cortena-ui 1.4.2 → 1.6.0

package/dist/agent-chat/bridge.js

@@ -0,0 +1,353 @@
+"use client";
+import { foldA2UIBlocks, readA2UIBlock } from "./a2ui-block.js";
+//#region src/agent-chat/bridge.ts
+/**
+* AG-UI events -> the three `AgentChatClient` sinks.
+*
+* Ported from `cortena-shared/src/agui/bridge.ts` (Cortena monorepo, DESIGN-37
+* step 1). `cortena-shared` is not published, so the translation lives here;
+* keep the two in step. It knows nothing about HTTP or `@ag-ui/client`, which
+* is why the tests can drive it with a literal array of events.
+*
+* One change against the original, and it is the reason this file is not a
+* copy: **TOOL_CALL_ARGS is handled.** cortenacore's mapper emits
+* `TOOL_CALL_START` -> `TOOL_CALL_ARGS { toolCallId, delta }` -> `TOOL_CALL_END`
+* at tool-start time, with the whole argument object stringified into one
+* `delta`. The original bridge had no case for it, so every tool card in the
+* AG-UI path showed a name and a spinner and never showed what the tool was
+* called with. The deltas are accumulated per call id and parsed when they
+* form valid JSON, which is also correct for a transport that streams the
+* arguments a fragment at a time.
+*/
+/** `CUSTOM` event names cortenacore emits that this bridge acts on. */
+const AGUI_CUSTOM_NAMES = {
+	CHAT_ABORTED: "cortena.chat.aborted",
+	TOOL_PROGRESS: "cortena.tool.progress",
+	APPROVAL_REQUEST: "cortena.approval.request",
+	APPROVAL_RESOLVED: "cortena.approval.resolved",
+	A2UI: "cortena.a2ui"
+};
+const DECISIONS = [
+	"allow-once",
+	"allow-always",
+	"deny"
+];
+var AgentChatBridge = class {
+	runId;
+	sessionKey;
+	chat;
+	tool;
+	approval;
+	now;
+	seq = 0;
+	/** Text of the assistant message currently streaming. */
+	text = "";
+	textMessageId = null;
+	reasoning = "";
+	/**
+	* The reasoning accumulated before each assistant message began, by message
+	* id, and the whole of the re-attach defence for the chain of thought.
+	*
+	* A re-attach re-streams the run from the top, so every REASONING delta
+	* arrives a second time. Restoring this snapshot when a message id starts
+	* again rewinds the buffer to exactly the point the first pass reached,
+	* whichever side of `TEXT_MESSAGE_START` the reasoning arrived on.
+	*/
+	reasoningAtStart = /* @__PURE__ */ new Map();
+	/**
+	* A2UI blocks seen this run. The chat treats the content array as a
+	* snapshot, so every emission carries all of them — the same rule the text
+	* follows, and what makes a re-attach land in the same place.
+	*/
+	a2ui = [];
+	/** Accumulated `TOOL_CALL_ARGS` deltas, per tool call id. */
+	args = /* @__PURE__ */ new Map();
+	/**
+	* A2UI messages already folded onto each surface, by their serialised form.
+	*
+	* A re-attach re-streams the run from the beginning, so every
+	* `CUSTOM cortena.a2ui` arrives again. Folding concatenates, so without this
+	* the surface's message list doubled on the first reconnection and trebled
+	* on the second — a table drawn once, then drawn again underneath itself.
+	*/
+	seenA2ui = /* @__PURE__ */ new Map();
+	terminal = false;
+	pendingInterrupts = [];
+	constructor(opts) {
+		this.runId = opts.runId;
+		this.sessionKey = opts.sessionKey;
+		this.chat = opts.chat;
+		this.tool = opts.tool;
+		this.approval = opts.approval;
+		this.now = opts.now ?? (() => Date.now());
+	}
+	/** True once RUN_FINISHED or RUN_ERROR has been seen; no retry after this. */
+	get finished() {
+		return this.terminal;
+	}
+	/** Interrupts carried by the terminal RUN_FINISHED, if any. */
+	get interrupts() {
+		return this.pendingInterrupts;
+	}
+	blocks() {
+		const content = [];
+		if (this.reasoning) content.push({
+			type: "thinking",
+			thinking: this.reasoning
+		});
+		if (this.text) content.push({
+			type: "text",
+			text: this.text
+		});
+		for (const block of this.a2ui) content.push({
+			type: "a2ui",
+			a2ui: block
+		});
+		return content;
+	}
+	emitDelta() {
+		const content = this.blocks();
+		if (content.length === 0) return;
+		this.chat({
+			runId: this.runId,
+			sessionKey: this.sessionKey,
+			seq: ++this.seq,
+			state: "delta",
+			message: {
+				role: "assistant",
+				content,
+				timestamp: this.now()
+			}
+		});
+	}
+	emitFinal(interrupted = false) {
+		const content = this.blocks();
+		this.chat({
+			runId: this.runId,
+			sessionKey: this.sessionKey,
+			seq: ++this.seq,
+			state: "final",
+			...interrupted ? { interrupted: true } : {},
+			...content.length > 0 ? { message: {
+				role: "assistant",
+				content,
+				timestamp: this.now()
+			} } : {}
+		});
+	}
+	/** Surface a transport failure the way a run error is surfaced. */
+	fail(message) {
+		if (this.terminal) return;
+		this.terminal = true;
+		this.chat({
+			runId: this.runId,
+			sessionKey: this.sessionKey,
+			seq: ++this.seq,
+			state: "error",
+			errorMessage: message
+		});
+	}
+	handleEvent(event) {
+		switch (event.type) {
+			case "RUN_STARTED":
+				this.textMessageId = null;
+				this.text = "";
+				this.reasoning = "";
+				break;
+			case "TEXT_MESSAGE_START": {
+				const id = event.messageId ?? null;
+				this.textMessageId = id;
+				this.text = "";
+				if (id !== null) {
+					const before = this.reasoningAtStart.get(id);
+					if (before === void 0) this.reasoningAtStart.set(id, this.reasoning);
+					else this.reasoning = before;
+				}
+				break;
+			}
+			case "TEXT_MESSAGE_CONTENT":
+				if (event.messageId && event.messageId !== this.textMessageId) {
+					this.textMessageId = event.messageId;
+					this.text = "";
+				}
+				this.text += event.delta ?? "";
+				this.emitDelta();
+				break;
+			case "REASONING_MESSAGE_CONTENT":
+				this.reasoning += event.delta ?? "";
+				this.emitDelta();
+				break;
+			case "TOOL_CALL_START":
+				this.tool?.({
+					event: "tool.start",
+					data: {
+						...event.toolCallId === void 0 ? {} : { id: event.toolCallId },
+						...event.toolCallName === void 0 ? {} : { name: event.toolCallName },
+						startedAt: this.now()
+					}
+				});
+				break;
+			case "TOOL_CALL_ARGS":
+				this.accumulateArgs(event);
+				break;
+			case "TOOL_CALL_END":
+				this.flushArgs(event.toolCallId);
+				break;
+			case "TOOL_CALL_RESULT":
+				this.tool?.({
+					event: event.metadata?.isError === true ? "tool.error" : "tool.complete",
+					data: {
+						...event.toolCallId === void 0 ? {} : { id: event.toolCallId },
+						output: event.content,
+						...event.metadata ? { metadata: event.metadata } : {},
+						completedAt: this.now()
+					}
+				});
+				break;
+			case "CUSTOM":
+				this.handleCustom(event);
+				break;
+			case "RUN_FINISHED": {
+				this.terminal = true;
+				const interrupted = event.outcome?.type === "interrupt";
+				if (interrupted) this.pendingInterrupts.push(...event.outcome?.interrupts ?? []);
+				this.emitFinal(interrupted);
+				break;
+			}
+			case "RUN_ERROR":
+				this.terminal = true;
+				this.chat({
+					runId: this.runId,
+					sessionKey: this.sessionKey,
+					seq: ++this.seq,
+					state: "error",
+					errorMessage: event.message ?? "An error occurred"
+				});
+		}
+	}
+	/**
+	* Accumulate one `TOOL_CALL_ARGS` delta and publish the best reading of it.
+	*
+	* Published on every delta rather than only at `TOOL_CALL_END`, because a
+	* run that is interrupted between the two — an approval, an abort, a dropped
+	* stream — would otherwise show a tool card with no input at all, which is
+	* the state the card exists to avoid.
+	*/
+	accumulateArgs(event) {
+		const id = event.toolCallId;
+		if (!id) return;
+		const next = (this.args.get(id) ?? "") + (event.delta ?? "");
+		this.args.set(id, next);
+		this.publishArgs(id, next);
+	}
+	flushArgs(id) {
+		if (!id) return;
+		const raw = this.args.get(id);
+		if (raw === void 0) return;
+		this.args.delete(id);
+		this.publishArgs(id, raw);
+	}
+	publishArgs(id, raw) {
+		if (!raw) return;
+		this.tool?.({
+			event: "tool.args",
+			data: {
+				id,
+				input: parseArgs(raw)
+			}
+		});
+	}
+	/**
+	* The block with any message this surface has already been sent removed;
+	* `null` when nothing in it is new.
+	*/
+	freshA2UI(block) {
+		if (!block) return null;
+		let seen = this.seenA2ui.get(block.surfaceId);
+		if (!seen) {
+			seen = /* @__PURE__ */ new Set();
+			this.seenA2ui.set(block.surfaceId, seen);
+		}
+		const messages = [];
+		for (const message of block.messages) {
+			const key = stableKey(message);
+			if (seen.has(key)) continue;
+			seen.add(key);
+			messages.push(message);
+		}
+		if (messages.length === 0 && !block.error) return null;
+		return {
+			...block,
+			messages
+		};
+	}
+	handleCustom(event) {
+		const value = event.value ?? {};
+		const id = typeof value.id === "string" ? value.id : "";
+		switch (event.name) {
+			case AGUI_CUSTOM_NAMES.TOOL_PROGRESS:
+				this.tool?.({
+					event: "tool.progress",
+					data: {
+						...typeof value.toolCallId === "string" ? { id: value.toolCallId } : {},
+						output: value.partialResult
+					}
+				});
+				break;
+			case AGUI_CUSTOM_NAMES.APPROVAL_REQUEST: {
+				const request = value.request ?? {};
+				this.approval?.({
+					type: "request",
+					request: {
+						id,
+						toolName: typeof request.command === "string" ? request.command : "exec",
+						args: request,
+						timestamp: typeof value.createdAtMs === "number" ? value.createdAtMs : this.now(),
+						runId: this.runId,
+						sessionKey: this.sessionKey
+					}
+				});
+				break;
+			}
+			case AGUI_CUSTOM_NAMES.A2UI: {
+				const block = this.freshA2UI(readA2UIBlock(value));
+				if (block) {
+					this.a2ui = foldA2UIBlocks([...this.a2ui, block]);
+					this.emitDelta();
+				}
+				break;
+			}
+			case AGUI_CUSTOM_NAMES.APPROVAL_RESOLVED: this.approval?.({
+				type: "resolved",
+				id,
+				decision: typeof value.decision === "string" && DECISIONS.includes(value.decision) ? value.decision : null
+			});
+		}
+	}
+};
+/**
+* A message's identity for de-duplication.
+*
+* `JSON.stringify` is enough: these are payloads the transport just parsed out
+* of JSON, so key order is the order the server wrote, and the same message
+* arriving twice on a re-attach serialises identically both times.
+*/
+function stableKey(message) {
+	try {
+		return JSON.stringify(message) ?? "undefined";
+	} catch {
+		return `${Math.random()}`;
+	}
+}
+/** Arguments as an object when the accumulation parses, as the raw text otherwise. */
+function parseArgs(raw) {
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return raw;
+	}
+}
+//#endregion
+export { AGUI_CUSTOM_NAMES, AgentChatBridge };
+
+//# sourceMappingURL=bridge.js.map

