@runtypelabs/persona 4.23.0 → 4.23.2

package/src/client.tool-pair-replay.test.ts

@@ -0,0 +1,325 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+import { AgentWidgetClient } from "./client";
+import { AgentWidgetSession } from "./session";
+import type { AgentWidgetMessage, ClientToolDefinition } from "./types";
+import { modelFacingToolName } from "./utils/tool-pair-replay";
+
+const SEARCH_TOOL: ClientToolDefinition = {
+  name: "search_catalog",
+  description: "Search the catalog",
+  origin: "webmcp",
+};
+
+const RESULT = { content: [{ type: "text", text: "SKU-42 costs $19" }] };
+
+const user = (id: string, content: string, at: number): AgentWidgetMessage => ({
+  id,
+  role: "user",
+  content,
+  createdAt: new Date(at).toISOString(),
+});
+
+const assistant = (id: string, content: string, at: number): AgentWidgetMessage => ({
+  id,
+  role: "assistant",
+  content,
+  createdAt: new Date(at).toISOString(),
+  variant: "assistant",
+});
+
+const answeredTool = (
+  toolCallId: string,
+  at: number,
+  overrides: Partial<NonNullable<AgentWidgetMessage["agentMetadata"]>> = {},
+): AgentWidgetMessage => ({
+  id: `tool-${toolCallId}`,
+  role: "assistant",
+  content: "",
+  createdAt: new Date(at).toISOString(),
+  variant: "tool",
+  toolCall: {
+    id: toolCallId,
+    name: "webmcp:search_catalog",
+    status: "complete",
+    args: { q: "sku 42" },
+    result: RESULT,
+  },
+  agentMetadata: {
+    executionId: "exec-1",
+    awaitingLocalTool: false,
+    webMcpToolCallId: toolCallId,
+    clientToolAnswer: {
+      toolCallId,
+      toolName: "webmcp:search_catalog",
+      args: { q: "sku 42" },
+      result: RESULT,
+    },
+    ...overrides,
+  },
+});
+
+/** Turn 1 (with its answered tool) followed by turn 2's user message. */
+const twoTurnTranscript = (): AgentWidgetMessage[] => [
+  user("u1", "What does SKU 42 cost?", 1_000),
+  answeredTool("toolu_01", 2_000),
+  assistant("a1", "SKU 42 costs $19.", 3_000),
+  user("u2", "And what was the SKU again?", 4_000),
+];
+
+function sse(): Response {
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    start(c) {
+      c.enqueue(encoder.encode('data: {"type":"done"}\n\n'));
+      c.close();
+    },
+  });
+  return new Response(stream, { headers: { "Content-Type": "text/event-stream" } });
+}
+
+let bodies: Array<Record<string, unknown>>;
+beforeEach(() => {
+  bodies = [];
+  global.fetch = vi.fn().mockImplementation(async (_url: string, init: { body: string }) => {
+    bodies.push(JSON.parse(init.body));
+    return sse();
+  });
+});
+
+const withTools = (client: AgentWidgetClient, tools: ClientToolDefinition[]) => {
+  (client as unknown as { webMcpBridge: { snapshotForDispatch: () => unknown[] } }).webMcpBridge = {
+    snapshotForDispatch: () => tools,
+  };
+  return client;
+};
+
+const EXPECTED_TURN_2 = [
+  { role: "user", content: "What does SKU 42 cost?" },
+  {
+    role: "assistant",
+    content: "",
+    toolCalls: [{ toolCallId: "toolu_01", toolName: "webmcp_search_catalog", args: { q: "sku 42" } }],
+  },
+  {
+    role: "tool",
+    content: "",
+    toolResults: [{ toolCallId: "toolu_01", toolName: "webmcp_search_catalog", result: RESULT }],
+  },
+  { role: "assistant", content: "SKU 42 costs $19." },
+  { role: "user", content: "And what was the SKU again?" },
+];
+
+const stripCreatedAt = (messages: unknown) =>
+  (messages as Array<Record<string, unknown>>).map(({ createdAt: _createdAt, ...rest }) => rest);
+
+describe("tool-pair replay: proxy mode", () => {
+  it("sends turn 1's answered call and result, paired and in order, on turn 2", async () => {
+    const client = withTools(new AgentWidgetClient({ apiUrl: "http://proxy.test/chat" }), [SEARCH_TOOL]);
+    await client.dispatch({ messages: twoTurnTranscript() }, () => undefined);
+    expect(stripCreatedAt(bodies[0]!.messages)).toEqual(EXPECTED_TURN_2);
+  });
+
+  it("keeps the pair after the page stops offering the tool", async () => {
+    const client = withTools(new AgentWidgetClient({ apiUrl: "http://proxy.test/chat" }), []);
+    await client.dispatch({ messages: twoTurnTranscript() }, () => undefined);
+    expect(stripCreatedAt(bodies[0]!.messages)).toEqual(EXPECTED_TURN_2);
+    expect(bodies[0]!.clientTools).toBeUndefined();
+  });
+});
+
+describe("tool-pair replay: agent mode", () => {
+  it("sends turn 1's answered call and result, paired and in order, on turn 2", async () => {
+    const client = withTools(
+      new AgentWidgetClient({
+        apiUrl: "http://proxy.test/agents",
+        agent: { name: "Test", model: "openai:gpt-4o-mini", systemPrompt: "test" },
+      }),
+      [SEARCH_TOOL],
+    );
+    await client.dispatch({ messages: twoTurnTranscript() }, () => undefined);
+    expect(stripCreatedAt(bodies[0]!.messages)).toEqual(EXPECTED_TURN_2);
+  });
+});
+
+describe("tool-pair replay: bubbles that must not replay", () => {
+  it("a tool bubble with no accepted answer emits nothing", async () => {
+    const pending: AgentWidgetMessage = {
+      ...answeredTool("toolu_02", 2_000),
+      toolCall: { id: "toolu_02", name: "webmcp:search_catalog", status: "running", args: {} },
+      agentMetadata: { executionId: "exec-1", awaitingLocalTool: true, webMcpToolCallId: "toolu_02" },
+    };
+    const client = withTools(new AgentWidgetClient({ apiUrl: "http://proxy.test/chat" }), [SEARCH_TOOL]);
+    await client.dispatch(
+      { messages: [user("u1", "hi", 1_000), pending, user("u2", "again", 3_000)] },
+      () => undefined,
+    );
+    const messages = bodies[0]!.messages as Array<Record<string, unknown>>;
+    expect(messages.map((m) => m.role)).toEqual(["user", "user"]);
+    expect(messages.some((m) => "toolCalls" in m || "toolResults" in m)).toBe(false);
+  });
+
+  it("a server-side tool's result stays out (only browser-answered calls replay)", async () => {
+    const serverTool: AgentWidgetMessage = {
+      ...answeredTool("toolu_03", 2_000),
+      agentMetadata: { executionId: "exec-1" },
+    };
+    const client = withTools(new AgentWidgetClient({ apiUrl: "http://proxy.test/chat" }), [SEARCH_TOOL]);
+    await client.dispatch(
+      { messages: [user("u1", "hi", 1_000), serverTool, user("u2", "again", 3_000)] },
+      () => undefined,
+    );
+    expect((bodies[0]!.messages as unknown[]).length).toBe(2);
+  });
+});
+
+describe("tool-pair replay: parallel and chained calls", () => {
+  type Sent = Array<{
+    role: string;
+    toolCalls?: Array<{ toolCallId: string }>;
+    toolResults?: Array<{ toolCallId: string }>;
+  }>;
+  const inBatch = (toolCallId: string, at: number, batch: string) => {
+    const message = answeredTool(toolCallId, at);
+    message.agentMetadata!.clientToolAnswer!.batch = batch;
+    return message;
+  };
+
+  it("groups answers from one /resume batch into one call message and one result message", async () => {
+    const client = withTools(new AgentWidgetClient({ apiUrl: "http://proxy.test/chat" }), [SEARCH_TOOL]);
+    await client.dispatch(
+      {
+        messages: [
+          user("u1", "compare", 1_000),
+          inBatch("toolu_a", 2_000, "b1"),
+          inBatch("toolu_b", 2_001, "b1"),
+          assistant("a1", "done", 3_000),
+        ],
+      },
+      () => undefined,
+    );
+    const messages = bodies[0]!.messages as Sent;
+    expect(messages.map((m) => m.role)).toEqual(["user", "assistant", "tool", "assistant"]);
+    expect(messages[1]!.toolCalls!.map((c) => c.toolCallId)).toEqual(["toolu_a", "toolu_b"]);
+    expect(messages[2]!.toolResults!.map((r) => r.toolCallId)).toEqual(["toolu_a", "toolu_b"]);
+  });
+
+  it("keeps a chained call (a later /resume batch, no text between) as its own pair", async () => {
+    const client = withTools(new AgentWidgetClient({ apiUrl: "http://proxy.test/chat" }), [SEARCH_TOOL]);
+    await client.dispatch(
+      {
+        messages: [
+          user("u1", "look it up, then look up the related item", 1_000),
+          inBatch("toolu_a", 2_000, "b1"),
+          inBatch("toolu_b", 2_500, "b2"),
+          assistant("a1", "done", 3_000),
+        ],
+      },
+      () => undefined,
+    );
+    const messages = bodies[0]!.messages as Sent;
+    expect(messages.map((m) => m.role)).toEqual(["user", "assistant", "tool", "assistant", "tool", "assistant"]);
+    expect(messages[1]!.toolCalls!.map((c) => c.toolCallId)).toEqual(["toolu_a"]);
+    expect(messages[3]!.toolCalls!.map((c) => c.toolCallId)).toEqual(["toolu_b"]);
+  });
+});
+
+describe("tool-pair replay: requestMiddleware", () => {
+  it("keeps replayed pairs when the middleware removes the tools", async () => {
+    const client = withTools(
+      new AgentWidgetClient({
+        apiUrl: "http://proxy.test/chat",
+        requestMiddleware: ({ payload }) => ({ ...payload, clientTools: undefined }),
+      }),
+      [SEARCH_TOOL],
+    );
+    await client.dispatch({ messages: twoTurnTranscript() }, () => undefined);
+    expect(stripCreatedAt(bodies[0]!.messages)).toEqual(EXPECTED_TURN_2);
+  });
+});
+
+describe("tool-pair replay: client-token mode is server-owned", () => {
+  it("sends no toolCalls, toolResults or tool role on /client/chat", async () => {
+    const client = withTools(
+      new AgentWidgetClient({ clientToken: "ct_live_demo", apiUrl: "https://api.runtype.com" }),
+      [SEARCH_TOOL],
+    );
+    (client as unknown as { clientSession: { sessionId: string; expiresAt: Date } }).clientSession = {
+      sessionId: "cs_1",
+      expiresAt: new Date(Date.now() + 600_000),
+    };
+    await client.dispatch({ messages: twoTurnTranscript(), assistantMessageId: "a2" }, () => undefined);
+    const messages = bodies[0]!.messages as Array<Record<string, unknown>>;
+    expect(messages.map((m) => m.role)).toEqual(["user", "assistant", "user"]);
+    expect(messages.some((m) => "toolCalls" in m || "toolResults" in m)).toBe(false);
+  });
+});
+
+describe("modelFacingToolName", () => {
+  it("matches core's AI-SDK sanitizer", () => {
+    expect(modelFacingToolName("webmcp:get_schema")).toBe("webmcp_get_schema");
+    expect(modelFacingToolName("webmcp:Get-Slide")).toBe("webmcp_get_slide");
+    expect(modelFacingToolName("suggest_replies")).toBe("suggest_replies");
+  });
+});
+
+describe("session records the accepted client-tool answer", () => {
+  const makeSession = (resumeStatus = 200) => {
+    const session = new AgentWidgetSession(
+      { apiUrl: "http://test", webmcp: { enabled: true } },
+      {
+        onMessagesChanged: () => undefined,
+        onStatusChanged: () => undefined,
+        onStreamingChanged: () => undefined,
+      },
+    );
+    const client = (session as unknown as { client: Record<string, unknown> }).client;
+    client.executeWebMcpToolCall = vi.fn(async () => RESULT);
+    client.isWebMcpOperational = vi.fn(() => true);
+    client.resumeFlow = vi.fn(async () => new Response(new Blob([""]), { status: resumeStatus }));
+    (session as unknown as { connectStream: () => Promise<void> }).connectStream = vi.fn(async () => undefined);
+    return session;
+  };
+
+  const awaiting = (): AgentWidgetMessage => ({
+    id: "tool-toolu_01",
+    role: "assistant",
+    content: "",
+    createdAt: new Date().toISOString(),
+    variant: "tool",
+    agentMetadata: { executionId: "exec-1", awaitingLocalTool: true, webMcpToolCallId: "toolu_01" },
+    toolCall: { id: "toolu_01", name: "webmcp:search_catalog", status: "running", args: { q: "sku 42" } },
+  });
+
+  const stored = (session: AgentWidgetSession) =>
+    (session as unknown as { messages: AgentWidgetMessage[] }).messages.find((m) => m.id === "tool-toolu_01");
+
+  it("stores the answer after /resume succeeds and keeps it across a tool_complete re-emit", async () => {
+    const session = makeSession();
+    await session.resolveWebMcpToolCall(awaiting());
+    expect(stored(session)?.agentMetadata?.clientToolAnswer).toEqual({
+      toolCallId: "toolu_01",
+      toolName: "webmcp:search_catalog",
+      args: { q: "sku 42" },
+      result: RESULT,
+      batch: expect.any(String),
+    });
+
+    (session as unknown as { upsertMessage: (m: AgentWidgetMessage) => void }).upsertMessage({
+      id: "tool-toolu_01",
+      role: "assistant",
+      content: "",
+      createdAt: new Date().toISOString(),
+      variant: "tool",
+      agentMetadata: { executionId: "exec-1" },
+      toolCall: { id: "toolu_01", name: "webmcp:search_catalog", status: "complete", result: "server copy" },
+    });
+    expect(stored(session)?.agentMetadata?.clientToolAnswer?.result).toEqual(RESULT);
+  });
+
+  it("stores nothing when /resume fails", async () => {
+    const session = makeSession(500);
+    await session.resolveWebMcpToolCall(awaiting());
+    expect(stored(session)?.agentMetadata?.clientToolAnswer).toBeUndefined();
+  });
+});

