agents 0.0.0-cec3cca → 0.0.0-cf3b3d7

package/dist/{client-Csp_m13H.d.ts → client-BaCHMay9.d.ts}

@@ -1,6 +1,18 @@
 import { t as MCPObservabilityEvent } from "./mcp-Dw5vDrY8.js";
-import { t as AgentsOAuthProvider } from "./do-oauth-client-provider-DGc5pP0l.js";
+import {
+  i as MCPServerRow,
+  r as MCPClientStorage,
+  t as AgentsOAuthProvider
+} from "./do-oauth-client-provider-CnbnngL2.js";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import {
+  SSEClientTransport,
+  SSEClientTransportOptions
+} from "@modelcontextprotocol/sdk/client/sse.js";
+import {
+  StreamableHTTPClientTransport,
+  StreamableHTTPClientTransportOptions
+} from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import {
   CallToolRequest,
   CallToolResultSchema,
@@ -15,14 +27,6 @@ import {
   ServerCapabilities,
   Tool
 } from "@modelcontextprotocol/sdk/types.js";
-import {
-  SSEClientTransport,
-  SSEClientTransportOptions
-} from "@modelcontextprotocol/sdk/client/sse.js";
-import {
-  StreamableHTTPClientTransport,
-  StreamableHTTPClientTransportOptions
-} from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import * as ai0 from "ai";
 import { ToolSet } from "ai";
 import * as zod0 from "zod";
@@ -32,40 +36,10 @@ import { RequestOptions } from "@modelcontextprotocol/sdk/shared/protocol.js";
 interface Disposable {
   dispose(): void;
 }
-type Event<T$1> = (listener: (e: T$1) => void) => Disposable;
-//#endregion
-//#region src/mcp/sse-edge.d.ts
-declare class SSEEdgeClientTransport extends SSEClientTransport {
-  private authProvider;
-  /**
-   * Creates a new EdgeSSEClientTransport, which overrides fetch to be compatible with the CF workers environment
-   */
-  constructor(url: URL, options: SSEClientTransportOptions);
-  authHeaders(): Promise<
-    | {
-        Authorization: string;
-      }
-    | undefined
-  >;
-}
-//#endregion
-//#region src/mcp/streamable-http-edge.d.ts
-declare class StreamableHTTPEdgeClientTransport extends StreamableHTTPClientTransport {
-  private authProvider;
-  /**
-   * Creates a new StreamableHTTPEdgeClientTransport, which overrides fetch to be compatible with the CF workers environment
-   */
-  constructor(url: URL, options: StreamableHTTPClientTransportOptions);
-  authHeaders(): Promise<
-    | {
-        Authorization: string;
-      }
-    | undefined
-  >;
-}
+type Event<T> = (listener: (e: T) => void) => Disposable;
 //#endregion
 //#region src/mcp/types.d.ts
-type MaybePromise<T$1> = T$1 | Promise<T$1>;
+type MaybePromise<T> = T | Promise<T>;
 type BaseTransportType = "sse" | "streamable-http";
 type TransportType = BaseTransportType | "auto";
 interface CORSOptions {
@@ -84,13 +58,43 @@ interface ServeOptions {
 //#endregion
 //#region src/mcp/client-connection.d.ts
 /**
- * Connection state for MCP client connections
+ * Connection state machine for MCP client connections.
+ *
+ * State transitions:
+ * - Non-OAuth: init() → "connecting" → "discovering" → "ready"
+ * - OAuth: init() → "authenticating" → (callback) → "connecting" → "discovering" → "ready"
+ * - Any state can transition to "failed" on error
  */
 type MCPConnectionState =
+  /**
+   * Waiting for OAuth authorization to complete.
+   * Server requires OAuth and user must complete the authorization flow.
+   * Next state: "connecting" (after handleCallbackRequest + establishConnection)
+   */
   | "authenticating"
+  /**
+   * Establishing transport connection to MCP server.
+   * OAuth (if required) is complete, now connecting to the actual MCP endpoint.
+   * Next state: "discovering" (after transport connected)
+   */
   | "connecting"
+  /**
+   * Fully connected and ready to use.
+   * Tools, resources, and prompts have been discovered and registered.
+   * This is the terminal success state.
+   */
   | "ready"
+  /**
+   * Discovering server capabilities (tools, resources, prompts).
+   * Transport is connected, now fetching available capabilities via MCP protocol.
+   * Next state: "ready" (after capabilities fetched)
+   */
   | "discovering"
+  /**
+   * Connection failed at some point.
+   * Check observability events for error details.
+   * This is a terminal error state.
+   */
   | "failed";
 type MCPTransportOptions = (
   | SSEClientTransportOptions
@@ -295,12 +299,51 @@ declare class MCPClientConnection {
    */
   getTransport(
     transportType: BaseTransportType
-  ): StreamableHTTPEdgeClientTransport | SSEEdgeClientTransport;
+  ): StreamableHTTPClientTransport | SSEClientTransport;
   private tryConnect;
   private _capabilityErrorHandler;
 }
 //#endregion
 //#region src/mcp/client.d.ts
+/**
+ * Options that can be stored in the server_options column
+ * This is what gets JSON.stringify'd and stored in the database
+ */
+type MCPServerOptions = {
+  client?: ConstructorParameters<typeof Client>[1];
+  transport?: {
+    headers?: HeadersInit;
+    type?: TransportType;
+  };
+};
+/**
+ * Options for registering an MCP server
+ */
+type RegisterServerOptions = {
+  url: string;
+  name: string;
+  callbackUrl: string;
+  client?: ConstructorParameters<typeof Client>[1];
+  transport?: MCPTransportOptions;
+  authUrl?: string;
+  clientId?: string;
+};
+/**
+ * Result of attempting to connect to an MCP server.
+ * Returns the current connection state after the operation.
+ *
+ * - "ready": Connection established and ready to use (non-OAuth)
+ * - "authenticating": OAuth required, user must visit authUrl to authorize
+ */
+type MCPConnectionResult =
+  | {
+      state: "ready";
+    }
+  | {
+      state: "authenticating";
+      authUrl: string;
+      clientId?: string;
+    };
 type MCPClientOAuthCallbackConfig = {
   successRedirect?: string;
   errorRedirect?: string;
@@ -311,6 +354,9 @@ type MCPClientOAuthResult = {
   authSuccess: boolean;
   authError?: string;
 };
+type MCPClientManagerOptions = {
+  storage: MCPClientStorage;
+};
 /**
  * Utility class that aggregates multiple MCP clients into one
  */
@@ -318,27 +364,51 @@ declare class MCPClientManager {
   private _name;
   private _version;
   mcpConnections: Record<string, MCPClientConnection>;
-  private _callbackUrls;
   private _didWarnAboutUnstableGetAITools;
   private _oauthCallbackConfig?;
   private _connectionDisposables;
+  private _storage;
+  private _isRestored;
   private readonly _onObservabilityEvent;
   readonly onObservabilityEvent: Event<MCPObservabilityEvent>;
-  private readonly _onConnected;
-  readonly onConnected: Event<string>;
+  private readonly _onServerStateChanged;
+  /**
+   * Event that fires whenever any MCP server state changes (registered, connected, removed, etc.)
+   * This is useful for broadcasting server state to clients.
+   */
+  readonly onServerStateChanged: Event<void>;
   /**
    * @param _name Name of the MCP client
    * @param _version Version of the MCP Client
-   * @param auth Auth paramters if being used to create a DurableObjectOAuthClientProvider
+   * @param options Storage adapter for persisting MCP server state
    */
-  constructor(_name: string, _version: string);
+  constructor(
+    _name: string,
+    _version: string,
+    options: MCPClientManagerOptions
+  );
   jsonSchema: typeof ai0.jsonSchema | undefined;
+  /**
+   * Create an auth provider for a server
+   * @internal
+   */
+  private createAuthProvider;
+  /**
+   * Restore MCP server connections from storage
+   * This method is called on Agent initialization to restore previously connected servers
+   *
+   * @param clientName Name to use for OAuth client (typically the agent instance name)
+   */
+  restoreConnectionsFromStorage(clientName: string): Promise<void>;
   /**
    * Connect to and register an MCP server
    *
-   * @param transportConfig Transport config
-   * @param clientConfig Client config
-   * @param capabilities Client capabilities (i.e. if the client supports roots/sampling)
+   * @deprecated This method is maintained for backward compatibility.
+   * For new code, use registerServer() and connectToServer() separately.
+   *
+   * @param url Server URL
+   * @param options Connection options
+   * @returns Object with server ID, auth URL (if OAuth), and client ID (if OAuth)
    */
   connect(
     url: string,
@@ -356,17 +426,47 @@ declare class MCPClientManager {
     authUrl?: string;
     clientId?: string;
   }>;
-  isCallbackRequest(req: Request): boolean;
+  /**
+   * Create an in-memory connection object and set up observability
+   * Does NOT save to storage - use registerServer() for that
+   */
+  private createConnection;
+  /**
+   * Register an MCP server connection without connecting
+   * Creates the connection object, sets up observability, and saves to storage
+   *
+   * @param id Server ID
+   * @param options Registration options including URL, name, callback URL, and connection config
+   * @returns Server ID
+   */
+  registerServer(id: string, options: RegisterServerOptions): Promise<string>;
+  /**
+   * Connect to an already registered MCP server and initialize the connection.
+   *
+   * For OAuth servers, this returns `{ state: "authenticating", authUrl, clientId? }`
+   * without establishing the connection. The user must complete the OAuth flow via
+   * the authUrl, which will trigger a callback handled by `handleCallbackRequest()`.
+   *
+   * For non-OAuth servers, this establishes the connection immediately and returns
+   * `{ state: "ready" }`.
+   *
+   * Updates storage with auth URL and client ID after connection.
+   *
+   * @param id Server ID (must be registered first via registerServer())
+   * @returns Connection result with current state and OAuth info (if applicable)
+   */
+  connectToServer(id: string): Promise<MCPConnectionResult>;
+  isCallbackRequest(req: Request): Promise<boolean>;
   handleCallbackRequest(req: Request): Promise<
     | {
         serverId: string;
         authSuccess: boolean;
-        authError?: undefined;
+        authError: string;
       }
     | {
         serverId: string;
         authSuccess: boolean;
-        authError: string;
+        authError?: undefined;
       }
   >;
   /**
@@ -375,16 +475,6 @@ declare class MCPClientManager {
    * @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
@@ -399,6 +489,18 @@ declare class MCPClientManager {
    * @returns namespaced list of tools
    */
   listTools(): NamespacedData["tools"];
+  /**
+   * Lazy-loads the jsonSchema function from the AI SDK.
+   *
+   * This defers importing the "ai" package until it's actually needed, which helps reduce
+   * initial bundle size and startup time. The jsonSchema function is required for converting
+   * MCP tools into AI SDK tool definitions via getAITools().
+   *
+   * @internal This method is for internal use only. It's automatically called before operations
+   * that need jsonSchema (like getAITools() or OAuth flows). External consumers should not need
+   * to call this directly.
+   */
+  ensureJsonSchema(): Promise<void>;
   /**
    * @returns a set of tools that you can use with the AI SDK
    */
@@ -417,6 +519,14 @@ declare class MCPClientManager {
    * @param id The id of the connection to close
    */
   closeConnection(id: string): Promise<void>;
+  /**
+   * Remove an MCP server from storage
+   */
+  removeServer(serverId: string): Promise<void>;
+  /**
+   * List all MCP servers from storage
+   */
+  listServers(): Promise<MCPServerRow[]>;
   /**
    * Dispose the manager and all resources.
    */
@@ -5293,23 +5403,25 @@ type NamespacedData = {
     serverId: string;
   })[];
 };
-declare function getNamespacedData<T$1 extends keyof NamespacedData>(
+declare function getNamespacedData<T extends keyof NamespacedData>(
   mcpClients: Record<string, MCPClientConnection>,
-  type: T$1
-): NamespacedData[T$1];
+  type: T
+): NamespacedData[T];
 //#endregion
 export {
-  MCPConnectionState as a,
-  MaybePromise as c,
-  StreamableHTTPEdgeClientTransport as d,
-  SSEEdgeClientTransport as f,
-  getNamespacedData as i,
-  ServeOptions as l,
-  MCPClientOAuthCallbackConfig as n,
-  BaseTransportType as o,
-  MCPClientOAuthResult as r,
-  CORSOptions as s,
+  MCPConnectionResult as a,
+  getNamespacedData as c,
+  CORSOptions as d,
+  MaybePromise as f,
+  MCPClientOAuthResult as i,
+  MCPConnectionState as l,
+  TransportType as m,
+  MCPClientManagerOptions as n,
+  MCPServerOptions as o,
+  ServeOptions as p,
+  MCPClientOAuthCallbackConfig as r,
+  RegisterServerOptions as s,
   MCPClientManager as t,
-  TransportType as u
+  BaseTransportType as u
 };
-//# sourceMappingURL=client-Csp_m13H.d.ts.map
+//# sourceMappingURL=client-BaCHMay9.d.ts.map