@runtypelabs/persona 4.26.0 → 4.27.0

package/src/session.voice.test.ts

@@ -36,7 +36,16 @@ const h = vi.hoisted(() => {
     errorCb: ((e: Error) => void) | null;
     bridge: VoiceSessionBridge | null;
     prewarms: number;
-  } = { transcriptCb: null, metricsCb: null, statusCb: null, errorCb: null, bridge: null, prewarms: 0 };
+    notice: string | null;
+  } = {
+    transcriptCb: null,
+    metricsCb: null,
+    statusCb: null,
+    errorCb: null,
+    bridge: null,
+    prewarms: 0,
+    notice: null,
+  };
 
   const fakeProvider = {
     type: 'runtype' as const,
@@ -64,6 +73,11 @@ const h = vi.hoisted(() => {
     setSessionBridge: (bridge: VoiceSessionBridge) => {
       state.bridge = bridge;
     },
+    takeNotice: () => {
+      const notice = state.notice;
+      state.notice = null;
+      return notice;
+    },
   };
 
   return { state, fakeProvider };
@@ -513,12 +527,31 @@ describe('AgentWidgetSession - voice client delegation bridge', () => {
   });
 
   it('hands the provider a bridge whose history is the visible settled messages', () => {
-    drive('user', 'still talk', false, 'u1'); // interim: not part of the context
-    // An earlier call's captions (filler, small talk) aren't conversation either.
+    // An earlier call's captions (e.g. on the previous page) are conversation
+    // the new voice session never heard, so they carry over.
     h.state.transcriptCb!('assistant', 'Let me check.', true, { turnId: 'f0', caption: true });
     h.state.transcriptCb!('user', 'hi there', true, { turnId: 'u0', caption: true });
+    drive('user', 'still talk', false, 'u1'); // interim: not part of the context
+    expect(h.state.bridge!.getHistory()).toEqual([
+      { role: 'assistant', content: 'Welcome! How can I help?' },
+      { role: 'assistant', content: 'Let me check.' },
+      { role: 'user', content: 'hi there' },
+    ]);
+  });
+
+  it("leaves a delegated turn's spoken filler out of the history, keeping the answer", async () => {
+    // Full duplex: the voice model's words arrive as captions.
+    h.state.transcriptCb!('user', 'whats the weather in paris', true, { turnId: 'u1', caption: true });
+    h.state.transcriptCb!('assistant', 'Let me check that.', true, { turnId: 'f1', caption: true });
+    dispatch.mockImplementation(async (_options, onEvent) => reply(onEvent, 'It is sunny in Paris.'));
+    await h.state.bridge!.runDelegatedTurn(req({ delegationId: 'd1', userText: 'whats the weather in paris' }));
+    h.state.transcriptCb!('assistant', 'Anything else?', true, { turnId: 'a2', caption: true });
+
     expect(h.state.bridge!.getHistory()).toEqual([
       { role: 'assistant', content: 'Welcome! How can I help?' },
+      { role: 'user', content: 'whats the weather in paris' },
+      { role: 'assistant', content: 'It is sunny in Paris.' },
+      { role: 'assistant', content: 'Anything else?' },
     ]);
   });
 
@@ -790,6 +823,7 @@ describe('AgentWidgetSession - voice client delegation bridge', () => {
       expect(decline).toEqual({
         status: 'denied',
         text: 'Okay, I cancelled the place pickup order request. Nothing was done.',
+        inChat: false, // only spoken: its read-back stays as a caption
       });
       expect(dispatch).toHaveBeenCalledTimes(1); // no chat turn for the decline
       expect(approvalOf().status).toBe('denied');
@@ -1448,3 +1482,26 @@ describe('AgentWidgetSession - prewarmVoice', () => {
     expect(h.state.prewarms).toBe(0);
   });
 });
+
+describe('AgentWidgetSession - voice session end (Amendment 6)', () => {
+  const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+  const tokenSession = () =>
+    new AgentWidgetSession(
+      {
+        clientToken: 'ct_live_demo',
+        apiUrl: 'https://api.runtype.com',
+        voiceRecognition: { enabled: true, provider: { type: 'runtype', runtype: { agentId: 'a1' } } },
+      },
+      { onMessagesChanged: () => {}, onStatusChanged: () => {}, onStreamingChanged: () => {}, onError: () => {} },
+    );
+
+  it("hands the UI the provider's status-line notice once", async () => {
+    const session = tokenSession();
+    session.setupVoice();
+    await flush();
+    h.state.notice = 'This voice call reached its time limit.';
+    expect(session.getVoiceNotice()).toBe('This voice call reached its time limit.');
+    expect(session.getVoiceNotice()).toBeNull();
+  });
+
+});

package/src/types.ts

@@ -5230,6 +5230,11 @@ export interface VoiceProvider {
   setSessionBridge?(bridge: VoiceSessionBridge): void;
   /** The AI-disclosure notice for the live call, if one should show (speech-to-speech). */
   getDisclosure?(): string | null;
+  /**
+   * Status-line text for the call, returned once: why the server ended it
+   * (`session_end`) or that it is reconnecting. `null` when there is none.
+   */
+  takeNotice?(): string | null;
 }
 
 /** Metadata on a {@link VoiceProvider.onTranscript} update. */
@@ -5294,6 +5299,12 @@ export type VoiceDelegationResult = {
   status: VoiceDelegationStatus;
   /** The assistant text (Markdown allowed). */
   text: string;
+  /**
+   * `false` when no chat message carries this answer (it is only spoken), so
+   * the voice model's read-back of it stays visible as a caption.
+   * @default true
+   */
+  inChat?: boolean;
   /**
    * Set when the turn parked on approvals (`text` then asks for the decision).
    * Resolves with the terminal result once the visitor decides (or the

package/src/ui.composer-defer-one.test.ts

@@ -159,6 +159,23 @@ describe("streamingSubmitBehavior: defer-one", () => {
     expect(status?.textContent).toContain("already queued");
   });
 
+  it("keeps a notice in the status line when the chat status changes under it", async () => {
+    const { mount } = makeController();
+    await startStreaming(mount);
+    type(mount, "queued message");
+    pressEnter(mount);
+    await flush();
+    type(mount, "second attempt");
+    pressEnter(mount);
+    await flush();
+
+    stream.push(unifiedFrames());
+    stream.close();
+    await flush(50);
+    const status = mount.querySelector<HTMLElement>("[data-persona-composer-notice]");
+    expect(status?.textContent).toContain("already queued");
+  });
+
   it("card Edit restores the snapshot into the draft and drops the card", async () => {
     const { mount, controller } = makeController();
     await startStreaming(mount);

package/src/ui.ts

@@ -353,11 +353,14 @@ import {
 // Default localStorage key for chat history (automatically cleared on clear chat)
 const DEFAULT_CHAT_HISTORY_STORAGE_KEY = "persona-chat-history";
 const VOICE_STATE_RESTORE_WINDOW = 30 * 1000;
+const VOICE_RESUME_NOTICE = "Tap the mic to resume your voice call";
 // Split desktop boundary; must match widget.css artifact media queries (min-width:641px).
 const ARTIFACT_SPLIT_DESKTOP_MIN = 641;
 
 /** Marks the status region while a composer lock reason owns it. */
 const COMPOSER_REASON_ATTR = "data-persona-composer-reason";
+/** Marks the status region while a transient composer notice owns it. */
+const COMPOSER_NOTICE_ATTR = "data-persona-composer-notice";
 
 const IMAGE_FILE_EXTENSION_BY_MIME_TYPE: Record<string, string> = {
   "image/png": "png",
@@ -1384,8 +1387,9 @@ export const createAgentExperience = (
       placeStatusIndicator(el, composerForm, statusCfg);
       applyStatusIndicatorState(el, statusCfg, status);
     }
-    // A composer lock reason owns the status region until the lock clears.
-    if (el.hasAttribute(COMPOSER_REASON_ATTR)) return;
+    // A composer lock reason owns the status region until the lock clears, and
+    // a notice until its timer ends (which re-applies the status).
+    if (el.hasAttribute(COMPOSER_REASON_ATTR) || el.hasAttribute(COMPOSER_NOTICE_ATTR)) return;
     if (status === "idle" && statusCfg.idleLink) {
       el.textContent = "";
       const link = document.createElement("a");
@@ -5083,6 +5087,15 @@ export const createAgentExperience = (
   // would otherwise not appear until the first keystroke.
   syncComposerCompact();
   const voiceAutoResumeMode = config.voiceRecognition?.autoResume ?? false;
+  // A session-voice call is live while listening OR while its continuous
+  // (barge-in) mic is hot: a full-duplex call cycles listening → processing →
+  // speaking, and `isVoiceActive()` alone (status === listening) would record a
+  // live call as hung up and never restore it on the next page.
+  const isSessionVoiceLive = () => session.isVoiceActive() || session.isBargeInActive();
+  // Set on `pagehide`: the unload tears the call down without the visitor
+  // hanging up, so its trailing status changes must not overwrite the
+  // persisted "call was live" record the next page restores from.
+  let pageHiding = false;
   const emitVoiceState = (source: AgentWidgetVoiceStateEvent["source"]) => {
     eventBus.emit("voice:state", {
       active: voiceState.active,
@@ -5112,17 +5125,37 @@ export const createAgentExperience = (
           voiceState.manuallyDeactivated = false;
           if (usesSessionVoice(config.voiceRecognition?.provider)) {
             session.toggleVoice().then(() => {
-              voiceState.active = session.isVoiceActive();
+              voiceState.active = isSessionVoiceLive();
               emitVoiceState("restore");
-              if (session.isVoiceActive()) applyRuntypeMicRecordingStyles();
+              if (voiceState.active) {
+                applyRuntypeMicRecordingStyles();
+              } else {
+                // Typically the autoplay policy: this page has no user gesture
+                // yet, so the audio graph can't start. A mic tap resumes it.
+                persistVoiceMetadata();
+                showComposerNotice(VOICE_RESUME_NOTICE, 10_000);
+              }
             });
           } else {
             startVoiceRecognition("restore");
           }
         }
-      }, 1000);
+        // Session voice redials at once (a navigation mid-call should feel
+        // seamless); toggleVoice() already waits on the provider setup.
+      }, usesSessionVoice(config.voiceRecognition?.provider) ? 0 : 1000);
     }
   };
+  // Re-stamp a live call as the page unloads: the restore window counts from
+  // the navigation, not from when the (possibly long) call was started. A
+  // back/forward-cache hide (`persisted`) isn't an unload: the page lives on.
+  const handleVoicePageHide = (event: PageTransitionEvent) => {
+    pageHiding = !event.persisted;
+    if (voiceState.active) persistVoiceMetadata();
+  };
+  if (typeof window !== "undefined") {
+    window.addEventListener("pagehide", handleVoicePageHide);
+    destroyCallbacks.push(() => window.removeEventListener("pagehide", handleVoicePageHide));
+  }
 
   const getMessagesForPersistence = () =>
     session
@@ -7916,6 +7949,7 @@ export const createAgentExperience = (
       statusText.setAttribute("role", "status");
       statusText.setAttribute("aria-live", "polite");
       statusText.setAttribute(COMPOSER_REASON_ATTR, "");
+      statusText.removeAttribute(COMPOSER_NOTICE_ATTR); // the reason outranks a notice
       statusText.textContent = reason;
       applyStatusIndicatorState(statusText, config.statusIndicator ?? {}, "idle");
       return;
@@ -8803,6 +8837,9 @@ export const createAgentExperience = (
       // provider; the mic-button styling below is runtype-specific.
       eventBus.emit("voice:status", { status, timestamp: Date.now() });
       if (status !== 'disconnected' && !usesSessionVoice(config.voiceRecognition?.provider)) return;
+      // Why the server ended the call, or that it is reconnecting.
+      const voiceNotice = session.getVoiceNotice();
+      if (voiceNotice) showComposerNotice(voiceNotice, 10_000);
 
       switch (status) {
         case 'listening':
@@ -8852,7 +8889,7 @@ export const createAgentExperience = (
             }
             removeRuntypeMicStateStyles();
             emitVoiceState("system");
-            persistVoiceMetadata();
+            if (!pageHiding) persistVoiceMetadata();
           }
           break;
       }
@@ -9507,7 +9544,6 @@ export const createAgentExperience = (
     resetHistoryNavigation();
   };
 
-  const COMPOSER_NOTICE_ATTR = "data-persona-composer-notice";
   let composerNoticeTimer: ReturnType<typeof setTimeout> | null = null;
 
   /** Transient message in the status region; a lock reason always outranks it. */
@@ -10497,11 +10533,11 @@ export const createAgentExperience = (
       }
 
       session.toggleVoice().then(() => {
-        voiceState.active = session.isVoiceActive();
-        voiceState.manuallyDeactivated = !session.isVoiceActive();
+        voiceState.active = isSessionVoiceLive();
+        voiceState.manuallyDeactivated = !voiceState.active;
         persistVoiceMetadata();
         emitVoiceState("user");
-        if (session.isVoiceActive()) {
+        if (voiceState.active) {
           applyRuntypeMicRecordingStyles();
         } else {
           removeRuntypeMicStateStyles();
@@ -12956,9 +12992,10 @@ export const createAgentExperience = (
         voiceState.manuallyDeactivated = false;
         persistVoiceMetadata();
         session.toggleVoice().then(() => {
-          voiceState.active = session.isVoiceActive();
+          voiceState.active = isSessionVoiceLive();
+          persistVoiceMetadata();
           emitVoiceState("user");
-          if (session.isVoiceActive()) applyRuntypeMicRecordingStyles();
+          if (voiceState.active) applyRuntypeMicRecordingStyles();
         });
         return true;
       }

package/src/voice/__fixtures__/voice-wire/server/session_end-provider-error.json

@@ -0,0 +1,6 @@
+{
+  "type": "session_end",
+  "reason": "provider_error",
+  "message": "The voice provider disconnected.",
+  "retryable": true
+}

package/src/voice/__fixtures__/voice-wire/server/session_end-unknown-reason.json

@@ -0,0 +1,4 @@
+{
+  "type": "session_end",
+  "reason": "maintenance_window"
+}

package/src/voice/__fixtures__/voice-wire/server/session_end.json

@@ -0,0 +1,5 @@
+{
+  "type": "session_end",
+  "reason": "max_duration",
+  "retryable": true
+}

package/src/voice/runtype-voice-provider.ts

@@ -56,10 +56,11 @@
 // replaced). A second gated tool in the same turn sends another update.
 // `delegation_cancelled{delegationId}` (or a `warning` refusing a frame for
 // it) stops all frames for that id; the chat turn still renders, and since
-// nobody speaks it now, browser TTS may read it. The voice model's spoken read-back after each
-// `delegation_completed` of an answered delegation (the first new assistant
-// utterance, unless the visitor speaks first) is folded: the chat already shows
-// it. Transcripts in such a call are display-only captions, never sent to the
+// nobody speaks it now, browser TTS may read it. The voice model's spoken read-back of
+// an answered delegation is folded: the chat already shows it. With
+// `delegation_read_back` negotiated it is the utterance the server tags with that
+// `delegationId`; otherwise it is the first new assistant utterance after
+// `delegation_completed`, unless the visitor speaks first. Transcripts in such a call are display-only captions, never sent to the
 // agent as conversation; a user bubble becomes conversation only when it is
 // submitted. With `context` negotiated, one `context{text}` frame (chat history
 // as of call start plus the host's `callContext`) is held until the visitor's
@@ -98,6 +99,8 @@ const LEVEL_RMS_SCALE = 4;
 const RIFF_MAGIC = 0x52494646; // "RIFF"
 /** `prewarm()` warms at most once per this window per provider instance. */
 const PREWARM_THROTTLE_MS = 30_000;
+/** How long a call start waits for a suspended capture context to run. */
+const AUDIO_RESUME_TIMEOUT_MS = 1_000;
 /** How long `startListening()` waits on an attach still handshaking. */
 const ATTACH_HANDSHAKE_TIMEOUT_MS = 5_000;
 /** Attached-socket idle window: server default and clamp range. */
@@ -141,6 +144,17 @@ const VOICE_PROTOCOL = "runtype-browser-v1";
 /** `approvalTimeoutMs` cap: below core's delegation deadline (600 s, restarted by each update). */
 const APPROVAL_TIMEOUT_MAX_MS = 540_000;
 const DISCLOSURE_TEXT = "You're talking to an AI assistant. Voice is processed by OpenAI.";
+/** Status-line text per `session_end.reason` (Amendment 6); unlisted reasons show nothing. */
+const SESSION_END_TEXT = new Map([
+  ["idle_timeout", "Voice call ended after a quiet period."],
+  ["max_duration", "This voice call reached its time limit."],
+  ["provider_ended", "The voice session ended."],
+  ["quota", "Voice is unavailable right now."],
+  ["auth_expired", "Voice session expired. Tap the mic to reconnect."],
+]);
+/** Reasons that get one automatic reconnect. */
+const RECONNECT_REASONS = ["provider_error", "server_restart"];
+const CONNECTION_LOST = "Voice connection lost.";
 /** Call-start context frame: total cap, host share, history window, per-message cap. */
 const CONTEXT_MAX_CHARS = 8000;
 const CONTEXT_HOST_MAX_CHARS = 4000;
@@ -270,6 +284,14 @@ export class RuntypeVoiceProvider implements VoiceProvider {
   #cancelledDelegations = new Set<string>();
   // session_config.callId: the server's id for this call, for logs.
   #callId: string | undefined;
+  // Amendment 6: why the server ended this call (its last frame), if it said.
+  #sessionEnd: { reason: string; message?: string } | null = null;
+  // Status-line text for the UI, read once (`takeNotice`).
+  #notice: string | null = null;
+  // One automatic reconnect per call the visitor started: pending, and spent.
+  #reconnectTimer: ReturnType<typeof setTimeout> | undefined;
+  #reconnected = false;
+  #autoReconnect = false;
   // Call-start context, built at session_config and held until the visitor's
   // first final transcript (sent earlier, the voice model tends to answer it).
   #contextSent = false;
@@ -450,7 +472,8 @@ export class RuntypeVoiceProvider implements VoiceProvider {
    */
   #voiceSocketUrl(host: string, agentId: string, attach?: URLSearchParams): string {
     const capabilities = ["partial_transcript", "context"];
-    if (this.bridge && this.config?.clientDelegation !== false) capabilities.push("client_delegation", "delegation_update");
+    if (this.bridge && this.config?.clientDelegation !== false)
+      capabilities.push("client_delegation", "delegation_update", "delegation_read_back");
     if (attach) capabilities.unshift("attach");
     const params = new URLSearchParams({
       voiceProtocol: VOICE_PROTOCOL,
@@ -465,6 +488,13 @@ export class RuntypeVoiceProvider implements VoiceProvider {
   /** Start the call: acquire mic, open the WS, stream PCM until hang-up. */
   async startListening(): Promise<void> {
     if (this.#callLive) return; // idempotent: a call is already live
+    // A call the visitor starts gets a fresh reconnect; the automatic one doesn't.
+    const auto = this.#autoReconnect;
+    if (!auto) {
+      this.#reconnected = false;
+      this.#notice = null;
+    }
+    this.#autoReconnect = false;
 
     const agentId = this.config?.agentId;
     const token = this.config?.clientToken;
@@ -497,10 +527,22 @@ export class RuntypeVoiceProvider implements VoiceProvider {
       const captureContext: AudioContext = new AudioCtx({
         sampleRate: CAPTURE_SAMPLE_RATE,
       });
+      this.#captureContext = captureContext;
       if (captureContext.state === "suspended") {
-        await captureContext.resume().catch(() => {});
+        // Outside a click (the automatic reconnect, or a call restored after a
+        // page navigation) the autoplay policy can leave audio suspended and
+        // `resume()` pending forever: fail fast rather than hang or open a dead call.
+        await Promise.race([
+          captureContext.resume().catch(() => {}),
+          new Promise((resolve) => setTimeout(resolve, auto ? 500 : AUDIO_RESUME_TIMEOUT_MS)),
+        ]);
+        if (generation !== this.#callGeneration) return; // hung up meanwhile
+        if ((captureContext.state as string) !== "running") {
+          if (auto) throw new Error((this.#notice = `${CONNECTION_LOST} Tap the mic to reconnect.`));
+          // A restored call: the widget asks for a tap to resume.
+          throw new Error("Audio blocked until a tap");
+        }
       }
-      this.#captureContext = captureContext;
 
       const engine = this.config?.createPlaybackEngine
         ? await this.config.createPlaybackEngine()
@@ -558,7 +600,8 @@ export class RuntypeVoiceProvider implements VoiceProvider {
     ws.onmessage = (event) => this.#handleMessage(event, generation);
 
     ws.onerror = () => {
-      if (generation !== this.#callGeneration) return;
+      // After `session_end`, the close that follows reports the server's reason.
+      if (generation !== this.#callGeneration || this.#sessionEnd) return;
       this.#emitError(new Error("Voice connection failed"));
       this.#emitStatus("error");
       this.#cleanup();
@@ -570,17 +613,68 @@ export class RuntypeVoiceProvider implements VoiceProvider {
         return;
       }
       if (generation !== this.#callGeneration) return;
-      if (evt.code !== 1000) {
-        const codeMsg = evt.code ? ` (code ${evt.code})` : "";
-        this.#emitError(new Error(`Voice connection closed${codeMsg}`));
-        this.#emitStatus("error");
-      } else {
-        this.#emitStatus("idle");
+      // Why the server ended it: its `session_end`, or the attach idle close.
+      const end = this.#sessionEnd ?? (evt.code === 4408 ? { reason: "idle_timeout" } : null);
+      if (!end) {
+        // No reason given (a deploy, a dropped connection): as before.
+        if (evt.code !== 1000) {
+          const codeMsg = evt.code ? ` (code ${evt.code})` : "";
+          this.#emitError(new Error(`Voice connection closed${codeMsg}`));
+          this.#emitStatus("error");
+        } else {
+          this.#emitStatus("idle");
+        }
+        this.#cleanup();
+        return;
       }
-      this.#cleanup();
+      this.#endCall(end.reason, end.message);
     };
   }
 
+  /**
+   * The server ended the call with a reason (`session_end`, Amendment 6): show
+   * its text, and reconnect once after a provider error or a restart. Unknown
+   * reasons are an ordinary end (`ended_by_server`).
+   */
+  #endCall(reason: string, message?: string): void {
+    const retry = RECONNECT_REASONS.includes(reason) && !this.#reconnected;
+    this.#cleanup();
+    if (retry) {
+      // Keep the call "live" while it waits, so the mic button hangs up (and cancels).
+      this.#reconnected = true;
+      this.#callLive = true;
+      this.#notice = reason === "provider_error" ? `${CONNECTION_LOST} Reconnecting…` : "Reconnecting…";
+      // A hang-up meanwhile runs #cleanup, which clears this timer.
+      this.#reconnectTimer = setTimeout(
+        () => {
+          this.#callLive = false;
+          this.#autoReconnect = true;
+          void this.startListening().catch(() => {});
+        },
+        1000 + Math.random() * 1000,
+      );
+      this.#emitStatus("idle");
+      return;
+    }
+    if (RECONNECT_REASONS.includes(reason)) {
+      // The reconnect already ran: this end is the second failure.
+      this.#notice = CONNECTION_LOST;
+      this.#emitError(new Error(CONNECTION_LOST));
+      return this.#emitStatus("error");
+    }
+    // `error`: the preceding `error` frame already reported it.
+    if (reason === "error") return this.#emitStatus("error");
+    this.#notice = (reason === "quota" && message) || SESSION_END_TEXT.get(reason) || null;
+    this.#emitStatus("idle");
+  }
+
+  /** Status-line text for the call (why it ended, or that it is reconnecting), once. */
+  takeNotice(): string | null {
+    const notice = this.#notice;
+    this.#notice = null;
+    return notice;
+  }
+
   /** The AI-disclosure notice for a live speech-to-speech call (`disclosureText`; `false` hides it). */
   getDisclosure(): string | null {
     const text = this.config?.disclosureText;
@@ -746,9 +840,17 @@ export class RuntypeVoiceProvider implements VoiceProvider {
           if (msg.final === true) this.#flushCallContext(generation);
           this.#foldReadback = false;
         } else {
-          // Read-back of a delegated result: core rotates the assistant id at
-          // completion, so it is the first new id after it. The chat renders it.
-          if (this.#foldReadback && !this.#assistantTurns.has(turnId)) {
+          // Read-back of a delegated result the chat already renders. A server
+          // that negotiated `delegation_read_back` tags it with its delegation;
+          // an older one rotates the assistant id at completion, so it is the
+          // first new id after it (a guess a filler finishing late defeats).
+          if (this.#capabilities.has("delegation_read_back")) {
+            // Fold only from the first frame: hiding an utterance already shown would strand a partial caption.
+            const tag = msg.delegationId;
+            if (typeof tag === "string" && this.#answered.has(tag) && !this.#assistantTurns.has(turnId)) {
+              this.#foldedTurns.add(turnId);
+            }
+          } else if (this.#foldReadback && !this.#assistantTurns.has(turnId)) {
             this.#foldedTurns.add(turnId);
             this.#foldReadback = false;
           }
@@ -862,6 +964,14 @@ export class RuntypeVoiceProvider implements VoiceProvider {
         this.#emitError(new Error(msg.error || "Voice error"));
         this.#emitStatus("error");
         break;
+
+      case "session_end":
+        // The server's last frame before it closes: the close acts on it.
+        this.#sessionEnd = {
+          reason: String(msg.reason),
+          ...(typeof msg.message === "string" && { message: msg.message }),
+        };
+        break;
     }
   }
 
@@ -946,7 +1056,7 @@ export class RuntypeVoiceProvider implements VoiceProvider {
         result.text,
       );
       if (!sent) return;
-      if (result.status !== "failed") this.#answered.add(delegationId);
+      if (result.status !== "failed" && result.inChat !== false) this.#answered.add(delegationId);
       if (!result.followUp) return;
       // The approval bookkeeping (expiry, supersede) runs either way.
       const abort = new AbortController();
@@ -1053,6 +1163,8 @@ export class RuntypeVoiceProvider implements VoiceProvider {
     this.#followUps.clear();
     this.#cancelledDelegations.clear();
     this.#callId = undefined;
+    this.#sessionEnd = null;
+    clearTimeout(this.#reconnectTimer);
     this.#contextSent = false;
     this.#pendingContext = null;
     this.#contextSend = null;

package/src/voice/voice-delegation.ts

@@ -164,16 +164,32 @@ export function createVoiceSessionBridge(host: VoiceDelegationHost): VoiceSessio
   };
 
   return {
-    getHistory: () =>
-      host.messages().flatMap((m) =>
-        (m.role === "user" || m.role === "assistant") &&
-        !m.variant &&
-        !m.voiceProcessing &&
-        !m.voiceCaption &&
-        m.content
-          ? [{ role: m.role, content: m.content }]
-          : [],
-      ),
+    // Read once at call start, before this call has any captions, so the
+    // captions here are earlier calls' (e.g. on the previous page of a
+    // multi-page site): spoken conversation the new voice session never heard.
+    // An assistant caption followed by a chat answer before the next user turn
+    // is a delegated turn's spoken filler ("Let me check."): it would only use
+    // up a slot of the context's recent-message window.
+    getHistory: () => {
+      const settled = host.messages().filter(
+        (m) =>
+          (m.role === "user" || m.role === "assistant") &&
+          !m.variant &&
+          !m.voiceProcessing &&
+          !m.streaming &&
+          m.content,
+      );
+      let answered = false;
+      const kept: Array<{ role: "user" | "assistant"; content: string }> = [];
+      for (let i = settled.length - 1; i >= 0; i -= 1) {
+        const m = settled[i];
+        if (m.role === "user") answered = false;
+        else if (!m.voiceCaption) answered = true;
+        else if (answered) continue;
+        kept.unshift({ role: m.role as "user" | "assistant", content: m.content });
+      }
+      return kept;
+    },
 
     dropDelegation(delegationId, expired) {
       // Remembered for a turn still running: when it parks, the same rule applies.
@@ -201,7 +217,7 @@ export function createVoiceSessionBridge(host: VoiceDelegationHost): VoiceSessio
         const tool = toolOf(pendingIds[0]);
         // The parked delegation still gets its one terminal result, silently.
         settle(live[0], "denied", "");
-        return { status: "denied", text: `Okay, I cancelled the ${tool} request. Nothing was done.` };
+        return { status: "denied", text: `Okay, I cancelled the ${tool} request. Nothing was done.`, inChat: false };
       }
       // A voice-originated WebMCP approval holds the chat turn open: this turn
       // replaces it (a new send declines it), so don't wait on it. Anything