agents 0.17.4 → 0.19.0

package/dist/{agent-tool-types-OhWqAbCp.d.ts → agent-tool-types-BNUGGBzQ.d.ts}

@@ -1,5 +1,5 @@
 import { n as AgentEmail } from "./internal_context-Dg4Cgjcu.js";
-import { t as RetryOptions } from "./retries-CvHJwSuh.js";
+import { t as RetryOptions } from "./retries-CAvxtG9d.js";
 import {
   n as Observability,
   r as ObservabilityEvent,
@@ -800,15 +800,16 @@ type MCPTransportOptions = (
   authProvider?: AgentMcpOAuthProvider;
   type?: TransportType;
 };
-/**
- * Result of a discovery operation.
- * success indicates whether discovery completed successfully.
- * error is present when success is false.
- */
-type MCPDiscoveryResult = {
-  success: boolean;
-  error?: string;
-};
+/** Result of discovering server capabilities. */
+type MCPDiscoveryResult =
+  | {
+      success: true;
+    }
+  | {
+      success: false;
+      reason: "error" | "stale-session";
+      error: string;
+    };
 /**
  * Handler for server-initiated `elicitation/create` requests.
  * Held in memory only — never persisted — so it must be re-supplied when a
@@ -1104,6 +1105,8 @@ declare class MCPClientConnection {
   handleElicitationRequest(request: ElicitRequest): Promise<ElicitResult>;
   private isResumedStreamableHttpSession;
   get sessionId(): string | undefined;
+  /** @internal Clear a restored session before reconnecting. */
+  clearResumedSession(): void;
   private getTransportName;
   close(): Promise<void>;
   /**
@@ -1296,6 +1299,8 @@ declare class MCPClientManager {
   private _name;
   private _version;
   mcpConnections: Record<string, MCPClientConnection>;
+  /** Cache only the current catalog so old schema graphs are not retained. */
+  private readonly _aiToolSchemas;
   private _didWarnAboutUnstableGetAITools;
   private _oauthCallbackConfig?;
   private _connectionDisposables;
@@ -1382,6 +1387,8 @@ declare class MCPClientManager {
   private isAuthAcceptedConnection;
   private oauthCallbackSuccess;
   private runWithCodeVerifierState;
+  private hasRedeemableOAuthState;
+  private ignoreUnverifiedCallback;
   private consumeStaleOAuthState;
   private completeAuthorizationAndCleanupVerifier;
   /**
@@ -1433,6 +1440,7 @@ declare class MCPClientManager {
    *   `undefined` (default) waits indefinitely.
    */
   waitForConnections(options?: { timeout?: number }): Promise<void>;
+  private _connectWithRetry;
   /**
    * Internal method to restore a single server connection and discovery
    */
@@ -1516,6 +1524,8 @@ declare class MCPClientManager {
       timeoutMs?: number;
     }
   ): Promise<MCPDiscoverResult | undefined>;
+  private _toDiscoverResult;
+  private _recoverStaleSession;
   /**
    * Establish connection in the background after OAuth completion.
    * This method connects to the server and discovers its capabilities.
@@ -1568,6 +1578,10 @@ declare class MCPClientManager {
    */
   listTools(filter?: MCPServerFilter): NamespacedData["tools"];
   /**
+   * Convert connected MCP tools for the AI SDK. Converted schemas are reused
+   * while a live connection retains the same catalog array and schema-source
+   * identities; tool records and execute closures are rebuilt on every call.
+   *
    * @param filter - Optional filter to scope results to specific servers
    * @returns a set of tools that you can use with the AI SDK
    */
@@ -2733,6 +2747,8 @@ declare class Agent<
     type: ObservabilityEvent["type"],
     payload?: Record<string, unknown>
   ): void;
+  /** Run SDK work under a stable parent for platform child spans. */
+  private _withAgentSpan;
   /**
    * Execute SQL queries against the Agent's database
    * @template T Type of the returned rows
@@ -2744,6 +2760,7 @@ declare class Agent<
     strings: TemplateStringsArray,
     ...values: (string | number | boolean | null)[]
   ): T[];
+  private _schemaInitialization;
   /**
    * Create all internal tables and run migrations if needed.
    * Called by the constructor on every wake. Idempotent — skips DDL when
@@ -3527,6 +3544,7 @@ declare class Agent<
    */
   private _hasPendingFiberRecovery;
   private _scheduleNextAlarm;
