@ai-sdk/anthropic 4.0.0-beta.4 → 4.0.0-beta.40

package/dist/internal/index.js

@@ -1,367 +1,361 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/internal/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AnthropicMessagesLanguageModel: () => AnthropicMessagesLanguageModel,
-  anthropicTools: () => anthropicTools,
-  prepareTools: () => prepareTools
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/anthropic-messages-language-model.ts
-var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils15 = require("@ai-sdk/provider-utils");
+// src/anthropic-language-model.ts
+import {
+  APICallError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler,
+  createToolNameMapping,
+  generateId,
+  isCustomReasoning,
+  mapReasoningToProviderBudget,
+  mapReasoningToProviderEffort,
+  parseProviderOptions as parseProviderOptions2,
+  postJsonToApi,
+  resolve,
+  resolveProviderReference as resolveProviderReference2,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE
+} from "@ai-sdk/provider-utils";
 
 // src/anthropic-error.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_v4 = require("zod/v4");
-var anthropicErrorDataSchema = (0, import_provider_utils.lazySchema)(
-  () => (0, import_provider_utils.zodSchema)(
-    import_v4.z.object({
-      type: import_v4.z.literal("error"),
-      error: import_v4.z.object({
-        type: import_v4.z.string(),
-        message: import_v4.z.string()
+import {
+  createJsonErrorResponseHandler,
+  lazySchema,
+  zodSchema
+} from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var anthropicErrorDataSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      type: z.literal("error"),
+      error: z.object({
+        type: z.string(),
+        message: z.string()
       })
     })
   )
 );
-var anthropicFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)({
+var anthropicFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: anthropicErrorDataSchema,
   errorToMessage: (data) => data.error.message
 });
 
-// src/anthropic-messages-api.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_v42 = require("zod/v4");
-var anthropicMessagesResponseSchema = (0, import_provider_utils2.lazySchema)(
-  () => (0, import_provider_utils2.zodSchema)(
-    import_v42.z.object({
-      type: import_v42.z.literal("message"),
-      id: import_v42.z.string().nullish(),
-      model: import_v42.z.string().nullish(),
-      content: import_v42.z.array(
-        import_v42.z.discriminatedUnion("type", [
-          import_v42.z.object({
-            type: import_v42.z.literal("text"),
-            text: import_v42.z.string(),
-            citations: import_v42.z.array(
-              import_v42.z.discriminatedUnion("type", [
-                import_v42.z.object({
-                  type: import_v42.z.literal("web_search_result_location"),
-                  cited_text: import_v42.z.string(),
-                  url: import_v42.z.string(),
-                  title: import_v42.z.string(),
-                  encrypted_index: import_v42.z.string()
+// src/anthropic-api.ts
+import { lazySchema as lazySchema2, zodSchema as zodSchema2 } from "@ai-sdk/provider-utils";
+import { z as z2 } from "zod/v4";
+var anthropicResponseSchema = lazySchema2(
+  () => zodSchema2(
+    z2.object({
+      type: z2.literal("message"),
+      id: z2.string().nullish(),
+      model: z2.string().nullish(),
+      content: z2.array(
+        z2.discriminatedUnion("type", [
+          z2.object({
+            type: z2.literal("text"),
+            text: z2.string(),
+            citations: z2.array(
+              z2.discriminatedUnion("type", [
+                z2.object({
+                  type: z2.literal("web_search_result_location"),
+                  cited_text: z2.string(),
+                  url: z2.string(),
+                  title: z2.string(),
+                  encrypted_index: z2.string()
                 }),
-                import_v42.z.object({
-                  type: import_v42.z.literal("page_location"),
-                  cited_text: import_v42.z.string(),
-                  document_index: import_v42.z.number(),
-                  document_title: import_v42.z.string().nullable(),
-                  start_page_number: import_v42.z.number(),
-                  end_page_number: import_v42.z.number()
+                z2.object({
+                  type: z2.literal("page_location"),
+                  cited_text: z2.string(),
+                  document_index: z2.number(),
+                  document_title: z2.string().nullable(),
+                  start_page_number: z2.number(),
+                  end_page_number: z2.number()
                 }),
-                import_v42.z.object({
-                  type: import_v42.z.literal("char_location"),
-                  cited_text: import_v42.z.string(),
-                  document_index: import_v42.z.number(),
-                  document_title: import_v42.z.string().nullable(),
-                  start_char_index: import_v42.z.number(),
-                  end_char_index: import_v42.z.number()
+                z2.object({
+                  type: z2.literal("char_location"),
+                  cited_text: z2.string(),
+                  document_index: z2.number(),
+                  document_title: z2.string().nullable(),
+                  start_char_index: z2.number(),
+                  end_char_index: z2.number()
                 })
               ])
             ).optional()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("thinking"),
-            thinking: import_v42.z.string(),
-            signature: import_v42.z.string()
+          z2.object({
+            type: z2.literal("thinking"),
+            thinking: z2.string(),
+            signature: z2.string()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("redacted_thinking"),
-            data: import_v42.z.string()
+          z2.object({
+            type: z2.literal("redacted_thinking"),
+            data: z2.string()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("compaction"),
-            content: import_v42.z.string()
+          z2.object({
+            type: z2.literal("compaction"),
+            content: z2.string()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("tool_use"),
-            id: import_v42.z.string(),
-            name: import_v42.z.string(),
-            input: import_v42.z.unknown(),
+          z2.object({
+            type: z2.literal("tool_use"),
+            id: z2.string(),
+            name: z2.string(),
+            input: z2.unknown(),
             // Programmatic tool calling: caller info when triggered from code execution
-            caller: import_v42.z.union([
-              import_v42.z.object({
-                type: import_v42.z.literal("code_execution_20250825"),
-                tool_id: import_v42.z.string()
+            caller: z2.union([
+              z2.object({
+                type: z2.literal("code_execution_20250825"),
+                tool_id: z2.string()
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("code_execution_20260120"),
-                tool_id: import_v42.z.string()
+              z2.object({
+                type: z2.literal("code_execution_20260120"),
+                tool_id: z2.string()
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("direct")
+              z2.object({
+                type: z2.literal("direct")
               })
             ]).optional()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("server_tool_use"),
-            id: import_v42.z.string(),
-            name: import_v42.z.string(),
-            input: import_v42.z.record(import_v42.z.string(), import_v42.z.unknown()).nullish(),
-            caller: import_v42.z.union([
-              import_v42.z.object({
-                type: import_v42.z.literal("code_execution_20260120"),
-                tool_id: import_v42.z.string()
+          z2.object({
+            type: z2.literal("server_tool_use"),
+            id: z2.string(),
+            name: z2.string(),
+            input: z2.record(z2.string(), z2.unknown()).nullish(),
+            caller: z2.union([
+              z2.object({
+                type: z2.literal("code_execution_20260120"),
+                tool_id: z2.string()
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("direct")
+              z2.object({
+                type: z2.literal("direct")
               })
             ]).optional()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("mcp_tool_use"),
-            id: import_v42.z.string(),
-            name: import_v42.z.string(),
-            input: import_v42.z.unknown(),
-            server_name: import_v42.z.string()
+          z2.object({
+            type: z2.literal("mcp_tool_use"),
+            id: z2.string(),
+            name: z2.string(),
+            input: z2.unknown(),
+            server_name: z2.string()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("mcp_tool_result"),
-            tool_use_id: import_v42.z.string(),
-            is_error: import_v42.z.boolean(),
-            content: import_v42.z.array(
-              import_v42.z.union([
-                import_v42.z.string(),
-                import_v42.z.object({ type: import_v42.z.literal("text"), text: import_v42.z.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() })
               ])
             )
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("web_fetch_tool_result"),
-            tool_use_id: import_v42.z.string(),
-            content: import_v42.z.union([
-              import_v42.z.object({
-                type: import_v42.z.literal("web_fetch_result"),
-                url: import_v42.z.string(),
-                retrieved_at: import_v42.z.string(),
-                content: import_v42.z.object({
-                  type: import_v42.z.literal("document"),
-                  title: import_v42.z.string().nullable(),
-                  citations: import_v42.z.object({ enabled: import_v42.z.boolean() }).optional(),
-                  source: import_v42.z.union([
-                    import_v42.z.object({
-                      type: import_v42.z.literal("base64"),
-                      media_type: import_v42.z.literal("application/pdf"),
-                      data: import_v42.z.string()
+          z2.object({
+            type: z2.literal("web_fetch_tool_result"),
+            tool_use_id: z2.string(),
+            content: z2.union([
+              z2.object({
+                type: z2.literal("web_fetch_result"),
+                url: z2.string(),
+                retrieved_at: z2.string(),
+                content: z2.object({
+                  type: z2.literal("document"),
+                  title: z2.string().nullable(),
+                  citations: z2.object({ enabled: z2.boolean() }).optional(),
+                  source: z2.union([
+                    z2.object({
+                      type: z2.literal("base64"),
+                      media_type: z2.literal("application/pdf"),
+                      data: z2.string()
                     }),
-                    import_v42.z.object({
-                      type: import_v42.z.literal("text"),
-                      media_type: import_v42.z.literal("text/plain"),
-                      data: import_v42.z.string()
+                    z2.object({
+                      type: z2.literal("text"),
+                      media_type: z2.literal("text/plain"),
+                      data: z2.string()
                     })
                   ])
                 })
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("web_fetch_tool_result_error"),
-                error_code: import_v42.z.string()
+              z2.object({
+                type: z2.literal("web_fetch_tool_result_error"),
+                error_code: z2.string()
               })
             ])
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("web_search_tool_result"),
-            tool_use_id: import_v42.z.string(),
-            content: import_v42.z.union([
-              import_v42.z.array(
-                import_v42.z.object({
-                  type: import_v42.z.literal("web_search_result"),
-                  url: import_v42.z.string(),
-                  title: import_v42.z.string(),
-                  encrypted_content: import_v42.z.string(),
-                  page_age: import_v42.z.string().nullish()
+          z2.object({
+            type: z2.literal("web_search_tool_result"),
+            tool_use_id: z2.string(),
+            content: z2.union([
+              z2.array(
+                z2.object({
+                  type: z2.literal("web_search_result"),
+                  url: z2.string(),
+                  title: z2.string(),
+                  encrypted_content: z2.string(),
+                  page_age: z2.string().nullish()
                 })
               ),
-              import_v42.z.object({
-                type: import_v42.z.literal("web_search_tool_result_error"),
-                error_code: import_v42.z.string()
+              z2.object({
+                type: z2.literal("web_search_tool_result_error"),
+                error_code: z2.string()
               })
             ])
           }),
           // code execution results for code_execution_20250522 tool:
-          import_v42.z.object({
-            type: import_v42.z.literal("code_execution_tool_result"),
-            tool_use_id: import_v42.z.string(),
-            content: import_v42.z.union([
-              import_v42.z.object({
-                type: import_v42.z.literal("code_execution_result"),
-                stdout: import_v42.z.string(),
-                stderr: import_v42.z.string(),
-                return_code: import_v42.z.number(),
-                content: import_v42.z.array(
-                  import_v42.z.object({
-                    type: import_v42.z.literal("code_execution_output"),
-                    file_id: import_v42.z.string()
+          z2.object({
+            type: z2.literal("code_execution_tool_result"),
+            tool_use_id: z2.string(),
+            content: z2.union([
+              z2.object({
+                type: z2.literal("code_execution_result"),
+                stdout: z2.string(),
+                stderr: z2.string(),
+                return_code: z2.number(),
+                content: z2.array(
+                  z2.object({
+                    type: z2.literal("code_execution_output"),
+                    file_id: z2.string()
                   })
                 ).optional().default([])
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("encrypted_code_execution_result"),
-                encrypted_stdout: import_v42.z.string(),
-                stderr: import_v42.z.string(),
-                return_code: import_v42.z.number(),
-                content: import_v42.z.array(
-                  import_v42.z.object({
-                    type: import_v42.z.literal("code_execution_output"),
-                    file_id: import_v42.z.string()
+              z2.object({
+                type: z2.literal("encrypted_code_execution_result"),
+                encrypted_stdout: z2.string(),
+                stderr: z2.string(),
+                return_code: z2.number(),
+                content: z2.array(
+                  z2.object({
+                    type: z2.literal("code_execution_output"),
+                    file_id: z2.string()
                   })
                 ).optional().default([])
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("code_execution_tool_result_error"),
-                error_code: import_v42.z.string()
+              z2.object({
+                type: z2.literal("code_execution_tool_result_error"),
+                error_code: z2.string()
               })
             ])
           }),
           // bash code execution results for code_execution_20250825 tool:
-          import_v42.z.object({
-            type: import_v42.z.literal("bash_code_execution_tool_result"),
-            tool_use_id: import_v42.z.string(),
-            content: import_v42.z.discriminatedUnion("type", [
-              import_v42.z.object({
-                type: import_v42.z.literal("bash_code_execution_result"),
-                content: import_v42.z.array(
-                  import_v42.z.object({
-                    type: import_v42.z.literal("bash_code_execution_output"),
-                    file_id: import_v42.z.string()
+          z2.object({
+            type: z2.literal("bash_code_execution_tool_result"),
+            tool_use_id: z2.string(),
+            content: z2.discriminatedUnion("type", [
+              z2.object({
+                type: z2.literal("bash_code_execution_result"),
+                content: z2.array(
+                  z2.object({
+                    type: z2.literal("bash_code_execution_output"),
+                    file_id: z2.string()
                   })
                 ),
-                stdout: import_v42.z.string(),
-                stderr: import_v42.z.string(),
-                return_code: import_v42.z.number()
+                stdout: z2.string(),
+                stderr: z2.string(),
+                return_code: z2.number()
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("bash_code_execution_tool_result_error"),
-                error_code: import_v42.z.string()
+              z2.object({
+                type: z2.literal("bash_code_execution_tool_result_error"),
+                error_code: z2.string()
               })
             ])
           }),
           // text editor code execution results for code_execution_20250825 tool:
-          import_v42.z.object({
-            type: import_v42.z.literal("text_editor_code_execution_tool_result"),
-            tool_use_id: import_v42.z.string(),
-            content: import_v42.z.discriminatedUnion("type", [
-              import_v42.z.object({
-                type: import_v42.z.literal("text_editor_code_execution_tool_result_error"),
-                error_code: import_v42.z.string()
+          z2.object({
+            type: z2.literal("text_editor_code_execution_tool_result"),
+            tool_use_id: z2.string(),
+            content: z2.discriminatedUnion("type", [
+              z2.object({
+                type: z2.literal("text_editor_code_execution_tool_result_error"),
+                error_code: z2.string()
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("text_editor_code_execution_view_result"),
-                content: import_v42.z.string(),
-                file_type: import_v42.z.string(),
-                num_lines: import_v42.z.number().nullable(),
-                start_line: import_v42.z.number().nullable(),
-                total_lines: import_v42.z.number().nullable()
+              z2.object({
+                type: z2.literal("text_editor_code_execution_view_result"),
+                content: z2.string(),
+                file_type: z2.string(),
+                num_lines: z2.number().nullable(),
+                start_line: z2.number().nullable(),
+                total_lines: z2.number().nullable()
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("text_editor_code_execution_create_result"),
-                is_file_update: import_v42.z.boolean()
+              z2.object({
+                type: z2.literal("text_editor_code_execution_create_result"),
+                is_file_update: z2.boolean()
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal(
+              z2.object({
+                type: z2.literal(
                   "text_editor_code_execution_str_replace_result"
                 ),
-                lines: import_v42.z.array(import_v42.z.string()).nullable(),
-                new_lines: import_v42.z.number().nullable(),
-                new_start: import_v42.z.number().nullable(),
-                old_lines: import_v42.z.number().nullable(),
-                old_start: import_v42.z.number().nullable()
+                lines: z2.array(z2.string()).nullable(),
+                new_lines: z2.number().nullable(),
+                new_start: z2.number().nullable(),
+                old_lines: z2.number().nullable(),
+                old_start: z2.number().nullable()
               })
             ])
           }),
           // tool search tool results for tool_search_tool_regex_20251119 and tool_search_tool_bm25_20251119:
-          import_v42.z.object({
-            type: import_v42.z.literal("tool_search_tool_result"),
-            tool_use_id: import_v42.z.string(),
-            content: import_v42.z.union([
-              import_v42.z.object({
-                type: import_v42.z.literal("tool_search_tool_search_result"),
-                tool_references: import_v42.z.array(
-                  import_v42.z.object({
-                    type: import_v42.z.literal("tool_reference"),
-                    tool_name: import_v42.z.string()
+          z2.object({
+            type: z2.literal("tool_search_tool_result"),
+            tool_use_id: z2.string(),
+            content: z2.union([
+              z2.object({
+                type: z2.literal("tool_search_tool_search_result"),
+                tool_references: z2.array(
+                  z2.object({
+                    type: z2.literal("tool_reference"),
+                    tool_name: z2.string()
                   })
                 )
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("tool_search_tool_result_error"),
-                error_code: import_v42.z.string()
+              z2.object({
+                type: z2.literal("tool_search_tool_result_error"),
+                error_code: z2.string()
               })
             ])
           })
         ])
       ),
-      stop_reason: import_v42.z.string().nullish(),
-      stop_sequence: import_v42.z.string().nullish(),
-      usage: import_v42.z.looseObject({
-        input_tokens: import_v42.z.number(),
-        output_tokens: import_v42.z.number(),
-        cache_creation_input_tokens: import_v42.z.number().nullish(),
-        cache_read_input_tokens: import_v42.z.number().nullish(),
-        iterations: import_v42.z.array(
-          import_v42.z.object({
-            type: import_v42.z.union([import_v42.z.literal("compaction"), import_v42.z.literal("message")]),
-            input_tokens: import_v42.z.number(),
-            output_tokens: import_v42.z.number()
+      stop_reason: z2.string().nullish(),
+      stop_sequence: z2.string().nullish(),
+      usage: z2.looseObject({
+        input_tokens: z2.number(),
+        output_tokens: z2.number(),
+        cache_creation_input_tokens: z2.number().nullish(),
+        cache_read_input_tokens: z2.number().nullish(),
+        iterations: z2.array(
+          z2.object({
+            type: z2.union([z2.literal("compaction"), z2.literal("message")]),
+            input_tokens: z2.number(),
+            output_tokens: z2.number()
           })
         ).nullish()
       }),
-      container: import_v42.z.object({
-        expires_at: import_v42.z.string(),
-        id: import_v42.z.string(),
-        skills: import_v42.z.array(
-          import_v42.z.object({
-            type: import_v42.z.union([import_v42.z.literal("anthropic"), import_v42.z.literal("custom")]),
-            skill_id: import_v42.z.string(),
-            version: import_v42.z.string()
+      container: z2.object({
+        expires_at: z2.string(),
+        id: z2.string(),
+        skills: z2.array(
+          z2.object({
+            type: z2.union([z2.literal("anthropic"), z2.literal("custom")]),
+            skill_id: z2.string(),
+            version: z2.string()
           })
         ).nullish()
       }).nullish(),
-      context_management: import_v42.z.object({
-        applied_edits: import_v42.z.array(
-          import_v42.z.union([
-            import_v42.z.object({
-              type: import_v42.z.literal("clear_tool_uses_20250919"),
-              cleared_tool_uses: import_v42.z.number(),
-              cleared_input_tokens: import_v42.z.number()
+      context_management: z2.object({
+        applied_edits: z2.array(
+          z2.union([
+            z2.object({
+              type: z2.literal("clear_tool_uses_20250919"),
+              cleared_tool_uses: z2.number(),
+              cleared_input_tokens: z2.number()
             }),
-            import_v42.z.object({
-              type: import_v42.z.literal("clear_thinking_20251015"),
-              cleared_thinking_turns: import_v42.z.number(),
-              cleared_input_tokens: import_v42.z.number()
+            z2.object({
+              type: z2.literal("clear_thinking_20251015"),
+              cleared_thinking_turns: z2.number(),
+              cleared_input_tokens: z2.number()
             }),
-            import_v42.z.object({
-              type: import_v42.z.literal("compact_20260112")
+            z2.object({
+              type: z2.literal("compact_20260112")
             })
           ])
         )
@@ -369,457 +363,457 @@ var anthropicMessagesResponseSchema = (0, import_provider_utils2.lazySchema)(
     })
   )
 );
-var anthropicMessagesChunkSchema = (0, import_provider_utils2.lazySchema)(
-  () => (0, import_provider_utils2.zodSchema)(
-    import_v42.z.discriminatedUnion("type", [
-      import_v42.z.object({
-        type: import_v42.z.literal("message_start"),
-        message: import_v42.z.object({
-          id: import_v42.z.string().nullish(),
-          model: import_v42.z.string().nullish(),
-          role: import_v42.z.string().nullish(),
-          usage: import_v42.z.looseObject({
-            input_tokens: import_v42.z.number(),
-            cache_creation_input_tokens: import_v42.z.number().nullish(),
-            cache_read_input_tokens: import_v42.z.number().nullish()
+var anthropicChunkSchema = lazySchema2(
+  () => zodSchema2(
+    z2.discriminatedUnion("type", [
+      z2.object({
+        type: z2.literal("message_start"),
+        message: z2.object({
+          id: z2.string().nullish(),
+          model: z2.string().nullish(),
+          role: z2.string().nullish(),
+          usage: z2.looseObject({
+            input_tokens: z2.number(),
+            cache_creation_input_tokens: z2.number().nullish(),
+            cache_read_input_tokens: z2.number().nullish()
           }),
           // Programmatic tool calling: content may be pre-populated for deferred tool calls
-          content: import_v42.z.array(
-            import_v42.z.discriminatedUnion("type", [
-              import_v42.z.object({
-                type: import_v42.z.literal("tool_use"),
-                id: import_v42.z.string(),
-                name: import_v42.z.string(),
-                input: import_v42.z.unknown(),
-                caller: import_v42.z.union([
-                  import_v42.z.object({
-                    type: import_v42.z.literal("code_execution_20250825"),
-                    tool_id: import_v42.z.string()
+          content: z2.array(
+            z2.discriminatedUnion("type", [
+              z2.object({
+                type: z2.literal("tool_use"),
+                id: z2.string(),
+                name: z2.string(),
+                input: z2.unknown(),
+                caller: z2.union([
+                  z2.object({
+                    type: z2.literal("code_execution_20250825"),
+                    tool_id: z2.string()
                   }),
-                  import_v42.z.object({
-                    type: import_v42.z.literal("code_execution_20260120"),
-                    tool_id: import_v42.z.string()
+                  z2.object({
+                    type: z2.literal("code_execution_20260120"),
+                    tool_id: z2.string()
                   }),
-                  import_v42.z.object({
-                    type: import_v42.z.literal("direct")
+                  z2.object({
+                    type: z2.literal("direct")
                   })
                 ]).optional()
               })
             ])
           ).nullish(),
-          stop_reason: import_v42.z.string().nullish(),
-          container: import_v42.z.object({
-            expires_at: import_v42.z.string(),
-            id: import_v42.z.string()
+          stop_reason: z2.string().nullish(),
+          container: z2.object({
+            expires_at: z2.string(),
+            id: z2.string()
           }).nullish()
         })
       }),
-      import_v42.z.object({
-        type: import_v42.z.literal("content_block_start"),
-        index: import_v42.z.number(),
-        content_block: import_v42.z.discriminatedUnion("type", [
-          import_v42.z.object({
-            type: import_v42.z.literal("text"),
-            text: import_v42.z.string()
+      z2.object({
+        type: z2.literal("content_block_start"),
+        index: z2.number(),
+        content_block: z2.discriminatedUnion("type", [
+          z2.object({
+            type: z2.literal("text"),
+            text: z2.string()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("thinking"),
-            thinking: import_v42.z.string()
+          z2.object({
+            type: z2.literal("thinking"),
+            thinking: z2.string()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("tool_use"),
-            id: import_v42.z.string(),
-            name: import_v42.z.string(),
+          z2.object({
+            type: z2.literal("tool_use"),
+            id: z2.string(),
+            name: z2.string(),
             // Programmatic tool calling: input may be present directly for deferred tool calls
-            input: import_v42.z.record(import_v42.z.string(), import_v42.z.unknown()).optional(),
+            input: z2.record(z2.string(), z2.unknown()).optional(),
             // Programmatic tool calling: caller info when triggered from code execution
-            caller: import_v42.z.union([
-              import_v42.z.object({
-                type: import_v42.z.literal("code_execution_20250825"),
-                tool_id: import_v42.z.string()
+            caller: z2.union([
+              z2.object({
+                type: z2.literal("code_execution_20250825"),
+                tool_id: z2.string()
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("code_execution_20260120"),
-                tool_id: import_v42.z.string()
+              z2.object({
+                type: z2.literal("code_execution_20260120"),
+                tool_id: z2.string()
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("direct")
+              z2.object({
+                type: z2.literal("direct")
               })
             ]).optional()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("redacted_thinking"),
-            data: import_v42.z.string()
+          z2.object({
+            type: z2.literal("redacted_thinking"),
+            data: z2.string()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("compaction"),
-            content: import_v42.z.string().nullish()
+          z2.object({
+            type: z2.literal("compaction"),
+            content: z2.string().nullish()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("server_tool_use"),
-            id: import_v42.z.string(),
-            name: import_v42.z.string(),
-            input: import_v42.z.record(import_v42.z.string(), import_v42.z.unknown()).nullish(),
-            caller: import_v42.z.union([
-              import_v42.z.object({
-                type: import_v42.z.literal("code_execution_20260120"),
-                tool_id: import_v42.z.string()
+          z2.object({
+            type: z2.literal("server_tool_use"),
+            id: z2.string(),
+            name: z2.string(),
+            input: z2.record(z2.string(), z2.unknown()).nullish(),
+            caller: z2.union([
+              z2.object({
+                type: z2.literal("code_execution_20260120"),
+                tool_id: z2.string()
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("direct")
+              z2.object({
+                type: z2.literal("direct")
               })
             ]).optional()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("mcp_tool_use"),
-            id: import_v42.z.string(),
-            name: import_v42.z.string(),
-            input: import_v42.z.unknown(),
-            server_name: import_v42.z.string()
+          z2.object({
+            type: z2.literal("mcp_tool_use"),
+            id: z2.string(),
+            name: z2.string(),
+            input: z2.unknown(),
+            server_name: z2.string()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("mcp_tool_result"),
-            tool_use_id: import_v42.z.string(),
-            is_error: import_v42.z.boolean(),
-            content: import_v42.z.array(
-              import_v42.z.union([
-                import_v42.z.string(),
-                import_v42.z.object({ type: import_v42.z.literal("text"), text: import_v42.z.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() })
               ])
             )
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("web_fetch_tool_result"),
-            tool_use_id: import_v42.z.string(),
-            content: import_v42.z.union([
-              import_v42.z.object({
-                type: import_v42.z.literal("web_fetch_result"),
-                url: import_v42.z.string(),
-                retrieved_at: import_v42.z.string(),
-                content: import_v42.z.object({
-                  type: import_v42.z.literal("document"),
-                  title: import_v42.z.string().nullable(),
-                  citations: import_v42.z.object({ enabled: import_v42.z.boolean() }).optional(),
-                  source: import_v42.z.union([
-                    import_v42.z.object({
-                      type: import_v42.z.literal("base64"),
-                      media_type: import_v42.z.literal("application/pdf"),
-                      data: import_v42.z.string()
+          z2.object({
+            type: z2.literal("web_fetch_tool_result"),
+            tool_use_id: z2.string(),
+            content: z2.union([
+              z2.object({
+                type: z2.literal("web_fetch_result"),
+                url: z2.string(),
+                retrieved_at: z2.string(),
+                content: z2.object({
+                  type: z2.literal("document"),
+                  title: z2.string().nullable(),
+                  citations: z2.object({ enabled: z2.boolean() }).optional(),
+                  source: z2.union([
+                    z2.object({
+                      type: z2.literal("base64"),
+                      media_type: z2.literal("application/pdf"),
+                      data: z2.string()
                     }),
-                    import_v42.z.object({
-                      type: import_v42.z.literal("text"),
-                      media_type: import_v42.z.literal("text/plain"),
-                      data: import_v42.z.string()
+                    z2.object({
+                      type: z2.literal("text"),
+                      media_type: z2.literal("text/plain"),
+                      data: z2.string()
                     })
                   ])
                 })
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("web_fetch_tool_result_error"),
-                error_code: import_v42.z.string()
+              z2.object({
+                type: z2.literal("web_fetch_tool_result_error"),
+                error_code: z2.string()
               })
             ])
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("web_search_tool_result"),
-            tool_use_id: import_v42.z.string(),
-            content: import_v42.z.union([
-              import_v42.z.array(
-                import_v42.z.object({
-                  type: import_v42.z.literal("web_search_result"),
-                  url: import_v42.z.string(),
-                  title: import_v42.z.string(),
-                  encrypted_content: import_v42.z.string(),
-                  page_age: import_v42.z.string().nullish()
+          z2.object({
+            type: z2.literal("web_search_tool_result"),
+            tool_use_id: z2.string(),
+            content: z2.union([
+              z2.array(
+                z2.object({
+                  type: z2.literal("web_search_result"),
+                  url: z2.string(),
+                  title: z2.string(),
+                  encrypted_content: z2.string(),
+                  page_age: z2.string().nullish()
                 })
               ),
-              import_v42.z.object({
-                type: import_v42.z.literal("web_search_tool_result_error"),
-                error_code: import_v42.z.string()
+              z2.object({
+                type: z2.literal("web_search_tool_result_error"),
+                error_code: z2.string()
               })
             ])
           }),
           // code execution results for code_execution_20250522 tool:
-          import_v42.z.object({
-            type: import_v42.z.literal("code_execution_tool_result"),
-            tool_use_id: import_v42.z.string(),
-            content: import_v42.z.union([
-              import_v42.z.object({
-                type: import_v42.z.literal("code_execution_result"),
-                stdout: import_v42.z.string(),
-                stderr: import_v42.z.string(),
-                return_code: import_v42.z.number(),
-                content: import_v42.z.array(
-                  import_v42.z.object({
-                    type: import_v42.z.literal("code_execution_output"),
-                    file_id: import_v42.z.string()
+          z2.object({
+            type: z2.literal("code_execution_tool_result"),
+            tool_use_id: z2.string(),
+            content: z2.union([
+              z2.object({
+                type: z2.literal("code_execution_result"),
+                stdout: z2.string(),
+                stderr: z2.string(),
+                return_code: z2.number(),
+                content: z2.array(
+                  z2.object({
+                    type: z2.literal("code_execution_output"),
+                    file_id: z2.string()
                   })
                 ).optional().default([])
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("encrypted_code_execution_result"),
-                encrypted_stdout: import_v42.z.string(),
-                stderr: import_v42.z.string(),
-                return_code: import_v42.z.number(),
-                content: import_v42.z.array(
-                  import_v42.z.object({
-                    type: import_v42.z.literal("code_execution_output"),
-                    file_id: import_v42.z.string()
+              z2.object({
+                type: z2.literal("encrypted_code_execution_result"),
+                encrypted_stdout: z2.string(),
+                stderr: z2.string(),
+                return_code: z2.number(),
+                content: z2.array(
+                  z2.object({
+                    type: z2.literal("code_execution_output"),
+                    file_id: z2.string()
                   })
                 ).optional().default([])
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("code_execution_tool_result_error"),
-                error_code: import_v42.z.string()
+              z2.object({
+                type: z2.literal("code_execution_tool_result_error"),
+                error_code: z2.string()
               })
             ])
           }),
           // bash code execution results for code_execution_20250825 tool:
-          import_v42.z.object({
-            type: import_v42.z.literal("bash_code_execution_tool_result"),
-            tool_use_id: import_v42.z.string(),
-            content: import_v42.z.discriminatedUnion("type", [
-              import_v42.z.object({
-                type: import_v42.z.literal("bash_code_execution_result"),
-                content: import_v42.z.array(
-                  import_v42.z.object({
-                    type: import_v42.z.literal("bash_code_execution_output"),
-                    file_id: import_v42.z.string()
+          z2.object({
+            type: z2.literal("bash_code_execution_tool_result"),
+            tool_use_id: z2.string(),
+            content: z2.discriminatedUnion("type", [
+              z2.object({
+                type: z2.literal("bash_code_execution_result"),
+                content: z2.array(
+                  z2.object({
+                    type: z2.literal("bash_code_execution_output"),
+                    file_id: z2.string()
                   })
                 ),
-                stdout: import_v42.z.string(),
-                stderr: import_v42.z.string(),
-                return_code: import_v42.z.number()
+                stdout: z2.string(),
+                stderr: z2.string(),
+                return_code: z2.number()
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("bash_code_execution_tool_result_error"),
-                error_code: import_v42.z.string()
+              z2.object({
+                type: z2.literal("bash_code_execution_tool_result_error"),
+                error_code: z2.string()
               })
             ])
           }),
           // text editor code execution results for code_execution_20250825 tool:
-          import_v42.z.object({
-            type: import_v42.z.literal("text_editor_code_execution_tool_result"),
-            tool_use_id: import_v42.z.string(),
-            content: import_v42.z.discriminatedUnion("type", [
-              import_v42.z.object({
-                type: import_v42.z.literal("text_editor_code_execution_tool_result_error"),
-                error_code: import_v42.z.string()
+          z2.object({
+            type: z2.literal("text_editor_code_execution_tool_result"),
+            tool_use_id: z2.string(),
+            content: z2.discriminatedUnion("type", [
+              z2.object({
+                type: z2.literal("text_editor_code_execution_tool_result_error"),
+                error_code: z2.string()
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("text_editor_code_execution_view_result"),
-                content: import_v42.z.string(),
-                file_type: import_v42.z.string(),
-                num_lines: import_v42.z.number().nullable(),
-                start_line: import_v42.z.number().nullable(),
-                total_lines: import_v42.z.number().nullable()
+              z2.object({
+                type: z2.literal("text_editor_code_execution_view_result"),
+                content: z2.string(),
+                file_type: z2.string(),
+                num_lines: z2.number().nullable(),
+                start_line: z2.number().nullable(),
+                total_lines: z2.number().nullable()
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("text_editor_code_execution_create_result"),
-                is_file_update: import_v42.z.boolean()
+              z2.object({
+                type: z2.literal("text_editor_code_execution_create_result"),
+                is_file_update: z2.boolean()
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal(
+              z2.object({
+                type: z2.literal(
                   "text_editor_code_execution_str_replace_result"
                 ),
-                lines: import_v42.z.array(import_v42.z.string()).nullable(),
-                new_lines: import_v42.z.number().nullable(),
-                new_start: import_v42.z.number().nullable(),
-                old_lines: import_v42.z.number().nullable(),
-                old_start: import_v42.z.number().nullable()
+                lines: z2.array(z2.string()).nullable(),
+                new_lines: z2.number().nullable(),
+                new_start: z2.number().nullable(),
+                old_lines: z2.number().nullable(),
+                old_start: z2.number().nullable()
               })
             ])
           }),
           // tool search tool results for tool_search_tool_regex_20251119 and tool_search_tool_bm25_20251119:
-          import_v42.z.object({
-            type: import_v42.z.literal("tool_search_tool_result"),
-            tool_use_id: import_v42.z.string(),
-            content: import_v42.z.union([
-              import_v42.z.object({
-                type: import_v42.z.literal("tool_search_tool_search_result"),
-                tool_references: import_v42.z.array(
-                  import_v42.z.object({
-                    type: import_v42.z.literal("tool_reference"),
-                    tool_name: import_v42.z.string()
+          z2.object({
+            type: z2.literal("tool_search_tool_result"),
+            tool_use_id: z2.string(),
+            content: z2.union([
+              z2.object({
+                type: z2.literal("tool_search_tool_search_result"),
+                tool_references: z2.array(
+                  z2.object({
+                    type: z2.literal("tool_reference"),
+                    tool_name: z2.string()
                   })
                 )
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("tool_search_tool_result_error"),
-                error_code: import_v42.z.string()
+              z2.object({
+                type: z2.literal("tool_search_tool_result_error"),
+                error_code: z2.string()
               })
             ])
           })
         ])
       }),
-      import_v42.z.object({
-        type: import_v42.z.literal("content_block_delta"),
-        index: import_v42.z.number(),
-        delta: import_v42.z.discriminatedUnion("type", [
-          import_v42.z.object({
-            type: import_v42.z.literal("input_json_delta"),
-            partial_json: import_v42.z.string()
+      z2.object({
+        type: z2.literal("content_block_delta"),
+        index: z2.number(),
+        delta: z2.discriminatedUnion("type", [
+          z2.object({
+            type: z2.literal("input_json_delta"),
+            partial_json: z2.string()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("text_delta"),
-            text: import_v42.z.string()
+          z2.object({
+            type: z2.literal("text_delta"),
+            text: z2.string()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("thinking_delta"),
-            thinking: import_v42.z.string()
+          z2.object({
+            type: z2.literal("thinking_delta"),
+            thinking: z2.string()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("signature_delta"),
-            signature: import_v42.z.string()
+          z2.object({
+            type: z2.literal("signature_delta"),
+            signature: z2.string()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("compaction_delta"),
-            content: import_v42.z.string().nullish()
+          z2.object({
+            type: z2.literal("compaction_delta"),
+            content: z2.string().nullish()
           }),
-          import_v42.z.object({
-            type: import_v42.z.literal("citations_delta"),
-            citation: import_v42.z.discriminatedUnion("type", [
-              import_v42.z.object({
-                type: import_v42.z.literal("web_search_result_location"),
-                cited_text: import_v42.z.string(),
-                url: import_v42.z.string(),
-                title: import_v42.z.string(),
-                encrypted_index: import_v42.z.string()
+          z2.object({
+            type: z2.literal("citations_delta"),
+            citation: z2.discriminatedUnion("type", [
+              z2.object({
+                type: z2.literal("web_search_result_location"),
+                cited_text: z2.string(),
+                url: z2.string(),
+                title: z2.string(),
+                encrypted_index: z2.string()
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("page_location"),
-                cited_text: import_v42.z.string(),
-                document_index: import_v42.z.number(),
-                document_title: import_v42.z.string().nullable(),
-                start_page_number: import_v42.z.number(),
-                end_page_number: import_v42.z.number()
+              z2.object({
+                type: z2.literal("page_location"),
+                cited_text: z2.string(),
+                document_index: z2.number(),
+                document_title: z2.string().nullable(),
+                start_page_number: z2.number(),
+                end_page_number: z2.number()
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("char_location"),
-                cited_text: import_v42.z.string(),
-                document_index: import_v42.z.number(),
-                document_title: import_v42.z.string().nullable(),
-                start_char_index: import_v42.z.number(),
-                end_char_index: import_v42.z.number()
+              z2.object({
+                type: z2.literal("char_location"),
+                cited_text: z2.string(),
+                document_index: z2.number(),
+                document_title: z2.string().nullable(),
+                start_char_index: z2.number(),
+                end_char_index: z2.number()
               })
             ])
           })
         ])
       }),
-      import_v42.z.object({
-        type: import_v42.z.literal("content_block_stop"),
-        index: import_v42.z.number()
+      z2.object({
+        type: z2.literal("content_block_stop"),
+        index: z2.number()
       }),
-      import_v42.z.object({
-        type: import_v42.z.literal("error"),
-        error: import_v42.z.object({
-          type: import_v42.z.string(),
-          message: import_v42.z.string()
+      z2.object({
+        type: z2.literal("error"),
+        error: z2.object({
+          type: z2.string(),
+          message: z2.string()
         })
       }),
-      import_v42.z.object({
-        type: import_v42.z.literal("message_delta"),
-        delta: import_v42.z.object({
-          stop_reason: import_v42.z.string().nullish(),
-          stop_sequence: import_v42.z.string().nullish(),
-          container: import_v42.z.object({
-            expires_at: import_v42.z.string(),
-            id: import_v42.z.string(),
-            skills: import_v42.z.array(
-              import_v42.z.object({
-                type: import_v42.z.union([
-                  import_v42.z.literal("anthropic"),
-                  import_v42.z.literal("custom")
+      z2.object({
+        type: z2.literal("message_delta"),
+        delta: z2.object({
+          stop_reason: z2.string().nullish(),
+          stop_sequence: z2.string().nullish(),
+          container: z2.object({
+            expires_at: z2.string(),
+            id: z2.string(),
+            skills: z2.array(
+              z2.object({
+                type: z2.union([
+                  z2.literal("anthropic"),
+                  z2.literal("custom")
                 ]),
-                skill_id: import_v42.z.string(),
-                version: import_v42.z.string()
+                skill_id: z2.string(),
+                version: z2.string()
               })
             ).nullish()
           }).nullish()
         }),
-        usage: import_v42.z.looseObject({
-          input_tokens: import_v42.z.number().nullish(),
-          output_tokens: import_v42.z.number(),
-          cache_creation_input_tokens: import_v42.z.number().nullish(),
-          cache_read_input_tokens: import_v42.z.number().nullish(),
-          iterations: import_v42.z.array(
-            import_v42.z.object({
-              type: import_v42.z.union([import_v42.z.literal("compaction"), import_v42.z.literal("message")]),
-              input_tokens: import_v42.z.number(),
-              output_tokens: import_v42.z.number()
+        usage: z2.looseObject({
+          input_tokens: z2.number().nullish(),
+          output_tokens: z2.number(),
+          cache_creation_input_tokens: z2.number().nullish(),
+          cache_read_input_tokens: z2.number().nullish(),
+          iterations: z2.array(
+            z2.object({
+              type: z2.union([z2.literal("compaction"), z2.literal("message")]),
+              input_tokens: z2.number(),
+              output_tokens: z2.number()
             })
           ).nullish()
         }),
-        context_management: import_v42.z.object({
-          applied_edits: import_v42.z.array(
-            import_v42.z.union([
-              import_v42.z.object({
-                type: import_v42.z.literal("clear_tool_uses_20250919"),
-                cleared_tool_uses: import_v42.z.number(),
-                cleared_input_tokens: import_v42.z.number()
+        context_management: z2.object({
+          applied_edits: z2.array(
+            z2.union([
+              z2.object({
+                type: z2.literal("clear_tool_uses_20250919"),
+                cleared_tool_uses: z2.number(),
+                cleared_input_tokens: z2.number()
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("clear_thinking_20251015"),
-                cleared_thinking_turns: import_v42.z.number(),
-                cleared_input_tokens: import_v42.z.number()
+              z2.object({
+                type: z2.literal("clear_thinking_20251015"),
+                cleared_thinking_turns: z2.number(),
+                cleared_input_tokens: z2.number()
               }),
-              import_v42.z.object({
-                type: import_v42.z.literal("compact_20260112")
+              z2.object({
+                type: z2.literal("compact_20260112")
               })
             ])
           )
         }).nullish()
       }),
-      import_v42.z.object({
-        type: import_v42.z.literal("message_stop")
+      z2.object({
+        type: z2.literal("message_stop")
       }),
-      import_v42.z.object({
-        type: import_v42.z.literal("ping")
+      z2.object({
+        type: z2.literal("ping")
       })
     ])
   )
 );
-var anthropicReasoningMetadataSchema = (0, import_provider_utils2.lazySchema)(
-  () => (0, import_provider_utils2.zodSchema)(
-    import_v42.z.object({
-      signature: import_v42.z.string().optional(),
-      redactedData: import_v42.z.string().optional()
+var anthropicReasoningMetadataSchema = lazySchema2(
+  () => zodSchema2(
+    z2.object({
+      signature: z2.string().optional(),
+      redactedData: z2.string().optional()
     })
   )
 );
 
-// src/anthropic-messages-options.ts
-var import_v43 = require("zod/v4");
-var anthropicFilePartProviderOptions = import_v43.z.object({
+// src/anthropic-options.ts
+import { z as z3 } from "zod/v4";
+var anthropicFilePartProviderOptions = z3.object({
   /**
    * Citation configuration for this document.
    * When enabled, this document will generate citations in the response.
    */
-  citations: import_v43.z.object({
+  citations: z3.object({
     /**
      * Enable citations for this document
      */
-    enabled: import_v43.z.boolean()
+    enabled: z3.boolean()
   }).optional(),
   /**
    * Custom title for the document.
    * If not provided, the filename will be used.
    */
-  title: import_v43.z.string().optional(),
+  title: z3.string().optional(),
   /**
    * Context about the document that will be passed to the model
    * but not used towards cited content.
    * Useful for storing document metadata as text or stringified JSON.
    */
-  context: import_v43.z.string().optional()
+  context: z3.string().optional()
 });
-var anthropicLanguageModelOptions = import_v43.z.object({
+var anthropicLanguageModelOptions = z3.object({
   /**
    * Whether to send reasoning to the model.
    *
    * This allows you to deactivate reasoning inputs for models that do not support them.
    */
-  sendReasoning: import_v43.z.boolean().optional(),
+  sendReasoning: z3.boolean().optional(),
   /**
    * Determines how structured outputs are generated.
    *
@@ -827,52 +821,72 @@ var anthropicLanguageModelOptions = import_v43.z.object({
    * - `jsonTool`: Use a special 'json' tool to specify the structured output format.
    * - `auto`: Use 'outputFormat' when supported, otherwise use 'jsonTool' (default).
    */
-  structuredOutputMode: import_v43.z.enum(["outputFormat", "jsonTool", "auto"]).optional(),
+  structuredOutputMode: z3.enum(["outputFormat", "jsonTool", "auto"]).optional(),
   /**
    * Configuration for enabling Claude's extended thinking.
    *
    * When enabled, responses include thinking content blocks showing Claude's thinking process before the final answer.
    * Requires a minimum budget of 1,024 tokens and counts towards the `max_tokens` limit.
    */
-  thinking: import_v43.z.discriminatedUnion("type", [
-    import_v43.z.object({
+  thinking: z3.discriminatedUnion("type", [
+    z3.object({
       /** for Sonnet 4.6, Opus 4.6, and newer models */
-      type: import_v43.z.literal("adaptive")
+      type: z3.literal("adaptive"),
+      /**
+       * Controls whether thinking content is included in the response.
+       * - `"omitted"`: Thinking blocks are present but text is empty (default for Opus 4.7+).
+       * - `"summarized"`: Thinking content is returned. Required to see reasoning output.
+       */
+      display: z3.enum(["omitted", "summarized"]).optional()
     }),
-    import_v43.z.object({
+    z3.object({
       /** for models before Opus 4.6, except Sonnet 4.6 still supports it */
-      type: import_v43.z.literal("enabled"),
-      budgetTokens: import_v43.z.number().optional()
+      type: z3.literal("enabled"),
+      budgetTokens: z3.number().optional()
     }),
-    import_v43.z.object({
-      type: import_v43.z.literal("disabled")
+    z3.object({
+      type: z3.literal("disabled")
     })
   ]).optional(),
   /**
    * Whether to disable parallel function calling during tool use. Default is false.
    * When set to true, Claude will use at most one tool per response.
    */
-  disableParallelToolUse: import_v43.z.boolean().optional(),
+  disableParallelToolUse: z3.boolean().optional(),
   /**
    * Cache control settings for this message.
    * See https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching
    */
-  cacheControl: import_v43.z.object({
-    type: import_v43.z.literal("ephemeral"),
-    ttl: import_v43.z.union([import_v43.z.literal("5m"), import_v43.z.literal("1h")]).optional()
+  cacheControl: z3.object({
+    type: z3.literal("ephemeral"),
+    ttl: z3.union([z3.literal("5m"), z3.literal("1h")]).optional()
+  }).optional(),
+  /**
+   * Metadata to include with the request.
+   *
+   * See https://platform.claude.com/docs/en/api/messages/create for details.
+   */
+  metadata: z3.object({
+    /**
+     * An external identifier for the user associated with the request.
+     *
+     * Should be a UUID, hash value, or other opaque identifier.
+     * Must not contain PII (name, email, phone number, etc.).
+     */
+    userId: z3.string().optional()
   }).optional(),
   /**
    * MCP servers to be utilized in this request.
    */
-  mcpServers: import_v43.z.array(
-    import_v43.z.object({
-      type: import_v43.z.literal("url"),
-      name: import_v43.z.string(),
-      url: import_v43.z.string(),
-      authorizationToken: import_v43.z.string().nullish(),
-      toolConfiguration: import_v43.z.object({
-        enabled: import_v43.z.boolean().nullish(),
-        allowedTools: import_v43.z.array(import_v43.z.string()).nullish()
+  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(),
@@ -881,83 +895,112 @@ var anthropicLanguageModelOptions = import_v43.z.object({
    * like document processing (PPTX, DOCX, PDF, XLSX) and data analysis.
    * Requires code execution tool to be enabled.
    */
-  container: import_v43.z.object({
-    id: import_v43.z.string().optional(),
-    skills: import_v43.z.array(
-      import_v43.z.object({
-        type: import_v43.z.union([import_v43.z.literal("anthropic"), import_v43.z.literal("custom")]),
-        skillId: import_v43.z.string(),
-        version: import_v43.z.string().optional()
-      })
+  container: z3.object({
+    id: z3.string().optional(),
+    skills: z3.array(
+      z3.discriminatedUnion("type", [
+        z3.object({
+          type: z3.literal("anthropic"),
+          skillId: z3.string(),
+          version: z3.string().optional()
+        }),
+        z3.object({
+          type: z3.literal("custom"),
+          providerReference: z3.record(z3.string(), z3.string()),
+          version: z3.string().optional()
+        })
+      ])
     ).optional()
   }).optional(),
   /**
-   * Whether to enable tool streaming (and structured output streaming).
-   *
-   * When set to false, the model will return all tool calls and results
-   * at once after a delay.
+   * Whether to enable fine-grained (eager) streaming of tool call inputs
+   * and structured outputs for every function tool in the request. When
+   * true (the default), each function tool receives a default of
+   * `eager_input_streaming: true` unless it explicitly sets
+   * `providerOptions.anthropic.eagerInputStreaming`.
    *
    * @default true
    */
-  toolStreaming: import_v43.z.boolean().optional(),
+  toolStreaming: z3.boolean().optional(),
   /**
    * @default 'high'
    */
-  effort: import_v43.z.enum(["low", "medium", "high", "max"]).optional(),
+  effort: z3.enum(["low", "medium", "high", "xhigh", "max"]).optional(),
+  /**
+   * Task budget for agentic turns. Informs the model of the total token budget
+   * available for the current task, allowing it to prioritize work and wind down
+   * gracefully as the budget is consumed.
+   *
+   * Advisory only — does not enforce a hard token limit.
+   */
+  taskBudget: z3.object({
+    type: z3.literal("tokens"),
+    total: z3.number().int().min(2e4),
+    remaining: z3.number().int().min(0).optional()
+  }).optional(),
   /**
    * Enable fast mode for faster inference (2.5x faster output token speeds).
    * Only supported with claude-opus-4-6.
    */
-  speed: import_v43.z.enum(["fast", "standard"]).optional(),
+  speed: z3.enum(["fast", "standard"]).optional(),
+  /**
+   * Controls where model inference runs for this request.
+   *
+   * - `"global"`: Inference may run in any available geography (default).
+   * - `"us"`: Inference runs only in US-based infrastructure.
+   *
+   * See https://platform.claude.com/docs/en/build-with-claude/data-residency
+   */
+  inferenceGeo: z3.enum(["us", "global"]).optional(),
   /**
    * A set of beta features to enable.
    * Allow a provider to receive the full `betas` set if it needs it.
    */
-  anthropicBeta: import_v43.z.array(import_v43.z.string()).optional(),
-  contextManagement: import_v43.z.object({
-    edits: import_v43.z.array(
-      import_v43.z.discriminatedUnion("type", [
-        import_v43.z.object({
-          type: import_v43.z.literal("clear_tool_uses_20250919"),
-          trigger: import_v43.z.discriminatedUnion("type", [
-            import_v43.z.object({
-              type: import_v43.z.literal("input_tokens"),
-              value: import_v43.z.number()
+  anthropicBeta: z3.array(z3.string()).optional(),
+  contextManagement: z3.object({
+    edits: z3.array(
+      z3.discriminatedUnion("type", [
+        z3.object({
+          type: z3.literal("clear_tool_uses_20250919"),
+          trigger: z3.discriminatedUnion("type", [
+            z3.object({
+              type: z3.literal("input_tokens"),
+              value: z3.number()
             }),
-            import_v43.z.object({
-              type: import_v43.z.literal("tool_uses"),
-              value: import_v43.z.number()
+            z3.object({
+              type: z3.literal("tool_uses"),
+              value: z3.number()
             })
           ]).optional(),
-          keep: import_v43.z.object({
-            type: import_v43.z.literal("tool_uses"),
-            value: import_v43.z.number()
+          keep: z3.object({
+            type: z3.literal("tool_uses"),
+            value: z3.number()
           }).optional(),
-          clearAtLeast: import_v43.z.object({
-            type: import_v43.z.literal("input_tokens"),
-            value: import_v43.z.number()
+          clearAtLeast: z3.object({
+            type: z3.literal("input_tokens"),
+            value: z3.number()
           }).optional(),
-          clearToolInputs: import_v43.z.boolean().optional(),
-          excludeTools: import_v43.z.array(import_v43.z.string()).optional()
+          clearToolInputs: z3.boolean().optional(),
+          excludeTools: z3.array(z3.string()).optional()
         }),
-        import_v43.z.object({
-          type: import_v43.z.literal("clear_thinking_20251015"),
-          keep: import_v43.z.union([
-            import_v43.z.literal("all"),
-            import_v43.z.object({
-              type: import_v43.z.literal("thinking_turns"),
-              value: import_v43.z.number()
+        z3.object({
+          type: z3.literal("clear_thinking_20251015"),
+          keep: z3.union([
+            z3.literal("all"),
+            z3.object({
+              type: z3.literal("thinking_turns"),
+              value: z3.number()
             })
           ]).optional()
         }),
-        import_v43.z.object({
-          type: import_v43.z.literal("compact_20260112"),
-          trigger: import_v43.z.object({
-            type: import_v43.z.literal("input_tokens"),
-            value: import_v43.z.number()
+        z3.object({
+          type: z3.literal("compact_20260112"),
+          trigger: z3.object({
+            type: z3.literal("input_tokens"),
+            value: z3.number()
           }).optional(),
-          pauseAfterCompaction: import_v43.z.boolean().optional(),
-          instructions: import_v43.z.string().optional()
+          pauseAfterCompaction: z3.boolean().optional(),
+          instructions: z3.string().optional()
         })
       ])
     )
@@ -965,7 +1008,9 @@ var anthropicLanguageModelOptions = import_v43.z.object({
 });
 
 // src/anthropic-prepare-tools.ts
-var import_provider = require("@ai-sdk/provider");
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
 
 // src/get-cache-control.ts
 var MAX_CACHE_BREAKPOINTS = 4;
@@ -1010,31 +1055,31 @@ var CacheControlValidator = class {
 };
 
 // src/tool/text-editor_20250728.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_v44 = require("zod/v4");
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var textEditor_20250728ArgsSchema = (0, import_provider_utils4.lazySchema)(
-  () => (0, import_provider_utils4.zodSchema)(
-    import_v44.z.object({
-      maxCharacters: import_v44.z.number().optional()
+import { createProviderDefinedToolFactory } from "@ai-sdk/provider-utils";
+import { z as z4 } from "zod/v4";
+import { lazySchema as lazySchema3, zodSchema as zodSchema3 } from "@ai-sdk/provider-utils";
+var textEditor_20250728ArgsSchema = lazySchema3(
+  () => zodSchema3(
+    z4.object({
+      maxCharacters: z4.number().optional()
     })
   )
 );
-var textEditor_20250728InputSchema = (0, import_provider_utils4.lazySchema)(
-  () => (0, import_provider_utils4.zodSchema)(
-    import_v44.z.object({
-      command: import_v44.z.enum(["view", "create", "str_replace", "insert"]),
-      path: import_v44.z.string(),
-      file_text: import_v44.z.string().optional(),
-      insert_line: import_v44.z.number().int().optional(),
-      new_str: import_v44.z.string().optional(),
-      insert_text: import_v44.z.string().optional(),
-      old_str: import_v44.z.string().optional(),
-      view_range: import_v44.z.array(import_v44.z.number().int()).optional()
+var textEditor_20250728InputSchema = lazySchema3(
+  () => zodSchema3(
+    z4.object({
+      command: z4.enum(["view", "create", "str_replace", "insert"]),
+      path: z4.string(),
+      file_text: z4.string().optional(),
+      insert_line: z4.number().int().optional(),
+      new_str: z4.string().optional(),
+      insert_text: z4.string().optional(),
+      old_str: z4.string().optional(),
+      view_range: z4.array(z4.number().int()).optional()
     })
   )
 );
-var factory = (0, import_provider_utils3.createProviderToolFactory)({
+var factory = createProviderDefinedToolFactory({
   id: "anthropic.text_editor_20250728",
   inputSchema: textEditor_20250728InputSchema
 });
@@ -1043,45 +1088,49 @@ var textEditor_20250728 = (args = {}) => {
 };
 
 // src/tool/web-search_20260209.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
-var import_v45 = require("zod/v4");
-var webSearch_20260209ArgsSchema = (0, import_provider_utils5.lazySchema)(
-  () => (0, import_provider_utils5.zodSchema)(
-    import_v45.z.object({
-      maxUses: import_v45.z.number().optional(),
-      allowedDomains: import_v45.z.array(import_v45.z.string()).optional(),
-      blockedDomains: import_v45.z.array(import_v45.z.string()).optional(),
-      userLocation: import_v45.z.object({
-        type: import_v45.z.literal("approximate"),
-        city: import_v45.z.string().optional(),
-        region: import_v45.z.string().optional(),
-        country: import_v45.z.string().optional(),
-        timezone: import_v45.z.string().optional()
+import {
+  createProviderExecutedToolFactory,
+  lazySchema as lazySchema4,
+  zodSchema as zodSchema4
+} from "@ai-sdk/provider-utils";
+import { z as z5 } from "zod/v4";
+var webSearch_20260209ArgsSchema = lazySchema4(
+  () => zodSchema4(
+    z5.object({
+      maxUses: z5.number().optional(),
+      allowedDomains: z5.array(z5.string()).optional(),
+      blockedDomains: z5.array(z5.string()).optional(),
+      userLocation: z5.object({
+        type: z5.literal("approximate"),
+        city: z5.string().optional(),
+        region: z5.string().optional(),
+        country: z5.string().optional(),
+        timezone: z5.string().optional()
       }).optional()
     })
   )
 );
-var webSearch_20260209OutputSchema = (0, import_provider_utils5.lazySchema)(
-  () => (0, import_provider_utils5.zodSchema)(
-    import_v45.z.array(
-      import_v45.z.object({
-        url: import_v45.z.string(),
-        title: import_v45.z.string().nullable(),
-        pageAge: import_v45.z.string().nullable(),
-        encryptedContent: import_v45.z.string(),
-        type: import_v45.z.literal("web_search_result")
+var webSearch_20260209OutputSchema = lazySchema4(
+  () => zodSchema4(
+    z5.array(
+      z5.object({
+        url: z5.string(),
+        title: z5.string().nullable(),
+        pageAge: z5.string().nullable(),
+        encryptedContent: z5.string(),
+        type: z5.literal("web_search_result")
       })
     )
   )
 );
-var webSearch_20260209InputSchema = (0, import_provider_utils5.lazySchema)(
-  () => (0, import_provider_utils5.zodSchema)(
-    import_v45.z.object({
-      query: import_v45.z.string()
+var webSearch_20260209InputSchema = lazySchema4(
+  () => zodSchema4(
+    z5.object({
+      query: z5.string()
     })
   )
 );
-var factory2 = (0, import_provider_utils5.createProviderToolFactoryWithOutputSchema)({
+var factory2 = createProviderExecutedToolFactory({
   id: "anthropic.web_search_20260209",
   inputSchema: webSearch_20260209InputSchema,
   outputSchema: webSearch_20260209OutputSchema,
@@ -1092,45 +1141,49 @@ var webSearch_20260209 = (args = {}) => {
 };
 
 // src/tool/web-search_20250305.ts
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
-var import_v46 = require("zod/v4");
-var webSearch_20250305ArgsSchema = (0, import_provider_utils6.lazySchema)(
-  () => (0, import_provider_utils6.zodSchema)(
-    import_v46.z.object({
-      maxUses: import_v46.z.number().optional(),
-      allowedDomains: import_v46.z.array(import_v46.z.string()).optional(),
-      blockedDomains: import_v46.z.array(import_v46.z.string()).optional(),
-      userLocation: import_v46.z.object({
-        type: import_v46.z.literal("approximate"),
-        city: import_v46.z.string().optional(),
-        region: import_v46.z.string().optional(),
-        country: import_v46.z.string().optional(),
-        timezone: import_v46.z.string().optional()
+import {
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory2,
+  lazySchema as lazySchema5,
+  zodSchema as zodSchema5
+} from "@ai-sdk/provider-utils";
+import { z as z6 } from "zod/v4";
+var webSearch_20250305ArgsSchema = lazySchema5(
+  () => zodSchema5(
+    z6.object({
+      maxUses: z6.number().optional(),
+      allowedDomains: z6.array(z6.string()).optional(),
+      blockedDomains: z6.array(z6.string()).optional(),
+      userLocation: z6.object({
+        type: z6.literal("approximate"),
+        city: z6.string().optional(),
+        region: z6.string().optional(),
+        country: z6.string().optional(),
+        timezone: z6.string().optional()
       }).optional()
     })
   )
 );
-var webSearch_20250305OutputSchema = (0, import_provider_utils6.lazySchema)(
-  () => (0, import_provider_utils6.zodSchema)(
-    import_v46.z.array(
-      import_v46.z.object({
-        url: import_v46.z.string(),
-        title: import_v46.z.string().nullable(),
-        pageAge: import_v46.z.string().nullable(),
-        encryptedContent: import_v46.z.string(),
-        type: import_v46.z.literal("web_search_result")
+var webSearch_20250305OutputSchema = lazySchema5(
+  () => zodSchema5(
+    z6.array(
+      z6.object({
+        url: z6.string(),
+        title: z6.string().nullable(),
+        pageAge: z6.string().nullable(),
+        encryptedContent: z6.string(),
+        type: z6.literal("web_search_result")
       })
     )
   )
 );
-var webSearch_20250305InputSchema = (0, import_provider_utils6.lazySchema)(
-  () => (0, import_provider_utils6.zodSchema)(
-    import_v46.z.object({
-      query: import_v46.z.string()
+var webSearch_20250305InputSchema = lazySchema5(
+  () => zodSchema5(
+    z6.object({
+      query: z6.string()
     })
   )
 );
-var factory3 = (0, import_provider_utils6.createProviderToolFactoryWithOutputSchema)({
+var factory3 = createProviderExecutedToolFactory2({
   id: "anthropic.web_search_20250305",
   inputSchema: webSearch_20250305InputSchema,
   outputSchema: webSearch_20250305OutputSchema,
@@ -1141,53 +1194,57 @@ var webSearch_20250305 = (args = {}) => {
 };
 
 // src/tool/web-fetch-20260209.ts
-var import_provider_utils7 = require("@ai-sdk/provider-utils");
-var import_v47 = require("zod/v4");
-var webFetch_20260209ArgsSchema = (0, import_provider_utils7.lazySchema)(
-  () => (0, import_provider_utils7.zodSchema)(
-    import_v47.z.object({
-      maxUses: import_v47.z.number().optional(),
-      allowedDomains: import_v47.z.array(import_v47.z.string()).optional(),
-      blockedDomains: import_v47.z.array(import_v47.z.string()).optional(),
-      citations: import_v47.z.object({ enabled: import_v47.z.boolean() }).optional(),
-      maxContentTokens: import_v47.z.number().optional()
+import {
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory3,
+  lazySchema as lazySchema6,
+  zodSchema as zodSchema6
+} from "@ai-sdk/provider-utils";
+import { z as z7 } from "zod/v4";
+var webFetch_20260209ArgsSchema = lazySchema6(
+  () => zodSchema6(
+    z7.object({
+      maxUses: z7.number().optional(),
+      allowedDomains: z7.array(z7.string()).optional(),
+      blockedDomains: z7.array(z7.string()).optional(),
+      citations: z7.object({ enabled: z7.boolean() }).optional(),
+      maxContentTokens: z7.number().optional()
     })
   )
 );
-var webFetch_20260209OutputSchema = (0, import_provider_utils7.lazySchema)(
-  () => (0, import_provider_utils7.zodSchema)(
-    import_v47.z.object({
-      type: import_v47.z.literal("web_fetch_result"),
-      url: import_v47.z.string(),
-      content: import_v47.z.object({
-        type: import_v47.z.literal("document"),
-        title: import_v47.z.string().nullable(),
-        citations: import_v47.z.object({ enabled: import_v47.z.boolean() }).optional(),
-        source: import_v47.z.union([
-          import_v47.z.object({
-            type: import_v47.z.literal("base64"),
-            mediaType: import_v47.z.literal("application/pdf"),
-            data: import_v47.z.string()
+var webFetch_20260209OutputSchema = lazySchema6(
+  () => zodSchema6(
+    z7.object({
+      type: z7.literal("web_fetch_result"),
+      url: z7.string(),
+      content: z7.object({
+        type: z7.literal("document"),
+        title: z7.string().nullable(),
+        citations: z7.object({ enabled: z7.boolean() }).optional(),
+        source: z7.union([
+          z7.object({
+            type: z7.literal("base64"),
+            mediaType: z7.literal("application/pdf"),
+            data: z7.string()
           }),
-          import_v47.z.object({
-            type: import_v47.z.literal("text"),
-            mediaType: import_v47.z.literal("text/plain"),
-            data: import_v47.z.string()
+          z7.object({
+            type: z7.literal("text"),
+            mediaType: z7.literal("text/plain"),
+            data: z7.string()
           })
         ])
       }),
-      retrievedAt: import_v47.z.string().nullable()
+      retrievedAt: z7.string().nullable()
     })
   )
 );
-var webFetch_20260209InputSchema = (0, import_provider_utils7.lazySchema)(
-  () => (0, import_provider_utils7.zodSchema)(
-    import_v47.z.object({
-      url: import_v47.z.string()
+var webFetch_20260209InputSchema = lazySchema6(
+  () => zodSchema6(
+    z7.object({
+      url: z7.string()
     })
   )
 );
-var factory4 = (0, import_provider_utils7.createProviderToolFactoryWithOutputSchema)({
+var factory4 = createProviderExecutedToolFactory3({
   id: "anthropic.web_fetch_20260209",
   inputSchema: webFetch_20260209InputSchema,
   outputSchema: webFetch_20260209OutputSchema,
@@ -1198,53 +1255,57 @@ var webFetch_20260209 = (args = {}) => {
 };
 
 // src/tool/web-fetch-20250910.ts
-var import_provider_utils8 = require("@ai-sdk/provider-utils");
-var import_v48 = require("zod/v4");
-var webFetch_20250910ArgsSchema = (0, import_provider_utils8.lazySchema)(
-  () => (0, import_provider_utils8.zodSchema)(
-    import_v48.z.object({
-      maxUses: import_v48.z.number().optional(),
-      allowedDomains: import_v48.z.array(import_v48.z.string()).optional(),
-      blockedDomains: import_v48.z.array(import_v48.z.string()).optional(),
-      citations: import_v48.z.object({ enabled: import_v48.z.boolean() }).optional(),
-      maxContentTokens: import_v48.z.number().optional()
+import {
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory4,
+  lazySchema as lazySchema7,
+  zodSchema as zodSchema7
+} from "@ai-sdk/provider-utils";
+import { z as z8 } from "zod/v4";
+var webFetch_20250910ArgsSchema = lazySchema7(
+  () => zodSchema7(
+    z8.object({
+      maxUses: z8.number().optional(),
+      allowedDomains: z8.array(z8.string()).optional(),
+      blockedDomains: z8.array(z8.string()).optional(),
+      citations: z8.object({ enabled: z8.boolean() }).optional(),
+      maxContentTokens: z8.number().optional()
     })
   )
 );
-var webFetch_20250910OutputSchema = (0, import_provider_utils8.lazySchema)(
-  () => (0, import_provider_utils8.zodSchema)(
-    import_v48.z.object({
-      type: import_v48.z.literal("web_fetch_result"),
-      url: import_v48.z.string(),
-      content: import_v48.z.object({
-        type: import_v48.z.literal("document"),
-        title: import_v48.z.string().nullable(),
-        citations: import_v48.z.object({ enabled: import_v48.z.boolean() }).optional(),
-        source: import_v48.z.union([
-          import_v48.z.object({
-            type: import_v48.z.literal("base64"),
-            mediaType: import_v48.z.literal("application/pdf"),
-            data: import_v48.z.string()
+var webFetch_20250910OutputSchema = lazySchema7(
+  () => zodSchema7(
+    z8.object({
+      type: z8.literal("web_fetch_result"),
+      url: z8.string(),
+      content: z8.object({
+        type: z8.literal("document"),
+        title: z8.string().nullable(),
+        citations: z8.object({ enabled: z8.boolean() }).optional(),
+        source: z8.union([
+          z8.object({
+            type: z8.literal("base64"),
+            mediaType: z8.literal("application/pdf"),
+            data: z8.string()
           }),
-          import_v48.z.object({
-            type: import_v48.z.literal("text"),
-            mediaType: import_v48.z.literal("text/plain"),
-            data: import_v48.z.string()
+          z8.object({
+            type: z8.literal("text"),
+            mediaType: z8.literal("text/plain"),
+            data: z8.string()
           })
         ])
       }),
-      retrievedAt: import_v48.z.string().nullable()
+      retrievedAt: z8.string().nullable()
     })
   )
 );
-var webFetch_20250910InputSchema = (0, import_provider_utils8.lazySchema)(
-  () => (0, import_provider_utils8.zodSchema)(
-    import_v48.z.object({
-      url: import_v48.z.string()
+var webFetch_20250910InputSchema = lazySchema7(
+  () => zodSchema7(
+    z8.object({
+      url: z8.string()
     })
   )
 );
-var factory5 = (0, import_provider_utils8.createProviderToolFactoryWithOutputSchema)({
+var factory5 = createProviderExecutedToolFactory4({
   id: "anthropic.web_fetch_20250910",
   inputSchema: webFetch_20250910InputSchema,
   outputSchema: webFetch_20250910OutputSchema,
@@ -1255,16 +1316,17 @@ var webFetch_20250910 = (args = {}) => {
 };
 
 // src/anthropic-prepare-tools.ts
-var import_provider_utils9 = require("@ai-sdk/provider-utils");
+import { validateTypes } from "@ai-sdk/provider-utils";
 async function prepareTools({
   tools,
   toolChoice,
   disableParallelToolUse,
   cacheControlValidator,
   supportsStructuredOutput,
-  supportsStrictTools
+  supportsStrictTools,
+  defaultEagerInputStreaming = false
 }) {
-  var _a;
+  var _a, _b;
   tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
   const toolWarnings = [];
   const betas = /* @__PURE__ */ new Set();
@@ -1281,7 +1343,7 @@ async function prepareTools({
           canCache: true
         });
         const anthropicOptions = (_a = tool.providerOptions) == null ? void 0 : _a.anthropic;
-        const eagerInputStreaming = anthropicOptions == null ? void 0 : anthropicOptions.eagerInputStreaming;
+        const eagerInputStreaming = (_b = anthropicOptions == null ? void 0 : anthropicOptions.eagerInputStreaming) != null ? _b : defaultEagerInputStreaming;
         const deferLoading = anthropicOptions == null ? void 0 : anthropicOptions.deferLoading;
         const allowedCallers = anthropicOptions == null ? void 0 : anthropicOptions.allowedCallers;
         if (!supportsStrictTools && tool.strict != null) {
@@ -1405,7 +1467,7 @@ async function prepareTools({
             break;
           }
           case "anthropic.text_editor_20250728": {
-            const args = await (0, import_provider_utils9.validateTypes)({
+            const args = await validateTypes({
               value: tool.args,
               schema: textEditor_20250728ArgsSchema
             });
@@ -1445,7 +1507,7 @@ async function prepareTools({
           }
           case "anthropic.web_fetch_20250910": {
             betas.add("web-fetch-2025-09-10");
-            const args = await (0, import_provider_utils9.validateTypes)({
+            const args = await validateTypes({
               value: tool.args,
               schema: webFetch_20250910ArgsSchema
             });
@@ -1463,7 +1525,7 @@ async function prepareTools({
           }
           case "anthropic.web_fetch_20260209": {
             betas.add("code-execution-web-tools-2026-02-09");
-            const args = await (0, import_provider_utils9.validateTypes)({
+            const args = await validateTypes({
               value: tool.args,
               schema: webFetch_20260209ArgsSchema
             });
@@ -1480,7 +1542,7 @@ async function prepareTools({
             break;
           }
           case "anthropic.web_search_20250305": {
-            const args = await (0, import_provider_utils9.validateTypes)({
+            const args = await validateTypes({
               value: tool.args,
               schema: webSearch_20250305ArgsSchema
             });
@@ -1497,7 +1559,7 @@ async function prepareTools({
           }
           case "anthropic.web_search_20260209": {
             betas.add("code-execution-web-tools-2026-02-09");
-            const args = await (0, import_provider_utils9.validateTypes)({
+            const args = await validateTypes({
               value: tool.args,
               schema: webSearch_20260209ArgsSchema
             });
@@ -1513,7 +1575,6 @@ async function prepareTools({
             break;
           }
           case "anthropic.tool_search_regex_20251119": {
-            betas.add("advanced-tool-use-2025-11-20");
             anthropicTools2.push({
               type: "tool_search_tool_regex_20251119",
               name: "tool_search_tool_regex"
@@ -1521,7 +1582,6 @@ async function prepareTools({
             break;
           }
           case "anthropic.tool_search_bm25_20251119": {
-            betas.add("advanced-tool-use-2025-11-20");
             anthropicTools2.push({
               type: "tool_search_tool_bm25_20251119",
               name: "tool_search_tool_bm25"
@@ -1592,15 +1652,15 @@ async function prepareTools({
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new import_provider.UnsupportedFunctionalityError({
+      throw new UnsupportedFunctionalityError({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
   }
 }
 
-// src/convert-anthropic-messages-usage.ts
-function convertAnthropicMessagesUsage({
+// src/convert-anthropic-usage.ts
+function convertAnthropicUsage({
   usage,
   rawUsage
 }) {
@@ -1639,37 +1699,51 @@ function convertAnthropicMessagesUsage({
   };
 }
 
-// src/convert-to-anthropic-messages-prompt.ts
-var import_provider2 = require("@ai-sdk/provider");
-var import_provider_utils14 = require("@ai-sdk/provider-utils");
+// src/convert-to-anthropic-prompt.ts
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
+import {
+  convertBase64ToUint8Array,
+  convertToBase64,
+  isProviderReference,
+  parseProviderOptions,
+  resolveProviderReference,
+  validateTypes as validateTypes2,
+  isNonNullable
+} from "@ai-sdk/provider-utils";
 
 // src/tool/code-execution_20250522.ts
-var import_provider_utils10 = require("@ai-sdk/provider-utils");
-var import_v49 = require("zod/v4");
-var codeExecution_20250522OutputSchema = (0, import_provider_utils10.lazySchema)(
-  () => (0, import_provider_utils10.zodSchema)(
-    import_v49.z.object({
-      type: import_v49.z.literal("code_execution_result"),
-      stdout: import_v49.z.string(),
-      stderr: import_v49.z.string(),
-      return_code: import_v49.z.number(),
-      content: import_v49.z.array(
-        import_v49.z.object({
-          type: import_v49.z.literal("code_execution_output"),
-          file_id: import_v49.z.string()
+import {
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory5,
+  lazySchema as lazySchema8,
+  zodSchema as zodSchema8
+} from "@ai-sdk/provider-utils";
+import { z as z9 } from "zod/v4";
+var codeExecution_20250522OutputSchema = lazySchema8(
+  () => zodSchema8(
+    z9.object({
+      type: z9.literal("code_execution_result"),
+      stdout: z9.string(),
+      stderr: z9.string(),
+      return_code: z9.number(),
+      content: z9.array(
+        z9.object({
+          type: z9.literal("code_execution_output"),
+          file_id: z9.string()
         })
       ).optional().default([])
     })
   )
 );
-var codeExecution_20250522InputSchema = (0, import_provider_utils10.lazySchema)(
-  () => (0, import_provider_utils10.zodSchema)(
-    import_v49.z.object({
-      code: import_v49.z.string()
+var codeExecution_20250522InputSchema = lazySchema8(
+  () => zodSchema8(
+    z9.object({
+      code: z9.string()
     })
   )
 );
-var factory6 = (0, import_provider_utils10.createProviderToolFactoryWithOutputSchema)({
+var factory6 = createProviderExecutedToolFactory5({
   id: "anthropic.code_execution_20250522",
   inputSchema: codeExecution_20250522InputSchema,
   outputSchema: codeExecution_20250522OutputSchema
@@ -1679,102 +1753,106 @@ var codeExecution_20250522 = (args = {}) => {
 };
 
 // src/tool/code-execution_20250825.ts
-var import_provider_utils11 = require("@ai-sdk/provider-utils");
-var import_v410 = require("zod/v4");
-var codeExecution_20250825OutputSchema = (0, import_provider_utils11.lazySchema)(
-  () => (0, import_provider_utils11.zodSchema)(
-    import_v410.z.discriminatedUnion("type", [
-      import_v410.z.object({
-        type: import_v410.z.literal("code_execution_result"),
-        stdout: import_v410.z.string(),
-        stderr: import_v410.z.string(),
-        return_code: import_v410.z.number(),
-        content: import_v410.z.array(
-          import_v410.z.object({
-            type: import_v410.z.literal("code_execution_output"),
-            file_id: import_v410.z.string()
+import {
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory6,
+  lazySchema as lazySchema9,
+  zodSchema as zodSchema9
+} from "@ai-sdk/provider-utils";
+import { z as z10 } from "zod/v4";
+var codeExecution_20250825OutputSchema = lazySchema9(
+  () => zodSchema9(
+    z10.discriminatedUnion("type", [
+      z10.object({
+        type: z10.literal("code_execution_result"),
+        stdout: z10.string(),
+        stderr: z10.string(),
+        return_code: z10.number(),
+        content: z10.array(
+          z10.object({
+            type: z10.literal("code_execution_output"),
+            file_id: z10.string()
           })
         ).optional().default([])
       }),
-      import_v410.z.object({
-        type: import_v410.z.literal("bash_code_execution_result"),
-        content: import_v410.z.array(
-          import_v410.z.object({
-            type: import_v410.z.literal("bash_code_execution_output"),
-            file_id: import_v410.z.string()
+      z10.object({
+        type: z10.literal("bash_code_execution_result"),
+        content: z10.array(
+          z10.object({
+            type: z10.literal("bash_code_execution_output"),
+            file_id: z10.string()
           })
         ),
-        stdout: import_v410.z.string(),
-        stderr: import_v410.z.string(),
-        return_code: import_v410.z.number()
+        stdout: z10.string(),
+        stderr: z10.string(),
+        return_code: z10.number()
       }),
-      import_v410.z.object({
-        type: import_v410.z.literal("bash_code_execution_tool_result_error"),
-        error_code: import_v410.z.string()
+      z10.object({
+        type: z10.literal("bash_code_execution_tool_result_error"),
+        error_code: z10.string()
       }),
-      import_v410.z.object({
-        type: import_v410.z.literal("text_editor_code_execution_tool_result_error"),
-        error_code: import_v410.z.string()
+      z10.object({
+        type: z10.literal("text_editor_code_execution_tool_result_error"),
+        error_code: z10.string()
       }),
-      import_v410.z.object({
-        type: import_v410.z.literal("text_editor_code_execution_view_result"),
-        content: import_v410.z.string(),
-        file_type: import_v410.z.string(),
-        num_lines: import_v410.z.number().nullable(),
-        start_line: import_v410.z.number().nullable(),
-        total_lines: import_v410.z.number().nullable()
+      z10.object({
+        type: z10.literal("text_editor_code_execution_view_result"),
+        content: z10.string(),
+        file_type: z10.string(),
+        num_lines: z10.number().nullable(),
+        start_line: z10.number().nullable(),
+        total_lines: z10.number().nullable()
       }),
-      import_v410.z.object({
-        type: import_v410.z.literal("text_editor_code_execution_create_result"),
-        is_file_update: import_v410.z.boolean()
+      z10.object({
+        type: z10.literal("text_editor_code_execution_create_result"),
+        is_file_update: z10.boolean()
       }),
-      import_v410.z.object({
-        type: import_v410.z.literal("text_editor_code_execution_str_replace_result"),
-        lines: import_v410.z.array(import_v410.z.string()).nullable(),
-        new_lines: import_v410.z.number().nullable(),
-        new_start: import_v410.z.number().nullable(),
-        old_lines: import_v410.z.number().nullable(),
-        old_start: import_v410.z.number().nullable()
+      z10.object({
+        type: z10.literal("text_editor_code_execution_str_replace_result"),
+        lines: z10.array(z10.string()).nullable(),
+        new_lines: z10.number().nullable(),
+        new_start: z10.number().nullable(),
+        old_lines: z10.number().nullable(),
+        old_start: z10.number().nullable()
       })
     ])
   )
 );
-var codeExecution_20250825InputSchema = (0, import_provider_utils11.lazySchema)(
-  () => (0, import_provider_utils11.zodSchema)(
-    import_v410.z.discriminatedUnion("type", [
+var codeExecution_20250825InputSchema = lazySchema9(
+  () => zodSchema9(
+    z10.discriminatedUnion("type", [
       // Programmatic tool calling format (mapped from { code } by AI SDK)
-      import_v410.z.object({
-        type: import_v410.z.literal("programmatic-tool-call"),
-        code: import_v410.z.string()
+      z10.object({
+        type: z10.literal("programmatic-tool-call"),
+        code: z10.string()
       }),
-      import_v410.z.object({
-        type: import_v410.z.literal("bash_code_execution"),
-        command: import_v410.z.string()
+      z10.object({
+        type: z10.literal("bash_code_execution"),
+        command: z10.string()
       }),
-      import_v410.z.discriminatedUnion("command", [
-        import_v410.z.object({
-          type: import_v410.z.literal("text_editor_code_execution"),
-          command: import_v410.z.literal("view"),
-          path: import_v410.z.string()
+      z10.discriminatedUnion("command", [
+        z10.object({
+          type: z10.literal("text_editor_code_execution"),
+          command: z10.literal("view"),
+          path: z10.string()
         }),
-        import_v410.z.object({
-          type: import_v410.z.literal("text_editor_code_execution"),
-          command: import_v410.z.literal("create"),
-          path: import_v410.z.string(),
-          file_text: import_v410.z.string().nullish()
+        z10.object({
+          type: z10.literal("text_editor_code_execution"),
+          command: z10.literal("create"),
+          path: z10.string(),
+          file_text: z10.string().nullish()
         }),
-        import_v410.z.object({
-          type: import_v410.z.literal("text_editor_code_execution"),
-          command: import_v410.z.literal("str_replace"),
-          path: import_v410.z.string(),
-          old_str: import_v410.z.string(),
-          new_str: import_v410.z.string()
+        z10.object({
+          type: z10.literal("text_editor_code_execution"),
+          command: z10.literal("str_replace"),
+          path: z10.string(),
+          old_str: z10.string(),
+          new_str: z10.string()
         })
       ])
     ])
   )
 );
-var factory7 = (0, import_provider_utils11.createProviderToolFactoryWithOutputSchema)({
+var factory7 = createProviderExecutedToolFactory6({
   id: "anthropic.code_execution_20250825",
   inputSchema: codeExecution_20250825InputSchema,
   outputSchema: codeExecution_20250825OutputSchema,
@@ -1788,113 +1866,117 @@ var codeExecution_20250825 = (args = {}) => {
 };
 
 // src/tool/code-execution_20260120.ts
-var import_provider_utils12 = require("@ai-sdk/provider-utils");
-var import_v411 = require("zod/v4");
-var codeExecution_20260120OutputSchema = (0, import_provider_utils12.lazySchema)(
-  () => (0, import_provider_utils12.zodSchema)(
-    import_v411.z.discriminatedUnion("type", [
-      import_v411.z.object({
-        type: import_v411.z.literal("code_execution_result"),
-        stdout: import_v411.z.string(),
-        stderr: import_v411.z.string(),
-        return_code: import_v411.z.number(),
-        content: import_v411.z.array(
-          import_v411.z.object({
-            type: import_v411.z.literal("code_execution_output"),
-            file_id: import_v411.z.string()
+import {
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory7,
+  lazySchema as lazySchema10,
+  zodSchema as zodSchema10
+} from "@ai-sdk/provider-utils";
+import { z as z11 } from "zod/v4";
+var codeExecution_20260120OutputSchema = lazySchema10(
+  () => zodSchema10(
+    z11.discriminatedUnion("type", [
+      z11.object({
+        type: z11.literal("code_execution_result"),
+        stdout: z11.string(),
+        stderr: z11.string(),
+        return_code: z11.number(),
+        content: z11.array(
+          z11.object({
+            type: z11.literal("code_execution_output"),
+            file_id: z11.string()
           })
         ).optional().default([])
       }),
-      import_v411.z.object({
-        type: import_v411.z.literal("encrypted_code_execution_result"),
-        encrypted_stdout: import_v411.z.string(),
-        stderr: import_v411.z.string(),
-        return_code: import_v411.z.number(),
-        content: import_v411.z.array(
-          import_v411.z.object({
-            type: import_v411.z.literal("code_execution_output"),
-            file_id: import_v411.z.string()
+      z11.object({
+        type: z11.literal("encrypted_code_execution_result"),
+        encrypted_stdout: z11.string(),
+        stderr: z11.string(),
+        return_code: z11.number(),
+        content: z11.array(
+          z11.object({
+            type: z11.literal("code_execution_output"),
+            file_id: z11.string()
           })
         ).optional().default([])
       }),
-      import_v411.z.object({
-        type: import_v411.z.literal("bash_code_execution_result"),
-        content: import_v411.z.array(
-          import_v411.z.object({
-            type: import_v411.z.literal("bash_code_execution_output"),
-            file_id: import_v411.z.string()
+      z11.object({
+        type: z11.literal("bash_code_execution_result"),
+        content: z11.array(
+          z11.object({
+            type: z11.literal("bash_code_execution_output"),
+            file_id: z11.string()
           })
         ),
-        stdout: import_v411.z.string(),
-        stderr: import_v411.z.string(),
-        return_code: import_v411.z.number()
+        stdout: z11.string(),
+        stderr: z11.string(),
+        return_code: z11.number()
       }),
-      import_v411.z.object({
-        type: import_v411.z.literal("bash_code_execution_tool_result_error"),
-        error_code: import_v411.z.string()
+      z11.object({
+        type: z11.literal("bash_code_execution_tool_result_error"),
+        error_code: z11.string()
       }),
-      import_v411.z.object({
-        type: import_v411.z.literal("text_editor_code_execution_tool_result_error"),
-        error_code: import_v411.z.string()
+      z11.object({
+        type: z11.literal("text_editor_code_execution_tool_result_error"),
+        error_code: z11.string()
       }),
-      import_v411.z.object({
-        type: import_v411.z.literal("text_editor_code_execution_view_result"),
-        content: import_v411.z.string(),
-        file_type: import_v411.z.string(),
-        num_lines: import_v411.z.number().nullable(),
-        start_line: import_v411.z.number().nullable(),
-        total_lines: import_v411.z.number().nullable()
+      z11.object({
+        type: z11.literal("text_editor_code_execution_view_result"),
+        content: z11.string(),
+        file_type: z11.string(),
+        num_lines: z11.number().nullable(),
+        start_line: z11.number().nullable(),
+        total_lines: z11.number().nullable()
       }),
-      import_v411.z.object({
-        type: import_v411.z.literal("text_editor_code_execution_create_result"),
-        is_file_update: import_v411.z.boolean()
+      z11.object({
+        type: z11.literal("text_editor_code_execution_create_result"),
+        is_file_update: z11.boolean()
       }),
-      import_v411.z.object({
-        type: import_v411.z.literal("text_editor_code_execution_str_replace_result"),
-        lines: import_v411.z.array(import_v411.z.string()).nullable(),
-        new_lines: import_v411.z.number().nullable(),
-        new_start: import_v411.z.number().nullable(),
-        old_lines: import_v411.z.number().nullable(),
-        old_start: import_v411.z.number().nullable()
+      z11.object({
+        type: z11.literal("text_editor_code_execution_str_replace_result"),
+        lines: z11.array(z11.string()).nullable(),
+        new_lines: z11.number().nullable(),
+        new_start: z11.number().nullable(),
+        old_lines: z11.number().nullable(),
+        old_start: z11.number().nullable()
       })
     ])
   )
 );
-var codeExecution_20260120InputSchema = (0, import_provider_utils12.lazySchema)(
-  () => (0, import_provider_utils12.zodSchema)(
-    import_v411.z.discriminatedUnion("type", [
-      import_v411.z.object({
-        type: import_v411.z.literal("programmatic-tool-call"),
-        code: import_v411.z.string()
+var codeExecution_20260120InputSchema = lazySchema10(
+  () => zodSchema10(
+    z11.discriminatedUnion("type", [
+      z11.object({
+        type: z11.literal("programmatic-tool-call"),
+        code: z11.string()
       }),
-      import_v411.z.object({
-        type: import_v411.z.literal("bash_code_execution"),
-        command: import_v411.z.string()
+      z11.object({
+        type: z11.literal("bash_code_execution"),
+        command: z11.string()
       }),
-      import_v411.z.discriminatedUnion("command", [
-        import_v411.z.object({
-          type: import_v411.z.literal("text_editor_code_execution"),
-          command: import_v411.z.literal("view"),
-          path: import_v411.z.string()
+      z11.discriminatedUnion("command", [
+        z11.object({
+          type: z11.literal("text_editor_code_execution"),
+          command: z11.literal("view"),
+          path: z11.string()
         }),
-        import_v411.z.object({
-          type: import_v411.z.literal("text_editor_code_execution"),
-          command: import_v411.z.literal("create"),
-          path: import_v411.z.string(),
-          file_text: import_v411.z.string().nullish()
+        z11.object({
+          type: z11.literal("text_editor_code_execution"),
+          command: z11.literal("create"),
+          path: z11.string(),
+          file_text: z11.string().nullish()
         }),
-        import_v411.z.object({
-          type: import_v411.z.literal("text_editor_code_execution"),
-          command: import_v411.z.literal("str_replace"),
-          path: import_v411.z.string(),
-          old_str: import_v411.z.string(),
-          new_str: import_v411.z.string()
+        z11.object({
+          type: z11.literal("text_editor_code_execution"),
+          command: z11.literal("str_replace"),
+          path: z11.string(),
+          old_str: z11.string(),
+          new_str: z11.string()
         })
       ])
     ])
   )
 );
-var factory8 = (0, import_provider_utils12.createProviderToolFactoryWithOutputSchema)({
+var factory8 = createProviderExecutedToolFactory7({
   id: "anthropic.code_execution_20260120",
   inputSchema: codeExecution_20260120InputSchema,
   outputSchema: codeExecution_20260120OutputSchema,
@@ -1905,21 +1987,25 @@ var codeExecution_20260120 = (args = {}) => {
 };
 
 // src/tool/tool-search-regex_20251119.ts
-var import_provider_utils13 = require("@ai-sdk/provider-utils");
-var import_v412 = require("zod/v4");
-var toolSearchRegex_20251119OutputSchema = (0, import_provider_utils13.lazySchema)(
-  () => (0, import_provider_utils13.zodSchema)(
-    import_v412.z.array(
-      import_v412.z.object({
-        type: import_v412.z.literal("tool_reference"),
-        toolName: import_v412.z.string()
+import {
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory8,
+  lazySchema as lazySchema11,
+  zodSchema as zodSchema11
+} from "@ai-sdk/provider-utils";
+import { z as z12 } from "zod/v4";
+var toolSearchRegex_20251119OutputSchema = lazySchema11(
+  () => zodSchema11(
+    z12.array(
+      z12.object({
+        type: z12.literal("tool_reference"),
+        toolName: z12.string()
       })
     )
   )
 );
-var toolSearchRegex_20251119InputSchema = (0, import_provider_utils13.lazySchema)(
-  () => (0, import_provider_utils13.zodSchema)(
-    import_v412.z.object({
+var toolSearchRegex_20251119InputSchema = lazySchema11(
+  () => zodSchema11(
+    z12.object({
       /**
        * A regex pattern to search for tools.
        * Uses Python re.search() syntax. Maximum 200 characters.
@@ -1930,15 +2016,15 @@ var toolSearchRegex_20251119InputSchema = (0, import_provider_utils13.lazySchema
        * - "database.*query|query.*database" - OR patterns for flexibility
        * - "(?i)slack" - case-insensitive search
        */
-      pattern: import_v412.z.string(),
+      pattern: z12.string(),
       /**
        * Maximum number of tools to return. Optional.
        */
-      limit: import_v412.z.number().optional()
+      limit: z12.number().optional()
     })
   )
 );
-var factory9 = (0, import_provider_utils13.createProviderToolFactoryWithOutputSchema)({
+var factory9 = createProviderExecutedToolFactory8({
   id: "anthropic.tool_search_regex_20251119",
   inputSchema: toolSearchRegex_20251119InputSchema,
   outputSchema: toolSearchRegex_20251119OutputSchema,
@@ -1948,20 +2034,20 @@ var toolSearchRegex_20251119 = (args = {}) => {
   return factory9(args);
 };
 
-// src/convert-to-anthropic-messages-prompt.ts
+// src/convert-to-anthropic-prompt.ts
 function convertToString(data) {
   if (typeof data === "string") {
-    return new TextDecoder().decode((0, import_provider_utils14.convertBase64ToUint8Array)(data));
+    return new TextDecoder().decode(convertBase64ToUint8Array(data));
   }
   if (data instanceof Uint8Array) {
     return new TextDecoder().decode(data);
   }
   if (data instanceof URL) {
-    throw new import_provider2.UnsupportedFunctionalityError({
+    throw new UnsupportedFunctionalityError2({
       functionality: "URL-based text documents are not supported for citations"
     });
   }
-  throw new import_provider2.UnsupportedFunctionalityError({
+  throw new UnsupportedFunctionalityError2({
     functionality: `unsupported data type for text documents: ${typeof data}`
   });
 }
@@ -1974,7 +2060,7 @@ function isUrlString(data) {
 function getUrlString(data) {
   return data instanceof URL ? data.toString() : data;
 }
-async function convertToAnthropicMessagesPrompt({
+async function convertToAnthropicPrompt({
   prompt,
   sendReasoning,
   warnings,
@@ -1989,7 +2075,7 @@ async function convertToAnthropicMessagesPrompt({
   const messages = [];
   async function shouldEnableCitations(providerMetadata) {
     var _a2, _b2;
-    const anthropicOptions = await (0, import_provider_utils14.parseProviderOptions)({
+    const anthropicOptions = await parseProviderOptions({
       provider: "anthropic",
       providerOptions: providerMetadata,
       schema: anthropicFilePartProviderOptions
@@ -1997,7 +2083,7 @@ async function convertToAnthropicMessagesPrompt({
     return (_b2 = (_a2 = anthropicOptions == null ? void 0 : anthropicOptions.citations) == null ? void 0 : _a2.enabled) != null ? _b2 : false;
   }
   async function getDocumentMetadata(providerMetadata) {
-    const anthropicOptions = await (0, import_provider_utils14.parseProviderOptions)({
+    const anthropicOptions = await parseProviderOptions({
       provider: "anthropic",
       providerOptions: providerMetadata,
       schema: anthropicFilePartProviderOptions
@@ -2014,7 +2100,7 @@ async function convertToAnthropicMessagesPrompt({
     switch (type) {
       case "system": {
         if (system != null) {
-          throw new import_provider2.UnsupportedFunctionalityError({
+          throw new UnsupportedFunctionalityError2({
             functionality: "Multiple system messages that are separated by user/assistant messages"
           });
         }
@@ -2054,7 +2140,26 @@ async function convertToAnthropicMessagesPrompt({
                     break;
                   }
                   case "file": {
-                    if (part.mediaType.startsWith("image/")) {
+                    if (isProviderReference(part.data)) {
+                      const fileId = resolveProviderReference({
+                        reference: part.data,
+                        provider: "anthropic"
+                      });
+                      betas.add("files-api-2025-04-14");
+                      if (part.mediaType.startsWith("image/")) {
+                        anthropicContent.push({
+                          type: "image",
+                          source: { type: "file", file_id: fileId },
+                          cache_control: cacheControl
+                        });
+                      } else {
+                        anthropicContent.push({
+                          type: "document",
+                          source: { type: "file", file_id: fileId },
+                          cache_control: cacheControl
+                        });
+                      }
+                    } else if (part.mediaType.startsWith("image/")) {
                       anthropicContent.push({
                         type: "image",
                         source: isUrlData(part.data) ? {
@@ -2063,7 +2168,7 @@ async function convertToAnthropicMessagesPrompt({
                         } : {
                           type: "base64",
                           media_type: part.mediaType === "image/*" ? "image/jpeg" : part.mediaType,
-                          data: (0, import_provider_utils14.convertToBase64)(part.data)
+                          data: convertToBase64(part.data)
                         },
                         cache_control: cacheControl
                       });
@@ -2083,7 +2188,7 @@ async function convertToAnthropicMessagesPrompt({
                         } : {
                           type: "base64",
                           media_type: "application/pdf",
-                          data: (0, import_provider_utils14.convertToBase64)(part.data)
+                          data: convertToBase64(part.data)
                         },
                         title: (_b = metadata.title) != null ? _b : part.filename,
                         ...metadata.context && { context: metadata.context },
@@ -2117,7 +2222,7 @@ async function convertToAnthropicMessagesPrompt({
                         cache_control: cacheControl
                       });
                     } else {
-                      throw new import_provider2.UnsupportedFunctionalityError({
+                      throw new UnsupportedFunctionalityError2({
                         functionality: `media type: ${part.mediaType}`
                       });
                     }
@@ -2153,26 +2258,16 @@ async function convertToAnthropicMessagesPrompt({
                             type: "text",
                             text: contentPart.text
                           };
-                        case "image-data": {
-                          return {
-                            type: "image",
-                            source: {
-                              type: "base64",
-                              media_type: contentPart.mediaType,
-                              data: contentPart.data
-                            }
-                          };
-                        }
-                        case "image-url": {
-                          return {
-                            type: "image",
-                            source: {
-                              type: "url",
-                              url: contentPart.url
-                            }
-                          };
-                        }
                         case "file-url": {
+                          if (contentPart.mediaType.startsWith("image/")) {
+                            return {
+                              type: "image",
+                              source: {
+                                type: "url",
+                                url: contentPart.url
+                              }
+                            };
+                          }
                           return {
                             type: "document",
                             source: {
@@ -2182,6 +2277,16 @@ async function convertToAnthropicMessagesPrompt({
                           };
                         }
                         case "file-data": {
+                          if (contentPart.mediaType.startsWith("image/")) {
+                            return {
+                              type: "image",
+                              source: {
+                                type: "base64",
+                                media_type: contentPart.mediaType,
+                                data: contentPart.data
+                              }
+                            };
+                          }
                           if (contentPart.mediaType === "application/pdf") {
                             betas.add("pdfs-2024-09-25");
                             return {
@@ -2221,14 +2326,14 @@ async function convertToAnthropicMessagesPrompt({
                           return void 0;
                         }
                       }
-                    }).filter(import_provider_utils14.isNonNullable);
+                    }).filter(isNonNullable);
                     break;
                   case "text":
                   case "error-text":
                     contentValue = output.value;
                     break;
                   case "execution-denied":
-                    contentValue = (_e = output.reason) != null ? _e : "Tool execution denied.";
+                    contentValue = (_e = output.reason) != null ? _e : "Tool call execution denied.";
                     break;
                   case "json":
                   case "error-json":
@@ -2297,7 +2402,7 @@ async function convertToAnthropicMessagesPrompt({
               }
               case "reasoning": {
                 if (sendReasoning) {
-                  const reasoningMetadata = await (0, import_provider_utils14.parseProviderOptions)({
+                  const reasoningMetadata = await parseProviderOptions({
                     provider: "anthropic",
                     providerOptions: part.providerOptions,
                     schema: anthropicReasoningMetadataSchema
@@ -2503,7 +2608,7 @@ async function convertToAnthropicMessagesPrompt({
                     break;
                   }
                   if (output.value.type === "code_execution_result") {
-                    const codeExecutionOutput = await (0, import_provider_utils14.validateTypes)({
+                    const codeExecutionOutput = await validateTypes2({
                       value: output.value,
                       schema: codeExecution_20250522OutputSchema
                     });
@@ -2520,7 +2625,7 @@ async function convertToAnthropicMessagesPrompt({
                       cache_control: cacheControl
                     });
                   } else if (output.value.type === "encrypted_code_execution_result") {
-                    const codeExecutionOutput = await (0, import_provider_utils14.validateTypes)({
+                    const codeExecutionOutput = await validateTypes2({
                       value: output.value,
                       schema: codeExecution_20260120OutputSchema
                     });
@@ -2539,7 +2644,7 @@ async function convertToAnthropicMessagesPrompt({
                       });
                     }
                   } else {
-                    const codeExecutionOutput = await (0, import_provider_utils14.validateTypes)({
+                    const codeExecutionOutput = await validateTypes2({
                       value: output.value,
                       schema: codeExecution_20250825OutputSchema
                     });
@@ -2608,7 +2713,7 @@ async function convertToAnthropicMessagesPrompt({
                     });
                     break;
                   }
-                  const webFetchOutput = await (0, import_provider_utils14.validateTypes)({
+                  const webFetchOutput = await validateTypes2({
                     value: output.value,
                     schema: webFetch_20250910OutputSchema
                   });
@@ -2643,7 +2748,7 @@ async function convertToAnthropicMessagesPrompt({
                     });
                     break;
                   }
-                  const webSearchOutput = await (0, import_provider_utils14.validateTypes)({
+                  const webSearchOutput = await validateTypes2({
                     value: output.value,
                     schema: webSearch_20250305OutputSchema
                   });
@@ -2670,7 +2775,7 @@ async function convertToAnthropicMessagesPrompt({
                     });
                     break;
                   }
-                  const toolSearchOutput = await (0, import_provider_utils14.validateTypes)({
+                  const toolSearchOutput = await validateTypes2({
                     value: output.value,
                     schema: toolSearchRegex_20251119OutputSchema
                   });
@@ -2783,7 +2888,153 @@ function mapAnthropicStopReason({
   }
 }
 
-// src/anthropic-messages-language-model.ts
+// src/sanitize-json-schema.ts
+var SUPPORTED_STRING_FORMATS = /* @__PURE__ */ new Set([
+  "date-time",
+  "time",
+  "date",
+  "duration",
+  "email",
+  "hostname",
+  "uri",
+  "ipv4",
+  "ipv6",
+  "uuid"
+]);
+var DESCRIPTION_CONSTRAINT_KEYS = [
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "minItems",
+  "maxItems",
+  "uniqueItems",
+  "minProperties",
+  "maxProperties",
+  "not"
+];
+function sanitizeJsonSchema(schema) {
+  return sanitizeSchema(schema);
+}
+function sanitizeDefinition(definition) {
+  if (typeof definition === "boolean" || !isPlainObject(definition)) {
+    return definition;
+  }
+  return sanitizeSchema(definition);
+}
+function sanitizeSchema(schema) {
+  const result = {};
+  const schemaWithDefs = schema;
+  if (schema.$ref != null) {
+    return { $ref: schema.$ref };
+  }
+  if (schema.$schema != null) {
+    result.$schema = schema.$schema;
+  }
+  if (schema.$id != null) {
+    result.$id = schema.$id;
+  }
+  if (schema.title != null) {
+    result.title = schema.title;
+  }
+  if (schema.description != null) {
+    result.description = schema.description;
+  }
+  if (schema.default !== void 0) {
+    result.default = schema.default;
+  }
+  if (schema.const !== void 0) {
+    result.const = schema.const;
+  }
+  if (schema.enum != null) {
+    result.enum = schema.enum;
+  }
+  if (schema.type != null) {
+    result.type = schema.type;
+  }
+  if (schema.anyOf != null) {
+    result.anyOf = schema.anyOf.map(sanitizeDefinition);
+  } else if (schema.oneOf != null) {
+    result.anyOf = schema.oneOf.map(sanitizeDefinition);
+  }
+  if (schema.allOf != null) {
+    result.allOf = schema.allOf.map(sanitizeDefinition);
+  }
+  if (schema.definitions != null) {
+    result.definitions = Object.fromEntries(
+      Object.entries(schema.definitions).map(([name, definition]) => [
+        name,
+        sanitizeDefinition(definition)
+      ])
+    );
+  }
+  if (schemaWithDefs.$defs != null) {
+    const resultWithDefs = result;
+    resultWithDefs.$defs = Object.fromEntries(
+      Object.entries(schemaWithDefs.$defs).map(([name, definition]) => [
+        name,
+        sanitizeDefinition(definition)
+      ])
+    );
+  }
+  if (schema.type === "object" || schema.properties != null) {
+    if (schema.properties != null) {
+      result.properties = Object.fromEntries(
+        Object.entries(schema.properties).map(([name, definition]) => [
+          name,
+          sanitizeDefinition(definition)
+        ])
+      );
+    }
+    result.additionalProperties = false;
+    if (schema.required != null) {
+      result.required = schema.required;
+    }
+  }
+  if (schema.items != null) {
+    result.items = Array.isArray(schema.items) ? schema.items.map(sanitizeDefinition) : sanitizeDefinition(schema.items);
+  }
+  if (typeof schema.format === "string" && SUPPORTED_STRING_FORMATS.has(schema.format)) {
+    result.format = schema.format;
+  }
+  const constraintDescription = getConstraintDescription(schema);
+  if (constraintDescription != null) {
+    result.description = result.description == null ? constraintDescription : `${result.description}
+${constraintDescription}`;
+  }
+  return result;
+}
+function getConstraintDescription(schema) {
+  const descriptions = DESCRIPTION_CONSTRAINT_KEYS.flatMap((key) => {
+    const value = schema[key];
+    if (value == null || value === false) {
+      return [];
+    }
+    return `${formatConstraintName(key)}: ${formatConstraintValue(value)}`;
+  });
+  if (typeof schema.format === "string" && !SUPPORTED_STRING_FORMATS.has(schema.format)) {
+    descriptions.push(`format: ${schema.format}`);
+  }
+  return descriptions.length === 0 ? void 0 : `${descriptions.join("; ")}.`;
+}
+function formatConstraintName(key) {
+  return key.replace(/[A-Z]/g, (match) => ` ${match.toLowerCase()}`);
+}
+function formatConstraintValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/anthropic-language-model.ts
 function createCitationSource(citation, citationDocuments, generateId2) {
   var _a;
   if (citation.type === "web_search_result_location") {
@@ -2828,13 +3079,22 @@ function createCitationSource(citation, citationDocuments, generateId2) {
     }
   };
 }
-var AnthropicMessagesLanguageModel = class {
+var AnthropicLanguageModel = class _AnthropicLanguageModel {
   constructor(modelId, config) {
     this.specificationVersion = "v4";
     var _a;
     this.modelId = modelId;
     this.config = config;
-    this.generateId = (_a = config.generateId) != null ? _a : import_provider_utils15.generateId;
+    this.generateId = (_a = config.generateId) != null ? _a : generateId;
+  }
+  static [WORKFLOW_SERIALIZE](model) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE](options) {
+    return new _AnthropicLanguageModel(options.modelId, options.config);
   }
   supportsUrl(url) {
     return url.protocol === "https:";
@@ -2869,10 +3129,11 @@ var AnthropicMessagesLanguageModel = class {
     seed,
     tools,
     toolChoice,
+    reasoning,
     providerOptions,
     stream
   }) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
     const warnings = [];
     if (frequencyPenalty != null) {
       warnings.push({ type: "unsupported", feature: "frequencyPenalty" });
@@ -2908,12 +3169,12 @@ var AnthropicMessagesLanguageModel = class {
       }
     }
     const providerOptionsName = this.providerOptionsName;
-    const canonicalOptions = await (0, import_provider_utils15.parseProviderOptions)({
+    const canonicalOptions = await parseProviderOptions2({
       provider: "anthropic",
       providerOptions,
       schema: anthropicLanguageModelOptions
     });
-    const customProviderOptions = providerOptionsName !== "anthropic" ? await (0, import_provider_utils15.parseProviderOptions)({
+    const customProviderOptions = providerOptionsName !== "anthropic" ? await parseProviderOptions2({
       provider: providerOptionsName,
       providerOptions,
       schema: anthropicLanguageModelOptions
@@ -2927,8 +3188,38 @@ var AnthropicMessagesLanguageModel = class {
     const {
       maxOutputTokens: maxOutputTokensForModel,
       supportsStructuredOutput: modelSupportsStructuredOutput,
+      supportsAdaptiveThinking,
+      rejectsSamplingParameters,
+      supportsXhighEffort,
       isKnownModel
     } = getModelCapabilities(this.modelId);
+    if (rejectsSamplingParameters) {
+      if (temperature != null) {
+        warnings.push({
+          type: "unsupported",
+          feature: "temperature",
+          details: `temperature is not supported by ${this.modelId} and will be ignored`
+        });
+        temperature = void 0;
+      }
+      if (topK != null) {
+        warnings.push({
+          type: "unsupported",
+          feature: "topK",
+          details: `topK is not supported by ${this.modelId} and will be ignored`
+        });
+        topK = void 0;
+      }
+      if (topP != null) {
+        warnings.push({
+          type: "unsupported",
+          feature: "topP",
+          details: `topP is not supported by ${this.modelId} and will be ignored`
+        });
+        topP = void 0;
+      }
+    }
+    const isAnthropicModel = isKnownModel || this.modelId.startsWith("claude-");
     const supportsStructuredOutput = ((_a = this.config.supportsNativeStructuredOutput) != null ? _a : true) && modelSupportsStructuredOutput;
     const supportsStrictTools = ((_b = this.config.supportsStrictTools) != null ? _b : true) && modelSupportsStructuredOutput;
     const structureOutputMode = (_c = anthropicOptions == null ? void 0 : anthropicOptions.structuredOutputMode) != null ? _c : "auto";
@@ -2941,7 +3232,7 @@ var AnthropicMessagesLanguageModel = class {
     } : void 0;
     const contextManagement = anthropicOptions == null ? void 0 : anthropicOptions.contextManagement;
     const cacheControlValidator = new CacheControlValidator();
-    const toolNameMapping = (0, import_provider_utils15.createToolNameMapping)({
+    const toolNameMapping = createToolNameMapping({
       tools,
       providerToolNames: {
         "anthropic.code_execution_20250522": "code_execution",
@@ -2964,16 +3255,34 @@ var AnthropicMessagesLanguageModel = class {
         "anthropic.tool_search_bm25_20251119": "tool_search_tool_bm25"
       }
     });
-    const { prompt: messagesPrompt, betas } = await convertToAnthropicMessagesPrompt({
+    const { prompt: messagesPrompt, betas } = await convertToAnthropicPrompt({
       prompt,
       sendReasoning: (_d = anthropicOptions == null ? void 0 : anthropicOptions.sendReasoning) != null ? _d : true,
       warnings,
       cacheControlValidator,
       toolNameMapping
     });
-    const thinkingType = (_e = anthropicOptions == null ? void 0 : anthropicOptions.thinking) == null ? void 0 : _e.type;
+    if (isCustomReasoning(reasoning) && (anthropicOptions == null ? void 0 : anthropicOptions.effort) == null) {
+      const reasoningConfig = resolveAnthropicReasoningConfig({
+        reasoning,
+        supportsAdaptiveThinking,
+        supportsXhighEffort,
+        maxOutputTokensForModel,
+        warnings
+      });
+      if (reasoningConfig != null) {
+        if (anthropicOptions.thinking == null) {
+          anthropicOptions.thinking = reasoningConfig.thinking;
+        }
+        if (reasoningConfig.effort != null && ((_e = anthropicOptions.thinking) == null ? void 0 : _e.type) !== "disabled") {
+          anthropicOptions.effort = reasoningConfig.effort;
+        }
+      }
+    }
+    const thinkingType = (_f = anthropicOptions == null ? void 0 : anthropicOptions.thinking) == null ? void 0 : _f.type;
     const isThinking = thinkingType === "enabled" || thinkingType === "adaptive";
-    let thinkingBudget = thinkingType === "enabled" ? (_f = anthropicOptions == null ? void 0 : anthropicOptions.thinking) == null ? void 0 : _f.budgetTokens : void 0;
+    let thinkingBudget = thinkingType === "enabled" ? (_g = anthropicOptions == null ? void 0 : anthropicOptions.thinking) == null ? void 0 : _g.budgetTokens : void 0;
+    const thinkingDisplay = thinkingType === "adaptive" ? (_h = anthropicOptions == null ? void 0 : anthropicOptions.thinking) == null ? void 0 : _h.display : void 0;
     const maxTokens = maxOutputTokens != null ? maxOutputTokens : maxOutputTokensForModel;
     const baseArgs = {
       // model id:
@@ -2988,18 +3297,28 @@ var AnthropicMessagesLanguageModel = class {
       ...isThinking && {
         thinking: {
           type: thinkingType,
-          ...thinkingBudget != null && { budget_tokens: thinkingBudget }
+          ...thinkingBudget != null && { budget_tokens: thinkingBudget },
+          ...thinkingDisplay != null && { display: thinkingDisplay }
         }
       },
-      ...((anthropicOptions == null ? void 0 : anthropicOptions.effort) || useStructuredOutput && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null) && {
+      ...((anthropicOptions == null ? void 0 : anthropicOptions.effort) || (anthropicOptions == null ? void 0 : anthropicOptions.taskBudget) || useStructuredOutput && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null) && {
         output_config: {
           ...(anthropicOptions == null ? void 0 : anthropicOptions.effort) && {
             effort: anthropicOptions.effort
           },
+          ...(anthropicOptions == null ? void 0 : anthropicOptions.taskBudget) && {
+            task_budget: {
+              type: anthropicOptions.taskBudget.type,
+              total: anthropicOptions.taskBudget.total,
+              ...anthropicOptions.taskBudget.remaining != null && {
+                remaining: anthropicOptions.taskBudget.remaining
+              }
+            }
+          },
           ...useStructuredOutput && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && {
             format: {
               type: "json_schema",
-              schema: responseFormat.schema
+              schema: sanitizeJsonSchema(responseFormat.schema)
             }
           }
         }
@@ -3007,9 +3326,15 @@ var AnthropicMessagesLanguageModel = class {
       ...(anthropicOptions == null ? void 0 : anthropicOptions.speed) && {
         speed: anthropicOptions.speed
       },
+      ...(anthropicOptions == null ? void 0 : anthropicOptions.inferenceGeo) && {
+        inference_geo: anthropicOptions.inferenceGeo
+      },
       ...(anthropicOptions == null ? void 0 : anthropicOptions.cacheControl) && {
         cache_control: anthropicOptions.cacheControl
       },
+      ...((_i = anthropicOptions == null ? void 0 : anthropicOptions.metadata) == null ? void 0 : _i.userId) != null && {
+        metadata: { user_id: anthropicOptions.metadata.userId }
+      },
       // mcp servers:
       ...(anthropicOptions == null ? void 0 : anthropicOptions.mcpServers) && anthropicOptions.mcpServers.length > 0 && {
         mcp_servers: anthropicOptions.mcpServers.map((server) => ({
@@ -3031,7 +3356,10 @@ var AnthropicMessagesLanguageModel = class {
             id: anthropicOptions.container.id,
             skills: anthropicOptions.container.skills.map((skill) => ({
               type: skill.type,
-              skill_id: skill.skillId,
+              skill_id: skill.type === "custom" ? resolveProviderReference2({
+                reference: skill.providerReference,
+                provider: "anthropic"
+              }) : skill.skillId,
               version: skill.version
             }))
           }
@@ -3133,7 +3461,7 @@ var AnthropicMessagesLanguageModel = class {
       }
       baseArgs.max_tokens = maxTokens + (thinkingBudget != null ? thinkingBudget : 0);
     } else {
-      if (topP != null && temperature != null) {
+      if (isAnthropicModel && topP != null && temperature != null) {
         warnings.push({
           type: "unsupported",
           feature: "topP",
@@ -3177,12 +3505,13 @@ var AnthropicMessagesLanguageModel = class {
     if (anthropicOptions == null ? void 0 : anthropicOptions.effort) {
       betas.add("effort-2025-11-24");
     }
+    if (anthropicOptions == null ? void 0 : anthropicOptions.taskBudget) {
+      betas.add("task-budgets-2026-03-13");
+    }
     if ((anthropicOptions == null ? void 0 : anthropicOptions.speed) === "fast") {
       betas.add("fast-mode-2026-02-01");
     }
-    if (stream && ((_g = anthropicOptions == null ? void 0 : anthropicOptions.toolStreaming) != null ? _g : true)) {
-      betas.add("fine-grained-tool-streaming-2025-05-14");
-    }
+    const defaultEagerInputStreaming = stream && ((_j = anthropicOptions == null ? void 0 : anthropicOptions.toolStreaming) != null ? _j : true);
     const {
       tools: anthropicTools2,
       toolChoice: anthropicToolChoice,
@@ -3195,14 +3524,16 @@ var AnthropicMessagesLanguageModel = class {
         disableParallelToolUse: true,
         cacheControlValidator,
         supportsStructuredOutput: false,
-        supportsStrictTools
+        supportsStrictTools,
+        defaultEagerInputStreaming
       } : {
         tools: tools != null ? tools : [],
         toolChoice,
         disableParallelToolUse: anthropicOptions == null ? void 0 : anthropicOptions.disableParallelToolUse,
         cacheControlValidator,
         supportsStructuredOutput,
-        supportsStrictTools
+        supportsStrictTools,
+        defaultEagerInputStreaming
       }
     );
     const cacheWarnings = cacheControlValidator.getWarnings();
@@ -3219,7 +3550,7 @@ var AnthropicMessagesLanguageModel = class {
         ...betas,
         ...toolsBetas,
         ...userSuppliedBetas,
-        ...(_h = anthropicOptions == null ? void 0 : anthropicOptions.anthropicBeta) != null ? _h : []
+        ...(_k = anthropicOptions == null ? void 0 : anthropicOptions.anthropicBeta) != null ? _k : []
       ]),
       usesJsonResponseTool: jsonResponseTool != null,
       toolNameMapping,
@@ -3231,16 +3562,16 @@ var AnthropicMessagesLanguageModel = class {
     betas,
     headers
   }) {
-    return (0, import_provider_utils15.combineHeaders)(
-      await (0, import_provider_utils15.resolve)(this.config.headers),
+    return combineHeaders(
+      this.config.headers ? await resolve(this.config.headers) : void 0,
       headers,
       betas.size > 0 ? { "anthropic-beta": Array.from(betas).join(",") } : {}
     );
   }
   async getBetasFromHeaders(requestHeaders) {
     var _a, _b;
-    const configHeaders = await (0, import_provider_utils15.resolve)(this.config.headers);
-    const configBetaHeader = (_a = configHeaders["anthropic-beta"]) != null ? _a : "";
+    const configHeaders = this.config.headers ? await resolve(this.config.headers) : void 0;
+    const configBetaHeader = (_a = configHeaders == null ? void 0 : configHeaders["anthropic-beta"]) != null ? _a : "";
     const requestBetaHeader = (_b = requestHeaders == null ? void 0 : requestHeaders["anthropic-beta"]) != null ? _b : "";
     return new Set(
       [
@@ -3305,13 +3636,13 @@ var AnthropicMessagesLanguageModel = class {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils15.postJsonToApi)({
+    } = await postJsonToApi({
       url: this.buildRequestUrl(false),
       headers: await this.getHeaders({ betas, headers: options.headers }),
       body: this.transformRequestBody(args, betas),
       failedResponseHandler: anthropicFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils15.createJsonResponseHandler)(
-        anthropicMessagesResponseSchema
+      successfulResponseHandler: createJsonResponseHandler(
+        anthropicResponseSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
@@ -3660,7 +3991,7 @@ var AnthropicMessagesLanguageModel = class {
         }),
         raw: (_e = response.stop_reason) != null ? _e : void 0
       },
-      usage: convertAnthropicMessagesUsage({ usage: response.usage }),
+      usage: convertAnthropicUsage({ usage: response.usage }),
       request: { body: args },
       response: {
         id: (_f = response.id) != null ? _f : void 0,
@@ -3670,11 +4001,10 @@ var AnthropicMessagesLanguageModel = class {
       },
       warnings,
       providerMetadata: (() => {
-        var _a2, _b2, _c2, _d2, _e2;
+        var _a2, _b2, _c2, _d2;
         const anthropicMetadata = {
           usage: response.usage,
-          cacheCreationInputTokens: (_a2 = response.usage.cache_creation_input_tokens) != null ? _a2 : null,
-          stopSequence: (_b2 = response.stop_sequence) != null ? _b2 : null,
+          stopSequence: (_a2 = response.stop_sequence) != null ? _a2 : null,
           iterations: response.usage.iterations ? response.usage.iterations.map((iter) => ({
             type: iter.type,
             inputTokens: iter.input_tokens,
@@ -3683,15 +4013,15 @@ var AnthropicMessagesLanguageModel = class {
           container: response.container ? {
             expiresAt: response.container.expires_at,
             id: response.container.id,
-            skills: (_d2 = (_c2 = response.container.skills) == null ? void 0 : _c2.map((skill) => ({
+            skills: (_c2 = (_b2 = response.container.skills) == null ? void 0 : _b2.map((skill) => ({
               type: skill.type,
               skillId: skill.skill_id,
               version: skill.version
-            }))) != null ? _d2 : null
+            }))) != null ? _c2 : null
           } : null,
-          contextManagement: (_e2 = mapAnthropicResponseContextManagement(
+          contextManagement: (_d2 = mapAnthropicResponseContextManagement(
             response.context_management
-          )) != null ? _e2 : null
+          )) != null ? _d2 : null
         };
         const providerMetadata = {
           anthropic: anthropicMetadata
@@ -3704,6 +4034,7 @@ var AnthropicMessagesLanguageModel = class {
     };
   }
   async doStream(options) {
+    "use step";
     var _a, _b;
     const {
       args: body,
@@ -3725,14 +4056,12 @@ var AnthropicMessagesLanguageModel = class {
       body.tools
     );
     const url = this.buildRequestUrl(true);
-    const { responseHeaders, value: response } = await (0, import_provider_utils15.postJsonToApi)({
+    const { responseHeaders, value: response } = await postJsonToApi({
       url,
       headers: await this.getHeaders({ betas, headers: options.headers }),
       body: this.transformRequestBody(body, betas),
       failedResponseHandler: anthropicFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils15.createEventSourceResponseHandler)(
-        anthropicMessagesChunkSchema
-      ),
+      successfulResponseHandler: createEventSourceResponseHandler(anthropicChunkSchema),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
@@ -3752,7 +4081,6 @@ var AnthropicMessagesLanguageModel = class {
     const serverToolCalls = {};
     let contextManagement = null;
     let rawUsage = void 0;
-    let cacheCreationInputTokens = null;
     let stopSequence = null;
     let container = null;
     let isJsonResponseFromTool = false;
@@ -3764,7 +4092,7 @@ var AnthropicMessagesLanguageModel = class {
           controller.enqueue({ type: "stream-start", warnings });
         },
         transform(chunk, controller) {
-          var _a2, _b2, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+          var _a2, _b2, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
           if (options.includeRawChunks) {
             controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
           }
@@ -4299,7 +4627,6 @@ var AnthropicMessagesLanguageModel = class {
               rawUsage = {
                 ...value.message.usage
               };
-              cacheCreationInputTokens = (_g = value.message.usage.cache_creation_input_tokens) != null ? _g : null;
               if (value.message.container != null) {
                 container = {
                   expiresAt: value.message.container.expires_at,
@@ -4318,8 +4645,8 @@ var AnthropicMessagesLanguageModel = class {
               }
               controller.enqueue({
                 type: "response-metadata",
-                id: (_h = value.message.id) != null ? _h : void 0,
-                modelId: (_i = value.message.model) != null ? _i : void 0
+                id: (_g = value.message.id) != null ? _g : void 0,
+                modelId: (_h = value.message.model) != null ? _h : void 0
               });
               if (value.message.content != null) {
                 for (let contentIndex = 0; contentIndex < value.message.content.length; contentIndex++) {
@@ -4335,7 +4662,7 @@ var AnthropicMessagesLanguageModel = class {
                       id: part.id,
                       toolName: part.name
                     });
-                    const inputStr = JSON.stringify((_j = part.input) != null ? _j : {});
+                    const inputStr = JSON.stringify((_i = part.input) != null ? _i : {});
                     controller.enqueue({
                       type: "tool-input-delta",
                       id: part.id,
@@ -4373,7 +4700,6 @@ var AnthropicMessagesLanguageModel = class {
               }
               if (value.usage.cache_creation_input_tokens != null) {
                 usage.cache_creation_input_tokens = value.usage.cache_creation_input_tokens;
-                cacheCreationInputTokens = value.usage.cache_creation_input_tokens;
               }
               if (value.usage.iterations != null) {
                 usage.iterations = value.usage.iterations;
@@ -4383,17 +4709,17 @@ var AnthropicMessagesLanguageModel = class {
                   finishReason: value.delta.stop_reason,
                   isJsonResponseFromTool
                 }),
-                raw: (_k = value.delta.stop_reason) != null ? _k : void 0
+                raw: (_j = value.delta.stop_reason) != null ? _j : void 0
               };
-              stopSequence = (_l = value.delta.stop_sequence) != null ? _l : null;
+              stopSequence = (_k = value.delta.stop_sequence) != null ? _k : null;
               container = value.delta.container != null ? {
                 expiresAt: value.delta.container.expires_at,
                 id: value.delta.container.id,
-                skills: (_n = (_m = value.delta.container.skills) == null ? void 0 : _m.map((skill) => ({
+                skills: (_m = (_l = value.delta.container.skills) == null ? void 0 : _l.map((skill) => ({
                   type: skill.type,
                   skillId: skill.skill_id,
                   version: skill.version
-                }))) != null ? _n : null
+                }))) != null ? _m : null
               } : null;
               if (value.context_management) {
                 contextManagement = mapAnthropicResponseContextManagement(
@@ -4409,7 +4735,6 @@ var AnthropicMessagesLanguageModel = class {
             case "message_stop": {
               const anthropicMetadata = {
                 usage: rawUsage != null ? rawUsage : null,
-                cacheCreationInputTokens,
                 stopSequence,
                 iterations: usage.iterations ? usage.iterations.map((iter) => ({
                   type: iter.type,
@@ -4428,7 +4753,7 @@ var AnthropicMessagesLanguageModel = class {
               controller.enqueue({
                 type: "finish",
                 finishReason,
-                usage: convertAnthropicMessagesUsage({ usage, rawUsage }),
+                usage: convertAnthropicUsage({ usage, rawUsage }),
                 providerMetadata
               });
               return;
@@ -4455,7 +4780,7 @@ var AnthropicMessagesLanguageModel = class {
       }
       if (((_b = result.value) == null ? void 0 : _b.type) === "error") {
         const error = result.value.error;
-        throw new import_provider3.APICallError({
+        throw new APICallError({
           message: error.message,
           url,
           requestBodyValues: body,
@@ -4478,46 +4803,76 @@ var AnthropicMessagesLanguageModel = class {
   }
 };
 function getModelCapabilities(modelId) {
-  if (modelId.includes("claude-sonnet-4-6") || modelId.includes("claude-opus-4-6")) {
+  if (modelId.includes("claude-opus-4-7")) {
     return {
       maxOutputTokens: 128e3,
       supportsStructuredOutput: true,
+      supportsAdaptiveThinking: true,
+      rejectsSamplingParameters: true,
+      supportsXhighEffort: true,
+      isKnownModel: true
+    };
+  } else if (modelId.includes("claude-sonnet-4-6") || modelId.includes("claude-opus-4-6")) {
+    return {
+      maxOutputTokens: 128e3,
+      supportsStructuredOutput: true,
+      supportsAdaptiveThinking: true,
+      rejectsSamplingParameters: false,
+      supportsXhighEffort: false,
       isKnownModel: true
     };
   } else if (modelId.includes("claude-sonnet-4-5") || modelId.includes("claude-opus-4-5") || modelId.includes("claude-haiku-4-5")) {
     return {
       maxOutputTokens: 64e3,
       supportsStructuredOutput: true,
+      supportsAdaptiveThinking: false,
+      rejectsSamplingParameters: false,
+      supportsXhighEffort: false,
       isKnownModel: true
     };
   } else if (modelId.includes("claude-opus-4-1")) {
     return {
       maxOutputTokens: 32e3,
       supportsStructuredOutput: true,
+      supportsAdaptiveThinking: false,
+      rejectsSamplingParameters: false,
+      supportsXhighEffort: false,
       isKnownModel: true
     };
   } else if (modelId.includes("claude-sonnet-4-")) {
     return {
       maxOutputTokens: 64e3,
       supportsStructuredOutput: false,
+      supportsAdaptiveThinking: false,
+      rejectsSamplingParameters: false,
+      supportsXhighEffort: false,
       isKnownModel: true
     };
   } else if (modelId.includes("claude-opus-4-")) {
     return {
       maxOutputTokens: 32e3,
       supportsStructuredOutput: false,
+      supportsAdaptiveThinking: false,
+      rejectsSamplingParameters: false,
+      supportsXhighEffort: false,
       isKnownModel: true
     };
   } else if (modelId.includes("claude-3-haiku")) {
     return {
       maxOutputTokens: 4096,
       supportsStructuredOutput: false,
+      supportsAdaptiveThinking: false,
+      rejectsSamplingParameters: false,
+      supportsXhighEffort: false,
       isKnownModel: true
     };
   } else {
     return {
       maxOutputTokens: 4096,
       supportsStructuredOutput: false,
+      supportsAdaptiveThinking: false,
+      rejectsSamplingParameters: false,
+      supportsXhighEffort: false,
       isKnownModel: false
     };
   }
@@ -4540,6 +4895,44 @@ function hasWebTool20260209WithoutCodeExecution(tools) {
   }
   return hasWebTool20260209 && !hasCodeExecutionTool;
 }
+function resolveAnthropicReasoningConfig({
+  reasoning,
+  supportsAdaptiveThinking,
+  supportsXhighEffort,
+  maxOutputTokensForModel,
+  warnings
+}) {
+  if (!isCustomReasoning(reasoning)) {
+    return void 0;
+  }
+  if (reasoning === "none") {
+    return { thinking: { type: "disabled" } };
+  }
+  if (supportsAdaptiveThinking) {
+    const effort = mapReasoningToProviderEffort({
+      reasoning,
+      effortMap: {
+        minimal: "low",
+        low: "low",
+        medium: "medium",
+        high: "high",
+        xhigh: supportsXhighEffort ? "xhigh" : "max"
+      },
+      warnings
+    });
+    return { thinking: { type: "adaptive" }, effort };
+  }
+  const budgetTokens = mapReasoningToProviderBudget({
+    reasoning,
+    maxOutputTokens: maxOutputTokensForModel,
+    maxReasoningBudget: maxOutputTokensForModel,
+    warnings
+  });
+  if (budgetTokens == null) {
+    return void 0;
+  }
+  return { thinking: { type: "enabled", budgetTokens } };
+}
 function mapAnthropicResponseContextManagement(contextManagement) {
   return contextManagement ? {
     appliedEdits: contextManagement.applied_edits.map((edit) => {
@@ -4567,44 +4960,56 @@ function mapAnthropicResponseContextManagement(contextManagement) {
 }
 
 // src/tool/bash_20241022.ts
-var import_provider_utils16 = require("@ai-sdk/provider-utils");
-var import_v413 = require("zod/v4");
-var bash_20241022InputSchema = (0, import_provider_utils16.lazySchema)(
-  () => (0, import_provider_utils16.zodSchema)(
-    import_v413.z.object({
-      command: import_v413.z.string(),
-      restart: import_v413.z.boolean().optional()
+import {
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory2,
+  lazySchema as lazySchema12,
+  zodSchema as zodSchema12
+} from "@ai-sdk/provider-utils";
+import { z as z13 } from "zod/v4";
+var bash_20241022InputSchema = lazySchema12(
+  () => zodSchema12(
+    z13.object({
+      command: z13.string(),
+      restart: z13.boolean().optional()
     })
   )
 );
-var bash_20241022 = (0, import_provider_utils16.createProviderToolFactory)({
+var bash_20241022 = createProviderDefinedToolFactory2({
   id: "anthropic.bash_20241022",
   inputSchema: bash_20241022InputSchema
 });
 
 // src/tool/bash_20250124.ts
-var import_provider_utils17 = require("@ai-sdk/provider-utils");
-var import_v414 = require("zod/v4");
-var bash_20250124InputSchema = (0, import_provider_utils17.lazySchema)(
-  () => (0, import_provider_utils17.zodSchema)(
-    import_v414.z.object({
-      command: import_v414.z.string(),
-      restart: import_v414.z.boolean().optional()
+import {
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory3,
+  lazySchema as lazySchema13,
+  zodSchema as zodSchema13
+} from "@ai-sdk/provider-utils";
+import { z as z14 } from "zod/v4";
+var bash_20250124InputSchema = lazySchema13(
+  () => zodSchema13(
+    z14.object({
+      command: z14.string(),
+      restart: z14.boolean().optional()
     })
   )
 );
-var bash_20250124 = (0, import_provider_utils17.createProviderToolFactory)({
+var bash_20250124 = createProviderDefinedToolFactory3({
   id: "anthropic.bash_20250124",
   inputSchema: bash_20250124InputSchema
 });
 
 // src/tool/computer_20241022.ts
-var import_provider_utils18 = require("@ai-sdk/provider-utils");
-var import_v415 = require("zod/v4");
-var computer_20241022InputSchema = (0, import_provider_utils18.lazySchema)(
-  () => (0, import_provider_utils18.zodSchema)(
-    import_v415.z.object({
-      action: import_v415.z.enum([
+import {
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory4,
+  lazySchema as lazySchema14,
+  zodSchema as zodSchema14
+} from "@ai-sdk/provider-utils";
+import { z as z15 } from "zod/v4";
+var computer_20241022InputSchema = lazySchema14(
+  () => zodSchema14(
+    z15.object({
+      action: z15.enum([
         "key",
         "type",
         "mouse_move",
@@ -4616,23 +5021,27 @@ var computer_20241022InputSchema = (0, import_provider_utils18.lazySchema)(
         "screenshot",
         "cursor_position"
       ]),
-      coordinate: import_v415.z.array(import_v415.z.number().int()).optional(),
-      text: import_v415.z.string().optional()
+      coordinate: z15.array(z15.number().int()).optional(),
+      text: z15.string().optional()
     })
   )
 );
-var computer_20241022 = (0, import_provider_utils18.createProviderToolFactory)({
+var computer_20241022 = createProviderDefinedToolFactory4({
   id: "anthropic.computer_20241022",
   inputSchema: computer_20241022InputSchema
 });
 
 // src/tool/computer_20250124.ts
-var import_provider_utils19 = require("@ai-sdk/provider-utils");
-var import_v416 = require("zod/v4");
-var computer_20250124InputSchema = (0, import_provider_utils19.lazySchema)(
-  () => (0, import_provider_utils19.zodSchema)(
-    import_v416.z.object({
-      action: import_v416.z.enum([
+import {
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory5,
+  lazySchema as lazySchema15,
+  zodSchema as zodSchema15
+} from "@ai-sdk/provider-utils";
+import { z as z16 } from "zod/v4";
+var computer_20250124InputSchema = lazySchema15(
+  () => zodSchema15(
+    z16.object({
+      action: z16.enum([
         "key",
         "hold_key",
         "type",
@@ -4650,27 +5059,31 @@ var computer_20250124InputSchema = (0, import_provider_utils19.lazySchema)(
         "wait",
         "screenshot"
       ]),
-      coordinate: import_v416.z.tuple([import_v416.z.number().int(), import_v416.z.number().int()]).optional(),
-      duration: import_v416.z.number().optional(),
-      scroll_amount: import_v416.z.number().optional(),
-      scroll_direction: import_v416.z.enum(["up", "down", "left", "right"]).optional(),
-      start_coordinate: import_v416.z.tuple([import_v416.z.number().int(), import_v416.z.number().int()]).optional(),
-      text: import_v416.z.string().optional()
+      coordinate: z16.tuple([z16.number().int(), z16.number().int()]).optional(),
+      duration: z16.number().optional(),
+      scroll_amount: z16.number().optional(),
+      scroll_direction: z16.enum(["up", "down", "left", "right"]).optional(),
+      start_coordinate: z16.tuple([z16.number().int(), z16.number().int()]).optional(),
+      text: z16.string().optional()
     })
   )
 );
-var computer_20250124 = (0, import_provider_utils19.createProviderToolFactory)({
+var computer_20250124 = createProviderDefinedToolFactory5({
   id: "anthropic.computer_20250124",
   inputSchema: computer_20250124InputSchema
 });
 
 // src/tool/computer_20251124.ts
-var import_provider_utils20 = require("@ai-sdk/provider-utils");
-var import_v417 = require("zod/v4");
-var computer_20251124InputSchema = (0, import_provider_utils20.lazySchema)(
-  () => (0, import_provider_utils20.zodSchema)(
-    import_v417.z.object({
-      action: import_v417.z.enum([
+import {
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory6,
+  lazySchema as lazySchema16,
+  zodSchema as zodSchema16
+} from "@ai-sdk/provider-utils";
+import { z as z17 } from "zod/v4";
+var computer_20251124InputSchema = lazySchema16(
+  () => zodSchema16(
+    z17.object({
+      action: z17.enum([
         "key",
         "hold_key",
         "type",
@@ -4689,166 +5102,186 @@ var computer_20251124InputSchema = (0, import_provider_utils20.lazySchema)(
         "screenshot",
         "zoom"
       ]),
-      coordinate: import_v417.z.tuple([import_v417.z.number().int(), import_v417.z.number().int()]).optional(),
-      duration: import_v417.z.number().optional(),
-      region: import_v417.z.tuple([
-        import_v417.z.number().int(),
-        import_v417.z.number().int(),
-        import_v417.z.number().int(),
-        import_v417.z.number().int()
+      coordinate: z17.tuple([z17.number().int(), z17.number().int()]).optional(),
+      duration: z17.number().optional(),
+      region: z17.tuple([
+        z17.number().int(),
+        z17.number().int(),
+        z17.number().int(),
+        z17.number().int()
       ]).optional(),
-      scroll_amount: import_v417.z.number().optional(),
-      scroll_direction: import_v417.z.enum(["up", "down", "left", "right"]).optional(),
-      start_coordinate: import_v417.z.tuple([import_v417.z.number().int(), import_v417.z.number().int()]).optional(),
-      text: import_v417.z.string().optional()
+      scroll_amount: z17.number().optional(),
+      scroll_direction: z17.enum(["up", "down", "left", "right"]).optional(),
+      start_coordinate: z17.tuple([z17.number().int(), z17.number().int()]).optional(),
+      text: z17.string().optional()
     })
   )
 );
-var computer_20251124 = (0, import_provider_utils20.createProviderToolFactory)({
+var computer_20251124 = createProviderDefinedToolFactory6({
   id: "anthropic.computer_20251124",
   inputSchema: computer_20251124InputSchema
 });
 
 // src/tool/memory_20250818.ts
-var import_provider_utils21 = require("@ai-sdk/provider-utils");
-var import_v418 = require("zod/v4");
-var memory_20250818InputSchema = (0, import_provider_utils21.lazySchema)(
-  () => (0, import_provider_utils21.zodSchema)(
-    import_v418.z.discriminatedUnion("command", [
-      import_v418.z.object({
-        command: import_v418.z.literal("view"),
-        path: import_v418.z.string(),
-        view_range: import_v418.z.tuple([import_v418.z.number(), import_v418.z.number()]).optional()
+import {
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory7,
+  lazySchema as lazySchema17,
+  zodSchema as zodSchema17
+} from "@ai-sdk/provider-utils";
+import { z as z18 } from "zod/v4";
+var memory_20250818InputSchema = lazySchema17(
+  () => zodSchema17(
+    z18.discriminatedUnion("command", [
+      z18.object({
+        command: z18.literal("view"),
+        path: z18.string(),
+        view_range: z18.tuple([z18.number(), z18.number()]).optional()
       }),
-      import_v418.z.object({
-        command: import_v418.z.literal("create"),
-        path: import_v418.z.string(),
-        file_text: import_v418.z.string()
+      z18.object({
+        command: z18.literal("create"),
+        path: z18.string(),
+        file_text: z18.string()
       }),
-      import_v418.z.object({
-        command: import_v418.z.literal("str_replace"),
-        path: import_v418.z.string(),
-        old_str: import_v418.z.string(),
-        new_str: import_v418.z.string()
+      z18.object({
+        command: z18.literal("str_replace"),
+        path: z18.string(),
+        old_str: z18.string(),
+        new_str: z18.string()
       }),
-      import_v418.z.object({
-        command: import_v418.z.literal("insert"),
-        path: import_v418.z.string(),
-        insert_line: import_v418.z.number(),
-        insert_text: import_v418.z.string()
+      z18.object({
+        command: z18.literal("insert"),
+        path: z18.string(),
+        insert_line: z18.number(),
+        insert_text: z18.string()
       }),
-      import_v418.z.object({
-        command: import_v418.z.literal("delete"),
-        path: import_v418.z.string()
+      z18.object({
+        command: z18.literal("delete"),
+        path: z18.string()
       }),
-      import_v418.z.object({
-        command: import_v418.z.literal("rename"),
-        old_path: import_v418.z.string(),
-        new_path: import_v418.z.string()
+      z18.object({
+        command: z18.literal("rename"),
+        old_path: z18.string(),
+        new_path: z18.string()
       })
     ])
   )
 );
-var memory_20250818 = (0, import_provider_utils21.createProviderToolFactory)({
+var memory_20250818 = createProviderDefinedToolFactory7({
   id: "anthropic.memory_20250818",
   inputSchema: memory_20250818InputSchema
 });
 
 // src/tool/text-editor_20241022.ts
-var import_provider_utils22 = require("@ai-sdk/provider-utils");
-var import_v419 = require("zod/v4");
-var textEditor_20241022InputSchema = (0, import_provider_utils22.lazySchema)(
-  () => (0, import_provider_utils22.zodSchema)(
-    import_v419.z.object({
-      command: import_v419.z.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
-      path: import_v419.z.string(),
-      file_text: import_v419.z.string().optional(),
-      insert_line: import_v419.z.number().int().optional(),
-      new_str: import_v419.z.string().optional(),
-      insert_text: import_v419.z.string().optional(),
-      old_str: import_v419.z.string().optional(),
-      view_range: import_v419.z.array(import_v419.z.number().int()).optional()
+import {
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory8,
+  lazySchema as lazySchema18,
+  zodSchema as zodSchema18
+} from "@ai-sdk/provider-utils";
+import { z as z19 } from "zod/v4";
+var textEditor_20241022InputSchema = lazySchema18(
+  () => zodSchema18(
+    z19.object({
+      command: z19.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
+      path: z19.string(),
+      file_text: z19.string().optional(),
+      insert_line: z19.number().int().optional(),
+      new_str: z19.string().optional(),
+      insert_text: z19.string().optional(),
+      old_str: z19.string().optional(),
+      view_range: z19.array(z19.number().int()).optional()
     })
   )
 );
-var textEditor_20241022 = (0, import_provider_utils22.createProviderToolFactory)({
+var textEditor_20241022 = createProviderDefinedToolFactory8({
   id: "anthropic.text_editor_20241022",
   inputSchema: textEditor_20241022InputSchema
 });
 
 // src/tool/text-editor_20250124.ts
-var import_provider_utils23 = require("@ai-sdk/provider-utils");
-var import_v420 = require("zod/v4");
-var textEditor_20250124InputSchema = (0, import_provider_utils23.lazySchema)(
-  () => (0, import_provider_utils23.zodSchema)(
-    import_v420.z.object({
-      command: import_v420.z.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
-      path: import_v420.z.string(),
-      file_text: import_v420.z.string().optional(),
-      insert_line: import_v420.z.number().int().optional(),
-      new_str: import_v420.z.string().optional(),
-      insert_text: import_v420.z.string().optional(),
-      old_str: import_v420.z.string().optional(),
-      view_range: import_v420.z.array(import_v420.z.number().int()).optional()
+import {
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory9,
+  lazySchema as lazySchema19,
+  zodSchema as zodSchema19
+} from "@ai-sdk/provider-utils";
+import { z as z20 } from "zod/v4";
+var textEditor_20250124InputSchema = lazySchema19(
+  () => zodSchema19(
+    z20.object({
+      command: z20.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
+      path: z20.string(),
+      file_text: z20.string().optional(),
+      insert_line: z20.number().int().optional(),
+      new_str: z20.string().optional(),
+      insert_text: z20.string().optional(),
+      old_str: z20.string().optional(),
+      view_range: z20.array(z20.number().int()).optional()
     })
   )
 );
-var textEditor_20250124 = (0, import_provider_utils23.createProviderToolFactory)({
+var textEditor_20250124 = createProviderDefinedToolFactory9({
   id: "anthropic.text_editor_20250124",
   inputSchema: textEditor_20250124InputSchema
 });
 
 // src/tool/text-editor_20250429.ts
-var import_provider_utils24 = require("@ai-sdk/provider-utils");
-var import_v421 = require("zod/v4");
-var textEditor_20250429InputSchema = (0, import_provider_utils24.lazySchema)(
-  () => (0, import_provider_utils24.zodSchema)(
-    import_v421.z.object({
-      command: import_v421.z.enum(["view", "create", "str_replace", "insert"]),
-      path: import_v421.z.string(),
-      file_text: import_v421.z.string().optional(),
-      insert_line: import_v421.z.number().int().optional(),
-      new_str: import_v421.z.string().optional(),
-      insert_text: import_v421.z.string().optional(),
-      old_str: import_v421.z.string().optional(),
-      view_range: import_v421.z.array(import_v421.z.number().int()).optional()
+import {
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory10,
+  lazySchema as lazySchema20,
+  zodSchema as zodSchema20
+} from "@ai-sdk/provider-utils";
+import { z as z21 } from "zod/v4";
+var textEditor_20250429InputSchema = lazySchema20(
+  () => zodSchema20(
+    z21.object({
+      command: z21.enum(["view", "create", "str_replace", "insert"]),
+      path: z21.string(),
+      file_text: z21.string().optional(),
+      insert_line: z21.number().int().optional(),
+      new_str: z21.string().optional(),
+      insert_text: z21.string().optional(),
+      old_str: z21.string().optional(),
+      view_range: z21.array(z21.number().int()).optional()
     })
   )
 );
-var textEditor_20250429 = (0, import_provider_utils24.createProviderToolFactory)({
+var textEditor_20250429 = createProviderDefinedToolFactory10({
   id: "anthropic.text_editor_20250429",
   inputSchema: textEditor_20250429InputSchema
 });
 
 // src/tool/tool-search-bm25_20251119.ts
-var import_provider_utils25 = require("@ai-sdk/provider-utils");
-var import_v422 = require("zod/v4");
-var toolSearchBm25_20251119OutputSchema = (0, import_provider_utils25.lazySchema)(
-  () => (0, import_provider_utils25.zodSchema)(
-    import_v422.z.array(
-      import_v422.z.object({
-        type: import_v422.z.literal("tool_reference"),
-        toolName: import_v422.z.string()
+import {
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory9,
+  lazySchema as lazySchema21,
+  zodSchema as zodSchema21
+} from "@ai-sdk/provider-utils";
+import { z as z22 } from "zod/v4";
+var toolSearchBm25_20251119OutputSchema = lazySchema21(
+  () => zodSchema21(
+    z22.array(
+      z22.object({
+        type: z22.literal("tool_reference"),
+        toolName: z22.string()
       })
     )
   )
 );
-var toolSearchBm25_20251119InputSchema = (0, import_provider_utils25.lazySchema)(
-  () => (0, import_provider_utils25.zodSchema)(
-    import_v422.z.object({
+var toolSearchBm25_20251119InputSchema = lazySchema21(
+  () => zodSchema21(
+    z22.object({
       /**
        * A natural language query to search for tools.
        * Claude will use BM25 text search to find relevant tools.
        */
-      query: import_v422.z.string(),
+      query: z22.string(),
       /**
        * Maximum number of tools to return. Optional.
        */
-      limit: import_v422.z.number().optional()
+      limit: z22.number().optional()
     })
   )
 );
-var factory10 = (0, import_provider_utils25.createProviderToolFactoryWithOutputSchema)({
+var factory10 = createProviderExecutedToolFactory9({
   id: "anthropic.tool_search_bm25_20251119",
   inputSchema: toolSearchBm25_20251119InputSchema,
   outputSchema: toolSearchBm25_20251119OutputSchema,
@@ -5059,10 +5492,11 @@ var anthropicTools = {
    */
   toolSearchBm25_20251119
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AnthropicMessagesLanguageModel,
+export {
+  AnthropicLanguageModel,
+  AnthropicLanguageModel as AnthropicMessagesLanguageModel,
   anthropicTools,
+  getModelCapabilities,
   prepareTools
-});
+};
 //# sourceMappingURL=index.js.map