const PENDING_HISTORY_CLOCK_SKEW_TOLERANCE_MS = 60_000;

type RepeatableSystemMessage = {

component: Container;

textNode: Text;

baseText: string;

count: number;

};

export class ChatLog extends Container {

private readonly maxComponents: number;

private toolById = new Map<string, ToolExecutionComponent>();

>();

private btwMessage: BtwInlineMessage | null = null;

private toolsExpanded = false;

private repeatableSystemMessage: RepeatableSystemMessage | null = null;

constructor(maxComponents = 180) {

super();

if (this.btwMessage === component) {

this.btwMessage = null;

}

if (this.repeatableSystemMessage?.component === component) {

this.repeatableSystemMessage = null;

}

}

private pruneOverflow() {

this.pruneOverflow();

}

private appendNonSystem(component: Component) {

this.repeatableSystemMessage = null;

this.append(component);

}

clearAll(opts?: { preservePendingUsers?: boolean }) {

this.clear();

this.toolById.clear();

this.streamingRuns.clear();

this.btwMessage = null;

this.repeatableSystemMessage = null;

if (!opts?.preservePendingUsers) {

this.pendingUsers.clear();

}

if (this.children.includes(entry.component)) {

continue;

}

this.append(entry.component);

this.appendNonSystem(entry.component);

}

}

this.pendingUsers.clear();

}

private createSystemMessage(text: string): Container {

private formatRepeatedSystemText(text: string, count: number) {

return count > 1 ? `${text} x${count}` : text;

}

private createSystemMessage(text: string): RepeatableSystemMessage {

const entry = new Container();

const textNode = new Text(theme.system(text), 1, 0);

entry.addChild(new Spacer(1));

entry.addChild(new Text(theme.system(text), 1, 0));

return entry;

entry.addChild(textNode);

return {

component: entry,

textNode,

baseText: text,

count: 1,

};

}

addSystem(text: string) {

this.append(this.createSystemMessage(text));

addSystem(text: string, opts?: { coalesceConsecutive?: boolean }) {

if (

opts?.coalesceConsecutive &&

this.repeatableSystemMessage?.baseText === text &&

this.children[this.children.length - 1] === this.repeatableSystemMessage.component

) {

this.repeatableSystemMessage.count += 1;

this.repeatableSystemMessage.textNode.setText(

theme.system(this.formatRepeatedSystemText(text, this.repeatableSystemMessage.count)),

);

return;

}

const message = this.createSystemMessage(text);

this.append(message.component);

this.repeatableSystemMessage = opts?.coalesceConsecutive ? message : null;

}

addUser(text: string) {

this.append(new UserMessageComponent(text));

this.appendNonSystem(new UserMessageComponent(text));

}

addPendingUser(runId: string, text: string, createdAt = Date.now()) {

}

const component = new UserMessageComponent(text);

this.pendingUsers.set(runId, { component, text, createdAt });

this.append(component);

this.appendNonSystem(component);

return component;

}

}

const component = new AssistantMessageComponent(text);

this.streamingRuns.set(effectiveRunId, component);

this.append(component);

this.appendNonSystem(component);

return component;

}

this.streamingRuns.delete(effectiveRunId);

return;

}

this.append(new AssistantMessageComponent(text));

this.appendNonSystem(new AssistantMessageComponent(text));

}

dropAssistant(runId?: string) {

this.btwMessage.setResult(params);

if (this.children[this.children.length - 1] !== this.btwMessage) {

this.removeChild(this.btwMessage);

this.append(this.btwMessage);

this.appendNonSystem(this.btwMessage);

}

return this.btwMessage;

}

const component = new BtwInlineMessage(params);

this.btwMessage = component;

this.append(component);

this.appendNonSystem(component);

return component;

}

const component = new ToolExecutionComponent(toolName, args);

component.setExpanded(this.toolsExpanded);

this.toolById.set(toolCallId, component);

this.append(component);

this.appendNonSystem(component);

return component;

}