agents 0.17.3 → 0.18.0

package/dist/{agent-tool-types-CNyE1iz_.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,
@@ -41,6 +41,7 @@ import {
 import {
   CallToolRequest,
   CallToolResultSchema,
+  ClientCapabilities,
   CompatibilityCallToolResultSchema,
   ElicitRequest,
   ElicitRequest as ElicitRequest$1,
@@ -799,20 +800,40 @@ type MCPTransportOptions = (
   authProvider?: AgentMcpOAuthProvider;
   type?: TransportType;
 };
+/** Result of discovering server capabilities. */
+type MCPDiscoveryResult =
+  | {
+      success: true;
+    }
+  | {
+      success: false;
+      reason: "error" | "stale-session";
+      error: string;
+    };
 /**
- * Result of a discovery operation.
- * success indicates whether discovery completed successfully.
- * error is present when success is false.
+ * Handler for server-initiated `elicitation/create` requests.
+ * Held in memory only — never persisted — so it must be re-supplied when a
+ * connection is recreated (e.g. after Durable Object hibernation).
  */
-type MCPDiscoveryResult = {
-  success: boolean;
-  error?: string;
+type MCPElicitationHandler = (request: ElicitRequest) => Promise<ElicitResult>;
+type MCPElicitationHandlers = {
+  form?: MCPElicitationHandler;
+  url?: MCPElicitationHandler;
 };
 declare class MCPClientConnection {
   url: URL;
+  private readonly _info;
   options: {
     transport: MCPTransportOptions;
     client: McpClientOptions;
+    elicitationHandlers?: MCPElicitationHandlers;
+    /**
+     * Client capabilities persisted from a previous session, advertised
+     * until handlers are reconfigured after a hibernation restore. Cleared
+     * by {@link configureElicitationHandlers} — reconfigured handlers are
+     * the source of truth. Explicit `client.capabilities` win per key.
+     */
+    capabilitySeed?: ClientCapabilities;
   };
   client: Client;
   connectionState: MCPConnectionState;
@@ -839,14 +860,41 @@ declare class MCPClientConnection {
   private _discoveryAbortController;
   private readonly _onObservabilityEvent;
   readonly onObservabilityEvent: Event<MCPObservabilityEvent>;
+  /**
+   * Whether the connection advertised the elicitation capability. The SDK
+   * client refuses to register an `elicitation/create` request handler when
+   * the capability was not declared, so handler registration is gated on
+   * this.
+   */
+  private _elicitationEnabled;
   constructor(
     url: URL,
-    info: ConstructorParameters<typeof Client>[0],
+    _info: ConstructorParameters<typeof Client>[0],
     options?: {
       transport: MCPTransportOptions;
       client: McpClientOptions;
+      elicitationHandlers?: MCPElicitationHandlers;
+      /**
+       * Client capabilities persisted from a previous session, advertised
+       * until handlers are reconfigured after a hibernation restore. Cleared
+       * by {@link configureElicitationHandlers} — reconfigured handlers are
+       * the source of truth. Explicit `client.capabilities` win per key.
+       */
+      capabilitySeed?: ClientCapabilities;
     }
   );
+  private createClient;
+  /**
+   * Configure the handler used for server-initiated elicitation requests.
+   *
+   * If the connection has not been initialized yet, rebuild the SDK client so
+   * handler-driven elicitation capabilities are reflected in the initial
+   * handshake. A rebuild (rather than `Client.registerCapabilities`) is
+   * required because SDK capability registration is merge-only — it cannot
+   * un-advertise a mode when handlers are cleared before connecting. Active
+   * connections keep their negotiated capabilities until they reconnect.
+   */
+  configureElicitationHandlers(handlers?: MCPElicitationHandlers): void;
   /**
    * Initialize a client connection, if authentication is required, the connection will be in the AUTHENTICATING state
    * Sets connection state based on the result and emits observability events
@@ -1047,12 +1095,18 @@ declare class MCPClientConnection {
     }[]
   >;
   /**
-   * Handle elicitation request from server
-   * Automatically uses the Agent's built-in elicitation handling if available
+   * Handle elicitation request from server.
+   *
+   * Delegates to the `elicitationHandlers` connection option when provided.
+   *
+   * @deprecated Overriding or instance-patching this method directly is
+   * deprecated — pass the `elicitationHandlers` connection option instead.
    */
-  handleElicitationRequest(_request: ElicitRequest): Promise<ElicitResult>;
+  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>;
   /**
@@ -1135,6 +1189,12 @@ type MCPServerOptions = {
     sessionId?: string;
   } /** Retry options for connection and reconnection attempts */;
   retry?: RetryOptions;
+  /**
+   * Client capabilities advertised from configured handlers (currently the
+   * elicitation modes). Handlers are functions and cannot be persisted, so
+   * this records what they advertised for restores after hibernation.
+   */
+  capabilities?: ClientCapabilities;
 };
 /**
  * Result of an OAuth callback request
@@ -1207,6 +1267,14 @@ type MCPClientOAuthResult =
       authSuccess: false /** May contain untrusted content from external OAuth providers. Escape appropriately for your output context. */;
       authError: string;
     };
+type MCPClientElicitationHandler = (
+  request: ElicitRequest,
+  serverId: string
+) => Promise<ElicitResult>;
+type MCPClientElicitationHandlers = {
+  form?: MCPClientElicitationHandler;
+  url?: MCPClientElicitationHandler;
+};
 type MCPClientManagerOptions = {
   storage: DurableObjectStorage;
   createAuthProvider?: (callbackUrl: string) => AgentMcpOAuthProvider;
@@ -1231,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;
@@ -1238,6 +1308,7 @@ declare class MCPClientManager {
   private _createAuthProviderFn?;
   private _isRestored;
   private _pendingConnections;
+  private _elicitationHandlers?;
   /** @internal Protected for testing purposes. */
   protected readonly _onObservabilityEvent: Emitter<MCPObservabilityEvent>;
   readonly onObservabilityEvent: Event<MCPObservabilityEvent>;
@@ -1257,6 +1328,12 @@ declare class MCPClientManager {
     _version: string,
     options: MCPClientManagerOptions
   );
+  /**
+   * Scope the manager-level elicitation handler to a single connection.
+   * Returns undefined when no handler is configured so the connection keeps
+   * its default throwing behavior.
+   */
+  private scopedElicitationHandlers;
   private sql;
   private saveServerToStorage;
   private removeServerFromStorage;
@@ -1287,6 +1364,19 @@ declare class MCPClientManager {
   private _renameInMemoryConnection;
   private getServersFromStorage;
   private filterConnections;
+  /**
+   * Get the parsed server_options for a stored server, if any.
+   */
+  private getStoredServerOptions;
+  /**
+   * Clear the capabilities persisted on a stored server row. Called once a
+   * seeded connection's handshake completes (see `createConnection`): the
+   * stamp is valid for one successful restore — sessions that configure
+   * handlers re-stamp every row, so a deploy that stops configuring them
+   * stops advertising stale modes after its first connected wake instead of
+   * forever, while wakes that never handshake don't burn the stamp.
+   */
+  private clearStoredCapabilities;
   /**
    * Get the retry options for a server from stored server_options
    */
@@ -1297,6 +1387,8 @@ declare class MCPClientManager {
   private isAuthAcceptedConnection;
   private oauthCallbackSuccess;
   private runWithCodeVerifierState;
+  private hasRedeemableOAuthState;
+  private ignoreUnverifiedCallback;
   private consumeStaleOAuthState;
   private completeAuthorizationAndCleanupVerifier;
   /**
@@ -1348,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
    */
@@ -1431,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.
@@ -1445,6 +1540,33 @@ declare class MCPClientManager {
    * @param config OAuth callback configuration
    */
   configureOAuthCallback(config: MCPClientOAuthCallbackConfig): void;
+  /**
+   * Configure handling for server-initiated `elicitation/create` requests.
+   *
+   * The handler is held in memory only and applied to every MCP connection
+   * created or restored by this manager. Call this before registering
+   * connections when you want the initial MCP handshake to advertise
+   * handler-driven form- and url-mode elicitation. Existing active connections
+   * keep their negotiated capabilities until they reconnect.
+   *
+   * The advertised modes are persisted with each stored server, so
+   * connections restored after hibernation re-advertise them at the handshake
+   * even when this is called later in the wake-up (e.g. from onStart) — the
+   * handlers attach to the live connections as soon as this runs.
+   *
+   * Pass undefined to clear the handler.
+   *
+   * @param handlers Elicitation handlers keyed by mode, each scoped with the server id that sent the request
+   */
+  configureElicitationHandlers(handlers?: MCPClientElicitationHandlers): void;
+  /** Client capabilities advertised from the currently configured handlers. */
+  private advertisedHandlerCapabilities;
+  /**
+   * Record the handler-derived capabilities on every stored server row so a
+   * restore after hibernation re-advertises them before the handlers
+   * themselves are reconfigured.
+   */
+  private persistAdvertisedCapabilities;
   /**
    * Get the current OAuth callback configuration
    * @returns The current OAuth callback configuration
@@ -1456,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
    */
@@ -1743,9 +1869,7 @@ declare class MCPClientManager {
                   uri: string;
                   text: string;
                   mimeType?: string | undefined;
-                  _meta /** Include only connections matching this server ID (or IDs). */?/** Include only connections matching this server ID (or IDs). */ :
-                    | Record<string, unknown>
-                    | undefined;
+                  _meta?: Record<string, unknown> | undefined;
                 }
               | {
                   uri: string;
@@ -1784,11 +1908,7 @@ declare class MCPClientManager {
             icons?:
               | {
                   src: string;
-                  mimeType?/**
-                   * Event that fires whenever any MCP server state changes (registered, connected, removed, etc.)
-                   * This is useful for broadcasting server state to clients.
-                   */
-                  : string | undefined;
+                  mimeType?: string | undefined;
                   sizes?: string[] | undefined;
                   theme?: "light" | "dark" | undefined;
                 }[]
@@ -2627,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
@@ -2638,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
@@ -3421,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,
@@ -4663,6 +4787,8 @@ declare class Agent<
         state: typeof MCPConnectionState.READY;
       }
   >;
+  private _redeemableAuthUrl;
+  private _isAbsoluteHttpUrl;
   removeMcpServer(id: string): Promise<void>;
   getMcpServers(): MCPServersState;
   /**
@@ -5275,71 +5401,72 @@ type AgentToolEventState<Part extends AgentToolRunPart = AgentToolRunPart> = {
 //#endregion
 export {
   RoutingRetryOptions as $,
-  McpClientOptions as $t,
+  WorkerTransport as $t,
   AgentGetOptions as A,
-  getNamespacedData as At,
+  MCP_SERVER_ID_MAX_LENGTH as At,
   EmailSendBinding as B,
-  McpAgent as Bt,
+  RPC_DO_PREFIX as Bt,
   DetachedRunAgentToolResult as C,
-  MCPConnectionResult as Ct,
+  MCPClientOAuthCallbackConfig as Ct,
   AddRpcMcpServerOptions as D,
-  MCPServerOptions as Dt,
+  MCPOAuthCallbackResult as Dt,
   AddMcpServerOptions as E,
-  MCPServerFilter as Et,
+  MCPDiscoverResult as Et,
   Connection$1 as F,
-  RPCServerTransportOptions as Ft,
+  MCPElicitationHandlers as Ft,
   FiberStatus as G,
-  experimental_createMcpHandler as Gt,
+  ClearableEventStore as Gt,
   FiberInspection as H,
-  DurableObjectEventStore as Ht,
+  ElicitRequestSchema$1 as Ht,
   ConnectionContext$1 as I,
-  RPC_DO_PREFIX as It,
+  RPCClientTransport as It,
   MCPServerMessage as J,
-  TransportState as Jt,
+  createMcpHandler as Jt,
   ListFibersOptions as K,
-  McpAuthContext as Kt,
+  DurableObjectEventStore as Kt,
   DEFAULT_AGENT_STATIC_OPTIONS as L,
-  ElicitRequest$1 as Lt,
+  RPCClientTransportOptions as Lt,
   AgentOptions as M,
-  RPCClientTransport as Mt,
+  getNamespacedData as Mt,
   AgentStaticOptions as N,
-  RPCClientTransportOptions as Nt,
+  normalizeServerId as Nt,
   Agent as O,
-  MCP_SERVER_ID_MAX_LENGTH as Ot,
+  MCPServerFilter as Ot,
   CallableMetadata as P,
-  RPCServerTransport as Pt,
+  MCPElicitationHandler as Pt,
   RPCResponse as Q,
-  StreamableHTTPEdgeClientTransport as Qt,
+  TransportState as Qt,
   DeleteFibersOptions as R,
-  ElicitRequestSchema$1 as Rt,
+  RPCServerTransport as Rt,
   DetachedAgentToolConfig as S,
-  MCPClientOAuthResult as St,
+  MCPClientManagerOptions as St,
   RunAgentToolResult as T,
-  MCPOAuthCallbackResult as Tt,
+  MCPConnectionResult as Tt,
   FiberRecoveryContext as U,
-  CreateMcpHandlerOptions as Ut,
+  ElicitResult$1 as Ut,
   FiberContext as V,
-  ClearableEventStore as Vt,
+  ElicitRequest$1 as Vt,
   FiberRecoveryResult as W,
-  createMcpHandler as Wt,
+  McpAgent as Wt,
   QueueItem as X,
-  WorkerTransportOptions as Xt,
+  McpAuthContext as Xt,
   MCPServersState as Y,
-  WorkerTransport as Yt,
+  experimental_createMcpHandler as Yt,
   RPCRequest as Z,
-  SSEEdgeClientTransport as Zt,
+  getMcpAuthContext as Zt,
   AgentToolRunState as _,
   MCPAITool as _t,
   AgentToolEvent as a,
-  routeSubAgentRequest as an,
+  SUB_PREFIX as an,
   StartFiberResult as at,
   AgentToolTerminalStatus as b,
-  MCPClientManagerOptions as bt,
+  MCPClientElicitationHandlers as bt,
   AgentToolFailure as c,
+  parseSubAgentPath as cn,
   SubAgentClass as ct,
   AgentToolMilestone as d,
   callable as dt,
-  TransportType as en,
+  WorkerTransportOptions as en,
   Schedule as et,
   AgentToolProgress as f,
   getAgentByName as ft,
@@ -5348,44 +5475,47 @@ export {
   AgentToolRunInspection as h,
   routeAgentRequest as ht,
   AgentToolDisplayMetadata as i,
-  parseSubAgentPath as in,
+  TransportType as in,
   StartFiberOptions as it,
   AgentNamespace as j,
-  normalizeServerId as jt,
+  RegisterServerOptions as jt,
   AgentContext as k,
-  RegisterServerOptions as kt,
+  MCPServerOptions as kt,
   AgentToolInterruptedReason as l,
+  routeSubAgentRequest as ln,
   SubAgentStub as lt,
   AgentToolRunInfo as m,
   routeAgentEmail as mt,
   AGENT_TOOL_PROGRESS_PART as n,
-  SubAgentPathMatch as nn,
+  StreamableHTTPEdgeClientTransport as nn,
   SendEmailOptions as nt,
   AgentToolEventMessage as o,
+  SubAgentPathMatch as on,
   StateUpdateMessage as ot,
   AgentToolProgressSnapshot as p,
   getCurrentAgent as pt,
   MCPServer as q,
-  getMcpAuthContext as qt,
+  CreateMcpHandlerOptions as qt,
   AgentToolChildAdapter as r,
-  getSubAgentByName as rn,
+  McpClientOptions as rn,
   SqlError as rt,
   AgentToolEventState as s,
+  getSubAgentByName as sn,
   StreamingResponse as st,
   AGENT_TOOL_MILESTONE_PART as t,
-  SUB_PREFIX as tn,
+  SSEEdgeClientTransport as tn,
   ScheduleCriteria as tt,
   AgentToolLifecycleResult as u,
   WSMessage$1 as ut,
   AgentToolRunStatus as v,
   MCPAIToolSet as vt,
   RunAgentToolOptions as w,
-  MCPDiscoverResult as wt,
+  MCPClientOAuthResult as wt,
   ChatCapableAgentClass as x,
-  MCPClientOAuthCallbackConfig as xt,
+  MCPClientManager as xt,
   AgentToolStoredChunk as y,
-  MCPClientManager as yt,
+  MCPClientElicitationHandler as yt,
   EmailRoutingOptions as z,
-  ElicitResult$1 as zt
+  RPCServerTransportOptions as zt
 };
-//# sourceMappingURL=agent-tool-types-CNyE1iz_.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-CNyE1iz_.js";
+} from "./agent-tool-types-BNUGGBzQ.js";
 export {
   AGENT_TOOL_MILESTONE_PART,
   AGENT_TOOL_PROGRESS_PART,

package/dist/{agent-tools-BeOheFBK.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-CNyE1iz_.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-BeOheFBK.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-CNyE1iz_.js";
+} from "./agent-tool-types-BNUGGBzQ.js";
 import { Tool } from "ai";
 
 //#region src/agent-tools.d.ts

package/dist/chat/index.d.ts

@@ -4,7 +4,7 @@ import {
   a as AgentToolEvent,
   o as AgentToolEventMessage,
   s as AgentToolEventState
-} from "../agent-tool-types-CNyE1iz_.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-BeOheFBK.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,