@ai-sdk/anthropic 1.1.9 → 1.1.11

package/dist/index.js

@@ -49,8 +49,117 @@ var anthropicFailedResponseHandler = (0, import_provider_utils.createJsonErrorRe
   errorToMessage: (data) => data.error.message
 });
 
-// src/convert-to-anthropic-messages-prompt.ts
+// src/anthropic-prepare-tools.ts
 var import_provider = require("@ai-sdk/provider");
+function prepareTools(mode) {
+  var _a;
+  const tools = ((_a = mode.tools) == null ? void 0 : _a.length) ? mode.tools : void 0;
+  const toolWarnings = [];
+  const betas = /* @__PURE__ */ new Set();
+  if (tools == null) {
+    return { tools: void 0, tool_choice: void 0, toolWarnings, betas };
+  }
+  const anthropicTools2 = [];
+  for (const tool of tools) {
+    switch (tool.type) {
+      case "function":
+        anthropicTools2.push({
+          name: tool.name,
+          description: tool.description,
+          input_schema: tool.parameters
+        });
+        break;
+      case "provider-defined":
+        switch (tool.id) {
+          case "anthropic.computer_20250124":
+            betas.add("computer-use-2025-01-24");
+            anthropicTools2.push({
+              name: tool.name,
+              type: "computer_20250124",
+              display_width_px: tool.args.displayWidthPx,
+              display_height_px: tool.args.displayHeightPx,
+              display_number: tool.args.displayNumber
+            });
+            break;
+          case "anthropic.computer_20241022":
+            betas.add("computer-use-2024-10-22");
+            anthropicTools2.push({
+              name: tool.name,
+              type: "computer_20241022",
+              display_width_px: tool.args.displayWidthPx,
+              display_height_px: tool.args.displayHeightPx,
+              display_number: tool.args.displayNumber
+            });
+            break;
+          case "anthropic.text_editor_20241022":
+            betas.add("computer-use-2024-10-22");
+            anthropicTools2.push({
+              name: tool.name,
+              type: "text_editor_20241022"
+            });
+            break;
+          case "anthropic.bash_20241022":
+            betas.add("computer-use-2024-10-22");
+            anthropicTools2.push({
+              name: tool.name,
+              type: "bash_20241022"
+            });
+            break;
+          default:
+            toolWarnings.push({ type: "unsupported-tool", tool });
+            break;
+        }
+        break;
+      default:
+        toolWarnings.push({ type: "unsupported-tool", tool });
+        break;
+    }
+  }
+  const toolChoice = mode.toolChoice;
+  if (toolChoice == null) {
+    return {
+      tools: anthropicTools2,
+      tool_choice: void 0,
+      toolWarnings,
+      betas
+    };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+      return {
+        tools: anthropicTools2,
+        tool_choice: { type: "auto" },
+        toolWarnings,
+        betas
+      };
+    case "required":
+      return {
+        tools: anthropicTools2,
+        tool_choice: { type: "any" },
+        toolWarnings,
+        betas
+      };
+    case "none":
+      return { tools: void 0, tool_choice: void 0, toolWarnings, betas };
+    case "tool":
+      return {
+        tools: anthropicTools2,
+        tool_choice: { type: "tool", name: toolChoice.toolName },
+        toolWarnings,
+        betas
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new import_provider.UnsupportedFunctionalityError({
+        functionality: `Unsupported tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+
+// src/convert-to-anthropic-messages-prompt.ts
+var import_provider2 = require("@ai-sdk/provider");
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
 function convertToAnthropicMessagesPrompt({
   prompt
@@ -73,7 +182,7 @@ function convertToAnthropicMessagesPrompt({
     switch (type) {
       case "system": {
         if (system != null) {
-          throw new import_provider.UnsupportedFunctionalityError({
+          throw new import_provider2.UnsupportedFunctionalityError({
             functionality: "Multiple system messages that are separated by user/assistant messages"
           });
         }
@@ -105,7 +214,7 @@ function convertToAnthropicMessagesPrompt({
                   }
                   case "image": {
                     if (part.image instanceof URL) {
-                      throw new import_provider.UnsupportedFunctionalityError({
+                      throw new import_provider2.UnsupportedFunctionalityError({
                         functionality: "Image URLs in user messages"
                       });
                     }
@@ -122,12 +231,12 @@ function convertToAnthropicMessagesPrompt({
                   }
                   case "file": {
                     if (part.data instanceof URL) {
-                      throw new import_provider.UnsupportedFunctionalityError({
+                      throw new import_provider2.UnsupportedFunctionalityError({
                         functionality: "Image URLs in user messages"
                       });
                     }
                     if (part.mimeType !== "application/pdf") {
-                      throw new import_provider.UnsupportedFunctionalityError({
+                      throw new import_provider2.UnsupportedFunctionalityError({
                         functionality: "Non-PDF files in user messages"
                       });
                     }
@@ -216,6 +325,23 @@ function convertToAnthropicMessagesPrompt({
                 });
                 break;
               }
+              case "reasoning": {
+                anthropicContent.push({
+                  type: "thinking",
+                  thinking: part.text,
+                  signature: part.signature,
+                  cache_control: cacheControl
+                });
+                break;
+              }
+              case "redacted-reasoning": {
+                anthropicContent.push({
+                  type: "redacted_thinking",
+                  data: part.data,
+                  cache_control: cacheControl
+                });
+                break;
+              }
               case "tool-call": {
                 anthropicContent.push({
                   type: "tool_use",
@@ -226,6 +352,10 @@ function convertToAnthropicMessagesPrompt({
                 });
                 break;
               }
+              default: {
+                const _exhaustiveCheck = part;
+                throw new Error(`Unsupported part: ${_exhaustiveCheck}`);
+              }
             }
           }
         }
@@ -305,103 +435,6 @@ function mapAnthropicStopReason(finishReason) {
   }
 }
 
-// src/anthropic-prepare-tools.ts
-var import_provider2 = require("@ai-sdk/provider");
-function prepareTools(mode) {
-  var _a;
-  const tools = ((_a = mode.tools) == null ? void 0 : _a.length) ? mode.tools : void 0;
-  const toolWarnings = [];
-  const betas = /* @__PURE__ */ new Set();
-  if (tools == null) {
-    return { tools: void 0, tool_choice: void 0, toolWarnings, betas };
-  }
-  const anthropicTools2 = [];
-  for (const tool of tools) {
-    switch (tool.type) {
-      case "function":
-        anthropicTools2.push({
-          name: tool.name,
-          description: tool.description,
-          input_schema: tool.parameters
-        });
-        break;
-      case "provider-defined":
-        betas.add("computer-use-2024-10-22");
-        switch (tool.id) {
-          case "anthropic.computer_20241022":
-            anthropicTools2.push({
-              name: tool.name,
-              type: "computer_20241022",
-              display_width_px: tool.args.displayWidthPx,
-              display_height_px: tool.args.displayHeightPx,
-              display_number: tool.args.displayNumber
-            });
-            break;
-          case "anthropic.text_editor_20241022":
-            anthropicTools2.push({
-              name: tool.name,
-              type: "text_editor_20241022"
-            });
-            break;
-          case "anthropic.bash_20241022":
-            anthropicTools2.push({
-              name: tool.name,
-              type: "bash_20241022"
-            });
-            break;
-          default:
-            toolWarnings.push({ type: "unsupported-tool", tool });
-            break;
-        }
-        break;
-      default:
-        toolWarnings.push({ type: "unsupported-tool", tool });
-        break;
-    }
-  }
-  const toolChoice = mode.toolChoice;
-  if (toolChoice == null) {
-    return {
-      tools: anthropicTools2,
-      tool_choice: void 0,
-      toolWarnings,
-      betas
-    };
-  }
-  const type = toolChoice.type;
-  switch (type) {
-    case "auto":
-      return {
-        tools: anthropicTools2,
-        tool_choice: { type: "auto" },
-        toolWarnings,
-        betas
-      };
-    case "required":
-      return {
-        tools: anthropicTools2,
-        tool_choice: { type: "any" },
-        toolWarnings,
-        betas
-      };
-    case "none":
-      return { tools: void 0, tool_choice: void 0, toolWarnings, betas };
-    case "tool":
-      return {
-        tools: anthropicTools2,
-        tool_choice: { type: "tool", name: toolChoice.toolName },
-        toolWarnings,
-        betas
-      };
-    default: {
-      const _exhaustiveCheck = type;
-      throw new import_provider2.UnsupportedFunctionalityError({
-        functionality: `Unsupported tool choice type: ${_exhaustiveCheck}`
-      });
-    }
-  }
-}
-
 // src/anthropic-messages-language-model.ts
 var AnthropicMessagesLanguageModel = class {
   constructor(modelId, settings, config) {
@@ -418,7 +451,8 @@ var AnthropicMessagesLanguageModel = class {
   async getArgs({
     mode,
     prompt,
-    maxTokens,
+    maxTokens = 4096,
+    // 4096: max model output tokens TODO update default in v5
     temperature,
     topP,
     topK,
@@ -426,8 +460,10 @@ var AnthropicMessagesLanguageModel = class {
     presencePenalty,
     stopSequences,
     responseFormat,
-    seed
+    seed,
+    providerMetadata: providerOptions
   }) {
+    var _a, _b, _c;
     const type = mode.type;
     const warnings = [];
     if (frequencyPenalty != null) {
@@ -458,20 +494,67 @@ var AnthropicMessagesLanguageModel = class {
     const { prompt: messagesPrompt, betas: messagesBetas } = convertToAnthropicMessagesPrompt({
       prompt
     });
+    const thinkingOptions = thinkingOptionsSchema.safeParse(
+      (_a = providerOptions == null ? void 0 : providerOptions.anthropic) == null ? void 0 : _a.thinking
+    );
+    if (!thinkingOptions.success) {
+      throw new import_provider3.InvalidArgumentError({
+        argument: "providerOptions.anthropic.thinking",
+        message: "invalid thinking options",
+        cause: thinkingOptions.error
+      });
+    }
+    const isThinking = ((_b = thinkingOptions.data) == null ? void 0 : _b.type) === "enabled";
+    const thinkingBudget = (_c = thinkingOptions.data) == null ? void 0 : _c.budgetTokens;
     const baseArgs = {
       // model id:
       model: this.modelId,
       // standardized settings:
-      max_tokens: maxTokens != null ? maxTokens : 4096,
-      // 4096: max model output tokens TODO remove
+      max_tokens: maxTokens,
       temperature,
       top_k: topK,
       top_p: topP,
       stop_sequences: stopSequences,
+      // provider specific settings:
+      ...isThinking && {
+        thinking: { type: "enabled", budget_tokens: thinkingBudget }
+      },
       // prompt:
       system: messagesPrompt.system,
       messages: messagesPrompt.messages
     };
+    if (isThinking) {
+      if (thinkingBudget == null) {
+        throw new import_provider3.UnsupportedFunctionalityError({
+          functionality: "thinking requires a budget"
+        });
+      }
+      if (baseArgs.temperature != null) {
+        baseArgs.temperature = void 0;
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "temperature",
+          details: "temperature is not supported when thinking is enabled"
+        });
+      }
+      if (topK != null) {
+        baseArgs.top_k = void 0;
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "topK",
+          details: "topK is not supported when thinking is enabled"
+        });
+      }
+      if (topP != null) {
+        baseArgs.top_p = void 0;
+        warnings.push({
+          type: "unsupported-setting",
+          setting: "topP",
+          details: "topP is not supported when thinking is enabled"
+        });
+      }
+      baseArgs.max_tokens = maxTokens + thinkingBudget;
+    }
     switch (type) {
       case "regular": {
         const {
@@ -562,8 +645,21 @@ var AnthropicMessagesLanguageModel = class {
         }
       }
     }
+    const reasoning = response.content.filter(
+      (content) => content.type === "redacted_thinking" || content.type === "thinking"
+    ).map(
+      (content) => content.type === "thinking" ? {
+        type: "text",
+        text: content.thinking,
+        signature: content.signature
+      } : {
+        type: "redacted",
+        data: content.data
+      }
+    );
     return {
       text,
+      reasoning: reasoning.length > 0 ? reasoning : void 0,
       toolCalls,
       finishReason: mapAnthropicStopReason(response.stop_reason),
       usage: {
@@ -608,7 +704,7 @@ var AnthropicMessagesLanguageModel = class {
     };
     const toolCallContentBlocks = {};
     let providerMetadata = void 0;
-    const self = this;
+    let blockType = void 0;
     return {
       stream: response.pipeThrough(
         new TransformStream({
@@ -625,8 +721,17 @@ var AnthropicMessagesLanguageModel = class {
               }
               case "content_block_start": {
                 const contentBlockType = value.content_block.type;
+                blockType = contentBlockType;
                 switch (contentBlockType) {
-                  case "text": {
+                  case "text":
+                  case "thinking": {
+                    return;
+                  }
+                  case "redacted_thinking": {
+                    controller.enqueue({
+                      type: "redacted-reasoning",
+                      data: value.content_block.data
+                    });
                     return;
                   }
                   case "tool_use": {
@@ -657,6 +762,7 @@ var AnthropicMessagesLanguageModel = class {
                   });
                   delete toolCallContentBlocks[value.index];
                 }
+                blockType = void 0;
                 return;
               }
               case "content_block_delta": {
@@ -669,6 +775,22 @@ var AnthropicMessagesLanguageModel = class {
                     });
                     return;
                   }
+                  case "thinking_delta": {
+                    controller.enqueue({
+                      type: "reasoning",
+                      textDelta: value.delta.thinking
+                    });
+                    return;
+                  }
+                  case "signature_delta": {
+                    if (blockType === "thinking") {
+                      controller.enqueue({
+                        type: "reasoning-signature",
+                        signature: value.delta.signature
+                      });
+                    }
+                    return;
+                  }
                   case "input_json_delta": {
                     const contentBlock = toolCallContentBlocks[value.index];
                     controller.enqueue({
@@ -748,6 +870,15 @@ var anthropicMessagesResponseSchema = import_zod2.z.object({
         type: import_zod2.z.literal("text"),
         text: import_zod2.z.string()
       }),
+      import_zod2.z.object({
+        type: import_zod2.z.literal("thinking"),
+        thinking: import_zod2.z.string(),
+        signature: import_zod2.z.string()
+      }),
+      import_zod2.z.object({
+        type: import_zod2.z.literal("redacted_thinking"),
+        data: import_zod2.z.string()
+      }),
       import_zod2.z.object({
         type: import_zod2.z.literal("tool_use"),
         id: import_zod2.z.string(),
@@ -786,10 +917,18 @@ var anthropicMessagesChunkSchema = import_zod2.z.discriminatedUnion("type", [
         type: import_zod2.z.literal("text"),
         text: import_zod2.z.string()
       }),
+      import_zod2.z.object({
+        type: import_zod2.z.literal("thinking"),
+        thinking: import_zod2.z.string()
+      }),
       import_zod2.z.object({
         type: import_zod2.z.literal("tool_use"),
         id: import_zod2.z.string(),
         name: import_zod2.z.string()
+      }),
+      import_zod2.z.object({
+        type: import_zod2.z.literal("redacted_thinking"),
+        data: import_zod2.z.string()
       })
     ])
   }),
@@ -804,6 +943,14 @@ var anthropicMessagesChunkSchema = import_zod2.z.discriminatedUnion("type", [
       import_zod2.z.object({
         type: import_zod2.z.literal("text_delta"),
         text: import_zod2.z.string()
+      }),
+      import_zod2.z.object({
+        type: import_zod2.z.literal("thinking_delta"),
+        thinking: import_zod2.z.string()
+      }),
+      import_zod2.z.object({
+        type: import_zod2.z.literal("signature_delta"),
+        signature: import_zod2.z.string()
       })
     ])
   }),
@@ -830,6 +977,10 @@ var anthropicMessagesChunkSchema = import_zod2.z.discriminatedUnion("type", [
     type: import_zod2.z.literal("ping")
   })
 ]);
+var thinkingOptionsSchema = import_zod2.z.object({
+  type: import_zod2.z.union([import_zod2.z.literal("enabled"), import_zod2.z.literal("disabled")]),
+  budgetTokens: import_zod2.z.number().optional()
+}).optional();
 
 // src/anthropic-tools.ts
 var import_zod3 = require("zod");
@@ -896,10 +1047,51 @@ function computerTool_20241022(options) {
     experimental_toToolResultContent: options.experimental_toToolResultContent
   };
 }
+var Computer20250124Parameters = import_zod3.z.object({
+  action: import_zod3.z.enum([
+    "key",
+    "hold_key",
+    "type",
+    "cursor_position",
+    "mouse_move",
+    "left_mouse_down",
+    "left_mouse_up",
+    "left_click",
+    "left_click_drag",
+    "right_click",
+    "middle_click",
+    "double_click",
+    "triple_click",
+    "scroll",
+    "wait",
+    "screenshot"
+  ]),
+  coordinate: import_zod3.z.tuple([import_zod3.z.number().int(), import_zod3.z.number().int()]).optional(),
+  duration: import_zod3.z.number().optional(),
+  scroll_amount: import_zod3.z.number().optional(),
+  scroll_direction: import_zod3.z.enum(["up", "down", "left", "right"]).optional(),
+  start_coordinate: import_zod3.z.tuple([import_zod3.z.number().int(), import_zod3.z.number().int()]).optional(),
+  text: import_zod3.z.string().optional()
+});
+function computerTool_20250124(options) {
+  return {
+    type: "provider-defined",
+    id: "anthropic.computer_20250124",
+    args: {
+      displayWidthPx: options.displayWidthPx,
+      displayHeightPx: options.displayHeightPx,
+      displayNumber: options.displayNumber
+    },
+    parameters: Computer20250124Parameters,
+    execute: options.execute,
+    experimental_toToolResultContent: options.experimental_toToolResultContent
+  };
+}
 var anthropicTools = {
   bash_20241022: bashTool_20241022,
   textEditor_20241022: textEditorTool_20241022,
-  computer_20241022: computerTool_20241022
+  computer_20241022: computerTool_20241022,
+  computer_20250124: computerTool_20250124
 };
 
 // src/anthropic-provider.ts