package/dist/agent-chat/bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.js","names":[],"sources":["../../src/agent-chat/bridge.ts"],"sourcesContent":["/**\n * AG-UI events -> the three `AgentChatClient` sinks.\n *\n * Ported from `cortena-shared/src/agui/bridge.ts` (Cortena monorepo, DESIGN-37\n * step 1). `cortena-shared` is not published, so the translation lives here;\n * keep the two in step. It knows nothing about HTTP or `@ag-ui/client`, which\n * is why the tests can drive it with a literal array of events.\n *\n * One change against the original, and it is the reason this file is not a\n * copy: **TOOL_CALL_ARGS is handled.** cortenacore's mapper emits\n * `TOOL_CALL_START` -> `TOOL_CALL_ARGS { toolCallId, delta }` -> `TOOL_CALL_END`\n * at tool-start time, with the whole argument object stringified into one\n * `delta`. The original bridge had no case for it, so every tool card in the\n * AG-UI path showed a name and a spinner and never showed what the tool was\n * called with. The deltas are accumulated per call id and parsed when they\n * form valid JSON, which is also correct for a transport that streams the\n * arguments a fragment at a time.\n */\n\nimport { type A2UIChatBlock, foldA2UIBlocks, readA2UIBlock } from \"./a2ui-block\";\nimport type {\n  AgentApprovalEvent,\n  AgentChatEvent,\n  AgentToolEvent,\n  AgentApprovalDecision,\n} from \"./types\";\n\n/** The subset of an AG-UI event this bridge reads. */\nexport interface AguiIncomingEvent {\n  type: string;\n  messageId?: string;\n  delta?: string;\n  toolCallId?: string;\n  toolCallName?: string;\n  content?: string;\n  message?: string;\n  name?: string;\n  value?: unknown;\n  metadata?: Record<string, unknown>;\n  snapshot?: unknown;\n  outcome?: { type?: string; interrupts?: Array<Record<string, unknown>> };\n}\n\n/** `CUSTOM` event names cortenacore emits that this bridge acts on. */\nexport const AGUI_CUSTOM_NAMES = {\n  CHAT_ABORTED: \"cortena.chat.aborted\",\n  TOOL_PROGRESS: \"cortena.tool.progress\",\n  APPROVAL_REQUEST: \"cortena.approval.request\",\n  APPROVAL_RESOLVED: \"cortena.approval.resolved\",\n  A2UI: \"cortena.a2ui\",\n} as const;\n\nexport interface AgentChatBridgeOptions {\n  runId: string;\n  sessionKey: string;\n  chat: (event: AgentChatEvent) => void;\n  tool?: (event: AgentToolEvent) => void;\n  approval?: (event: AgentApprovalEvent) => void;\n  now?: () => number;\n}\n\ntype ContentBlock = {\n  type: \"thinking\" | \"text\" | \"a2ui\";\n  thinking?: string;\n  text?: string;\n  a2ui?: A2UIChatBlock;\n};\n\nconst DECISIONS: readonly string[] = [\"allow-once\", \"allow-always\", \"deny\"];\n\nexport class AgentChatBridge {\n  readonly runId: string;\n  readonly sessionKey: string;\n\n  private readonly chat: (event: AgentChatEvent) => void;\n  private readonly tool: ((event: AgentToolEvent) => void) | undefined;\n  private readonly approval: ((event: AgentApprovalEvent) => void) | undefined;\n  private readonly now: () => number;\n\n  private seq = 0;\n  /** Text of the assistant message currently streaming. */\n  private text = \"\";\n  private textMessageId: string | null = null;\n  private reasoning = \"\";\n  /**\n   * The reasoning accumulated before each assistant message began, by message\n   * id, and the whole of the re-attach defence for the chain of thought.\n   *\n   * A re-attach re-streams the run from the top, so every REASONING delta\n   * arrives a second time. Restoring this snapshot when a message id starts\n   * again rewinds the buffer to exactly the point the first pass reached,\n   * whichever side of `TEXT_MESSAGE_START` the reasoning arrived on.\n   */\n  private readonly reasoningAtStart = new Map<string, string>();\n  /**\n   * A2UI blocks seen this run. The chat treats the content array as a\n   * snapshot, so every emission carries all of them — the same rule the text\n   * follows, and what makes a re-attach land in the same place.\n   */\n  private a2ui: A2UIChatBlock[] = [];\n  /** Accumulated `TOOL_CALL_ARGS` deltas, per tool call id. */\n  private readonly args = new Map<string, string>();\n  /**\n   * A2UI messages already folded onto each surface, by their serialised form.\n   *\n   * A re-attach re-streams the run from the beginning, so every\n   * `CUSTOM cortena.a2ui` arrives again. Folding concatenates, so without this\n   * the surface's message list doubled on the first reconnection and trebled\n   * on the second — a table drawn once, then drawn again underneath itself.\n   */\n  private readonly seenA2ui = new Map<string, Set<string>>();\n  private terminal = false;\n  private readonly pendingInterrupts: Array<Record<string, unknown>> = [];\n\n  constructor(opts: AgentChatBridgeOptions) {\n    this.runId = opts.runId;\n    this.sessionKey = opts.sessionKey;\n    this.chat = opts.chat;\n    this.tool = opts.tool;\n    this.approval = opts.approval;\n    this.now = opts.now ?? (() => Date.now());\n  }\n\n  /** True once RUN_FINISHED or RUN_ERROR has been seen; no retry after this. */\n  get finished(): boolean {\n    return this.terminal;\n  }\n\n  /** Interrupts carried by the terminal RUN_FINISHED, if any. */\n  get interrupts(): ReadonlyArray<Record<string, unknown>> {\n    return this.pendingInterrupts;\n  }\n\n  private blocks(): ContentBlock[] {\n    const content: ContentBlock[] = [];\n    if (this.reasoning) {\n      content.push({ type: \"thinking\", thinking: this.reasoning });\n    }\n    if (this.text) {\n      content.push({ type: \"text\", text: this.text });\n    }\n    for (const block of this.a2ui) {\n      content.push({ type: \"a2ui\", a2ui: block });\n    }\n    return content;\n  }\n\n  private emitDelta(): void {\n    const content = this.blocks();\n    if (content.length === 0) {\n      return;\n    }\n    this.chat({\n      runId: this.runId,\n      sessionKey: this.sessionKey,\n      seq: ++this.seq,\n      state: \"delta\",\n      message: { role: \"assistant\", content, timestamp: this.now() },\n    });\n  }\n\n  private emitFinal(interrupted = false): void {\n    const content = this.blocks();\n    this.chat({\n      runId: this.runId,\n      sessionKey: this.sessionKey,\n      seq: ++this.seq,\n      state: \"final\",\n      // Carried through so the store can tell \"the run succeeded\" from \"the\n      // run is waiting for you\". Both arrive as RUN_FINISHED.\n      ...(interrupted ? { interrupted: true } : {}),\n      ...(content.length > 0\n        ? { message: { role: \"assistant\", content, timestamp: this.now() } }\n        : {}),\n    });\n  }\n\n  /** Surface a transport failure the way a run error is surfaced. */\n  fail(message: string): void {\n    if (this.terminal) {\n      return;\n    }\n    this.terminal = true;\n    this.chat({\n      runId: this.runId,\n      sessionKey: this.sessionKey,\n      seq: ++this.seq,\n      state: \"error\",\n      errorMessage: message,\n    });\n  }\n\n  handleEvent(event: AguiIncomingEvent): void {\n    switch (event.type) {\n      case \"RUN_STARTED\":\n        // The run begins here, so the streaming buffers do too. This is the\n        // only place the chain of thought is cleared outright.\n        this.textMessageId = null;\n        this.text = \"\";\n        this.reasoning = \"\";\n        break;\n      case \"TEXT_MESSAGE_START\": {\n        // A new assistant message replaces the text buffer, and *only* the\n        // text buffer. cortenacore emits the REASONING deltas before the\n        // message they explain, so clearing the reasoning here threw away the\n        // chain of thought a moment after it arrived — the thinking block\n        // never rendered at all. Re-attach doubling is handled instead by\n        // rewinding to the snapshot taken when this message id first started.\n        const id = event.messageId ?? null;\n        this.textMessageId = id;\n        this.text = \"\";\n        if (id !== null) {\n          const before = this.reasoningAtStart.get(id);\n          if (before === undefined) {\n            this.reasoningAtStart.set(id, this.reasoning);\n          } else {\n            this.reasoning = before;\n          }\n        }\n        break;\n      }\n      case \"TEXT_MESSAGE_CONTENT\":\n        if (event.messageId && event.messageId !== this.textMessageId) {\n          this.textMessageId = event.messageId;\n          this.text = \"\";\n        }\n        this.text += event.delta ?? \"\";\n        this.emitDelta();\n        break;\n      case \"REASONING_MESSAGE_CONTENT\":\n        this.reasoning += event.delta ?? \"\";\n        this.emitDelta();\n        break;\n      case \"TOOL_CALL_START\":\n        this.tool?.({\n          event: \"tool.start\",\n          data: {\n            ...(event.toolCallId === undefined ? {} : { id: event.toolCallId }),\n            ...(event.toolCallName === undefined ? {} : { name: event.toolCallName }),\n            startedAt: this.now(),\n          },\n        });\n        break;\n      case \"TOOL_CALL_ARGS\":\n        this.accumulateArgs(event);\n        break;\n      case \"TOOL_CALL_END\":\n        // Nothing more will arrive for this call's arguments; emit whatever\n        // accumulated, even when it never parsed, so the card shows something.\n        this.flushArgs(event.toolCallId);\n        break;\n      case \"TOOL_CALL_RESULT\":\n        // The metadata travels WITH the event. It carries `isError`, and the\n        // `meta` a Cortena tool attaches to a failure — the status, the code\n        // and the message — and it is the only trustworthy account of how the\n        // call went. Dropping it here is what forced the store to guess at an\n        // envelope inside `content`, and the guess was wrong for every real\n        // result cortenacore emits.\n        this.tool?.({\n          event: event.metadata?.isError === true ? \"tool.error\" : \"tool.complete\",\n          data: {\n            ...(event.toolCallId === undefined ? {} : { id: event.toolCallId }),\n            output: event.content,\n            ...(event.metadata ? { metadata: event.metadata } : {}),\n            completedAt: this.now(),\n          },\n        });\n        break;\n      case \"CUSTOM\":\n        this.handleCustom(event);\n        break;\n      case \"RUN_FINISHED\": {\n        this.terminal = true;\n        const interrupted = event.outcome?.type === \"interrupt\";\n        if (interrupted) {\n          this.pendingInterrupts.push(...(event.outcome?.interrupts ?? []));\n        }\n        this.emitFinal(interrupted);\n        break;\n      }\n      case \"RUN_ERROR\":\n        this.terminal = true;\n        this.chat({\n          runId: this.runId,\n          sessionKey: this.sessionKey,\n          seq: ++this.seq,\n          state: \"error\",\n          errorMessage: event.message ?? \"An error occurred\",\n        });\n        break;\n      default:\n        break;\n    }\n  }\n\n  /**\n   * Accumulate one `TOOL_CALL_ARGS` delta and publish the best reading of it.\n   *\n   * Published on every delta rather than only at `TOOL_CALL_END`, because a\n   * run that is interrupted between the two — an approval, an abort, a dropped\n   * stream — would otherwise show a tool card with no input at all, which is\n   * the state the card exists to avoid.\n   */\n  private accumulateArgs(event: AguiIncomingEvent): void {\n    const id = event.toolCallId;\n    if (!id) {\n      return;\n    }\n    const next = (this.args.get(id) ?? \"\") + (event.delta ?? \"\");\n    this.args.set(id, next);\n    this.publishArgs(id, next);\n  }\n\n  private flushArgs(id?: string): void {\n    if (!id) {\n      return;\n    }\n    const raw = this.args.get(id);\n    if (raw === undefined) {\n      return;\n    }\n    this.args.delete(id);\n    this.publishArgs(id, raw);\n  }\n\n  private publishArgs(id: string, raw: string): void {\n    if (!raw) {\n      return;\n    }\n    this.tool?.({ event: \"tool.args\", data: { id, input: parseArgs(raw) } });\n  }\n\n  /**\n   * The block with any message this surface has already been sent removed;\n   * `null` when nothing in it is new.\n   */\n  private freshA2UI(block: A2UIChatBlock | null): A2UIChatBlock | null {\n    if (!block) {\n      return null;\n    }\n    let seen = this.seenA2ui.get(block.surfaceId);\n    if (!seen) {\n      seen = new Set();\n      this.seenA2ui.set(block.surfaceId, seen);\n    }\n    const messages: unknown[] = [];\n    for (const message of block.messages) {\n      const key = stableKey(message);\n      if (seen.has(key)) {\n        continue;\n      }\n      seen.add(key);\n      messages.push(message);\n    }\n    // An error still deserves a card even when its messages are all repeats.\n    if (messages.length === 0 && !block.error) {\n      return null;\n    }\n    return { ...block, messages };\n  }\n\n  private handleCustom(event: AguiIncomingEvent): void {\n    const value = (event.value ?? {}) as Record<string, unknown>;\n    const id = typeof value.id === \"string\" ? value.id : \"\";\n    switch (event.name) {\n      case AGUI_CUSTOM_NAMES.TOOL_PROGRESS:\n        this.tool?.({\n          event: \"tool.progress\",\n          data: {\n            ...(typeof value.toolCallId === \"string\" ? { id: value.toolCallId } : {}),\n            output: value.partialResult,\n          },\n        });\n        break;\n      case AGUI_CUSTOM_NAMES.APPROVAL_REQUEST: {\n        const request = (value.request ?? {}) as Record<string, unknown>;\n        this.approval?.({\n          type: \"request\",\n          request: {\n            id,\n            toolName: typeof request.command === \"string\" ? request.command : \"exec\",\n            args: request,\n            timestamp: typeof value.createdAtMs === \"number\" ? value.createdAtMs : this.now(),\n            // Captured here, where the run and the session are facts about the\n            // event rather than about whatever is in flight when the user\n            // eventually presses a button.\n            runId: this.runId,\n            sessionKey: this.sessionKey,\n          },\n        });\n        break;\n      }\n      case AGUI_CUSTOM_NAMES.A2UI: {\n        // One event per block; folding here means two pushes to one surface\n        // reach the renderer as a single message list, which is how a surface\n        // the agent streams in pieces ends up drawn once.\n        const block = this.freshA2UI(readA2UIBlock(value));\n        if (block) {\n          this.a2ui = foldA2UIBlocks([...this.a2ui, block]);\n          this.emitDelta();\n        }\n        break;\n      }\n      case AGUI_CUSTOM_NAMES.APPROVAL_RESOLVED:\n        this.approval?.({\n          type: \"resolved\",\n          id,\n          decision:\n            typeof value.decision === \"string\" && DECISIONS.includes(value.decision)\n              ? (value.decision as AgentApprovalDecision)\n              : null,\n        });\n        break;\n      default:\n        // cortena.chat.aborted needs no change here: abort() has already reset\n        // the local streaming state before the request went out.\n        break;\n    }\n  }\n}\n\n/**\n * A message's identity for de-duplication.\n *\n * `JSON.stringify` is enough: these are payloads the transport just parsed out\n * of JSON, so key order is the order the server wrote, and the same message\n * arriving twice on a re-attach serialises identically both times.\n */\nfunction stableKey(message: unknown): string {\n  try {\n    return JSON.stringify(message) ?? \"undefined\";\n  } catch {\n    // Circular, which a JSON transport cannot produce. Never equal to anything.\n    return `${Math.random()}`;\n  }\n}\n\n/** Arguments as an object when the accumulation parses, as the raw text otherwise. */\nfunction parseArgs(raw: string): unknown {\n  try {\n    return JSON.parse(raw);\n  } catch {\n    return raw;\n  }\n}\n"],"mappings":"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"}

