@ai-sdk/anthropic 3.0.0-beta.27 → 3.0.0-beta.29

package/dist/internal/index.mjs

@@ -98,6 +98,24 @@ var anthropicMessagesResponseSchema = lazySchema2(
             name: z2.string(),
             input: z2.record(z2.string(), z2.unknown()).nullish()
           }),
+          z2.object({
+            type: z2.literal("mcp_tool_use"),
+            id: z2.string(),
+            name: z2.string(),
+            input: z2.unknown(),
+            server_name: z2.string()
+          }),
+          z2.object({
+            type: z2.literal("mcp_tool_result"),
+            tool_use_id: z2.string(),
+            is_error: z2.boolean(),
+            content: z2.array(
+              z2.union([
+                z2.string(),
+                z2.object({ type: z2.literal("text"), text: z2.string() })
+              ])
+            )
+          }),
           z2.object({
             type: z2.literal("web_fetch_tool_result"),
             tool_use_id: z2.string(),
@@ -270,6 +288,24 @@ var anthropicMessagesChunkSchema = lazySchema2(
             name: z2.string(),
             input: z2.record(z2.string(), z2.unknown()).nullish()
           }),
+          z2.object({
+            type: z2.literal("mcp_tool_use"),
+            id: z2.string(),
+            name: z2.string(),
+            input: z2.unknown(),
+            server_name: z2.string()
+          }),
+          z2.object({
+            type: z2.literal("mcp_tool_result"),
+            tool_use_id: z2.string(),
+            is_error: z2.boolean(),
+            content: z2.array(
+              z2.union([
+                z2.string(),
+                z2.object({ type: z2.literal("text"), text: z2.string() })
+              ])
+            )
+          }),
           z2.object({
             type: z2.literal("web_fetch_tool_result"),
             tool_use_id: z2.string(),
@@ -522,7 +558,19 @@ var anthropicProviderOptions = z3.object({
   cacheControl: z3.object({
     type: z3.literal("ephemeral"),
     ttl: z3.union([z3.literal("5m"), z3.literal("1h")]).optional()
-  }).optional()
+  }).optional(),
+  mcpServers: z3.array(
+    z3.object({
+      type: z3.literal("url"),
+      name: z3.string(),
+      url: z3.string(),
+      authorizationToken: z3.string().nullish(),
+      toolConfiguration: z3.object({
+        enabled: z3.boolean().nullish(),
+        allowedTools: z3.array(z3.string()).nullish()
+      }).nullish()
+    })
+  ).optional()
 });
 
 // src/anthropic-prepare-tools.ts
@@ -915,7 +963,8 @@ import {
 import {
   convertToBase64,
   parseProviderOptions,
-  validateTypes as validateTypes2
+  validateTypes as validateTypes2,
+  isNonNullable
 } from "@ai-sdk/provider-utils";
 
 // src/tool/code-execution_20250522.ts
@@ -1067,7 +1116,7 @@ async function convertToAnthropicMessagesPrompt({
   sendReasoning,
   warnings
 }) {
-  var _a, _b, _c, _d, _e, _f;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
   const betas = /* @__PURE__ */ new Set();
   const blocks = groupIntoBlocks(prompt);
   let system = void 0;
@@ -1218,20 +1267,20 @@ async function convertToAnthropicMessagesPrompt({
                           return {
                             type: "text",
                             text: contentPart.text,
-                            cache_control: void 0
+                            cache_control: cacheControl
                           };
-                        case "media": {
-                          if (contentPart.mediaType.startsWith("image/")) {
-                            return {
-                              type: "image",
-                              source: {
-                                type: "base64",
-                                media_type: contentPart.mediaType,
-                                data: contentPart.data
-                              },
-                              cache_control: void 0
-                            };
-                          }
+                        case "image-data": {
+                          return {
+                            type: "image",
+                            source: {
+                              type: "base64",
+                              media_type: contentPart.mediaType,
+                              data: contentPart.data
+                            },
+                            cache_control: cacheControl
+                          };
+                        }
+                        case "file-data": {
                           if (contentPart.mediaType === "application/pdf") {
                             betas.add("pdfs-2024-09-25");
                             return {
@@ -1241,15 +1290,24 @@ async function convertToAnthropicMessagesPrompt({
                                 media_type: contentPart.mediaType,
                                 data: contentPart.data
                               },
-                              cache_control: void 0
+                              cache_control: cacheControl
                             };
                           }
-                          throw new UnsupportedFunctionalityError2({
-                            functionality: `media type: ${contentPart.mediaType}`
+                          warnings.push({
+                            type: "other",
+                            message: `unsupported tool content part type: ${contentPart.type} with media type: ${contentPart.mediaType}`
                           });
+                          return void 0;
+                        }
+                        default: {
+                          warnings.push({
+                            type: "other",
+                            message: `unsupported tool content part type: ${contentPart.type}`
+                          });
+                          return void 0;
                         }
                       }
-                    });
+                    }).filter(isNonNullable);
                     break;
                   case "text":
                   case "error-text":
@@ -1285,6 +1343,7 @@ async function convertToAnthropicMessagesPrompt({
       }
       case "assistant": {
         const anthropicContent = [];
+        const mcpToolUseIds = /* @__PURE__ */ new Set();
         for (let j = 0; j < block.messages.length; j++) {
           const message = block.messages[j];
           const isLastMessage = j === block.messages.length - 1;
@@ -1350,7 +1409,29 @@ async function convertToAnthropicMessagesPrompt({
               }
               case "tool-call": {
                 if (part.providerExecuted) {
-                  if (part.toolName === "code_execution" && part.input != null && typeof part.input === "object" && "type" in part.input && typeof part.input.type === "string" && (part.input.type === "bash_code_execution" || part.input.type === "text_editor_code_execution")) {
+                  const isMcpToolUse = ((_h = (_g = part.providerOptions) == null ? void 0 : _g.anthropic) == null ? void 0 : _h.type) === "mcp-tool-use";
+                  if (isMcpToolUse) {
+                    mcpToolUseIds.add(part.toolCallId);
+                    const serverName = (_j = (_i = part.providerOptions) == null ? void 0 : _i.anthropic) == null ? void 0 : _j.serverName;
+                    if (serverName == null || typeof serverName !== "string") {
+                      warnings.push({
+                        type: "other",
+                        message: "mcp tool use server name is required and must be a string"
+                      });
+                      break;
+                    }
+                    anthropicContent.push({
+                      type: "mcp_tool_use",
+                      id: part.toolCallId,
+                      name: part.toolName,
+                      input: part.input,
+                      server_name: serverName,
+                      cache_control: cacheControl
+                    });
+                  } else if (
+                    // code execution 20250825:
+                    part.toolName === "code_execution" && part.input != null && typeof part.input === "object" && "type" in part.input && typeof part.input.type === "string" && (part.input.type === "bash_code_execution" || part.input.type === "text_editor_code_execution")
+                  ) {
                     anthropicContent.push({
                       type: "server_tool_use",
                       id: part.toolCallId,
@@ -1386,7 +1467,23 @@ async function convertToAnthropicMessagesPrompt({
                 break;
               }
               case "tool-result": {
-                if (part.toolName === "code_execution") {
+                if (mcpToolUseIds.has(part.toolCallId)) {
+                  const output = part.output;
+                  if (output.type !== "json" && output.type !== "error-json") {
+                    warnings.push({
+                      type: "other",
+                      message: `provider executed tool result output type ${output.type} for tool ${part.toolName} is not supported`
+                    });
+                    break;
+                  }
+                  anthropicContent.push({
+                    type: "mcp_tool_result",
+                    tool_use_id: part.toolCallId,
+                    is_error: output.type === "error-json",
+                    content: output.value,
+                    cache_control: cacheControl
+                  });
+                } else if (part.toolName === "code_execution") {
                   const output = part.output;
                   if (output.type !== "json") {
                     warnings.push({
@@ -1701,7 +1798,7 @@ var AnthropicMessagesLanguageModel = class {
       providerOptions,
       schema: anthropicProviderOptions
     });
-    const { prompt: messagesPrompt, betas: messagesBetas } = await convertToAnthropicMessagesPrompt({
+    const { prompt: messagesPrompt, betas } = await convertToAnthropicMessagesPrompt({
       prompt,
       sendReasoning: (_a = anthropicOptions == null ? void 0 : anthropicOptions.sendReasoning) != null ? _a : true,
       warnings
@@ -1723,6 +1820,19 @@ var AnthropicMessagesLanguageModel = class {
       ...isThinking && {
         thinking: { type: "enabled", budget_tokens: thinkingBudget }
       },
+      // mcp servers:
+      ...(anthropicOptions == null ? void 0 : anthropicOptions.mcpServers) && anthropicOptions.mcpServers.length > 0 && {
+        mcp_servers: anthropicOptions.mcpServers.map((server) => ({
+          type: server.type,
+          name: server.name,
+          url: server.url,
+          authorization_token: server.authorizationToken,
+          tool_configuration: server.toolConfiguration ? {
+            allowed_tools: server.toolConfiguration.allowedTools,
+            enabled: server.toolConfiguration.enabled
+          } : void 0
+        }))
+      },
       // prompt:
       system: messagesPrompt.system,
       messages: messagesPrompt.messages
@@ -1764,11 +1874,14 @@ var AnthropicMessagesLanguageModel = class {
         warnings.push({
           type: "unsupported-setting",
           setting: "maxOutputTokens",
-          details: `${maxTokens} (maxOutputTokens + thinkingBudget) is greater than ${this.modelId} ${maxOutputTokensForModel} max output tokens. The max output tokens have been limited to ${maxOutputTokensForModel}.`
+          details: `${baseArgs.max_tokens} (maxOutputTokens + thinkingBudget) is greater than ${this.modelId} ${maxOutputTokensForModel} max output tokens. The max output tokens have been limited to ${maxOutputTokensForModel}.`
         });
       }
       baseArgs.max_tokens = maxOutputTokensForModel;
     }
+    if ((anthropicOptions == null ? void 0 : anthropicOptions.mcpServers) && anthropicOptions.mcpServers.length > 0) {
+      betas.add("mcp-client-2025-04-04");
+    }
     const {
       tools: anthropicTools2,
       toolChoice: anthropicToolChoice,
@@ -1792,7 +1905,7 @@ var AnthropicMessagesLanguageModel = class {
         tool_choice: anthropicToolChoice
       },
       warnings: [...warnings, ...toolWarnings],
-      betas: /* @__PURE__ */ new Set([...messagesBetas, ...toolsBetas]),
+      betas: /* @__PURE__ */ new Set([...betas, ...toolsBetas]),
       usesJsonResponseTool: jsonResponseTool != null
     };
   }
@@ -1857,6 +1970,7 @@ var AnthropicMessagesLanguageModel = class {
       fetch: this.config.fetch
     });
     const content = [];
+    const mcpToolCalls = {};
     for (const part of response.content) {
       switch (part.type) {
         case "text": {
@@ -1936,6 +2050,37 @@ var AnthropicMessagesLanguageModel = class {
           }
           break;
         }
+        case "mcp_tool_use": {
+          mcpToolCalls[part.id] = {
+            type: "tool-call",
+            toolCallId: part.id,
+            toolName: part.name,
+            input: JSON.stringify(part.input),
+            providerExecuted: true,
+            dynamic: true,
+            providerMetadata: {
+              anthropic: {
+                type: "mcp-tool-use",
+                serverName: part.server_name
+              }
+            }
+          };
+          content.push(mcpToolCalls[part.id]);
+          break;
+        }
+        case "mcp_tool_result": {
+          content.push({
+            type: "tool-result",
+            toolCallId: part.tool_use_id,
+            toolName: mcpToolCalls[part.tool_use_id].toolName,
+            isError: part.is_error,
+            result: part.content,
+            providerExecuted: true,
+            dynamic: true,
+            providerMetadata: mcpToolCalls[part.tool_use_id].providerMetadata
+          });
+          break;
+        }
         case "web_fetch_tool_result": {
           if (part.content.type === "web_fetch_result") {
             content.push({
@@ -2116,6 +2261,7 @@ var AnthropicMessagesLanguageModel = class {
       totalTokens: void 0
     };
     const contentBlocks = {};
+    const mcpToolCalls = {};
     let rawUsage = void 0;
     let cacheCreationInputTokens = null;
     let stopSequence = null;
@@ -2142,7 +2288,8 @@ var AnthropicMessagesLanguageModel = class {
                 return;
               }
               case "content_block_start": {
-                const contentBlockType = value.content_block.type;
+                const part = value.content_block;
+                const contentBlockType = part.type;
                 blockType = contentBlockType;
                 switch (contentBlockType) {
                   case "text": {
@@ -2168,7 +2315,7 @@ var AnthropicMessagesLanguageModel = class {
                       id: String(value.index),
                       providerMetadata: {
                         anthropic: {
-                          redactedData: value.content_block.data
+                          redactedData: part.data
                         }
                       }
                     });
@@ -2177,16 +2324,16 @@ var AnthropicMessagesLanguageModel = class {
                   case "tool_use": {
                     contentBlocks[value.index] = usesJsonResponseTool ? { type: "text" } : {
                       type: "tool-call",
-                      toolCallId: value.content_block.id,
-                      toolName: value.content_block.name,
+                      toolCallId: part.id,
+                      toolName: part.name,
                       input: "",
                       firstDelta: true
                     };
                     controller.enqueue(
                       usesJsonResponseTool ? { type: "text-start", id: String(value.index) } : {
                         type: "tool-input-start",
-                        id: value.content_block.id,
-                        toolName: value.content_block.name
+                        id: part.id,
+                        toolName: part.name
                       }
                     );
                     return;
@@ -2201,19 +2348,19 @@ var AnthropicMessagesLanguageModel = class {
                       "text_editor_code_execution",
                       // code execution 20250825 bash:
                       "bash_code_execution"
-                    ].includes(value.content_block.name)) {
+                    ].includes(part.name)) {
                       contentBlocks[value.index] = {
                         type: "tool-call",
-                        toolCallId: value.content_block.id,
-                        toolName: value.content_block.name,
+                        toolCallId: part.id,
+                        toolName: part.name,
                         input: "",
                         providerExecuted: true,
                         firstDelta: true
                       };
-                      const mappedToolName = value.content_block.name === "text_editor_code_execution" || value.content_block.name === "bash_code_execution" ? "code_execution" : value.content_block.name;
+                      const mappedToolName = part.name === "text_editor_code_execution" || part.name === "bash_code_execution" ? "code_execution" : part.name;
                       controller.enqueue({
                         type: "tool-input-start",
-                        id: value.content_block.id,
+                        id: part.id,
                         toolName: mappedToolName,
                         providerExecuted: true
                       });
@@ -2221,7 +2368,6 @@ var AnthropicMessagesLanguageModel = class {
                     return;
                   }
                   case "web_fetch_tool_result": {
-                    const part = value.content_block;
                     if (part.content.type === "web_fetch_result") {
                       controller.enqueue({
                         type: "tool-result",
@@ -2259,7 +2405,6 @@ var AnthropicMessagesLanguageModel = class {
                     return;
                   }
                   case "web_search_tool_result": {
-                    const part = value.content_block;
                     if (Array.isArray(part.content)) {
                       controller.enqueue({
                         type: "tool-result",
@@ -2308,7 +2453,6 @@ var AnthropicMessagesLanguageModel = class {
                   }
                   // code execution 20250522:
                   case "code_execution_tool_result": {
-                    const part = value.content_block;
                     if (part.content.type === "code_execution_result") {
                       controller.enqueue({
                         type: "tool-result",
@@ -2340,7 +2484,6 @@ var AnthropicMessagesLanguageModel = class {
                   // code execution 20250825:
                   case "bash_code_execution_tool_result":
                   case "text_editor_code_execution_tool_result": {
-                    const part = value.content_block;
                     controller.enqueue({
                       type: "tool-result",
                       toolCallId: part.tool_use_id,
@@ -2350,6 +2493,37 @@ var AnthropicMessagesLanguageModel = class {
                     });
                     return;
                   }
+                  case "mcp_tool_use": {
+                    mcpToolCalls[part.id] = {
+                      type: "tool-call",
+                      toolCallId: part.id,
+                      toolName: part.name,
+                      input: JSON.stringify(part.input),
+                      providerExecuted: true,
+                      dynamic: true,
+                      providerMetadata: {
+                        anthropic: {
+                          type: "mcp-tool-use",
+                          serverName: part.server_name
+                        }
+                      }
+                    };
+                    controller.enqueue(mcpToolCalls[part.id]);
+                    return;
+                  }
+                  case "mcp_tool_result": {
+                    controller.enqueue({
+                      type: "tool-result",
+                      toolCallId: part.tool_use_id,
+                      toolName: mcpToolCalls[part.tool_use_id].toolName,
+                      isError: part.is_error,
+                      result: part.content,
+                      providerExecuted: true,
+                      dynamic: true,
+                      providerMetadata: mcpToolCalls[part.tool_use_id].providerMetadata
+                    });
+                    return;
+                  }
                   default: {
                     const _exhaustiveCheck = contentBlockType;
                     throw new Error(