@ai-sdk/anthropic 2.0.0-canary.10 → 2.0.0-canary.12

package/dist/index.js

@@ -32,7 +32,7 @@ var import_provider_utils4 = require("@ai-sdk/provider-utils");
 // src/anthropic-messages-language-model.ts
 var import_provider3 = require("@ai-sdk/provider");
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/anthropic-error.ts
 var import_provider_utils = require("@ai-sdk/provider-utils");
@@ -49,6 +49,21 @@ var anthropicFailedResponseHandler = (0, import_provider_utils.createJsonErrorRe
   errorToMessage: (data) => data.error.message
 });
 
+// src/anthropic-messages-options.ts
+var import_zod2 = require("zod");
+var anthropicProviderOptions = import_zod2.z.object({
+  /**
+  Include reasoning content in requests sent to the model. Defaults to `true`.
+  
+  If you are experiencing issues with the model handling requests involving
+    */
+  sendReasoning: import_zod2.z.boolean().optional(),
+  thinking: 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-prepare-tools.ts
 var import_provider = require("@ai-sdk/provider");
 function prepareTools({
@@ -176,7 +191,7 @@ function prepareTools({
 // 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({
+async function convertToAnthropicMessagesPrompt({
   prompt,
   sendReasoning,
   warnings
@@ -339,12 +354,37 @@ function convertToAnthropicMessagesPrompt({
               }
               case "reasoning": {
                 if (sendReasoning) {
-                  anthropicContent.push({
-                    type: "thinking",
-                    thinking: part.text,
-                    signature: part.signature,
-                    cache_control: cacheControl
+                  const reasoningMetadata = await (0, import_provider_utils2.parseProviderOptions)({
+                    provider: "anthropic",
+                    providerOptions: part.providerOptions,
+                    schema: anthropicReasoningMetadataSchema
                   });
+                  if (reasoningMetadata != null) {
+                    if (reasoningMetadata.signature != null) {
+                      anthropicContent.push({
+                        type: "thinking",
+                        thinking: part.text,
+                        signature: reasoningMetadata.signature,
+                        cache_control: cacheControl
+                      });
+                    } else if (reasoningMetadata.redactedData != null) {
+                      anthropicContent.push({
+                        type: "redacted_thinking",
+                        data: reasoningMetadata.redactedData,
+                        cache_control: cacheControl
+                      });
+                    } else {
+                      warnings.push({
+                        type: "other",
+                        message: "unsupported reasoning metadata"
+                      });
+                    }
+                  } else {
+                    warnings.push({
+                      type: "other",
+                      message: "unsupported reasoning metadata"
+                    });
+                  }
                 } else {
                   warnings.push({
                     type: "other",
@@ -353,14 +393,6 @@ function convertToAnthropicMessagesPrompt({
                 }
                 break;
               }
-              case "redacted-reasoning": {
-                anthropicContent.push({
-                  type: "redacted_thinking",
-                  data: part.data,
-                  cache_control: cacheControl
-                });
-                break;
-              }
               case "tool-call": {
                 anthropicContent.push({
                   type: "tool_use",
@@ -452,10 +484,9 @@ function mapAnthropicStopReason(finishReason) {
 
 // src/anthropic-messages-language-model.ts
 var AnthropicMessagesLanguageModel = class {
-  constructor(modelId, settings, config) {
+  constructor(modelId, config) {
     this.specificationVersion = "v2";
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
   }
   supportsUrl(url) {
@@ -511,15 +542,15 @@ var AnthropicMessagesLanguageModel = class {
         details: "JSON response format is not supported."
       });
     }
-    const { prompt: messagesPrompt, betas: messagesBetas } = convertToAnthropicMessagesPrompt({
-      prompt,
-      sendReasoning: (_a = this.settings.sendReasoning) != null ? _a : true,
-      warnings
-    });
-    const anthropicOptions = (0, import_provider_utils3.parseProviderOptions)({
+    const anthropicOptions = await (0, import_provider_utils3.parseProviderOptions)({
       provider: "anthropic",
       providerOptions,
-      schema: anthropicProviderOptionsSchema
+      schema: anthropicProviderOptions
+    });
+    const { prompt: messagesPrompt, betas: messagesBetas } = await convertToAnthropicMessagesPrompt({
+      prompt,
+      sendReasoning: (_a = anthropicOptions == null ? void 0 : anthropicOptions.sendReasoning) != null ? _a : true,
+      warnings
     });
     const isThinking = ((_b = anthropicOptions == null ? void 0 : anthropicOptions.thinking) == null ? void 0 : _b.type) === "enabled";
     const thinkingBudget = (_c = anthropicOptions == null ? void 0 : anthropicOptions.thinking) == null ? void 0 : _c.budgetTokens;
@@ -634,21 +665,24 @@ var AnthropicMessagesLanguageModel = class {
         case "thinking": {
           content.push({
             type: "reasoning",
-            reasoningType: "text",
-            text: part.thinking
-          });
-          content.push({
-            type: "reasoning",
-            reasoningType: "signature",
-            signature: part.signature
+            text: part.thinking,
+            providerMetadata: {
+              anthropic: {
+                signature: part.signature
+              }
+            }
           });
           break;
         }
         case "redacted_thinking": {
           content.push({
             type: "reasoning",
-            reasoningType: "redacted",
-            data: part.data
+            text: "",
+            providerMetadata: {
+              anthropic: {
+                redactedData: part.data
+              }
+            }
           });
           break;
         }
@@ -737,9 +771,14 @@ var AnthropicMessagesLanguageModel = class {
                   case "redacted_thinking": {
                     controller.enqueue({
                       type: "reasoning",
-                      reasoningType: "redacted",
-                      data: value.content_block.data
+                      text: "",
+                      providerMetadata: {
+                        anthropic: {
+                          redactedData: value.content_block.data
+                        }
+                      }
                     });
+                    controller.enqueue({ type: "reasoning-part-finish" });
                     return;
                   }
                   case "tool_use": {
@@ -786,7 +825,6 @@ var AnthropicMessagesLanguageModel = class {
                   case "thinking_delta": {
                     controller.enqueue({
                       type: "reasoning",
-                      reasoningType: "text",
                       text: value.delta.thinking
                     });
                     return;
@@ -795,9 +833,14 @@ var AnthropicMessagesLanguageModel = class {
                     if (blockType === "thinking") {
                       controller.enqueue({
                         type: "reasoning",
-                        reasoningType: "signature",
-                        signature: value.delta.signature
+                        text: "",
+                        providerMetadata: {
+                          anthropic: {
+                            signature: value.delta.signature
+                          }
+                        }
                       });
+                      controller.enqueue({ type: "reasoning-part-finish" });
                     }
                     return;
                   }
@@ -868,135 +911,133 @@ var AnthropicMessagesLanguageModel = class {
     };
   }
 };
-var anthropicMessagesResponseSchema = import_zod2.z.object({
-  type: import_zod2.z.literal("message"),
-  id: import_zod2.z.string().nullish(),
-  model: import_zod2.z.string().nullish(),
-  content: import_zod2.z.array(
-    import_zod2.z.discriminatedUnion("type", [
-      import_zod2.z.object({
-        type: import_zod2.z.literal("text"),
-        text: import_zod2.z.string()
+var anthropicMessagesResponseSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("message"),
+  id: import_zod3.z.string().nullish(),
+  model: import_zod3.z.string().nullish(),
+  content: import_zod3.z.array(
+    import_zod3.z.discriminatedUnion("type", [
+      import_zod3.z.object({
+        type: import_zod3.z.literal("text"),
+        text: import_zod3.z.string()
       }),
-      import_zod2.z.object({
-        type: import_zod2.z.literal("thinking"),
-        thinking: import_zod2.z.string(),
-        signature: import_zod2.z.string()
+      import_zod3.z.object({
+        type: import_zod3.z.literal("thinking"),
+        thinking: import_zod3.z.string(),
+        signature: import_zod3.z.string()
       }),
-      import_zod2.z.object({
-        type: import_zod2.z.literal("redacted_thinking"),
-        data: import_zod2.z.string()
+      import_zod3.z.object({
+        type: import_zod3.z.literal("redacted_thinking"),
+        data: import_zod3.z.string()
       }),
-      import_zod2.z.object({
-        type: import_zod2.z.literal("tool_use"),
-        id: import_zod2.z.string(),
-        name: import_zod2.z.string(),
-        input: import_zod2.z.unknown()
+      import_zod3.z.object({
+        type: import_zod3.z.literal("tool_use"),
+        id: import_zod3.z.string(),
+        name: import_zod3.z.string(),
+        input: import_zod3.z.unknown()
       })
     ])
   ),
-  stop_reason: import_zod2.z.string().nullish(),
-  usage: import_zod2.z.object({
-    input_tokens: import_zod2.z.number(),
-    output_tokens: import_zod2.z.number(),
-    cache_creation_input_tokens: import_zod2.z.number().nullish(),
-    cache_read_input_tokens: import_zod2.z.number().nullish()
+  stop_reason: import_zod3.z.string().nullish(),
+  usage: import_zod3.z.object({
+    input_tokens: import_zod3.z.number(),
+    output_tokens: import_zod3.z.number(),
+    cache_creation_input_tokens: import_zod3.z.number().nullish(),
+    cache_read_input_tokens: import_zod3.z.number().nullish()
   })
 });
-var anthropicMessagesChunkSchema = import_zod2.z.discriminatedUnion("type", [
-  import_zod2.z.object({
-    type: import_zod2.z.literal("message_start"),
-    message: import_zod2.z.object({
-      id: import_zod2.z.string().nullish(),
-      model: import_zod2.z.string().nullish(),
-      usage: import_zod2.z.object({
-        input_tokens: import_zod2.z.number(),
-        output_tokens: import_zod2.z.number(),
-        cache_creation_input_tokens: import_zod2.z.number().nullish(),
-        cache_read_input_tokens: import_zod2.z.number().nullish()
+var anthropicMessagesChunkSchema = import_zod3.z.discriminatedUnion("type", [
+  import_zod3.z.object({
+    type: import_zod3.z.literal("message_start"),
+    message: import_zod3.z.object({
+      id: import_zod3.z.string().nullish(),
+      model: import_zod3.z.string().nullish(),
+      usage: import_zod3.z.object({
+        input_tokens: import_zod3.z.number(),
+        output_tokens: import_zod3.z.number(),
+        cache_creation_input_tokens: import_zod3.z.number().nullish(),
+        cache_read_input_tokens: import_zod3.z.number().nullish()
       })
     })
   }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("content_block_start"),
-    index: import_zod2.z.number(),
-    content_block: import_zod2.z.discriminatedUnion("type", [
-      import_zod2.z.object({
-        type: import_zod2.z.literal("text"),
-        text: import_zod2.z.string()
+  import_zod3.z.object({
+    type: import_zod3.z.literal("content_block_start"),
+    index: import_zod3.z.number(),
+    content_block: import_zod3.z.discriminatedUnion("type", [
+      import_zod3.z.object({
+        type: import_zod3.z.literal("text"),
+        text: import_zod3.z.string()
       }),
-      import_zod2.z.object({
-        type: import_zod2.z.literal("thinking"),
-        thinking: import_zod2.z.string()
+      import_zod3.z.object({
+        type: import_zod3.z.literal("thinking"),
+        thinking: import_zod3.z.string()
       }),
-      import_zod2.z.object({
-        type: import_zod2.z.literal("tool_use"),
-        id: import_zod2.z.string(),
-        name: import_zod2.z.string()
+      import_zod3.z.object({
+        type: import_zod3.z.literal("tool_use"),
+        id: import_zod3.z.string(),
+        name: import_zod3.z.string()
       }),
-      import_zod2.z.object({
-        type: import_zod2.z.literal("redacted_thinking"),
-        data: import_zod2.z.string()
+      import_zod3.z.object({
+        type: import_zod3.z.literal("redacted_thinking"),
+        data: import_zod3.z.string()
       })
     ])
   }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("content_block_delta"),
-    index: import_zod2.z.number(),
-    delta: import_zod2.z.discriminatedUnion("type", [
-      import_zod2.z.object({
-        type: import_zod2.z.literal("input_json_delta"),
-        partial_json: import_zod2.z.string()
+  import_zod3.z.object({
+    type: import_zod3.z.literal("content_block_delta"),
+    index: import_zod3.z.number(),
+    delta: import_zod3.z.discriminatedUnion("type", [
+      import_zod3.z.object({
+        type: import_zod3.z.literal("input_json_delta"),
+        partial_json: import_zod3.z.string()
       }),
-      import_zod2.z.object({
-        type: import_zod2.z.literal("text_delta"),
-        text: import_zod2.z.string()
+      import_zod3.z.object({
+        type: import_zod3.z.literal("text_delta"),
+        text: import_zod3.z.string()
       }),
-      import_zod2.z.object({
-        type: import_zod2.z.literal("thinking_delta"),
-        thinking: import_zod2.z.string()
+      import_zod3.z.object({
+        type: import_zod3.z.literal("thinking_delta"),
+        thinking: import_zod3.z.string()
       }),
-      import_zod2.z.object({
-        type: import_zod2.z.literal("signature_delta"),
-        signature: import_zod2.z.string()
+      import_zod3.z.object({
+        type: import_zod3.z.literal("signature_delta"),
+        signature: import_zod3.z.string()
       })
     ])
   }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("content_block_stop"),
-    index: import_zod2.z.number()
+  import_zod3.z.object({
+    type: import_zod3.z.literal("content_block_stop"),
+    index: import_zod3.z.number()
   }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("error"),
-    error: import_zod2.z.object({
-      type: import_zod2.z.string(),
-      message: import_zod2.z.string()
+  import_zod3.z.object({
+    type: import_zod3.z.literal("error"),
+    error: import_zod3.z.object({
+      type: import_zod3.z.string(),
+      message: import_zod3.z.string()
     })
   }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("message_delta"),
-    delta: import_zod2.z.object({ stop_reason: import_zod2.z.string().nullish() }),
-    usage: import_zod2.z.object({ output_tokens: import_zod2.z.number() })
+  import_zod3.z.object({
+    type: import_zod3.z.literal("message_delta"),
+    delta: import_zod3.z.object({ stop_reason: import_zod3.z.string().nullish() }),
+    usage: import_zod3.z.object({ output_tokens: import_zod3.z.number() })
   }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("message_stop")
+  import_zod3.z.object({
+    type: import_zod3.z.literal("message_stop")
   }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("ping")
+  import_zod3.z.object({
+    type: import_zod3.z.literal("ping")
   })
 ]);
-var anthropicProviderOptionsSchema = import_zod2.z.object({
-  thinking: 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()
+var anthropicReasoningMetadataSchema = import_zod3.z.object({
+  signature: import_zod3.z.string().optional(),
+  redactedData: import_zod3.z.string().optional()
 });
 
 // src/anthropic-tools.ts
-var import_zod3 = require("zod");
-var Bash20241022Parameters = import_zod3.z.object({
-  command: import_zod3.z.string(),
-  restart: import_zod3.z.boolean().optional()
+var import_zod4 = require("zod");
+var Bash20241022Parameters = import_zod4.z.object({
+  command: import_zod4.z.string(),
+  restart: import_zod4.z.boolean().optional()
 });
 function bashTool_20241022(options = {}) {
   return {
@@ -1008,9 +1049,9 @@ function bashTool_20241022(options = {}) {
     experimental_toToolResultContent: options.experimental_toToolResultContent
   };
 }
-var Bash20250124Parameters = import_zod3.z.object({
-  command: import_zod3.z.string(),
-  restart: import_zod3.z.boolean().optional()
+var Bash20250124Parameters = import_zod4.z.object({
+  command: import_zod4.z.string(),
+  restart: import_zod4.z.boolean().optional()
 });
 function bashTool_20250124(options = {}) {
   return {
@@ -1022,14 +1063,14 @@ function bashTool_20250124(options = {}) {
     experimental_toToolResultContent: options.experimental_toToolResultContent
   };
 }
-var TextEditor20241022Parameters = import_zod3.z.object({
-  command: import_zod3.z.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
-  path: import_zod3.z.string(),
-  file_text: import_zod3.z.string().optional(),
-  insert_line: import_zod3.z.number().int().optional(),
-  new_str: import_zod3.z.string().optional(),
-  old_str: import_zod3.z.string().optional(),
-  view_range: import_zod3.z.array(import_zod3.z.number().int()).optional()
+var TextEditor20241022Parameters = import_zod4.z.object({
+  command: import_zod4.z.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
+  path: import_zod4.z.string(),
+  file_text: import_zod4.z.string().optional(),
+  insert_line: import_zod4.z.number().int().optional(),
+  new_str: import_zod4.z.string().optional(),
+  old_str: import_zod4.z.string().optional(),
+  view_range: import_zod4.z.array(import_zod4.z.number().int()).optional()
 });
 function textEditorTool_20241022(options = {}) {
   return {
@@ -1041,14 +1082,14 @@ function textEditorTool_20241022(options = {}) {
     experimental_toToolResultContent: options.experimental_toToolResultContent
   };
 }
-var TextEditor20250124Parameters = import_zod3.z.object({
-  command: import_zod3.z.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
-  path: import_zod3.z.string(),
-  file_text: import_zod3.z.string().optional(),
-  insert_line: import_zod3.z.number().int().optional(),
-  new_str: import_zod3.z.string().optional(),
-  old_str: import_zod3.z.string().optional(),
-  view_range: import_zod3.z.array(import_zod3.z.number().int()).optional()
+var TextEditor20250124Parameters = import_zod4.z.object({
+  command: import_zod4.z.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
+  path: import_zod4.z.string(),
+  file_text: import_zod4.z.string().optional(),
+  insert_line: import_zod4.z.number().int().optional(),
+  new_str: import_zod4.z.string().optional(),
+  old_str: import_zod4.z.string().optional(),
+  view_range: import_zod4.z.array(import_zod4.z.number().int()).optional()
 });
 function textEditorTool_20250124(options = {}) {
   return {
@@ -1060,8 +1101,8 @@ function textEditorTool_20250124(options = {}) {
     experimental_toToolResultContent: options.experimental_toToolResultContent
   };
 }
-var Computer20241022Parameters = import_zod3.z.object({
-  action: import_zod3.z.enum([
+var Computer20241022Parameters = import_zod4.z.object({
+  action: import_zod4.z.enum([
     "key",
     "type",
     "mouse_move",
@@ -1073,8 +1114,8 @@ var Computer20241022Parameters = import_zod3.z.object({
     "screenshot",
     "cursor_position"
   ]),
-  coordinate: import_zod3.z.array(import_zod3.z.number().int()).optional(),
-  text: import_zod3.z.string().optional()
+  coordinate: import_zod4.z.array(import_zod4.z.number().int()).optional(),
+  text: import_zod4.z.string().optional()
 });
 function computerTool_20241022(options) {
   return {
@@ -1090,8 +1131,8 @@ function computerTool_20241022(options) {
     experimental_toToolResultContent: options.experimental_toToolResultContent
   };
 }
-var Computer20250124Parameters = import_zod3.z.object({
-  action: import_zod3.z.enum([
+var Computer20250124Parameters = import_zod4.z.object({
+  action: import_zod4.z.enum([
     "key",
     "hold_key",
     "type",
@@ -1109,12 +1150,12 @@ var Computer20250124Parameters = import_zod3.z.object({
     "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()
+  coordinate: import_zod4.z.tuple([import_zod4.z.number().int(), import_zod4.z.number().int()]).optional(),
+  duration: import_zod4.z.number().optional(),
+  scroll_amount: import_zod4.z.number().optional(),
+  scroll_direction: import_zod4.z.enum(["up", "down", "left", "right"]).optional(),
+  start_coordinate: import_zod4.z.tuple([import_zod4.z.number().int(), import_zod4.z.number().int()]).optional(),
+  text: import_zod4.z.string().optional()
 });
 function computerTool_20250124(options) {
   return {
@@ -1152,7 +1193,7 @@ function createAnthropic(options = {}) {
     }),
     ...options.headers
   });
-  const createChatModel = (modelId, settings = {}) => new AnthropicMessagesLanguageModel(modelId, settings, {
+  const createChatModel = (modelId) => new AnthropicMessagesLanguageModel(modelId, {
     provider: "anthropic.messages",
     baseURL,
     headers: getHeaders,
@@ -1161,13 +1202,13 @@ function createAnthropic(options = {}) {
       "image/*": [/^https?:\/\/.*$/]
     })
   });
-  const provider = function(modelId, settings) {
+  const provider = function(modelId) {
     if (new.target) {
       throw new Error(
         "The Anthropic model function cannot be called with the new keyword."
       );
     }
-    return createChatModel(modelId, settings);
+    return createChatModel(modelId);
   };
   provider.languageModel = createChatModel;
   provider.chat = createChatModel;