@ai-sdk/mcp 1.0.0-beta.4 → 1.0.0-beta.41

package/dist/index.mjs

@@ -47,6 +47,7 @@ var SUPPORTED_PROTOCOL_VERSIONS = [
   "2025-03-26",
   "2024-11-05"
 ];
+var ToolMetaSchema = z.optional(z.record(z.string(), z.unknown()));
 var ClientOrServerImplementationSchema = z.looseObject({
   name: z.string(),
   version: z.string()
@@ -59,6 +60,9 @@ var RequestSchema = z.object({
   method: z.string(),
   params: z.optional(BaseParamsSchema)
 });
+var ElicitationCapabilitySchema = z.object({
+  applyDefaults: z.optional(z.boolean())
+}).loose();
 var ServerCapabilitiesSchema = z.looseObject({
   experimental: z.optional(z.object({}).loose()),
   logging: z.optional(z.object({}).loose()),
@@ -77,8 +81,12 @@ var ServerCapabilitiesSchema = z.looseObject({
     z.looseObject({
       listChanged: z.optional(z.boolean())
     })
-  )
+  ),
+  elicitation: z.optional(ElicitationCapabilitySchema)
 });
+var ClientCapabilitiesSchema = z.object({
+  elicitation: z.optional(ElicitationCapabilitySchema)
+}).loose();
 var InitializeResultSchema = ResultSchema.extend({
   protocolVersion: z.string(),
   capabilities: ServerCapabilitiesSchema,
@@ -99,7 +107,8 @@ var ToolSchema = z.object({
     z.object({
       title: z.optional(z.string())
     }).loose()
-  )
+  ),
+  _meta: ToolMetaSchema
 }).loose();
 var ListToolsResultSchema = PaginatedResultSchema.extend({
   tools: z.array(ToolSchema)
@@ -177,6 +186,48 @@ var ReadResourceResultSchema = ResultSchema.extend({
     z.union([TextResourceContentsSchema, BlobResourceContentsSchema])
   )
 });
+var PromptArgumentSchema = z.object({
+  name: z.string(),
+  description: z.optional(z.string()),
+  required: z.optional(z.boolean())
+}).loose();
+var PromptSchema = z.object({
+  name: z.string(),
+  title: z.optional(z.string()),
+  description: z.optional(z.string()),
+  arguments: z.optional(z.array(PromptArgumentSchema))
+}).loose();
+var ListPromptsResultSchema = PaginatedResultSchema.extend({
+  prompts: z.array(PromptSchema)
+});
+var PromptMessageSchema = z.object({
+  role: z.union([z.literal("user"), z.literal("assistant")]),
+  content: z.union([
+    TextContentSchema,
+    ImageContentSchema,
+    EmbeddedResourceSchema
+  ])
+}).loose();
+var GetPromptResultSchema = ResultSchema.extend({
+  description: z.optional(z.string()),
+  messages: z.array(PromptMessageSchema)
+});
+var ElicitationRequestParamsSchema = BaseParamsSchema.extend({
+  message: z.string(),
+  requestedSchema: z.unknown()
+});
+var ElicitationRequestSchema = RequestSchema.extend({
+  method: z.literal("elicitation/create"),
+  params: ElicitationRequestParamsSchema
+});
+var ElicitResultSchema = ResultSchema.extend({
+  action: z.union([
+    z.literal("accept"),
+    z.literal("decline"),
+    z.literal("cancel")
+  ]),
+  content: z.optional(z.record(z.string(), z.unknown()))
+});
 
 // src/tool/json-rpc-message.ts
 var JSONRPC_VERSION = "2.0";
@@ -752,7 +803,8 @@ async function refreshAuthorization(authorizationServerUrl, {
     tokenUrl = new URL("/token", authorizationServerUrl);
   }
   const headers = new Headers({
-    "Content-Type": "application/x-www-form-urlencoded"
+    "Content-Type": "application/x-www-form-urlencoded",
+    Accept: "application/json"
   });
   const params = new URLSearchParams({
     grant_type: grantType,
@@ -1499,13 +1551,16 @@ var DefaultMCPClient = class {
   constructor({
     transport: transportConfig,
     name: name3 = "ai-sdk-mcp-client",
-    onUncaughtError
+    version = CLIENT_VERSION,
+    onUncaughtError,
+    capabilities
   }) {
     this.requestMessageId = 0;
     this.responseHandlers = /* @__PURE__ */ new Map();
     this.serverCapabilities = {};
     this.isClosed = true;
     this.onUncaughtError = onUncaughtError;
+    this.clientCapabilities = capabilities != null ? capabilities : {};
     if (isCustomMcpTransport(transportConfig)) {
       this.transport = transportConfig;
     } else {
@@ -1515,18 +1570,22 @@ var DefaultMCPClient = class {
     this.transport.onerror = (error) => this.onError(error);
     this.transport.onmessage = (message) => {
       if ("method" in message) {
-        this.onError(
-          new MCPClientError({
-            message: "Unsupported message type"
-          })
-        );
+        if ("id" in message) {
+          this.onRequestMessage(message);
+        } else {
+          this.onError(
+            new MCPClientError({
+              message: "Unsupported message type"
+            })
+          );
+        }
         return;
       }
       this.onResponse(message);
     };
     this.clientInfo = {
       name: name3,
-      version: CLIENT_VERSION
+      version
     };
   }
   async init() {
@@ -1538,7 +1597,7 @@ var DefaultMCPClient = class {
           method: "initialize",
           params: {
             protocolVersion: LATEST_PROTOCOL_VERSION,
-            capabilities: {},
+            capabilities: this.clientCapabilities,
             clientInfo: this.clientInfo
           }
         },
@@ -1591,6 +1650,14 @@ var DefaultMCPClient = class {
           });
         }
         break;
+      case "prompts/list":
+      case "prompts/get":
+        if (!this.serverCapabilities.prompts) {
+          throw new MCPClientError({
+            message: `Server does not support prompts`
+          });
+        }
+        break;
       default:
         throw new MCPClientError({
           message: `Unsupported method: ${method}`
@@ -1723,6 +1790,35 @@ var DefaultMCPClient = class {
       throw error;
     }
   }
+  async listPromptsInternal({
+    params,
+    options
+  } = {}) {
+    try {
+      return this.request({
+        request: { method: "prompts/list", params },
+        resultSchema: ListPromptsResultSchema,
+        options
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+  async getPromptInternal({
+    name: name3,
+    args,
+    options
+  }) {
+    try {
+      return this.request({
+        request: { method: "prompts/get", params: { name: name3, arguments: args } },
+        resultSchema: GetPromptResultSchema,
+        options
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
   async notification(notification) {
     const jsonrpcNotification = {
       ...notification,
@@ -1745,7 +1841,8 @@ var DefaultMCPClient = class {
         name: name3,
         description,
         inputSchema,
-        annotations
+        annotations,
+        _meta
       } of listToolsResult.tools) {
         const title = annotations == null ? void 0 : annotations.title;
         if (schemas !== "automatic" && !(name3 in schemas)) {
@@ -1772,7 +1869,7 @@ var DefaultMCPClient = class {
           inputSchema: schemas[name3].inputSchema,
           execute
         });
-        tools[name3] = toolWithExecute;
+        tools[name3] = { ...toolWithExecute, _meta };
       }
       return tools;
     } catch (error) {
@@ -1796,6 +1893,90 @@ var DefaultMCPClient = class {
   } = {}) {
     return this.listResourceTemplatesInternal({ options });
   }
+  experimental_listPrompts({
+    params,
+    options
+  } = {}) {
+    return this.listPromptsInternal({ params, options });
+  }
+  experimental_getPrompt({
+    name: name3,
+    arguments: args,
+    options
+  }) {
+    return this.getPromptInternal({ name: name3, args, options });
+  }
+  onElicitationRequest(schema, handler) {
+    if (schema !== ElicitationRequestSchema) {
+      throw new MCPClientError({
+        message: "Unsupported request schema. Only ElicitationRequestSchema is supported."
+      });
+    }
+    this.elicitationRequestHandler = handler;
+  }
+  async onRequestMessage(request) {
+    try {
+      if (request.method !== "elicitation/create") {
+        await this.transport.send({
+          jsonrpc: "2.0",
+          id: request.id,
+          error: {
+            code: -32601,
+            message: `Unsupported request method: ${request.method}`
+          }
+        });
+        return;
+      }
+      if (!this.elicitationRequestHandler) {
+        await this.transport.send({
+          jsonrpc: "2.0",
+          id: request.id,
+          error: {
+            code: -32601,
+            message: "No elicitation handler registered on client"
+          }
+        });
+        return;
+      }
+      const parsedRequest = ElicitationRequestSchema.safeParse({
+        method: request.method,
+        params: request.params
+      });
+      if (!parsedRequest.success) {
+        await this.transport.send({
+          jsonrpc: "2.0",
+          id: request.id,
+          error: {
+            code: -32602,
+            message: `Invalid elicitation request: ${parsedRequest.error.message}`,
+            data: parsedRequest.error.issues
+          }
+        });
+        return;
+      }
+      try {
+        const result = await this.elicitationRequestHandler(parsedRequest.data);
+        const validatedResult = ElicitResultSchema.parse(result);
+        await this.transport.send({
+          jsonrpc: "2.0",
+          id: request.id,
+          result: validatedResult
+        });
+      } catch (error) {
+        await this.transport.send({
+          jsonrpc: "2.0",
+          id: request.id,
+          error: {
+            code: -32603,
+            message: error instanceof Error ? error.message : "Failed to handle elicitation request"
+          }
+        });
+        this.onError(error);
+      }
+    } catch (error) {
+      this.onError(error);
+    }
+  }
   onClose() {
     if (this.isClosed) return;
     this.isClosed = true;
@@ -1834,8 +2015,11 @@ var DefaultMCPClient = class {
   }
 };
 export {
+  ElicitResultSchema,
+  ElicitationRequestSchema,
   UnauthorizedError,
   auth,
+  createMCPClient,
   createMCPClient as experimental_createMCPClient
 };
 //# sourceMappingURL=index.mjs.map