agents 0.0.0-ed3f94d → 0.0.0-edd3357

package/dist/{client-DVoPb3-C.d.ts → client-CvaJdLQA.d.ts}

@@ -16,7 +16,6 @@ import {
   GetPromptRequest
 } from "@modelcontextprotocol/sdk/types.js";
 import { ToolSet } from "ai";
-import { M as MCPObservabilityEvent } from "./mcp-BH1fJeiU.js";
 import {
   SSEClientTransport,
   SSEClientTransportOptions
@@ -27,11 +26,6 @@ import {
 } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { AgentsOAuthProvider } from "./mcp/do-oauth-client-provider.js";
 
-interface Disposable {
-  dispose(): void;
-}
-type Event<T> = (listener: (e: T) => void) => Disposable;
-
 declare class SSEEdgeClientTransport extends SSEClientTransport {
   private authProvider;
   /**
@@ -60,38 +54,14 @@ declare class StreamableHTTPEdgeClientTransport extends StreamableHTTPClientTran
   >;
 }
 
-type MaybePromise<T> = T | Promise<T>;
-type BaseTransportType = "sse" | "streamable-http";
-type TransportType = BaseTransportType | "auto";
-interface CORSOptions {
-  origin?: string;
-  methods?: string;
-  headers?: string;
-  maxAge?: number;
-  exposeHeaders?: string;
-}
-interface ServeOptions {
-  binding?: string;
-  corsOptions?: CORSOptions;
-  transport?: BaseTransportType;
-}
-
-/**
- * Connection state for MCP client connections
- */
-type MCPConnectionState =
-  | "authenticating"
-  | "connecting"
-  | "ready"
-  | "discovering"
-  | "failed";
 type MCPTransportOptions = (
   | SSEClientTransportOptions
   | StreamableHTTPClientTransportOptions
 ) & {
   authProvider?: AgentsOAuthProvider;
-  type?: TransportType;
+  type?: "sse" | "streamable-http" | "auto";
 };
+type TransportType = Exclude<MCPTransportOptions["type"], "auto">;
 declare class MCPClientConnection {
   url: URL;
   options: {
@@ -99,16 +69,18 @@ declare class MCPClientConnection {
     client: ConstructorParameters<typeof Client>[1];
   };
   client: Client;
-  connectionState: MCPConnectionState;
-  lastConnectedTransport: BaseTransportType | undefined;
+  connectionState:
+    | "authenticating"
+    | "connecting"
+    | "ready"
+    | "discovering"
+    | "failed";
   instructions?: string;
   tools: Tool[];
   prompts: Prompt[];
   resources: Resource[];
   resourceTemplates: ResourceTemplate[];
   serverCapabilities: ServerCapabilities | undefined;
-  private readonly _onObservabilityEvent;
-  readonly onObservabilityEvent: Event<MCPObservabilityEvent>;
   constructor(
     url: URL,
     info: ConstructorParameters<typeof Client>[0],
@@ -120,27 +92,10 @@ declare class MCPClientConnection {
   /**
    * Initialize a client connection
    *
+   * @param code Optional OAuth code to initialize the connection with if auth hasn't been initialized
    * @returns
    */
-  init(): Promise<void>;
-  /**
-   * Finish OAuth by probing transports based on configured type.
-   * - Explicit: finish on that transport
-   * - Auto: try streamable-http, then sse on 404/405/Not Implemented
-   */
-  private finishAuthProbe;
-  /**
-   * Complete OAuth authorization
-   */
-  completeAuthorization(code: string): Promise<void>;
-  /**
-   * Establish connection after successful authorization
-   */
-  establishConnection(): Promise<void>;
-  /**
-   * Discover server capabilities and register tools, resources, prompts, and templates
-   */
-  private discoverAndRegister;
+  init(code?: string): Promise<void>;
   /**
    * Notification handler registration
    */
@@ -175,12 +130,12 @@ declare class MCPClientConnection {
           }
         | undefined;
       description?: string | undefined;
-      title?: string | undefined;
       _meta?:
         | {
             [x: string]: unknown;
           }
         | undefined;
+      title?: string | undefined;
       annotations?:
         | {
             [x: string]: unknown;
@@ -207,12 +162,12 @@ declare class MCPClientConnection {
       name: string;
       uri: string;
       description?: string | undefined;
-      title?: string | undefined;
       _meta?:
         | {
             [x: string]: unknown;
           }
         | undefined;
+      title?: string | undefined;
       icons?:
         | {
             [x: string]: unknown;
@@ -229,12 +184,12 @@ declare class MCPClientConnection {
       [x: string]: unknown;
       name: string;
       description?: string | undefined;
-      title?: string | undefined;
       _meta?:
         | {
             [x: string]: unknown;
           }
         | undefined;
+      title?: string | undefined;
       icons?:
         | {
             [x: string]: unknown;
@@ -259,12 +214,12 @@ declare class MCPClientConnection {
       name: string;
       uriTemplate: string;
       description?: string | undefined;
-      title?: string | undefined;
       _meta?:
         | {
             [x: string]: unknown;
           }
         | undefined;
+      title?: string | undefined;
       mimeType?: string | undefined;
     }[]
   >;
@@ -279,22 +234,14 @@ declare class MCPClientConnection {
    * @returns The transport for the client
    */
   getTransport(
-    transportType: BaseTransportType
+    transportType: TransportType
   ): SSEEdgeClientTransport | StreamableHTTPEdgeClientTransport;
-  private tryConnect;
-  private _capabilityErrorHandler;
+  tryConnect(
+    transportType: MCPTransportOptions["type"],
+    code?: string
+  ): Promise<void>;
 }
 
-type MCPClientOAuthCallbackConfig = {
-  successRedirect?: string;
-  errorRedirect?: string;
-  customHandler?: (result: MCPClientOAuthResult) => Response;
-};
-type MCPClientOAuthResult = {
-  serverId: string;
-  authSuccess: boolean;
-  authError?: string;
-};
 /**
  * Utility class that aggregates multiple MCP clients into one
  */
@@ -304,12 +251,6 @@ declare class MCPClientManager {
   mcpConnections: Record<string, MCPClientConnection>;
   private _callbackUrls;
   private _didWarnAboutUnstableGetAITools;
-  private _oauthCallbackConfig?;
-  private _connectionDisposables;
-  private readonly _onObservabilityEvent;
-  readonly onObservabilityEvent: Event<MCPObservabilityEvent>;
-  private readonly _onConnected;
-  readonly onConnected: Event<string>;
   /**
    * @param _name Name of the MCP client
    * @param _version Version of the MCP Client
@@ -340,44 +281,9 @@ declare class MCPClientManager {
     clientId?: string;
   }>;
   isCallbackRequest(req: Request): boolean;
-  handleCallbackRequest(req: Request): Promise<
-    | {
-        serverId: string;
-        authSuccess: boolean;
-        authError?: undefined;
-      }
-    | {
-        serverId: string;
-        authSuccess: boolean;
-        authError: string;
-      }
-  >;
-  /**
-   * Establish connection in the background after OAuth completion
-   * This method is called asynchronously and doesn't block the OAuth callback response
-   * @param serverId The server ID to establish connection for
-   */
-  establishConnection(serverId: string): Promise<void>;
-  /**
-   * Register a callback URL for OAuth handling
-   * @param url The callback URL to register
-   */
-  registerCallbackUrl(url: string): void;
-  /**
-   * Unregister a callback URL
-   * @param serverId The server ID whose callback URL should be removed
-   */
-  unregisterCallbackUrl(serverId: string): void;
-  /**
-   * Configure OAuth callback handling
-   * @param config OAuth callback configuration
-   */
-  configureOAuthCallback(config: MCPClientOAuthCallbackConfig): void;
-  /**
-   * Get the current OAuth callback configuration
-   * @returns The current OAuth callback configuration
-   */
-  getOAuthCallbackConfig(): MCPClientOAuthCallbackConfig | undefined;
+  handleCallbackRequest(req: Request): Promise<{
+    serverId: string;
+  }>;
   /**
    * @returns namespaced list of tools
    */
@@ -394,16 +300,12 @@ declare class MCPClientManager {
   /**
    * Closes all connections to MCP servers
    */
-  closeAllConnections(): Promise<void>;
+  closeAllConnections(): Promise<void[]>;
   /**
    * Closes a connection to an MCP server
    * @param id The id of the connection to close
    */
   closeConnection(id: string): Promise<void>;
-  /**
-   * Dispose the manager and all resources.
-   */
-  dispose(): Promise<void>;
   /**
    * @returns namespaced list of prompts
    */
@@ -5106,15 +5008,8 @@ declare function getNamespacedData<T extends keyof NamespacedData>(
 ): NamespacedData[T];
 
 export {
-  type BaseTransportType as B,
-  type MaybePromise as M,
-  type ServeOptions as S,
-  type TransportType as T,
-  SSEEdgeClientTransport as a,
-  StreamableHTTPEdgeClientTransport as b,
-  type MCPClientOAuthResult as c,
-  type MCPClientOAuthCallbackConfig as d,
-  MCPClientManager as e,
-  type MCPConnectionState as f,
+  MCPClientManager as M,
+  SSEEdgeClientTransport as S,
+  StreamableHTTPEdgeClientTransport as a,
   getNamespacedData as g
 };

package/dist/client.js

@@ -3,8 +3,7 @@ import {
   agentFetch,
   camelCaseToKebabCase
 } from "./chunk-QEVM4BVL.js";
-import "./chunk-BER7KXUJ.js";
-import "./chunk-PR4QN5HX.js";
+import "./chunk-AVYJQSLW.js";
 export {
   AgentClient,
   agentFetch,

package/dist/index.d.ts

@@ -8,17 +8,12 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 import { Server, Connection, PartyServerOptions } from "partyserver";
 export { Connection, ConnectionContext, WSMessage } from "partyserver";
-import {
-  e as MCPClientManager,
-  T as TransportType,
-  f as MCPConnectionState
-} from "./client-DVoPb3-C.js";
+import { M as MCPClientManager } from "./client-CvaJdLQA.js";
 import { Observability } from "./observability/index.js";
 import { MessageType } from "./ai-types.js";
 import "zod";
 import "@modelcontextprotocol/sdk/shared/protocol.js";
 import "ai";
-import "./mcp-BH1fJeiU.js";
 import "@modelcontextprotocol/sdk/client/sse.js";
 import "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import "./mcp/do-oauth-client-provider.js";
@@ -129,7 +124,6 @@ type Schedule<T = string> = {
       cron: string;
     }
 );
-
 /**
  * MCP Server state update message from server -> Client
  */
@@ -149,7 +143,7 @@ type MCPServer = {
   name: string;
   server_url: string;
   auth_url: string | null;
-  state: MCPConnectionState;
+  state: "authenticating" | "connecting" | "ready" | "discovering" | "failed";
   instructions: string | null;
   capabilities: ServerCapabilities | null;
 };
@@ -172,9 +166,8 @@ declare class Agent<
   Props extends Record<string, unknown> = Record<string, unknown>
 > extends Server<Env, Props> {
   private _state;
-  private _disposables;
   private _ParentClass;
-  readonly mcp: MCPClientManager;
+  mcp: MCPClientManager;
   /**
    * Initial state for the Agent
    * Override to provide default state values
@@ -351,40 +344,55 @@ declare class Agent<
   /**
    * Connect to a new MCP Server
    *
-   * @param serverName Name of the MCP server
    * @param url MCP Server SSE URL
-   * @param callbackHost Base host for the agent, used for the redirect URI. If not provided, will be derived from the current request.
+   * @param callbackHost Base host for the agent, used for the redirect URI.
    * @param agentsPrefix agents routing prefix if not using `agents`
-   * @param options MCP client and transport options
+   * @param options MCP client and transport (header) options
    * @returns authUrl
    */
   addMcpServer(
     serverName: string,
     url: string,
-    callbackHost?: string,
+    callbackHost: string,
     agentsPrefix?: string,
     options?: {
       client?: ConstructorParameters<typeof Client>[1];
+      transport?: {
+        headers: HeadersInit;
+      };
+    }
+  ): Promise<{
+    id: string;
+    authUrl: string | undefined;
+  }>;
+  _connectToMcpServerInternal(
+    _serverName: string,
+    url: string,
+    callbackUrl: string,
+    options?: {
+      client?: ConstructorParameters<typeof Client>[1];
+      /**
+       * We don't expose the normal set of transport options because:
+       * 1) we can't serialize things like the auth provider or a fetch function into the DB for reconnection purposes
+       * 2) We probably want these options to be agnostic to the transport type (SSE vs Streamable)
+       *
+       * This has the limitation that you can't override fetch, but I think headers should handle nearly all cases needed (i.e. non-standard bearer auth).
+       */
       transport?: {
         headers?: HeadersInit;
-        type?: TransportType;
       };
+    },
+    reconnect?: {
+      id: string;
+      oauthClientId?: string;
     }
   ): Promise<{
     id: string;
     authUrl: string | undefined;
+    clientId: string | undefined;
   }>;
-  private _connectToMcpServerInternal;
   removeMcpServer(id: string): Promise<void>;
   getMcpServers(): MCPServersState;
-  private broadcastMcpServers;
-  /**
-   * Handle OAuth callback response using MCPClientManager configuration
-   * @param result OAuth callback result
-   * @param request The original request (needed for base URL)
-   * @returns Response for the OAuth callback
-   */
-  private handleOAuthCallbackResponse;
 }
 /**
  * Namespace for creating Agent instances
@@ -544,7 +552,6 @@ export {
   type Schedule,
   type StateUpdateMessage,
   StreamingResponse,
-  TransportType,
   callable,
   createAddressBasedEmailResolver,
   createCatchAllEmailResolver,

package/dist/index.js

@@ -10,12 +10,11 @@ import {
   routeAgentEmail,
   routeAgentRequest,
   unstable_callable
-} from "./chunk-254F4GDT.js";
-import "./chunk-3OT2NNEW.js";
-import "./chunk-Z44WASMA.js";
+} from "./chunk-YDUDMOL6.js";
+import "./chunk-MH46VMM4.js";
+import "./chunk-LL2AFX7V.js";
 import "./chunk-QEVM4BVL.js";
-import "./chunk-BER7KXUJ.js";
-import "./chunk-PR4QN5HX.js";
+import "./chunk-AVYJQSLW.js";
 export {
   Agent,
   StreamingResponse,

package/dist/mcp/client.d.ts

@@ -3,8 +3,7 @@ import '@modelcontextprotocol/sdk/client/index.js';
 import '@modelcontextprotocol/sdk/shared/protocol.js';
 import '@modelcontextprotocol/sdk/types.js';
 import 'ai';
-export { e as MCPClientManager, d as MCPClientOAuthCallbackConfig, c as MCPClientOAuthResult, g as getNamespacedData } from '../client-DVoPb3-C.js';
-import '../mcp-BH1fJeiU.js';
+export { M as MCPClientManager, g as getNamespacedData } from '../client-CvaJdLQA.js';
 import '@modelcontextprotocol/sdk/client/sse.js';
 import '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import './do-oauth-client-provider.js';

package/dist/mcp/client.js

@@ -1,8 +1,7 @@
 import {
   MCPClientManager,
   getNamespacedData
-} from "../chunk-3OT2NNEW.js";
-import "../chunk-PR4QN5HX.js";
+} from "../chunk-MH46VMM4.js";
 export {
   MCPClientManager,
   getNamespacedData

package/dist/mcp/do-oauth-client-provider.js

@@ -1,7 +1,6 @@
 import {
   DurableObjectOAuthClientProvider
-} from "../chunk-Z44WASMA.js";
-import "../chunk-PR4QN5HX.js";
+} from "../chunk-LL2AFX7V.js";
 export {
   DurableObjectOAuthClientProvider
 };

package/dist/mcp/index.d.ts

@@ -2,14 +2,12 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { JSONRPCMessage, ElicitResult } from '@modelcontextprotocol/sdk/types.js';
 export { ElicitRequest, ElicitRequestSchema, ElicitResult } from '@modelcontextprotocol/sdk/types.js';
-import { Agent } from '../index.js';
-import { M as MaybePromise, B as BaseTransportType, S as ServeOptions } from '../client-DVoPb3-C.js';
-export { d as MCPClientOAuthCallbackConfig, c as MCPClientOAuthResult, a as SSEEdgeClientTransport, b as StreamableHTTPEdgeClientTransport } from '../client-DVoPb3-C.js';
-import { Connection, ConnectionContext } from 'partyserver';
+import { Agent, AgentContext } from '../index.js';
+export { S as SSEEdgeClientTransport, a as StreamableHTTPEdgeClientTransport } from '../client-CvaJdLQA.js';
+import { Connection, ConnectionContext, WSMessage } from 'partyserver';
 import 'cloudflare:workers';
 import '@modelcontextprotocol/sdk/client/index.js';
 import '../observability/index.js';
-import '../mcp-BH1fJeiU.js';
 import '../ai-types.js';
 import 'ai';
 import 'zod';
@@ -20,34 +18,54 @@ import './do-oauth-client-provider.js';
 import '@modelcontextprotocol/sdk/client/auth.js';
 import '@modelcontextprotocol/sdk/shared/auth.js';
 
+type MaybePromise<T> = T | Promise<T>;
+type TransportType = "sse" | "streamable-http";
+interface CORSOptions {
+    origin?: string;
+    methods?: string;
+    headers?: string;
+    maxAge?: number;
+    exposeHeaders?: string;
+}
+interface ServeOptions {
+    binding?: string;
+    corsOptions?: CORSOptions;
+    transport?: TransportType;
+}
+
 declare abstract class McpAgent<Env = unknown, State = unknown, Props extends Record<string, unknown> = Record<string, unknown>> extends Agent<Env, State, Props> {
     private _transport?;
+    private _requestIdToConnectionId;
+    private _standaloneSseConnectionId?;
     props?: Props;
     abstract server: MaybePromise<McpServer | Server>;
     abstract init(): Promise<void>;
+    constructor(ctx: AgentContext, env: Env);
     setInitializeRequest(initializeRequest: JSONRPCMessage): Promise<void>;
     getInitializeRequest(): Promise<JSONRPCMessage | undefined>;
     /** Read the transport type for this agent.
      * This relies on the naming scheme being `sse:${sessionId}`
      * or `streamable-http:${sessionId}`.
      */
-    getTransportType(): BaseTransportType;
-    /** Read the sessionId for this agent.
-     * This relies on the naming scheme being `sse:${sessionId}`
-     * or `streamable-http:${sessionId}`.
-     */
-    getSessionId(): string;
+    getTransportType(): TransportType;
+    /** Get the WebSocket for the standalone SSE if any. Streamable HTTP only. */
+    private getWebSocketForStandaloneSse;
     /** Get the unique WebSocket. SSE transport only. */
     private getWebSocket;
+    /** Get the corresponding WebSocket for a responseId. Streamable HTTP only. */
+    private getWebSocketForResponseID;
     /** 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>;
+    onConnect(conn: Connection, _: ConnectionContext): Promise<void>;
+    /** Handles MCP Messages for Streamable HTTP. */
+    onMessage(connection: Connection, event: WSMessage): Promise<void>;
+    /** Remove clients from our cache when they disconnect */
+    onClose(conn: Connection, _code: number, _reason: string, _wasClean: boolean): Promise<void>;
     /** Handles MCP Messages for the legacy SSE transport. */
     onSSEMcpMessage(_sessionId: string, messageBody: unknown): Promise<Error | null>;
     /** Elicit user input with a message and schema */