package/src/client.ts

@@ -49,6 +49,7 @@ import {
 import { resolveTarget } from "./utils/target";
 import { generateTurnId } from "./utils/message-id";
 import { builtInClientToolsForDispatch } from "./ask-user-question-tool";
+import { serializeWithToolPairs } from "./utils/tool-pair-replay";
 import {
   extractTextFromJson,
   createPlainTextParser,
@@ -221,6 +222,18 @@ const hasValidContent = (message: AgentWidgetMessage): boolean => {
   return false;
 };
 
+const sortByCreatedAt = (messages: AgentWidgetMessage[]): AgentWidgetMessage[] =>
+  messages
+    .slice()
+    .sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+
+// Priority: contentParts (multi-modal) > llmContent (explicit LLM content) > rawContent (structured parsers) > content (display)
+const toPayloadMessage = (message: AgentWidgetMessage) => ({
+  role: message.role,
+  content: message.contentParts ?? message.llmContent ?? message.rawContent ?? message.content,
+  createdAt: message.createdAt
+});
+
 /**
  * Maps parserType string to the corresponding parser factory function
  */
@@ -755,6 +768,7 @@ export class AgentWidgetClient {
     identityProof?: string | null;
     storedSessionId?: string | null;
     omitVisitorFields?: boolean;
+    signal?: AbortSignal;
   }): Promise<ClientSession> {
     const historyCapable = this.isHistoryCapable() && !opts.omitVisitorFields;
     // Recovery is negotiated independently from the history UI. New servers
@@ -792,6 +806,7 @@ export class AgentWidgetClient {
           : {}),
     };
 
+    opts.signal?.throwIfAborted();
     const response = await fetch(this.getClientApiUrl('init'), {
       method: 'POST',
       headers: {
@@ -799,6 +814,7 @@ export class AgentWidgetClient {
         'X-Persona-Version': VERSION,
       },
       body: JSON.stringify(requestBody),
+      signal: opts.signal,
     });
 
     if (!response.ok) {
@@ -1805,25 +1821,44 @@ export class AgentWidgetClient {
     onEvent({ type: "status", status: "connecting" });
 
     try {
-      // Ensure session is initialized
-      const session = await this.initSession();
-
-      // Check if session is about to expire (within 1 minute)
-      if (new Date() >= new Date(session.expiresAt.getTime() - 60000)) {
-        // Session expired or expiring soon
-        this.clearClientSession();
-        this.config.onSessionExpired?.();
-        const error = new Error('Session expired. Please refresh to continue.');
-        forward({ type: "error", error });
-        throw error;
+      const assertCurrentTurn = () => {
+        options.signal?.throwIfAborted();
+        if (!isCurrentTurn()) throw new DOMException('Turn superseded', 'AbortError');
+      };
+      let session = this.clientSession ?? (await this.initSession());
+      assertCurrentTurn();
+      const renewSession = async () => {
+        assertCurrentTurn();
+        const previous = session;
+        const durable = previous.durableRecovery?.enabled === true;
+        if (durable && (!previous.conversationId || !(await this.readVisitorToken()))) {
+          throw new Error('Renewing this conversation requires its visitor credential.');
+        }
+        assertCurrentTurn();
+        const renewed = await this.createClientSession({
+          ...(durable || this.isHistoryCapable()
+            ? { conversationId: previous.conversationId, durableResume: durable }
+            : { storedSessionId: previous.sessionId }),
+          signal: options.signal,
+        });
+        assertCurrentTurn();
+        if (
+          (previous.conversationId && renewed.conversationId !== previous.conversationId) ||
+          (durable && renewed.durableRecovery?.enabled !== true)
+        ) {
+          throw new Error('Session renewal did not preserve this conversation.');
+        }
+        session = this.finishInit(renewed, previous.conversationId ?? null, false);
+        this.clientSession = session;
+        this.resetClientToolsFingerprint();
+        this.config.onSessionInit?.(session);
+      };
+      if (Date.now() >= session.expiresAt.getTime() - 60000) {
+        await renewSession();
       }
 
       // Build the standard payload to get context/metadata from middleware
       const basePayload = await this.buildPayload(options.messages);
-      const recoveryVisitorToken =
-        session.durableRecovery?.enabled === true
-          ? await this.readVisitorToken()
-          : null;
 
       // Build the chat request payload with message IDs for feedback tracking
       // Filter out sessionId from metadata if present (it's only for local storage)
@@ -1869,9 +1904,17 @@ export class AgentWidgetClient {
       // ship it again or just its fingerprint (retrying once on a 409 registry
       // miss). The cache is committed only after a successful stream start
       // (below), so a 409/failure leaves it untouched.
-      const { response, commit: commitClientToolsFingerprint } =
-        await this.sendWithClientToolsDiff(session.sessionId, basePayload.clientTools, (toolFields) => {
-          const chatRequest: ClientChatRequest = { ...baseChatRequest, ...toolFields };
+      const send = async () => {
+        assertCurrentTurn();
+        const recoveryVisitorToken =
+          session.durableRecovery?.enabled === true ? await this.readVisitorToken() : null;
+        assertCurrentTurn();
+        return this.sendWithClientToolsDiff(session.sessionId, basePayload.clientTools, (toolFields) => {
+          const chatRequest: ClientChatRequest = {
+            ...baseChatRequest,
+            sessionId: session.sessionId,
+            ...toolFields,
+          };
 
           if (this.debug) {
             // eslint-disable-next-line no-console
@@ -1891,6 +1934,19 @@ export class AgentWidgetClient {
             signal: options.signal,
           });
         });
+      };
+      let result = await send();
+      assertCurrentTurn();
+      if (result.response.status === 401) {
+        const rejection = await result.response.clone().json().catch(() => null);
+        assertCurrentTurn();
+        if (rejection?.error === 'Session not found or expired') {
+          await renewSession();
+          result = await send();
+          assertCurrentTurn();
+        }
+      }
+      const { response, commit: commitClientToolsFingerprint } = result;
 
       if (!response.ok) {
         const data = await response.json().catch(() => ({ error: 'Chat request failed' }));
@@ -2490,22 +2546,17 @@ export class AgentWidgetClient {
       throw new Error('Agent configuration required for agent mode');
     }
 
-    // Filter out messages with empty content and normalize
-    const normalizedMessages = messages
-      .slice()
-      .filter(hasValidContent)
-      .filter(m => m.role === "user" || m.role === "assistant" || m.role === "system")
-      .filter(m => !m.variant || m.variant === "assistant")
-      .sort((a, b) => {
-        const timeA = new Date(a.createdAt).getTime();
-        const timeB = new Date(b.createdAt).getTime();
-        return timeA - timeB;
-      })
-      .map((message) => ({
-        role: message.role,
-        content: message.contentParts ?? message.llmContent ?? message.rawContent ?? message.content,
-        createdAt: message.createdAt
-      }));
+    // Filter out messages with empty content and normalize; answered
+    // client-tool calls replay as paired toolCalls/toolResults messages.
+    const normalizedMessages = serializeWithToolPairs(
+      sortByCreatedAt(messages),
+      (message) =>
+        hasValidContent(message) &&
+        (message.role === "user" || message.role === "assistant" || message.role === "system") &&
+        (!message.variant || message.variant === "assistant")
+          ? toPayloadMessage(message)
+          : null
+    );
 
     const composer = this.normalizeComposerOptions(composerOptions);
     const payload: AgentWidgetAgentRequestPayload = {
@@ -2547,21 +2598,14 @@ export class AgentWidgetClient {
     messages: AgentWidgetMessage[],
     composerOptions?: ComposerOptionsPayload
   ): Promise<AgentWidgetRequestPayload> {
-    // Filter out messages with empty content to prevent validation errors
-    const normalizedMessages = messages
-      .slice()
-      .filter(hasValidContent)
-      .sort((a, b) => {
-        const timeA = new Date(a.createdAt).getTime();
-        const timeB = new Date(b.createdAt).getTime();
-        return timeA - timeB;
-      })
-      .map((message) => ({
-        role: message.role,
-        // Priority: contentParts (multi-modal) > llmContent (explicit LLM content) > rawContent (structured parsers) > content (display)
-        content: message.contentParts ?? message.llmContent ?? message.rawContent ?? message.content,
-        createdAt: message.createdAt
-      }));
+    // Filter out messages with empty content to prevent validation errors;
+    // answered client-tool calls replay as paired toolCalls/toolResults
+    // messages. Client-token mode maps `options.messages` itself and never
+    // reads these, so the server stays the replay owner there.
+    const normalizedMessages = serializeWithToolPairs(
+      sortByCreatedAt(messages),
+      (message) => (hasValidContent(message) ? toPayloadMessage(message) : null)
+    );
 
     const routed = this.routing();
     const payload: AgentWidgetRequestPayload = {

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

@@ -78,6 +78,7 @@ export type RuntypeExecutionStreamEvent = ({
   turnIndex?: number;
   type: "turn_start";
 }) | ({
+  attributes?: Record<string, string | number | boolean>;
   completedAt?: string;
   content?: string;
   cost?: number;
@@ -136,7 +137,8 @@ export type RuntypeExecutionStreamEvent = ({
 };
   turnId?: string;
   type: "model_call_start";
-} | {
+} | ({
+  attributes?: Record<string, string | number | boolean>;
   completedAt?: string;
   cost?: number;
   durationMs?: number;
@@ -160,10 +162,11 @@ export type RuntypeExecutionStreamEvent = ({
   cacheWrite?: number;
   input: number;
   output: number;
+  reasoning?: number;
 };
   turnId?: string;
   type: "model_call_complete";
-} | {
+}) | {
   executionId: string;
   id: string;
   index?: number;
@@ -558,38 +561,50 @@ export type RuntypeStopReasonKind = NonNullable<
   RuntypeTurnCompleteEvent["stopReason"] | RuntypeStepCompleteEvent["stopReason"]
 >;
 
-export type RuntypeClientInitRequest = {
+export type RuntypeClientInitRequest = ({
   durableRecovery?: boolean;
   flowId?: string;
-  identityProof?: string;
+  identityProof?: string | {
+  provider: string;
+  token: string;
+};
   token: string;
   visitorHistory?: boolean;
   visitorToken?: string;
-} | {
+}) | ({
   durableRecovery?: boolean;
   flowId?: string;
-  identityProof?: string;
+  identityProof?: string | {
+  provider: string;
+  token: string;
+};
   sessionId: string;
   token: string;
   visitorHistory?: boolean;
   visitorToken?: string;
-} | {
+}) | ({
   conversationId: string;
   durableRecovery?: boolean;
   flowId?: string;
-  identityProof?: string;
+  identityProof?: string | {
+  provider: string;
+  token: string;
+};
   token: string;
   visitorHistory?: boolean;
   visitorToken: string;
-} | {
+}) | ({
   conversationId: string;
   durableRecovery?: boolean;
   flowId?: string;
-  identityProof: string;
+  identityProof: string | {
+  provider: string;
+  token: string;
+};
   token: string;
   visitorHistory?: boolean;
   visitorToken?: string;
-};
+});
 
 export type RuntypeClientInitResponse = {
   app?: {

package/src/session.ts

@@ -3816,16 +3816,34 @@ export class AgentWidgetSession {
       // re-emits don't re-execute the page tool, then complete each bubble.
       // Do this only after /resume HTTP success; if /resume fails, the server
       // may still be paused and the retry path must not show a final result.
+      const batch = ready[0]!.dedupeKey;
       for (const r of ready) {
         this.webMcpResolvedKeys.add(r.dedupeKey);
+        const toolName = r.toolMessage.toolCall?.name;
+        const toolCallId = r.toolMessage.agentMetadata?.webMcpToolCallId;
         this.markWebMcpToolComplete(
           r.toolMessage,
           r.output,
           r.startedAt,
           r.completedAt,
-          r.toolMessage.toolCall?.name === SUGGEST_REPLIES_TOOL_NAME
-            ? { suggestRepliesResolved: true }
-            : undefined,
+          {
+            ...(toolName === SUGGEST_REPLIES_TOOL_NAME
+              ? { suggestRepliesResolved: true }
+              : {}),
+            // Only a provider call id can be replayed: a legacy name-keyed
+            // resume has nothing the model's transcript can reference.
+            ...(toolName && toolCallId
+              ? {
+                  clientToolAnswer: {
+                    toolCallId,
+                    toolName,
+                    args: r.toolMessage.toolCall?.args,
+                    result: r.output,
+                    batch,
+                  },
+                }
+              : {}),
+          },
         );
       }
       if (response.body) {
@@ -4928,6 +4946,17 @@ export class AgentWidgetSession {
           awaitingLocalTool: false,
         };
       }
+      // The accepted client-tool answer is what later proxy/agent turns
+      // replay; a post-resume `tool_complete` re-emit carries a fresh
+      // metadata skeleton and must not drop it.
+      const clientToolAnswer = existing.agentMetadata?.clientToolAnswer;
+      if (
+        clientToolAnswer &&
+        merged.agentMetadata &&
+        !merged.agentMetadata.clientToolAnswer
+      ) {
+        merged.agentMetadata = { ...merged.agentMetadata, clientToolAnswer };
+      }
       // Approval equivalent: `approval_complete` carries only the
       // resolution (approvalId, decision, resolvedBy): the runtime does not
       // re-send toolName/description/toolType/reason/parameters, so client.ts