package/dist/agent-chat/session.d.ts

@@ -0,0 +1,79 @@
+"use client";
+import { AgentChatMessage, AgentChatStep } from "./types.js";
+//#region src/agent-chat/session.d.ts
+/**
+ * A new session key, minted client-side.
+ *
+ * `agent:<agentId>:new-<Date.now()>-<random36>`. cortenacore reads the
+ * `agent:<id>:` prefix to bind the session to that agent's template, and the
+ * key is the AG-UI `threadId` verbatim, prefix included. Minting it rather than
+ * asking for one is what lets the first message go out immediately.
+ */
+export declare function mintSessionKey(agentId: string): string;
+/** Was this key minted locally for a chat that had no session yet? */
+export declare function isProvisionalSessionKey(key: string): boolean;
+/** Does this session belong to this agent? `sessions.list` is filtered by it. */
+export declare function isSessionOfAgent(key: string, agentId: string): boolean;
+/** The `sessionStorage` name the current key is kept under, per extension. */
+export declare function sessionStorageKey(scope: string): string;
+/** The `sessionStorage` name the open/collapsed state is kept under. */
+export declare function viewStorageKey(scope: string): string;
+/** The `sessionStorage` name this window's progress steps are kept under. */
+export declare function stepsStorageKey(scope: string): string;
+export declare function readStoredSessionKey(scope: string): string | null;
+export declare function writeStoredSessionKey(scope: string, key: string | null): void;
+/** Most steps kept, in memory and in `sessionStorage`. A turn that long is a runaway loop. */
+export declare const STEP_LIMIT = 50;
+/**
+ * The steps of the current turn, and the session they belong to.
+ *
+ * They go in the per-window store beside the session key, for the same reason
+ * the key does: a tab is reloaded mid-run, or a host remounts the surface on a
+ * route change, and both threw the whole strip away. (Collapsing the pop-up is
+ * NOT one of them — the panel is `hidden`, not unmounted, and the run streams
+ * into it either way.) Messages come back from `chat.history`; steps do not
+ * exist on the server, so this is the only place they can come back from.
+ *
+ * Scoped to a session key, and checked on read: resuming a different session
+ * must not inherit the last one's steps.
+ */
+export declare function readStoredSteps(scope: string, sessionKey: string): AgentChatStep[];
+/** The slot's contents, projected and trimmed to fit the byte cap. */
+export declare function serialiseSteps(sessionKey: string, steps: readonly AgentChatStep[]): string;
+export declare function writeStoredSteps(scope: string, sessionKey: string | null, steps: readonly AgentChatStep[]): void;
+/** Raw transcript records to the messages the list renders. */
+export declare function parseHistoryMessages(raw: readonly unknown[]): AgentChatMessage[];
+/**
+ * The history shrink guard.
+ *
+ * A history load must not shrink the session already on screen. The first
+ * message of a new chat loads history while the turn is still in flight and the
+ * user's message has not been persisted yet; replacing wholesale threw that
+ * message away, and the reply survived, so the symptom was a conversation with
+ * the answer but not the question.
+ *
+ * Only the same session, and only against losing messages: a longer or equal
+ * history still replaces, so an edit, a deletion made elsewhere and a compaction
+ * all land normally.
+ */
+export declare function wouldShrinkHistory(params: {
+  currentSessionKey: string | null;
+  loadedSessionKey: string;
+  currentCount: number;
+  loadedCount: number;
+}): boolean;
+/**
+ * Should this message be hidden?
+ *
+ * The same chain cortenaweb's bubble applies, in the same order. It exists
+ * because tool plumbing leaks into a transcript in several recognisable shapes,
+ * and a chat that renders them reads as broken. Tool detail is not lost: it is
+ * in the tool strip and in the chain of thought.
+ *
+ * A reply that is only UI the agent drew has no text at all, so an A2UI block
+ * counts as content — without that, the surface the user asked for is filtered
+ * away and nothing appears.
+ */
+export declare function isHiddenMessage(message: AgentChatMessage): boolean;
+//#endregion
+//# sourceMappingURL=session.d.ts.map