@runtypelabs/persona 4.28.2 → 4.29.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtypelabs/persona",
-  "version": "4.28.2",
+  "version": "4.29.1",
   "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",
@@ -117,6 +117,11 @@
       "import": "./dist/voice-runtime.js",
       "require": "./dist/voice-runtime.cjs"
     },
+    "./voice-client-tools": {
+      "types": "./dist/voice-client-tools.d.ts",
+      "import": "./dist/voice-client-tools.js",
+      "require": "./dist/voice-client-tools.cjs"
+    },
     "./forms-ui": {
       "types": "./dist/forms-ui.d.ts",
       "import": "./dist/forms-ui.js",

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,
@@ -34,6 +35,7 @@ import {
   recordWebMcpToolDisplayTitles,
 } from "./webmcp-bridge";
 import { loadWebMcpRuntime } from "./webmcp-runtime-loader";
+import { loadVoiceClientTools } from "./voice-client-tools-loader";
 import type { WebMcpBridge } from "./webmcp-runtime-entry";
 import { resolveTarget } from "./utils/target";
 import { generateTurnId } from "./utils/message-id";
@@ -54,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.
 
@@ -80,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;
@@ -152,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;
@@ -406,6 +416,42 @@ export class AgentWidgetClient {
    * session that it should fall back to the legacy local-tool resume path,
    * if any).
    */
+  /**
+   * WebMCP access for a Runtype voice call's fast tier: the same per-turn
+   * snapshot `clientTools[]` carries, registry change notifications, and the
+   * voice execute path. `null` when WebMCP is not enabled.
+   */
+  public getVoiceClientTools():import("./types").VoiceClientTools | null {
+    if (this.config.webmcp?.enabled !== true) return null;
+    const bridge = () => this.#getWebMcpBridge();
+    const surface: import("./types").VoiceClientTools = {
+      open: async (channel) => (await loadVoiceClientTools()).createVoiceClientToolsSession(surface, channel),
+      snapshot: async () => {
+        const tools = (await (await bridge())?.snapshotForDispatch()) ?? [];
+        return { tools, fingerprint: computeClientToolsFingerprint(tools) };
+      },
+      onChange: (listener) => {
+        let stop: (() => void) | null = null;
+        let stopped = false;
+        void bridge().then((b) => {
+          if (b && !stopped) stop = b.watchToolChanges(listener);
+        });
+        return () => {
+          stopped = true;
+          stop?.();
+        };
+      },
+      execute: async (name, args, options) => {
+        const b = await bridge();
+        if (!b) {
+          return { status: "failed", error: { message: "WebMCP runtime failed to load." } };
+        }
+        return b.executeVoiceToolCall(name, args, options);
+      },
+    };
+    return surface;
+  }
+
   public executeWebMcpToolCall(
     wireToolName: string,
     args: unknown,
@@ -1516,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
@@ -1830,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);
   }
 
   /**
@@ -1972,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/client.voice-tools.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { AgentWidgetClient } from "./client";
+import type { ClientToolDefinition } from "./types";
+import { computeClientToolsFingerprint } from "./webmcp-bridge";
+
+const tool: ClientToolDefinition = {
+  name: "next_slide",
+  description: "Advance the presentation to the next slide.",
+  parametersSchema: { type: "object", properties: {} },
+  origin: "webmcp",
+  annotations: { readOnlyHint: true },
+};
+
+const withBridge = (bridge: Record<string, unknown>) => {
+  const client = new AgentWidgetClient({ apiUrl: "http://test", webmcp: { enabled: true } });
+  (client as unknown as { webMcpBridge: unknown }).webMcpBridge = bridge;
+  return client;
+};
+
+describe("AgentWidgetClient.getVoiceClientTools", () => {
+  it("is null when WebMCP is off", () => {
+    expect(new AgentWidgetClient({ apiUrl: "http://test" }).getVoiceClientTools()).toBeNull();
+  });
+
+  it("snapshots exactly the dispatch clientTools[] entries, with their fingerprint", async () => {
+    const client = withBridge({ snapshotForDispatch: async () => [tool] });
+    const snapshot = await client.getVoiceClientTools()!.snapshot();
+    expect(snapshot).toEqual({ tools: [tool], fingerprint: computeClientToolsFingerprint([tool]) });
+  });
+
+  it("routes execute and change subscriptions to the bridge's voice methods", async () => {
+    const stop = vi.fn();
+    const watchToolChanges = vi.fn(() => stop);
+    const executeVoiceToolCall = vi.fn(async () => ({ status: "completed", result: { slidePosition: 2 } }));
+    const surface = withBridge({ watchToolChanges, executeVoiceToolCall }).getVoiceClientTools()!;
+
+    const signal = new AbortController().signal;
+    const outcome = await surface.execute("webmcp:next_slide", {}, { signal, autoConfirmReadOnly: true });
+    expect(executeVoiceToolCall).toHaveBeenCalledWith("webmcp:next_slide", {}, { signal, autoConfirmReadOnly: true });
+    expect(outcome).toEqual({ status: "completed", result: { slidePosition: 2 } });
+
+    const listener = vi.fn();
+    const unsubscribe = surface.onChange(listener);
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(watchToolChanges).toHaveBeenCalledWith(listener);
+    unsubscribe();
+    expect(stop).toHaveBeenCalledTimes(1);
+  });
+
+  it("opens a fast-tier session from the lazy chunk that sends the snapshot through the channel", async () => {
+    const client = new AgentWidgetClient({ apiUrl: "http://test", webmcp: { enabled: true } });
+    const slot = client as unknown as { webMcpBridge: unknown };
+    // Let the real lazy bridge adopt first, so it cannot replace the fake mid-test.
+    await vi.waitFor(() => expect(slot.webMcpBridge).not.toBeNull());
+    slot.webMcpBridge = { snapshotForDispatch: async () => [tool], watchToolChanges: () => () => undefined };
+    const surface = client.getVoiceClientTools()!;
+    const sent: Array<Record<string, unknown>> = [];
+    const session = await surface.open({ send: (frame) => (sent.push(frame), true), cancelled: () => false });
+    await vi.waitFor(() => expect(sent).toHaveLength(1));
+    expect(sent[0]).toMatchObject({ type: "client_tools", tools: [{ ...tool, name: "webmcp:next_slide" }] });
+    session.close();
+  });
+});

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

@@ -35,6 +35,7 @@ export type RuntypeExecutionStreamEvent = ({
   finalOutput?: string;
   iterations?: number;
   kind: "agent" | "flow";
+  outcome?: "completed" | "error" | "aborted";
   seq: number;
   stepErrorCount?: number;
   stopReason?: string;
@@ -60,6 +61,7 @@ export type RuntypeExecutionStreamEvent = ({
   executionId: string;
   finalOutput?: string;
   kind: "agent" | "flow";
+  outcome?: "completed" | "error" | "aborted";
   seq: number;
   stopReason?: string;
   type: "execution_error";
@@ -379,6 +381,15 @@ export type RuntypeExecutionStreamEvent = ({
   seq: number;
   type: "state_delta";
 }) | ({
+  annotations?: {
+  consequentialHint?: boolean;
+  debugging?: boolean;
+  destructiveHint?: boolean;
+  idempotentHint?: boolean;
+  openWorldHint?: boolean;
+  readOnlyHint?: boolean;
+  untrustedContentHint?: boolean;
+};
   executionId: string;
   hiddenParameterNames?: Array<string>;
   iteration?: number;
@@ -477,6 +488,15 @@ export type RuntypeExecutionStreamEvent = ({
   seq: number;
   type: "approval_complete";
 }) | ({
+  annotations?: {
+  consequentialHint?: boolean;
+  debugging?: boolean;
+  destructiveHint?: boolean;
+  idempotentHint?: boolean;
+  openWorldHint?: boolean;
+  readOnlyHint?: boolean;
+  untrustedContentHint?: boolean;
+};
   awaitReason?: string;
   awaitedAt?: string;
   crawlId?: string;
@@ -641,6 +661,15 @@ export type RuntypeClientInitResponse = {
 export type RuntypeClientChatRequest = {
   assistantMessageId?: string;
   clientTools?: Array<{
+  annotations?: {
+  consequentialHint?: boolean;
+  debugging?: boolean;
+  destructiveHint?: boolean;
+  idempotentHint?: boolean;
+  openWorldHint?: boolean;
+  readOnlyHint?: boolean;
+  untrustedContentHint?: boolean;
+};
   description: string;
   name: string;
   origin?: "webmcp" | "sdk";
@@ -681,7 +710,7 @@ export type RuntypeClientChatRequest = {
 }>;
   metadata?: Record<string, unknown>;
   sessionId: string;
-  submitMode?: "normal" | "interrupt" | "steer";
+  submitMode?: "normal" | "interrupt" | "steer" | "auto";
   turnId?: string;
   voice?: {
   spoken?: boolean;
@@ -694,6 +723,15 @@ export type RuntypeClientResumeRequest = {
   after?: string;
   assistantMessageId?: string;
   clientTools?: Array<{
+  annotations?: {
+  consequentialHint?: boolean;
+  debugging?: boolean;
+  destructiveHint?: boolean;
+  idempotentHint?: boolean;
+  openWorldHint?: boolean;
+  readOnlyHint?: boolean;
+  untrustedContentHint?: boolean;
+};
   description: string;
   name: string;
   origin?: "webmcp" | "sdk";

package/src/index-core.ts

@@ -174,6 +174,7 @@ export type {
   // WebMCP: page-discovered tool consumption
   AgentWidgetWebMcpConfig,
   ClientToolDefinition,
+  ToolAnnotations,
   WebMcpConfirmHandler,
   WebMcpConfirmInfo,
   WebMcpToolResult,
@@ -659,6 +660,16 @@ export type {
   VoiceDelegationStatus,
   VoiceDelegationFollowUp,
   VoiceSessionBridge,
+  VoiceClientTools,
+  VoiceClientToolsSnapshot,
+  VoiceClientToolsChannel,
+  VoiceClientToolsSession,
+  VoiceClientToolOutcome,
+  VoiceClientToolStatus,
+  VoiceDirectTurn,
+  ClientToolsFrame,
+  ClientToolCallFrame,
+  ClientToolResultFrame,
   PcmStreamPlayer,
   AgentWidgetVoiceStatusEvent,
   ReadAloudState,

package/src/index-global.ts

@@ -221,6 +221,12 @@ import { setVoiceRuntimeLoader } from "./voice-runtime-loader";
 
 setVoiceRuntimeLoader(siblingChunk("voice-runtime.js"));
 
+// The voice fast tier (`client_tools`), fetched by client.ts only when a voice
+// call negotiates it. Same sibling-URL scheme.
+import { setVoiceClientToolsLoader } from "./voice-client-tools-loader";
+
+setVoiceClientToolsLoader(siblingChunk("voice-client-tools.js"));
+
 // ---------------------------------------------------------------------------
 // Deferred artifacts-ui loading.
 //