@runtypelabs/persona 4.25.0 → 4.26.0

package/src/client.ts

@@ -1,10 +1,9 @@
-import type { RuntypeExecutionStreamEvent, RuntypeClientInitResponse } from "./generated/runtype-openapi-contract";
+import type { RuntypeClientInitResponse } from "./generated/runtype-openapi-contract";
 import {
   AgentWidgetConfig,
   AgentWidgetMessage,
   AgentWidgetEvent,
   AgentWidgetStreamParser,
-  AgentWidgetStreamParserResult,
   AgentWidgetContextProvider,
   AgentWidgetRequestMiddleware,
   AgentWidgetRequestPayload,
@@ -13,20 +12,15 @@ import {
   AgentWidgetSSEEventParser,
   AgentWidgetHeadersFunction,
   AgentWidgetSSEEventResult as _AgentWidgetSSEEventResult,
-  StopReasonKind,
   ClientSession,
   ClientChatRequest,
   ClientToolDefinition,
   ClientFeedbackRequest,
   ClientFeedbackType,
-  PersonaArtifactKind,
-  PersonaArtifactFileMeta,
-  ContentPart,
   PreparedClientSession,
   WidgetHistoryInternals,
   HistoryScope,
   HistoryIdentityStatus,
-  HistoryConversationSummary,
   HistoryConversationPage,
   HistoryConversationDetail,
   HistoryDisplayProjection,
@@ -36,28 +30,26 @@ import {
 import {
   computeClientToolsFingerprint,
   getWebMcpToolDisplayTitle,
-  isWebMcpToolName,
   loadWebMcpPolyfillModule,
   recordWebMcpToolDisplayTitles,
 } from "./webmcp-bridge";
 import { loadWebMcpRuntime } from "./webmcp-runtime-loader";
 import type { WebMcpBridge } from "./webmcp-runtime-entry";
-import {
-  buildArtifactRefRawContent,
-  resolveArtifactDisplayMode
-} from "./utils/artifact-display";
 import { resolveTarget } from "./utils/target";
 import { generateTurnId } from "./utils/message-id";
 import { builtInClientToolsForDispatch } from "./ask-user-question-tool";
 import { serializeWithToolPairs } from "./utils/tool-pair-replay";
 import {
-  extractTextFromJson,
   createPlainTextParser,
   createJsonStreamParser,
   createRegexJsonParser,
   createXmlParser
 } from "./utils/formatting";
 import { VERSION } from "./version";
+import { getClientStreamSync, loadClientStream } from "./client-stream-loader";
+import { loadClientHistory } from "./client-history-loader";
+import type { ClientHistoryHost } from "./client-history";
+import type { ClientResumeHost } from "./client-resume";
 
 /** History transcripts stay on the wire shape; `utils/history-messages.ts` maps them. */
 export type { HistoryWireMessage } from "./utils/history-messages";
@@ -84,10 +76,10 @@ type DispatchOptions = {
   interrupt?: boolean;
 };
 
-type SSEHandler = (event: AgentWidgetEvent) => void;
+export type SSEHandler = (event: AgentWidgetEvent) => void;
 
 const DEFAULT_ENDPOINT = "https://api.runtype.com/v1/dispatch";
-const DEFAULT_CLIENT_API_BASE = "https://api.runtype.com";
+import { DEFAULT_CLIENT_API_BASE } from "./utils/constants";
 
 /** Branch on `code`, never on message text. */
 export type HistoryClientErrorCode =
@@ -134,68 +126,17 @@ export class HistoryClientError extends Error {
   }
 }
 
-/** Per-message / per-batch display-projection caps (contract facts #5, #15). */
-const DISPLAY_PROJECTION_MESSAGE_CAP = 32768;
-const DISPLAY_PROJECTION_BATCH_CAP = 49152;
-
-/** Normalize current history metadata without leaking wire-only aliases. */
-const normalizeHistorySummary = (raw: unknown): HistoryConversationSummary => {
-  const row = (raw ?? {}) as Record<string, unknown>;
-  const targetId = typeof row.targetId === "string" ? row.targetId : null;
-  return {
-    id: typeof row.id === "string" ? row.id : "",
-    title: typeof row.title === "string" ? row.title : "",
-    targetId,
-    preview: typeof row.preview === "string" ? row.preview : null,
-    messageCount: typeof row.messageCount === "number" ? row.messageCount : 0,
-    createdAt: typeof row.createdAt === "string" ? row.createdAt : "",
-    updatedAt: typeof row.updatedAt === "string" ? row.updatedAt : "",
-  };
-};
-
 const identityReason = (status: HistoryIdentityStatus): string | undefined =>
   "reason" in status ? status.reason : undefined;
 
-const PROOF_NOT_ADMITTED_MESSAGE =
-  "The identity proof was not admitted; account history is unavailable";
+
 const PROOF_REJECTED_MESSAGE = "The identity proof was rejected";
-const NO_VISITOR_CREDENTIAL_MESSAGE = "The request carried no visitor credential";
-const IDENTITY_MISMATCH_MESSAGE = "The stored visitor belongs to a different signed-in user";
 
 const isHistoryClientError = (
   error: unknown,
   code: HistoryClientErrorCode
 ): boolean => error instanceof HistoryClientError && error.code === code;
 
-/**
- * Derive a download filename for `agent_media` parts that are delivered
- * without one. Maps a few well-known MIME types to friendly extensions and
- * falls back to `attachment.<subtype>` (or just `attachment` for opaque
- * types like `application/octet-stream`).
- */
-function filenameFromMediaType(mediaType: string): string {
-  // MIME types are case-insensitive (RFC 7231); compare against a lowercased
-  // copy so callers that pass mixed casing still hit the friendly extensions.
-  const lower = mediaType.toLowerCase();
-  const knownExtensions: Record<string, string> = {
-    "application/pdf": "pdf",
-    "application/json": "json",
-    "application/zip": "zip",
-    "text/plain": "txt",
-    "text/csv": "csv",
-    "text/markdown": "md"
-  };
-  const ext = knownExtensions[lower];
-  if (ext) return `attachment.${ext}`;
-  const slash = lower.indexOf("/");
-  if (slash > 0) {
-    const subtype = lower.slice(slash + 1).split(";")[0]?.trim() ?? "";
-    if (subtype && subtype !== "octet-stream" && /^[a-z0-9.+-]+$/i.test(subtype)) {
-      return `attachment.${subtype}`;
-    }
-  }
-  return "attachment";
-}
 
 /**
  * Check if a message has valid (non-empty) content for sending to the API.
@@ -203,6 +144,8 @@ function filenameFromMediaType(mediaType: string): string {
  *
  */
 const hasValidContent = (message: AgentWidgetMessage): boolean => {
+  // Display-only voice captions are never conversation.
+  if (message.voiceCaption) return false;
   // Check contentParts (multi-modal content)
   if (message.contentParts && message.contentParts.length > 0) {
     return true;
@@ -253,60 +196,27 @@ function getParserFromType(parserType?: "plain" | "json" | "regex-json" | "xml")
 
 export type SSEEventCallback = (eventType: string, payload: unknown) => void;
 
-const looksStructured = (value: string) =>
-  value.startsWith("{") || value.startsWith("[") || value.startsWith("<");
-
-/**
- * Choose the best content source for sealed-segment reconciliation.
- * Prefers the final structured payload from step_complete when the raw
- * buffer is only a partial/unparseable prefix of the same structured format.
- */
-export function preferFinalStructuredContent(
-  rawBuffer: string | undefined,
-  finalString: string
-): string {
-  if (!rawBuffer) return finalString;
-
-  const rawTrimmed = rawBuffer.trim();
-  const finalTrimmed = finalString.trim();
-  if (rawTrimmed.length === 0) return finalString;
-  if (finalTrimmed.length === 0) return rawBuffer;
-
-  const rawLooksStructured = looksStructured(rawTrimmed);
-  const finalLooksStructured = looksStructured(finalTrimmed);
-
-  if (!finalLooksStructured) return rawBuffer;
-  if (!rawLooksStructured) return finalString;
-  if (finalTrimmed === rawTrimmed) return finalString;
-  if (finalTrimmed.startsWith(rawTrimmed)) return finalString;
-
-  const rawJsonText = extractTextFromJson(rawBuffer);
-  const finalJsonText = extractTextFromJson(finalString);
-  if (finalJsonText !== null && rawJsonText === null) return finalString;
-
-  return rawBuffer;
-}
 
 export class AgentWidgetClient {
-  private readonly apiUrl: string;
-  private readonly headers: Record<string, string>;
+  readonly #apiUrl: string;
+  readonly #headers: Record<string, string>;
   private readonly debug: boolean;
-  private readonly createStreamParser: () => AgentWidgetStreamParser;
-  private readonly contextProviders: AgentWidgetContextProvider[];
-  private readonly requestMiddleware?: AgentWidgetRequestMiddleware;
-  private readonly customFetch?: AgentWidgetCustomFetch;
-  private readonly parseSSEEvent?: AgentWidgetSSEEventParser;
-  private readonly getHeaders?: AgentWidgetHeadersFunction;
-  private onSSEEvent?: SSEEventCallback;
+  readonly #createStreamParser: () => AgentWidgetStreamParser;
+  readonly #contextProviders: AgentWidgetContextProvider[];
+  readonly #requestMiddleware?: AgentWidgetRequestMiddleware;
+  readonly #customFetch?: AgentWidgetCustomFetch;
+  readonly #parseSSEEvent?: AgentWidgetSSEEventParser;
+  readonly #getHeaders?: AgentWidgetHeadersFunction;
+  #onSSEEvent?: SSEEventCallback;
   
   // Client token mode properties
   /**
    * Turn id of the newest client-token dispatch. A dispatch whose id no longer
    * matches is superseded, and every SSE frame it still receives is dropped
    */
-  private currentClientTurnId: string | null = null;
+  #currentClientTurnId: string | null = null;
   private clientSession: ClientSession | null = null;
-  private sessionInitPromise: Promise<ClientSession> | null = null;
+  #sessionInitPromise: Promise<ClientSession> | null = null;
   /**
    * Early-init latch for `warmSession()`. `false` = armed. Otherwise it holds
    * the session value (`null` or an expired session) the one early attempt was
@@ -314,7 +224,7 @@ export class AgentWidgetClient {
    * re-armed when a session is installed or cleared, so each session lifetime
    * gets one early init.
    */
-  private sessionWarmLatch: ClientSession | null | false = false;
+  #sessionWarmLatch: ClientSession | null | false = false;
 
   // Diff-only / send-once WebMCP tool dispatch (client-token mode ONLY).
   // Fingerprint of the clientTools[] last *sent in full* and confirmed by a
@@ -330,32 +240,32 @@ export class AgentWidgetClient {
   // execution — so a later resume with an empty registry must still send the
   // explicit `clientTools: []` replace. Reset only by an explicit [] replace,
   // a session change, or a conversation reset.
-  private sentNonEmptyClientToolsSessionId: string | null = null;
+  #sentNonEmptyClientToolsSessionId: string | null = null;
 
   // Visitor history (client-token mode ONLY). `historyUnavailable` latches for
   // the client's lifetime on a 403 `visitor_history_disabled`; `claimInFlight`
   // bounds the immediate first-conversation claim to one extra init.
-  private historyUnavailable = false;
-  private historyUnavailableWarned = false;
-  private claimInFlight = false;
+  #historyUnavailable = false;
+  #historyUnavailableWarned = false;
+  #claimInFlight = false;
   // Evidence-based identity state. Null means "never moved off the resting
   // state", which is recomputed from config so `update()` stays honest.
-  private historyIdentityStatus: HistoryIdentityStatus | null = null;
+  #historyIdentityStatus: HistoryIdentityStatus | null = null;
   // Fan-out beside the single internals callback: the Runtype history provider
   // bridges these into the generic seam. Cleared with the client instance.
-  private historyIdentitySubscribers = new Set<
+  #historyIdentitySubscribers = new Set<
     (status: HistoryIdentityStatus) => void
   >();
-  private historyAvailabilitySubscribers = new Set<(available: boolean) => void>();
+  #historyAvailabilitySubscribers = new Set<(available: boolean) => void>();
 
   // WebMCP: page-discovered tool consumption. The bridge runtime ships in the
   // lazy webmcp-runtime chunk; `webMcpBridge` stays null until the chunk is
   // adopted (and forever when `config.webmcp?.enabled !== true`). Dispatch
   // paths await `getWebMcpBridge()`; sync callers read the cached instance.
   private webMcpBridge: WebMcpBridge | null = null;
-  private webMcpBridgePromise: Promise<WebMcpBridge | null> | null = null;
+  #webMcpBridgePromise: Promise<WebMcpBridge | null> | null = null;
   /** undefined = never set; null = explicitly cleared. Applied at adoption. */
-  private pendingWebMcpConfirmHandler: WebMcpConfirmHandler | null | undefined;
+  #pendingWebMcpConfirmHandler: WebMcpConfirmHandler | null | undefined;
 
   constructor(
     private config: AgentWidgetConfig = {},
@@ -366,29 +276,29 @@ export class AgentWidgetClient {
         "[Persona] `target` is mutually exclusive with `agentId`, `flowId`, and `agent`. Set only one routing field.",
       );
     }
-    this.apiUrl = config.apiUrl ?? DEFAULT_ENDPOINT;
-    this.headers = {
+    this.#apiUrl = config.apiUrl ?? DEFAULT_ENDPOINT;
+    this.#headers = {
       "Content-Type": "application/json",
       "X-Persona-Version": VERSION,
       ...config.headers
     };
     this.debug = Boolean(config.debug);
     // Use custom stream parser if provided, otherwise use parserType, or fall back to plain text parser
-    this.createStreamParser = config.streamParser ?? getParserFromType(config.parserType);
-    this.contextProviders = config.contextProviders ?? [];
-    this.requestMiddleware = config.requestMiddleware;
-    this.customFetch = config.customFetch;
-    this.parseSSEEvent = config.parseSSEEvent;
-    this.getHeaders = config.getHeaders;
+    this.#createStreamParser = config.streamParser ?? getParserFromType(config.parserType);
+    this.#contextProviders = config.contextProviders ?? [];
+    this.#requestMiddleware = config.requestMiddleware;
+    this.#customFetch = config.customFetch;
+    this.#parseSSEEvent = config.parseSSEEvent;
+    this.#getHeaders = config.getHeaders;
     if (config.webmcp?.enabled === true) {
       // Kick the runtime chunk fetch now so the bridge is warm before the
       // first dispatch snapshot (which awaits it either way).
-      this.webMcpBridgePromise = this.createWebMcpBridge(config.webmcp);
+      this.#webMcpBridgePromise = this.#createWebMcpBridge(config.webmcp);
     }
   }
 
   /** Load the lazy runtime chunk and construct the bridge with core-owned deps. */
-  private createWebMcpBridge(
+  #createWebMcpBridge(
     webmcpConfig: NonNullable<AgentWidgetConfig["webmcp"]>
   ): Promise<WebMcpBridge | null> {
     return loadWebMcpRuntime()
@@ -398,8 +308,8 @@ export class AgentWidgetClient {
           getToolDisplayTitle: getWebMcpToolDisplayTitle,
           loadPolyfill: loadWebMcpPolyfillModule,
         });
-        if (this.pendingWebMcpConfirmHandler !== undefined) {
-          bridge.setConfirmHandler(this.pendingWebMcpConfirmHandler);
+        if (this.#pendingWebMcpConfirmHandler !== undefined) {
+          bridge.setConfirmHandler(this.#pendingWebMcpConfirmHandler);
         }
         this.webMcpBridge = bridge;
         return bridge;
@@ -407,7 +317,7 @@ export class AgentWidgetClient {
       .catch((err) => {
         // Failed chunk fetch: clear the memoized promise so the next dispatch
         // retries (the chunk loader clears its own rejection too).
-        this.webMcpBridgePromise = null;
+        this.#webMcpBridgePromise = null;
         // Always surface this: a silently-absent bridge means empty tool
         // snapshots and failed webmcp resumes with no operator signal.
         console.warn("[Persona] Failed to load the WebMCP runtime chunk", err);
@@ -416,13 +326,13 @@ export class AgentWidgetClient {
   }
 
   /** Resolve the bridge, loading the runtime chunk on first use. */
-  private getWebMcpBridge(): Promise<WebMcpBridge | null> {
+  #getWebMcpBridge(): Promise<WebMcpBridge | null> {
     if (this.webMcpBridge) return Promise.resolve(this.webMcpBridge);
     if (this.config.webmcp?.enabled !== true) return Promise.resolve(null);
-    if (!this.webMcpBridgePromise) {
-      this.webMcpBridgePromise = this.createWebMcpBridge(this.config.webmcp);
+    if (!this.#webMcpBridgePromise) {
+      this.#webMcpBridgePromise = this.#createWebMcpBridge(this.config.webmcp);
     }
-    return this.webMcpBridgePromise;
+    return this.#webMcpBridgePromise;
   }
 
   /**
@@ -456,7 +366,7 @@ export class AgentWidgetClient {
    * Set callback for capturing raw SSE events
    */
   public setSSEEventCallback(callback: SSEEventCallback): void {
-    this.onSSEEvent = callback;
+    this.#onSSEEvent = callback;
   }
 
   /**
@@ -466,7 +376,7 @@ export class AgentWidgetClient {
    */
   public setWebMcpConfirmHandler(handler: WebMcpConfirmHandler | null): void {
     // Queue for a bridge still in flight; apply immediately once adopted.
-    this.pendingWebMcpConfirmHandler = handler;
+    this.#pendingWebMcpConfirmHandler = handler;
     this.webMcpBridge?.setConfirmHandler(handler);
   }
 
@@ -499,7 +409,7 @@ export class AgentWidgetClient {
     // have adopted yet, and returning null would misroute the call to the
     // legacy local-tool resume path.
     if (this.config.webmcp?.enabled !== true) return null;
-    return this.getWebMcpBridge().then((bridge) =>
+    return this.#getWebMcpBridge().then((bridge) =>
       bridge
         ? bridge.executeToolCall(wireToolName, args, signal)
         : {
@@ -515,7 +425,7 @@ export class AgentWidgetClient {
    * Get the current SSE event callback (used to preserve across client recreation)
    */
   public getSSEEventCallback(): SSEEventCallback | undefined {
-    return this.onSSEEvent;
+    return this.#onSSEEvent;
   }
 
   /**
@@ -532,7 +442,7 @@ export class AgentWidgetClient {
    * across `update()`; the `target`/explicit-field conflict is rejected in the
    * constructor, so at most one source is set here.
    */
-  private routing(): {
+  #routing(): {
     agentId?: string;
     flowId?: string;
     targetPayload?: Record<string, unknown>;
@@ -551,7 +461,7 @@ export class AgentWidgetClient {
    * Check if operating in agent execution mode
    */
   public isAgentMode(): boolean {
-    return !!(this.config.agent || this.routing().agentId);
+    return !!(this.config.agent || this.#routing().agentId);
   }
 
   /**
@@ -560,7 +470,7 @@ export class AgentWidgetClient {
    * pointed at the dispatch endpoint still resolves its sibling routes. Not
    * used for proxy-mode URLs, whose resume route is `${apiUrl}/resume`.
    */
-  private clientApiBase(): string {
+  #clientApiBase(): string {
     return (
       this.config.apiUrl?.replace(/\/+$/, '').replace(/\/v1\/dispatch$/, '') ||
       DEFAULT_CLIENT_API_BASE
@@ -570,8 +480,8 @@ export class AgentWidgetClient {
   /**
    * Get the appropriate API URL based on mode
    */
-  private getClientApiUrl(endpoint: 'init' | 'chat' | 'resume'): string {
-    return `${this.clientApiBase()}/v1/client/${endpoint}`;
+  #getClientApiUrl(endpoint: 'init' | 'chat' | 'resume'): string {
+    return `${this.#clientApiBase()}/v1/client/${endpoint}`;
   }
 
   /**
@@ -600,7 +510,7 @@ export class AgentWidgetClient {
         );
       }
       const path =
-        `${this.clientApiBase()}/v1/client/conversations/` +
+        `${this.#clientApiBase()}/v1/client/conversations/` +
         `${encodeURIComponent(conversationId)}/executions/` +
         `${encodeURIComponent(ctx.executionId)}/events`;
       const query = new URLSearchParams({
@@ -617,14 +527,18 @@ export class AgentWidgetClient {
       });
       if (response.status === 401 && !recovered) {
         recovered = true;
-        session = await this.recoverFromUnauthorized(
-          await this.readErrorCode(response),
+        const history = await loadClientHistory();
+        session = await history.recoverFromUnauthorized(
+          this.#historyHost(),
+          await history.readErrorCode(this.#historyHost(), response),
           null,
           true
         );
         continue;
       }
-      if (!response.ok) throw await this.historyErrorFor(response, true);
+      if (!response.ok) {
+        throw await (await loadClientHistory()).historyErrorFor(this.#historyHost(), response, true);
+      }
       return response;
     }
   }
@@ -646,13 +560,13 @@ export class AgentWidgetClient {
     const current = this.clientSession;
     if (
       !this.isClientTokenMode() ||
-      this.sessionInitPromise ||
+      this.#sessionInitPromise ||
       (current && new Date() < current.expiresAt) ||
-      this.sessionWarmLatch === current
+      this.#sessionWarmLatch === current
     ) {
       return null;
     }
-    this.sessionWarmLatch = current;
+    this.#sessionWarmLatch = current;
     // Swallowed on purpose: the send's own initSession() reports failures.
     return this.initSession().catch(() => null);
   }
@@ -676,19 +590,19 @@ export class AgentWidgetClient {
     }
 
     // Deduplicate concurrent init calls
-    if (this.sessionInitPromise) {
-      return this.sessionInitPromise;
+    if (this.#sessionInitPromise) {
+      return this.#sessionInitPromise;
     }
 
     // Callers that dedupe share this promise, so the stale check below covers
     // them too (the send reusing an early init included).
-    const pending: Promise<ClientSession> = (this.sessionInitPromise = this._doInitSession()
+    const pending: Promise<ClientSession> = (this.#sessionInitPromise = this.#_doInitSession()
       .then((session) => {
         // A clear or replacement (credential change, start-new, proof re-init)
         // while this was in flight makes the result stale: never install it.
-        if (this.sessionInitPromise !== pending) return this.initSession();
+        if (this.#sessionInitPromise !== pending) return this.initSession();
         this.clientSession = session;
-        this.sessionWarmLatch = false;
+        this.#sessionWarmLatch = false;
         // A freshly-minted session must resend the full WebMCP tool list on its
         // next turn: drop any diff-only fingerprint cached under a prior session,
         // so we never claim "unchanged" against a session the server didn't store
@@ -699,17 +613,17 @@ export class AgentWidgetClient {
         return session;
       })
       .finally(() => {
-        if (this.sessionInitPromise === pending) this.sessionInitPromise = null;
+        if (this.#sessionInitPromise === pending) this.#sessionInitPromise = null;
       }));
     return pending;
   }
 
   /** Visitor history rides on client-token init only, and latches off after a 403 degrade. */
-  private isHistoryCapable(): boolean {
+  #isHistoryCapable(): boolean {
     return (
       this.config.features?.history?.enabled === true &&
       this.isClientTokenMode() &&
-      !this.historyUnavailable
+      !this.#historyUnavailable
     );
   }
 
@@ -721,36 +635,36 @@ export class AgentWidgetClient {
   }
 
   /** One-way, client-lifetime latch: chat keeps working without history. */
-  private markHistoryUnavailable(): void {
-    if (this.historyUnavailable) return;
+  #markHistoryUnavailable(): void {
+    if (this.#historyUnavailable) return;
     // Announce before the latch flips, or the resting state already matches.
-    this.setHistoryIdentityStatus({ state: 'unavailable', reason: 'history_disabled' });
-    this.historyUnavailable = true;
-    if (!this.historyUnavailableWarned && typeof console !== 'undefined') {
-      this.historyUnavailableWarned = true;
+    this.#setHistoryIdentityStatus({ state: 'unavailable', reason: 'history_disabled' });
+    this.#historyUnavailable = true;
+    if (!this.#historyUnavailableWarned && typeof console !== 'undefined') {
+      this.#historyUnavailableWarned = true;
       // eslint-disable-next-line no-console
       console.warn(
         '[Persona] Visitor history is disabled for this surface; continuing without it.'
       );
     }
     this.historyInternals.onHistoryAvailabilityChanged?.(false);
-    for (const subscriber of [...this.historyAvailabilitySubscribers]) {
+    for (const subscriber of [...this.#historyAvailabilitySubscribers]) {
       subscriber(false);
     }
   }
 
   /** Public, secret-free view of the current identity state. */
   public getHistoryIdentityStatus(): HistoryIdentityStatus {
-    return this.historyIdentityStatus ?? this.restingIdentityStatus();
+    return this.#historyIdentityStatus ?? this.#restingIdentityStatus();
   }
 
   /** Deduped status notifications; carries no token, proof, or identity value. */
   public subscribeHistoryIdentityStatus(
     callback: (status: HistoryIdentityStatus) => void
   ): () => void {
-    this.historyIdentitySubscribers.add(callback);
+    this.#historyIdentitySubscribers.add(callback);
     return () => {
-      this.historyIdentitySubscribers.delete(callback);
+      this.#historyIdentitySubscribers.delete(callback);
     };
   }
 
@@ -758,32 +672,32 @@ export class AgentWidgetClient {
   public subscribeHistoryAvailability(
     callback: (available: boolean) => void
   ): () => void {
-    this.historyAvailabilitySubscribers.add(callback);
-    if (this.historyUnavailable) callback(false);
+    this.#historyAvailabilitySubscribers.add(callback);
+    if (this.#historyUnavailable) callback(false);
     return () => {
-      this.historyAvailabilitySubscribers.delete(callback);
+      this.#historyAvailabilitySubscribers.delete(callback);
     };
   }
 
   /** Config-derived state before any per-operation evidence exists. */
-  private restingIdentityStatus(): HistoryIdentityStatus {
+  #restingIdentityStatus(): HistoryIdentityStatus {
     if (!this.isClientTokenMode()) {
       return { state: 'unavailable', reason: 'ineligible_mode' };
     }
-    if (this.config.features?.history?.enabled !== true || this.historyUnavailable) {
+    if (this.config.features?.history?.enabled !== true || this.#historyUnavailable) {
       return { state: 'unavailable', reason: 'history_disabled' };
     }
-    return this.browserOnlyStatus();
+    return this.#browserOnlyStatus();
   }
 
   /** Keeps an already-observed browser_only reason; otherwise derives one. */
-  private browserOnlyStatus(): HistoryIdentityStatus {
-    const current = this.historyIdentityStatus;
+  #browserOnlyStatus(): HistoryIdentityStatus {
+    const current = this.#historyIdentityStatus;
     if (current?.state === 'browser_only') return current;
-    return this.derivedBrowserOnly();
+    return this.#derivedBrowserOnly();
   }
 
-  private derivedBrowserOnly(): HistoryIdentityStatus {
+  #derivedBrowserOnly(): HistoryIdentityStatus {
     if (this.config.features?.history?.scope === 'browser') {
       return { state: 'browser_only', reason: 'configured_browser_scope' };
     }
@@ -794,14 +708,14 @@ export class AgentWidgetClient {
   }
 
   /** Identical consecutive states are not re-announced. */
-  private setHistoryIdentityStatus(next: HistoryIdentityStatus): void {
+  #setHistoryIdentityStatus(next: HistoryIdentityStatus): void {
     const current = this.getHistoryIdentityStatus();
     const unchanged =
       current.state === next.state && identityReason(current) === identityReason(next);
-    this.historyIdentityStatus = next;
+    this.#historyIdentityStatus = next;
     if (unchanged) return;
     this.historyInternals.onHistoryIdentityStatusChanged?.(next);
-    for (const subscriber of [...this.historyIdentitySubscribers]) subscriber(next);
+    for (const subscriber of [...this.#historyIdentitySubscribers]) subscriber(next);
   }
 
   /**
@@ -809,7 +723,7 @@ export class AgentWidgetClient {
    * `conversationId` and `sessionId` are mutually exclusive on the wire (strict
    * server union), so a resume never carries the stored session id.
    */
-  private async createClientSession(opts: {
+  async #createClientSession(opts: {
     conversationId?: string;
     durableResume?: boolean;
     identityProof?: string | null;
@@ -817,7 +731,7 @@ export class AgentWidgetClient {
     omitVisitorFields?: boolean;
     signal?: AbortSignal;
   }): Promise<ClientSession> {
-    const historyCapable = this.isHistoryCapable() && !opts.omitVisitorFields;
+    const historyCapable = this.#isHistoryCapable() && !opts.omitVisitorFields;
     // Recovery is negotiated independently from the history UI. New servers
     // return an explicit capability bit; old strict servers reject the
     // additive request field, which the fallback below handles once.
@@ -829,7 +743,7 @@ export class AgentWidgetClient {
       visitorToken = await this.readVisitorToken();
     }
 
-    const routed = this.routing();
+    const routed = this.#routing();
     const sessionTargetId = routed.agentId ?? routed.flowId;
     const resumeConversationId =
       historyCapable || opts.durableResume ? opts.conversationId : undefined;
@@ -854,7 +768,7 @@ export class AgentWidgetClient {
     };
 
     opts.signal?.throwIfAborted();
-    const response = await fetch(this.getClientApiUrl('init'), {
+    const response = await fetch(this.#getClientApiUrl('init'), {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -867,7 +781,7 @@ export class AgentWidgetClient {
     if (!response.ok) {
       const error = await response.json().catch(() => ({ error: 'Session initialization failed' }));
       if (historyCapable && response.status === 403 && error.error === 'visitor_history_disabled') {
-        this.markHistoryUnavailable();
+        this.#markHistoryUnavailable();
         // A resume must not silently degrade into some other conversation.
         if (resumeConversationId) {
           throw new HistoryClientError(
@@ -875,7 +789,7 @@ export class AgentWidgetClient {
             'Visitor history is disabled for this surface'
           );
         }
-        return this.createClientSession({ ...opts, omitVisitorFields: true });
+        return this.#createClientSession({ ...opts, omitVisitorFields: true });
       }
       if (response.status === 403 && error.error === 'durable_recovery_disabled') {
         throw new HistoryClientError(
@@ -929,13 +843,13 @@ export class AgentWidgetClient {
     };
   }
 
-  private async _doInitSession(): Promise<ClientSession> {
+  async #_doInitSession(): Promise<ClientSession> {
     await this.historyInternals.historyBootstrapReady;
     const previousConversationId = this.config.getStoredConversationId?.() || null;
     const durableResume =
       this.historyInternals.shouldResumeDurableConversation?.() === true;
-    if (!this.isHistoryCapable() && !durableResume) {
-      return this.ordinaryInit(previousConversationId, false);
+    if (!this.#isHistoryCapable() && !durableResume) {
+      return this.#ordinaryInit(previousConversationId, false);
     }
     const storedToken = await this.readVisitorToken();
 
@@ -943,14 +857,14 @@ export class AgentWidgetClient {
     // session id, so benign expiry never forks or wipes the conversation.
     if (previousConversationId && storedToken) {
       try {
-        const resumed = await this.createClientSession({
+        const resumed = await this.#createClientSession({
           conversationId: previousConversationId,
           durableResume,
         });
         if (durableResume && resumed.durableRecovery?.enabled !== true) {
           this.historyInternals.setStoredResumableHandle?.(null);
         }
-        return this.finishInit(resumed, previousConversationId, false);
+        return this.#finishInit(resumed, previousConversationId, false);
       } catch (error) {
         if (
           !isHistoryClientError(error, 'not_found') &&
@@ -963,11 +877,11 @@ export class AgentWidgetClient {
           this.historyInternals.setStoredResumableHandle?.(null);
         }
         // Record gone or credential dead: exactly one ordinary fallback, never a loop.
-        return this.ordinaryInit(previousConversationId, true);
+        return this.#ordinaryInit(previousConversationId, true);
       }
     }
 
-    return this.ordinaryInit(previousConversationId, false);
+    return this.#ordinaryInit(previousConversationId, false);
   }
 
   /**
@@ -975,27 +889,27 @@ export class AgentWidgetClient {
    * cross-tab first-init lock: a waiter re-reads inside the lock and joins the
    * winner's visitor instead of minting a second one.
    */
-  private async ordinaryInit(
+  async #ordinaryInit(
     previousConversationId: string | null,
     continuityBroken: boolean
   ): Promise<ClientSession> {
     const store = this.historyInternals.visitorStore;
     if (store && !(await this.readVisitorToken())) {
       return store.withFirstInitLock(() =>
-        this.doOrdinaryInit(previousConversationId, continuityBroken)
+        this.#doOrdinaryInit(previousConversationId, continuityBroken)
       );
     }
-    return this.doOrdinaryInit(previousConversationId, continuityBroken);
+    return this.#doOrdinaryInit(previousConversationId, continuityBroken);
   }
 
-  private async doOrdinaryInit(
+  async #doOrdinaryInit(
     previousConversationId: string | null,
     continuityBroken: boolean
   ): Promise<ClientSession> {
     const storedSessionId = this.config.getStoredSessionId?.() || null;
-    const first = await this.createClientSession({ storedSessionId });
-    const session = await this.claimFirstConversation(first);
-    return this.finishInit(session, previousConversationId, continuityBroken);
+    const first = await this.#createClientSession({ storedSessionId });
+    const session = await this.#claimFirstConversation(first);
+    return this.#finishInit(session, previousConversationId, continuityBroken);
   }
 
   /**
@@ -1003,17 +917,17 @@ export class AgentWidgetClient {
    * persists any replacement token (inside `createClientSession`), and installs
    * the result as the live session.
    */
-  private async reinitWithProof(proof: string): Promise<ClientSession> {
+  async #reinitWithProof(proof: string): Promise<ClientSession> {
     const storedSessionId = this.config.getStoredSessionId?.() || null;
     const previousConversationId = this.config.getStoredConversationId?.() || null;
-    const session = await this.createClientSession({
+    const session = await this.#createClientSession({
       storedSessionId,
       identityProof: proof,
     });
-    const installed = this.finishInit(session, previousConversationId, false);
+    const installed = this.#finishInit(session, previousConversationId, false);
     this.clientSession = installed;
-    this.sessionInitPromise = null;
-    this.sessionWarmLatch = false;
+    this.#sessionInitPromise = null;
+    this.#sessionWarmLatch = false;
     this.resetClientToolsFingerprint();
     return installed;
   }
@@ -1022,22 +936,22 @@ export class AgentWidgetClient {
    * A minted visitor means the record this session just created is still
    * unowned; one immediate re-init with `{visitorToken, sessionId}` claims it.
    */
-  private async claimFirstConversation(first: ClientSession): Promise<ClientSession> {
+  async #claimFirstConversation(first: ClientSession): Promise<ClientSession> {
     if (
       !first.visitor?.token ||
-      this.claimInFlight ||
-      (!this.isHistoryCapable() && first.durableRecovery?.enabled !== true)
+      this.#claimInFlight ||
+      (!this.#isHistoryCapable() && first.durableRecovery?.enabled !== true)
     ) {
       return first;
     }
-    this.claimInFlight = true;
+    this.#claimInFlight = true;
     try {
-      return await this.createClientSession({ storedSessionId: first.sessionId });
+      return await this.#createClientSession({ storedSessionId: first.sessionId });
     } catch {
       // Non-fatal: the next page load claims through the normal backend path.
       return first;
     } finally {
-      this.claimInFlight = false;
+      this.#claimInFlight = false;
     }
   }
 
@@ -1045,7 +959,7 @@ export class AgentWidgetClient {
    * Continuity guard + id persistence. A different record than the persisted
    * one is a privacy transition, announced before the new id is written.
    */
-  private finishInit(
+  #finishInit(
     session: ClientSession,
     previousConversationId: string | null,
     continuityBroken: boolean
@@ -1072,7 +986,7 @@ export class AgentWidgetClient {
   }
 
   /** Wrap an uncached init so nothing installs until the winner commits. */
-  private prepared(session: ClientSession): PreparedClientSession {
+  #prepared(session: ClientSession): PreparedClientSession {
     let settled = false;
     return {
       session,
@@ -1080,7 +994,7 @@ export class AgentWidgetClient {
         if (settled) return;
         settled = true;
         this.clientSession = session;
-        this.sessionWarmLatch = false;
+        this.#sessionWarmLatch = false;
         this.resetClientToolsFingerprint();
       },
       discard: () => {
@@ -1101,7 +1015,7 @@ export class AgentWidgetClient {
     if (!this.isClientTokenMode()) {
       throw new Error('prepareConversationSession() only available in client token mode');
     }
-    if (!this.isHistoryCapable()) {
+    if (!this.#isHistoryCapable()) {
       throw new HistoryClientError(
         'history_disabled',
         'Visitor history is disabled for this surface'
@@ -1116,11 +1030,11 @@ export class AgentWidgetClient {
         'Reopening a conversation requires a stored visitor token or an identity proof'
       );
     }
-    const session = await this.createClientSession({
+    const session = await this.#createClientSession({
       conversationId,
       identityProof: proof,
     });
-    return this.prepared(session);
+    return this.#prepared(session);
   }
 
   /** Transactional new conversation: no stored session id, no conversation id. */
@@ -1129,8 +1043,8 @@ export class AgentWidgetClient {
       throw new Error('prepareNewConversationSession() only available in client token mode');
     }
     await this.historyInternals.historyBootstrapReady;
-    const session = await this.createClientSession({});
-    return this.prepared(session);
+    const session = await this.#createClientSession({});
+    return this.#prepared(session);
   }
 
   /**
@@ -1140,8 +1054,8 @@ export class AgentWidgetClient {
    */
   public handleExternalCredentialChange(): void {
     this.clearClientSession();
-    if (this.isHistoryCapable()) {
-      this.setHistoryIdentityStatus(this.derivedBrowserOnly());
+    if (this.#isHistoryCapable()) {
+      this.#setHistoryIdentityStatus(this.#derivedBrowserOnly());
     }
   }
 
@@ -1150,8 +1064,8 @@ export class AgentWidgetClient {
    */
   public clearClientSession(): void {
     this.clientSession = null;
-    this.sessionInitPromise = null;
-    this.sessionWarmLatch = false;
+    this.#sessionInitPromise = null;
+    this.#sessionWarmLatch = false;
     this.resetClientToolsFingerprint();
   }
 
@@ -1163,14 +1077,14 @@ export class AgentWidgetClient {
   public resetClientToolsFingerprint(): void {
     this.lastSentClientToolsFingerprint = null;
     this.clientToolsFingerprintSessionId = null;
-    this.sentNonEmptyClientToolsSessionId = null;
+    this.#sentNonEmptyClientToolsSessionId = null;
   }
 
   /**
    * Get the feedback API URL
    */
-  private getFeedbackApiUrl(): string {
-    return `${this.clientApiBase()}/v1/client/feedback`;
+  #getFeedbackApiUrl(): string {
+    return `${this.#clientApiBase()}/v1/client/feedback`;
   }
 
   /**
@@ -1248,7 +1162,7 @@ export class AgentWidgetClient {
       ...(this.config.clientToken && { token: this.config.clientToken }),
     };
 
-    const response = await fetch(this.getFeedbackApiUrl(), {
+    const response = await fetch(this.#getFeedbackApiUrl(), {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -1262,7 +1176,7 @@ export class AgentWidgetClient {
       
       if (response.status === 401) {
         this.clientSession = null;
-        this.sessionWarmLatch = false;
+        this.#sessionWarmLatch = false;
         this.config.onSessionExpired?.();
         throw new Error('Session expired. Please refresh to continue.');
       }
@@ -1330,32 +1244,11 @@ export class AgentWidgetClient {
   }
 
   // ==========================================================================
-  // Visitor conversation history REST (client token mode only)
+  // Visitor conversation history REST (client token mode only). The bodies
+  // live in `client-history.ts` (lazy `client-history.js` chunk on the CDN).
   // ==========================================================================
 
-  /** `/v1/client/<path>` with a query string; credentials ride in headers. */
-  private historyUrl(
-    path: string,
-    query: Record<string, string | number | undefined>
-  ): string {
-    const params = new URLSearchParams();
-    for (const [key, value] of Object.entries(query)) {
-      if (value === undefined || value === '') continue;
-      params.set(key, String(value));
-    }
-    const search = params.toString();
-    return `${this.clientApiBase()}/v1/client/${path}${search ? `?${search}` : ''}`;
-  }
-
-  /** Explicit per-operation scope wins; otherwise config, then evidence. */
-  private resolveHistoryScope(requested?: HistoryScope): HistoryScope {
-    if (requested) return requested;
-    const configured = this.config.features?.history?.scope;
-    if (configured) return configured;
-    return this.config.getIdentityProof ? 'verified-user' : 'browser';
-  }
-
-  private async resolveChatIdentityProof(signal?: AbortSignal): Promise<ClientChatRequest['identityProof']> {
+  async #resolveChatIdentityProof(signal?: AbortSignal): Promise<ClientChatRequest['identityProof']> {
     signal?.throwIfAborted();
     const provider = this.config.identityProvider;
     if (provider === undefined) return undefined;
@@ -1389,317 +1282,58 @@ export class AgentWidgetClient {
     return { provider, token };
   }
 
-  /**
-   * Resolve the proof for one logical request. `null` is an intentional
-   * browser-scope fallback only while the visitor has never been bound.
-   */
-  private async resolveIdentityProof(
-    session: ClientSession,
-    track: boolean
-  ): Promise<string | null> {
-    const provider = this.config.getIdentityProof;
-    if (!provider) {
-      if (track) this.setHistoryIdentityStatus(this.browserOnlyStatus());
-      return null;
-    }
-    if (track) this.setHistoryIdentityStatus({ state: 'verifying' });
-    let proof: string | null;
-    try {
-      proof = (await provider()) ?? null;
-    } catch {
-      if (track) this.setHistoryIdentityStatus({ state: 'identity_provider_failed' });
-      throw new HistoryClientError(
-        'identity_provider_failed',
-        'The identity proof provider failed'
-      );
-    }
-    if (proof) return proof;
-    if (session.visitor?.endUserId != null) {
-      // Never downgrade a bound visitor into its own browser scope.
-      if (track) {
-        this.setHistoryIdentityStatus({
-          state: 'authentication_required',
-          reason: 'proof_unavailable_after_binding',
-        });
-      }
-      throw new HistoryClientError(
-        'authentication_required',
-        'This browser is bound to a signed-in user and needs a fresh identity proof'
-      );
-    }
-    if (track) {
-      this.setHistoryIdentityStatus({
-        state: 'browser_only',
-        reason: 'proof_unavailable_before_binding',
-      });
-    }
-    return null;
-  }
-
-  /** Bind the visitor before the first verified request; admitted proofs only. */
-  private async bindIdentity(
-    session: ClientSession,
-    proof: string,
-    track: boolean
-  ): Promise<ClientSession> {
-    if (session.visitor?.endUserId != null) return session;
-    const bound = await this.reinitWithProof(proof);
-    const admitted =
-      bound.visitor?.identityStatus === 'admitted' && bound.visitor?.endUserId != null;
-    if (!admitted) {
-      // "ignored", or a pre-acknowledgement server that left endUserId null.
-      if (track) {
-        this.setHistoryIdentityStatus({
-          state: 'configuration_error',
-          reason: 'proof_not_admitted',
-        });
-      }
-      throw new HistoryClientError(
-        'proof_not_admitted',
-        PROOF_NOT_ADMITTED_MESSAGE
-      );
-    }
-    return bound;
-  }
-
-  private async readErrorCode(response: Response): Promise<string> {
-    const body = (await response.json().catch(() => ({}))) as Record<string, unknown>;
-    if (typeof body.error === 'string') return body.error;
-    if (typeof body.message === 'string') return body.message;
-    return '';
-  }
-
-  /**
-   * Selective one-shot 401 recovery. Returns the session to retry under;
-   * anything unrecoverable throws typed and is never retried.
-   */
-  private async recoverFromUnauthorized(
-    reason: string,
-    proof: string | null,
-    track: boolean
-  ): Promise<ClientSession> {
-    const text = reason.toLowerCase();
-    if (text.includes('invalid_identity_proof')) {
-      if (track) {
-        this.setHistoryIdentityStatus({
-          state: 'authentication_required',
-          reason: 'invalid_identity_proof',
-        });
-      }
-      throw new HistoryClientError('invalid_identity_proof', PROOF_REJECTED_MESSAGE);
-    }
-    if (text.includes('visitor token required')) {
-      throw new HistoryClientError('visitor_token_missing', NO_VISITOR_CREDENTIAL_MESSAGE);
-    }
-    if (text.includes('visitor_identity_mismatch')) {
-      if (!proof) {
-        if (track) {
-          this.setHistoryIdentityStatus({
-            state: 'authentication_required',
-            reason: 'proof_unavailable_after_binding',
-          });
-        }
-        throw new HistoryClientError('visitor_identity_mismatch', IDENTITY_MISMATCH_MESSAGE);
-      }
-      // Same proof: binds this visitor, or gives a different person a clean one.
-      return this.reinitWithProof(proof);
-    }
-    if (text.includes('expired') || text.includes('not found')) {
-      this.clearClientSession();
-      return this.initSession();
-    }
-    throw new HistoryClientError('unauthorized', reason || 'History request was not authorized');
-  }
-
-  private async historyErrorFor(
-    response: Response,
-    track: boolean
-  ): Promise<HistoryClientError> {
-    const code = await this.readErrorCode(response);
-    if (response.status === 404) {
-      return new HistoryClientError('not_found', 'Conversation not found');
-    }
-    if (response.status === 429) {
-      const header = Number.parseInt(response.headers.get('Retry-After') ?? '', 10);
-      return new HistoryClientError('rate_limited', 'Too many history requests', {
-        ...(Number.isFinite(header) ? { retryAfterSeconds: header } : {}),
-      });
-    }
-    if (response.status === 503 && code.includes('identity_proof_not_admitted')) {
-      if (track) {
-        this.setHistoryIdentityStatus({
-          state: 'configuration_error',
-          reason: 'proof_not_admitted',
-        });
-      }
-      return new HistoryClientError(
-        'proof_not_admitted',
-        PROOF_NOT_ADMITTED_MESSAGE
-      );
-    }
-    if (response.status === 401) {
-      const text = code.toLowerCase();
-      if (text.includes('invalid_identity_proof')) {
-        if (track) {
-          this.setHistoryIdentityStatus({
-            state: 'authentication_required',
-            reason: 'invalid_identity_proof',
-          });
-        }
-        return new HistoryClientError('invalid_identity_proof', PROOF_REJECTED_MESSAGE);
-      }
-      if (text.includes('visitor token required')) {
-        return new HistoryClientError('visitor_token_missing', NO_VISITOR_CREDENTIAL_MESSAGE);
-      }
-      if (text.includes('visitor_identity_mismatch')) {
-        return new HistoryClientError('visitor_identity_mismatch', IDENTITY_MISMATCH_MESSAGE);
-      }
-      return new HistoryClientError('unauthorized', code || 'History request was not authorized');
-    }
-    return new HistoryClientError(
-      'request_failed',
-      code || `History request failed (${response.status})`
-    );
-  }
-
-  /**
-   * Validate `X-History-Identity-Status` before any body is committed: the
-   * per-operation acknowledgement, not a prior init, is what proves scope.
-   */
-  private commitIdentityAcknowledgement(
-    header: string | null,
-    proofSent: boolean,
-    track: boolean
-  ): void {
-    const value = header?.toLowerCase() ?? null;
-    if (proofSent) {
-      if (value === 'admitted') {
-        if (track) this.setHistoryIdentityStatus({ state: 'verified' });
-        return;
-      }
-      if (track) {
-        this.setHistoryIdentityStatus({
-          state: 'configuration_error',
-          reason: 'proof_not_admitted',
-        });
-      }
-      if (value === 'ignored') {
-        // The gate-off path must fail before I/O; a 2xx here is a broken server.
-        throw new HistoryClientError(
-          'identity_contract_violation',
-          'Server reported an ignored identity proof on a success response'
-        );
-      }
-      throw new HistoryClientError(
-        'proof_not_admitted',
-        'The response did not acknowledge the identity proof this request sent'
-      );
-    }
-    if (value === 'admitted') {
-      throw new HistoryClientError(
-        'identity_contract_violation',
-        'Server admitted an identity proof that was never sent'
-      );
-    }
-    // "not_provided", a missing header (rolling deploy), or an unknown value:
-    // no verified claim was made either way.
-    if (track) this.setHistoryIdentityStatus(this.browserOnlyStatus());
-  }
-
-  /**
-   * Shared history transport: live session, `sessionId` query param,
-   * `X-Visitor-Token` header, one resolved proof, one-shot 401 recovery, and a
-   * credential-revision guard that discards a response the store outran.
-   */
-  private async historyFetch<T>(
-    path: string,
-    opts: {
-      method: 'GET' | 'POST' | 'PATCH' | 'DELETE';
-      query?: Record<string, string | number | undefined>;
-      scope?: HistoryScope;
-      body?: unknown;
-      /** Reset tolerates a missing credential; every other route requires one. */
-      visitorTokenOptional?: boolean;
-      keepalive?: boolean;
-      /** Transport ops validate the acknowledgement but publish no status. */
-      trackIdentity?: boolean;
-    }
-  ): Promise<T> {
-    this.assertHistoryUsable();
-    const track = opts.trackIdentity !== false;
-    let session = await this.initSession();
-
-    // Resolved once per logical request: a recovery retry reuses the same proof
-    // so one action cannot switch identities midway.
-    let proof: string | null = null;
-    if (this.resolveHistoryScope(opts.scope) === 'verified-user') {
-      proof = await this.resolveIdentityProof(session, track);
-      if (proof) session = await this.bindIdentity(session, proof, track);
-    }
-
-    const store = this.historyInternals.visitorStore;
-    let recovered = false;
-    for (;;) {
-      const capturedRevision = store?.revision() ?? 0;
-      const visitorToken = await this.readVisitorToken();
-      if (!visitorToken && !opts.visitorTokenOptional) {
-        throw new HistoryClientError(
-          'visitor_token_missing',
-          'No visitor credential is stored for this browser'
-        );
-      }
-      const response = await fetch(
-        this.historyUrl(path, { ...opts.query, sessionId: session.sessionId }),
-        {
-          method: opts.method,
-          headers: {
-            'X-Persona-Version': VERSION,
-            ...(visitorToken ? { 'X-Visitor-Token': visitorToken } : {}),
-            ...(proof ? { 'X-Identity-Proof': proof } : {}),
-            ...(opts.body !== undefined ? { 'Content-Type': 'application/json' } : {}),
-          },
-          ...(opts.body !== undefined ? { body: JSON.stringify(opts.body) } : {}),
-          ...(opts.keepalive ? { keepalive: true } : {}),
-        }
-      );
-
-      if (response.status === 401 && !recovered) {
-        recovered = true;
-        session = await this.recoverFromUnauthorized(
-          await this.readErrorCode(response),
-          proof,
-          track
-        );
-        continue;
-      }
-      if (!response.ok) {
-        throw await this.historyErrorFor(response, track);
-      }
-
-      const acknowledgement = response.headers.get('X-History-Identity-Status');
-      const data = (await response.json().catch(() => undefined)) as T;
-      if (store && store.revision() !== capturedRevision) {
-        // Another tab reset or replaced the credential: this body is stale.
-        throw new HistoryClientError(
-          'credential_changed',
-          'The visitor credential changed while the request was in flight'
-        );
-      }
-      this.commitIdentityAcknowledgement(acknowledgement, proof !== null, track);
-      return data;
-    }
+  // Live accessors for the approval / resume requests (`client-resume.ts`,
+  // shipped in the lazy client-stream chunk on the CDN).
+  #resumeHostCache: ClientResumeHost | null = null;
+  #resumeHost(): ClientResumeHost {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const client = this;
+    return (this.#resumeHostCache ??= {
+      get config() {
+        return client.config;
+      },
+      headers: this.#headers,
+      getHeaders: this.#getHeaders,
+      debug: this.debug,
+      clientApiBase: () => client.#clientApiBase(),
+      getClientApiUrl: (endpoint) => client.#getClientApiUrl(endpoint),
+      getWebMcpBridge: () => client.#getWebMcpBridge(),
+      sendWithClientToolsDiff: (sessionId, tools, doFetch, opts) =>
+        client.#sendWithClientToolsDiff(sessionId, tools, doFetch, opts),
+      initSession: () => client.initSession(),
+      readVisitorToken: () => client.readVisitorToken(),
+      isClientTokenMode: () => client.isClientTokenMode(),
+    });
   }
 
-  private assertHistoryUsable(): void {
-    if (!this.isClientTokenMode()) {
-      throw new Error('Conversation history is only available in client token mode');
-    }
-    if (!this.isHistoryCapable()) {
-      throw new HistoryClientError(
-        'history_disabled',
-        'Visitor history is disabled for this surface'
-      );
-    }
+  // Live accessors handed to the lazily loaded history REST functions
+  // (`client-history.ts`); built once per client.
+  #historyHostCache: ClientHistoryHost | null = null;
+  #historyHost(): ClientHistoryHost {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const client = this;
+    return (this.#historyHostCache ??= {
+      HistoryClientError,
+      get config() {
+        return client.config;
+      },
+      get historyInternals() {
+        return client.historyInternals;
+      },
+      get clientSession() {
+        return client.clientSession;
+      },
+      clientApiBase: () => client.#clientApiBase(),
+      setHistoryIdentityStatus: (next) => client.#setHistoryIdentityStatus(next),
+      browserOnlyStatus: () => client.#browserOnlyStatus(),
+      derivedBrowserOnly: () => client.#derivedBrowserOnly(),
+      reinitWithProof: (proof) => client.#reinitWithProof(proof),
+      isHistoryCapable: () => client.#isHistoryCapable(),
+      clearClientSession: () => client.clearClientSession(),
+      initSession: () => client.initSession(),
+      readVisitorToken: () => client.readVisitorToken(),
+      isClientTokenMode: () => client.isClientTokenMode(),
+    });
   }
 
   /** One page of the visitor's conversations, newest first. */
@@ -1709,22 +1343,7 @@ export class AgentWidgetClient {
     targetId?: string;
     scope?: HistoryScope;
   }): Promise<HistoryConversationPage> {
-    const page = await this.historyFetch<{
-      data?: unknown[];
-      nextCursor?: string | null;
-    }>('conversations', {
-      method: 'GET',
-      query: {
-        ...(opts?.cursor ? { cursor: opts.cursor } : {}),
-        ...(opts?.limit !== undefined ? { limit: opts.limit } : {}),
-        ...(opts?.targetId ? { targetId: opts.targetId } : {}),
-      },
-      ...(opts?.scope ? { scope: opts.scope } : {}),
-    });
-    return {
-      data: (Array.isArray(page?.data) ? page.data : []).map(normalizeHistorySummary),
-      nextCursor: typeof page?.nextCursor === 'string' ? page.nextCursor : null,
-    };
+    return (await loadClientHistory()).listConversations(this.#historyHost(), opts);
   }
 
   /**
@@ -1735,26 +1354,7 @@ export class AgentWidgetClient {
     conversationId: string,
     opts?: { messageCursor?: string; scope?: HistoryScope }
   ): Promise<HistoryConversationDetail> {
-    const detail = await this.historyFetch<Record<string, unknown>>(
-      `conversations/${encodeURIComponent(conversationId)}`,
-      {
-        method: 'GET',
-        query: {
-          ...(opts?.messageCursor ? { messageCursor: opts.messageCursor } : {}),
-        },
-        ...(opts?.scope ? { scope: opts.scope } : {}),
-      }
-    );
-    return {
-      summary: normalizeHistorySummary(detail),
-      messages: Array.isArray(detail?.messages)
-        ? (detail.messages as HistoryConversationDetail['messages'])
-        : [],
-      nextMessageCursor:
-        typeof detail?.nextMessageCursor === 'string' ? detail.nextMessageCursor : null,
-      conversationRevision:
-        typeof detail?.conversationRevision === 'string' ? detail.conversationRevision : null,
-    };
+    return (await loadClientHistory()).getConversation(this.#historyHost(), conversationId, opts);
   }
 
   /**
@@ -1766,63 +1366,14 @@ export class AgentWidgetClient {
     conversationId: string,
     messages: HistoryDisplayProjection[]
   ): Promise<{ conversationRevision: string | null }> {
-    this.assertHistoryUsable();
-    let total = 0;
-    for (const message of messages) {
-      const size = message.displayContent.length;
-      if (size > DISPLAY_PROJECTION_MESSAGE_CAP) {
-        throw new HistoryClientError(
-          'payload_too_large',
-          `displayContent exceeds the ${DISPLAY_PROJECTION_MESSAGE_CAP} character limit`
-        );
-      }
-      total += size;
-    }
-    if (total > DISPLAY_PROJECTION_BATCH_CAP) {
-      throw new HistoryClientError(
-        'payload_too_large',
-        `Display projection batch exceeds the ${DISPLAY_PROJECTION_BATCH_CAP} character limit`
-      );
-    }
-
-    await this.initSession();
-    const store = this.historyInternals.visitorStore;
-    const capturedRevision = store?.revision() ?? 0;
-    const result = await this.historyFetch<{ conversationRevision?: string }>(
-      `conversations/${encodeURIComponent(conversationId)}/display-projections`,
-      {
-        method: 'PATCH',
-        body: { messages },
-        scope: 'browser',
-        keepalive: total <= DISPLAY_PROJECTION_BATCH_CAP,
-        trackIdentity: false,
-      }
-    );
-    const conversationRevision =
-      typeof result?.conversationRevision === 'string' ? result.conversationRevision : null;
-    // Install only while the same record and the same credential are still live.
-    if (
-      conversationRevision &&
-      this.clientSession?.conversationId === conversationId &&
-      (store?.revision() ?? 0) === capturedRevision
-    ) {
-      this.historyInternals.setStoredConversationRevision?.(conversationRevision);
-    }
-    return { conversationRevision };
+    return (await loadClientHistory()).finalizeDisplayProjections(this.#historyHost(), conversationId, messages);
   }
 
   public async deleteConversation(
     conversationId: string,
     opts?: { scope?: HistoryScope }
   ): Promise<{ deleted: number }> {
-    const result = await this.historyFetch<{ deleted?: number }>(
-      `conversations/${encodeURIComponent(conversationId)}`,
-      {
-        method: 'DELETE',
-        ...(opts?.scope ? { scope: opts.scope } : {}),
-      }
-    );
-    return { deleted: typeof result?.deleted === 'number' ? result.deleted : 0 };
+    return (await loadClientHistory()).deleteConversation(this.#historyHost(), conversationId, opts);
   }
 
   /**
@@ -1834,14 +1385,7 @@ export class AgentWidgetClient {
     targetId?: string;
     scope?: HistoryScope;
   }): Promise<{ deleted: number }> {
-    const result = await this.historyFetch<{ deleted?: number }>('conversations', {
-      method: 'DELETE',
-      query: {
-        ...(opts?.targetId !== undefined ? { targetId: opts.targetId } : {}),
-      },
-      ...(opts?.scope ? { scope: opts.scope } : {}),
-    });
-    return { deleted: typeof result?.deleted === 'number' ? result.deleted : 0 };
+    return (await loadClientHistory()).deleteAllConversations(this.#historyHost(), opts);
   }
 
   /**
@@ -1850,20 +1394,7 @@ export class AgentWidgetClient {
    * revocation still detaches this device.
    */
   public async resetVisitor(): Promise<{ reset: true }> {
-    this.assertHistoryUsable();
-    this.setHistoryIdentityStatus({ state: 'resetting' });
-    try {
-      await this.historyFetch<{ reset?: boolean }>('visitor/reset', {
-        method: 'POST',
-        scope: 'browser',
-        visitorTokenOptional: true,
-      });
-    } finally {
-      await this.historyInternals.visitorStore?.clear();
-      // Post-reset resting state: this browser is a never-bound visitor again.
-      this.setHistoryIdentityStatus(this.derivedBrowserOnly());
-    }
-    return { reset: true };
+    return (await loadClientHistory()).resetVisitor(this.#historyHost());
   }
 
   /**
@@ -1871,24 +1402,27 @@ export class AgentWidgetClient {
    */
   public async dispatch(options: DispatchOptions, onEvent: SSEHandler) {
     options.signal?.throwIfAborted();
+    // Fetch the stream processor in parallel with the request; a failure here
+    // is retried by the awaited load in #streamResponse.
+    loadClientStream().catch(() => {});
     if (this.isClientTokenMode()) {
-      return this.dispatchClientToken(options, onEvent);
+      return this.#dispatchClientToken(options, onEvent);
     }
     if (this.isAgentMode()) {
-      return this.dispatchAgent(options, onEvent);
+      return this.#dispatchAgent(options, onEvent);
     }
-    return this.dispatchProxy(options, onEvent);
+    return this.#dispatchProxy(options, onEvent);
   }
 
   /**
    * Client token mode dispatch
    */
-  private async dispatchClientToken(options: DispatchOptions, onEvent: SSEHandler) {
+  async #dispatchClientToken(options: DispatchOptions, onEvent: SSEHandler) {
     // Claim the turn before any await: a later dispatch that interrupts this one
     // takes the claim, and every event this call still receives is then stale.
     const turnId = generateTurnId();
-    this.currentClientTurnId = turnId;
-    const isCurrentTurn = () => this.currentClientTurnId === turnId;
+    this.#currentClientTurnId = turnId;
+    const isCurrentTurn = () => this.#currentClientTurnId === turnId;
     // Terminal frames of a superseded run must not reopen the composer or paint
     // into the new turn's bubble; status frames are equally misleading.
     const forward: SSEHandler = (event) => {
@@ -1913,8 +1447,8 @@ export class AgentWidgetClient {
           throw new Error('Renewing this conversation requires its visitor credential.');
         }
         assertCurrentTurn();
-        const renewed = await this.createClientSession({
-          ...(durable || this.isHistoryCapable()
+        const renewed = await this.#createClientSession({
+          ...(durable || this.#isHistoryCapable()
             ? { conversationId: previous.conversationId, durableResume: durable }
             : { storedSessionId: previous.sessionId }),
           signal: options.signal,
@@ -1926,9 +1460,9 @@ export class AgentWidgetClient {
         ) {
           throw new Error('Session renewal did not preserve this conversation.');
         }
-        session = this.finishInit(renewed, previous.conversationId ?? null, false);
+        session = this.#finishInit(renewed, previous.conversationId ?? null, false);
         this.clientSession = session;
-        this.sessionWarmLatch = false;
+        this.#sessionWarmLatch = false;
         this.resetClientToolsFingerprint();
         this.config.onSessionInit?.(session);
       };
@@ -1937,7 +1471,7 @@ export class AgentWidgetClient {
       }
 
       // Build the standard payload to get context/metadata from middleware
-      const basePayload = await this.buildPayload(options.messages);
+      const basePayload = await this.#buildPayload(options.messages);
 
       // Build the chat request payload with message IDs for feedback tracking
       // Filter out sessionId from metadata if present (it's only for local storage)
@@ -1948,7 +1482,7 @@ export class AgentWidgetClient {
         : undefined;
       
       // Common (tools-independent) fields for the chat request.
-      const historyCapable = this.isHistoryCapable();
+      const historyCapable = this.#isHistoryCapable();
       const baseChatRequest: Omit<ClientChatRequest, 'clientTools' | 'clientToolsFingerprint'> = {
         sessionId: session.sessionId,
         // Filter out messages with empty content to prevent validation errors
@@ -1988,9 +1522,9 @@ export class AgentWidgetClient {
         const recoveryVisitorToken =
           session.durableRecovery?.enabled === true ? await this.readVisitorToken() : null;
         assertCurrentTurn();
-        return this.sendWithClientToolsDiff(session.sessionId, basePayload.clientTools, async (toolFields) => {
+        return this.#sendWithClientToolsDiff(session.sessionId, basePayload.clientTools, async (toolFields) => {
           assertCurrentTurn();
-          const identityProof = await this.resolveChatIdentityProof(options.signal);
+          const identityProof = await this.#resolveChatIdentityProof(options.signal);
           assertCurrentTurn();
           const chatRequest: ClientChatRequest = {
             ...baseChatRequest,
@@ -2007,7 +1541,7 @@ export class AgentWidgetClient {
             });
           }
 
-          return fetch(this.getClientApiUrl('chat'), {
+          return fetch(this.#getClientApiUrl('chat'), {
             method: 'POST',
             headers: {
               'Content-Type': 'application/json',
@@ -2090,7 +1624,7 @@ export class AgentWidgetClient {
 
       // Stream the response (same SSE handling as proxy mode)
       try {
-        await this.streamResponse(response.body, forward, options.assistantMessageId);
+        await this.#streamResponse(response.body, forward, options.assistantMessageId);
       } finally {
         forward({ type: "status", status: "idle" });
       }
@@ -2111,10 +1645,10 @@ export class AgentWidgetClient {
   /**
    * Proxy mode dispatch (original implementation)
    */
-  private async dispatchProxy(options: DispatchOptions, onEvent: SSEHandler) {
+  async #dispatchProxy(options: DispatchOptions, onEvent: SSEHandler) {
     onEvent({ type: "status", status: "connecting" });
 
-    const payload = await this.buildPayload(
+    const payload = await this.#buildPayload(
       options.messages,
       options.composerOptions
     );
@@ -2125,10 +1659,10 @@ export class AgentWidgetClient {
     }
 
     // Build headers - merge static headers with dynamic headers if provided
-    let headers = { ...this.headers };
-    if (this.getHeaders) {
+    let headers = { ...this.#headers };
+    if (this.#getHeaders) {
       try {
-        const dynamicHeaders = await this.getHeaders();
+        const dynamicHeaders = await this.#getHeaders();
         headers = { ...headers, ...dynamicHeaders };
       } catch (error) {
         if (typeof console !== "undefined") {
@@ -2140,10 +1674,10 @@ export class AgentWidgetClient {
 
     // Use customFetch if provided, otherwise use default fetch
     let response: Response;
-    if (this.customFetch) {
+    if (this.#customFetch) {
       try {
-        response = await this.customFetch(
-          this.apiUrl,
+        response = await this.#customFetch(
+          this.#apiUrl,
           {
             method: "POST",
             headers,
@@ -2158,7 +1692,7 @@ export class AgentWidgetClient {
         throw err;
       }
     } else {
-      response = await fetch(this.apiUrl, {
+      response = await fetch(this.#apiUrl, {
         method: "POST",
         headers,
         body: JSON.stringify(payload),
@@ -2176,7 +1710,7 @@ export class AgentWidgetClient {
 
     onEvent({ type: "status", status: "connected" });
     try {
-      await this.streamResponse(response.body, onEvent);
+      await this.#streamResponse(response.body, onEvent);
     } finally {
       onEvent({ type: "status", status: "idle" });
     }
@@ -2185,10 +1719,10 @@ export class AgentWidgetClient {
   /**
    * Agent mode dispatch
    */
-  private async dispatchAgent(options: DispatchOptions, onEvent: SSEHandler) {
+  async #dispatchAgent(options: DispatchOptions, onEvent: SSEHandler) {
     onEvent({ type: "status", status: "connecting" });
 
-    const payload = await this.buildAgentPayload(
+    const payload = await this.#buildAgentPayload(
       options.messages,
       options.composerOptions
     );
@@ -2199,10 +1733,10 @@ export class AgentWidgetClient {
     }
 
     // Build headers - merge static headers with dynamic headers if provided
-    let headers = { ...this.headers };
-    if (this.getHeaders) {
+    let headers = { ...this.#headers };
+    if (this.#getHeaders) {
       try {
-        const dynamicHeaders = await this.getHeaders();
+        const dynamicHeaders = await this.#getHeaders();
         headers = { ...headers, ...dynamicHeaders };
       } catch (error) {
         if (typeof console !== "undefined") {
@@ -2214,10 +1748,10 @@ export class AgentWidgetClient {
 
     // Use customFetch if provided, otherwise use default fetch
     let response: Response;
-    if (this.customFetch) {
+    if (this.#customFetch) {
       try {
-        response = await this.customFetch(
-          this.apiUrl,
+        response = await this.#customFetch(
+          this.#apiUrl,
           {
             method: "POST",
             headers,
@@ -2232,7 +1766,7 @@ export class AgentWidgetClient {
         throw err;
       }
     } else {
-      response = await fetch(this.apiUrl, {
+      response = await fetch(this.#apiUrl, {
         method: "POST",
         headers,
         body: JSON.stringify(payload),
@@ -2250,7 +1784,7 @@ export class AgentWidgetClient {
 
     onEvent({ type: "status", status: "connected" });
     try {
-      await this.streamResponse(response.body, onEvent, options.assistantMessageId);
+      await this.#streamResponse(response.body, onEvent, options.assistantMessageId);
     } finally {
       onEvent({ type: "status", status: "idle" });
     }
@@ -2269,7 +1803,7 @@ export class AgentWidgetClient {
   ): Promise<void> {
     onEvent({ type: "status", status: "connected" });
     try {
-      await this.streamResponse(body, onEvent, assistantMessageId, seedContent);
+      await this.#streamResponse(body, onEvent, assistantMessageId, seedContent);
     } finally {
       onEvent({ type: "status", status: "idle" });
     }
@@ -2278,31 +1812,20 @@ export class AgentWidgetClient {
   /**
    * Send an approval decision to the API and return the response
    * for streaming continuation.
+   *
+   * Routes by mode:
+   *  - **client-token mode**: POST `${apiBase}/v1/client/approve` with the
+   *    active `sessionId` and no Bearer key (runtypelabs/core#9518). Answers a
+   *    gate authored `tools.approval.approver: 'end-user'`; the SSE body has
+   *    the same shape as `/v1/client/resume`.
+   *  - **dispatch / proxy mode**: POST `${apiBase}/v1/agents/{agentId}/approve`
+   *    with the host's headers.
    */
   public async resolveApproval(
     approval: { agentId: string; executionId: string; approvalId: string },
     decision: 'approved' | 'denied'
   ): Promise<Response> {
-    const url = `${this.clientApiBase()}/v1/agents/${approval.agentId}/approve`;
-
-    let headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-      ...this.headers
-    };
-    if (this.getHeaders) {
-      Object.assign(headers, await this.getHeaders());
-    }
-
-    return fetch(url, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({
-        executionId: approval.executionId,
-        approvalId: approval.approvalId,
-        decision,
-        streamResponse: true,
-      }),
-    });
+    return (await loadClientStream()).resolveApproval(this.#resumeHost(), approval, decision);
   }
 
   /**
@@ -2364,7 +1887,7 @@ export class AgentWidgetClient {
    * tools this turn", whereas on `/resume` absence means "keep the frozen
    * dispatch-time set".
    */
-  private async sendWithClientToolsDiff(
+  async #sendWithClientToolsDiff(
     sessionId: string,
     fullClientTools: ClientToolDefinition[] | undefined,
     doFetch: (
@@ -2388,7 +1911,7 @@ export class AgentWidgetClient {
     const sendEmptyReplace =
       !hasClientTools &&
       opts?.emptyMeansReplace === true &&
-      this.sentNonEmptyClientToolsSessionId === sessionId;
+      this.#sentNonEmptyClientToolsSessionId === sessionId;
 
     // `forceFull` flips to true after a 409 cache-miss so the single retry
     // resends the full list.
@@ -2427,11 +1950,11 @@ export class AgentWidgetClient {
         this.lastSentClientToolsFingerprint = clientToolsFingerprint ?? null;
         this.clientToolsFingerprintSessionId = sessionId;
         if (hasClientTools) {
-          this.sentNonEmptyClientToolsSessionId = sessionId;
+          this.#sentNonEmptyClientToolsSessionId = sessionId;
         } else if (sendEmptyReplace) {
           // The explicit [] replaced the persisted set server-side; the
           // pending clear is done.
-          this.sentNonEmptyClientToolsSessionId = null;
+          this.#sentNonEmptyClientToolsSessionId = null;
         }
         // Omitted-empty commits (chat with zero tools) leave the flag set:
         // they don't touch tools persisted for a paused execution.
@@ -2444,95 +1967,7 @@ export class AgentWidgetClient {
     toolOutputs: Record<string, unknown>,
     options?: { streamResponse?: boolean; signal?: AbortSignal; after?: string }
   ): Promise<Response> {
-    const isClientToken = this.isClientTokenMode();
-    const url = isClientToken
-      ? this.getClientApiUrl('resume')
-      : `${this.config.apiUrl?.replace(/\/+$/, '') || DEFAULT_CLIENT_API_BASE}/resume`;
-
-    // The client-token resume route authenticates the session, not a Bearer
-    // key. A WebMCP approval can sit awaiting user input for a long time, so by
-    // the time we resume the original session may have expired. Re-validate (and
-    // silently re-init if needed) via initSession(): which returns the live
-    // session when `new Date() < expiresAt`, else mints a fresh one: instead of
-    // trusting the possibly-stale `this.clientSession`. (core#3889; BugBot
-    // PR #214 r3367875360.)
-    let resumeSessionId: string | undefined;
-    let resumeVisitorToken: string | null = null;
-    if (isClientToken) {
-      const session = await this.initSession();
-      resumeSessionId = session.sessionId;
-      if (session.durableRecovery?.enabled === true) {
-        resumeVisitorToken = await this.readVisitorToken();
-      }
-    }
-
-    let headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-      ...(resumeVisitorToken ? { 'X-Visitor-Token': resumeVisitorToken } : {}),
-      ...this.headers
-    };
-    if (this.getHeaders) {
-      Object.assign(headers, await this.getHeaders());
-    }
-
-    const body: Record<string, unknown> = {
-      executionId,
-      toolOutputs,
-      streamResponse: options?.streamResponse ?? true,
-      ...(options?.after ? { after: options.after } : {}),
-    };
-    // Thread the (refreshed) sessionId through like `/v1/client/chat` does.
-    if (resumeSessionId) {
-      body.sessionId = resumeSessionId;
-    }
-
-    if (isClientToken && resumeSessionId) {
-      // Mid-run WebMCP tool refresh (runtypelabs/core#5361): the paused tool
-      // may have navigated the page, so the dispatch-time snapshot the server
-      // persisted can be stale. Re-snapshot the registry — the same built-in +
-      // bridge composition as the payload builders, so fingerprints computed
-      // here and on chat turns describe the same tool space — and ship it via
-      // the shared diff-only protocol. `emptyMeansReplace` sends an explicit
-      // `clientTools: []` when the registry vanished after a non-empty send,
-      // so the server replaces the persisted set instead of keeping it frozen.
-      const fullClientTools = [
-        ...builtInClientToolsForDispatch(this.config),
-        ...((await (await this.getWebMcpBridge())?.snapshotForDispatch()) ?? []),
-      ];
-      const { response, commit } = await this.sendWithClientToolsDiff(
-        resumeSessionId,
-        fullClientTools,
-        (toolFields) => {
-          const resumeRequest = { ...body, ...toolFields };
-          if (this.debug) {
-            // eslint-disable-next-line no-console
-            console.debug("[AgentWidgetClient] client token resume", resumeRequest);
-          }
-          return fetch(url, {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(resumeRequest),
-            signal: options?.signal,
-          });
-        },
-        { emptyMeansReplace: true }
-      );
-      // The server stores the refreshed registry before running the
-      // continuation pipeline, so an OK response means it holds this set under
-      // this fingerprint. Mirror chat's commit-on-success discipline: a failed
-      // resume must not record a fingerprint the server never stored.
-      if (response.ok) {
-        commit();
-      }
-      return response;
-    }
-
-    return fetch(url, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(body),
-      signal: options?.signal,
-    });
+    return (await loadClientStream()).resumeFlow(this.#resumeHost(), executionId, toolOutputs, options);
   }
 
   /**
@@ -2544,7 +1979,7 @@ export class AgentWidgetClient {
    * The default model-visible path (`llmAppend`) already rode into the message's
    * `llmContent`/`contentParts`, so it needs nothing here.
    */
-  private latestMentionContext(
+  #latestMentionContext(
     messages: AgentWidgetMessage[]
   ): Record<string, unknown> | null {
     for (let i = messages.length - 1; i >= 0; i--) {
@@ -2566,13 +2001,13 @@ export class AgentWidgetClient {
    * contributed, so callers can skip setting `payload.context`. Shared by the
    * agent and flow payload builders.
    */
-  private async buildContextAggregate(
+  async #buildContextAggregate(
     messages: AgentWidgetMessage[]
   ): Promise<Record<string, unknown> | null> {
     const contextAggregate: Record<string, unknown> = {};
-    if (this.contextProviders.length) {
+    if (this.#contextProviders.length) {
       await Promise.all(
-        this.contextProviders.map(async (provider) => {
+        this.#contextProviders.map(async (provider) => {
           try {
             const result = await provider({
               messages,
@@ -2590,7 +2025,7 @@ export class AgentWidgetClient {
         })
       );
     }
-    const mentionContext = this.latestMentionContext(messages);
+    const mentionContext = this.#latestMentionContext(messages);
     if (mentionContext) Object.assign(contextAggregate, mentionContext);
     return Object.keys(contextAggregate).length ? contextAggregate : null;
   }
@@ -2600,7 +2035,7 @@ export class AgentWidgetClient {
    * the wire entirely, so a widget with no picker and no modes sends exactly
    * what it sent before.
    */
-  private normalizeComposerOptions(
+  #normalizeComposerOptions(
     options: ComposerOptionsPayload | undefined
   ): ComposerOptionsPayload | undefined {
     if (!options) return undefined;
@@ -2617,7 +2052,7 @@ export class AgentWidgetClient {
    * composer, but only for an id the host actually declared in
    * `composer.models`. Config is untouched; the mapping is per request.
    */
-  private applyInlineAgentModel(
+  #applyInlineAgentModel(
     agent: AgentWidgetAgentRequestPayload["agent"],
     composerOptions: ComposerOptionsPayload | undefined
   ): AgentWidgetAgentRequestPayload["agent"] {
@@ -2629,11 +2064,11 @@ export class AgentWidgetClient {
     return declared ? { ...agent, model: selected } : agent;
   }
 
-  private async buildAgentPayload(
+  async #buildAgentPayload(
     messages: AgentWidgetMessage[],
     composerOptions?: ComposerOptionsPayload
   ): Promise<AgentWidgetAgentRequestPayload> {
-    const routedAgentId = this.routing().agentId;
+    const routedAgentId = this.#routing().agentId;
     if (!this.config.agent && !routedAgentId) {
       throw new Error('Agent configuration required for agent mode');
     }
@@ -2650,9 +2085,9 @@ export class AgentWidgetClient {
           : null
     );
 
-    const composer = this.normalizeComposerOptions(composerOptions);
+    const composer = this.#normalizeComposerOptions(composerOptions);
     const payload: AgentWidgetAgentRequestPayload = {
-      agent: this.applyInlineAgentModel(
+      agent: this.#applyInlineAgentModel(
         this.config.agent ?? { agentId: routedAgentId! },
         composer
       ),
@@ -2673,20 +2108,20 @@ export class AgentWidgetClient {
     // so dispatch microtask timing is unchanged.
     const clientTools = [
       ...builtInClientToolsForDispatch(this.config),
-      ...((await (await this.getWebMcpBridge())?.snapshotForDispatch()) ?? []),
+      ...((await (await this.#getWebMcpBridge())?.snapshotForDispatch()) ?? []),
     ];
     if (clientTools.length > 0) {
       payload.clientTools = clientTools;
     }
 
     // Add context from providers + opt-in mention context.
-    const contextAggregate = await this.buildContextAggregate(messages);
+    const contextAggregate = await this.#buildContextAggregate(messages);
     if (contextAggregate) payload.context = contextAggregate;
 
     return payload;
   }
 
-  private async buildPayload(
+  async #buildPayload(
     messages: AgentWidgetMessage[],
     composerOptions?: ComposerOptionsPayload
   ): Promise<AgentWidgetRequestPayload> {
@@ -2699,7 +2134,7 @@ export class AgentWidgetClient {
       (message) => (hasValidContent(message) ? toPayloadMessage(message) : null)
     );
 
-    const routed = this.routing();
+    const routed = this.#routing();
     const payload: AgentWidgetRequestPayload = {
       messages: normalizedMessages,
       ...(routed.agentId
@@ -2724,24 +2159,24 @@ export class AgentWidgetClient {
     // (flow-dispatch path).
     const clientTools = [
       ...builtInClientToolsForDispatch(this.config),
-      ...((await (await this.getWebMcpBridge())?.snapshotForDispatch()) ?? []),
+      ...((await (await this.#getWebMcpBridge())?.snapshotForDispatch()) ?? []),
     ];
     if (clientTools.length > 0) {
       payload.clientTools = clientTools;
     }
 
-    const contextAggregate = await this.buildContextAggregate(messages);
+    const contextAggregate = await this.#buildContextAggregate(messages);
     if (contextAggregate) payload.context = contextAggregate;
 
     // Its own field, never folded into `context`: a value in generic context
     // does not change inference, and each transport must decide explicitly.
     // Set before the middleware runs so hosts can read, rewrite, or drop it.
-    const composer = this.normalizeComposerOptions(composerOptions);
+    const composer = this.#normalizeComposerOptions(composerOptions);
     if (composer) payload.composerOptions = composer;
 
-    if (this.requestMiddleware) {
+    if (this.#requestMiddleware) {
       try {
-        const result = await this.requestMiddleware({
+        const result = await this.#requestMiddleware({
           payload: { ...payload },
           config: this.config
         });
@@ -2774,1773 +2209,24 @@ export class AgentWidgetClient {
     return payload;
   }
 
-  /**
-   * Handle custom SSE event parsing via parseSSEEvent callback
-   * Returns true if event was handled, false otherwise
-   */
-  private async handleCustomSSEEvent(
-    payload: unknown,
-    onEvent: SSEHandler,
-    assistantMessageRef: { current: AgentWidgetMessage | null },
-    emitMessage: (msg: AgentWidgetMessage) => void,
-    nextSequence: () => number,
-    partIdState: { current: string | null }
-  ): Promise<boolean> {
-    if (!this.parseSSEEvent) return false;
-
-    try {
-      const result = await this.parseSSEEvent(payload);
-      if (result === null) return false; // Event should be ignored
-
-      const createNewAssistant = (partId?: string): AgentWidgetMessage => {
-        const msg: AgentWidgetMessage = {
-          id: `assistant-${Date.now()}-${Math.random().toString(16).slice(2)}`,
-          role: "assistant",
-          content: "",
-          createdAt: new Date().toISOString(),
-          streaming: true,
-          variant: "assistant",
-          sequence: nextSequence(),
-          ...(partId !== undefined && { partId })
-        };
-        assistantMessageRef.current = msg;
-        emitMessage(msg);
-        return msg;
-      };
-
-      const ensureAssistant = (partId?: string) => {
-        if (assistantMessageRef.current) return assistantMessageRef.current;
-        return createNewAssistant(partId);
-      };
-
-      if (result.text !== undefined) {
-        // partId-based message segmentation: when partId changes, seal current
-        // message and start a new one for chronological tool/text interleaving
-        if (result.partId !== undefined && partIdState.current !== null && result.partId !== partIdState.current) {
-          // Seal the current assistant message
-          if (assistantMessageRef.current) {
-            assistantMessageRef.current.streaming = false;
-            emitMessage(assistantMessageRef.current);
-          }
-          // Create a new assistant message for the new text segment
-          createNewAssistant(result.partId);
-        }
-
-        // Update partId tracking (only when partId is provided: backward compatible)
-        if (result.partId !== undefined) {
-          partIdState.current = result.partId;
-        }
-
-        const assistant = ensureAssistant(result.partId);
-        // Tag the message with partId if present and not already set
-        if (result.partId !== undefined && !assistant.partId) {
-          assistant.partId = result.partId;
-        }
-        assistant.content += result.text;
-        emitMessage(assistant);
-      }
-
-      if (result.done) {
-        if (assistantMessageRef.current) {
-          assistantMessageRef.current.streaming = false;
-          emitMessage(assistantMessageRef.current);
-        }
-        partIdState.current = null;
-        onEvent({ type: "status", status: "idle" });
-      }
-
-      if (result.error) {
-        partIdState.current = null;
-        onEvent({
-          type: "error",
-          error: new Error(result.error)
-        });
-      }
-
-      return true; // Event was handled
-    } catch (error) {
-      if (typeof console !== "undefined") {
-        // eslint-disable-next-line no-console
-        console.error("[AgentWidget] parseSSEEvent error:", error);
-      }
-      return false;
-    }
-  }
-
-  private async streamResponse(
+  async #streamResponse(
     body: ReadableStream<Uint8Array>,
     onEvent: SSEHandler,
     assistantMessageId?: string,
-    // Durable reconnect: seed the assistant accumulator with the text already
-    // shown before the drop, so replayed post-cursor deltas APPEND to it
-    // instead of a fresh stream clobbering it (the replay carries only
-    // `seq > after`, i.e. the new deltas, not the full text).
     seedContent?: string
   ) {
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-
-    const baseSequence = Date.now();
-    let sequenceCounter = 0;
-    const nextSequence = () => baseSequence + sequenceCounter++;
-
-    const cloneMessage = (msg: AgentWidgetMessage): AgentWidgetMessage => {
-      const reasoning = msg.reasoning
-        ? {
-            ...msg.reasoning,
-            chunks: [...msg.reasoning.chunks]
-          }
-        : undefined;
-      const toolCall = msg.toolCall
-        ? {
-            ...msg.toolCall,
-            chunks: msg.toolCall.chunks ? [...msg.toolCall.chunks] : undefined
-          }
-        : undefined;
-      const tools = msg.tools
-        ? msg.tools.map((tool) => ({
-            ...tool,
-            chunks: tool.chunks ? [...tool.chunks] : undefined
-          }))
-        : undefined;
-
-      return {
-        ...msg,
-        reasoning,
-        toolCall,
-        tools
-      };
-    };
-
-    const shouldEmitMessage = (msg: AgentWidgetMessage): boolean => {
-      if (msg.role !== "assistant" || msg.variant) return true;
-
-      const hasContentParts =
-        Array.isArray(msg.contentParts) && msg.contentParts.length > 0;
-      const hasRawContent =
-        typeof msg.rawContent === "string" && msg.rawContent.trim() !== "";
-      const hasVisibleText =
-        typeof msg.content === "string" && msg.content.trim() !== "";
-
-      // Do not surface assistant text bubbles that only contain whitespace.
-      // Some providers emit newline-only text parts around a leading tool call;
-      // rendering those as normal messages creates an empty bubble above the
-      // tool card. Keep media/component/stop-reason messages renderable.
-      return hasVisibleText || hasContentParts || hasRawContent || Boolean(msg.stopReason);
-    };
-
-    const emitMessage = (msg: AgentWidgetMessage) => {
-      if (!shouldEmitMessage(msg)) return;
-      onEvent({
-        type: "message",
-        message: cloneMessage(msg)
-      });
-    };
-
-    let assistantMessage: AgentWidgetMessage | null = null;
-    // Tracks the most recently touched assistant text message for the
-    // current agent turn so `turn_complete.stopReason` can attach
-    // to the final visible text segment even after `assistantMessage`
-    // has been finalized at a tool-call boundary within the turn.
-    let lastAssistantInTurn: AgentWidgetMessage | null = null;
-    // Reference to track assistant message for custom event handler
-    const assistantMessageRef = { current: null as AgentWidgetMessage | null };
-    // Segmentation state for the `parseSSEEvent` extensibility callback (the
-    // consumer's own `partId` field) — independent of the wire.
-    const customParsePartId = { current: null as string | null };
-    // Unified text-channel block id (from `text_start`/`text_delta` `id`). Drives
-    // bubble-id segmentation on the wire in place of the legacy `partId`:
-    // a new block id means a new bubble, sealed at `text_complete`/tool boundaries.
-    let currentTextBlockId: string | null = null;
-    // Raw text accumulated for the open text block, on both the flow and agent
-    // paths — lets a whitespace-only flow block resolve without a stray bubble,
-    // and gives the structured-content parser the whole block on either path.
-    let pendingTextRaw = "";
-    // Nested flow-as-tool attribution (PR #4602): a text/reasoning block whose
-    // `parentToolCallId` matches a `tool_start.toolCallId` belongs to a flow
-    // running as that tool. Keyed by the wire block id, these route the block's
-    // deltas into a message tagged `agentMetadata.parentToolId` (the parent tool's
-    // row) instead of the top-level assistant/reasoning channel.
-    const nestedBlockParent = new Map<string, string>();
-    const nestedBlockMessages = new Map<string, AgentWidgetMessage>();
-    const nestedBlockRaw = new Map<string, string>();
-    const reasoningMessages = new Map<string, AgentWidgetMessage>();
-    const toolMessages = new Map<string, AgentWidgetMessage>();
-    const baseAssistantId = assistantMessageId;
-    let assistantIdConsumed = false;
-
-    const ensureAssistantMessage = () => {
-      if (assistantMessage) return assistantMessage;
-      let id: string;
-      let initialContent = "";
-      const segment = currentTextBlockId;
-      if (!assistantIdConsumed && baseAssistantId) {
-        id = baseAssistantId;
-        assistantIdConsumed = true;
-        // First (and only) time we reuse the caller-supplied id: this is the
-        // bubble a durable reconnect resumes into, so continue its text.
-        initialContent = seedContent ?? "";
-      } else if (baseAssistantId && segment) {
-        id = `${baseAssistantId}_${segment}`;
-      } else {
-        id = `assistant-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-      }
-      assistantMessage = {
-        id,
-        role: "assistant",
-        content: initialContent,
-        createdAt: new Date().toISOString(),
-        streaming: true,
-        sequence: nextSequence()
-      };
-      emitMessage(assistantMessage);
-      return assistantMessage;
-    };
-
-    const ensureReasoningMessage = (reasoningId: string) => {
-      const existing = reasoningMessages.get(reasoningId);
-      if (existing) {
-        return existing;
-      }
-
-      const message: AgentWidgetMessage = {
-        id: `reason-${reasoningId}`,
-        role: "assistant",
-        content: "",
-        createdAt: new Date().toISOString(),
-        streaming: true,
-        variant: "reasoning",
-        sequence: nextSequence(),
-        reasoning: {
-          id: reasoningId,
-          status: "streaming",
-          chunks: []
-        }
-      };
-
-      reasoningMessages.set(reasoningId, message);
-      emitMessage(message);
-      return message;
-    };
-
-    // Track tool call IDs for artifact emit tools so we can suppress their UI
-    const artifactToolCallIds = new Set<string>();
-    // Track artifact block messages (reference card or inline block) so we can
-    // update them on artifact_complete
-    const artifactCardMessages = new Map<string, AgentWidgetMessage>();
-    // Track artifact IDs that already have a reference card
-    const artifactIdsWithCards = new Set<string>();
-    // Accumulate artifact markdown content (and component props) for embedding
-    // in block props on complete. `props` accumulates across `artifact_update`
-    // events so an inline component block hydrates with its real props after a
-    // refresh (the session artifact registry, which also tracks them live, is
-    // not persisted).
-    const artifactContent = new Map<
-      string,
+    const { streamResponse } = getClientStreamSync() ?? (await loadClientStream());
+    return streamResponse(
       {
-        markdown: string;
-        title?: string;
-        file?: PersonaArtifactFileMeta;
-        props?: Record<string, unknown>;
-      }
-    >();
-    const isArtifactEmitToolName = (name: string | undefined): boolean => {
-      if (!name) return false;
-      const normalized = name.replace(/_+/g, "_").replace(/^_|_$/g, "");
-      return normalized === "emit_artifact_markdown" || normalized === "emit_artifact_component";
-    };
-
-    const ensureToolMessage = (toolId: string) => {
-      const existing = toolMessages.get(toolId);
-      if (existing) {
-        return existing;
-      }
-
-      const message: AgentWidgetMessage = {
-        id: `tool-${toolId}`,
-        role: "assistant",
-        content: "",
-        createdAt: new Date().toISOString(),
-        streaming: true,
-        variant: "tool",
-        sequence: nextSequence(),
-        toolCall: {
-          id: toolId,
-          status: "pending"
-        }
-      };
-
-      toolMessages.set(toolId, message);
-      emitMessage(message);
-      return message;
-    };
-
-    const resolveTimestamp = (value: unknown) => {
-      if (typeof value === "number" && Number.isFinite(value)) {
-        return value;
-      }
-      if (typeof value === "string") {
-        const parsed = Number(value);
-        if (!Number.isNaN(parsed) && Number.isFinite(parsed)) {
-          return parsed;
-        }
-        const dateParsed = Date.parse(value);
-        if (!Number.isNaN(dateParsed)) {
-          return dateParsed;
-        }
-      }
-      return Date.now();
-    };
-
-    const ensureStringContent = (value: unknown): string => {
-      if (typeof value === "string") {
-        return value;
-      }
-      if (value === null || value === undefined) {
-        return "";
-      }
-      // Convert objects/arrays to JSON string
-      try {
-        return JSON.stringify(value);
-      } catch {
-        return String(value);
-      }
-    };
-
-    // Maintain stateful stream parsers per message for incremental parsing
-    const streamParsers = new Map<string, AgentWidgetStreamParser>();
-    // Track accumulated raw content for structured formats (JSON, XML, etc.)
-    const rawContentBuffers = new Map<string, string>();
-    /** Reconcile a sealed text block with its authoritative structured response. */
-    const reconcileSealedAssistantWithFinalResponse = (
-      msg: AgentWidgetMessage,
-      finalContent: unknown
-    ) => {
-      const finalString = ensureStringContent(finalContent);
-      const rawBuffer = rawContentBuffers.get(msg.id);
-      const contentToProcess = preferFinalStructuredContent(rawBuffer, finalString);
-      msg.rawContent = contentToProcess;
-      const parser = streamParsers.get(msg.id);
-
-      const mergeIfBetter = (mergedDisplay: string) => {
-        const cur = msg.content ?? "";
-        if (mergedDisplay.trim() === "") return;
-        // Only replace when empty, or when the stream left a strict prefix of the
-        // authoritative final (truncation). Do not use length alone: multi-segment
-        // flows can have a short last bubble whose content is not a prefix of the
-        // full step response.
-        if (
-          cur.trim().length === 0 ||
-          mergedDisplay.startsWith(cur) ||
-          mergedDisplay.trimStart().startsWith(cur.trim())
-        ) {
-          msg.content = mergedDisplay;
-        }
-      };
-
-      const finalizeCleanup = () => {
-        if (parser) {
-          const closeResult = parser.close?.();
-          if (closeResult instanceof Promise) closeResult.catch(() => {});
-        }
-        streamParsers.delete(msg.id);
-        rawContentBuffers.delete(msg.id);
-        msg.streaming = false;
-        emitMessage(msg);
-      };
-
-      if (!parser) {
-        mergeIfBetter(finalString);
-        finalizeCleanup();
-        return;
-      }
-
-      // Prefer JSON fast path when the final payload is JSON-shaped
-      const extractedFromJson = extractTextFromJson(contentToProcess);
-      if (extractedFromJson !== null && extractedFromJson.trim() !== "") {
-        mergeIfBetter(extractedFromJson);
-        finalizeCleanup();
-        return;
-      }
-
-      const bestDisplayText = (
-        result: AgentWidgetStreamParserResult | string | null
-      ): string => {
-        const text =
-          typeof result === "string" ? result : result?.text ?? null;
-        if (text !== null && text.trim() !== "") return text;
-        const extracted = parser.getExtractedText();
-        if (extracted !== null && extracted.trim() !== "") return extracted;
-        return finalString;
-      };
-
-      let parsedResult: ReturnType<typeof parser.processChunk>;
-      try {
-        parsedResult = parser.processChunk(contentToProcess);
-      } catch {
-        mergeIfBetter(finalString);
-        finalizeCleanup();
-        return;
-      }
-
-      if (parsedResult instanceof Promise) {
-        parsedResult
-          .then((result) => {
-            mergeIfBetter(bestDisplayText(result));
-            finalizeCleanup();
-          })
-          .catch(() => {
-            mergeIfBetter(finalString);
-            finalizeCleanup();
-          });
-        return;
-      }
-
-      mergeIfBetter(bestDisplayText(parsedResult));
-      finalizeCleanup();
-    };
-
-    // === Unified text channel ===
-    // Prompt-step and agent text both stream as `text_delta` blocks (segmented by
-    // `text_start`/`text_complete`) and can be structured JSON, so each block runs
-    // through the per-bubble structured-content parser. This is the legacy
-    // step_delta parser core, re-keyed from `partId` to the wire block-id bubble.
-    // The caller materializes the bubble lazily (whitespace-only blocks around
-    // tool boundaries never leave a stray bubble) and `step_complete.result.response`
-    // reconciles the authoritative final.
-    let lastSealedFlowBubble: AgentWidgetMessage | null = null;
-
-    // Stream one accumulated chunk of block text through the parser, setting
-    // display `content` (extracted) + `rawContent` (raw) and emitting. Mirrors the
-    // legacy step_delta chunk path; plain text bypasses the structured parser.
-    const applyTextChunk = (
-      assistant: AgentWidgetMessage,
-      accumulatedRaw: string,
-      chunk: string,
-      chunkSeq: number | undefined
-    ) => {
-      assistant.rawContent = accumulatedRaw;
-      if (!streamParsers.has(assistant.id)) {
-        streamParsers.set(assistant.id, this.createStreamParser());
-      }
-      const parser = streamParsers.get(assistant.id)!;
-      const looksLikeJson =
-        accumulatedRaw.trim().startsWith("{") || accumulatedRaw.trim().startsWith("[");
-      if (looksLikeJson) {
-        rawContentBuffers.set(assistant.id, accumulatedRaw);
-      }
-      const isPlainTextParser = (parser as any).__isPlainTextParser === true;
-      if (isPlainTextParser) {
-        assistant.content =
-          chunkSeq !== undefined ? accumulatedRaw : assistant.content + chunk;
-        rawContentBuffers.delete(assistant.id);
-        streamParsers.delete(assistant.id);
-        assistant.rawContent = undefined;
-        emitMessage(assistant);
-        return;
-      }
-      const parsedResult = parser.processChunk(accumulatedRaw);
-      if (parsedResult instanceof Promise) {
-        parsedResult
-          .then((result) => {
-            const text = typeof result === "string" ? result : result?.text ?? null;
-            if (text !== null && text.trim() !== "") {
-              assistant.content = text;
-              emitMessage(assistant);
-            } else if (!looksLikeJson && !accumulatedRaw.trim().startsWith("<")) {
-              assistant.content =
-                chunkSeq !== undefined ? accumulatedRaw : assistant.content + chunk;
-              rawContentBuffers.delete(assistant.id);
-              streamParsers.delete(assistant.id);
-              assistant.rawContent = undefined;
-              emitMessage(assistant);
-            }
-          })
-          .catch(() => {
-            assistant.content =
-              chunkSeq !== undefined ? accumulatedRaw : assistant.content + chunk;
-            rawContentBuffers.delete(assistant.id);
-            streamParsers.delete(assistant.id);
-            assistant.rawContent = undefined;
-            emitMessage(assistant);
-          });
-      } else {
-        const text =
-          typeof parsedResult === "string" ? parsedResult : parsedResult?.text ?? null;
-        if (text !== null && text.trim() !== "") {
-          assistant.content = text;
-          emitMessage(assistant);
-        } else if (!looksLikeJson && !accumulatedRaw.trim().startsWith("<")) {
-          assistant.content =
-            chunkSeq !== undefined ? accumulatedRaw : assistant.content + chunk;
-          rawContentBuffers.delete(assistant.id);
-          streamParsers.delete(assistant.id);
-          assistant.rawContent = undefined;
-          emitMessage(assistant);
-        }
-      }
-    };
-
-    // Seal a flow text block at `text_complete`: run final structured extraction
-    // off the accumulated raw buffer (U2: `text_complete.text` mirrors that raw
-    // buffer, so we never double-count), then finalize the bubble. The structured
-    // `step_complete.result.response` reconciles afterward.
-    const finalizeFlowTextBlock = (
-      assistant: AgentWidgetMessage,
-      finalContent?: unknown
-    ) => {
-      const effectiveFinal =
-        finalContent !== undefined && finalContent !== null
-          ? finalContent
-          : assistant.content;
-      if (
-        effectiveFinal === undefined ||
-        effectiveFinal === null ||
-        effectiveFinal === ""
-      ) {
-        assistant.streaming = false;
-        emitMessage(assistant);
-        return;
-      }
-      const rawBuffer = rawContentBuffers.get(assistant.id);
-      const contentToProcess = rawBuffer ?? ensureStringContent(effectiveFinal);
-      assistant.rawContent = contentToProcess;
-      const parser = streamParsers.get(assistant.id);
-      let extractedText: string | null = null;
-      let asyncPending = false;
-      if (parser) {
-        extractedText = parser.getExtractedText();
-        if (extractedText === null) {
-          extractedText = extractTextFromJson(contentToProcess);
-        }
-        if (extractedText === null) {
-          const parsedResult = parser.processChunk(contentToProcess);
-          if (parsedResult instanceof Promise) {
-            asyncPending = true;
-            parsedResult
-              .then((result) => {
-                const text =
-                  typeof result === "string" ? result : result?.text ?? null;
-                if (text !== null) {
-                  assistant.content = text;
-                  assistant.streaming = false;
-                  streamParsers.delete(assistant.id);
-                  rawContentBuffers.delete(assistant.id);
-                  emitMessage(assistant);
-                }
-              })
-              .catch(() => {});
-          } else {
-            extractedText =
-              typeof parsedResult === "string"
-                ? parsedResult
-                : parsedResult?.text ?? null;
-          }
-        }
-      }
-      if (!asyncPending) {
-        if (extractedText !== null && extractedText.trim() !== "") {
-          assistant.content = extractedText;
-        } else if (!rawContentBuffers.has(assistant.id)) {
-          assistant.content = ensureStringContent(effectiveFinal);
-        }
-        const parserToClose = streamParsers.get(assistant.id);
-        if (parserToClose) {
-          const closeResult = parserToClose.close?.();
-          if (closeResult instanceof Promise) closeResult.catch(() => {});
-          streamParsers.delete(assistant.id);
-        }
-        rawContentBuffers.delete(assistant.id);
-        assistant.streaming = false;
-        emitMessage(assistant);
-      }
-    };
-
-    // Materialize (lazily) the message for a nested flow-as-tool block, tagged
-    // with the parent tool-call id so the UI renders it in the parent tool's row.
-    const ensureNestedBlockMessage = (
-      blockId: string,
-      parentToolCallId: string,
-      variant?: "reasoning"
-    ): AgentWidgetMessage => {
-      const existing = nestedBlockMessages.get(blockId);
-      if (existing) return existing;
-      const message: AgentWidgetMessage = {
-        id: `nested-${parentToolCallId}-${blockId}`,
-        role: "assistant",
-        content: "",
-        createdAt: new Date().toISOString(),
-        streaming: true,
-        sequence: nextSequence(),
-        ...(variant ? { variant } : {}),
-        ...(variant === "reasoning"
-          ? { reasoning: { id: blockId, status: "streaming", chunks: [] } }
-          : {}),
-        agentMetadata: { parentToolId: parentToolCallId },
-      };
-      nestedBlockMessages.set(blockId, message);
-      emitMessage(message);
-      return message;
-    };
-
-    // Ready queue of parsed wire frames awaiting a drain. The API streams the
-    // unified wire vocabulary; each frame is parsed in the SSE loop
-    // below and rendered directly by the handler (no translation bridge), then
-    // pushed here. The wire stream is a single, in-order SSE connection, so
-    // frames drain straight through with no reordering.
-    const eventQueue: RuntypeExecutionStreamEvent[] = [];
-    // Declared here so later closures can reference it; assigned after all
-    // handler-scoped variables are initialised (before the SSE loop).
-    let drainReadyQueue: () => void;
-    // Per-stream media-block buffer: the media triad
-    // (media_start/media_delta/media_complete) is reassembled here into a single
-    // synthetic message at media_complete, keyed by the block id.
-    const mediaBuffers = new Map<
-      string,
-      { mediaType?: string; toolCallId?: string; parts: string[] }
-    >();
-    // Tracks the last iteration surfaced as a per-iteration message boundary, so
-    // `turn_start` advancing the iteration rotates the bubble in 'separate' mode.
-    let lastIterationSeen = 0;
-    // Execution kind, resolved from the leading `execution_start` frame. Drives
-    // the agent-vs-flow branches that the single wire vocabulary collapses.
-    let executionKind: "agent" | "flow" = "agent";
-    // Whether `executionKind` was set authoritatively by an `execution_start`
-    // frame. Continuation streams (e.g. a tool-driven `/resume`) do NOT re-emit
-    // `execution_start`, so a fresh `streamResponse` for the continuation starts
-    // with the default `"agent"`. For a flow that mis-routes the final
-    // prompt-step finalization and duplicates the last message (the streamed
-    // text block is sealed, then `step_complete.result.response` re-renders it as
-    // a second bubble). When `execution_start` is absent we recover the flow kind
-    // from the first flow `step_*` frame below.
-    let executionKindResolved = false;
-    // Open turn id (from `turn_start`). Unified text/reasoning deltas carry their
-    // own block id, not the turn id, so the turn id is threaded onto agentMetadata
-    // from here.
-    let openTurnId: string | null = null;
-    // Agent execution state tracking
-    let agentExecution: { executionId: string; agentId: string; agentName: string } | null = null;
-    const iterationDisplay = this.config.iterationDisplay ?? 'separate';
-
-    // Drains the queued native events through the main event handler.
-    // Also invoked after the SSE loop exits so any events queued at
-    // end-of-stream are processed.
-    drainReadyQueue = () => {
-      for (let i = 0; i < eventQueue.length; i++) {
-        const payload = eventQueue[i];
-
-        // Recover the execution kind on continuation streams that omit
-        // `execution_start` (e.g. a tool-driven `/resume`). Flow `step_*` frames
-        // carry a `stepType`; agent loops never do (they use `turn_*`). Without
-        // this, the continuation defaults to `"agent"` and a flow's final
-        // prompt-step finalization is duplicated. We only infer when no
-        // `execution_start` resolved the kind, so an explicit `agent` is never
-        // overridden.
-        if (
-          !executionKindResolved &&
-          executionKind !== "flow" &&
-          typeof (payload as { stepType?: unknown }).stepType === "string"
-        ) {
-          executionKind = "flow";
-        }
-
-        if (payload.type === "reasoning_start") {
-          // Nested flow-as-tool thinking (PR #4602): route to the parent tool's row.
-          const rStartBlockId = typeof payload.id === "string" ? payload.id : null;
-          const rStartParent =
-            typeof payload.parentToolCallId === "string" && payload.parentToolCallId
-              ? payload.parentToolCallId
-              : null;
-          if (rStartBlockId && rStartParent) {
-            nestedBlockParent.set(rStartBlockId, rStartParent);
-            ensureNestedBlockMessage(rStartBlockId, rStartParent, "reasoning");
-            continue;
-          }
-          const reasoningId = payload.id;
-          const reasoningMessage = ensureReasoningMessage(reasoningId);
-          reasoningMessage.reasoning = reasoningMessage.reasoning ?? {
-            id: reasoningId,
-            status: "streaming",
-            chunks: []
-          };
-          reasoningMessage.reasoning.startedAt =
-            reasoningMessage.reasoning.startedAt ??
-            Date.now();
-          reasoningMessage.reasoning.completedAt = undefined;
-          reasoningMessage.reasoning.durationMs = undefined;
-          if (payload.scope === "loop" || payload.scope === "turn") {
-            reasoningMessage.reasoning.scope = payload.scope;
-          }
-          reasoningMessage.streaming = true;
-          reasoningMessage.reasoning.status = "streaming";
-          emitMessage(reasoningMessage);
-        } else if (payload.type === "reasoning_delta") {
-          // Nested flow-as-tool thinking: append to the parent-tool-row message.
-          const rDeltaBlockId = typeof payload.id === "string" ? payload.id : null;
-          if (
-            rDeltaBlockId &&
-            nestedBlockParent.has(rDeltaBlockId) &&
-            nestedBlockMessages.has(rDeltaBlockId)
-          ) {
-            const nested = nestedBlockMessages.get(rDeltaBlockId)!;
-            const nestedChunk = payload.delta;
-            if (nestedChunk && nested.reasoning) {
-              nested.reasoning.chunks.push(String(nestedChunk));
-              emitMessage(nested);
-            }
-            continue;
-          }
-          const reasoningId = payload.id;
-          const reasoningMessage = ensureReasoningMessage(reasoningId);
-          reasoningMessage.reasoning = reasoningMessage.reasoning ?? {
-            id: reasoningId,
-            status: "streaming",
-            chunks: []
-          };
-          reasoningMessage.reasoning.startedAt =
-            reasoningMessage.reasoning.startedAt ??
-            Date.now();
-          if (payload.delta) reasoningMessage.reasoning.chunks.push(payload.delta);
-          reasoningMessage.reasoning.status = "streaming";
-          reasoningMessage.streaming = true;
-          emitMessage(reasoningMessage);
-        } else if (payload.type === "reasoning_complete") {
-          // Nested flow-as-tool thinking close: seal the parent-tool-row message.
-          const rCompleteBlockId = typeof payload.id === "string" ? payload.id : null;
-          if (
-            rCompleteBlockId &&
-            nestedBlockParent.has(rCompleteBlockId) &&
-            nestedBlockMessages.has(rCompleteBlockId)
-          ) {
-            const nested = nestedBlockMessages.get(rCompleteBlockId)!;
-            if (nested.reasoning) {
-              const nestedReflection =
-                typeof payload.text === "string" ? payload.text : "";
-              if (nestedReflection && nested.reasoning.chunks.length === 0) {
-                nested.reasoning.chunks.push(nestedReflection);
-              }
-              nested.reasoning.status = "complete";
-              nested.streaming = false;
-              emitMessage(nested);
-            }
-            nestedBlockParent.delete(rCompleteBlockId);
-            nestedBlockMessages.delete(rCompleteBlockId);
-            continue;
-          }
-          const reasoningId = payload.id;
-          // A close carrying text (or scope:"loop") is a cross-iteration
-          // reflection fold (merged spec §4 E3): the API streams nothing for the
-          // block, then delivers the whole reflection as `text` on the close.
-          // Materialize a reasoning bubble even if no reasoning_start/delta opened
-          // one, and adopt the close text when the block streamed no chunks (the
-          // common reflection case, where reasoning_start opened an empty bubble).
-          const reflectionText = typeof payload.text === "string" ? payload.text : "";
-          if (!reasoningMessages.get(reasoningId) && (reflectionText || payload.scope === "loop")) {
-            ensureReasoningMessage(reasoningId);
-          }
-          const reasoningMessage = reasoningMessages.get(reasoningId);
-          if (reasoningMessage?.reasoning) {
-            if (payload.scope === "loop" || payload.scope === "turn") {
-              reasoningMessage.reasoning.scope = payload.scope;
-            }
-            if (reflectionText && reasoningMessage.reasoning.chunks.length === 0) {
-              reasoningMessage.reasoning.chunks.push(reflectionText);
-            }
-            reasoningMessage.reasoning.status = "complete";
-            reasoningMessage.reasoning.completedAt = Date.now();
-            const start = reasoningMessage.reasoning.startedAt ?? Date.now();
-            reasoningMessage.reasoning.durationMs = Math.max(
-              0,
-              (reasoningMessage.reasoning.completedAt ?? Date.now()) - start
-            );
-            reasoningMessage.streaming = false;
-
-            emitMessage(reasoningMessage);
-          }
-        } else if (payload.type === "tool_start") {
-          // Unified tool family (agent + flow). Seal any open assistant bubble so
-          // text→tool→text interleaves chronologically (the API also emits a
-          // text_complete here, so this is usually a no-op — kept for safety).
-          if (assistantMessage) {
-            (assistantMessage as AgentWidgetMessage).streaming = false;
-            emitMessage(assistantMessage as AgentWidgetMessage);
-            assistantMessage = null;
-          }
-          // Unified denormalizes `iteration` onto tool frames too (merged spec §2).
-          // Track it so media/reflection blocks — which carry no iteration of their
-          // own — can be stamped with the enclosing iteration even on tool-only
-          // turns that never emit a `turn_start`.
-          if (typeof payload.iteration === "number") lastIterationSeen = payload.iteration;
-          const toolId = payload.toolCallId;
-          const toolName = payload.toolName;
-          // Suppress tool UI for artifact emit tools: artifacts are handled via artifact_* events
-          if (isArtifactEmitToolName(toolName)) {
-            artifactToolCallIds.add(toolId);
-            continue;
-          }
-          const toolMessage = ensureToolMessage(toolId);
-          const tool = toolMessage.toolCall ?? {
-            id: toolId,
-            status: "pending"
-          };
-          tool.name = toolName ?? tool.name;
-          tool.status = "running";
-          tool.success = undefined;
-          tool.error = undefined;
-          tool.duration = undefined;
-          if (payload.parameters !== undefined) {
-            tool.args = payload.parameters;
-          }
-          tool.startedAt =
-            tool.startedAt ??
-            resolveTimestamp(payload.startedAt);
-          tool.completedAt = undefined;
-          tool.durationMs = undefined;
-          toolMessage.toolCall = tool;
-          toolMessage.streaming = true;
-          if (payload.executionId) {
-            toolMessage.agentMetadata = {
-              executionId: payload.executionId,
-              iteration: payload.iteration,
-            };
-          }
-          emitMessage(toolMessage);
-        } else if (payload.type === "tool_output_delta") {
-          const toolId = payload.toolCallId;
-          if (artifactToolCallIds.has(toolId)) continue;
-          const toolMessage = ensureToolMessage(toolId);
-          const tool = toolMessage.toolCall ?? {
-            id: toolId,
-            status: "running"
-          };
-          tool.startedAt =
-            tool.startedAt ??
-            Date.now();
-          const chunkText = payload.delta;
-          if (chunkText) {
-            tool.chunks = tool.chunks ?? [];
-            tool.chunks.push(String(chunkText));
-          }
-          tool.status = "running";
-          toolMessage.toolCall = tool;
-          toolMessage.streaming = true;
-          if (payload.executionId) {
-            toolMessage.agentMetadata = toolMessage.agentMetadata ?? {
-              executionId: payload.executionId,
-              iteration: lastIterationSeen,
-            };
-          }
-          emitMessage(toolMessage);
-        } else if (payload.type === "tool_complete") {
-          const toolId = payload.toolCallId;
-          if (artifactToolCallIds.has(toolId)) {
-            artifactToolCallIds.delete(toolId);
-            continue;
-          }
-          const toolMessage = ensureToolMessage(toolId);
-          const tool = toolMessage.toolCall ?? {
-            id: toolId,
-            status: "running"
-          };
-          tool.status = "complete";
-          if (payload.result !== undefined) {
-            tool.result = payload.result;
-          }
-          tool.name = payload.toolName ?? tool.name;
-          tool.success = payload.success;
-          tool.error = payload.error;
-          tool.completedAt = Date.now();
-          const durationValue = payload.executionTime;
-          if (typeof durationValue === "number") {
-            tool.durationMs = durationValue;
-            tool.duration = durationValue;
-          } else {
-            const start = tool.startedAt ?? Date.now();
-            tool.durationMs = Math.max(
-              0,
-              (tool.completedAt ?? Date.now()) - start
-            );
-          }
-          toolMessage.toolCall = tool;
-          toolMessage.streaming = false;
-          if (payload.executionId) {
-            toolMessage.agentMetadata = toolMessage.agentMetadata ?? {
-              executionId: payload.executionId,
-              iteration: payload.iteration ?? lastIterationSeen,
-            };
-          }
-          emitMessage(toolMessage);
-        } else if (payload.type === "await" && payload.toolName) {
-          // Unified LOCAL tool pause for either dispatch kind. The execution
-          // waits for /resume with toolOutputs. Page tools with origin "webmcp"
-          // may carry a bare name, normalized to the internal webmcp: prefix.
-          //
-          // Upsert a fully-populated tool-variant message so the existing
-          // ask_user_question bubble + sheet paths fire. Mark the message with
-          // `awaitingLocalTool: true` so the UI knows to resolve via
-          // resumeFlow rather than the legacy sendMessage fallback.
-          //
-          // Key the message by the per-call `toolCallId` (provider `toolu_…`;
-          // core#3878) when present. Two PARALLEL calls to the SAME tool in one
-          // turn collapse to an identical `toolId` (`runtime_webmcp:<name>_<ms>`)
-          // and `index: 0`: only `toolCallId` distinguishes them. Keying on it
-          // (a) keeps the two awaits as DISTINCT messages with their own args
-          // instead of the second clobbering the first, and (b) merges each
-          // await into the matching `tool_start` bubble (also keyed by
-          // `toolCallId`). Fall back to the collapsed `toolId` for legacy
-          // servers that don't emit `toolCallId`.
-          const toolCallId: string | undefined =
-            typeof payload.toolCallId === "string" && payload.toolCallId.length > 0
-              ? (payload.toolCallId as string)
-              : undefined;
-          const toolId =
-            toolCallId ?? (payload.toolId as string) ?? `local-${nextSequence()}`;
-          const toolMessage = ensureToolMessage(toolId);
-          const rawToolName = payload.toolName as string;
-          // Page tools may arrive with a bare name; synthesize the
-          // `webmcp:` prefix so isWebMcpToolName (and the bridge's prefix-strip on
-          // resume) treat them identically to a flow `await`.
-          const toolName =
-            payload.origin === "webmcp" &&
-            !isWebMcpToolName(rawToolName)
-              ? `webmcp:${rawToolName}`
-              : rawToolName;
-          const webMcpTool = isWebMcpToolName(toolName);
-          const tool = toolMessage.toolCall ?? { id: toolId, status: "pending" as const };
-          tool.name = toolName;
-          tool.args = payload.parameters;
-          // WebMCP tools are executed asynchronously by the browser AFTER this
-          // `await` arrives. Keep them running until session.ts resolves
-          // the page tool and records its actual elapsed time. Other local
-          // tools (for example ask_user_question) keep the existing complete
-          // state because they are waiting for a user interaction, not an
-          // automatic page-tool execution.
-          tool.status = webMcpTool ? "running" : "complete";
-          tool.chunks = tool.chunks ?? [];
-          tool.startedAt =
-            tool.startedAt ??
-            resolveTimestamp(payload.awaitedAt);
-          if (webMcpTool) {
-            tool.completedAt = undefined;
-            tool.duration = undefined;
-            tool.durationMs = undefined;
-          } else {
-            tool.completedAt = tool.completedAt ?? tool.startedAt;
-          }
-          toolMessage.toolCall = tool;
-          toolMessage.streaming = false;
-          toolMessage.agentMetadata = {
-            ...toolMessage.agentMetadata,
-            executionId: (payload.executionId as string) ?? toolMessage.agentMetadata?.executionId,
-            awaitingLocalTool: true,
-            // Only set when the server emitted a real per-call id; its presence
-            // is what tells session.ts to batch + key `/resume` by id rather
-            // than by tool name (which can't represent two same-tool calls).
-            ...(toolCallId ? { webMcpToolCallId: toolCallId } : {}),
-          };
-          emitMessage(toolMessage);
-        } else if (payload.type === "text_start") {
-          // Nested flow-as-tool text (PR #4602): a `parentToolCallId` means this
-          // block belongs to a flow running as that tool — record the mapping and
-          // leave the top-level assistant bubble untouched (the nested deltas route
-          // into the parent tool's row).
-          const startBlockId = typeof payload.id === "string" ? payload.id : null;
-          const startParent =
-            typeof payload.parentToolCallId === "string" && payload.parentToolCallId
-              ? payload.parentToolCallId
-              : null;
-          if (startBlockId && startParent) {
-            nestedBlockParent.set(startBlockId, startParent);
-            continue;
-          }
-          // Unified text-channel block open. A new block id means a new bubble, so
-          // seal any open assistant bubble; the next text_delta creates a fresh one
-          // (lazily). The API emits a fresh block at every tool/media/approval/await
-          // boundary, so block-id keying drives segmentation — no partId.
-          const prev = assistantMessage as AgentWidgetMessage | null;
-          if (prev) {
-            // Normally text_complete already sealed the prior block; this is the
-            // defensive path if a producer opens a new block without closing.
-            if (executionKind === "flow") {
-              finalizeFlowTextBlock(prev);
-              lastSealedFlowBubble = prev;
-            } else {
-              prev.streaming = false;
-              emitMessage(prev);
-            }
-            assistantMessage = null;
-          }
-          currentTextBlockId =
-            typeof payload.id === "string" ? payload.id : currentTextBlockId;
-          pendingTextRaw = "";
-        } else if (payload.type === "text_delta") {
-          // Nested flow-as-tool text: route to the parent tool's row, through the
-          // same structured-content parser, never the top-level assistant channel.
-          const deltaBlockId = typeof payload.id === "string" ? payload.id : null;
-          const nestedParent = deltaBlockId
-            ? nestedBlockParent.get(deltaBlockId)
-            : undefined;
-          if (deltaBlockId && nestedParent) {
-            const nestedDelta =
-              typeof payload.delta === "string" ? payload.delta : "";
-            const nestedRaw = (nestedBlockRaw.get(deltaBlockId) ?? "") + nestedDelta;
-            nestedBlockRaw.set(deltaBlockId, nestedRaw);
-            if (nestedRaw.trim() === "") continue;
-            const nested = ensureNestedBlockMessage(deltaBlockId, nestedParent);
-            nested.agentMetadata = {
-              ...nested.agentMetadata,
-              executionId: payload.executionId,
-              parentToolId: nestedParent,
-            };
-            applyTextChunk(nested, nestedRaw, nestedDelta, undefined);
-            continue;
-          }
-          currentTextBlockId =
-            typeof payload.id === "string" ? payload.id : currentTextBlockId;
-          if (executionKind === "flow") {
-            // Flow prompt-step text can be structured JSON: accumulate the raw
-            // block and run it through the structured-content parser, keyed by the
-            // block-id bubble. Materialize lazily so a whitespace-only block
-            // (newlines around a tool boundary) never leaves a stray bubble.
-            const delta = typeof payload.delta === "string" ? payload.delta : "";
-            pendingTextRaw += delta;
-            if (pendingTextRaw.trim() === "") continue;
-            const assistant = ensureAssistantMessage();
-            assistant.agentMetadata = {
-              executionId: payload.executionId,
-              iteration: lastIterationSeen,
-            };
-            applyTextChunk(assistant, pendingTextRaw, delta, undefined);
-            lastAssistantInTurn = assistant;
-            continue;
-          }
-          // Agent text can be structured JSON too, whenever the host configures a
-          // custom `streamParser` (e.g. the page-context demo's `{"text": ...}` /
-          // `{"action": "add_to_cart", ...}` envelope). Accumulate the open block's
-          // raw text and run it through the same structured-content path the flow
-          // branch uses, so the parser sees the whole block and `rawContent` stays
-          // populated for the action manager. With the default plain-text parser
-          // this is byte-identical to appending the delta, so agent demos that
-          // stream prose are unaffected.
-          const agentDelta = typeof payload.delta === "string" ? payload.delta : "";
-          pendingTextRaw += agentDelta;
-          const assistant = ensureAssistantMessage();
-          assistant.agentMetadata = {
-            executionId: payload.executionId,
-            iteration: lastIterationSeen,
-            turnId: openTurnId ?? undefined,
-            agentName: agentExecution?.agentName
-          };
-          applyTextChunk(assistant, pendingTextRaw, agentDelta, undefined);
-          lastAssistantInTurn = assistant;
-        } else if (payload.type === "text_complete") {
-          // Nested flow-as-tool text block close: seal its parent-tool-row message.
-          const completeBlockId = typeof payload.id === "string" ? payload.id : null;
-          if (completeBlockId && nestedBlockParent.has(completeBlockId)) {
-            const nested = nestedBlockMessages.get(completeBlockId);
-            if (nested) finalizeFlowTextBlock(nested);
-            nestedBlockParent.delete(completeBlockId);
-            nestedBlockRaw.delete(completeBlockId);
-            nestedBlockMessages.delete(completeBlockId);
-            continue;
-          }
-          // Seal the current text block's bubble.
-          const prev = assistantMessage as AgentWidgetMessage | null;
-          if (prev) {
-            if (executionKind === "flow") {
-              // Final structured extraction off the accumulated raw buffer; the
-              // authoritative step_complete.result.response reconciles next.
-              finalizeFlowTextBlock(prev);
-              lastSealedFlowBubble = prev;
-            } else {
-              // U2: text_complete carries the assembled text, but the bubble already
-              // holds it from the deltas — only fall back to payload.text when no
-              // delta content was seen, never double-count.
-              if ((prev.content ?? "") === "" && typeof payload.text === "string") {
-                prev.content = payload.text;
-              }
-              prev.streaming = false;
-              emitMessage(prev);
-            }
-            assistantMessage = null;
-          }
-          currentTextBlockId = null;
-          pendingTextRaw = "";
-        } else if (payload.type === "step_complete") {
-          // Only process completions for prompt steps, not tool/context steps
-          if (payload.stepType === "tool") {
-            // Skip tool-related completions - they're handled by tool_complete
-            continue;
-          }
-
-          // A failed step (`success:false`) — including the legacy `step_error`
-          // event, which the wire encoder folds into a failed `step_complete`
-          // — surfaces as a terminal error and finalizes the stream.
-          if (payload.success === false) {
-            const message = payload.error || "Step failed";
-            onEvent({ type: "error", error: new Error(message) });
-            const finalMsg = assistantMessage as AgentWidgetMessage | null;
-            if (finalMsg && finalMsg.streaming) {
-              finalMsg.streaming = false;
-              emitMessage(finalMsg);
-            }
-            onEvent({ type: "status", status: "idle" });
-            continue;
-          }
-
-          // Unified flow: reconcile the just-sealed text block with the
-          // authoritative structured final (`result.response`). Displayed content
-          // stays as streamed — a multi-segment step keeps each bubble's own text;
-          // reconcile only fills/repairs the last sealed block and sets rawContent.
-          // A pure-tool / text-less step (no sealed flow bubble) completes silently.
-          {
-            const sealed = lastSealedFlowBubble;
-            lastSealedFlowBubble = null;
-            const flowStopReason = payload.stopReason as
-              | StopReasonKind
-              | undefined;
-            const result = payload.result && typeof payload.result === "object"
-              ? payload.result as Record<string, unknown>
-              : null;
-            const finalResponse = result?.response;
-            if (sealed) {
-              if (flowStopReason) sealed.stopReason = flowStopReason;
-              if (finalResponse !== undefined && finalResponse !== null) {
-                reconcileSealedAssistantWithFinalResponse(sealed, finalResponse);
-              } else if (sealed.streaming !== false) {
-                streamParsers.delete(sealed.id);
-                rawContentBuffers.delete(sealed.id);
-                sealed.streaming = false;
-                emitMessage(sealed);
-              }
-            } else {
-              // Buffered / dispatch-mode step: no streamed text block, but the step
-              // carries the final response (and/or a stopReason) — render it as the
-              // assistant message. An empty response + stopReason still surfaces a
-              // sealed bubble so the UI can show an affordance.
-              const hasResponse =
-                finalResponse !== undefined &&
-                finalResponse !== null &&
-                finalResponse !== "";
-              if (hasResponse || flowStopReason) {
-                const assistant = ensureAssistantMessage();
-                if (flowStopReason) assistant.stopReason = flowStopReason;
-                if (hasResponse) {
-                  finalizeFlowTextBlock(assistant, finalResponse);
-                } else {
-                  assistant.streaming = false;
-                  emitMessage(assistant);
-                }
-              }
-            }
-            continue;
-          }
-        // ================================================================
-        // Agent Loop Execution Events
-        // ================================================================
-        } else if (payload.type === "execution_start") {
-          executionKind = payload.kind === "flow" ? "flow" : "agent";
-          executionKindResolved = true;
-          if (executionKind === "agent") {
-            agentExecution = {
-              executionId: payload.executionId,
-              agentId: payload.agentId ?? 'virtual',
-              agentName: payload.agentName ?? ''
-            };
-          }
-        } else if (payload.type === "turn_start") {
-          // Unified collapsed `agent_iteration_*` into a denormalized `iteration`
-          // field on the turn (merged spec §2). Reconstruct the per-iteration
-          // message boundary the 'separate' renderer keys off: when the iteration
-          // advances, seal the previous iteration's bubble and rotate to a new one.
-          const iteration =
-            typeof payload.iteration === "number" ? payload.iteration : lastIterationSeen;
-          if (iteration !== lastIterationSeen) {
-            if (iterationDisplay === 'separate' && iteration > 1) {
-              const prevMsg = assistantMessage as AgentWidgetMessage | null;
-              if (prevMsg) {
-                prevMsg.streaming = false;
-                emitMessage(prevMsg);
-                assistantMessage = null;
-              }
-            }
-            lastIterationSeen = iteration;
-          }
-          openTurnId = typeof payload.id === "string" ? payload.id : null;
-          // Reset the per-turn assistant tracker. lastAssistantInTurn is used by
-          // turn_complete to attach stopReason to the final text segment of the
-          // turn even if that segment was sealed by an intervening tool boundary.
-          lastAssistantInTurn = null;
-        } else if (payload.type === "tool_input_delta") {
-          // Streamed tool arguments (display-only; authoritative args ride
-          // tool_input_complete / tool_start).
-          const toolId = payload.toolCallId;
-          if (toolId) {
-            const toolMessage = toolMessages.get(toolId);
-            if (toolMessage?.toolCall) {
-              toolMessage.toolCall.chunks = toolMessage.toolCall.chunks ?? [];
-              toolMessage.toolCall.chunks.push(payload.delta ?? '');
-              emitMessage(toolMessage);
-            }
-          }
-        } else if (payload.type === "tool_input_complete") {
-          if (artifactToolCallIds.has(payload.toolCallId)) continue;
-          const toolMessage = ensureToolMessage(payload.toolCallId);
-          const tool = toolMessage.toolCall!;
-          tool.args = payload.parameters;
-          tool.name = payload.toolName ?? tool.name;
-          emitMessage(toolMessage);
-        } else if (payload.type === "turn_complete") {
-          // Reasoning is sealed by its own reasoning_complete on the wire
-          // vocabulary; this only attaches the turn-level stopReason to the
-          // assistant message produced by this turn. Falls back to
-          // lastAssistantInTurn when the bubble was sealed at a tool boundary
-          // mid-turn, so the notice still attaches to the final visible segment.
-          const turnStopReason = payload.stopReason as
-            | StopReasonKind
-            | undefined;
-          const stopReasonTarget = assistantMessage ?? lastAssistantInTurn;
-          if (turnStopReason && stopReasonTarget !== null) {
-            const turnId = payload.id;
-            const matchesTurn =
-              !turnId || stopReasonTarget.agentMetadata?.turnId === turnId;
-            if (matchesTurn) {
-              stopReasonTarget.stopReason = turnStopReason;
-              emitMessage(stopReasonTarget);
-            }
-          }
-          if (openTurnId === payload.id) openTurnId = null;
-        } else if (payload.type === "media_start") {
-          // Open a media block; buffer fragments until media_complete.
-          const id = String(payload.id);
-          mediaBuffers.set(id, {
-            mediaType: typeof payload.mediaType === "string" ? payload.mediaType : undefined,
-            toolCallId: payload.toolCallId,
-            parts: [],
-          });
-        } else if (payload.type === "media_delta") {
-          const buf = mediaBuffers.get(String(payload.id));
-          if (buf && typeof payload.delta === "string") buf.parts.push(payload.delta);
-        } else if (payload.type === "media_complete") {
-          // Reassemble the buffered media triad into a single AI SDK–aligned
-          // `MediaContentPart`, then render it as a synthetic assistant message
-          // inserted between the tool bubble and the next text turn:
-          //   { type: 'media', data, mediaType }                // AI SDK v6: base64
-          //   { type: 'image-url', url, mediaType? }            // AI SDK v3/v4
-          //   { type: 'file-url', url, mediaType }              // AI SDK v3/v4
-          const mediaBlockId = String(payload.id);
-          const buf = mediaBuffers.get(mediaBlockId);
-          mediaBuffers.delete(mediaBlockId);
-          const completeMediaType =
-            (typeof payload.mediaType === "string" ? payload.mediaType : undefined) ??
-            buf?.mediaType ??
-            "application/octet-stream";
-          const completeData = typeof payload.data === "string" ? payload.data : undefined;
-          const completeUrl =
-            typeof payload.url === "string"
-              ? payload.url
-              : buf && buf.parts.length > 0
-                ? buf.parts.join("")
-                : undefined;
-          let reconstructed: Record<string, unknown> | null = null;
-          if (completeData) {
-            reconstructed = { type: "media", data: completeData, mediaType: completeMediaType };
-          } else if (completeUrl) {
-            // The wire is mediaType-only; a URL part with no declared MIME
-            // arrives as the bare bucket hint "image" (per the API encoder). Treat
-            // that — and any real `image/*` — as a hosted image so we don't misroute
-            // generated images into the file bucket.
-            const lower = completeMediaType.toLowerCase();
-            const isImage = lower === "image" || lower.startsWith("image/");
-            reconstructed = {
-              type: isImage ? "image-url" : "file-url",
-              url: completeUrl,
-              mediaType: completeMediaType,
-            };
-          }
-          const mediaToolCallId = payload.toolCallId ?? buf?.toolCallId;
-          const rawMedia = reconstructed ? [reconstructed] : [];
-          const mediaContentParts: ContentPart[] = [];
-          for (const part of rawMedia) {
-            if (!part || typeof part !== "object") continue;
-            const rec = part as Record<string, unknown>;
-            const partType = typeof rec.type === "string" ? rec.type : undefined;
-
-            // Resolve `(src, mediaType)` for the part.
-            // RFC 7231 says MIME types are case-insensitive, so we canonicalize
-            // to lowercase once here. That makes the `startsWith("image/")` /
-            // `"audio/"` / `"video/"` bucket checks robust to upstream tools
-            // that emit non-canonical casing like `Image/PNG`.
-            const rawMediaType =
-              typeof rec.mediaType === "string" ? rec.mediaType.toLowerCase() : "";
-            let src: string | null = null;
-            let mediaType = "";
-            if (partType === "media") {
-              const data = typeof rec.data === "string" ? rec.data : undefined;
-              if (!data) continue;
-              // Empty/missing mediaType yields `data:;base64,...` which RFC 2397
-              // resolves to `text/plain`: stamp a default so the data URI is
-              // well-formed and the part lands in the file bucket.
-              mediaType = rawMediaType.length > 0 ? rawMediaType : "application/octet-stream";
-              src = `data:${mediaType};base64,${data}`;
-            } else if (partType === "image-url") {
-              const url = typeof rec.url === "string" ? rec.url : undefined;
-              if (!url) continue;
-              mediaType = rawMediaType;
-              src = url;
-            } else if (partType === "file-url") {
-              const url = typeof rec.url === "string" ? rec.url : undefined;
-              if (!url) continue;
-              mediaType = rawMediaType;
-              src = url;
-            } else {
-              continue;
-            }
-            if (!src) continue;
-
-            // Pick the right rendering bucket based on mediaType.
-            if (partType === "image-url" || mediaType.startsWith("image/")) {
-              mediaContentParts.push({
-                type: "image",
-                image: src,
-                // Only a real MIME (`image/png`) is a usable mimeType; the bare
-                // bucket hint "image" (a hosted URL with no declared type) is not.
-                ...(mediaType.includes("/") ? { mimeType: mediaType } : {}),
-              });
-            } else if (mediaType.startsWith("audio/")) {
-              mediaContentParts.push({
-                type: "audio",
-                audio: src,
-                mimeType: mediaType,
-              });
-            } else if (mediaType.startsWith("video/")) {
-              mediaContentParts.push({
-                type: "video",
-                video: src,
-                mimeType: mediaType,
-              });
-            } else {
-              const resolvedMediaType = mediaType || "application/octet-stream";
-              mediaContentParts.push({
-                type: "file",
-                data: src,
-                mimeType: resolvedMediaType,
-                filename: filenameFromMediaType(resolvedMediaType),
-              });
-            }
-          }
-
-          if (mediaContentParts.length > 0) {
-            // Uniquify per emission. A tool may emit multiple `agent_media`
-            // events for the same `toolCallId` (e.g. streamed/batched media);
-            // sharing an id would let `emitMessage` merge them by id and
-            // overwrite the prior `contentParts`.
-            const seq = nextSequence();
-            const toolCallIdRaw = mediaToolCallId;
-            const mediaIdSuffix =
-              typeof toolCallIdRaw === "string" && toolCallIdRaw.length > 0
-                ? `${toolCallIdRaw}-${seq}`
-                : String(seq);
-            const mediaMessage: AgentWidgetMessage = {
-              id: `agent-media-${mediaIdSuffix}`,
-              role: "assistant",
-              content: "",
-              contentParts: mediaContentParts,
-              createdAt: new Date().toISOString(),
-              streaming: false,
-              sequence: seq,
-              agentMetadata: {
-                executionId: payload.executionId,
-                // Media blocks carry no iteration of their own; stamp the
-                // enclosing iteration tracked from turn/tool frames.
-                iteration: lastIterationSeen,
-              },
-            };
-            emitMessage(mediaMessage);
-
-            // Seal any in-flight assistant text bubble before splitting the
-            // stream. Without this, an orphan bubble retains `streaming: true`
-            // forever: `execution_complete` only finalizes the latest
-            // `assistantMessage`, so the typing/caret indicator would stay on
-            // the prior bubble even though no more deltas will arrive.
-            const prevAssistant = assistantMessage as AgentWidgetMessage | null;
-            if (prevAssistant) {
-              prevAssistant.streaming = false;
-              emitMessage(prevAssistant);
-            }
-            assistantMessage = null;
-            assistantMessageRef.current = null;
-          }
-        } else if (payload.type === "execution_complete") {
-          // Finalize any still-open assistant message. Per-step reconciliation
-          // (step_complete.result.response) normally sealed the flow blocks
-          // already; this is the defensive close for an unterminated block, and
-          // for flow it runs the final structured extraction off the raw buffer.
-          const finalMsg = assistantMessage as AgentWidgetMessage | null;
-          if (finalMsg) {
-            if (payload.kind === "flow" && finalMsg.streaming !== false) {
-              finalizeFlowTextBlock(finalMsg);
-            } else {
-              finalMsg.streaming = false;
-              emitMessage(finalMsg);
-            }
-            assistantMessage = null;
-          }
-          currentTextBlockId = null;
-          pendingTextRaw = "";
-          lastSealedFlowBubble = null;
-
-          // `terminal: true` marks this as a graceful finish (not a drop). The
-          // session uses it to distinguish the real end-of-turn from the plain
-          // `idle` the dispatch wrappers emit in their `finally` when a durable
-          // connection drops mid-stream (durable-reconnect drop detection).
-          onEvent({ type: "status", status: "idle", terminal: true });
-        } else if (payload.type === "execution_error") {
-          // Terminal failure. The non-terminal `error` is handled
-          // separately (recoverable → warn).
-          const errorMessage = typeof payload.error === 'string'
-            ? payload.error
-            : payload.error?.message ?? 'Execution error';
-          onEvent({
-            type: "error",
-            error: new Error(errorMessage)
-          });
-        } else if (payload.type === "ping") {
-          // Keep-alive heartbeat - no action needed
-        // ================================================================
-        // Tool Approval Events
-        // ================================================================
-        } else if (payload.type === "approval_start") {
-          const approvalId = payload.approvalId ?? `approval-${nextSequence()}`;
-          const approvalMessage: AgentWidgetMessage = {
-            id: `approval-${approvalId}`,
-            role: "assistant",
-            content: "",
-            createdAt: new Date().toISOString(),
-            streaming: false,
-            variant: "approval",
-            sequence: nextSequence(),
-            approval: {
-              id: approvalId,
-              status: "pending",
-              agentId: agentExecution?.agentId ?? 'virtual',
-              executionId: payload.executionId ?? agentExecution?.executionId ?? '',
-              toolName: payload.toolName ?? '',
-              toolType: payload.toolType,
-              description: payload.description ?? `Execute ${payload.toolName ?? 'tool'}`,
-              ...(typeof payload.reason === "string" && payload.reason
-                ? { reason: payload.reason }
-                : {}),
-              parameters: payload.parameters,
-            },
-          };
-          emitMessage(approvalMessage);
-        } else if (payload.type === "approval_complete") {
-          const approvalId = payload.approvalId;
-          if (approvalId) {
-            // Find and update the existing approval message
-            const approvalMessageId = `approval-${approvalId}`;
-            const existingMessage: AgentWidgetMessage = {
-              id: approvalMessageId,
-              role: "assistant",
-              content: "",
-              createdAt: new Date().toISOString(),
-              streaming: false,
-              variant: "approval",
-              sequence: nextSequence(),
-              approval: {
-                id: approvalId,
-                status: (payload.decision as "approved" | "denied") ?? "approved",
-                agentId: agentExecution?.agentId ?? 'virtual',
-                executionId: payload.executionId ?? agentExecution?.executionId ?? '',
-                toolName: '',
-                description: '',
-                resolvedAt: Date.now(),
-              },
-            };
-            emitMessage(existingMessage);
-          }
-        } else if (
-          payload.type === "artifact_start" ||
-          payload.type === "artifact_delta" ||
-          payload.type === "artifact_update" ||
-          payload.type === "artifact_complete"
-        ) {
-          if (payload.type === "artifact_start") {
-            const at = payload.artifactType as PersonaArtifactKind;
-            const artId = String(payload.id);
-            const artTitle = typeof payload.title === "string" ? payload.title : undefined;
-            // Additive `file` metadata: validate shape (object with string path +
-            // string mimeType; optional string language). Drop silently if malformed
-            // so old/new backends and unexpected payloads never break the stream.
-            const rawFile = payload.file;
-            let artFile: PersonaArtifactFileMeta | undefined;
-            if (
-              rawFile &&
-              typeof rawFile === "object" &&
-              !Array.isArray(rawFile) &&
-              typeof rawFile.path === "string" &&
-              typeof rawFile.mimeType === "string"
-            ) {
-              artFile = {
-                path: rawFile.path,
-                mimeType: rawFile.mimeType,
-                ...(typeof rawFile.language === "string" ? { language: rawFile.language } : {}),
-              };
-            }
-            onEvent({
-              type: "artifact_start",
-              id: artId,
-              artifactType: at,
-              title: artTitle,
-              component: typeof payload.component === "string" ? payload.component : undefined,
-              ...(artFile ? { file: artFile } : {})
-            });
-            artifactContent.set(artId, {
-              markdown: "",
-              title: artTitle,
-              file: artFile,
-            });
-            // Insert the in-thread artifact block once per ID.
-            // The resolved display mode picks the component:
-            // "card"/"panel" inject the reference card; "inline" injects the
-            // inline preview block. Both share the rawContent JSON-component
-            // shape so transcript persistence and hydration work unchanged.
-            if (!artifactIdsWithCards.has(artId)) {
-              artifactIdsWithCards.add(artId);
-              const displayMode = resolveArtifactDisplayMode(
-                this.config.features?.artifacts,
-                {
-                  artifactType: at,
-                  ...(artFile ? { file: artFile } : {}),
-                }
-              );
-              const artComponent =
-                typeof payload.component === "string" ? payload.component : undefined;
-              const cardMsg: AgentWidgetMessage = {
-                id: `artifact-ref-${artId}`,
-                role: "assistant",
-                content: "",
-                createdAt: new Date().toISOString(),
-                streaming: true,
-                sequence: nextSequence(),
-                rawContent: buildArtifactRefRawContent(displayMode, {
-                  artifactId: artId,
-                  title: artTitle,
-                  artifactType: at,
-                  status: "streaming",
-                  ...(artFile ? { file: artFile } : {}),
-                  ...(artComponent ? { component: artComponent } : {}),
-                }),
-              };
-              artifactCardMessages.set(artId, cardMsg);
-              emitMessage(cardMsg);
-            }
-          } else if (payload.type === "artifact_delta") {
-            const deltaId = String(payload.id);
-            const deltaText = typeof payload.delta === "string" ? payload.delta : String(payload.delta ?? "");
-            onEvent({
-              type: "artifact_delta",
-              id: deltaId,
-              artDelta: deltaText
-            });
-            const acc = artifactContent.get(deltaId);
-            if (acc) acc.markdown += deltaText;
-          } else if (payload.type === "artifact_update") {
-            const props =
-              payload.props && typeof payload.props === "object" && !Array.isArray(payload.props)
-                ? (payload.props as Record<string, unknown>)
-                : {};
-            onEvent({
-              type: "artifact_update",
-              id: String(payload.id),
-              props,
-              component: typeof payload.component === "string" ? payload.component : undefined
-            });
-            // Accumulate for hydration: embedded on artifact_complete so an
-            // inline component block re-renders with its real props after a
-            // refresh.
-            const updateAcc = artifactContent.get(String(payload.id));
-            if (updateAcc) {
-              updateAcc.props = { ...(updateAcc.props ?? {}), ...props };
-            }
-          } else if (payload.type === "artifact_complete") {
-            const artCompleteId = String(payload.id);
-            onEvent({ type: "artifact_complete", id: artCompleteId });
-            // Update the inline card to show completed state
-            const refMsg = artifactCardMessages.get(artCompleteId);
-            if (refMsg) {
-              refMsg.streaming = false;
-              try {
-                const parsed = JSON.parse(refMsg.rawContent ?? "{}");
-                if (parsed.props) {
-                  parsed.props.status = "complete";
-                  // Store markdown content in card props so download works after page refresh
-                  const acc = artifactContent.get(artCompleteId);
-                  if (acc?.markdown) {
-                    parsed.props.markdown = acc.markdown;
-                  }
-                  // Persist file metadata too so the download path unfences correctly after refresh.
-                  if (acc?.file) {
-                    parsed.props.file = acc.file;
-                  }
-                  // Embed accumulated component props so an inline component
-                  // block hydrates with its real props after a refresh. Only
-                  // the inline block reads them; the card never does.
-                  if (
-                    parsed.component === "PersonaArtifactInline" &&
-                    acc?.props &&
-                    Object.keys(acc.props).length > 0
-                  ) {
-                    parsed.props.componentProps = acc.props;
-                  }
-                }
-                refMsg.rawContent = JSON.stringify(parsed);
-              } catch { /* ignore parse errors */ }
-              artifactContent.delete(artCompleteId);
-              emitMessage(refMsg);
-              artifactCardMessages.delete(artCompleteId);
-            }
-          }
-        } else if (payload.type === "error") {
-          // Unified non-terminal error (merged spec). A bare `error` is
-          // recoverable by default — a transient notice such as "rate limited,
-          // retrying" — and the execution continues, so it must NOT surface as a
-          // fatal error or finalize the stream. The API routes terminal failures
-          // through `execution_error`. Only an explicit `recoverable: false`
-          // promotes an `error` to terminal.
-          if (
-            payload.recoverable === false &&
-            payload.error != null &&
-            payload.error !== ""
-          ) {
-            const errorMessage =
-              typeof payload.error === "string"
-                ? payload.error
-                : (payload.error as { message?: unknown })?.message != null
-                  ? String((payload.error as { message?: unknown }).message)
-                  : "Execution error";
-            onEvent({ type: "error", error: new Error(errorMessage) });
-            const finalMsg = assistantMessage as AgentWidgetMessage | null;
-            if (finalMsg && finalMsg.streaming) {
-              finalMsg.streaming = false;
-              emitMessage(finalMsg);
-            }
-            onEvent({ type: "status", status: "idle" });
-          }
-
-        }
-      }
-      eventQueue.length = 0;
-    };
-
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      buffer += decoder.decode(value, { stream: true });
-      const events = buffer.split("\n\n");
-      buffer = events.pop() ?? "";
-
-      for (const event of events) {
-        const lines = event.split("\n");
-        let eventType = "message";
-        let data = "";
-        // Durable-reconnect cursor: the SSE `id:` line (the durable row seq).
-        // Only durable, resumable agent executions stamp these (e.g. Claude
-        // Managed agents, or any async/background run the backend persists and
-        // can replay); other streams carry no cursor. We emit a `cursor`
-        // event AFTER the frame is fully parsed and dispatched, so the session's
-        // `lastEventId` only advances past frames it has actually applied, so the
-        // happy path has no dupes against the server's `seq > after` replay.
-        let frameId: string | null = null;
-
-        for (const line of lines) {
-          if (line.startsWith("event:")) {
-            eventType = line.replace("event:", "").trim();
-          } else if (line.startsWith("data:")) {
-            data += line.replace("data:", "").trim();
-          } else if (line.startsWith("id:")) {
-            frameId = line.slice(3).trim();
-          }
-        }
-
-        const advanceCursor = () => {
-          if (frameId !== null && frameId !== "") {
-            onEvent({ type: "cursor", id: frameId });
-          }
-        };
-
-        // A frame with an `id:` but no `data:` (e.g. a bare keepalive line) is
-        // still a received durable row, so advance the cursor past it.
-        if (!data) {
-          advanceCursor();
-          continue;
-        }
-        let payload: unknown;
-        try {
-          payload = JSON.parse(data);
-        } catch (error) {
-          // Parse failure: the frame was NOT applied. Do NOT advance the cursor
-          // so a reconnect re-fetches this row.
-          onEvent({
-            type: "error",
-            error:
-              error instanceof Error
-                ? error
-                : new Error("Failed to parse chat stream payload")
-          });
-          continue;
-        }
-
-        const record = payload !== null && typeof payload === "object" && !Array.isArray(payload)
-          ? payload as Record<string, unknown>
-          : null;
-        const payloadType = eventType !== "message"
-          ? eventType
-          : typeof record?.type === "string" ? record.type : "message";
-
-        // Tap: capture raw SSE event for event stream inspector
-        this.onSSEEvent?.(payloadType, payload);
-
-        // If custom SSE event parser is provided, try it first
-        if (this.parseSSEEvent) {
-          // Keep assistant message ref in sync
-          assistantMessageRef.current = assistantMessage;
-          const handled = await this.handleCustomSSEEvent(
-            payload,
-            onEvent,
-            assistantMessageRef,
-            emitMessage,
-            nextSequence,
-            customParsePartId
-          );
-          // Update assistantMessage from ref (in case it was created or replaced by partId segmentation)
-          if (assistantMessageRef.current && assistantMessageRef.current !== assistantMessage) {
-            assistantMessage = assistantMessageRef.current;
-          }
-          if (handled) {
-            advanceCursor();
-            continue; // Skip default handling if custom handler processed it
-          }
-        }
-
-        // The wire is the wire vocabulary; the handler consumes it
-        // natively. The stream is single-connection and in order, so each frame
-        // drains straight through.
-        if (record) {
-          // The raw tap and custom parser above retain the original payload.
-          // Known native branches use the generated union; unknown event types
-          // fall through without rejecting a custom backend's stream.
-          eventQueue.push({ ...record, type: payloadType } as RuntypeExecutionStreamEvent);
-          drainReadyQueue();
-        }
-        advanceCursor();
-      }
-    }
-
-    drainReadyQueue();
+        config: () => this.config,
+        createStreamParser: this.#createStreamParser,
+        parseSSEEvent: this.#parseSSEEvent,
+        onSSEEvent: (eventType, payload) => this.#onSSEEvent?.(eventType, payload),
+      },
+      body,
+      onEvent,
+      assistantMessageId,
+      seedContent
+    );
   }
 }