@runtypelabs/persona 4.29.0 → 4.29.1

package/src/ui.restored-browser-tools.test.ts

@@ -0,0 +1,128 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createAgentExperience } from "./ui";
+import { provideApprovalUi } from "./approval-ui-loader";
+import * as approvalUiEntry from "./approval-ui-entry";
+import type { AgentWidgetMessage, AgentWidgetStoredState } from "./types";
+import { createDemoHistoryProvider } from "./internal/demo-history-provider";
+
+provideApprovalUi(approvalUiEntry);
+let controller: ReturnType<typeof createAgentExperience> | undefined;
+afterEach(() => { controller?.destroy(); document.body.replaceChildren(); localStorage.clear(); vi.restoreAllMocks(); });
+
+const snapshot = (): AgentWidgetStoredState => ({
+  metadata: { custom: "retained" }, draft: { text: "My unsent proposal" },
+  messages: [
+    { id: "tool-1", role: "assistant", content: "", createdAt: "2026-01-01", sequence: 1, streaming: true, variant: "tool", agentMetadata: { executionId: "exec", awaitingLocalTool: true }, toolCall: { id: "call-1", name: "webmcp:purchase", status: "running", startedAt: 1, args: { quantity: 2 }, approvalStatus: "pending" } },
+    { id: "tool-2", role: "assistant", content: "", createdAt: "2026-01-01", sequence: 2, variant: "tool", toolCall: { id: "call-2", name: "webmcp:search", status: "complete", result: "Found two items", durationMs: 2000 } },
+    { id: "approval-webmcp-1", role: "assistant", content: "", createdAt: "2026-01-01", sequence: 3, variant: "approval", approval: { id: "webmcp-1", status: "pending", agentId: "", executionId: "", toolType: "webmcp", toolName: "webmcp:purchase", description: "Buy items", parameters: { quantity: 2 } } },
+  ] satisfies AgentWidgetMessage[],
+});
+
+for (const source of ["sync", "async", "initial", "hook"] as const) {
+  describe.each(["card", "row"] as const)(`${source} restoration (%s)`, variant => {
+    it("renders historical controls and activity as interrupted while preserving drafts", async () => {
+      const stored = snapshot();
+      const before = structuredClone(stored);
+      const mount = document.createElement("div"); document.body.appendChild(mount);
+      const fetchSpy = vi.spyOn(globalThis, "fetch");
+      controller = createAgentExperience(mount, {
+        apiUrl: "/test", launcher: { enabled: false }, webmcp: { enabled: true },
+        ...(source === "initial" ? { initialMessages: stored.messages, persistState: false } : source === "hook" ? { onStateLoaded: () => stored, persistState: false } : {
+          storageAdapter: { load: () => source === "async" ? Promise.resolve(stored) : stored, save: vi.fn(), clear: vi.fn() },
+        }),
+        features: { toolCallDisplay: { variant, grouped: true, groupedMode: "collapsible" } },
+        toolCall: { completeTextTemplate: "Finished {toolName} ~{duration}~" },
+      });
+      await vi.waitFor(() => expect(mount.textContent).toContain("chat restarted"));
+      expect(mount.querySelector('[data-action="allow"], [data-action="deny"], [data-approval-buttons]')).toBeNull();
+      expect(mount.querySelector('[data-tool-elapsed], [data-activity-state="running"], [data-activity-state="awaiting-approval"]')).toBeNull();
+      expect(mount.querySelector('[data-message-id="tool-1"]')?.textContent).toContain("Interrupted");
+      expect(mount.querySelector('[data-message-id="tool-1"]')?.textContent).not.toContain("Finished");
+      if (variant === "row") {
+        expect(mount.querySelector('[data-persona-tool-group]')?.getAttribute("data-activity-state")).toBe("interrupted");
+        expect(mount.textContent).toContain("2s");
+      }
+      if (source === "sync" || source === "async") expect(controller.getComposerState().text).toBe("My unsent proposal");
+      expect(stored).toEqual(before);
+      expect(fetchSpy).not.toHaveBeenCalled();
+    });
+  });
+}
+
+it("keeps a cardless interrupted tool visible when completed rows are removed", async () => {
+  const stored = snapshot();
+  const mount = document.createElement("div"); document.body.appendChild(mount);
+  controller = createAgentExperience(mount, {
+    launcher: { enabled: false }, persistState: false,
+    initialMessages: [stored.messages![0]],
+    features: { toolCallDisplay: { variant: "row", completedVisibility: "removed" } },
+    toolCall: { renderCollapsedSummary: ({ createElapsedElement }) => createElapsedElement() },
+  });
+  expect(mount.querySelector('[data-message-id="tool-1"]')).not.toBeNull();
+  expect(mount.querySelector('[data-tool-elapsed]')).toBeNull();
+  expect(mount.textContent).toContain("chat restarted");
+});
+
+it("supports a custom approval renderer that only handles the original statuses", () => {
+  const labels = { pending: "Waiting", approved: "Allowed", denied: "Denied", timeout: "Expired" };
+  const mount = document.createElement("div"); document.body.appendChild(mount);
+  const render = vi.fn(({ message }: { message: AgentWidgetMessage }) => {
+    const node = document.createElement("span");
+    node.textContent = message.approval ? labels[message.approval.status] : "";
+    return node;
+  });
+  controller = createAgentExperience(mount, {
+    launcher: { enabled: false }, persistState: false,
+    initialMessages: [snapshot().messages![2]],
+    plugins: [{ id: "existing-approval-renderer", renderApproval: render }],
+  });
+  expect(mount.textContent).toContain("Expired");
+  expect(render).toHaveBeenCalled();
+  expect(render.mock.calls[0][0].message.approval).toMatchObject({ status: "timeout", interrupted: true });
+});
+
+it.each(["card", "row"] as const)("loading earlier messages retires browser activity in %s display", async variant => {
+  const stored = snapshot();
+  const before = structuredClone(stored);
+  const provider = createDemoHistoryProvider();
+  const summary = { id: "restored", title: "Restored", targetId: null, preview: "", createdAt: "2026-01-01", updatedAt: "2026-01-02", messageCount: 4 };
+  vi.spyOn(provider, "prepareOpen").mockResolvedValue({ conversationId: summary.id, conversationRevision: "r1", commit: vi.fn(), discard: vi.fn() });
+  vi.spyOn(provider, "getPage").mockImplementation(async (_id, options) => ({
+    summary, conversationRevision: "r1", nextCursor: options?.cursor ? null : "older",
+    messages: options?.cursor ? stored.messages! : [{ id: "newer", role: "assistant", content: "Newer reply", createdAt: "2026-01-02" }],
+  }));
+  const mount = document.createElement("div"); document.body.appendChild(mount);
+  const fetchSpy = vi.spyOn(globalThis, "fetch");
+  controller = createAgentExperience(mount, {
+    apiUrl: "/test", launcher: { enabled: false }, persistState: false,
+    features: { history: { enabled: true, provider }, toolCallDisplay: { variant, grouped: true } },
+  });
+  await controller.openConversation(summary.id);
+  const earlier = mount.querySelector<HTMLButtonElement>("[data-persona-history-earlier]");
+  expect(earlier).not.toBeNull();
+  earlier!.click();
+  await vi.waitFor(() => expect(mount.textContent).toContain("chat restarted"));
+  expect(mount.querySelector('[data-action="allow"], [data-action="deny"], [data-tool-elapsed], [data-activity-state="running"], [data-activity-state="awaiting-approval"]')).toBeNull();
+  expect(mount.textContent).toContain("Interrupted");
+  expect(mount.textContent).toContain("Newer reply");
+  expect(stored).toEqual(before);
+  expect(fetchSpy).not.toHaveBeenCalled();
+});
+
+it.each(["button", "controller"] as const)("restored server WebMCP approval uses its transport via %s", async route => {
+  const message = snapshot().messages![2];
+  message.approval!.executionId = "durable-exec";
+  const onDecision = vi.fn(async () => undefined);
+  const mount = document.createElement("div"); document.body.appendChild(mount);
+  controller = createAgentExperience(mount, {
+    launcher: { enabled: false }, persistState: false, initialMessages: [message], approval: { onDecision },
+  });
+  expect(onDecision).not.toHaveBeenCalled();
+  if (route === "button") mount.querySelector<HTMLButtonElement>('[data-action="allow"]')!.click();
+  else await controller.resolveApproval(message.approval!.id, "approved");
+  await vi.waitFor(() => expect(onDecision).toHaveBeenCalledTimes(1));
+  expect(onDecision.mock.calls[0]).toEqual([{
+    approvalId: "webmcp-1", executionId: "durable-exec", agentId: "", toolName: "webmcp:purchase",
+  }, "approved", undefined]);
+});

