@ai-sdk/mcp 1.0.19 → 1.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/mcp",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -34,7 +34,7 @@
   "dependencies": {
     "pkce-challenge": "^5.0.0",
     "@ai-sdk/provider": "3.0.8",
-    "@ai-sdk/provider-utils": "4.0.14"
+    "@ai-sdk/provider-utils": "4.0.15"
   },
   "devDependencies": {
     "@types/node": "20.17.24",

package/src/index.ts

@@ -16,6 +16,7 @@ export { ElicitationRequestSchema, ElicitResultSchema } from './tool/types';
 export type {
   ElicitationRequest,
   ElicitResult,
+  ListToolsResult,
   ClientCapabilities as MCPClientCapabilities,
 } from './tool/types';
 export { auth, UnauthorizedError } from './tool/oauth';

package/src/tool/mcp-client.ts

@@ -123,6 +123,22 @@ export interface MCPClient {
     schemas?: TOOL_SCHEMAS;
   }): Promise<McpToolSet<TOOL_SCHEMAS>>;
 
+  /**
+   * Lists available tools from the MCP server.
+   */
+  listTools(options?: {
+    params?: PaginatedRequest['params'];
+    options?: RequestOptions;
+  }): Promise<ListToolsResult>;
+
+  /**
+   * Creates AI SDK tools from tool definitions.
+   */
+  toolsFromDefinitions<TOOL_SCHEMAS extends ToolSchemas = 'automatic'>(
+    definitions: ListToolsResult,
+    options?: { schemas?: TOOL_SCHEMAS },
+  ): McpToolSet<TOOL_SCHEMAS>;
+
   listResources(options?: {
     params?: PaginatedRequest['params'];
     options?: RequestOptions;
@@ -383,22 +399,18 @@ class DefaultMCPClient implements MCPClient {
     });
   }
 
-  private async listTools({
+  async listTools({
     params,
     options,
   }: {
     params?: PaginatedRequest['params'];
     options?: RequestOptions;
   } = {}): Promise<ListToolsResult> {
-    try {
-      return this.request({
-        request: { method: 'tools/list', params },
-        resultSchema: ListToolsResultSchema,
-        options,
-      });
-    } catch (error) {
-      throw error;
-    }
+    return this.request({
+      request: { method: 'tools/list', params },
+      resultSchema: ListToolsResultSchema,
+      options,
+    });
   }
 
   private async callTool({
@@ -522,7 +534,8 @@ class DefaultMCPClient implements MCPClient {
   }
 
   /**
-   * Returns a set of AI SDK tools from the MCP server
+   * Returns a set of AI SDK tools from the MCP server.
+   * This fetches tool definitions and wraps them with execute functions.
    * @returns A record of tool names to their implementations
    */
   async tools<TOOL_SCHEMAS extends ToolSchemas = 'automatic'>({
@@ -530,70 +543,80 @@ class DefaultMCPClient implements MCPClient {
   }: {
     schemas?: TOOL_SCHEMAS;
   } = {}): Promise<McpToolSet<TOOL_SCHEMAS>> {
-    const tools: Record<string, Tool & { _meta?: ToolMeta }> = {};
+    const definitions = await this.listTools();
+    return this.toolsFromDefinitions(definitions, {
+      schemas,
+    } as { schemas?: TOOL_SCHEMAS });
+  }
 
-    try {
-      const listToolsResult = await this.listTools();
-      for (const {
-        name,
-        title,
-        description,
-        inputSchema,
-        annotations,
-        _meta,
-      } of listToolsResult.tools) {
-        const resolvedTitle = title ?? annotations?.title;
-        if (schemas !== 'automatic' && !(name in schemas)) {
-          continue;
-        }
+  /**
+   * Creates AI SDK tools from tool definitions without fetching from the server.
+   */
+  toolsFromDefinitions<TOOL_SCHEMAS extends ToolSchemas = 'automatic'>(
+    definitions: ListToolsResult,
+    { schemas = 'automatic' }: { schemas?: TOOL_SCHEMAS } = {} as {
+      schemas?: TOOL_SCHEMAS;
+    },
+  ): McpToolSet<TOOL_SCHEMAS> {
+    const tools: Record<string, Tool & { _meta?: ToolMeta }> = {};
 
-        const self = this;
-        const outputSchema =
-          schemas !== 'automatic' ? schemas[name]?.outputSchema : undefined;
+    for (const {
+      name,
+      title,
+      description,
+      inputSchema,
+      annotations,
+      _meta,
+    } of definitions.tools) {
+      const resolvedTitle = title ?? annotations?.title;
+      if (schemas !== 'automatic' && !(name in schemas)) {
+        continue;
+      }
 
-        const execute = async (
-          args: any,
-          options: ToolExecutionOptions,
-        ): Promise<unknown> => {
-          options?.abortSignal?.throwIfAborted();
-          const result = await self.callTool({ name, args, options });
+      const self = this;
+      const outputSchema =
+        schemas !== 'automatic' ? schemas[name]?.outputSchema : undefined;
 
-          if (outputSchema != null) {
-            return self.extractStructuredContent(result, outputSchema, name);
-          }
+      const execute = async (
+        args: any,
+        options: ToolExecutionOptions,
+      ): Promise<unknown> => {
+        options?.abortSignal?.throwIfAborted();
+        const result = await self.callTool({ name, args, options });
 
-          return result;
-        };
+        if (outputSchema != null) {
+          return self.extractStructuredContent(result, outputSchema, name);
+        }
 
-        const toolWithExecute =
-          schemas === 'automatic'
-            ? dynamicTool({
-                description,
-                title: resolvedTitle,
-                inputSchema: jsonSchema({
-                  ...inputSchema,
-                  properties: inputSchema.properties ?? {},
-                  additionalProperties: false,
-                } as JSONSchema7),
-                execute,
-                toModelOutput: mcpToModelOutput,
-              })
-            : tool({
-                description,
-                title: resolvedTitle,
-                inputSchema: schemas[name].inputSchema,
-                ...(outputSchema != null ? { outputSchema } : {}),
-                execute,
-                toModelOutput: mcpToModelOutput,
-              });
-
-        tools[name] = { ...toolWithExecute, _meta };
-      }
+        return result;
+      };
 
-      return tools as McpToolSet<TOOL_SCHEMAS>;
-    } catch (error) {
-      throw error;
+      const toolWithExecute =
+        schemas === 'automatic'
+          ? dynamicTool({
+              description,
+              title: resolvedTitle,
+              inputSchema: jsonSchema({
+                ...inputSchema,
+                properties: inputSchema.properties ?? {},
+                additionalProperties: false,
+              } as JSONSchema7),
+              execute,
+              toModelOutput: mcpToModelOutput,
+            })
+          : tool({
+              description,
+              title: resolvedTitle,
+              inputSchema: schemas[name].inputSchema,
+              ...(outputSchema != null ? { outputSchema } : {}),
+              execute,
+              toModelOutput: mcpToModelOutput,
+            });
+
+      tools[name] = { ...toolWithExecute, _meta };
     }
+
+    return tools as McpToolSet<TOOL_SCHEMAS>;
   }
 
   /**