+  private _scheduleNextAlarmBody;
   /**
    * Override PartyServer's onAlarm hook as a no-op.
    * Agent handles alarm logic directly in the alarm() method override,
@@ -4769,6 +4787,7 @@ declare class Agent<
         state: typeof MCPConnectionState.READY;
       }
   >;
+  private _redeemableAuthUrl;
   private _isAbsoluteHttpUrl;
   removeMcpServer(id: string): Promise<void>;
   getMcpServers(): MCPServersState;
@@ -5499,4 +5518,4 @@ export {
   EmailRoutingOptions as z,
   RPCServerTransportOptions as zt
 };
-//# sourceMappingURL=agent-tool-types-OhWqAbCp.d.ts.map
+//# sourceMappingURL=agent-tool-types-BNUGGBzQ.d.ts.map

package/dist/agent-tool-types.d.ts

@@ -24,7 +24,7 @@ import {
   w as RunAgentToolOptions,
   x as ChatCapableAgentClass,
   y as AgentToolStoredChunk
-} from "./agent-tool-types-OhWqAbCp.js";
+} from "./agent-tool-types-BNUGGBzQ.js";
 export {
   AGENT_TOOL_MILESTONE_PART,
   AGENT_TOOL_PROGRESS_PART,

package/dist/{agent-tools-LdNKGZT9.d.ts → agent-tools-BFbzVLFc.d.ts}

@@ -4,7 +4,7 @@ import {
   o as AgentToolEventMessage,
   s as AgentToolEventState,
   y as AgentToolStoredChunk
-} from "./agent-tool-types-OhWqAbCp.js";
+} from "./agent-tool-types-BNUGGBzQ.js";
 
 //#region src/chat/agent-tools.d.ts
 type AgentToolProgressEmitResult = "emitted" | "coalesced" | "inactive";
@@ -130,4 +130,4 @@ export {
   interceptAgentToolBroadcast as s,
   AgentToolBroadcastHooks as t
 };
-//# sourceMappingURL=agent-tools-LdNKGZT9.d.ts.map
+//# sourceMappingURL=agent-tools-BFbzVLFc.d.ts.map

package/dist/agent-tools.d.ts

@@ -19,7 +19,7 @@ import {
   w as RunAgentToolOptions,
   x as ChatCapableAgentClass,
   y as AgentToolStoredChunk
-} from "./agent-tool-types-OhWqAbCp.js";
+} from "./agent-tool-types-BNUGGBzQ.js";
 import { Tool } from "ai";
 
 //#region src/agent-tools.d.ts

package/dist/browser/tanstack-ai.js

@@ -41,13 +41,14 @@ function createBrowserTools(options) {
 	const executeTool = tools.browser_execute;
 	return [toolDefinition({
 		name: "browser_execute",
-		description: executeTool.description ?? "",
+		description: typeof executeTool.description === "function" ? "" : executeTool.description ?? "",
 		inputSchema: z.object({ code: z.string().meta({ description: "TypeScript async arrow function that uses the cdp connector" }) })
 	}).server(async ({ code }) => {
 		if (!executeTool.execute) throw new Error("browser_execute tool is not executable");
 		return await executeTool.execute({ code }, {
 			toolCallId: crypto.randomUUID(),
-			messages: []
+			messages: [],
+			context: {}
 		});
 	})];
 }

package/dist/browser/tanstack-ai.js.map

@@ -1 +1 @@
-{"version":3,"file":"tanstack-ai.js","names":[],"sources":["../../src/browser/tanstack-ai.ts"],"sourcesContent":["import { toolDefinition } from \"@tanstack/ai\";\nimport type { ServerTool } from \"@tanstack/ai\";\nimport type { ProxyToolOutput } from \"@cloudflare/codemode\";\nimport { z } from \"zod\";\nimport { createBrowserRuntime, type CreateBrowserToolsOptions } from \"./ai\";\n\nexport type { CreateBrowserToolsOptions } from \"./ai\";\n\n/**\n * Create TanStack AI tools for browser automation via CDP code mode.\n *\n * Returns an array with a single durable `browser_execute` `ServerTool`\n * backed by the same codemode runtime as `agents/browser/ai` — the model\n * writes TypeScript against the `cdp` connector and browser sessions\n * survive pauses.\n *\n * The stateless Quick Action tools are not surfaced through this TanStack\n * wrapper (it exposes only `browser_execute`); use `createQuickActionTools`\n * from `agents/browser/ai` if you want them.\n *\n * @example\n * ```ts\n * import { createBrowserTools } from \"agents/browser/tanstack-ai\";\n * import { chat } from \"@tanstack/ai\";\n *\n * // inside a Durable Object / Agent:\n * const browserTools = createBrowserTools({\n *   ctx: this.ctx,\n *   browser: this.env.BROWSER,\n *   loader: this.env.LOADER,\n * });\n *\n * const stream = chat({\n *   adapter: openaiText(\"gpt-4o\"),\n *   tools: [...browserTools, ...otherTools],\n *   messages,\n * });\n * ```\n */\nexport function createBrowserTools(\n  options: CreateBrowserToolsOptions\n): ServerTool[] {\n  // This wrapper only surfaces `browser_execute`, so don't build the default-on\n  // Quick Action tools just to discard them.\n  const { tools } = createBrowserRuntime({ ...options, quickActions: false });\n  const executeTool = tools.browser_execute;\n\n  const execute = toolDefinition({\n    name: \"browser_execute\" as const,\n    description: executeTool.description ?? \"\",\n    inputSchema: z.object({\n      code: z.string().meta({\n        description:\n          \"TypeScript async arrow function that uses the cdp connector\"\n      })\n    })\n  }).server(async ({ code }) => {\n    if (!executeTool.execute) {\n      throw new Error(\"browser_execute tool is not executable\");\n    }\n    const result = (await executeTool.execute(\n      { code },\n      { toolCallId: crypto.randomUUID(), messages: [] }\n    )) as ProxyToolOutput;\n    return result;\n  });\n\n  return [execute];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,mBACd,SACc;CAGd,MAAM,EAAE,UAAU,qBAAqB;EAAE,GAAG;EAAS,cAAc;CAAM,CAAC;CAC1E,MAAM,cAAc,MAAM;CAsB1B,OAAO,CApBS,eAAe;EAC7B,MAAM;EACN,aAAa,YAAY,eAAe;EACxC,aAAa,EAAE,OAAO,EACpB,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,EACpB,aACE,8DACJ,CAAC,EACH,CAAC;CACH,CAAC,CAAC,CAAC,OAAO,OAAO,EAAE,WAAW;EAC5B,IAAI,CAAC,YAAY,SACf,MAAM,IAAI,MAAM,wCAAwC;EAM1D,OAAO,MAJe,YAAY,QAChC,EAAE,KAAK,GACP;GAAE,YAAY,OAAO,WAAW;GAAG,UAAU,CAAC;EAAE,CAClD;CAEF,CAEc,CAAC;AACjB"}
+{"version":3,"file":"tanstack-ai.js","names":[],"sources":["../../src/browser/tanstack-ai.ts"],"sourcesContent":["import { toolDefinition } from \"@tanstack/ai\";\nimport type { ServerTool } from \"@tanstack/ai\";\nimport type { ProxyToolOutput } from \"@cloudflare/codemode\";\nimport { z } from \"zod\";\nimport { createBrowserRuntime, type CreateBrowserToolsOptions } from \"./ai\";\n\nexport type { CreateBrowserToolsOptions } from \"./ai\";\n\n/**\n * Create TanStack AI tools for browser automation via CDP code mode.\n *\n * Returns an array with a single durable `browser_execute` `ServerTool`\n * backed by the same codemode runtime as `agents/browser/ai` — the model\n * writes TypeScript against the `cdp` connector and browser sessions\n * survive pauses.\n *\n * The stateless Quick Action tools are not surfaced through this TanStack\n * wrapper (it exposes only `browser_execute`); use `createQuickActionTools`\n * from `agents/browser/ai` if you want them.\n *\n * @example\n * ```ts\n * import { createBrowserTools } from \"agents/browser/tanstack-ai\";\n * import { chat } from \"@tanstack/ai\";\n *\n * // inside a Durable Object / Agent:\n * const browserTools = createBrowserTools({\n *   ctx: this.ctx,\n *   browser: this.env.BROWSER,\n *   loader: this.env.LOADER,\n * });\n *\n * const stream = chat({\n *   adapter: openaiText(\"gpt-4o\"),\n *   tools: [...browserTools, ...otherTools],\n *   messages,\n * });\n * ```\n */\nexport function createBrowserTools(\n  options: CreateBrowserToolsOptions\n): ServerTool[] {\n  // This wrapper only surfaces `browser_execute`, so don't build the default-on\n  // Quick Action tools just to discard them.\n  const { tools } = createBrowserRuntime({ ...options, quickActions: false });\n  const executeTool = tools.browser_execute;\n\n  const execute = toolDefinition({\n    name: \"browser_execute\" as const,\n    description:\n      typeof executeTool.description === \"function\"\n        ? \"\"\n        : (executeTool.description ?? \"\"),\n    inputSchema: z.object({\n      code: z.string().meta({\n        description:\n          \"TypeScript async arrow function that uses the cdp connector\"\n      })\n    })\n  }).server(async ({ code }) => {\n    if (!executeTool.execute) {\n      throw new Error(\"browser_execute tool is not executable\");\n    }\n    const result = (await executeTool.execute({ code }, {\n      toolCallId: crypto.randomUUID(),\n      messages: [],\n      context: {}\n    } as never)) as ProxyToolOutput;\n    return result;\n  });\n\n  return [execute];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,mBACd,SACc;CAGd,MAAM,EAAE,UAAU,qBAAqB;EAAE,GAAG;EAAS,cAAc;CAAM,CAAC;CAC1E,MAAM,cAAc,MAAM;CA0B1B,OAAO,CAxBS,eAAe;EAC7B,MAAM;EACN,aACE,OAAO,YAAY,gBAAgB,aAC/B,KACC,YAAY,eAAe;EAClC,aAAa,EAAE,OAAO,EACpB,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,EACpB,aACE,8DACJ,CAAC,EACH,CAAC;CACH,CAAC,CAAC,CAAC,OAAO,OAAO,EAAE,WAAW;EAC5B,IAAI,CAAC,YAAY,SACf,MAAM,IAAI,MAAM,wCAAwC;EAO1D,OAAO,MALe,YAAY,QAAQ,EAAE,KAAK,GAAG;GAClD,YAAY,OAAO,WAAW;GAC9B,UAAU,CAAC;GACX,SAAS,CAAC;EACZ,CAAU;CAEZ,CAEc,CAAC;AACjB"}

package/dist/chat/index.d.ts

@@ -4,7 +4,7 @@ import {
   a as AgentToolEvent,
   o as AgentToolEventMessage,
   s as AgentToolEventState
-} from "../agent-tool-types-OhWqAbCp.js";
+} from "../agent-tool-types-BNUGGBzQ.js";
 import {
   n as ClientToolSchema,
   r as createToolsFromClientSchemas,
@@ -18,7 +18,7 @@ import {
   r as AgentToolProgressEmitResult,
   s as interceptAgentToolBroadcast,
   t as AgentToolBroadcastHooks
-} from "../agent-tools-LdNKGZT9.js";
+} from "../agent-tools-BFbzVLFc.js";
 import { JSONSchema7, UIMessage } from "ai";
 import { Connection } from "agents";
 
@@ -987,6 +987,12 @@ declare function buildInClauseStrings(
  * clients. Both @cloudflare/ai-chat (via its MessageType enum) and
  * @cloudflare/think use these values.
  */
+declare const STREAM_RESUME_NONE_REASONS: {
+  /** No active, pending, or terminal stream exists for this agent. */ readonly IDLE: "idle" /** An active tool continuation is owned by another live connection. */;
+  readonly CONTINUATION_OWNED: "continuation-owned";
+};
+type StreamResumeNoneReason =
+  (typeof STREAM_RESUME_NONE_REASONS)[keyof typeof STREAM_RESUME_NONE_REASONS];
 declare const CHAT_MESSAGE_TYPES: {
   readonly CHAT_MESSAGES: "cf_agent_chat_messages";
   readonly USE_CHAT_REQUEST: "cf_agent_use_chat_request";
@@ -1069,14 +1075,21 @@ type OutgoingMessage<ChatMessage extends UIMessage = UIMessage> =
     }
   | {
       /** Indicates the server is resuming an active stream */ type: MessageType.CF_AGENT_STREAM_RESUMING /** The request ID of the stream being resumed */;
-      id: string;
+      id: string /** Present when this offer directly answers a client resume probe. */;
+      probeId?: string;
     }
   | {
       /** Server notifies client that a message was updated (e.g., tool result applied) */ type: MessageType.CF_AGENT_MESSAGE_UPDATED /** The updated message */;
       message: ChatMessage;
     }
   | {
-      /** Server responds to resume request when no active stream exists */ type: MessageType.CF_AGENT_STREAM_RESUME_NONE;
+      /** Server responds to a resume request with no stream for this client. */ type: MessageType.CF_AGENT_STREAM_RESUME_NONE;
+      /**
+       * Why no stream was offered. Only `idle` proves global inactivity;
+       * omitted by older servers and by non-authoritative delayed releases.
+       */
+      reason?: StreamResumeNoneReason /** Correlates an authoritative response to its client resume probe. */;
+      probeId?: string;
     }
   | {
       /**
@@ -1085,7 +1098,8 @@ type OutgoingMessage<ChatMessage extends UIMessage = UIMessage> =
        * `STREAM_RESUME_NONE`) rather than give up. See #1784.
        */
       type: MessageType.CF_AGENT_STREAM_PENDING /** The accepted request id, when known. */;
-      id?: string;
+      id?: string /** Correlates a direct keep-waiting response to its client probe. */;
+      probeId?: string;
     }
   | {
       /**
@@ -1135,7 +1149,8 @@ type IncomingMessage<ChatMessage extends UIMessage = UIMessage> =
       id: string;
     }
   | {
-      /** Client requests stream resume check after message handler is registered */ type: MessageType.CF_AGENT_STREAM_RESUME_REQUEST;
+      /** Client requests stream resume check after message handler is registered */ type: MessageType.CF_AGENT_STREAM_RESUME_REQUEST /** Opaque correlation id echoed by direct server responses. */;
+      probeId?: string;
     }
   | {
       /** Client sends tool result to server (for client-side tools) */ type: MessageType.CF_AGENT_TOOL_RESULT /** The tool call ID this result is for */;
@@ -1299,7 +1314,7 @@ declare class PreStreamTurns<
    * `pendingResumeConnections` — they must keep receiving any live broadcast —
    * until the host flushes them through `notifyStreamResuming` on stream start.
    */
-  park(connection: TConnection): boolean;
+  park(connection: TConnection, probeId?: string): boolean;
   /** Drop a single connection (e.g. on socket close) without releasing others. */
   release(connectionId: string): void;
   /**
@@ -1774,6 +1789,7 @@ type ChatProtocolEvent =
     }
   | {
       type: "stream-resume-request";
+      probeId?: string;
     }
   | {
       type: "stream-resume-ack";
@@ -3153,14 +3169,16 @@ declare class ResumeHandshake {
    * `reconnectToStream` hangs to its timeout with no replay), and the proactive
    * notify is required for clients that never send a request. The notify is one
    * tiny frame; the client dedupes its ACK so the buffer is not replayed twice.
+   * Direct responses echo the opaque probe id; proactive notifications omit it.
    */
-  notifyStreamResuming(connection: Connection): void;
+  notifyStreamResuming(connection: Connection, probeId?: string): void;
   /**
    * Handle a client `STREAM_RESUME_REQUEST`. The client sends this after its
    * message handler is registered, avoiding the race where a proactive
    * `STREAM_RESUMING` from onConnect arrives before the handler is ready.
    */
-  handleResumeRequest(connection: Connection): Promise<void>;
+  handleResumeRequest(connection: Connection, probeId?: string): Promise<void>;
+  private _sendResumeNone;
   /** Send a keep-waiting `STREAM_PENDING` frame (#1784). */
   private _sendStreamPending;
   /** Whether the active continuation's owner connection is still present. */
@@ -3324,6 +3342,7 @@ export {
   ResumeHandshake,
   type ResumeHandshakeHost,
   STREAM_CLEANUP_DELAY_SECONDS,
+  STREAM_RESUME_NONE_REASONS,
   type SaveMessagesOptions,
   type SaveMessagesResult,
   type SnapshotMessage,
@@ -3332,6 +3351,7 @@ export {
   type StreamAccumulatorOptions,
   type StreamChunkData,
   StreamProgressCreditThrottle,
+  type StreamResumeNoneReason,
   SubmitConcurrencyController,
   type SubmitConcurrencyDecision,
   TIMED_OUT,

package/dist/chat/index.js

@@ -1,7 +1,7 @@
 import { i as normalizeToolInput, n as getPartialStreamText, r as isReplayChunk, t as applyChunkToParts } from "../message-builder-BymO4N_D.js";
 import { i as interceptAgentToolBroadcast, n as applyAgentToolEvent, r as createAgentToolEventState, t as AgentToolProgressEmitter } from "../agent-tools-y7zLfw4Q.js";
 import { t as truncateToolOutput } from "../tool-output-truncation-CNnnGZQ3.js";
-import { n as transition, r as StreamAccumulator, t as MessageType } from "../wire-types-nflOzNuU.js";
+import { a as StreamAccumulator, i as transition, n as CHAT_MESSAGE_TYPES, r as STREAM_RESUME_NONE_REASONS, t as MessageType } from "../wire-types-CU9rLoeS.js";
 import { jsonSchema, tool } from "ai";
 import { nanoid } from "nanoid";
 //#region src/chat/sanitize.ts
@@ -335,31 +335,6 @@ var SubmitConcurrencyController = class {
 	}
 };
 //#endregion
-//#region src/chat/protocol.ts
-/**
-* Wire protocol message type constants for the cf_agent_chat_* protocol.
-*
-* These are the string values used on the wire between agent servers and
-* clients. Both @cloudflare/ai-chat (via its MessageType enum) and
-* @cloudflare/think use these values.
-*/
-const CHAT_MESSAGE_TYPES = {
-	CHAT_MESSAGES: "cf_agent_chat_messages",
-	USE_CHAT_REQUEST: "cf_agent_use_chat_request",
-	USE_CHAT_RESPONSE: "cf_agent_use_chat_response",
-	CHAT_CLEAR: "cf_agent_chat_clear",
-	CHAT_REQUEST_CANCEL: "cf_agent_chat_request_cancel",
-	STREAM_RESUMING: "cf_agent_stream_resuming",
-	STREAM_RESUME_ACK: "cf_agent_stream_resume_ack",
-	STREAM_RESUME_REQUEST: "cf_agent_stream_resume_request",
-	STREAM_RESUME_NONE: "cf_agent_stream_resume_none",
-	STREAM_PENDING: "cf_agent_stream_pending",
-	TOOL_RESULT: "cf_agent_tool_result",
-	TOOL_APPROVAL: "cf_agent_tool_approval",
-	MESSAGE_UPDATED: "cf_agent_message_updated",
-	CHAT_RECOVERING: "cf_agent_chat_recovering"
-};
-//#endregion
 //#region src/chat/connection.ts
 /**
 * Send a message on a connection, swallowing the specific
@@ -1056,7 +1031,7 @@ function createToolsFromClientSchemas(clientTools, options) {
 	const execute = options?.execute;
 	const createTool = tool;
 	return Object.fromEntries(clientTools.map((t) => [t.name, createTool({
-		description: t.description ?? "",
+		description: typeof t.description === "function" ? "" : t.description ?? "",
 		inputSchema: jsonSchema(t.parameters ?? { type: "object" }),
 		...execute ? { execute: (input, executeOptions) => execute({
 			toolName: t.name,
@@ -1245,12 +1220,13 @@ var PreStreamTurns = class {
 	* `pendingResumeConnections` — they must keep receiving any live broadcast —
 	* until the host flushes them through `notifyStreamResuming` on stream start.
 	*/
-	park(connection) {
+	park(connection, probeId) {
 		if (!this.hasInFlight()) return false;
 		this.awaitingConnections.set(connection.id, connection);
 		sendIfOpen(connection, JSON.stringify({
 			type: MSG_STREAM_PENDING,
-			...this._latestRequestId ? { id: this._latestRequestId } : {}
+			...this._latestRequestId ? { id: this._latestRequestId } : {},
+			...probeId ? { probeId } : {}
 		}));
 		return true;
 	}
@@ -1870,7 +1846,10 @@ function parseProtocolMessage(raw) {
 			approved: data.approved,
 			autoContinue: data.autoContinue
 		};
-		case CHAT_MESSAGE_TYPES.STREAM_RESUME_REQUEST: return { type: "stream-resume-request" };
+		case CHAT_MESSAGE_TYPES.STREAM_RESUME_REQUEST: return {
+			type: "stream-resume-request",
+			...typeof data.probeId === "string" ? { probeId: data.probeId } : {}
+		};
 		case CHAT_MESSAGE_TYPES.STREAM_RESUME_ACK: return {
 			type: "stream-resume-ack",
 			id: data.id
@@ -2327,13 +2306,15 @@ var ResumeHandshake = class {
 	* `reconnectToStream` hangs to its timeout with no replay), and the proactive
 	* notify is required for clients that never send a request. The notify is one
 	* tiny frame; the client dedupes its ACK so the buffer is not replayed twice.
+	* Direct responses echo the opaque probe id; proactive notifications omit it.
 	*/
-	notifyStreamResuming(connection) {
+	notifyStreamResuming(connection, probeId) {
 		const { resumableStream, pendingResumeConnections } = this.host;
 		if (!resumableStream.hasActiveStream()) return;
 		if (sendIfOpen(connection, JSON.stringify({
 			type: CHAT_MESSAGE_TYPES.STREAM_RESUMING,
-			id: resumableStream.activeRequestId
+			id: resumableStream.activeRequestId,
+			...probeId ? { probeId } : {}
 		}))) pendingResumeConnections.add(connection.id);
 	}
 	/**
@@ -2341,20 +2322,28 @@ var ResumeHandshake = class {
 	* message handler is registered, avoiding the race where a proactive
 	* `STREAM_RESUMING` from onConnect arrives before the handler is ready.
 	*/
-	async handleResumeRequest(connection) {
+	async handleResumeRequest(connection, probeId) {
 		const { resumableStream, continuation, preStream } = this.host;
-		if (resumableStream.hasActiveStream()) if (continuation.activeRequestId === resumableStream.activeRequestId && continuation.activeConnectionId !== null && continuation.activeConnectionId !== connection.id && this._ownerStillPresent(continuation.activeConnectionId)) sendIfOpen(connection, JSON.stringify({ type: CHAT_MESSAGE_TYPES.STREAM_RESUME_NONE }));
-		else this.notifyStreamResuming(connection);
+		if (resumableStream.hasActiveStream()) if (continuation.activeRequestId === resumableStream.activeRequestId && continuation.activeConnectionId !== null && continuation.activeConnectionId !== connection.id && this._ownerStillPresent(continuation.activeConnectionId)) this._sendResumeNone(connection, STREAM_RESUME_NONE_REASONS.CONTINUATION_OWNED, probeId);
+		else this.notifyStreamResuming(connection, probeId);
 		else if (continuation.pending !== null && (continuation.pending.connectionId === null || continuation.pending.connectionId === connection.id)) {
 			continuation.awaitingConnections.set(connection.id, connection);
-			this._sendStreamPending(connection, continuation.pending.requestId);
-		} else if (await this._replayTerminalOnResume(connection)) {} else if (preStream?.park(connection)) {} else sendIfOpen(connection, JSON.stringify({ type: CHAT_MESSAGE_TYPES.STREAM_RESUME_NONE }));
+			this._sendStreamPending(connection, continuation.pending.requestId, probeId);
+		} else if (await this._replayTerminalOnResume(connection, probeId)) {} else if (preStream?.park(connection, probeId)) {} else this._sendResumeNone(connection, STREAM_RESUME_NONE_REASONS.IDLE, probeId);
+	}
+	_sendResumeNone(connection, reason, probeId) {
+		sendIfOpen(connection, JSON.stringify({
+			type: CHAT_MESSAGE_TYPES.STREAM_RESUME_NONE,
+			reason,
+			...probeId ? { probeId } : {}
+		}));
 	}
 	/** Send a keep-waiting `STREAM_PENDING` frame (#1784). */
-	_sendStreamPending(connection, requestId) {
+	_sendStreamPending(connection, requestId, probeId) {
 		sendIfOpen(connection, JSON.stringify({
 			type: CHAT_MESSAGE_TYPES.STREAM_PENDING,
-			...requestId ? { id: requestId } : {}
+			...requestId ? { id: requestId } : {},
+			...probeId ? { probeId } : {}
 		}));
 	}
 	/** Whether the active continuation's owner connection is still present. */
@@ -2385,12 +2374,13 @@ var ResumeHandshake = class {
 	* error frame once the client ACKs (see {@link _replayTerminalOnAck}). Returns
 	* `true` if a terminal was pending (and `STREAM_RESUMING` was sent).
 	*/
-	async _replayTerminalOnResume(connection) {
+	async _replayTerminalOnResume(connection, probeId) {
 		const pending = await this.host.pendingChatTerminal();
 		if (!pending) return false;
 		sendIfOpen(connection, JSON.stringify({
 			type: CHAT_MESSAGE_TYPES.STREAM_RESUMING,
-			id: pending.requestId
+			id: pending.requestId,
+			...probeId ? { probeId } : {}
 		}));
 		return true;
 	}
@@ -3403,6 +3393,6 @@ async function* iterateWithStallWatchdog(source, timeoutMs, onStall) {
 	}
 }
 //#endregion
-export { AGENT_TOOL_STREAM_PROGRESS_BUMP_THROTTLE_MS, AbortRegistry, AgentToolProgressEmitter, AgentToolStreamProgressThrottle, AutoContinuationController, CHAT_LAST_TERMINAL_KEY, CHAT_MESSAGE_TYPES, CHAT_RECOVERING_FLAG_TTL_MS, CHAT_RECOVERING_KEY, CHAT_RECOVERY_ALARM_DEBOUNCE_MS, CHAT_RECOVERY_INCIDENT_KEY_PREFIX, CHAT_RECOVERY_INCIDENT_TTL_MS, CHAT_RECOVERY_PROGRESS_KEY, CHAT_RECOVERY_STABLE_RETRY_DELAY_SECONDS, CHAT_STREAM_PROGRESS_CREDIT_THROTTLE_MS, ChatRecoveryEngine, ChatStreamStalledError, ContinuationState, DEFAULT_CHAT_RECOVERY_MAX_ATTEMPTS, DEFAULT_CHAT_RECOVERY_MAX_OOM_RETRIES, DEFAULT_CHAT_RECOVERY_MAX_WORK, DEFAULT_CHAT_RECOVERY_NO_PROGRESS_TIMEOUT_MS, DEFAULT_CHAT_RECOVERY_STABLE_TIMEOUT_MS, DEFAULT_CHAT_RECOVERY_TERMINAL_MESSAGE, KV_DELETE_MAX_KEYS, MAX_BOUND_PARAMS, MessageType, PreStreamTurns, ROW_MAX_BYTES, ResumableStream, ResumeHandshake, STREAM_CLEANUP_DELAY_SECONDS, StreamAccumulator, StreamProgressCreditThrottle, SubmitConcurrencyController, TIMED_OUT, TurnQueue, aiSdkRecoveryCodec, applyAgentToolEvent, applyChunkToParts, applyToolUpdate, awaitWithDeadline, transition as broadcastTransition, buildChatRecoveringFrame, buildInClauseStrings, bumpChatRecoveryProgress, byteLength, chatRecoverySchedulePolicy, classifyAgentToolChildRecovery, cleanupStreamBuffers, clearChatTerminal, clientResolvableToolNames, createAgentToolEventState, createChatFiberSnapshot, createToolsFromClientSchemas, crossMessageToolResultUpdate, drainInteractionApplies, enforceRowSizeLimit, hasIncompleteToolBatch, interceptAgentToolBroadcast, isReplayChunk, iterateWithStallWatchdog, listActiveChatRecoveryIncidents, normalizeToolInput, parseProtocolMessage, partAwaitsClientInteraction, pausedExecutionUpdate, pendingChatTerminal, persistReconstructedOrphan, readChatRecoveryProgress, reconcileMessages, reconcileOrphanPartial, recordChatTerminal, repairInterruptedToolParts, resolveChatRecoveryConfig, resolveToolMergeId, runChatRecoveryExhaustion, sanitizeMessage, sendIfOpen, setChatRecovering, shouldCreditStreamProgress, sweepStaleChatRecoveryIncidents, toolApprovalUpdate, toolPartHasSettledResult, toolResultUpdate, unwrapChatFiberSnapshot, wrapChatFiberSnapshot };
+export { AGENT_TOOL_STREAM_PROGRESS_BUMP_THROTTLE_MS, AbortRegistry, AgentToolProgressEmitter, AgentToolStreamProgressThrottle, AutoContinuationController, CHAT_LAST_TERMINAL_KEY, CHAT_MESSAGE_TYPES, CHAT_RECOVERING_FLAG_TTL_MS, CHAT_RECOVERING_KEY, CHAT_RECOVERY_ALARM_DEBOUNCE_MS, CHAT_RECOVERY_INCIDENT_KEY_PREFIX, CHAT_RECOVERY_INCIDENT_TTL_MS, CHAT_RECOVERY_PROGRESS_KEY, CHAT_RECOVERY_STABLE_RETRY_DELAY_SECONDS, CHAT_STREAM_PROGRESS_CREDIT_THROTTLE_MS, ChatRecoveryEngine, ChatStreamStalledError, ContinuationState, DEFAULT_CHAT_RECOVERY_MAX_ATTEMPTS, DEFAULT_CHAT_RECOVERY_MAX_OOM_RETRIES, DEFAULT_CHAT_RECOVERY_MAX_WORK, DEFAULT_CHAT_RECOVERY_NO_PROGRESS_TIMEOUT_MS, DEFAULT_CHAT_RECOVERY_STABLE_TIMEOUT_MS, DEFAULT_CHAT_RECOVERY_TERMINAL_MESSAGE, KV_DELETE_MAX_KEYS, MAX_BOUND_PARAMS, MessageType, PreStreamTurns, ROW_MAX_BYTES, ResumableStream, ResumeHandshake, STREAM_CLEANUP_DELAY_SECONDS, STREAM_RESUME_NONE_REASONS, StreamAccumulator, StreamProgressCreditThrottle, SubmitConcurrencyController, TIMED_OUT, TurnQueue, aiSdkRecoveryCodec, applyAgentToolEvent, applyChunkToParts, applyToolUpdate, awaitWithDeadline, transition as broadcastTransition, buildChatRecoveringFrame, buildInClauseStrings, bumpChatRecoveryProgress, byteLength, chatRecoverySchedulePolicy, classifyAgentToolChildRecovery, cleanupStreamBuffers, clearChatTerminal, clientResolvableToolNames, createAgentToolEventState, createChatFiberSnapshot, createToolsFromClientSchemas, crossMessageToolResultUpdate, drainInteractionApplies, enforceRowSizeLimit, hasIncompleteToolBatch, interceptAgentToolBroadcast, isReplayChunk, iterateWithStallWatchdog, listActiveChatRecoveryIncidents, normalizeToolInput, parseProtocolMessage, partAwaitsClientInteraction, pausedExecutionUpdate, pendingChatTerminal, persistReconstructedOrphan, readChatRecoveryProgress, reconcileMessages, reconcileOrphanPartial, recordChatTerminal, repairInterruptedToolParts, resolveChatRecoveryConfig, resolveToolMergeId, runChatRecoveryExhaustion, sanitizeMessage, sendIfOpen, setChatRecovering, shouldCreditStreamProgress, sweepStaleChatRecoveryIncidents, toolApprovalUpdate, toolPartHasSettledResult, toolResultUpdate, unwrapChatFiberSnapshot, wrapChatFiberSnapshot };
 
 //# sourceMappingURL=index.js.map