agents 0.30.1 → 0.31.0

package/dist/{agent-routing-CDbpVjYq.d.ts → agent-routing-wS1TimZ_.d.ts}

@@ -17,6 +17,7 @@ import {
 import { n as CurrentAgentContext } from "./current-agent-CKgT5d1O.js";
 import { t as AgentEmail } from "./internal_context-BlxFEWfn.js";
 import { r as EmailResolver, s as SendEmailOptions } from "./email-7TatiTnl.js";
+import { r as InternalHostMessage } from "./internal-hosts-Kfp5A392.js";
 import {
   n as Observability,
   r as ObservabilityEvent,
@@ -24,17 +25,11 @@ import {
 } from "./index-YSKgfgg9.js";
 import { t as AgentMcpOAuthProvider } from "./do-oauth-client-provider-DfsUcpc3.js";
 import {
-  a as McpAuthContext,
-  c as CORSOptions,
-  d as ServeOptions,
-  f as TransportType,
-  l as MaybePromise,
-  n as StatelessMcpHandler,
-  s as BaseTransportType,
-  t as CreateStatelessMcpHandlerOptions,
-  u as McpClientOptions
-} from "./handler-stateless-DxYpJ_XF.js";
-import { n as LegacyCallToolResultSchema } from "./invoker-CG0_p_Wq.js";
+  i as McpClientOptions,
+  o as TransportType,
+  t as BaseTransportType
+} from "./types-D2naO3rA.js";
+import { t as LegacyCallToolResultSchema } from "./invoker-DoLFPJZV.js";
 import { t as MessageType } from "./types-6Zo2zfoO.js";
 import {
   a as ScheduleCriteria,
@@ -64,10 +59,8 @@ import {
   DiscoverResult,
   ElicitRequest,
   ElicitRequest as ElicitRequest$1,
-  ElicitRequest as ElicitRequest$2,
   ElicitResult,
-  ElicitResult as ElicitResult$2,
-  ElicitResult as ElicitResult$3,
+  ElicitResult as ElicitResult$1,
   GetPromptRequest,
   JSONRPCMessage,
   MessageExtraInfo,
@@ -86,33 +79,6 @@ import {
   Transport,
   TransportSendOptions
 } from "@modelcontextprotocol/client";
-import {
-  ElicitRequestSchema,
-  ElicitResult as ElicitResult$1,
-  InitializeRequestParams,
-  JSONRPCMessage as JSONRPCMessage$1,
-  MessageExtraInfo as MessageExtraInfo$1,
-  RequestId
-} from "@modelcontextprotocol/sdk/types.js";
-import { McpServerFactory } from "@modelcontextprotocol/server";
-import { McpServer as McpServer$1 } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { Server as Server$1 } from "@modelcontextprotocol/sdk/server/index.js";
-import {
-  EventStore as EventStore$1,
-  StreamId as StreamId$1,
-  WebStandardStreamableHTTPServerTransport as WebStandardStreamableHTTPServerTransport$1,
-  WebStandardStreamableHTTPServerTransportOptions
-} from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
-import {
-  Transport as Transport$1,
-  TransportSendOptions as TransportSendOptions$1
-} from "@modelcontextprotocol/sdk/shared/transport.js";
-import {
-  EventId,
-  EventStore,
-  StreamId
-} from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { AuthInfo } from "@modelcontextprotocol/sdk/server/auth/types.js";
 
 //#region src/observability/tracing/tracer.d.ts
 type InvocationScopeOptions = {
@@ -344,11 +310,13 @@ type Promisify<T> = T extends Promise<unknown> ? T : Promise<T>;
  * are excluded — only user-defined methods on the subclass are exposed.
  */
 type DynamicAgentStub<T extends Agent> = {
-  [K in keyof T as K extends keyof Agent
-    ? never
-    : T[K] extends (...args: never[]) => unknown
-      ? K
-      : never]: T[K] extends (...args: infer A) => infer R
+  [
+    K in keyof T as K extends keyof Agent
+      ? never
+      : T[K] extends (...args: never[]) => unknown
+        ? K
+        : never
+  ]: T[K] extends (...args: infer A) => infer R
     ? (...args: A) => Promisify<R>
     : never;
 };
@@ -1023,479 +991,19 @@ declare class DynamicAgents {
   }>;
 }
 //#endregion
-//#region src/core/events.d.ts
-interface Disposable {
-  dispose(): void;
-}
-type Event<T> = (listener: (e: T) => void) => Disposable;
-declare class Emitter<T> implements Disposable {
-  private _listeners;
-  readonly event: Event<T>;
-  fire(data: T): void;
-  dispose(): void;
-}
-//#endregion
-//#region src/mcp/client/transports.d.ts
-/**
- * @deprecated Use SSEClientTransport from @modelcontextprotocol/client instead. This alias will be removed in the next major version.
- */
-declare class SSEEdgeClientTransport extends SSEClientTransport {
-  constructor(url: URL, options: SSEClientTransportOptions);
-}
-/**
- * @deprecated Use StreamableHTTPClientTransport from @modelcontextprotocol/client instead. This alias will be removed in the next major version.
- */
-declare class StreamableHTTPEdgeClientTransport extends StreamableHTTPClientTransport {
-  constructor(url: URL, options: StreamableHTTPClientTransportOptions);
-}
-//#endregion
-//#region src/mcp/server/worker-transport.d.ts
-/**
- * Pluggable storage adapter for persisting `WorkerTransport` state across
- * Durable Object hibernation / restart cycles.
- *
- * A typical implementation reads/writes a single key on `this.ctx.storage`
- * inside a Durable Object or Agent.
- */
-interface MCPStorageApi {
-  get(): Promise<TransportState | undefined> | TransportState | undefined;
-  set(state: TransportState): Promise<void> | void;
-}
-/** Shape of the persisted transport state. */
-interface TransportState {
-  sessionId?: string;
-  initialized: boolean;
-  initializeParams?: InitializeRequestParams;
-}
-interface WorkerTransportOptions extends WebStandardStreamableHTTPServerTransportOptions {
-  /**
-   * CORS options applied to every response and to OPTIONS preflight.
-   * Defaults: `origin: *`, expose `mcp-session-id`, allow the standard MCP
-   * methods/headers, max-age 86400.
-   */
-  corsOptions?: CORSOptions;
-  /**
-   * Optional storage adapter for persisting transport state across DO
-   * hibernation / restart. Use this to keep an MCP session alive across
-   * Durable Object wake-ups.
-   */
-  storage?: MCPStorageApi;
-}
-declare class WorkerTransport extends WebStandardStreamableHTTPServerTransport$1 {
-  private readonly _corsOptions?;
-  private readonly _storage?;
-  private _stateRestored;
-  private _capturedInitializeParams?;
-  private _userOnSessionInitialized?;
-  private _bridgeInstalled;
-  /**
-   * Request ids whose SSE stream was deliberately torn down via
-   * `closeSSEStream`. The SDK's `send()` throws "No connection established"
-   * when a request id has no stream — a race that surfaces whenever the
-   * server's tool handler resolves *after* the caller closed the stream
-   * (e.g. polling-style early-close, or test fixtures closing mid-flight).
-   * We swallow `send()` for these ids so the rejection doesn't bubble out
-   * of the protocol layer as an unhandled rejection. Mirrors the
-   * silent-noop behaviour of the pre-refactor `WorkerTransport`.
-   */
-  private readonly _closedRequestIds;
-  constructor(options?: WorkerTransportOptions);
-  /**
-   * Backwards-compatible alias for the SDK's internal `_started` flag.
-   * Several callers and tests check `transport.started` directly.
-   */
-  get started(): boolean;
-  /**
-   * Top-level request entry point. Handles CORS preflight, restores any
-   * persisted state on first invocation, then delegates to the SDK transport
-   * and finally appends CORS headers to whatever response comes back.
-   */
-  handleRequest(
-    request: Request,
-    options?: {
-      parsedBody?: unknown;
-      authInfo?: AuthInfo;
-    }
-  ): Promise<Response>;
-  /**
-   * The SDK's 405 responses advertise `Allow: GET, POST, DELETE` because
-   * OPTIONS is handled outside the SDK. Since our wrapper *does* handle
-   * OPTIONS, advertise it in `Allow` so clients can probe accurately.
-   */
-  private normalizeAllowHeader;
-  closeSSEStream(requestId: RequestId): void;
-  close(): Promise<void>;
-  /**
-   * Swallow two classes of message that would otherwise surface as
-   * unhandled rejections from the SDK transport's `send()`:
-   *
-   *   1. Replayed initialize responses (the `RESTORE_REQUEST_ID` sentinel)
-   *      — we synthesise these in `restoreState()` to rebuild server
-   *      capabilities; there's no real client waiting for the response.
-   *   2. Sends for a request id whose SSE stream has been deliberately
-   *      closed via `closeSSEStream`. The protocol layer's tool-handler
-   *      promise may settle after the close, and the SDK's `send()` throws
-   *      "No connection established" — a race the pre-refactor transport
-   *      silently swallowed.
-   *
-   * Everything else is delegated. We use `await super.send(...)` rather
-   * than `return super.send(...)` so any rejection is observed inside this
-   * async frame; without the await, the test runner's
-   * unhandled-rejection tracker can fire before the caller's own `await`
-   * observes it.
-   */
-  send(
-    message: JSONRPCMessage$1,
-    options?: TransportSendOptions$1
-  ): Promise<void>;
-  private getCorsHeaders;
-  private withCorsHeaders;
-  private installOnSessionInitializedBridge;
-  private captureInitializeParams;
-  private restoreState;
-  private saveState;
-}
-//#endregion
-//#region src/mcp/server/handler-legacy.d.ts
-/** Options for the retained SDK v1, sessionful handler. */
-interface CreateLegacyMcpHandlerOptions extends WorkerTransportOptions {
-  /** Exact route handled by this handler. @default "/mcp" */
-  route?: string;
-  /** Application props exposed through {@link getMcpAuthContext}. */
-  authContext?: McpAuthContext;
-  /** Pre-created sessionful transport. */
-  transport?: WorkerTransport;
-}
-type CreateMcpHandlerOptions$1 = CreateLegacyMcpHandlerOptions;
-type LegacyMcpHandler = (
-  request: Request,
-  env: unknown,
-  ctx: ExecutionContext
-) => Promise<Response>;
-/**
- * Create a sessionful Legacy MCP handler backed by SDK v1.
- *
- * New Stateless servers should use `createMcpHandler` from
- * `agents/mcp/server` instead.
- */
-declare function createLegacyMcpHandler(
-  server: McpServer$1 | Server$1,
-  options?: CreateLegacyMcpHandlerOptions
-): LegacyMcpHandler;
-//#endregion
-//#region src/mcp/server/handler-compat.d.ts
-/**
- * @deprecated Passing an SDK v1 server to createMcpHandler is deprecated and
- * will be removed in the next major version. Pass an SDK v2 factory to
- * createMcpHandler. Use createLegacyMcpHandler only to temporarily retain
- * sessionful SDK v1 behavior while migrating.
- */
-declare function createMcpHandler$1(
-  server: McpServer$1 | Server$1,
-  options?: CreateMcpHandlerOptions$1
-): LegacyMcpHandler;
-declare function createMcpHandler$1(
-  factory: McpServerFactory,
-  options?: CreateStatelessMcpHandlerOptions
-): StatelessMcpHandler;
-/**
- * @deprecated Pass an SDK v2 factory to createMcpHandler.
- * experimental_createMcpHandler will be removed in the next major version.
- * Use createLegacyMcpHandler only to temporarily retain sessionful SDK v1
- * behavior while migrating.
- */
-declare function experimental_createMcpHandler(
-  server: McpServer$1 | Server$1,
-  options?: CreateMcpHandlerOptions$1
-): LegacyMcpHandler;
-//#endregion
-//#region src/mcp/server/event-store.d.ts
-/**
- * Durable Object–backed {@link EventStore} for SSE resumability.
- *
- * Default for `McpAgent`. Override `McpAgent.getEventStore()` to swap
- * or disable.
- *
- * ## Storage layout
- *
- * Events are stored under `__mcp_event__:<streamId>:<seqHex>`, where
- * `<seqHex>` is a 16-char zero-padded counter so events in a stream
- * sort lexicographically and `getStreamIdForEventId` can recover the
- * stream from `eventId` without a storage hit.
- *
- * ## Lifecycle
- *
- * Each POST tool-call stream's events live only until the final
- * response is delivered. The transport calls {@link clearStream}
- * immediately after writing the close frame, so storage growth is
- * bounded by the in-flight POST streams plus the standalone GET
- * stream. There is no background sweep — quiescent agents do no work,
- * and the DO itself dies with the session.
- *
- * Standalone GET stream events (`_GET_stream`) are *not* cleared
- * automatically; they accumulate for the lifetime of the DO. Bounded
- * by session length in practice.
- *
- * Trade-off: if the client TCP connection dies *after* the close
- * frame has been enqueued on the WS but before the bytes reach the
- * client, the final message is unreplayable. Every earlier event in
- * the stream is still replayable while the in-flight stream is open.
- *
- * ## Stream id constraints
- *
- * `streamId` MUST NOT contain `:`. `storeEvent` asserts this so
- * embedders using custom stream ids fail loudly rather than risk
- * prefix-scan collisions (e.g. clearing `a` accidentally hitting
- * `a:b`). Default ids (`connection.id` UUIDs and the literal
- * `_GET_stream`) already satisfy this.
- */
-declare class DurableObjectEventStore implements EventStore {
-  private static readonly EVENT_KEY_PREFIX;
-  private static readonly SEQ_PAD;
-  /** DO storage caps multi-key delete at 128. */
-  private static readonly DELETE_CHUNK;
-  /** Defensive ceiling on a single replay batch. A live stream's
-   *  event count is small (progress notifications + final result);
-   *  this is here so a pathological history can't OOM the DO. */
-  private static readonly REPLAY_LIMIT;
-  private readonly storage;
-  /** In-memory seq counters per stream, rehydrated lazily from storage. */
-  private readonly seqByStream;
-  private readonly seqInit;
-  constructor(storage: DurableObjectStorage);
-  storeEvent(streamId: StreamId, message: JSONRPCMessage$1): Promise<EventId>;
-  getStreamIdForEventId(eventId: EventId): Promise<StreamId | undefined>;
-  replayEventsAfter(
-    lastEventId: EventId,
-    {
-      send
-    }: {
-      send: (eventId: EventId, message: JSONRPCMessage$1) => Promise<void>;
-    }
-  ): Promise<StreamId>;
-  /**
-   * Drop the event log for a single stream. Called by the transport
-   * immediately after a POST's final response has been written to the
-   * wire — no future `Last-Event-ID` for this stream is expected to
-   * resolve.
-   *
-   * Lists and deletes in chunks of {@link DELETE_CHUNK} (128, the DO
-   * storage cap) so we never load the entire event log into memory.
-   * After deleting, the next `list` call won't see the deleted keys,
-   * so passing `start: <prefix>` again is enough — no cursor bookkeeping.
-   */
-  clearStream(streamId: StreamId): Promise<void>;
-  private ensureSeqLoaded;
-}
-//#endregion
-//#region src/mcp/server/transport.d.ts
-/**
- * An {@link EventStore} that supports dropping all events for a single
- * stream id. Implemented by {@link DurableObjectEventStore}.
- */
-interface ClearableEventStore extends EventStore$1 {
-  clearStream(streamId: StreamId$1): Promise<void>;
-}
-//#endregion
-//#region src/mcp/server/legacy-agent.d.ts
+//#region src/mcp/rpc.d.ts
 /**
- * @deprecated McpAgent is feature-frozen. Migrate to an SDK v2 factory with
- * createMcpHandler from agents/mcp/server. When sessionful features prevent an
- * immediate migration, run the stateless route beside the existing McpAgent
- * route until clients transition and sessions drain.
+ * Structural shape of a Durable Object that serves MCP over RPC, such as
+ * `McpAgent`. Declared structurally so the client side does not pull the
+ * legacy server (and `@modelcontextprotocol/sdk`) into its types.
  */
-declare abstract class McpAgent<
-  Env extends Cloudflare.Env = Cloudflare.Env,
-  State = unknown,
-  Props extends Record<string, unknown> = Record<string, unknown>
-> extends Agent<Env, State, Props> {
-  private _transport?;
-  private _pendingElicitations;
-  props?: Props;
-  shouldSendProtocolMessages(
-    _connection: Connection,
-    ctx: ConnectionContext
-  ): boolean;
-  abstract server: MaybePromise<McpServer$1 | Server$1>;
-  abstract init(): Promise<void>;
-  setInitializeRequest(initializeRequest: JSONRPCMessage$1): Promise<void>;
-  getInitializeRequest(): Promise<JSONRPCMessage$1 | undefined>;
-  /**
-   * End a streamable HTTP session (`DELETE`). Teardown is deferred to the
-   * agent's alarm (#1625), so the stored initialize request is cleared too:
-   * every route treats a session without one as unknown, which makes requests
-   * carrying the terminated session ID get 404 as the spec requires. Teardown
-   * is scheduled first, so a failure part-way leaves a session the client can
-   * `DELETE` again rather than one that is never cleaned up.
-   *
-   * @internal
-   */
-  _cf_terminateSession(): Promise<void>;
-  /**
-   * Storage key prefix for the `streamId -> requestIds` mapping used
-   * to support POST stream resumption across WebSocket reconnects.
-   *
-   * @internal
-   */
-  private static readonly STREAM_REQS_KEY_PREFIX;
-  /** Persist the `requestIds` for a POST stream. @internal */
-  setStreamRequestIds(streamId: string, requestIds: RequestId[]): Promise<void>;
-  /** Read the persisted `requestIds` for a POST stream. @internal */
-  getStreamRequestIds(streamId: string): Promise<RequestId[] | undefined>;
-  /** Drop the persisted `requestIds` for a POST stream. @internal */
-  deleteStreamRequestIds(streamId: string): Promise<void>;
-  /**
-   * Reverse lookup: find which POST stream a given `requestId` belongs
-   * to, and return the stream's full `requestIds` list in the same
-   * pass. Used by the transport when the originating WS has dropped,
-   * so `send()` can still record events for replay and decide whether
-   * the stream is fully responded — mirrors the SDK's
-   * `_requestToStreamMapping` which outlives connection loss.
-   *
-   * Returning `requestIds` alongside `streamId` lets `send()` skip a
-   * second `getStreamRequestIds` read on the same key.
-   *
-   * O(n) in the number of in-flight POST streams — single-digit in
-   * practice since each stream is cleaned up on its final response.
-   * The `limit` is a defensive ceiling so an abandoned-POST leak can't
-   * unbounded-load this scan; if you hit it, something else has gone
-   * wrong and `send()` will throw `No active stream found`.
-   *
-   * @internal
-   */
-  getStreamForRequestId(requestId: RequestId): Promise<
-    | {
-        streamId: string;
-        requestIds: RequestId[];
-      }
-    | undefined
-  >;
-  /** Read the transport type for this agent.
-   * This relies on the naming scheme being `sse:${sessionId}`,
-   * `streamable-http:${sessionId}`, or `rpc:${sessionId}`.
-   */
-  getTransportType(): BaseTransportType;
-  /** Read the sessionId for this agent.
-   * This relies on the naming scheme being `sse:${sessionId}`
-   * or `streamable-http:${sessionId}`.
-   */
-  getSessionId(): string;
-  /** Get the unique WebSocket. SSE transport only. */
-  getWebSocket(): Connection<unknown> | null;
-  /**
-   * Returns options for configuring the RPC server transport.
-   * Override this method to customize RPC transport behavior (e.g., timeout).
-   *
-   * @example
-   * ```typescript
-   * class MyMCP extends McpAgent {
-   *   protected getRpcTransportOptions() {
-   *     return { timeout: 120000 }; // 2 minutes
-   *   }
-   * }
-   * ```
-   */
-  protected getRpcTransportOptions(): RPCServerTransportOptions;
-  /**
-   * Returns the {@link EventStore} for SSE resumability. Defaults to a
-   * {@link DurableObjectEventStore} backed by this agent's storage,
-   * letting clients reconnect with `Last-Event-ID` after the Cloudflare
-   * edge closes an idle SSE stream (~5 minute watchdog) instead of
-   * relying on a server-side keepalive that would block hibernation.
-   *
-   * Per-stream events are cleared by the transport immediately after
-   * the final response is written to the wire, so there's no
-   * background cleanup — storage cost is bounded by the in-flight
-   * streams alone.
-   *
-   * Override to disable (`return undefined`) or swap implementations.
-   */
-  protected getEventStore(): EventStore | undefined;
-  /** Returns a new transport matching the type of the Agent. */
-  private initTransport;
-  /** Update and store the props */
-  updateProps(props?: Props): Promise<void>;
-  reinitializeServer(): Promise<void>;
-  /** Sets up the MCP transport and server every time the Agent is started.*/
-  onStart(props?: Props): Promise<void>;
-  /** Validates new WebSocket connections. */
-  onConnect(
-    conn: Connection,
-    { request: req }: ConnectionContext
-  ): Promise<void>;
-  /** Handles MCP Messages for the legacy SSE transport. */
-  onSSEMcpMessage(
-    _sessionId: string,
-    messageBody: unknown,
-    extraInfo?: MessageExtraInfo$1
-  ): Promise<Error | null>;
-  /** Elicit user input with a message and schema */
-  elicitInput(
-    params: {
-      message: string;
-      requestedSchema: unknown;
-    },
-    options?: {
-      relatedRequestId?: RequestId;
-    }
-  ): Promise<ElicitResult$1>;
-  /** Handle elicitation responses via in-memory resolver */
-  private _handleElicitationResponse;
-  /**
-   * Handle an RPC message for MCP
-   * This method is called by the RPC stub to process MCP messages
-   * @param message The JSON-RPC message(s) to handle
-   * @returns The response message(s) or undefined
-   */
+type McpRpcAgent = Agent<Cloudflare.Env, unknown, Record<string, unknown>> & {
   handleMcpMessage(
-    message: JSONRPCMessage$1 | JSONRPCMessage$1[]
-  ): Promise<JSONRPCMessage$1 | JSONRPCMessage$1[] | undefined>;
-  /** Return a handler for the given path for this MCP.
-   * Defaults to Streamable HTTP transport.
-   */
-  static serve(
-    path: string,
-    { binding, corsOptions, transport, jurisdiction }?: ServeOptions
-  ): {
-    fetch<Env>(
-      this: void,
-      request: Request,
-      env: Env,
-      ctx: ExecutionContext
-    ): Promise<Response>;
-  };
-  /**
-   * Legacy api
-   **/
-  static mount(
-    path: string,
-    opts?: Omit<ServeOptions, "transport">
-  ): {
-    fetch<Env>(
-      this: void,
-      request: Request,
-      env: Env,
-      ctx: ExecutionContext
-    ): Promise<Response>;
-  };
-  static serveSSE(
-    path: string,
-    opts?: Omit<ServeOptions, "transport">
-  ): {
-    fetch<Env>(
-      this: void,
-      request: Request,
-      env: Env,
-      ctx: ExecutionContext
-    ): Promise<Response>;
-  };
-}
-//#endregion
-//#region src/mcp/rpc.d.ts
-type JSONRPCMessage$2 = JSONRPCMessage$1;
-type MessageExtraInfo$2 = MessageExtraInfo$1;
+    message: JSONRPCMessage | JSONRPCMessage[]
+  ): Promise<JSONRPCMessage | JSONRPCMessage[] | undefined>;
+};
 declare const RPC_DO_PREFIX = "rpc:";
-interface RPCClientTransportOptions<T extends McpAgent = McpAgent> {
+interface RPCClientTransportOptions<T extends McpRpcAgent = McpRpcAgent> {
   namespace: DurableObjectNamespace<T>;
   name: string;
   props?: Record<string, unknown>;
@@ -1511,7 +1019,7 @@ declare class RPCClientTransport implements Transport {
   onclose?: () => void;
   onerror?: (error: Error) => void;
   onmessage?: (message: JSONRPCMessage, extra?: MessageExtraInfo) => void;
-  constructor(options: RPCClientTransportOptions<McpAgent>);
+  constructor(options: RPCClientTransportOptions<McpRpcAgent>);
   setProtocolVersion(version: string): void;
   getProtocolVersion(): string | undefined;
   start(): Promise<void>;
@@ -1521,53 +1029,17 @@ declare class RPCClientTransport implements Transport {
     options?: TransportSendOptions
   ): Promise<void>;
 }
-interface RPCServerTransportOptions {
-  timeout?: number;
+//#endregion
+//#region src/core/events.d.ts
+interface Disposable {
+  dispose(): void;
 }
-declare class RPCServerTransport implements Transport$1 {
-  private _started;
-  private _protocolVersion?;
-  private _timeout;
-  private _pendingRequests;
-  private _pendingContinuations;
-  sessionId?: string;
-  onclose?: () => void;
-  onerror?: (error: Error) => void;
-  onmessage?: (message: JSONRPCMessage$2, extra?: MessageExtraInfo$2) => void;
-  constructor(options?: RPCServerTransportOptions);
-  setProtocolVersion(version: string): void;
-  getProtocolVersion(): string | undefined;
-  start(): Promise<void>;
-  close(): Promise<void>;
-  private _makeTimeout;
-  private _appendPending;
-  private _completePending;
-  private _completeRequest;
-  private _appendRequest;
-  private _completeContinuation;
-  private _appendContinuation;
-  send(
-    message: JSONRPCMessage$2,
-    options?: TransportSendOptions$1
-  ): Promise<void>;
-  /**
-   * @internal Called by McpAgent.handleMcpMessage() — not for external use.
-   *
-   * Wait for the next unmatched send() call that expects a client response or
-   * completes a resumed tool call.
-   *
-   * Used after resolving an elicitation response: the original tool call has
-   * already returned the elicitation request to the RPC client, and the resumed
-   * tool handler will eventually send the final tool result. That final response
-   * has the original tool request id, so there is no active handle() waiter left
-   * for id-based routing; this continuation waiter receives it instead.
-   */
-  _awaitPendingResponse(): Promise<
-    JSONRPCMessage$2 | JSONRPCMessage$2[] | undefined
-  >;
-  handle(
-    message: JSONRPCMessage$2 | JSONRPCMessage$2[]
-  ): Promise<JSONRPCMessage$2 | JSONRPCMessage$2[] | undefined>;
+type Event<T> = (listener: (e: T) => void) => Disposable;
+declare class Emitter<T> implements Disposable {
+  private _listeners;
+  readonly event: Event<T>;
+  fire(data: T): void;
+  dispose(): void;
 }
 //#endregion
 //#region src/mcp/client/connection.d.ts
@@ -2571,7 +2043,7 @@ declare class MCPClientConnection {
    */
   getTransport(
     transportType: BaseTransportType
-  ): StreamableHTTPClientTransport | SSEClientTransport | RPCClientTransport;
+  ): RPCClientTransport | StreamableHTTPClientTransport | SSEClientTransport;
   private tryConnect;
   private _capabilityErrorHandler;
 }
@@ -5089,6 +4561,14 @@ declare class Agent<
   private _lifecycleRouteAddress;
   private _routeLifecycleToRoot;
   private _routeLifecycleToTarget;
+  /**
+   * Serves a browser's request to one of its internal hostnames. Browser
+   * Run's `InternalHostRouter` calls this over RPC; it passes the message to
+   * the `Browser` it names, which runs the host's `fetch`. Built in, so an
+   * Agent needs nothing extra for internal hostnames. Not `@callable`, so
+   * clients can't reach it.
+   */
+  fetchInternalHost(message: InternalHostMessage): Promise<Response>;
   /** Single native-RPC aperture for routed Lifecycle capabilities. */
   _cf_routeLifecycle(
     target: LifecycleRouteAddress | undefined,
@@ -6654,7 +6134,7 @@ declare class Agent<
    * await this.addMcpServer("counter", env.MY_MCP);
    * await this.addMcpServer("counter", env.MY_MCP, { props: { userId: "123" } });
    */
-  addMcpServer<T extends McpAgent>(
+  addMcpServer<T extends McpRpcAgent>(
     serverName: string,
     binding: DurableObjectNamespace<T>,
     options?: AddRpcMcpServerOptions
@@ -6904,20 +6384,16 @@ declare function getAgentByName<
 //#endregion
 export {
   ChatCapableAgentClass as $,
-  RPCServerTransport as $t,
+  RPCClientTransportOptions as $t,
   getCurrentAgent as A,
-  getSubAgentByName as An,
   ElicitRequest$1 as At,
   AgentToolFailure as B,
   MCPConnectionResult as Bt,
   MCPServersState as C,
-  BuildAgentPathOptions as Cn,
   WorkflowInfo as Ct,
   StartFiberResult as D,
-  buildAgentUrl as Dn,
   WorkflowRejectedError as Dt,
   StartFiberOptions as E,
-  buildAgentPath as En,
   WorkflowQueryCriteria as Et,
   AgentToolDisplayMetadata as F,
   MCPClientElicitationHandlers as Ft,
@@ -6934,25 +6410,20 @@ export {
   AgentToolEventDelivery as L,
   MCPClientManagerOptions as Lt,
   AGENT_TOOL_MILESTONE_PART as M,
-  routeSubAgentRequest as Mn,
   MCPAITool as Mt,
   AGENT_TOOL_PROGRESS_PART as N,
-  withInvocationScope as Nn,
   MCPAIToolSet as Nt,
   StateUpdateMessage as O,
-  buildSubAgentPath as On,
   WorkflowStatus as Ot,
   AgentToolChildAdapter as P,
   MCPClientElicitationHandler as Pt,
   AgentToolTerminalStatus as Q,
-  RPCClientTransportOptions as Qt,
+  RPCClientTransport as Qt,
   AgentToolEventMessage as R,
   MCPClientOAuthCallbackConfig as Rt,
   MCPServerMessage as S,
-  AgentPathStep as Sn,
   WorkflowEventPayload as St,
   RPCResponse as T,
-  SubAgentPathMatch as Tn,
   WorkflowProgressCallback as Tt,
   AgentToolMilestone as U,
   MCPServerFilter as Ut,
@@ -6965,84 +6436,74 @@ export {
   AgentToolRunState as Y,
   MCPElicitationHandler as Yt,
   AgentToolStoredChunk as Z,
-  RPCClientTransport as Zt,
+  McpRpcAgent as Zt,
   FiberRecoveryContext as _,
-  WorkerTransportOptions as _n,
   WorkflowCallbackBase as _t,
   routeAgentRequest as a,
-  McpAgent as an,
+  SUB_PREFIX as an,
   isPositionlessAgentToolChunk as at,
   ListFibersOptions as b,
-  DynamicAgentClass as bn,
   WorkflowErrorCallback as bt,
   Agent as c,
-  createMcpHandler$1 as cn,
+  buildAgentUrl as cn,
   AgentWorkflowOrigin as ct,
   AgentStaticOptions as d,
-  CreateMcpHandlerOptions$1 as dn,
+  getSubAgentByName as dn,
   AgentWorkflowStep as dt,
-  RPCServerTransportOptions as en,
+  RPC_DO_PREFIX as en,
   DetachedAgentToolConfig as et,
   DEFAULT_AGENT_STATIC_OPTIONS as f,
-  LegacyMcpHandler as fn,
+  parseSubAgentPath as fn,
   ApprovalEventPayload as ft,
   FiberInspection as g,
-  WorkerTransport as gn,
   WorkflowCallback as gt,
   FiberContext as h,
-  TransportState as hn,
   WaitForApprovalOptions as ht,
   getAgentByName as i,
-  ElicitResult$3 as in,
+  BuildAgentPathOptions as in,
   isAgentToolLifecycleChunk as it,
   routeAgentEmail as j,
-  parseSubAgentPath as jn,
-  ElicitResult$2 as jt,
+  ElicitResult$1 as jt,
   StreamingResponse as k,
-  buildSubAgentPathUnchecked as kn,
   WorkflowTrackingRow as kt,
   AgentContext as l,
-  experimental_createMcpHandler as ln,
+  buildSubAgentPath as ln,
   AgentWorkflowParams as lt,
   EmailRoutingOptions as m,
-  MCPStorageApi as mn,
+  withInvocationScope as mn,
   RunWorkflowOptions as mt,
   AgentOptions as n,
-  ElicitRequest$2 as nn,
+  DynamicAgentStub as nn,
   RunAgentToolOptions as nt,
   AddMcpServerOptions as o,
-  ClearableEventStore as on,
+  SubAgentPathMatch as on,
   AgentWorkflowEvent as ot,
   DeleteFibersOptions as p,
-  createLegacyMcpHandler as pn,
+  routeSubAgentRequest as pn,
   DefaultProgress as pt,
   AgentToolRunInspection as q,
   getNamespacedData as qt,
   RoutingRetryOptions as r,
-  ElicitRequestSchema as rn,
+  AgentPathStep as rn,
   RunAgentToolResult as rt,
   AddRpcMcpServerOptions as s,
-  DurableObjectEventStore as sn,
+  buildAgentPath as sn,
   AgentWorkflowInternalParams as st,
   AgentGetOptions as t,
-  RPC_DO_PREFIX as tn,
+  DynamicAgentClass as tn,
   DetachedRunAgentToolResult as tt,
   AgentNamespace as u,
-  CreateLegacyMcpHandlerOptions as un,
+  buildSubAgentPathUnchecked as un,
   AgentWorkflowPathStep as ut,
   FiberRecoveryResult as v,
-  SSEEdgeClientTransport as vn,
   WorkflowCallbackType as vt,
   RPCRequest as w,
-  SUB_PREFIX as wn,
   WorkflowPage as wt,
   MCPServer as x,
-  DynamicAgentStub as xn,
   WorkflowEventCallback as xt,
   FiberStatus as y,
-  StreamableHTTPEdgeClientTransport as yn,
   WorkflowCompleteCallback as yt,
   AgentToolEventState as z,
   MCPClientOAuthResult as zt
 };
-//# sourceMappingURL=agent-routing-CDbpVjYq.d.ts.map
+//# sourceMappingURL=agent-routing-wS1TimZ_.d.ts.map