agents 0.0.0-979394a → 0.0.0-9dbe072

package/dist/mcp/client.d.ts

@@ -1,14 +1,22 @@
 import * as zod from 'zod';
-import { Tool, Prompt, Resource, ResourceTemplate, ServerCapabilities, ClientCapabilities, CallToolRequest, CallToolResultSchema, CompatibilityCallToolResultSchema, ReadResourceRequest, GetPromptRequest } from '@modelcontextprotocol/sdk/types.js';
+import { ClientCapabilities, Tool, Prompt, Resource, ResourceTemplate, ServerCapabilities, CallToolRequest, CallToolResultSchema, CompatibilityCallToolResultSchema, ReadResourceRequest, GetPromptRequest } from '@modelcontextprotocol/sdk/types.js';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { SSEClientTransportOptions } from '@modelcontextprotocol/sdk/client/sse.js';
+import { AgentsOAuthProvider } from './do-oauth-client-provider.js';
 import { RequestOptions } from '@modelcontextprotocol/sdk/shared/protocol.js';
-import { OAuthClientProvider } from '@modelcontextprotocol/sdk/client/auth.js';
+import { ToolSet } from 'ai';
+import '@modelcontextprotocol/sdk/client/auth.js';
+import '@modelcontextprotocol/sdk/shared/auth.js';
 
 declare class MCPClientConnection {
     url: URL;
-    private info;
-    private options;
+    options: {
+        transport: SSEClientTransportOptions & {
+            authProvider?: AgentsOAuthProvider;
+        };
+        client: ConstructorParameters<typeof Client>[1];
+        capabilities: ClientCapabilities;
+    };
     client: Client;
     connectionState: "authenticating" | "connecting" | "ready" | "discovering" | "failed";
     instructions?: string;
@@ -18,7 +26,9 @@ declare class MCPClientConnection {
     resourceTemplates: ResourceTemplate[];
     serverCapabilities: ServerCapabilities | undefined;
     constructor(url: URL, info: ConstructorParameters<typeof Client>[0], options?: {
-        transport: SSEClientTransportOptions;
+        transport: SSEClientTransportOptions & {
+            authProvider?: AgentsOAuthProvider;
+        };
         client: ConstructorParameters<typeof Client>[1];
         capabilities: ClientCapabilities;
     });
@@ -50,8 +60,8 @@ declare class MCPClientConnection {
     }[]>;
     fetchResources(): Promise<{
         [x: string]: unknown;
-        name: string;
         uri: string;
+        name: string;
         mimeType?: string | undefined;
         description?: string | undefined;
     }[]>;
@@ -75,28 +85,20 @@ declare class MCPClientConnection {
     }[]>;
 }
 
-interface AgentsOAuthProvider extends OAuthClientProvider {
-    authUrl: string | undefined;
-    clientId: string | undefined;
-}
-
 /**
  * Utility class that aggregates multiple MCP clients into one
  */
 declare class MCPClientManager {
     private name;
     private version;
-    private auth?;
     mcpConnections: Record<string, MCPClientConnection>;
+    private callbackUrls;
     /**
      * @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
      */
-    constructor(name: string, version: string, auth?: {
-        baseCallbackUri: string;
-        storage: DurableObjectStorage;
-    } | undefined);
+    constructor(name: string, version: string);
     /**
      * Connect to and register an MCP server
      *
@@ -104,14 +106,14 @@ declare class MCPClientManager {
      * @param clientConfig Client config
      * @param capabilities Client capabilities (i.e. if the client supports roots/sampling)
      */
-    connect(url: string, opts?: {
+    connect(url: string, options?: {
         reconnect?: {
             id: string;
             oauthClientId?: string;
             oauthCode?: string;
         };
         transport?: SSEClientTransportOptions & {
-            authProvider: AgentsOAuthProvider;
+            authProvider?: AgentsOAuthProvider;
         };
         client?: ConstructorParameters<typeof Client>[1];
         capabilities?: ClientCapabilities;
@@ -127,6 +129,10 @@ declare class MCPClientManager {
      * @returns namespaced list of tools
      */
     listTools(): NamespacedData["tools"];
+    /**
+     * @returns a set of tools that you can use with the AI SDK
+     */
+    unstable_getAITools(): ToolSet;
     /**
      * @returns namespaced list of prompts
      */
@@ -144,9 +150,9 @@ declare class MCPClientManager {
      */
     callTool(params: CallToolRequest["params"] & {
         serverId: string;
-    }, resultSchema: typeof CallToolResultSchema | typeof CompatibilityCallToolResultSchema, options: RequestOptions): Promise<zod.objectOutputType<zod.objectUtil.extendShape<{
+    }, resultSchema?: typeof CallToolResultSchema | typeof CompatibilityCallToolResultSchema, options?: RequestOptions): Promise<zod.objectOutputType<{
         _meta: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-    }, {
+    } & {
         content: zod.ZodArray<zod.ZodUnion<[zod.ZodObject<{
             type: zod.ZodLiteral<"text">;
             text: zod.ZodString;
@@ -281,19 +287,19 @@ declare class MCPClientManager {
             }>, zod.ZodTypeAny, "passthrough">>]>;
         }, zod.ZodTypeAny, "passthrough">>]>, "many">;
         isError: zod.ZodOptional<zod.ZodDefault<zod.ZodBoolean>>;
-    }>, zod.ZodTypeAny, "passthrough"> | zod.objectOutputType<zod.objectUtil.extendShape<{
+    }, zod.ZodTypeAny, "passthrough"> | zod.objectOutputType<{
         _meta: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-    }, {
+    } & {
         toolResult: zod.ZodUnknown;
-    }>, zod.ZodTypeAny, "passthrough">>;
+    }, zod.ZodTypeAny, "passthrough">>;
     /**
      * Namespaced version of readResource
      */
     readResource(params: ReadResourceRequest["params"] & {
         serverId: string;
-    }, options: RequestOptions): Promise<zod.objectOutputType<zod.objectUtil.extendShape<{
+    }, options: RequestOptions): Promise<zod.objectOutputType<{
         _meta: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-    }, {
+    } & {
         contents: zod.ZodArray<zod.ZodUnion<[zod.ZodObject<zod.objectUtil.extendShape<{
             uri: zod.ZodString;
             mimeType: zod.ZodOptional<zod.ZodString>;
@@ -325,15 +331,15 @@ declare class MCPClientManager {
         }, {
             blob: zod.ZodString;
         }>, zod.ZodTypeAny, "passthrough">>]>, "many">;
-    }>, zod.ZodTypeAny, "passthrough">>;
+    }, zod.ZodTypeAny, "passthrough">>;
     /**
      * Namespaced version of getPrompt
      */
     getPrompt(params: GetPromptRequest["params"] & {
         serverId: string;
-    }, options: RequestOptions): Promise<zod.objectOutputType<zod.objectUtil.extendShape<{
+    }, options: RequestOptions): Promise<zod.objectOutputType<{
         _meta: zod.ZodOptional<zod.ZodObject<{}, "passthrough", zod.ZodTypeAny, zod.objectOutputType<{}, zod.ZodTypeAny, "passthrough">, zod.objectInputType<{}, zod.ZodTypeAny, "passthrough">>>;
-    }, {
+    } & {
         description: zod.ZodOptional<zod.ZodString>;
         messages: zod.ZodArray<zod.ZodObject<{
             role: zod.ZodEnum<["user", "assistant"]>;
@@ -741,7 +747,7 @@ declare class MCPClientManager {
                 }>, zod.ZodTypeAny, "passthrough">>]>;
             }, zod.ZodTypeAny, "passthrough">>]>;
         }, zod.ZodTypeAny, "passthrough">>, "many">;
-    }>, zod.ZodTypeAny, "passthrough">>;
+    }, zod.ZodTypeAny, "passthrough">>;
 }
 type NamespacedData = {
     tools: (Tool & {

package/dist/mcp/client.js

@@ -1,469 +1,8 @@
-import "../chunk-HMLY7DHA.js";
-
-// src/mcp/sse-edge.ts
-import {
-  SSEClientTransport
-} from "@modelcontextprotocol/sdk/client/sse.js";
-var SSEEdgeClientTransport = class extends SSEClientTransport {
-  /**
-   * Creates a new EdgeSSEClientTransport, which overrides fetch to be compatible with the CF workers environment
-   */
-  constructor(url, options) {
-    const fetchOverride = async (fetchUrl, fetchInit = {}) => {
-      const headers = await this.authHeaders();
-      const workerOptions = {
-        ...fetchInit,
-        headers: {
-          ...fetchInit?.headers,
-          ...headers
-        }
-      };
-      delete workerOptions.mode;
-      return fetch(fetchUrl, workerOptions);
-    };
-    super(url, {
-      ...options,
-      eventSourceInit: {
-        fetch: fetchOverride
-      }
-    });
-    this.authProvider = options.authProvider;
-  }
-  async authHeaders() {
-    if (this.authProvider) {
-      const tokens = await this.authProvider.tokens();
-      if (tokens) {
-        return {
-          Authorization: `Bearer ${tokens.access_token}`
-        };
-      }
-    }
-  }
-};
-
-// src/mcp/client-connection.ts
 import {
-  ToolListChangedNotificationSchema,
-  ResourceListChangedNotificationSchema,
-  PromptListChangedNotificationSchema
-} from "@modelcontextprotocol/sdk/types.js";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-var MCPClientConnection = class {
-  constructor(url, info, options = { transport: {}, client: {}, capabilities: {} }) {
-    this.url = url;
-    this.info = info;
-    this.options = options;
-    this.connectionState = "connecting";
-    this.tools = [];
-    this.prompts = [];
-    this.resources = [];
-    this.resourceTemplates = [];
-    this.client = new Client(info, options.client);
-    this.client.registerCapabilities(options.capabilities);
-  }
-  /**
-   * Initialize a client connection
-   *
-   * @param code Optional OAuth code to initialize the connection with if auth hasn't been initialized
-   * @returns
-   */
-  async init(code, clientId) {
-    try {
-      const transport = new SSEEdgeClientTransport(
-        this.url,
-        this.options.transport
-      );
-      if (code) {
-        await transport.finishAuth(code);
-      }
-      await this.client.connect(transport);
-    } catch (e) {
-      if (e.toString().includes("Unauthorized")) {
-        this.connectionState = "authenticating";
-        return;
-      }
-      this.connectionState = "failed";
-      throw e;
-    }
-    this.connectionState = "discovering";
-    this.serverCapabilities = await this.client.getServerCapabilities();
-    if (!this.serverCapabilities) {
-      throw new Error("The MCP Server failed to return server capabilities");
-    }
-    const [instructions, tools, resources, prompts, resourceTemplates] = await Promise.all([
-      this.client.getInstructions(),
-      this.registerTools(),
-      this.registerResources(),
-      this.registerPrompts(),
-      this.registerResourceTemplates()
-    ]);
-    this.instructions = instructions;
-    this.tools = tools;
-    this.resources = resources;
-    this.prompts = prompts;
-    this.resourceTemplates = resourceTemplates;
-    this.connectionState = "ready";
-  }
-  /**
-   * Notification handler registration
-   */
-  async registerTools() {
-    if (!this.serverCapabilities || !this.serverCapabilities.tools) {
-      return [];
-    }
-    if (this.serverCapabilities.tools.listChanged) {
-      this.client.setNotificationHandler(
-        ToolListChangedNotificationSchema,
-        async (_notification) => {
-          this.tools = await this.fetchTools();
-        }
-      );
-    }
-    return this.fetchTools();
-  }
-  async registerResources() {
-    if (!this.serverCapabilities || !this.serverCapabilities.resources) {
-      return [];
-    }
-    if (this.serverCapabilities.resources.listChanged) {
-      this.client.setNotificationHandler(
-        ResourceListChangedNotificationSchema,
-        async (_notification) => {
-          this.resources = await this.fetchResources();
-        }
-      );
-    }
-    return this.fetchResources();
-  }
-  async registerPrompts() {
-    if (!this.serverCapabilities || !this.serverCapabilities.prompts) {
-      return [];
-    }
-    if (this.serverCapabilities.prompts.listChanged) {
-      this.client.setNotificationHandler(
-        PromptListChangedNotificationSchema,
-        async (_notification) => {
-          this.prompts = await this.fetchPrompts();
-        }
-      );
-    }
-    return this.fetchPrompts();
-  }
-  async registerResourceTemplates() {
-    if (!this.serverCapabilities || !this.serverCapabilities.resources) {
-      return [];
-    }
-    return this.fetchResourceTemplates();
-  }
-  async fetchTools() {
-    let toolsAgg = [];
-    let toolsResult = { tools: [] };
-    do {
-      toolsResult = await this.client.listTools({
-        cursor: toolsResult.nextCursor
-      });
-      toolsAgg = toolsAgg.concat(toolsResult.tools);
-    } while (toolsResult.nextCursor);
-    return toolsAgg;
-  }
-  async fetchResources() {
-    let resourcesAgg = [];
-    let resourcesResult = { resources: [] };
-    do {
-      resourcesResult = await this.client.listResources({
-        cursor: resourcesResult.nextCursor
-      });
-      resourcesAgg = resourcesAgg.concat(resourcesResult.resources);
-    } while (resourcesResult.nextCursor);
-    return resourcesAgg;
-  }
-  async fetchPrompts() {
-    let promptsAgg = [];
-    let promptsResult = { prompts: [] };
-    do {
-      promptsResult = await this.client.listPrompts({
-        cursor: promptsResult.nextCursor
-      });
-      promptsAgg = promptsAgg.concat(promptsResult.prompts);
-    } while (promptsResult.nextCursor);
-    return promptsAgg;
-  }
-  async fetchResourceTemplates() {
-    let templatesAgg = [];
-    let templatesResult = {
-      resourceTemplates: []
-    };
-    do {
-      templatesResult = await this.client.listResourceTemplates({
-        cursor: templatesResult.nextCursor
-      });
-      templatesAgg = templatesAgg.concat(templatesResult.resourceTemplates);
-    } while (templatesResult.nextCursor);
-    return templatesAgg;
-  }
-};
-
-// src/mcp/do-oauth-client-provider.ts
-var DurableObjectOAuthClientProvider = class {
-  constructor(storage, clientName, sessionId, redirectUrl, clientId_) {
-    this.storage = storage;
-    this.clientName = clientName;
-    this.sessionId = sessionId;
-    this.redirectUrl = redirectUrl;
-    this.clientId_ = clientId_;
-  }
-  get clientMetadata() {
-    return {
-      redirect_uris: [this.redirectUrl],
-      token_endpoint_auth_method: "none",
-      grant_types: ["authorization_code", "refresh_token"],
-      response_types: ["code"],
-      client_name: this.clientName,
-      client_uri: "example.com"
-    };
-  }
-  get clientId() {
-    if (!this.clientId_) {
-      throw new Error("no clientId");
-    }
-    return this.clientId_;
-  }
-  set clientId(clientId_) {
-    this.clientId_ = clientId_;
-  }
-  keyPrefix(clientId) {
-    return `/${this.clientName}/${this.sessionId}/${clientId}`;
-  }
-  clientInfoKey(clientId) {
-    return `${this.keyPrefix(clientId)}/client_info/`;
-  }
-  async clientInformation() {
-    if (!this.clientId_) {
-      return void 0;
-    }
-    return await this.storage.get(
-      this.clientInfoKey(this.clientId)
-    ) ?? void 0;
-  }
-  async saveClientInformation(clientInformation) {
-    await this.storage.put(
-      this.clientInfoKey(clientInformation.client_id),
-      clientInformation
-    );
-    this.clientId = clientInformation.client_id;
-  }
-  tokenKey(clientId) {
-    return `${this.keyPrefix(clientId)}/token`;
-  }
-  async tokens() {
-    if (!this.clientId_) {
-      return void 0;
-    }
-    return await this.storage.get(this.tokenKey(this.clientId)) ?? void 0;
-  }
-  async saveTokens(tokens) {
-    await this.storage.put(this.tokenKey(this.clientId), tokens);
-  }
-  get authUrl() {
-    return this.authUrl_;
-  }
-  /**
-   * Because this operates on the server side (but we need browser auth), we send this url back to the user
-   * and require user interact to initiate the redirect flow
-   */
-  async redirectToAuthorization(authUrl) {
-    const client_id = authUrl.searchParams.get("client_id");
-    if (client_id) {
-      authUrl.searchParams.append("state", client_id);
-    }
-    this.authUrl_ = authUrl.toString();
-  }
-  codeVerifierKey(clientId) {
-    return `${this.keyPrefix(clientId)}/code_verifier`;
-  }
-  async saveCodeVerifier(verifier) {
-    await this.storage.put(this.codeVerifierKey(this.clientId), verifier);
-  }
-  async codeVerifier() {
-    const codeVerifier = await this.storage.get(
-      this.codeVerifierKey(this.clientId)
-    );
-    if (!codeVerifier) {
-      throw new Error("No code verifier found");
-    }
-    return codeVerifier;
-  }
-};
-
-// src/mcp/client.ts
-var MCPClientManager = class {
-  /**
-   * @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
-   */
-  constructor(name, version, auth) {
-    this.name = name;
-    this.version = version;
-    this.auth = auth;
-    this.mcpConnections = {};
-  }
-  /**
-   * 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)
-   */
-  async connect(url, opts = {}) {
-    const id = opts.reconnect?.id ?? crypto.randomUUID();
-    if (this.auth) {
-      console.warn(
-        "Using .auth configuration to generate an oauth provider, this is temporary and will be removed in the next version. Instead use transport.authProvider to provide an auth provider"
-      );
-    }
-    const authProvider = this.auth ? new DurableObjectOAuthClientProvider(
-      this.auth.storage,
-      this.name,
-      id,
-      `${this.auth.baseCallbackUri}/${id}`,
-      opts.reconnect?.oauthClientId
-    ) : opts.transport?.authProvider;
-    this.mcpConnections[id] = new MCPClientConnection(
-      new URL(url),
-      {
-        name: this.name,
-        version: this.version
-      },
-      {
-        transport: {
-          ...opts.transport,
-          authProvider
-        },
-        client: opts.client ?? {},
-        capabilities: opts.client ?? {}
-      }
-    );
-    await this.mcpConnections[id].init(
-      opts.reconnect?.oauthCode,
-      opts.reconnect?.oauthClientId
-    );
-    return {
-      id,
-      authUrl: authProvider?.authUrl
-    };
-  }
-  isCallbackRequest(req) {
-    if (this.auth?.baseCallbackUri) {
-      return req.url.startsWith(this.auth.baseCallbackUri) && req.method === "GET";
-    }
-    return false;
-  }
-  async handleCallbackRequest(req) {
-    const url = new URL(req.url);
-    const code = url.searchParams.get("code");
-    const clientId = url.searchParams.get("state");
-    let serverId = req.url.replace(this.auth.baseCallbackUri, "").split("?")[0];
-    serverId = serverId.replaceAll("/", "");
-    if (!code) {
-      throw new Error("Unauthorized: no code provided");
-    }
-    if (!clientId) {
-      throw new Error("Unauthorized: no state provided");
-    }
-    if (this.mcpConnections[serverId] === void 0) {
-      throw new Error(`Could not find serverId: ${serverId}`);
-    }
-    if (this.mcpConnections[serverId].connectionState !== "authenticating") {
-      throw new Error(
-        "Failed to authenticate: the client isn't in the `authenticating` state"
-      );
-    }
-    const serverUrl = this.mcpConnections[serverId].url.toString();
-    await this.connect(serverUrl, {
-      reconnect: {
-        id: serverId,
-        oauthClientId: clientId,
-        oauthCode: code
-      }
-    });
-    if (this.mcpConnections[serverId].connectionState === "authenticating") {
-      throw new Error("Failed to authenticate: client failed to initialize");
-    }
-    return { serverId };
-  }
-  /**
-   * @returns namespaced list of tools
-   */
-  listTools() {
-    return getNamespacedData(this.mcpConnections, "tools");
-  }
-  /**
-   * @returns namespaced list of prompts
-   */
-  listPrompts() {
-    return getNamespacedData(this.mcpConnections, "prompts");
-  }
-  /**
-   * @returns namespaced list of tools
-   */
-  listResources() {
-    return getNamespacedData(this.mcpConnections, "resources");
-  }
-  /**
-   * @returns namespaced list of resource templates
-   */
-  listResourceTemplates() {
-    return getNamespacedData(this.mcpConnections, "resourceTemplates");
-  }
-  /**
-   * Namespaced version of callTool
-   */
-  callTool(params, resultSchema, options) {
-    const unqualifiedName = params.name.replace(`${params.serverId}.`, "");
-    return this.mcpConnections[params.serverId].client.callTool(
-      {
-        ...params,
-        name: unqualifiedName
-      },
-      resultSchema,
-      options
-    );
-  }
-  /**
-   * Namespaced version of readResource
-   */
-  readResource(params, options) {
-    return this.mcpConnections[params.serverId].client.readResource(
-      params,
-      options
-    );
-  }
-  /**
-   * Namespaced version of getPrompt
-   */
-  getPrompt(params, options) {
-    return this.mcpConnections[params.serverId].client.getPrompt(
-      params,
-      options
-    );
-  }
-};
-function getNamespacedData(mcpClients, type) {
-  const sets = Object.entries(mcpClients).map(([name, conn]) => {
-    return { name, data: conn[type] };
-  });
-  const namespacedData = sets.flatMap(({ name: serverId, data }) => {
-    return data.map((item) => {
-      return {
-        ...item,
-        // we add a serverId so we can easily pull it out and send the tool call to the right server
-        serverId
-      };
-    });
-  });
-  return namespacedData;
-}
+  MCPClientManager,
+  getNamespacedData
+} from "../chunk-YZNSS675.js";
+import "../chunk-HMLY7DHA.js";
 export {
   MCPClientManager,
   getNamespacedData