@runtypelabs/persona 4.24.0 → 4.26.0

package/dist/forms-ui.d.ts

@@ -6689,6 +6689,22 @@ type AgentWidgetStatusIndicatorConfig = {
     /** Status text while a reconnect attempt is in flight. */
     resumingText?: string;
 };
+/** Built-in `voiceRecognition.prewarm` triggers. See {@link AgentWidgetVoiceRecognitionConfig.prewarm}. */
+type AgentWidgetVoicePrewarmTrigger = 'hover';
+/**
+ * Custom `voiceRecognition.prewarm` trigger. Runs while the composer has a mic
+ * button, and again when the button is rebuilt or `update()` swaps in a
+ * different function. Call `warm()` whenever the visitor shows intent to talk
+ * (it is safe to call repeatedly). Return a cleanup to run on replacement.
+ */
+type AgentWidgetVoicePrewarmHook = (context: {
+    /** Fire-and-forget voice warm-up; latched and error-swallowing. */
+    warm: () => void;
+    /** The composer's current mic button. */
+    micButton: HTMLButtonElement;
+    /** The widget's mount element. */
+    mount: HTMLElement;
+}) => void | (() => void);
 type AgentWidgetVoiceRecognitionConfig = {
     /**
      * Enable the mic button and voice input. The mic still only renders when the
@@ -6754,6 +6770,29 @@ type AgentWidgetVoiceRecognitionConfig = {
      * Fires once per turn after the reply completes.
      */
     onMetrics?: (metrics: VoiceMetrics) => void;
+    /**
+     * Warm the voice path when the visitor shows intent to talk, before the mic
+     * click, so the call starts faster.
+     *
+     * - `'hover'`: when the pointer enters the mic button, it receives focus, or
+     *   (on touch) the first pointer-down on it.
+     * - `false`: never.
+     * - A function: custom trigger. Called with `{ warm, micButton, mount }`
+     *   while the mic button exists (and again when the button is rebuilt or
+     *   `update()` swaps in a different function); call `warm()` whenever you
+     *   decide, e.g. when the panel opens. May return a cleanup that runs on
+     *   destroy, rebuild, or replacement. Replaces the built-in trigger.
+     *
+     * What `warm()` does depends on the provider: `runtype` fires its prewarm
+     * (see `provider.runtype.prewarmMode`), a `custom` provider's optional
+     * {@link VoiceProvider.prewarm} runs, and the browser (Web Speech) path
+     * starts the client-token session init (as `sessionInit` does), since speech
+     * recognition itself cannot start before the click. Warming is
+     * fire-and-forget, latched, and never surfaces an error or UI state.
+     *
+     * @default 'hover' in client token mode, otherwise `false`
+     */
+    prewarm?: AgentWidgetVoicePrewarmTrigger | AgentWidgetVoicePrewarmHook | false;
     provider?: {
         type: 'browser' | 'runtype' | 'custom';
         browser?: {
@@ -6775,6 +6814,62 @@ type AgentWidgetVoiceRecognitionConfig = {
              * `@runtypelabs/persona/voice-worklet-player` for a jitter-buffered engine.
              */
             createPlaybackEngine?: () => VoicePlaybackEngine | Promise<VoicePlaybackEngine>;
+            /**
+             * How `prewarm()` warms the voice path (see `voiceRecognition.prewarm`).
+             *
+             * - `'request'` (default): a fire-and-forget
+             *   `POST {host}/v1/client/agents/{agentId}/voice/prewarm`.
+             * - `'attach'`: open the voice WebSocket ahead of the click without
+             *   starting a call; the click then starts the call on that socket. It can
+             *   create server work before the visitor clicks, so it is opt-in.
+             * @default 'request'
+             */
+            prewarmMode?: 'request' | 'attach';
+            /**
+             * `'attach'` mode: how long (ms) an attached socket waits for the click
+             * before it closes. The server clamps it to 30000..600000.
+             * @default 30000
+             */
+            attachIdleMs?: number;
+            /**
+             * Full-duplex (speech-to-speech, e.g. GPT-Live) calls: run the turns the
+             * voice model hands off to the agent through this widget's normal chat
+             * pipeline. The spoken request becomes the user message, and the answer
+             * renders as a regular assistant message (streaming, tool and approval
+             * UI, WebMCP page tools, persistence) that the voice model then reads
+             * aloud. Only takes effect when the server supports it (it confirms in
+             * `session_config`); otherwise the agent turn runs on the server and its
+             * spoken reply is transcribed, as before. Set `false` to always keep the
+             * agent turn on the server.
+             * @default true
+             */
+            clientDelegation?: boolean;
+            /**
+             * Full-duplex calls: extra context for the voice model (for example the
+             * page the visitor is on), sent after the chat history as of call start.
+             * The frame goes out once, when the visitor finishes their first
+             * utterance (or at the first agent hand-off). A function is
+             * called at call start and may be async. This text is capped at 4000 characters and the whole frame
+             * (history included) at 8000. Sent only to servers that accept call
+             * context (they announce it in `session_config`).
+             */
+            callContext?: string | (() => string | Promise<string>);
+            /**
+             * Full-duplex calls with client delegation: how long a tool approval
+             * that a spoken request raised may wait before it is declined as
+             * expired (and the voice model says so). Server-side approval gates
+             * keep their own timeout too. Hanging up never declines it: the
+             * approval card in the chat stays usable. Capped at 540000 (9 minutes),
+             * under the server's 10-minute delegation deadline.
+             * @default 300000
+             */
+            approvalTimeoutMs?: number;
+            /**
+             * Speech-to-speech calls: the one-line notice shown in the composer
+             * status area when the call starts. `false` hides it.
+             * @default "You're talking to an AI assistant. Voice is processed by OpenAI."
+             */
+            disclosureText?: string | false;
             /** @deprecated No-op on the realtime path: the server's STT owns turn-taking. */
             pauseDuration?: number;
             /** @deprecated No-op on the realtime path: the server's STT owns turn-taking. */
@@ -7013,6 +7108,13 @@ interface VoicePlaybackEngine {
     onFinished(callback: () => void): void;
     /** Release all audio resources. */
     destroy(): Promise<void> | void;
+    /**
+     * Optional. Speech-to-speech calls stream reply audio with no end-of-stream
+     * marker, so an engine that holds audio below a prebuffer waterline must, while
+     * continuous, release that held tail on its own (e.g. after a short input gap)
+     * instead of waiting for {@link markStreamEnd}. Engines without a prebuffer can omit it.
+     */
+    setContinuousMode?(enabled: boolean): void;
 }
 /**
  * A {@link VoicePlaybackEngine} that also supports pause/resume. Returned by
@@ -7060,6 +7162,18 @@ type VoiceConfig = {
          * `@runtypelabs/persona/voice-worklet-player` for a jitter-buffered engine.
          */
         createPlaybackEngine?: () => VoicePlaybackEngine | Promise<VoicePlaybackEngine>;
+        /** See `voiceRecognition.provider.runtype.prewarmMode`. @default 'request' */
+        prewarmMode?: 'request' | 'attach';
+        /** See `voiceRecognition.provider.runtype.attachIdleMs`. @default 30000 */
+        attachIdleMs?: number;
+        /** See `voiceRecognition.provider.runtype.clientDelegation`. @default true */
+        clientDelegation?: boolean;
+        /** See `voiceRecognition.provider.runtype.callContext`. */
+        callContext?: string | (() => string | Promise<string>);
+        /** See `voiceRecognition.provider.runtype.approvalTimeoutMs`. @default 300000 (capped at 540000) */
+        approvalTimeoutMs?: number;
+        /** See `voiceRecognition.provider.runtype.disclosureText`. */
+        disclosureText?: string | false;
         /** @deprecated No-op on the realtime path: the server's STT owns turn-taking. */
         pauseDuration?: number;
         /** @deprecated No-op on the realtime path: the server's STT owns turn-taking. */
@@ -7092,14 +7206,23 @@ interface VoiceProvider {
      * Register a callback for incremental transcript updates during a voice turn.
      * `isFinal=false` is a live interim update (user partials, or assistant deltas
      * on providers that stream them); `isFinal=true` finalizes that role's text.
-     * On the realtime `runtype` path, interim updates fire for the `user` only and
-     * the `assistant` arrives as a single final. Providers with overlapping turns
-     * must include the same turnId on user and assistant finals; without IDs,
-     * providers must discard cancelled output before emitting the next user final.
-     */
-    onTranscript?(callback: (role: 'user' | 'assistant', text: string, isFinal: boolean, metadata?: {
-        turnId?: string;
-    }) => void): void;
+     * On the classic realtime `runtype` path, interim updates fire for the `user`
+     * only and the `assistant` arrives as a single final; without a turnId the
+     * session assumes strictly alternating turns, and providers must discard
+     * cancelled output before emitting the next user final.
+     *
+     * When `metadata.turnId` is present (full-duplex / speech-to-speech, e.g.
+     * GPT-Live), the session reconciles by `(turnId, role)`: each pair owns one
+     * bubble that later updates replace in place, turns may overlap or arrive in
+     * any order, and no empty assistant placeholder is injected. User and
+     * assistant may share a turnId (a late user bubble then renders above its
+     * reply) or use distinct ones. `metadata.startMs` (call-relative ms when the
+     * utterance began) orders a new bubble among the call's other keyed bubbles;
+     * without it bubbles order by first arrival. After a stop, keyed providers
+     * must drop the cancelled reply's output until the server acknowledges the
+     * cancel: the session renders every reply it receives.
+     */
+    onTranscript?(callback: (role: 'user' | 'assistant', text: string, isFinal: boolean, metadata?: VoiceTranscriptMetadata) => void): void;
     /** Register a callback for per-turn latency metrics (realtime path). */
     onMetrics?(callback: (metrics: VoiceMetrics) => void): void;
     /**
@@ -7120,6 +7243,116 @@ interface VoiceProvider {
     deactivateBargeIn?(): Promise<void>;
     /** Stop playback / cancel in-flight request without starting recording */
     stopPlayback?(): void;
+    /**
+     * Warm the provider ahead of `startListening()` (the widget calls it on mic
+     * intent, see `voiceRecognition.prewarm`). Must be fire-and-forget: never
+     * throw, emit errors or status, or acquire the microphone. May be called
+     * repeatedly; throttle as needed.
+     */
+    prewarm?(): void;
+    /**
+     * Called by the session once after construction with the chat-side surface
+     * a full-duplex provider uses to hand agent turns to the chat pipeline
+     * ({@link VoiceSessionBridge}). Providers without client delegation omit it.
+     */
+    setSessionBridge?(bridge: VoiceSessionBridge): void;
+    /** The AI-disclosure notice for the live call, if one should show (speech-to-speech). */
+    getDisclosure?(): string | null;
+}
+/** Metadata on a {@link VoiceProvider.onTranscript} update. */
+type VoiceTranscriptMetadata = {
+    /** Groups updates that belong to one utterance bubble (full duplex). */
+    turnId?: string;
+    /** Call-relative ms when the utterance began; orders late bubbles. */
+    startMs?: number;
+    /** Call-relative ms of the latest audio this update covers. */
+    endMs?: number;
+    /**
+     * The bubble only captions speech (see `AgentWidgetMessage.voiceCaption`).
+     * The chat pipeline owns the conversation, as with client delegation.
+     */
+    caption?: boolean;
+};
+/** An agent turn a full-duplex voice model handed to the widget. */
+type VoiceDelegationRequest = {
+    /** The voice model's delegation id (`delegation_started.delegationId`). */
+    delegationId: string;
+    /** What the visitor asked, as the voice model heard it. */
+    userText: string;
+    /**
+     * The user transcript utterances `userText` joins, oldest first (the last
+     * is the one it came from). May be empty.
+     */
+    userUtteranceIds: string[];
+    /** The voice model's view of the conversation it delegated from. */
+    messages: Array<{
+        role: string;
+        content: unknown;
+    }>;
+};
+/**
+ * How a delegated turn ended, or that it waits on an approval (contract
+ * Amendment 5). `pending_approval` is the only non-terminal status. Open:
+ * a receiver treats an unknown terminal status as `failed`.
+ * - `completed`: the work ran.
+ * - `denied`: the visitor said no (Deny tap, or a spoken decline).
+ * - `timeout`: the approval lapsed (`approvalTimeoutMs`, or the server's own timeout).
+ * - `cancelled`: replaced by a newer request, or abandoned by the system.
+ * - `failed`: an error.
+ */
+type VoiceDelegationStatus = 'completed' | 'pending_approval' | 'denied' | 'timeout' | 'cancelled' | 'failed' | (string & {});
+/** The terminal result of a turn that parked on approvals. */
+type VoiceDelegationFollowUp = {
+    status: VoiceDelegationStatus;
+    /** What to read aloud (Markdown allowed). May be empty: nothing more to say. */
+    text: string;
+};
+/** The delegated turn's answer, sent back for the voice model to read aloud. */
+type VoiceDelegationResult = {
+    /** `pending_approval` when `followUp` is set; otherwise terminal. */
+    status: VoiceDelegationStatus;
+    /** The assistant text (Markdown allowed). */
+    text: string;
+    /**
+     * Set when the turn parked on approvals (`text` then asks for the decision).
+     * Resolves with the terminal result once the visitor decides (or the
+     * approval is replaced, declined by voice, or unanswered for
+     * `approvalTimeoutMs`) and the resumed turn finishes; `null` only when
+     * `signal` aborts first (hang-up, or the server cancelled the delegation).
+     */
+    followUp?: (options: {
+        signal: AbortSignal;
+        approvalTimeoutMs?: number;
+        /** `false`: run only the approval bookkeeping (expiry, supersede); nothing will be read back. @default true */
+        readBack?: boolean;
+        /** The resumed turn stopped on another approval: ask for it too (`text` is its approval script). */
+        onUpdate?: (text: string) => void;
+    }) => Promise<VoiceDelegationFollowUp | null>;
+};
+/**
+ * Chat-side surface the session hands a full-duplex provider: the visible
+ * history (for the call-start context) and a way to run a delegated turn
+ * through the normal chat pipeline.
+ */
+interface VoiceSessionBridge {
+    /** Visible user/assistant messages, oldest first. */
+    getHistory(): Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>;
+    /**
+     * Submit the turn as the visitor's message (reusing its transcript bubble)
+     * and resolve with the assistant's final answer once the turn settles.
+     * Waits for any chat turn already in flight first. Never rejects.
+     */
+    runDelegatedTurn(request: VoiceDelegationRequest): Promise<VoiceDelegationResult>;
+    /**
+     * The server dropped this delegation's result (cancelled it, or refused a
+     * late result): its chat answer is no longer spoken, so browser TTS may read it.
+     * `expired`: the server's deadline passed, so its pending approvals are
+     * declined too, as the approval TTL would.
+     */
+    dropDelegation?(delegationId: string, expired?: boolean): void;
 }
 /**
  * Extra context for an approval decision, surfaced to `onDecision` and to the
@@ -9814,6 +10047,11 @@ type AgentWidgetToolCall = {
     startedAt?: number;
     completedAt?: number;
     durationMs?: number;
+    /**
+     * The call paused for an approval that was granted, and the agent re-ran it
+     * as a new tool call: that later call carries the result, this one has none.
+     */
+    superseded?: boolean;
 };
 /**
  * Represents a tool approval request in the chat conversation.
@@ -9835,6 +10073,8 @@ type AgentWidgetApproval = {
      */
     reason?: string;
     parameters?: unknown;
+    /** The paused tool call this approval gates (`approval_start.toolCallId`). */
+    toolCallId?: string;
     resolvedAt?: number;
 };
 type AgentWidgetMessageVariant = "assistant" | "reasoning" | "tool" | "approval";
@@ -9934,6 +10174,13 @@ type AgentWidgetMessage = {
      * }
      */
     voiceProcessing?: boolean;
+    /**
+     * Display-only caption of full-duplex voice speech, such as the voice
+     * model's own words, or something the visitor said that wasn't submitted
+     * as a chat turn. It renders in the transcript but is never sent to the
+     * model as conversation.
+     */
+    voiceCaption?: boolean;
     /**
      * Raw structured payload for this message (e.g., JSON action response).
      * Populated automatically when structured parsers run.
@@ -10049,6 +10296,8 @@ type InjectMessageOptions = {
      * Consumers can detect this in `messageTransform` to render custom UI.
      */
     voiceProcessing?: boolean;
+    /** See {@link AgentWidgetMessage.voiceCaption}. */
+    voiceCaption?: boolean;
     /**
      * Raw structured payload (typically a JSON string) representing the
      * full directive that produced this message: e.g. `{ "text": "...",
@@ -10251,51 +10500,15 @@ type DispatchOptions = {
 type SSEHandler = (event: AgentWidgetEvent) => void;
 type SSEEventCallback = (eventType: string, payload: unknown) => void;
 declare class AgentWidgetClient {
+    #private;
     private config;
     private historyInternals;
-    private readonly apiUrl;
-    private readonly headers;
     private readonly debug;
-    private readonly createStreamParser;
-    private readonly contextProviders;
-    private readonly requestMiddleware?;
-    private readonly customFetch?;
-    private readonly parseSSEEvent?;
-    private readonly getHeaders?;
-    private onSSEEvent?;
-    /**
-     * 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;
     private clientSession;
-    private sessionInitPromise;
-    /**
-     * Early-init latch for `warmSession()`. `false` = armed. Otherwise it holds
-     * the session value (`null` or an expired session) the one early attempt was
-     * made against, so a failed attempt is not retried on every keystroke. It is
-     * re-armed when a session is installed or cleared, so each session lifetime
-     * gets one early init.
-     */
-    private sessionWarmLatch;
     private lastSentClientToolsFingerprint;
     private clientToolsFingerprintSessionId;
-    private sentNonEmptyClientToolsSessionId;
-    private historyUnavailable;
-    private historyUnavailableWarned;
-    private claimInFlight;
-    private historyIdentityStatus;
-    private historyIdentitySubscribers;
-    private historyAvailabilitySubscribers;
     private webMcpBridge;
-    private webMcpBridgePromise;
-    /** undefined = never set; null = explicitly cleared. Applied at adoption. */
-    private pendingWebMcpConfirmHandler;
     constructor(config?: AgentWidgetConfig, historyInternals?: WidgetHistoryInternals);
-    /** Load the lazy runtime chunk and construct the bridge with core-owned deps. */
-    private createWebMcpBridge;
-    /** Resolve the bridge, loading the runtime chunk on first use. */
-    private getWebMcpBridge;
     /**
      * Refresh config in place WITHOUT tearing down the live connection or the
      * WebMCP bridge. `AgentWidgetSession.updateConfig` calls this when only
@@ -10353,29 +10566,10 @@ declare class AgentWidgetClient {
      * Check if running in client token mode
      */
     isClientTokenMode(): boolean;
-    /**
-     * Resolve the effective backend routing for the current config. Combines the
-     * explicit `agentId`/`flowId` fields with the normalized `target` string
-     * (resolved via `resolveTarget`). Computed on demand so it stays correct
-     * across `update()`; the `target`/explicit-field conflict is rejected in the
-     * constructor, so at most one source is set here.
-     */
-    private routing;
     /**
      * Check if operating in agent execution mode
      */
     isAgentMode(): boolean;
-    /**
-     * Base URL for Runtype client-surface routes (`/v1/client/*`,
-     * `/v1/agents/*`). Strips a configured `/v1/dispatch` suffix so an apiUrl
-     * pointed at the dispatch endpoint still resolves its sibling routes. Not
-     * used for proxy-mode URLs, whose resume route is `${apiUrl}/resume`.
-     */
-    private clientApiBase;
-    /**
-     * Get the appropriate API URL based on mode
-     */
-    private getClientApiUrl;
     /**
      * Get the current client session (if any)
      */
@@ -10409,56 +10603,13 @@ declare class AgentWidgetClient {
      * `/v1/client/init`.
      */
     initSession(): Promise<ClientSession>;
-    /** Visitor history rides on client-token init only, and latches off after a 403 degrade. */
-    private isHistoryCapable;
     private readVisitorToken;
-    /** One-way, client-lifetime latch: chat keeps working without history. */
-    private markHistoryUnavailable;
     /** Public, secret-free view of the current identity state. */
     getHistoryIdentityStatus(): HistoryIdentityStatus;
     /** Deduped status notifications; carries no token, proof, or identity value. */
     subscribeHistoryIdentityStatus(callback: (status: HistoryIdentityStatus) => void): () => void;
     /** Fires only on the one-way 403 degrade; availability never returns. */
     subscribeHistoryAvailability(callback: (available: boolean) => void): () => void;
-    /** Config-derived state before any per-operation evidence exists. */
-    private restingIdentityStatus;
-    /** Keeps an already-observed browser_only reason; otherwise derives one. */
-    private browserOnlyStatus;
-    private derivedBrowserOnly;
-    /** Identical consecutive states are not re-announced. */
-    private setHistoryIdentityStatus;
-    /**
-     * The single uncached init primitive: builds one body, performs one fetch.
-     * `conversationId` and `sessionId` are mutually exclusive on the wire (strict
-     * server union), so a resume never carries the stored session id.
-     */
-    private createClientSession;
-    private _doInitSession;
-    /**
-     * An empty store means this init may mint a visitor, so it runs under the
-     * 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 ordinaryInit;
-    private doOrdinaryInit;
-    /**
-     * Ordinary init carrying an identity proof: binds/rebinds the visitor,
-     * persists any replacement token (inside `createClientSession`), and installs
-     * the result as the live session.
-     */
-    private reinitWithProof;
-    /**
-     * A minted visitor means the record this session just created is still
-     * unowned; one immediate re-init with `{visitorToken, sessionId}` claims it.
-     */
-    private claimFirstConversation;
-    /**
-     * Continuity guard + id persistence. A different record than the persisted
-     * one is a privacy transition, announced before the new id is written.
-     */
-    private finishInit;
-    /** Wrap an uncached init so nothing installs until the winner commits. */
-    private prepared;
     /**
      * Transactional reopen of a known conversation. Always bypasses the session
      * cache, never sends the stored session id, and needs a credential the server
@@ -10485,10 +10636,6 @@ declare class AgentWidgetClient {
      * when the conversation is reset (`WidgetSession.clearMessages`).
      */
     resetClientToolsFingerprint(): void;
-    /**
-     * Get the feedback API URL
-     */
-    private getFeedbackApiUrl;
     /**
      * Send feedback for a message (client token mode only).
      * Supports upvote, downvote, copy, csat, and nps feedback types.
@@ -10547,37 +10694,6 @@ declare class AgentWidgetClient {
      * @param comment - Optional comment
      */
     submitNPSFeedback(rating: number, comment?: string): Promise<void>;
-    /** `/v1/client/<path>` with a query string; credentials ride in headers. */
-    private historyUrl;
-    /** Explicit per-operation scope wins; otherwise config, then evidence. */
-    private resolveHistoryScope;
-    private resolveChatIdentityProof;
-    /**
-     * Resolve the proof for one logical request. `null` is an intentional
-     * browser-scope fallback only while the visitor has never been bound.
-     */
-    private resolveIdentityProof;
-    /** Bind the visitor before the first verified request; admitted proofs only. */
-    private bindIdentity;
-    private readErrorCode;
-    /**
-     * Selective one-shot 401 recovery. Returns the session to retry under;
-     * anything unrecoverable throws typed and is never retried.
-     */
-    private recoverFromUnauthorized;
-    private historyErrorFor;
-    /**
-     * Validate `X-History-Identity-Status` before any body is committed: the
-     * per-operation acknowledgement, not a prior init, is what proves scope.
-     */
-    private commitIdentityAcknowledgement;
-    /**
-     * 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 historyFetch;
-    private assertHistoryUsable;
     /** One page of the visitor's conversations, newest first. */
     listConversations(opts?: {
         cursor?: string;
@@ -10629,18 +10745,6 @@ declare class AgentWidgetClient {
      * Send a message - handles both proxy and client token modes
      */
     dispatch(options: DispatchOptions, onEvent: SSEHandler): Promise<void>;
-    /**
-     * Client token mode dispatch
-     */
-    private dispatchClientToken;
-    /**
-     * Proxy mode dispatch (original implementation)
-     */
-    private dispatchProxy;
-    /**
-     * Agent mode dispatch
-     */
-    private dispatchAgent;
     /**
      * Process an external SSE stream through the SDK's event pipeline.
      * This allows piping responses from endpoints like agent approval
@@ -10650,114 +10754,25 @@ declare 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.
      */
     resolveApproval(approval: {
         agentId: string;
         executionId: string;
         approvalId: string;
     }, decision: 'approved' | 'denied'): Promise<Response>;
-    /**
-     * Resume a paused flow execution by supplying outputs for LOCAL
-     * (client-executed) tools. Used by the built-in `ask_user_question`
-     * answer-pill sheet, but generic enough for any LOCAL tool.
-     *
-     * Routes by mode:
-     *  - **client-token mode**: POST `${apiBase}/v1/client/resume` (the
-     *    session-authenticated sibling of `/v1/client/chat`; runtypelabs/core#3889),
-     *    with the active `sessionId` in the body and no Bearer key: a browser
-     *    client-token page holds no secret. The page's tool registry is
-     *    re-snapshotted and sent alongside `toolOutputs` via the same diff-only
-     *    `clientTools` / `clientToolsFingerprint` protocol as `/v1/client/chat`
-     *    (runtypelabs/core#5361), so tools registered by a mid-run page
-     *    navigation replace the run's dispatch-time set and become callable on
-     *    the next model turn. Old servers strip the unknown fields and keep the
-     *    frozen-at-dispatch behavior.
-     *  - **dispatch / proxy mode**: POST `${apiUrl}/resume`: Runtype mounts
-     *    resume as a child of `/v1/dispatch`, so the URL is `${apiUrl}/resume`,
-     *    and proxies follow the same shape (`/api/chat/dispatch/resume`).
-     *
-     * Returns the raw Response so the caller can pipe its SSE body through
-     * `connectStream()`.
-     *
-     * @param executionId - The paused execution id carried on `await`.
-     * @param toolOutputs - Map keyed by per-call `toolCallId` (core#3878),
-     *   falling back to tool name for legacy servers → the tool's result value.
-     */
-    /**
-     * Diff-only / send-once WebMCP clientTools transport, shared by the
-     * client-token chat (`/v1/client/chat`) and resume (`/v1/client/resume`)
-     * paths — both routes speak the same protocol (runtypelabs/core#5361).
-     *
-     * Decides, against the shared fingerprint cache, whether this request ships
-     * the full `clientTools[]` + fingerprint (first send under this session, or
-     * a changed set) or the fingerprint alone (unchanged set; the server reuses
-     * its stored copy). Runs `doFetch` with the chosen fields and retries
-     * EXACTLY once with the full array on a
-     * `409 { error: 'client_tools_resend_required' }` registry miss — the retry
-     * is 409-*triggered*, never 409-*expected*, so servers predating the
-     * protocol (which strip the unknown fields and never 409) work unchanged.
-     * The 409 body is probed on a `clone()` so the original response body stays
-     * readable by the caller's error handling.
-     *
-     * The cache is NOT committed here: callers invoke the returned `commit()`
-     * only after the server has accepted the request (response OK / stream
-     * started), so a failed request can never record a fingerprint the server
-     * never stored. A resend-required miss invalidates the cached fingerprint
-     * immediately so later turns keep resending in full until a clean success
-     * commits a fresh one.
-     *
-     * `emptyMeansReplace` (resume only): when the live snapshot is empty but a
-     * non-empty set was committed under this session and never explicitly
-     * cleared (the paused tool navigated to a page with no tool registry), ship
-     * an explicit `clientTools: []` so the server REPLACES the persisted
-     * dispatch-time set with nothing and clears its stored registry. Chat keeps
-     * its omit-when-empty behavior: on `/chat`, absent fields already mean "no
-     * tools this turn", whereas on `/resume` absence means "keep the frozen
-     * dispatch-time set".
-     */
-    private sendWithClientToolsDiff;
     resumeFlow(executionId: string, toolOutputs: Record<string, unknown>, options?: {
         streamResponse?: boolean;
         signal?: AbortSignal;
         after?: string;
     }): Promise<Response>;
-    /**
-     * The opt-in structured mention channel: the MOST RECENT user turn's
-     * `mentionContext` (set by `session.applyMentionBundle`) namespaced under
-     * `mentions`. Only the latest user message is consulted — otherwise an older
-     * turn's mentions would re-attach to `context.mentions` on every later send.
-     * Returns null when the latest user turn carried no structured mention context.
-     * The default model-visible path (`llmAppend`) already rode into the message's
-     * `llmContent`/`contentParts`, so it needs nothing here.
-     */
-    private latestMentionContext;
-    /**
-     * Aggregate request `context`: merge every context provider's result with the
-     * opt-in mention context from the latest user turn. Returns null when nothing
-     * contributed, so callers can skip setting `payload.context`. Shared by the
-     * agent and flow payload builders.
-     */
-    private buildContextAggregate;
-    /**
-     * Non-empty composer selections only. An empty snapshot leaves the field off
-     * the wire entirely, so a widget with no picker and no modes sends exactly
-     * what it sent before.
-     */
-    private normalizeComposerOptions;
-    /**
-     * Rule 4: an inline client-defined agent may take the turn's model from the
-     * composer, but only for an id the host actually declared in
-     * `composer.models`. Config is untouched; the mapping is per request.
-     */
-    private applyInlineAgentModel;
-    private buildAgentPayload;
-    private buildPayload;
-    /**
-     * Handle custom SSE event parsing via parseSSEEvent callback
-     * Returns true if event was handled, false otherwise
-     */
-    private handleCustomSSEEvent;
-    private streamResponse;
 }
 
 /** The resolved bundle gathered at submit, merged into the user message. */
@@ -10831,6 +10846,7 @@ type SessionHistoryNotice = {
     message: string;
 };
 declare class AgentWidgetSession {
+    #private;
     private config;
     private callbacks;
     private historyInternals;
@@ -10839,79 +10855,16 @@ declare class AgentWidgetSession {
     private status;
     private streaming;
     private abortController;
-    private sequenceCounter;
     private clientSession;
     private agentExecution;
-    private resumable;
-    private activeAssistantMessageId;
-    private reconnecting;
-    private reconnectController;
-    private reconnectControllerPromise;
-    private executionStateTimer;
     private artifacts;
-    private selectedArtifactId;
     private webMcpInflightKeys;
     private webMcpResolvedKeys;
     private webMcpResolveControllers;
-    private webMcpEpoch;
     private webMcpApprovalResolvers;
-    private webMcpApprovalSeq;
+    private approvalTokens;
     private webMcpAwaitBatches;
-    private voiceProvider;
-    /** In-flight setupVoice chunk load; toggleVoice awaits it when racing setup. */
-    private voiceSetupPromise;
-    /** Bumped by setupVoice/cleanupVoice so a stale chunk load can't install. */
-    private voiceSetupGeneration;
-    /** Latest 0..1 capture amplitude pushed by a provider that reports one. */
-    private voiceLevel;
-    private voiceActive;
-    private voiceStatus;
-    private activeConversationId;
-    private activeConversationRevision;
-    private historyNextMessageCursor;
-    /** Monotonic: a later selection supersedes every earlier fetch/prepare. */
-    private historyOpenEpoch;
-    /** Blocks `setClientSession`'s welcome branch across a reopen re-init. */
-    private suppressWelcomeInjection;
-    private historyRecovery;
-    private historySendBlocked;
-    /** Continuity wipe / boot reconciliation; dispatch waits on it. */
-    private historyGate;
-    /** Deduped by `(id, cursor)` so repeated clicks issue one request. */
-    private olderPageRequests;
-    /** Serializes projection finalization against every other operation. */
-    private projectionFinalizationPromise;
-    /** Message id → projection the server has acknowledged (sent or finalized). */
-    private acknowledgedProjections;
-    private pendingProjections;
-    /** Persisted revision as it stood before boot init overwrote it. */
-    private bootConversationRevision;
-    private bootRevisionCaptured;
-    /** Exactly one visitor-store subscription per instance; re-keyed with the store. */
-    private visitorStoreUnsubscribe;
-    private subscribedVisitorStore;
-    /** An external credential change happened; the next dispatch must re-init. */
-    private credentialReinitPending;
-    private credentialReinitPromise;
     constructor(config: AgentWidgetConfig | undefined, callbacks: SessionCallbacks, historyInternals?: WidgetHistoryInternals);
-    /**
-     * Warm the deferred voice-runtime chunk (provider factory + providers) at
-     * init when a voice provider is configured, so setupVoice / the first mic
-     * click resolve against a warm module. Module fetch only — WebSocket and
-     * AudioContext still wait for their own triggers. Errors are swallowed: the
-     * setupVoice path retries via the chunk loader's rejection-retry.
-     */
-    private prefetchVoiceRuntime;
-    /**
-     * Warm the deferred Runtype TTS engine chunk at init so it's resolved before
-     * the first "Read aloud" click. Module fetch only — no AudioContext (that
-     * still waits for the user gesture on first playback). In the IIFE/CDN build
-     * this fetches the standalone `runtype-tts.js`; in bundler builds the module
-     * is already inlined, so this is a cheap no-op. Errors are swallowed: a failed
-     * prefetch just means the chunk loads on first click instead (or, on a hard
-     * failure, the browser-voice fallback kicks in).
-     */
-    private prefetchRuntypeTts;
     /**
      * Set callback for capturing raw SSE events (forwards to client)
      */
@@ -10944,6 +10897,8 @@ declare class AgentWidgetSession {
      * Get current voice status
      */
     getVoiceStatus(): VoiceStatus;
+    /** The live call's AI-disclosure notice, if it shows one. */
+    getVoiceDisclosure(): string | null;
     /**
      * Get the voice interruption mode from the provider (none/cancel/barge-in)
      */
@@ -10963,40 +10918,27 @@ declare class AgentWidgetSession {
     isBargeInActive(): boolean;
     /** Tear down the barge-in mic pipeline: "hang up" the always-on mic */
     deactivateBargeIn(): Promise<void>;
-    private pendingVoiceUserMessageId;
-    private pendingVoiceAssistantMessageId;
-    private voiceTurns;
-    private voiceDisconnectPromise;
     private ttsSpokenMessageIds;
     private readAloud;
-    /**
-     * Resolve the speech engine behind read-aloud (and auto-speak):
-     *   1. An explicit `textToSpeech.createEngine` always wins (full BYO control).
-     *   2. `provider: 'runtype'` builds the hosted {@link RuntypeSpeechEngine}
-     *      from the widget config (host = `apiUrl`, `agentId`, `clientToken`),
-     *      wrapped in a browser {@link FallbackSpeechEngine} unless
-     *      `browserFallback: false` — so a missing endpoint or transient failure
-     *      degrades to the browser voice instead of erroring, and auto-upgrades to
-     *      Runtype voices the day the endpoint ships.
-     *   3. Otherwise the browser Web Speech API engine.
-     */
-    private createSpeechEngine;
     /**
      * Setup voice recognition with the given configuration
      */
     setupVoice(config?: VoiceConfig): void;
-    /** Wire callbacks onto a freshly constructed provider and connect it. */
-    private wireVoiceProvider;
     /**
      * Toggle voice recognition on/off
      */
     toggleVoice(): Promise<void>;
+    /**
+     * Warm the voice path ahead of the mic click (`voiceRecognition.prewarm`).
+     * Session-owned providers (`runtype`, `custom`) get `provider.prewarm()` once
+     * the lazy voice runtime has installed them; the browser (Web Speech) path
+     * warms the client-token session instead. Fire-and-forget and silent.
+     */
+    prewarmVoice(): void;
     /**
      * Cleanup voice resources
      */
     cleanupVoice(): void;
-    private disconnectVoice;
-    private settlePendingVoiceTurn;
     /**
      * Extract voice configuration from widget config
      */
@@ -11017,12 +10959,6 @@ declare class AgentWidgetSession {
      * Set the client session after initialization
      */
     setClientSession(session: ClientSession, pristine?: boolean): void;
-    /**
-     * Welcome injection is skipped while `suppressWelcomeInjection` is latched:
-     * reopening a stored conversation is not a new thread, and the hydrated
-     * transcript would otherwise race a welcome bubble.
-     */
-    private injectWelcomeMessage;
     /**
      * Get current client session
      */
@@ -11071,26 +11007,10 @@ declare class AgentWidgetSession {
     setHistoryInternals(internals: WidgetHistoryInternals): void;
     /** Widget teardown: release the visitor-store subscription. */
     destroy(): void;
-    /**
-     * The session always owns the continuity transition, whether or not the shell
-     * supplied its own observer: a credential/record break must wipe local state
-     * before the replacement session becomes sendable.
-     */
-    private composeHistoryInternals;
-    private get historyProvider();
-    private requireHistoryProvider;
-    /**
-     * One resolved scope per logical action. An explicitly requested scope the
-     * provider cannot serve fails locally rather than silently downgrading.
-     */
-    private historyContext;
     getHistoryState(): SessionHistoryState;
     getActiveConversationId(): string | null;
-    private emitHistoryState;
-    private notifyHistory;
     /** Pending destructive/reconciliation work every other operation waits on. */
     awaitHistorySettled(): Promise<void>;
-    private assertHistoryIdle;
     listConversations(opts?: {
         cursor?: string;
         limit?: number;
@@ -11115,7 +11035,6 @@ declare class AgentWidgetSession {
     loadOlderMessages(id: string, cursor?: string | null, opts?: {
         scope?: HistoryScope;
     }): Promise<HistoryOlderPage>;
-    private fetchOlderPage;
     /**
      * The canonical new-thread operation. A failed prepare leaves the current
      * conversation completely intact.
@@ -11123,11 +11042,6 @@ declare class AgentWidgetSession {
     startNewConversation(opts?: {
         scope?: HistoryScope;
     }): Promise<void>;
-    /**
-     * Clear local + persisted conversation state, then commit the replacement.
-     * Welcome injection is deliberately allowed once the transcript is empty.
-     */
-    private installFreshConversation;
     /**
      * Deleting the active record (or everything) is already irreversible: the
      * transcript is destroyed first, then a replacement session is prepared.
@@ -11154,60 +11068,12 @@ declare class AgentWidgetSession {
     resetHistoryDevice(): Promise<{
         remoteRevocationConfirmed: boolean;
     }>;
-    private recoverFromDestroyedConversation;
-    /**
-     * Never reinstalls the deleted session. A failed preparation leaves an
-     * explicit recoverable state instead of the old transcript.
-     */
-    private prepareReplacementConversation;
-    /** The next explicit action retries a failed replacement preparation. */
-    private retryRequiredConversation;
-    /**
-     * Install a prepared activation. The provider's commit also invokes the
-     * session binding (`bindActivatedSession`); the fallback covers a shell that
-     * has not wired that callback yet.
-     */
-    private commitActivation;
     /**
      * Session-owned binding for a winning prepared activation. Installs the
      * client session WITHOUT the ordinary welcome branch while the reopen latch
      * is set, and persists the replacement ids through the normal storage path.
      */
     bindActivatedSession(session: ClientSession): void;
-    private persistConversationMetadata;
-    /** Conversation-scoped caches that must not leak across records. */
-    private resetConversationScopedState;
-    /**
-     * Irreversible local + persisted clear. Used by new-conversation, active
-     * deletion, 410 recovery, reset, and the continuity wipe.
-     */
-    private discardConversationState;
-    /**
-     * D6 continuity wipe (session side): a replacement visitor, identity rebind,
-     * cross-tab convergence, or credential expiry selected a different record.
-     * Invalidate synchronously; dispatch stays blocked until cleanup completes.
-     */
-    private handleHistoryContinuityChanged;
-    /**
-     * One subscription per widget instance, re-keyed when the controller swaps
-     * the store. Owned here so the transition sits beside the continuity wipe it
-     * reuses.
-     */
-    private syncVisitorStoreSubscription;
-    /**
-     * D3 privacy boundary: a sibling tab cleared or replaced the shared visitor
-     * credential. Privacy wins over turn continuity, so a live turn is cancelled.
-     * A "local" change is this tab's own mint/write and owns its init path; a
-     * change out of an empty store is first-init convergence, not a break.
-     */
-    private handleExternalCredentialChange;
-    /**
-     * Dispatch may not proceed until a session exists under the NEW credential.
-     * Deliberately lazy: re-initializing on the storage event itself would hand
-     * an idle tab a fresh credential the visitor just deleted elsewhere.
-     */
-    private completeCredentialReinit;
-    private runCredentialReinit;
     /**
      * Authoritative boot reconciliation (D4). Runs after a `conversationId` boot
      * resume and before chat becomes sendable: an unchanged revision needs no
@@ -11217,47 +11083,11 @@ declare class AgentWidgetSession {
     reconcileBootConversation(opts?: {
         scope?: HistoryScope;
     }): Promise<void>;
-    private runBootReconciliation;
-    /** Runtype transport op: active session + browser scope, never a proof. */
-    private projectionFinalizationEnabled;
-    private setPendingProjections;
-    private readPendingProjections;
-    /** Record what the dispatch payload carried as each message's projection. */
-    private recordDispatchedProjections;
-    /**
-     * After a terminal assistant message, finalize any browser-derived projection
-     * the server cannot have. Painting is never delayed by this.
-     */
-    private scheduleProjectionFinalization;
-    /** Serialized: operations await this chain instead of racing it. */
-    private enqueueProjectionFinalization;
-    private finalizeProjections;
-    /** Transport-shaped failures only; a contract failure is not retried. */
-    private isTransientProjectionError;
-    private clearFinalizedMarker;
     /**
      * Boot replay: rebuild the batch from the persisted ids plus the local
      * message content, then finalize before display reconciliation completes.
      */
     replayPendingProjections(): Promise<void>;
-    /**
-     * A local transcript mutation whose response carries no new revision: clear
-     * the persisted one rather than guessing, so the next boot refreshes safely.
-     */
-    private invalidateConversationRevision;
-    /** Blocks a send until the owning history transition finishes. */
-    private awaitHistorySendable;
-    private static isConversationDeleted;
-    /**
-     * Safe 410 recovery (D5). The old payload would recreate the transcript that
-     * was just deleted, so the retry carries ONLY the just-submitted user turn.
-     */
-    private dispatchWithDeletedRecovery;
-    /**
-     * Capture only the newly submitted user message, destroy the deleted record's
-     * local state, and initialize a fresh owned conversation to retry into.
-     */
-    private recoverFromDeletedConversation;
     updateConfig(next: AgentWidgetConfig): void;
     getMessages(): AgentWidgetMessage[];
     getStatus(): AgentWidgetSessionStatus;
@@ -11354,15 +11184,6 @@ declare class AgentWidgetSession {
      * });
      */
     injectComponentDirective(options: InjectComponentDirectiveOptions): AgentWidgetMessage;
-    /**
-     * Resolve the gathered mentions and merge them into the user message's
-     * model-visible content. Default path is `llmAppend` → `llmContent` (or a text
-     * `contentPart` when parts are present, since `contentParts` wins the priority
-     * chain); the opt-in structured `context` lands on `mentionContext` for the
-     * client to namespace into the request `context`. Failures were already
-     * dropped by `finalize()`.
-     */
-    private applyMentionBundle;
     sendMessage(rawInput: string, options?: {
         viaVoice?: boolean;
         /** Multi-modal content parts (e.g., images) to include with the message */
@@ -11407,6 +11228,15 @@ declare class AgentWidgetSession {
          * (`composer.streamingSubmitBehavior: "interrupt"`).
          */
         interrupt?: boolean;
+        /**
+         * Internal (voice client delegation): this is the delegated voice turn.
+         * `userMessageId` names an existing transcript bubble to submit as the
+         * turn's user message instead of appending a new one, so the spoken
+         * request appears (and is sent) exactly once.
+         */
+        voiceTurn?: {
+            userMessageId?: string;
+        };
     }): Promise<void>;
     /**
      * Re-run the conversation from one user turn (docs/composer-gap-analysis.md
@@ -11430,8 +11260,6 @@ declare class AgentWidgetSession {
      * turn would carry no content; nothing is truncated in that case.
      */
     resubmitFrom(messageId: string, options: ComposerResubmitOptions): boolean;
-    /** Submission options → the wire payload shape; quote travels separately. */
-    private toComposerOptionsPayload;
     /**
      * Continue the conversation without adding a new user message.
      * Triggers the model to respond based on the current conversation state.
@@ -11466,13 +11294,6 @@ declare class AgentWidgetSession {
          */
         seedContent?: string;
     }): Promise<void>;
-    /**
-     * Install the native approval-bubble confirm handler on the WebMCP bridge
-     * when the integrator hasn't supplied a custom `webmcp.onConfirm`. Without
-     * this, the bridge falls back to a blunt `window.confirm`. Safe to call
-     * repeatedly (e.g. after the client is re-created in `updateConfig`).
-     */
-    private wireDefaultWebMcpConfirm;
     /**
      * Default WebMCP confirm gate: render Persona's native in-panel approval
      * bubble and resolve when the user clicks Approve/Deny. Returns immediately
@@ -11506,6 +11327,14 @@ declare class AgentWidgetSession {
      *   3. Append a user-visible bubble with the answer text so the
      *      transcript reads naturally.
      */
+    resolveAskUserQuestion(toolMessage: AgentWidgetMessage, answer: string | Record<string, string | string[]>): Promise<void>;
+    /**
+     * Resolve a paused auto-resolving LOCAL tool call (`webmcp:*` page tools
+     * and the built-in `suggest_replies`) and post the result to `/resume`.
+     * Triggered automatically from `handleEvent`; idempotent on the message's
+     * `toolCall.id`. See `resolveWebMcpToolCall` in `session-actions.ts`.
+     */
+    resolveWebMcpToolCall(toolMessage: AgentWidgetMessage): Promise<void>;
     /**
      * Persist in-progress answers and the current page index for a multi-question
      * `ask_user_question` payload, so a refresh resumes on the same page with
@@ -11524,123 +11353,6 @@ declare class AgentWidgetSession {
      * answers via top-level merge.
      */
     markAskUserQuestionResolved(toolMessage: AgentWidgetMessage, answers?: Record<string, string | string[]>): void;
-    resolveAskUserQuestion(toolMessage: AgentWidgetMessage, answer: string | Record<string, string | string[]>): Promise<void>;
-    /**
-     * Collect an auto-resolving LOCAL-tool `await` (`webmcp:*` page tools
-     * and the built-in `suggest_replies`) into a per-executionId batch
-     * and schedule a single deferred flush. Parallel calls (core#3878) emit
-     * several `await`s for ONE paused execution within the same stream tick;
-     * buffering them and flushing once lets us post ONE `/resume` keyed by the
-     * per-call `webMcpToolCallId` rather than racing N name-keyed resumes on the
-     * same execution (which 404'd on the second and hung the turn).
-     *
-     * Deferred via `queueMicrotask` (epoch-guarded) for the same reason the old
-     * direct resolve was: handleEvent must return first so the dispatch's
-     * `connectStream` sees end-of-stream and releases the shared abortController
-     * before a resolve grabs it.
-     *
-     * Awaits without an `executionId` or `toolCall.id` can't be batched (no key)
-     *: route them straight to the single-call path, which surfaces the malformed
-     * wire shape via `onError` / an `isError` resume.
-     */
-    private enqueueWebMcpAwait;
-    /**
-     * Flush every buffered local-tool await batch, one `/resume` per executionId.
-     * Called once a stream ends (`status: idle` / `error`): by then all parallel
-     * `await`s the stream carried have been collected, even if split across
-     * SSE chunks. Deferred via `queueMicrotask` (epoch-guarded) so the idle
-     * handler returns first and the stream's end-of-stream teardown (streaming /
-     * abortController) settles before a resolve grabs them: the same ordering the
-     * single-call resolve always relied on.
-     */
-    private scheduleWebMcpBatchFlush;
-    /**
-     * Run a buffered batch of local-tool awaits for one executionId. Size 1
-     * (single call, or distinct-tool turns that happened to arrive alone) takes
-     * the original single-call path; size >1 (parallel calls) takes the batched
-     * path that posts ONE `/resume`. The batch is removed from the map up front
-     * so any later sibling re-emit (e.g. from a re-pause) forms a fresh batch
-     * rather than mutating one already in flight.
-     */
-    private flushWebMcpAwaitBatch;
-    private resolveWebMcpToolStartedAt;
-    /**
-     * Persisted-resolution guard for `suggest_replies`. The in-memory dedupe
-     * sets (`webMcpInflightKeys` / `webMcpResolvedKeys`) are cleared by
-     * hydrateMessages/clearMessages/cancel, but `suggestRepliesResolved`
-     * survives on the stored message, so a stale `await` re-emit after a
-     * hydration must not re-POST `/resume` for an already-resolved call (the
-     * historical double-resume failure mode the batching work exists to avoid).
-     * Checks the LIVE message first; the handleEvent snapshot is a fresh wire
-     * skeleton whose metadata never carries the flag.
-     */
-    private isSuggestRepliesAlreadyResolved;
-    private markWebMcpToolRunning;
-    private markWebMcpToolComplete;
-    /**
-     * Resolve one or more parallel local-tool awaits sharing one paused
-     * executionId with a SINGLE `/resume` (core#3878); `resolveWebMcpToolCall`
-     * delegates size-1 resolves here after its guards. By default each call is
-     * executed against the page registry concurrently: every gated call renders
-     * its own native approval bubble, and a sibling's confirm Promise never
-     * blocks another's execution. With `webmcp.execution: "sequential"` the
-     * calls run one at a time in emission order instead (see the config docs
-     * for when that matters). Outputs are keyed by per-call `webMcpToolCallId`
-     * (server prefers it over tool name; name-keying remains the fallback for
-     * legacy single/distinct-tool turns), so two calls to the SAME tool no longer
-     * collide. The server is tolerant: any call we omit (declined-after-abort,
-     * dedupe, exec failure) simply re-pauses and is retried on its re-emit.
-     *
-     * Owns the dedupe / abort / streaming machinery for both routes; resolved
-     * keys are marked on the shared resume POST's HTTP OK.
-     */
-    private resolveWebMcpToolCallBatch;
-    /**
-     * Resolve a paused auto-resolving LOCAL tool call and post the result to
-     * `/resume`: `webmcp:*` calls execute against the host page's tool
-     * registry; the built-in `suggest_replies` skips execution entirely and
-     * resumes with a canned "shown" result (the chips render from the message
-     * list, not from this resolve).
-     *
-     * Triggered automatically from `handleEvent` when an `await`-derived
-     * message arrives for such a tool: the user does not click a pill; the
-     * bridge's confirm-bubble gate (WebMCP only) is the only interactive
-     * surface.
-     *
-     * Idempotent on the message's `toolCall.id`: re-emits of the same await
-     * (e.g. from message coalescing) won't double-fire `tool.execute`. Failure
-     * modes, declined, timed out, throw, unknown tool, all resolve into a
-     * `{ isError: true, content: [...] }` payload that resumes the dispatch
-     * cleanly so the agent can recover.
-     *
-     * After the malformed-wire guards this is a thin gate over
-     * `resolveWebMcpToolCallBatch` with a size-1 batch: the dedupe check runs
-     * synchronously here so a stale re-emit never toggles streaming.
-     */
-    resolveWebMcpToolCall(toolMessage: AgentWidgetMessage): Promise<void>;
-    /**
-     * POST `/resume` with a SINGLE tool's output and pipe the resulting SSE
-     * stream back through `connectStream`. Shared by every single-call local-tool
-     * resolve path (ask_user_question and single WebMCP calls). Parallel WebMCP
-     * calls use `resolveWebMcpToolCallBatch`, which posts one resume for many.
-     *
-     * `resumeKey` is the `toolOutputs` map key: the per-call `webMcpToolCallId`
-     * for WebMCP (core#3878), or the tool name for ask_user_question / legacy
-     * servers. `onHttpOk` runs synchronously between the HTTP-status check and the
-     * stream pipe; it lets the WebMCP resolve path commit the dedupe flag at
-     * "server accepted the answer" rather than "stream finished cleanly".
-     */
-    private resumeWithToolOutput;
-    /**
-     * Tear down every in-flight WebMCP resolve and advance the epoch. Each
-     * resolve owns a dedicated AbortController (chained/parallel resolves don't
-     * share one), so we abort them individually; the aborts propagate into the
-     * bridge's execute race and into each `/resume` fetch signal. Bumping
-     * `webMcpEpoch` strands any resolve still deferred in a queued microtask:   * it captured the prior epoch and bails before installing a fresh
-     * controller, so it can't escape this teardown. Called from every stop /
-     * new-turn boundary (cancel, clearMessages, hydrateMessages, sendMessage).
-     */
-    private abortWebMcpResolves;
     cancel(): void;
     clearMessages(): void;
     getArtifacts(): PersonaArtifactRecord[];
@@ -11649,68 +11361,9 @@ declare class AgentWidgetSession {
     selectArtifact(id: string | null): void;
     clearArtifacts(): void;
     upsertArtifact(manual: PersonaArtifactManualUpsert): PersonaArtifactRecord;
-    /**
-     * Injects (or refreshes) the in-thread artifact block for a programmatically
-     * upserted artifact, matching the streamed UX: the resolved display mode
-     * picks the component ("collapsed"/"panel" → reference card, "inline" → inline
-     * preview).
-     *
-     * Unlike the streamed path (which embeds content on `artifact_complete`),
-     * the programmatic record is complete up front, so the final markdown /
-     * file meta / component name + props are embedded immediately and the block
-     * hydrates after a refresh without the original registry state.
-     *
-     * A re-upsert of the same id rebuilds the existing block's persisted
-     * rawContent in place (the registry is not persisted, so hydration reads
-     * these props); without this the block would keep the first version's
-     * content after a refresh.
-     */
-    private injectArtifactRefBlock;
-    /**
-     * Re-materialize existing transcript artifact blocks after a live display
-     * preference update. One messages callback keeps conversion atomic.
-     */
-    private refreshArtifactReferenceBlocks;
-    private clearArtifactState;
-    private emitArtifactsState;
-    private applyArtifactStreamEvent;
     hydrateMessages(messages: AgentWidgetMessage[]): void;
     hydrateArtifacts(artifacts: PersonaArtifactRecord[], selectedId?: string | null): void;
     private handleEvent;
-    /**
-     * Record the latest SSE `id:` cursor and (lazily) form/advance the resume
-     * handle. Needs an executionId (lifted into `agentExecution` from the same
-     * frame's metadata, handled before this trailing cursor event) and the active
-     * assistant message id.
-     */
-    private trackCursor;
-    /**
-     * The drop gate: is this stream-end a dropped connection we should reconnect,
-     * rather than a graceful finish or an intentional `await` pause? ALL must
-     * hold (see plan §Design overview keystone 3).
-     */
-    private isDurableDrop;
-    /**
-     * True when the run is parked awaiting user input (an unanswered
-     * `ask_user_question` / local-tool await, or a pending approval). Those end
-     * the stream with `idle` and no terminal too, but are NOT drops.
-     */
-    private isAwaitPending;
-    /**
-     * Enter the reconnect flow. Keeps the assistant bubble open and `streaming`
-     * true, flips to `resuming`, and kicks the bounded backoff loop. Re-entrant
-     * calls (a second drop while reconnecting) are no-ops.
-     */
-    private beginReconnect;
-    /**
-     * Lazily import and instantiate the reconnect controller. Cached so repeated
-     * reconnects reuse one controller (and one module load). Deliberately kept off
-     * every hot path (`sendMessage` / `cancel` / `teardownReconnect`) so a widget
-     * that never reconnects never pulls the chunk.
-     */
-    private loadReconnectController;
-    /** The narrow surface the lazily-loaded reconnect loop drives. */
-    private buildReconnectHost;
     /** Public manual retry (e.g. a "Reconnect" button). */
     reconnectNow(): void;
     /**
@@ -11722,34 +11375,13 @@ declare class AgentWidgetSession {
         executionId: string;
         after: string;
     }): void;
-    /**
-     * Reopen the trailing assistant bubble (the persisted partial) so replayed
-     * deltas append to it. Returns its id, or null if the last turn doesn't end
-     * in a plain assistant message.
-     */
-    private reopenTrailingAssistant;
-    /**
-     * Tear down any in-flight/pending reconnect and clear the resume handle. Runs
-     * on every new turn / cancel / hydrate, so it must NOT pull the reconnect
-     * chunk: it only delegates to the controller if one was already created.
-     */
-    private teardownReconnect;
-    /** Drop the resume handle and notify the host (`onExecutionState(null)`). */
-    private clearResumable;
-    /**
-     * Surface the resume handle to the host for persistence. Immediate on
-     * create/clear; trailing-edge throttled on cursor advances so it isn't called
-     * per delta.
-     */
-    private notifyExecutionState;
     /** The current durable resume handle, if any (read-only). */
     getResumableHandle(): ResumableHandle | null;
-    private setStatus;
-    private setStreaming;
     /**
      * Speak the latest assistant message using the Web Speech API
      * if text-to-speech is enabled in the config.
      */
+    /** `only`: speak it only if the latest assistant message is one of these. */
     private speakLatestAssistantMessage;
     /**
      * Pick the best available English voice from a list of SpeechSynthesisVoices.
@@ -11773,11 +11405,7 @@ declare class AgentWidgetSession {
      * Stop any in-progress text-to-speech / read-aloud playback.
      */
     stopSpeaking(): void;
-    private appendMessage;
     private upsertMessage;
-    private ensureSequence;
-    private nextSequence;
-    private sortMessages;
 }
 
 declare const formDefinitions: Record<string, {