cortena-ui 1.4.2 → 1.5.0

package/dist/agent-chat/agui-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agui-client.js","names":[],"sources":["../../src/agent-chat/agui-client.ts"],"sourcesContent":["/**\n * `AgentChatClient` over AG-UI.\n *\n * Ported from `cortena-shared/src/agui/client.ts` (Cortena monorepo,\n * DESIGN-37). `cortena-shared` is not published, so what this package needs is\n * copied rather than imported; keep the two in step.\n *\n * **This is the only module in cortena-ui that imports `@ag-ui/client`**, and\n * `cortena-ui/agent-chat` is the only entry that reaches it. `@ag-ui/client`\n * brings rxjs, zod 3, uuid and protobuf; `test/bundle-probe.test.mjs` asserts\n * none of it is reachable from `cortena-ui` or `cortena-ui/core`.\n *\n * It is an OPTIONAL peer, and the import is therefore **lazy**: a static\n * `import { HttpAgent }` made the whole `cortena-ui/agent-chat` entry fail to\n * load for a consumer that had not installed it, so an extension on another\n * transport could not draw `AgentChatPopup` at all — a package it never asked\n * for decided whether its chat rendered. Loading it inside the factory keeps\n * the entry resolvable, and moves the failure to the one operation that\n * genuinely needs the peer, with a message that says what to install.\n *\n * What an extension must expose for this to work is in README.md, \"The agent\n * pop-up\": `POST /agui/run`, `/agui/abort`, `/agui/approval` and the two\n * control-plane reads, all proxied through the extension's own gateway with the\n * signed-in user's JWT — never a service token.\n *\n * Two things about the wire that are easy to get wrong:\n *\n * - The stream ends by **closing the connection** after `RUN_FINISHED` or\n *   `RUN_ERROR`. There is no `data: [DONE]` sentinel; emitting one makes the\n *   AG-UI client error the subject, because it `JSON.parse`s every `data:` line.\n * - Approvals go to their own endpoint. Sending a decision as `state` on a\n *   second `/agui/run` opens a second concurrent stream, and two mappers then\n *   write two sets of message ids into one bridge, which resets its text buffer\n *   whenever the message id changes.\n */\n\nimport type { HttpAgent } from \"@ag-ui/client\";\nimport { AgentChatBridge } from \"./bridge\";\nimport type {\n  AgentApprovalContext,\n  AgentApprovalDecision,\n  AgentApprovalEvent,\n  AgentChatClient,\n  AgentChatEvent,\n  AgentChatSendInput,\n  AgentToolEvent,\n} from \"./types\";\n\nexport interface CreateAguiAgentChatClientOptions {\n  /**\n   * Origin the AG-UI and control-plane paths hang off, no trailing slash.\n   * For an extension this is its own gateway, which proxies to cortenacore.\n   */\n  baseUrl: string;\n  /** The signed-in USER's JWT. Read on every request, never captured once. */\n  getToken: () => string;\n  /** The agent template slug — the extension id. Sessions are `agent:<id>:…`. */\n  agentId: string;\n  fetchImpl?: typeof fetch;\n  /** Frontend tools advertised on every run; AG-UI requires a description. */\n  tools?: Array<{ name: string; description: string; parameters?: unknown }>;\n  /** Backoff before re-attaching a dropped stream. */\n  reconnectDelays?: readonly number[];\n  maxReconnectAttempts?: number;\n  sleep?: (ms: number) => Promise<void>;\n  now?: () => number;\n}\n\nconst DEFAULT_RECONNECT_DELAYS: readonly number[] = [500, 1_000, 2_000, 5_000, 10_000];\nconst DEFAULT_MAX_RECONNECT_ATTEMPTS = 5;\n\nconst defaultSleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));\n\n/**\n * What a relative `baseUrl` resolves against.\n *\n * The browser's own origin, and a placeholder under Node — where this module\n * is exercised by tests with a `fetchImpl` stub and there is no origin to\n * speak of. The placeholder never reaches the network: the stub sees the\n * resolved string, and `/api/core/...` is what it asserts on.\n */\nfunction requestBase(): string {\n  return typeof location === \"undefined\" ? \"http://cortena.invalid\" : location.origin;\n}\n\n/** What `@ag-ui/client` exports and this module constructs. */\ntype HttpAgentConstructor = typeof import(\"@ag-ui/client\").HttpAgent;\n\nexport const MISSING_AGUI_PEER =\n  'cortena-ui/agent-chat: the AG-UI transport needs the optional peer \"@ag-ui/client\". ' +\n  \"Install it (pnpm add @ag-ui/client), or pass your own AgentChatClient to AgentChat.\";\n\n/**\n * `@ag-ui/client`, on demand.\n *\n * The specifier is a literal so a bundler still sees the dependency and puts\n * it in a chunk of its own — `test/bundle-probe.test.mjs` measures that the\n * agent-chat entry carries it. What changes is *when* it is evaluated, and\n * what happens when it is not there at all.\n */\nasync function loadHttpAgent(): Promise<HttpAgentConstructor> {\n  try {\n    return (await import(\"@ag-ui/client\")).HttpAgent;\n  } catch (cause) {\n    throw new Error(MISSING_AGUI_PEER, { cause });\n  }\n}\n\ntype Sink<T> = (event: T) => void;\n\ninterface ActiveRun {\n  runId: string;\n  sessionKey: string;\n  bridge: AgentChatBridge;\n  agent: HttpAgent;\n  aborted: boolean;\n}\n\nclass AguiAgentChatClient implements AgentChatClient {\n  readonly agentId: string;\n\n  private readonly opts: CreateAguiAgentChatClientOptions;\n  private readonly delays: readonly number[];\n  private readonly maxAttempts: number;\n  private readonly sleep: (ms: number) => Promise<void>;\n  private readonly chatSinks = new Set<Sink<AgentChatEvent>>();\n  private readonly toolSinks = new Set<Sink<AgentToolEvent>>();\n  private readonly approvalSinks = new Set<Sink<AgentApprovalEvent>>();\n  private active: ActiveRun | null = null;\n  /** The optional peer, requested when the client is created and awaited per run. */\n  private readonly httpAgent: Promise<HttpAgentConstructor>;\n\n  constructor(opts: CreateAguiAgentChatClientOptions) {\n    this.opts = opts;\n    this.agentId = opts.agentId;\n    this.delays = opts.reconnectDelays ?? DEFAULT_RECONNECT_DELAYS;\n    this.maxAttempts = opts.maxReconnectAttempts ?? DEFAULT_MAX_RECONNECT_ATTEMPTS;\n    this.sleep = opts.sleep ?? defaultSleep;\n    // Started here so a missing peer is discovered when the client is made\n    // rather than mid-stream. The rejection is answered immediately: a client\n    // created and never sent to must not raise an unhandled rejection, and\n    // `startRun` awaits the same promise where the user can be told.\n    this.httpAgent = loadHttpAgent();\n    this.httpAgent.catch(() => {});\n  }\n\n  onChat(sink: Sink<AgentChatEvent>): () => void {\n    this.chatSinks.add(sink);\n    return () => this.chatSinks.delete(sink);\n  }\n\n  onTool(sink: Sink<AgentToolEvent>): () => void {\n    this.toolSinks.add(sink);\n    return () => this.toolSinks.delete(sink);\n  }\n\n  onApproval(sink: Sink<AgentApprovalEvent>): () => void {\n    this.approvalSinks.add(sink);\n    return () => this.approvalSinks.delete(sink);\n  }\n\n  get runUrl(): string {\n    return `${this.opts.baseUrl}/agui/run`;\n  }\n\n  get abortUrl(): string {\n    return `${this.opts.baseUrl}/agui/abort`;\n  }\n\n  get approvalUrl(): string {\n    return `${this.opts.baseUrl}/agui/approval`;\n  }\n\n  private headers(): Record<string, string> {\n    return {\n      authorization: `Bearer ${this.opts.getToken()}`,\n      \"content-type\": \"application/json\",\n    };\n  }\n\n  private get fetch(): typeof fetch {\n    return this.opts.fetchImpl ?? globalThis.fetch;\n  }\n\n  /** `sessions.list` and `chat.history` over the REST control plane. */\n  async request<T = unknown>(method: string, params: Record<string, unknown>): Promise<T> {\n    const path = `${this.opts.baseUrl}/api/core/${method.split(\".\").join(\"/\")}`;\n    const readOnly = method === \"sessions.list\" || method === \"chat.history\";\n    // `new URL(path)` with no base throws on a relative `baseUrl`, and the one\n    // in this module's own example is `\"/api/agent\"` — the shape every\n    // extension uses, since the gateway that proxies these calls is the app's\n    // own origin. `sessions.list` therefore threw before it was ever sent, and\n    // the chat opened on \"The agent could not be reached\".\n    const url = new URL(path, requestBase());\n    if (readOnly) {\n      for (const [key, value] of Object.entries(params)) {\n        if (value !== undefined && value !== null) {\n          url.searchParams.set(key, String(value));\n        }\n      }\n    }\n    const response = await this.fetch(url.toString(), {\n      method: readOnly ? \"GET\" : \"POST\",\n      headers: this.headers(),\n      ...(readOnly ? {} : { body: JSON.stringify(params) }),\n    });\n    if (!response.ok) {\n      throw new Error(await readError(response, method));\n    }\n    return (await response.json()) as T;\n  }\n\n  async send(input: AgentChatSendInput): Promise<void> {\n    // Fire and forget: the caller only awaits the acceptance. Events follow on\n    // the stream, exactly as they do when the server acknowledges a send.\n    void this.startRun(input);\n  }\n\n  private async startRun(input: AgentChatSendInput): Promise<void> {\n    const bridge = new AgentChatBridge({\n      runId: input.runId,\n      sessionKey: input.sessionKey,\n      chat: (event) => this.emit(this.chatSinks, event),\n      tool: (event) => this.emit(this.toolSinks, event),\n      approval: (event) => this.emit(this.approvalSinks, event),\n      ...(this.opts.now ? { now: this.opts.now } : {}),\n    });\n\n    const forwarded: Record<string, unknown> = {\n      ...(input.thinking ? { thinking: input.thinking } : {}),\n      ...(input.attachments?.length ? { attachments: input.attachments } : {}),\n      ...(input.model ? { model: input.model } : {}),\n      // A click inside a rendered A2UI surface or MCP App. Structured rather\n      // than typed prose: cortenacore turns it into the documented envelope.\n      ...(input.a2uiAction ? { a2uiAction: input.a2uiAction } : {}),\n      ...(input.mcpAppAction ? { mcpAppAction: input.mcpAppAction } : {}),\n    };\n\n    let Agent: HttpAgentConstructor;\n    try {\n      Agent = await this.httpAgent;\n    } catch (err) {\n      // The one operation that needs the peer, and the only place it can be\n      // reported: in the chat, as a failed run, rather than as a rejected\n      // promise nobody is holding.\n      bridge.fail(err instanceof Error ? err.message : MISSING_AGUI_PEER);\n      return;\n    }\n\n    let attempt = 0;\n    let resume = false;\n    for (;;) {\n      const runId = resume ? `${input.runId}:resume-${attempt}` : input.runId;\n      const agent = new Agent({\n        url: this.runUrl,\n        headers: this.headers(),\n        threadId: input.sessionKey,\n        // A re-attach carries no new user message; the server re-streams the\n        // run named by forwardedProps.resumeRunId instead of starting one.\n        initialMessages: resume\n          ? []\n          : [{ id: input.runId, role: \"user\", content: input.message }],\n        ...(this.opts.fetchImpl ? { fetch: this.opts.fetchImpl } : {}),\n      });\n      this.active = {\n        runId: input.runId,\n        sessionKey: input.sessionKey,\n        bridge,\n        agent,\n        aborted: this.active?.aborted === true && this.active.runId === input.runId,\n      };\n      try {\n        await agent.runAgent(\n          {\n            runId,\n            ...(this.opts.tools?.length ? { tools: this.opts.tools } : {}),\n            forwardedProps: {\n              ...forwarded,\n              ...(resume ? { resumeRunId: input.runId } : {}),\n            },\n          },\n          { onEvent: ({ event }) => bridge.handleEvent(event as never) },\n        );\n        return;\n      } catch (err) {\n        if (bridge.finished || this.active?.aborted) {\n          return;\n        }\n        attempt += 1;\n        if (attempt > this.maxAttempts) {\n          bridge.fail(err instanceof Error ? err.message : \"The agent stream failed\");\n          return;\n        }\n        await this.sleep(this.delays[Math.min(attempt - 1, this.delays.length - 1)] ?? 1_000);\n        // The backoff is up to ten seconds long, and everything can change in\n        // it: the user presses Stop, or a late RUN_FINISHED lands on the\n        // bridge. Checking only before the sleep re-attached to a run that had\n        // already ended — a second stream, a second set of message ids into\n        // one bridge, and an abort the user watched do nothing.\n        if (bridge.finished || this.active?.aborted) {\n          return;\n        }\n        resume = true;\n      }\n    }\n  }\n\n  async abort(params?: { runId?: string; sessionKey?: string }): Promise<void> {\n    const active = this.active;\n    if (active) {\n      active.aborted = true;\n      try {\n        active.agent.abortRun();\n      } catch {\n        // Already finished; the POST below is still worth making.\n      }\n    }\n    const runId = params?.runId ?? active?.runId;\n    const threadId = params?.sessionKey ?? active?.sessionKey;\n    if (!runId || !threadId) {\n      return;\n    }\n    try {\n      await this.fetch(this.abortUrl, {\n        method: \"POST\",\n        headers: this.headers(),\n        body: JSON.stringify({ runId, threadId }),\n      });\n    } catch {\n      // Best-effort: dropping the stream aborts the run server-side anyway.\n    }\n  }\n\n  /**\n   * Answer one approval, on the thread and run it arrived on.\n   *\n   * `this.active` is deliberately not consulted. An approval pauses a run, and\n   * a user is free to open another session from the drawer or start another\n   * turn while it waits — at which point `active.sessionKey` is a different\n   * conversation and \"allow\" would be sent against it. The request carried its\n   * own `{ runId, sessionKey }`; those are what go on the wire.\n   */\n  async resolveApproval(\n    id: string,\n    decision: AgentApprovalDecision,\n    context: AgentApprovalContext,\n  ): Promise<void> {\n    const response = await this.fetch(this.approvalUrl, {\n      method: \"POST\",\n      headers: this.headers(),\n      body: JSON.stringify({\n        id,\n        decision,\n        threadId: context.sessionKey,\n        runId: context.runId,\n      }),\n    });\n    // A rejected decision has to reach the user. Swallowing it left the card\n    // gone, the run paused server-side and nothing on screen saying so — the\n    // user believes they answered and the agent believes nobody did.\n    if (!response.ok) {\n      throw new Error(await readError(response, \"approval\"));\n    }\n  }\n\n  private emit<T>(sinks: Set<Sink<T>>, event: T): void {\n    for (const sink of [...sinks]) {\n      sink(event);\n    }\n  }\n}\n\n/**\n * An `AgentChatClient` that streams over AG-UI and reads sessions and history\n * over the REST control plane.\n *\n * ```tsx\n * const client = React.useMemo(\n *   () => createAguiAgentChatClient({ baseUrl: \"/api/agent\", getToken: () => jwt, agentId: \"tasks\" }),\n *   [jwt],\n * );\n * ```\n */\nexport function createAguiAgentChatClient(\n  options: CreateAguiAgentChatClientOptions,\n): AgentChatClient {\n  return new AguiAgentChatClient(options);\n}\n\nasync function readError(response: Response, method: string): Promise<string> {\n  try {\n    const body = (await response.json()) as { error?: { message?: string } };\n    if (body?.error?.message) {\n      return body.error.message;\n    }\n  } catch {\n    // Not JSON. The status is all there is.\n  }\n  if (response.status === 404) {\n    // The single most common misconfiguration: the control-plane endpoints are\n    // off, so every path under /api/core answers 404 before authentication.\n    return `${method} is unavailable (404). Check that the AG-UI and control-plane endpoints are enabled.`;\n  }\n  return `${method} failed (${response.status})`;\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,109 @@
+"use client";
+import { AgentApprovalEvent, AgentChatEvent, AgentToolEvent } from "./types.js";
+//#region src/agent-chat/bridge.d.ts
+/** The subset of an AG-UI event this bridge reads. */
+export interface AguiIncomingEvent {
+  type: string;
+  messageId?: string;
+  delta?: string;
+  toolCallId?: string;
+  toolCallName?: string;
+  content?: string;
+  message?: string;
+  name?: string;
+  value?: unknown;
+  metadata?: Record<string, unknown>;
+  snapshot?: unknown;
+  outcome?: {
+    type?: string;
+    interrupts?: Array<Record<string, unknown>>;
+  };
+}
+/** `CUSTOM` event names cortenacore emits that this bridge acts on. */
+export declare const AGUI_CUSTOM_NAMES: {
+  readonly CHAT_ABORTED: "cortena.chat.aborted";
+  readonly TOOL_PROGRESS: "cortena.tool.progress";
+  readonly APPROVAL_REQUEST: "cortena.approval.request";
+  readonly APPROVAL_RESOLVED: "cortena.approval.resolved";
+  readonly A2UI: "cortena.a2ui";
+};
+export interface AgentChatBridgeOptions {
+  runId: string;
+  sessionKey: string;
+  chat: (event: AgentChatEvent) => void;
+  tool?: (event: AgentToolEvent) => void;
+  approval?: (event: AgentApprovalEvent) => void;
+  now?: () => number;
+}
+export declare class AgentChatBridge {
+  readonly runId: string;
+  readonly sessionKey: string;
+  private readonly chat;
+  private readonly tool;
+  private readonly approval;
+  private readonly now;
+  private seq;
+  /** Text of the assistant message currently streaming. */
+  private text;
+  private textMessageId;
+  private 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.
+   */
+  private readonly reasoningAtStart;
+  /**
+   * 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.
+   */
+  private a2ui;
+  /** Accumulated `TOOL_CALL_ARGS` deltas, per tool call id. */
+  private readonly args;
+  /**
+   * 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.
+   */
+  private readonly seenA2ui;
+  private terminal;
+  private readonly pendingInterrupts;
+  constructor(opts: AgentChatBridgeOptions);
+  /** True once RUN_FINISHED or RUN_ERROR has been seen; no retry after this. */
+  get finished(): boolean;
+  /** Interrupts carried by the terminal RUN_FINISHED, if any. */
+  get interrupts(): ReadonlyArray<Record<string, unknown>>;
+  private blocks;
+  private emitDelta;
+  private emitFinal;
+  /** Surface a transport failure the way a run error is surfaced. */
+  fail(message: string): void;
+  handleEvent(event: AguiIncomingEvent): void;
+  /**
+   * 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.
+   */
+  private accumulateArgs;
+  private flushArgs;
+  private publishArgs;
+  /**
+   * The block with any message this surface has already been sent removed;
+   * `null` when nothing in it is new.
+   */
+  private freshA2UI;
+  private handleCustom;
+}
+//#endregion
+//# sourceMappingURL=bridge.d.ts.map

package/dist/agent-chat/bridge.js

@@ -0,0 +1,349 @@
+"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() {
+		const content = this.blocks();
+		this.chat({
+			runId: this.runId,
+			sessionKey: this.sessionKey,
+			seq: ++this.seq,
+			state: "final",
+			...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,
+						completedAt: this.now()
+					}
+				});
+				break;
+			case "CUSTOM":
+				this.handleCustom(event);
+				break;
+			case "RUN_FINISHED":
+				this.terminal = true;
+				if (event.outcome?.type === "interrupt") this.pendingInterrupts.push(...event.outcome.interrupts ?? []);
+				this.emitFinal();
+				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(): 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      ...(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        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            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        if (event.outcome?.type === \"interrupt\") {\n          this.pendingInterrupts.push(...(event.outcome.interrupts ?? []));\n        }\n        this.emitFinal();\n        break;\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,58 @@
+"use client";
+import { AgentChatMessage } 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;
+export declare function readStoredSessionKey(scope: string): string | null;
+export declare function writeStoredSessionKey(scope: string, key: string | null): 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