package/src/ui.ts

@@ -1,3 +1,4 @@
+import { isBrowserLocalApproval } from "./utils/restored-browser-state";
 import { activityVariant, activityDuration, createActivityLifecycle, createActivityGroup } from "./components/activity-row";
 import { applyStatusIndicatorState, placeStatusIndicator } from "./utils/status-indicator";
 import { usesSessionVoice } from "./utils/voice-support";
@@ -331,7 +332,8 @@ import {
   defaultActionHandlers,
   defaultJsonActionParser
 } from "./utils/actions";
-import { createLocalStorageAdapter } from "./utils/storage";
+import { createLocalStorageAdapter, transcriptStorageKey } from "./utils/storage";
+import { isLocalOnlyMessage } from "./utils/local-only-message";
 import { createVisitorStore, type VisitorStore } from "./utils/visitor-store";
 import { loadHistoryView } from "./history-view-loader";
 import { getHistoryShellSync, loadHistoryShell, type HistoryShellModule } from "./history-shell-loader";
@@ -501,11 +503,13 @@ const ensureRecord = (value: unknown): Record<string, unknown> => {
   return { ...(value as Record<string, unknown>) };
 };
 
-const stripStreamingFromMessages = (messages: AgentWidgetMessage[]) =>
-  messages.map((message) => ({
-    ...message,
-    streaming: false
-  }));
+const messagesForStorage = (messages: AgentWidgetMessage[]) =>
+  messages
+    .filter((message) => !isLocalOnlyMessage(message))
+    .map((message) => ({
+      ...message,
+      streaming: false
+    }));
 
 type Controller = {
   update: (config: AgentWidgetConfigPatch) => void;
@@ -1064,7 +1068,12 @@ export const createAgentExperience = (
   const storageAdapter: AgentWidgetStorageAdapter | null =
     messagePersistenceDisabled
       ? null
-      : (config.storageAdapter ?? createLocalStorageAdapter());
+      : (config.storageAdapter ??
+        createLocalStorageAdapter(
+          transcriptStorageKey(
+            typeof config.persistState === "object" ? config.persistState.keyPrefix : undefined
+          )
+        ));
   const personaOwnsClientTokenRecovery =
     Boolean(config.clientToken) && typeof config.reconnectStream !== "function";
   let persistentMetadata: Record<string, unknown> = {};
@@ -3055,8 +3064,8 @@ export const createAgentExperience = (
 
     // WebMCP gate approvals resolve a local Promise the bridge is parked on
     // (no server round-trip); server-driven approvals call the API. The
-    // `toolType` marker set in `requestWebMcpApproval` discriminates the two.
-    if (approvalMessage.approval.toolType === "webmcp") {
+    // `toolType` marker and absent execution id identify browser-local gates.
+    if (isBrowserLocalApproval(approvalMessage.approval)) {
       session.resolveWebMcpApproval(messageId, decision);
     } else {
       session.resolveApproval(approvalMessage.approval, decision);
@@ -5159,7 +5168,7 @@ export const createAgentExperience = (
 
   const getMessagesForPersistence = () =>
     session
-      ? stripStreamingFromMessages(session.getMessages()).filter(msg => !(msg as any).__skipPersist)
+      ? messagesForStorage(session.getMessages()).filter(msg => !(msg as any).__skipPersist)
       : [];
 
   let storageMutationTail: Promise<void> | null = null;
@@ -5209,7 +5218,7 @@ export const createAgentExperience = (
 
     // Allow saving even if session doesn't exist yet (for metadata during init)
     const messages = messagesOverride
-      ? stripStreamingFromMessages(messagesOverride)
+      ? messagesForStorage(messagesOverride)
       : session
         ? getMessagesForPersistence()
         : [];
@@ -6239,7 +6248,8 @@ export const createAgentExperience = (
       return (
         dropCompletedToolCalls &&
         message.variant === "tool" &&
-        message.toolCall?.status === "complete"
+        message.toolCall?.status === "complete" &&
+        !message.toolCall.interrupted
       );
     };
 
@@ -6507,7 +6517,7 @@ export const createAgentExperience = (
               ?.getMessages()
               .find((m) => m.id === approvalMessageId);
             if (!live?.approval) return;
-            if (live.approval.toolType === "webmcp") {
+            if (isBrowserLocalApproval(live.approval)) {
               sessionRef.current?.resolveWebMcpApproval(live.id, decision);
             } else {
               sessionRef.current?.resolveApproval(live.approval, decision, options);
@@ -6801,7 +6811,7 @@ export const createAgentExperience = (
           // A tool call hidden by `completedVisibility: "removed"` does not
           // create a visible break in the transcript, so it should not split
           // an otherwise contiguous group.
-          if (dropCompletedToolCalls && message.toolCall.status === "complete") {
+          if (dropCompletedToolCalls && message.toolCall.status === "complete" && !message.toolCall.interrupted) {
             return;
           }
           currentGroup.push(message);
@@ -6859,10 +6869,12 @@ export const createAgentExperience = (
             id, name: `${group.length} tools`, status: active ? "running" : "complete",
             chunks: group.flatMap(item => item.toolCall?.chunks ?? []),
             success: !group.some(item => item.toolCall?.success === false),
+            interrupted: !active && group.some(item => item.toolCall?.interrupted),
           } };
           activityIds.add(id);
           activityLifecycle.observe(synthetic, "tool", toolExpansionState, config.features.toolCallDisplay);
-          const label = `${active ? "Using" : "Used"} ${group.length} tools`;
+          const label = synthetic.toolCall?.interrupted ? `${group.length} tools · Interrupted`
+            : `${active ? "Using" : "Used"} ${group.length} tools`;
           const custom = config.toolCall?.renderGroupedSummary?.({ messages: group, toolCalls: group.map(item => item.toolCall!), defaultSummary: label, config });
           const row = createActivityGroup(synthetic, config, toolExpansionState.has(id), custom ?? label);
           row.bubble.classList.add("persona-tool-group");
@@ -6888,7 +6900,9 @@ export const createAgentExperience = (
           "persona-tool-group-summary persona-text-xs persona-text-persona-muted";
         summary.id = `tool-group-summary-${group[0].id}`;
 
-        const defaultSummary = `Called ${group.length} ${group.length === 1 ? "tool" : "tools"}`;
+        const toolCount = `${group.length} ${group.length === 1 ? "tool" : "tools"}`;
+        const defaultSummary = group.some(item => item.toolCall?.interrupted)
+          ? `${toolCount} · Interrupted` : `Called ${toolCount}`;
         const renderedSummary = config.toolCall?.renderGroupedSummary?.({
           messages: group,
           toolCalls: group
@@ -13277,8 +13291,8 @@ export const createAgentExperience = (
       // Mirror the in-panel click handler: WebMCP gate bubbles resolve a local
       // Promise the bridge is parked on (no server round-trip and they carry an
       // empty executionId/agentId), so they must NOT hit the server approval
-      // API. Route by the `toolType` marker set in `requestWebMcpApproval`.
-      if (approvalMessage.approval.toolType === "webmcp") {
+      // API. Server-backed approvals retain their execution id and use the API.
+      if (isBrowserLocalApproval(approvalMessage.approval)) {
         session.resolveWebMcpApproval(approvalMessage.id, decision);
         return;
       }

package/src/utils/formatting.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { createJsonStreamParser, parseFormattedTemplate, computeReasoningElapsed } from "./formatting";
+import { createJsonStreamParser, parseFormattedTemplate, computeReasoningElapsed, computeToolElapsed } from "./formatting";
 
 describe("JSON Stream Parser", () => {
   it("should extract text field incrementally as JSON streams in", () => {
@@ -268,3 +268,11 @@ describe("computeReasoningElapsed", () => {
     expect(result).toBe("<0.1s");
   });
 });
+
+it("never invents an interrupted tool's duration, including elapsed render hooks", () => {
+  const tool = { id: "browser", status: "complete" as const, interrupted: true };
+  expect(computeToolElapsed(tool)).toBe("");
+  expect(computeToolElapsed({ ...tool, startedAt: 1 })).toBe("");
+  expect(computeToolElapsed({ ...tool, durationMs: 2000 })).toBe("2s");
+  expect(computeToolElapsed({ ...tool, startedAt: 1000, completedAt: 4000 })).toBe("3s");
+});

package/src/utils/formatting.ts

@@ -124,6 +124,10 @@ export const formatElapsedMs = (ms: number): string => {
  * Computes the current elapsed time string for a tool call.
  */
 export const computeToolElapsed = (tool: AgentWidgetToolCall): string => {
+  if (
+    tool.interrupted && tool.duration === undefined && tool.durationMs === undefined &&
+    (tool.startedAt === undefined || tool.completedAt === undefined)
+  ) return "";
   const durationMs =
     typeof tool.duration === "number"
       ? tool.duration

package/src/utils/local-only-message.ts

@@ -0,0 +1,15 @@
+import type { AgentWidgetMessage } from "../types";
+
+/** Id prefix of the bubble the durable reconnect loop posts when it gives up. */
+export const RECONNECT_FAILED_ID_PREFIX = "reconnect-failed-";
+
+/**
+ * A widget-generated notice that is shown in this browser only: never sent as
+ * conversation history and never written to the storage adapter. The id check
+ * covers reconnect-failure bubbles persisted before `localOnly` existed.
+ */
+export const isLocalOnlyMessage = (message: AgentWidgetMessage): boolean =>
+  message.localOnly === true ||
+  (message.role === "assistant" &&
+    typeof message.id === "string" &&
+    message.id.startsWith(RECONNECT_FAILED_ID_PREFIX));

package/src/utils/restored-browser-state.ts

@@ -0,0 +1,50 @@
+import type { AgentWidgetApproval, AgentWidgetMessage, AgentWidgetToolCall } from "../types";
+import { isWebMcpToolName } from "../webmcp-bridge";
+
+export const BROWSER_TOOL_INTERRUPTION =
+  "The chat restarted and this browser tool was interrupted. Request a fresh proposal to try again.";
+
+export function isBrowserLocalApproval(approval: AgentWidgetApproval): boolean {
+  return approval.toolType === "webmcp" && !approval.executionId;
+}
+
+/** History cannot restore a browser callback. Server continuations stay live. */
+export function restoreBrowserToolState(message: AgentWidgetMessage): AgentWidgetMessage {
+  const approval = message.approval;
+  // Server approvals can also name webmcp tools. An execution id identifies
+  // their durable continuation; native browser gates have no execution id.
+  const interruptedApproval = approval?.status === "pending" && isBrowserLocalApproval(approval);
+  let hasBrowserTool = false;
+  const settle = (tool: AgentWidgetToolCall): AgentWidgetToolCall => {
+    if (!tool.name || !isWebMcpToolName(tool.name)) return tool;
+    hasBrowserTool = true;
+    // Older await frames used complete for the wire step before the browser
+    // had executed anything. A recorded outcome, however, remains historical.
+    const unfinished = tool.status !== "complete" ||
+      (message.agentMetadata?.awaitingLocalTool === true &&
+        tool.result === undefined && tool.success === undefined);
+    if (!unfinished) return tool;
+    return {
+      ...tool,
+      status: "complete",
+      interrupted: true,
+      success: false,
+      error: BROWSER_TOOL_INTERRUPTION,
+      approvalStatus: tool.approvalStatus === "pending" ? "timeout" : tool.approvalStatus,
+      // Retain recorded durations and paired timestamps. Never fabricate an
+      // end timestamp or derive a duration from the time spent off the page.
+      startedAt: tool.completedAt === undefined ? undefined : tool.startedAt,
+    };
+  };
+  const toolCall = message.toolCall ? settle(message.toolCall) : undefined;
+  const tools = message.tools?.map(settle);
+  return {
+    ...message,
+    streaming: hasBrowserTool || interruptedApproval ? false : message.streaming,
+    ...(interruptedApproval ? { approval: { ...approval, status: "timeout" as const, interrupted: true } } : {}),
+    ...(toolCall ? { toolCall } : {}),
+    ...(tools ? { tools } : {}),
+    ...(hasBrowserTool && message.agentMetadata?.awaitingLocalTool
+      ? { agentMetadata: { ...message.agentMetadata, awaitingLocalTool: false } } : {}),
+  };
+}

package/src/utils/storage.ts

@@ -30,8 +30,19 @@ const sanitizeArtifacts = (artifacts: PersonaArtifactRecord[]) =>
     status: "complete" as const
   }));
 
+const DEFAULT_PERSIST_KEY_PREFIX = "persona-";
+
+/**
+ * The widget's default transcript key, scoped by `persistState.keyPrefix` so
+ * two widgets on one origin with distinct prefixes keep separate transcripts.
+ * The default prefix yields the legacy `"persona-state"` key, so unprefixed
+ * widgets keep their stored conversation; prefixed widgets never adopt it.
+ */
+export const transcriptStorageKey = (keyPrefix?: string): string =>
+  `${keyPrefix ?? DEFAULT_PERSIST_KEY_PREFIX}state`;
+
 export const createLocalStorageAdapter = (
-  key = "persona-state"
+  key = transcriptStorageKey()
 ): AgentWidgetStorageAdapter => {
   const getStorage = () => {
     if (typeof window === "undefined" || !window.localStorage) {

package/src/utils/voice-prior-tool-results.ts

@@ -0,0 +1,37 @@
+import type { AgentWidgetMessage } from "../types";
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+/**
+ * Tool rows for the page tools a voice server already ran before handing the
+ * turn to the chat (`delegation_started.input.priorToolResults`). Each row is
+ * a completed call carrying `clientToolAnswer`, so proxy/agent payloads replay
+ * it to the model as an assistant `toolCalls` + `tool` `toolResults` pair under
+ * the same `toolCallId`. Nothing marks it awaiting, so it never runs again.
+ * Malformed entries and repeats of a `toolCallId` are skipped.
+ */
+export const voicePriorToolRows = (value: unknown, createdAt: string): AgentWidgetMessage[] => {
+  const seen = new Set<string>();
+  return (Array.isArray(value) ? value : []).flatMap((entry): AgentWidgetMessage[] => {
+    if (!isRecord(entry)) return [];
+    const { toolCallId, name } = entry;
+    if (typeof toolCallId !== "string" || !toolCallId || typeof name !== "string" || !name) return [];
+    if (seen.has(toolCallId)) return [];
+    seen.add(toolCallId);
+    const args = isRecord(entry.arguments) ? entry.arguments : {};
+    const result = entry.result ?? null;
+    return [
+      {
+        id: `voice-tool-${toolCallId}`,
+        role: "assistant",
+        variant: "tool",
+        content: "",
+        createdAt,
+        streaming: false,
+        toolCall: { id: toolCallId, name, status: "complete", args, result },
+        agentMetadata: { clientToolAnswer: { toolCallId, toolName: name, args, result } },
+      },
+    ];
+  });
+};

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

@@ -99,7 +99,10 @@
 // sent), `failed`, or `timeout` (past `timeoutMs`, which bounds the gate too).
 // Then `delegation_completed{route:'direct', text}` for a delegation that never
 // started here writes the heard user turn and `text` into the chat. When the
-// server falls through, the delegation arrives as today's `delegation_started`.
+// server falls through, the delegation arrives as today's `delegation_started`;
+// its `input.priorToolResults` (page tools the server already ran; sent only
+// with `prior_tool_results`, declared beside `client_tools`) ride along to the
+// chat turn as completed calls, never run again here.
 
 import type {
   VoiceClientToolsSession,
@@ -519,17 +522,17 @@ export class RuntypeVoiceProvider implements VoiceProvider {
    * the URL, and these params are not secrets.
    */
   #voiceSocketUrl(host: string, agentId: string, attach?: URLSearchParams): string {
-    const capabilities = ["partial_transcript", "context"];
+    let capabilities = "partial_transcript,context";
     if (this.bridge && this.config?.clientDelegation !== false) {
-      capabilities.push("client_delegation", "delegation_update", "delegation_read_back", "delegation_stream");
-      if (this.bridge.clientTools?.()) capabilities.push("client_tools");
+      capabilities += ",client_delegation,delegation_update,delegation_read_back,delegation_stream";
+      if (this.bridge.clientTools?.()) capabilities += ",client_tools,prior_tool_results";
     }
-    if (attach) capabilities.unshift("attach");
+    if (attach) capabilities = `attach,${capabilities}`;
     const params = new URLSearchParams({
       voiceProtocol: VOICE_PROTOCOL,
       clientVersion: `persona/${VERSION}`,
       voiceCapabilities: FULL_DUPLEX_CAPABILITY,
-      clientCapabilities: capabilities.join(","),
+      clientCapabilities: capabilities,
     });
     attach?.forEach((value, key) => params.set(key, value));
     return `${toWsBase(host)}/ws/agents/${encodeURIComponent(agentId)}/voice?${params}`;
@@ -877,9 +880,10 @@ export class RuntypeVoiceProvider implements VoiceProvider {
           this.#pendingContext = this.#buildContextText();
         }
         if (this.#clientDelegation && this.#capabilities.has("client_tools") && !this.#fastTier) {
+          // INVARIANT: #clientDelegation implies a bridge.
           this.#fastTier =
-            this.bridge
-              ?.clientTools?.()
+            this.bridge!
+              .clientTools?.()
               ?.open({
                 send: (frame) => {
                   const ws = this.#ws;
@@ -974,6 +978,7 @@ export class RuntypeVoiceProvider implements VoiceProvider {
                   ? input.userUtteranceIds.filter((id: unknown): id is string => typeof id === "string")
                   : [],
                 messages: Array.isArray(input.messages) ? input.messages : [],
+                priorToolResults: input.priorToolResults,
               },
               generation,
             );

package/src/voice/session-voice-wiring.ts

@@ -81,8 +81,7 @@ export const wireSessionVoice = (
           busy: () => p.busy(),
           parked: () => s.webMcpApprovalResolvers.size > 0,
           claim: (text, userUtteranceIds) => p.keyed?.claimUserTurn(text, userUtteranceIds) ?? null,
-          send: (text, userMessageId) =>
-            s.sendMessage(text, { viaVoice: true, voiceTurn: { userMessageId } }),
+          send: (text, voiceTurn) => s.sendMessage(text, { viaVoice: true, voiceTurn }),
           track: (capture) => {
             p.setDelegation(capture);
           },

package/src/voice/voice-delegation.ts

@@ -45,8 +45,11 @@ export interface VoiceDelegationHost {
   parked(): boolean;
   /** The transcript bubble the request came from (see KeyedVoiceTranscript.claimUserTurn). */
   claim(userText: string, userUtteranceIds: string[]): string | null;
-  /** sendMessage as a voice turn, submitting `userMessageId`'s bubble when given. */
-  send(userText: string, userMessageId: string | undefined): Promise<void>;
+  /**
+   * sendMessage as a voice turn, submitting `userMessageId`'s bubble when
+   * given and recording `priorToolResults` as already-run tool calls.
+   */
+  send(userText: string, voiceTurn: { userMessageId?: string | null; priorToolResults?: unknown }): Promise<void>;
   /** Route the chat stream's assistant messages and failures into `capture` (or stop). */
   track(capture: VoiceDelegationCapture | null): void;
   /** Deny a pending approval (server gate or WebMCP) by its message id. */
@@ -240,6 +243,7 @@ export function createVoiceSessionBridge(host: VoiceDelegationHost): VoiceSessio
       userText,
       userUtteranceIds,
       stream,
+      priorToolResults,
     }: VoiceDelegationRequest): Promise<VoiceDelegationResult> {
       const live = parks.filter((park) => pendingOf(park).length);
       const pendingIds = live.flatMap(pendingOf);
@@ -306,7 +310,10 @@ export function createVoiceSessionBridge(host: VoiceDelegationHost): VoiceSessio
       active = capture;
       retrack();
       try {
-        await host.send(userText, host.claim(userText, userUtteranceIds) ?? undefined);
+        await host.send(userText, {
+          userMessageId: host.claim(userText, userUtteranceIds),
+          priorToolResults,
+        });
         // Local tools and approvals may continue the turn past the first stream.
         await settled(capture);
       } catch {

package/src/voice/voice.test.ts

@@ -1762,7 +1762,7 @@ describe('RuntypeVoiceProvider (realtime streaming)', () => {
           );
         const results = (ws: MockWebSocket) => sentJson(ws).filter((f) => f.type === 'client_tool_result');
 
-        it('declares client_tools only when the bridge has WebMCP tools', async () => {
+        it('declares client_tools and prior_tool_results only when the bridge has WebMCP tools', async () => {
           const { ws } = await startFastCall();
           expect(ws.url).toBe(
             voiceUrl('wss://api.example.com', 'a1', [
@@ -1772,12 +1772,15 @@ describe('RuntypeVoiceProvider (realtime streaming)', () => {
               'delegation_read_back',
               'delegation_stream',
               'client_tools',
+              'prior_tool_results',
             ]),
           );
           const provider = new RuntypeVoiceProvider(baseConfig());
           provider.setSessionBridge({ ...makeBridge().bridge, clientTools: () => null });
           await provider.startListening();
-          expect(new URL(lastWs().url).searchParams.get('clientCapabilities')).not.toContain('client_tools');
+          const declared = new URL(lastWs().url).searchParams.get('clientCapabilities');
+          expect(declared).not.toContain('client_tools');
+          expect(declared).not.toContain('prior_tool_results');
         });
 
         it('sends client_tools after session_config with full webmcp: names and the dispatch fields', async () => {
@@ -2002,6 +2005,39 @@ describe('RuntypeVoiceProvider (realtime streaming)', () => {
           ]);
         });
 
+        it('hands a fall-through its priorToolResults without running them again on the page', async () => {
+          const { ws, calls, executed, recorded, pending } = await startFastCall([...FAST_CAPS, 'prior_tool_results']);
+          const prior = [
+            { toolCallId: 'vtc_01', name: 'webmcp:jump_to_slide', arguments: { position: 5 }, result: { slideTitle: 'Pricing' } },
+          ];
+          heard(ws);
+          toolCall(ws);
+          await flush();
+          expect(executed).toHaveLength(1);
+          ws.triggerMessage(
+            JSON.stringify({
+              type: 'delegation_started',
+              delegationId: 'd1',
+              input: { text: 'Jump to the pricing slide', userUtteranceIds: ['u1'], messages: [], priorToolResults: prior },
+            }),
+          );
+          await flush();
+          expect(calls).toHaveLength(1);
+          expect(calls[0].priorToolResults).toEqual(prior);
+          pending[0]({ status: 'completed', text: 'You are on Pricing.' });
+          await flush();
+          directCompleted(ws);
+          expect(executed).toHaveLength(1);
+          expect(recorded).toEqual([]);
+        });
+
+        it('leaves priorToolResults unset on a fall-through without them', async () => {
+          const { ws, calls } = await startFastCall();
+          started(ws, 'd1');
+          await flush();
+          expect(calls[0].priorToolResults).toBeUndefined();
+        });
+
         it('ignores a direct completion when client_tools was not negotiated', async () => {
           const { ws, recorded } = await startFastCall(ALL_CAPS);
           heard(ws);

package/dist/chunk-B6zZsT6F.js

@@ -1 +0,0 @@
-const e=[1e3,2e3,4e3,8e3,8e3];function t(t){let n=0,r=null,i=null,a=!1,o=()=>{if(i&&=(clearTimeout(i),null),r){let e=r;r=null,e()}},s=()=>{let e=t.getStatus();(e===`resuming`||e===`paused`)&&o()},c=()=>{(typeof document>`u`||document.visibilityState!==`hidden`)&&s()},l=()=>{s()},u=()=>{a||=(typeof document<`u`&&document.addEventListener(`visibilitychange`,c),typeof window<`u`&&window.addEventListener(`online`,l),!0)},d=()=>{a&&=(typeof document<`u`&&document.removeEventListener(`visibilitychange`,c),typeof window<`u`&&window.removeEventListener(`online`,l),!1)},f=e=>new Promise(t=>{r=t,i=setTimeout(()=>{i=null,r=null,t()},e)}),p=()=>{let e=t.getResumable();t.clearResumable(),t.setReconnecting(!1),n=0,d(),t.setAbortController(null);let r=!1;for(let e of t.getMessages())e.streaming&&(e.streaming=!1,r=!0);let i=t.buildErrorContent(`Connection lost and the response could not be resumed.`);i?t.appendMessage({id:`reconnect-failed-${e?.executionId??t.nextSequence()}`,role:`assistant`,content:i,createdAt:(/* @__PURE__ */ new Date()).toISOString(),streaming:!1,sequence:t.nextSequence()}):r&&t.notifyMessagesChanged(),t.setStreaming(!1),t.setStatus(`idle`),t.onError(/* @__PURE__ */ Error(`Durable session reconnect failed.`))},m=async()=>{let r=t.config.reconnect?.backoffMs??e,i=t.config.reconnect?.maxAttempts??r.length,a=t.config.reconnectStream;if(!a)t.setReconnecting(!1);else{for(;t.getResumable()&&n<i;){n+=1,t.setStatus(`resuming`);let e=t.getResumable(),o=e.lastEventId,s=new AbortController;t.setAbortController(s),t.emitReconnect({phase:`resuming`,handle:e,attempt:n});let c=null;try{let t=await a({executionId:e.executionId,after:e.lastEventId,signal:s.signal});t&&t.ok&&t.body&&(c=t.body)}catch{c=null}if(s.signal.aborted)return;if(c){let r=t.getMessages().find(t=>t.id===e.assistantMessageId)?.content,i=typeof r==`string`?r:``;try{await t.resumeConnect(c,e.assistantMessageId,i)}catch{}if(s.signal.aborted)return;if(!t.getResumable()){t.setReconnecting(!1),n=0,d(),t.emitReconnect({phase:`resumed`,handle:e});return}t.getResumable().lastEventId!==o&&(n=0)}if(t.getResumable()&&n<i&&(t.setStatus(`paused`),await f(r[Math.min(n-1,r.length-1)]??1e3),s.signal.aborted))return}t.getResumable()&&p()}};return{begin(){n=0,u(),m()},teardown(){i&&=(clearTimeout(i),null),r=null,n=0,d()},wake:o}}export{t as createReconnectController};

package/dist/chunk-CIVsNcrk.js

@@ -1 +0,0 @@
-const e=`4.29.0`;export{e as t};