@runtypelabs/persona 4.29.0 → 4.29.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtypelabs/persona",
-  "version": "4.29.0",
+  "version": "4.29.2",
   "description": "Themeable, pluggable streaming agent widget for websites, in plain JS with support for voice input and reasoning / tool output.",
   "type": "module",
   "main": "dist/index.cjs",

package/src/client-approve.test.ts

@@ -176,6 +176,22 @@ describe("AgentWidgetSession.resolveApproval in client-token mode", () => {
     expect(errors).toEqual([]);
   });
 
+  it("sends the continuation bubble's id so the stored reply dedupes by id (core#9961)", async () => {
+    const calls = mockFetch(
+      sse([
+        { type: "text_start", id: "t1" },
+        { type: "text_delta", id: "t1", delta: "Order placed." },
+        { type: "text_complete", id: "t1" },
+        { type: "execution_complete", kind: "agent", success: true },
+      ])
+    );
+    const { approve, last } = setup();
+    await approve();
+
+    expect(calls[0].body.assistantMessageId).toMatch(/^ast_/);
+    expect(last()?.id).toBe(calls[0].body.assistantMessageId);
+  });
+
   it.each([
     [
       403,
@@ -210,7 +226,7 @@ describe("AgentWidgetSession.resolveApproval in client-token mode", () => {
     await approve();
 
     expect(bubble()?.approval?.status).toBe(badge);
-    expect(last()).toMatchObject({ id: "approval-error-appr_1", content: text });
+    expect(last()).toMatchObject({ id: "approval-error-appr_1", content: text, localOnly: true });
     expect(session.isStreaming()).toBe(false);
     expect(errors.map((e) => e.message)).toEqual([text]);
     // A refused request settles too: its token must not outlive it.

package/src/client-resume.ts

@@ -41,7 +41,8 @@ export type ClientResumeHost = {
 export async function resolveApproval(
   h: ClientResumeHost,
   approval: { agentId: string; executionId: string; approvalId: string },
-  decision: "approved" | "denied"
+  decision: "approved" | "denied",
+  options?: { assistantMessageId?: string }
 ): Promise<Response> {
   let headers: Record<string, string> = {
     'Content-Type': 'application/json',
@@ -68,7 +69,10 @@ export async function resolveApproval(
 
   // Same re-validation as `resumeFlow`: an approval can sit for a long time.
   const { sessionId } = await h.initSession();
-  const response = await post('/v1/client/approve', { sessionId });
+  const response = await post('/v1/client/approve', {
+    sessionId,
+    ...(options?.assistantMessageId ? { assistantMessageId: options.assistantMessageId } : {}),
+  });
   // A core without the route answers with its generic `Not Found`; an unknown
   // or expired pause 404s with its own error, which the caller surfaces.
   if (response.status === 404) {
@@ -83,7 +87,13 @@ export async function resumeFlow(
   h: ClientResumeHost,
   executionId: string,
   toolOutputs: Record<string, unknown>,
-  options?: { streamResponse?: boolean; signal?: AbortSignal; after?: string }
+  options?: {
+    streamResponse?: boolean;
+    signal?: AbortSignal;
+    after?: string;
+    /** Id of the local bubble the resumed stream renders into (client-token only). */
+    assistantMessageId?: string;
+  }
 ): Promise<Response> {
   const isClientToken = h.isClientTokenMode();
   const url = isClientToken
@@ -125,6 +135,8 @@ export async function resumeFlow(
   // Thread the (refreshed) sessionId through like `/v1/client/chat` does.
   if (resumeSessionId) {
     body.sessionId = resumeSessionId;
+    // WHY(runtypelabs/core#9961): the server stores the reply under this id, so a later re-send dedupes by id.
+    if (options?.assistantMessageId) body.assistantMessageId = options.assistantMessageId;
   }
 
   if (isClientToken && resumeSessionId) {

package/src/client.interrupt.test.ts

@@ -108,6 +108,27 @@ describe("client-token turn identity", () => {
     expect(bodies[1]).not.toHaveProperty("voice");
   });
 
+  it("a voice hand-back with prior tool results sends them under voice; an empty list sends none", async () => {
+    const bodies: Record<string, unknown>[] = [];
+    global.fetch = vi.fn(async (url: unknown, init: any) => {
+      if (String(url).endsWith("/v1/client/init")) return initResponse();
+      bodies.push(JSON.parse(init.body));
+      const stream = controlledStream();
+      stream.close();
+      return stream.response;
+    }) as unknown as typeof fetch;
+    const prior = [
+      { toolCallId: "vtc_1", name: "webmcp:jump_to_slide", arguments: { position: 5 }, result: { slideTitle: "Pricing" } },
+    ];
+
+    const client = clientTokenClient();
+    await client.dispatch({ messages, voiceSpoken: true, voicePriorToolResults: prior }, () => {});
+    await client.dispatch({ messages, voiceSpoken: true, voicePriorToolResults: [] }, () => {});
+
+    expect(bodies[0].voice).toEqual({ spoken: true, priorToolResults: prior });
+    expect(bodies[1].voice).toEqual({ spoken: true });
+  });
+
   it("drops SSE events belonging to a superseded turn", async () => {
     const first = controlledStream();
     const second = controlledStream();

package/src/client.ts

@@ -14,6 +14,7 @@ import {
   AgentWidgetSSEEventResult as _AgentWidgetSSEEventResult,
   ClientSession,
   ClientChatRequest,
+  VoicePriorToolResult,
   ClientToolDefinition,
   ClientFeedbackRequest,
   ClientFeedbackType,
@@ -55,6 +56,7 @@ import type { ClientResumeHost } from "./client-resume";
 /** History transcripts stay on the wire shape; `utils/history-messages.ts` maps them. */
 export type { HistoryWireMessage } from "./utils/history-messages";
 import { divergentDisplayProjection } from "./utils/history-messages";
+import { isLocalOnlyMessage } from "./utils/local-only-message";
 // artifactsSidebarEnabled is used in ui.ts to gate the sidebar pane rendering;
 // artifact events are always processed here regardless of config.
 
@@ -81,6 +83,12 @@ type DispatchOptions = {
    * answer.
    */
   voiceSpoken?: boolean;
+  /**
+   * Client-token only: page tools the voice server already ran for this
+   * delegated turn, sent as `voice.priorToolResults` with `voiceSpoken`.
+   * Proxy/agent payloads carry them as replayed tool rows instead.
+   */
+  voicePriorToolResults?: VoicePriorToolResult[];
 };
 
 export type SSEHandler = (event: AgentWidgetEvent) => void;
@@ -153,6 +161,7 @@ const isHistoryClientError = (
 const hasValidContent = (message: AgentWidgetMessage): boolean => {
   // Display-only voice captions are never conversation.
   if (message.voiceCaption) return false;
+  if (isLocalOnlyMessage(message)) return false;
   // Check contentParts (multi-modal content)
   if (message.contentParts && message.contentParts.length > 0) {
     return true;
@@ -1553,7 +1562,12 @@ export class AgentWidgetClient {
         // superseded run and this client can drop its stale events below.
         turnId,
         ...(options.interrupt && { submitMode: 'interrupt' as const }),
-        ...(options.voiceSpoken && { voice: { spoken: true as const } }),
+        ...(options.voiceSpoken && {
+          voice: {
+            spoken: true as const,
+            ...(options.voicePriorToolResults?.length && { priorToolResults: options.voicePriorToolResults }),
+          },
+        }),
       };
 
       // Diff-only / send-once WebMCP tool dispatch. `buildPayload()` already
@@ -1867,9 +1881,10 @@ export class AgentWidgetClient {
    */
   public async resolveApproval(
     approval: { agentId: string; executionId: string; approvalId: string },
-    decision: 'approved' | 'denied'
+    decision: 'approved' | 'denied',
+    options?: { assistantMessageId?: string }
   ): Promise<Response> {
-    return (await loadClientStream()).resolveApproval(this.#resumeHost(), approval, decision);
+    return (await loadClientStream()).resolveApproval(this.#resumeHost(), approval, decision, options);
   }
 
   /**
@@ -2009,7 +2024,12 @@ export class AgentWidgetClient {
   public async resumeFlow(
     executionId: string,
     toolOutputs: Record<string, unknown>,
-    options?: { streamResponse?: boolean; signal?: AbortSignal; after?: string }
+    options?: {
+      streamResponse?: boolean;
+      signal?: AbortSignal;
+      after?: string;
+      assistantMessageId?: string;
+    }
   ): Promise<Response> {
     return (await loadClientStream()).resumeFlow(this.#resumeHost(), executionId, toolOutputs, options);
   }

package/src/components/activity-row.ts

@@ -41,13 +41,14 @@ export function applyActivityRow(bubble: HTMLElement, message: AgentWidgetMessag
   const data = kind === "tool" ? message.toolCall : message.reasoning;
   const active = data?.status !== "complete";
   const approval = message.approval?.status ?? message.toolCall?.approvalStatus;
-  const state = approval === "denied" ? "denied" : approval === "pending" ? "awaiting-approval"
+  const state = message.toolCall?.interrupted ? "interrupted"
+    : approval === "denied" ? "denied" : approval === "pending" ? "awaiting-approval"
     : message.toolCall?.success === false ? "error" : !active ? "done"
     : data?.status === "pending" ? "pending" : "running";
   bubble.dataset.activityState = state;
   const icon = createElement("span", "persona-activity-icon");
   icon.dataset.activityIcon = state;
-  const names = { pending: "circle", running: "loader-circle", done: "check", error: "x", denied: "x", "awaiting-approval": "clock" };
+  const names = { pending: "circle", running: "loader-circle", done: "check", error: "x", denied: "x", interrupted: "x", "awaiting-approval": "clock" };
   const customIcon = kind === "reasoning" ? config.features?.reasoningDisplay?.iconName : undefined;
   const glyph = customIcon ? renderLucideIcon(customIcon, 16, "currentColor", 2)
     : state === "pending" ? renderIconNode(Circle, 16, "currentColor", 2)

package/src/components/approval-actions.test.ts

@@ -346,3 +346,11 @@ describe("built-in approval — resolved states", () => {
     expect(el?.textContent).toContain("timed out");
   });
 });
+
+it("interrupted approvals explain expiry without action controls", () => {
+  const { el } = render({}, makeMessage({ status: "timeout", interrupted: true }));
+  expect(el?.textContent).toContain("approval expired");
+  expect(el?.textContent).toContain("chat restarted");
+  expect(el?.textContent).toContain("fresh proposal");
+  expect(el?.querySelector("button, [data-action]")).toBeNull();
+});

package/src/components/approval-actions.ts

@@ -18,7 +18,8 @@
  * tool call takes over the transcript); denied/timeout → a subtle one-line
  * trace.
  */
-import { createElement } from "../utils/dom";
+import { createElement, createNode } from "../utils/dom";
+import { BROWSER_TOOL_INTERRUPTION } from "../utils/restored-browser-state";
 // The webmcp-title lookup is injected by ui.ts at chunk adoption (see
 // approval-deps): this module ships in the lazy approval-ui chunk. Icons are
 // direct lucide data imports.
@@ -168,7 +169,10 @@ const buildResolvedTrace = (approval: Approval): HTMLElement => {
   if (icon) row.appendChild(icon);
   const name = createElement("span", "persona-approval-resolved-name");
   name.textContent = approval.toolName ? humanizeToolName(approval.toolName) : "Tool";
-  row.append(name, document.createTextNode(approval.status === "timeout" ? " timed out" : " denied"));
+  const explanation = approval.status === "timeout" && approval.interrupted
+    ? ` approval expired. ${BROWSER_TOOL_INTERRUPTION}`
+    : approval.status === "timeout" ? " timed out" : " denied";
+  row.appendChild(createNode("span", { className: "persona-approval-resolved-text" }, name, explanation));
   return row;
 };
 

package/src/components/approval-bubble.test.ts

@@ -5,6 +5,7 @@ import {
   createApprovalBubble,
   humanizeToolName,
   updateApprovalDetailsUI,
+  updateApprovalBubbleUI,
 } from "./approval-bubble";
 import {
   getWebMcpToolDisplayTitle,
@@ -45,6 +46,19 @@ const makeMessage = (
   },
 });
 
+it("shows interruption metadata while keeping the existing timeout status", () => {
+  const bubble = createApprovalBubble(makeMessage({ status: "timeout", interrupted: true }));
+  const badge = bubble.querySelector("[data-approval-status]");
+  expect(badge?.getAttribute("data-approval-status")).toBe("timeout");
+  expect(badge?.textContent).toBe("Interrupted");
+  expect(bubble.textContent).toContain("chat restarted");
+  expect(bubble.textContent).toContain("fresh proposal");
+  expect(bubble.querySelector('[data-action="allow"], [data-action="deny"]')).toBeNull();
+  updateApprovalBubbleUI("msg-1", bubble, {}, makeMessage({ status: "timeout", interrupted: true }).approval);
+  expect(badge?.textContent).toBe("Interrupted");
+  expect(badge?.getAttribute("data-approval-status")).toBe("timeout");
+});
+
 describe("createApprovalBubble shadow", () => {
   it("falls back to the themeable --persona-approval-shadow variable when no config.shadow is set", () => {
     const bubble = createApprovalBubble(makeMessage());

package/src/components/approval-bubble.ts

@@ -1,3 +1,4 @@
+import { BROWSER_TOOL_INTERRUPTION } from "../utils/restored-browser-state";
 import { createElement } from "../utils/dom";
 import { AgentWidgetMessage, AgentWidgetConfig } from "../types";
 import { formatUnknownValue } from "../utils/formatting";
@@ -100,6 +101,7 @@ export const updateApprovalBubbleUI = (
   if (statusBadge) {
     statusBadge.textContent = approval.status === "approved" ? "Approved"
       : approval.status === "denied" ? "Denied"
+      : (approval.status === "timeout" && approval.interrupted) ? "Interrupted"
       : approval.status === "timeout" ? "Timeout"
       : "Pending";
 
@@ -232,12 +234,17 @@ export const createApprovalBubble = (
     } else if (approval.status === "timeout") {
       badge.style.backgroundColor = "var(--persona-palette-colors-warning-100)";
       badge.style.color = "var(--persona-palette-colors-warning-700)";
-      badge.textContent = "Timeout";
+      badge.textContent = (approval.status === "timeout" && approval.interrupted) ? "Interrupted" : "Timeout";
     }
     titleRow.appendChild(badge);
   }
 
   content.appendChild(titleRow);
+  if (approval.status === "timeout" && approval.interrupted) {
+    const notice = createElement("p", "persona-text-sm");
+    notice.textContent = BROWSER_TOOL_INTERRUPTION;
+    content.appendChild(notice);
+  }
 
   // User-facing summary line. The wire `description` is the tool's
   // agent-facing description (prompt prose, usage rules), so it is not shown

package/src/components/tool-bubble.ts

@@ -78,7 +78,8 @@ const getToolSummaryText = (
         message,
         toolDisplayConfig?.previewMaxLines ?? DEFAULT_TOOL_CALL_DISPLAY.previewMaxLines
       );
-  const defaultSummary = tool ? (activityVariant(config, "tool") === "row" ? `${tool.status === "complete" ? "Used" : "Using"} ${tool.name?.trim() || "tool"}` : describeToolTitle(tool)) : "";
+  const defaultSummary = tool?.interrupted ? `${tool.name?.trim() || "Tool"} · Interrupted`
+    : tool ? (activityVariant(config, "tool") === "row" ? `${tool.status === "complete" ? "Used" : "Using"} ${tool.name?.trim() || "tool"}` : describeToolTitle(tool)) : "";
 
   if (!tool) {
     return { summary: defaultSummary, previewText, isActive: false };
@@ -96,11 +97,13 @@ const getToolSummaryText = (
   // Apply text templates if configured
   if (isActive && toolCallConfig.activeTextTemplate) {
     summary = resolveToolHeaderText(tool, toolCallConfig.activeTextTemplate, summary);
-  } else if (!isActive && toolCallConfig.completeTextTemplate) {
+  } else if (!isActive && !tool.interrupted && toolCallConfig.completeTextTemplate) {
     summary = resolveToolHeaderText(tool, toolCallConfig.completeTextTemplate, summary);
   }
 
-  if (tool.success === false) summary += " · Failed";
+  if (tool.interrupted) {
+    if (!summary.includes(" · Interrupted")) summary += " · Interrupted";
+  } else if (tool.success === false) summary += " · Failed";
   else if (tool.superseded) summary += " · Approved, ran again below";
   return { summary, previewText, isActive };
 };
@@ -184,7 +187,7 @@ export const createToolBubble = (
   // Helper: build a <span data-tool-elapsed> that the global timer in ui.ts updates
   const createElapsedSpan = (): HTMLElement => {
     const span = createElement("span", "");
-    span.setAttribute("data-tool-elapsed", startedAt);
+    if (isActive) span.setAttribute("data-tool-elapsed", startedAt);
     span.textContent = computeToolElapsed(tool);
     return span;
   };
@@ -213,7 +216,7 @@ export const createToolBubble = (
   // Apply loading animation when tool is active and no custom HTMLElement was provided
   const loadingAnimation = toolDisplayConfig.loadingAnimation ?? DEFAULT_TOOL_CALL_DISPLAY.loadingAnimation;
   const activeTemplate = toolCallConfig.activeTextTemplate;
-  const completeTemplate = toolCallConfig.completeTextTemplate;
+  const completeTemplate = tool.interrupted ? undefined : toolCallConfig.completeTextTemplate;
   const currentTemplate = isActive ? activeTemplate : completeTemplate;
   const skipCustomElement = customSummary instanceof HTMLElement;
 

package/src/generated/runtype-openapi-contract.ts

@@ -710,9 +710,15 @@ export type RuntypeClientChatRequest = {
 }>;
   metadata?: Record<string, unknown>;
   sessionId: string;
-  submitMode?: "normal" | "interrupt" | "steer";
+  submitMode?: "normal" | "interrupt" | "steer" | "auto";
   turnId?: string;
   voice?: {
+  priorToolResults?: Array<{
+  arguments: Record<string, unknown>;
+  name: string;
+  result?: unknown;
+  toolCallId: string;
+}>;
   spoken?: boolean;
 };
 };

package/src/resume-dedupe-local-only.test.ts

@@ -0,0 +1,273 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { AgentWidgetClient } from "./client";
+import { AgentWidgetSession, type AgentWidgetSessionStatus } from "./session";
+import type { AgentWidgetConfig, AgentWidgetMessage, ResumableHandle } from "./types";
+
+// runtypelabs/core#9961: resumed replies must keep the id the server stores
+// them under, and widget failure notices must never become history.
+
+const originalFetch = global.fetch;
+afterEach(() => {
+  global.fetch = originalFetch;
+  vi.restoreAllMocks();
+});
+
+const enc = new TextEncoder();
+const frame = (data: Record<string, unknown>) => `data: ${JSON.stringify(data)}\n\n`;
+const sseStream = (text: string) =>
+  new ReadableStream<Uint8Array>({
+    start(c) {
+      if (text) c.enqueue(enc.encode(text));
+      c.close();
+    },
+  });
+const replyFrames = (text: string) =>
+  frame({ type: "text_start", id: "t1" }) +
+  frame({ type: "text_delta", id: "t1", delta: text }) +
+  frame({ type: "text_complete", id: "t1" }) +
+  frame({ type: "execution_complete", kind: "agent", success: true });
+
+type ClientInternals = {
+  clientSession: { sessionId: string; expiresAt: Date };
+  isWebMcpOperational: () => boolean;
+  executeWebMcpToolCall: () => Promise<unknown>;
+  resumeFlow: (...args: unknown[]) => Promise<Response>;
+};
+const internals = (session: AgentWidgetSession) =>
+  (session as unknown as { client: ClientInternals }).client;
+
+const track = (config: AgentWidgetConfig) => {
+  const state = {
+    messages: [] as AgentWidgetMessage[],
+    status: "idle" as AgentWidgetSessionStatus,
+    errors: [] as Error[],
+  };
+  const session = new AgentWidgetSession(config, {
+    onMessagesChanged: (m) => {
+      state.messages = m;
+    },
+    onStatusChanged: (s) => {
+      state.status = s;
+    },
+    onStreamingChanged: () => {},
+    onError: (e) => state.errors.push(e),
+  });
+  return { session, state };
+};
+
+const awaitingWebMcpTool = (): AgentWidgetMessage => ({
+  id: "tool-call-1",
+  role: "assistant",
+  content: "",
+  createdAt: "2026-01-01T00:00:01.000Z",
+  streaming: true,
+  variant: "tool",
+  agentMetadata: { executionId: "exec-1", awaitingLocalTool: true, webMcpToolCallId: "call-1" },
+  toolCall: { id: "call-1", name: "webmcp:purchase", status: "running", args: { quantity: 1 } },
+});
+
+describe("resumed reply ids", () => {
+  const tokenClient = () => {
+    const client = new AgentWidgetClient({ clientToken: "ct_live_demo", apiUrl: "https://api.runtype.com" });
+    (client as unknown as ClientInternals).clientSession = {
+      sessionId: "cs_123",
+      expiresAt: new Date(Date.now() + 60_000),
+    };
+    return client;
+  };
+  const captureBodies = () => {
+    const bodies: Record<string, unknown>[] = [];
+    global.fetch = vi.fn(async (_url: string, init: RequestInit) => {
+      bodies.push(JSON.parse(init.body as string));
+      return new Response(sseStream(""));
+    }) as unknown as typeof fetch;
+    return bodies;
+  };
+
+  it("sends the local bubble id as assistantMessageId on a client-token /resume", async () => {
+    const bodies = captureBodies();
+    await tokenClient().resumeFlow("exec_1", { call_1: "ok" }, { assistantMessageId: "ast_local" });
+    expect(bodies[0]).toMatchObject({ executionId: "exec_1", sessionId: "cs_123", assistantMessageId: "ast_local" });
+  });
+
+  it("keeps the proxy /resume body unchanged", async () => {
+    const bodies = captureBodies();
+    const client = new AgentWidgetClient({ apiUrl: "https://proxy.example.com/chat" });
+    await client.resumeFlow("exec_1", { call_1: "ok" }, { assistantMessageId: "ast_local" });
+    expect(bodies[0].assistantMessageId).toBeUndefined();
+  });
+
+  it("renders a resumed WebMCP leg into the bubble whose id it sent", async () => {
+    const { session, state } = track({ apiUrl: "http://test", webmcp: { enabled: true } });
+    const client = internals(session);
+    client.isWebMcpOperational = () => true;
+    client.executeWebMcpToolCall = vi.fn(async () => ({ content: [{ type: "text", text: "Purchased" }] }));
+    const resume = vi.fn(async () => new Response(sseStream(replyFrames("Your order is in."))));
+    client.resumeFlow = resume;
+
+    await session.resolveWebMcpToolCall(awaitingWebMcpTool());
+
+    expect(resume).toHaveBeenCalledTimes(1);
+    const sentId = (resume.mock.calls[0] as unknown[])[2] as { assistantMessageId?: string };
+    expect(sentId.assistantMessageId).toMatch(/^ast_/);
+    const reply = state.messages.find((m) => m.content === "Your order is in.");
+    expect(reply?.id).toBe(sentId.assistantMessageId);
+    session.destroy();
+  });
+});
+
+describe("local-only failure notices", () => {
+  it("shows a dispatch failure but never sends it as history", async () => {
+    const payloads: Array<{ messages: Array<{ role: string; content: unknown }> }> = [];
+    let calls = 0;
+    const { session, state } = track({
+      apiUrl: "http://test",
+      customFetch: async (_url, _init, payload) => {
+        payloads.push(payload as (typeof payloads)[number]);
+        calls += 1;
+        if (calls === 1) throw new Error("upstream unavailable");
+        return new Response(sseStream(replyFrames("Back online.")));
+      },
+    });
+
+    await session.sendMessage("first");
+    const notice = state.messages.at(-1)!;
+    expect(notice.role).toBe("assistant");
+    expect(notice.localOnly).toBe(true);
+
+    await session.sendMessage("second");
+    expect(payloads[1].messages.map((m) => m.content)).toEqual(["first", "second"]);
+    session.destroy();
+  });
+
+  it("drops reconnect-failure bubbles stored before the flag existed", async () => {
+    const payloads: Array<{ messages: Array<{ content: unknown }> }> = [];
+    const { session } = track({
+      apiUrl: "http://test",
+      initialMessages: [
+        { id: "u1", role: "user", content: "hi", createdAt: "2026-01-01T00:00:00.000Z" },
+        {
+          id: "reconnect-failed-exec_1",
+          role: "assistant",
+          content: "Connection lost and the response could not be resumed.",
+          createdAt: "2026-01-01T00:00:01.000Z",
+        },
+      ],
+      customFetch: async (_url, _init, payload) => {
+        payloads.push(payload as (typeof payloads)[number]);
+        return new Response(sseStream(replyFrames("ok")));
+      },
+    });
+
+    await session.sendMessage("again");
+    expect(payloads[0].messages.map((m) => m.content)).toEqual(["hi", "again"]);
+    session.destroy();
+  });
+
+  it("marks the reconnect give-up bubble local-only", async () => {
+    const { session, state } = track({
+      apiUrl: "http://test",
+      reconnectStream: async () => {
+        throw new Error("network down");
+      },
+      reconnect: { backoffMs: [1], maxAttempts: 1 },
+    });
+    session.hydrateMessages([
+      { id: "u1", role: "user", content: "tell me", createdAt: "2026-01-01T00:00:00.000Z" },
+      { id: "a1", role: "assistant", content: "Once", createdAt: "2026-01-01T00:00:01.000Z" },
+    ]);
+
+    session.resumeFromHandle({ executionId: "exec_5", after: "5" });
+    await vi.waitFor(() => expect(state.errors).toHaveLength(1));
+
+    const notice = state.messages.find((m) => m.id === "reconnect-failed-exec_5");
+    expect(notice?.localOnly).toBe(true);
+    session.destroy();
+  });
+});
+
+describe("boot resume of a run parked on an await", () => {
+  it("keeps retrying when the reconnect request itself fails", async () => {
+    let calls = 0;
+    const reconnectStream = vi.fn(async () => {
+      calls += 1;
+      if (calls === 1) throw new Error("network blip");
+      return new Response(sseStream(""));
+    });
+    const { session, state } = track({
+      apiUrl: "http://test",
+      webmcp: { enabled: true },
+      reconnectStream,
+      reconnect: { backoffMs: [1, 1, 1, 1, 1], maxAttempts: 5 },
+    });
+    session.hydrateMessages([
+      { id: "u1", role: "user", content: "buy one", createdAt: "2026-01-01T00:00:00.000Z" },
+      { id: "a1", role: "assistant", content: "Buying it now.", createdAt: "2026-01-01T00:00:00.500Z" },
+      awaitingWebMcpTool(),
+    ]);
+
+    session.resumeFromHandle({ executionId: "exec-1", after: "7" });
+    await vi.waitFor(() => expect(state.status).toBe("idle"));
+    await new Promise((r) => setTimeout(r, 20));
+
+    expect(reconnectStream).toHaveBeenCalledTimes(2);
+    expect(state.errors).toEqual([]);
+    expect(session.getResumableHandle()).toBeNull();
+    session.destroy();
+  });
+
+  it("ends quietly when the reload interrupted the WebMCP call and nothing replays", async () => {
+    const executionStates: Array<ResumableHandle | null> = [];
+    const reconnectStream = vi.fn(async () => new Response(sseStream("")));
+    const { session, state } = track({
+      apiUrl: "http://test",
+      webmcp: { enabled: true },
+      reconnectStream,
+      reconnect: { backoffMs: [1, 1, 1, 1, 1], maxAttempts: 5 },
+      onExecutionState: (h) => executionStates.push(h),
+    });
+    session.hydrateMessages([
+      { id: "u1", role: "user", content: "buy one", createdAt: "2026-01-01T00:00:00.000Z" },
+      { id: "a1", role: "assistant", content: "Buying it now.", createdAt: "2026-01-01T00:00:00.500Z" },
+      awaitingWebMcpTool(),
+    ]);
+
+    session.resumeFromHandle({ executionId: "exec-1", after: "7" });
+    await vi.waitFor(() => expect(state.status).toBe("idle"));
+    await new Promise((r) => setTimeout(r, 20));
+
+    expect(reconnectStream).toHaveBeenCalledTimes(1);
+    expect(state.errors).toEqual([]);
+    expect(state.messages.some((m) => m.id.startsWith("reconnect-failed-"))).toBe(false);
+    expect(state.messages.every((m) => !m.streaming)).toBe(true);
+    expect(state.messages.map((m) => m.id)).toEqual(["u1", "a1", "tool-call-1"]);
+    expect(session.getResumableHandle()).toBeNull();
+    expect(executionStates.at(-1)).toBeNull();
+    session.destroy();
+  });
+
+  it("keeps the cursor for a pending ask_user_question card instead of reconnecting", async () => {
+    const reconnectStream = vi.fn(async () => new Response(sseStream("")));
+    const { session, state } = track({ apiUrl: "http://test", reconnectStream });
+    session.hydrateMessages([
+      { id: "u1", role: "user", content: "plan a trip", createdAt: "2026-01-01T00:00:00.000Z" },
+      {
+        id: "tool-ask-1",
+        role: "assistant",
+        content: "",
+        createdAt: "2026-01-01T00:00:01.000Z",
+        variant: "tool",
+        agentMetadata: { executionId: "exec-2", awaitingLocalTool: true },
+        toolCall: { id: "ask-1", name: "ask_user_question", status: "running" },
+      },
+    ]);
+
+    session.resumeFromHandle({ executionId: "exec-2", after: "4" });
+    await new Promise((r) => setTimeout(r, 20));
+
+    expect(reconnectStream).not.toHaveBeenCalled();
+    expect(state.status).toBe("idle");
+    expect(session.getResumableHandle()).toMatchObject({ executionId: "exec-2", lastEventId: "4" });
+    session.destroy();
+  });
+});