maka-agent 0.2.0-dev.62.20260928 → 0.2.0-dev.64.20260929

package/node_modules/@ai-sdk/anthropic/dist/index.js

@@ -1,6 +1,6 @@
 // src/anthropic-provider.ts
 import {
-  InvalidArgumentError as InvalidArgumentError2,
+  InvalidArgumentError as InvalidArgumentError3,
   NoSuchModelError
 } from "@ai-sdk/provider";
 import {
@@ -11,6 +11,7 @@ import {
   withoutTrailingSlash,
   withUserAgentSuffix
 } from "@ai-sdk/provider-utils";
+import { Experimental_EvaluationLanguageModel as EvaluationLanguageModel } from "@ai-sdk/provider-utils/experimental-evaluation";
 
 // src/anthropic-files.ts
 import {
@@ -75,7 +76,6 @@ var AnthropicFiles = class {
     abortSignal,
     headers
   }) {
-    var _a, _b;
     const fileBytes = convertInlineFileDataToUint8Array(data);
     const blob = new Blob([fileBytes], { type: mediaType });
     const formData = new FormData();
@@ -102,8 +102,8 @@ var AnthropicFiles = class {
     return {
       warnings: [],
       providerReference: { anthropic: response.id },
-      mediaType: (_a = response.mime_type) != null ? _a : mediaType,
-      filename: (_b = response.filename) != null ? _b : filename,
+      mediaType: response.mime_type ?? mediaType,
+      filename: response.filename ?? filename,
       providerMetadata: {
         anthropic: {
           filename: response.filename,
@@ -120,6 +120,7 @@ var AnthropicFiles = class {
 // src/anthropic-language-model.ts
 import {
   APICallError,
+  InvalidArgumentError,
   InvalidResponseDataError
 } from "@ai-sdk/provider";
 import {
@@ -155,6 +156,20 @@ var anthropicStopDetailsSchema = z3.object({
   explanation: z3.string().nullish(),
   recommended_model: z3.string().nullish()
 });
+var anthropicSafeguardResultSchema = z3.object({
+  type: z3.string(),
+  status: z3.object({
+    type: z3.string(),
+    tool_uses: z3.record(
+      z3.string(),
+      z3.object({
+        type: z3.string(),
+        outcome: z3.string().nullish(),
+        explanation: z3.string().nullish()
+      })
+    ).nullish()
+  })
+});
 var anthropicToolCallCallerSchema = z3.union([
   z3.object({
     type: z3.literal("code_execution_20250825"),
@@ -257,7 +272,8 @@ var anthropicResponseSchema = lazySchema3(
           }),
           z3.object({
             type: z3.literal("compaction"),
-            content: z3.string()
+            content: z3.string().nullish(),
+            signature: z3.string().nullish()
           }),
           z3.object({
             type: z3.literal("tool_use"),
@@ -265,7 +281,9 @@ var anthropicResponseSchema = lazySchema3(
             name: z3.string(),
             input: z3.unknown(),
             // Programmatic tool calling: caller info when triggered from code execution
-            caller: anthropicToolCallCallerSchema.optional()
+            caller: anthropicToolCallCallerSchema.optional(),
+            // Toolsets (e.g. computer toolset): name of the toolset this member call belongs to
+            toolset_name: z3.string().nullish()
           }),
           z3.object({
             type: z3.literal("server_tool_use"),
@@ -488,6 +506,7 @@ var anthropicResponseSchema = lazySchema3(
       stop_sequence: z3.string().nullish(),
       stop_details: anthropicStopDetailsSchema.nullish(),
       input_transformations: z3.array(anthropicInputTransformationSchema).nullish(),
+      safeguard_results: z3.array(anthropicSafeguardResultSchema).nullish(),
       usage: z3.looseObject({
         input_tokens: z3.number(),
         output_tokens: z3.number(),
@@ -567,7 +586,8 @@ var anthropicChunkSchema = lazySchema3(
                 id: z3.string(),
                 name: z3.string(),
                 input: z3.unknown(),
-                caller: anthropicToolCallCallerSchema.optional()
+                caller: anthropicToolCallCallerSchema.optional(),
+                toolset_name: z3.string().nullish()
               })
             ])
           ).nullish(),
@@ -598,7 +618,9 @@ var anthropicChunkSchema = lazySchema3(
             // Programmatic tool calling: input may be present directly for deferred tool calls
             input: z3.record(z3.string(), z3.unknown()).optional(),
             // Programmatic tool calling: caller info when triggered from code execution
-            caller: anthropicToolCallCallerSchema.optional()
+            caller: anthropicToolCallCallerSchema.optional(),
+            // Toolsets (e.g. computer toolset): name of the toolset this member call belongs to
+            toolset_name: z3.string().nullish()
           }),
           z3.object({
             type: z3.literal("redacted_thinking"),
@@ -606,7 +628,8 @@ var anthropicChunkSchema = lazySchema3(
           }),
           z3.object({
             type: z3.literal("compaction"),
-            content: z3.string().nullish()
+            content: z3.string().nullish(),
+            signature: z3.string().nullish()
           }),
           z3.object({
             type: z3.literal("server_tool_use"),
@@ -871,6 +894,7 @@ var anthropicChunkSchema = lazySchema3(
           stop_reason: z3.string().nullish(),
           stop_sequence: z3.string().nullish(),
           stop_details: anthropicStopDetailsSchema.nullish(),
+          safeguard_results: z3.array(anthropicSafeguardResultSchema).nullish(),
           container: z3.object({
             expires_at: z3.string(),
             id: z3.string(),
@@ -989,9 +1013,10 @@ var anthropicSystemMessageProviderOptions = z4.object({
    */
   clearAt: z4.literal("next_user_message").optional(),
   /**
-   * Sets the model effort for the turn that follows this mid-conversation
-   * system message. The required `mid-conversation-effort-2026-08-01` beta
-   * is added automatically.
+   * Sets the model effort from the next user turn until a later message
+   * changes it. An effort-only system message with empty content can appear
+   * first. The required `mid-conversation-output-config-2026-07-01` beta is
+   * added automatically.
    */
   effort: z4.enum(["low", "medium", "high", "xhigh", "max"]).optional(),
   /**
@@ -1041,6 +1066,14 @@ var anthropicLanguageModelOptions = z4.object({
    *
    * 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.
+   *
+   * Models that always use adaptive thinking (e.g. `claude-opus-5-5`,
+   * `claude-fable-5-1`) reject `enabled` and `disabled`. For those models the
+   * provider drops the unsupported setting, emits a warning, and sends an
+   * adaptive thinking request. Use `effort` to control how much they think.
+   *
+   * `claude-sonnet-5-5` supports `between_tools`, its lowest thinking setting,
+   * and the provider uses it in place of `disabled` for that model.
    */
   thinking: z4.union([
     z4.discriminatedUnion("type", [
@@ -1069,6 +1102,14 @@ var anthropicLanguageModelOptions = z4.object({
       }),
       z4.object({
         type: z4.literal("disabled")
+      }),
+      z4.object({
+        /**
+         * for `claude-sonnet-5-5`: no upfront thinking, but progress notes
+         * between tool calls are returned as summarized thinking blocks.
+         * Only supported at `low`, `medium`, and `high` effort.
+         */
+        type: z4.literal("between_tools")
       })
     ]),
     z4.object({
@@ -1153,7 +1194,11 @@ var anthropicLanguageModelOptions = z4.object({
    */
   toolStreaming: z4.boolean().optional(),
   /**
-   * @default 'high'
+   * Controls how much effort the model spends on thinking, text responses,
+   * and tool calls. On models that always use adaptive thinking
+   * (e.g. `claude-opus-5-5`), effort is the main lever for latency and cost.
+   *
+   * The API default is `high` for most models and `medium` for `claude-opus-5-5`.
    */
   effort: z4.enum(["low", "medium", "high", "xhigh", "max"]).optional(),
   /**
@@ -1219,6 +1264,32 @@ var anthropicLanguageModelOptions = z4.object({
    * Allow a provider to receive the full `betas` set if it needs it.
    */
   anthropicBeta: z4.array(z4.string()).optional(),
+  /**
+   * Server-side safeguards to run as part of the request.
+   *
+   * `dangerous_tool_use` asks the API to classify every `tool_use` block in
+   * the response for dangerous actions (the check Claude Code's auto mode
+   * relies on). The per-call verdicts are returned in
+   * `providerMetadata.anthropic.safeguardResults`, keyed by tool call id.
+   * `classifierContext` is passed through to the API as `classifier_context`.
+   * The `dangerous-tool-use-2026-09-03` beta is added automatically.
+   */
+  safeguards: z4.array(
+    z4.object({
+      type: z4.literal("dangerous_tool_use"),
+      classifierContext: z4.record(z4.string(), z4.unknown()).optional()
+    })
+  ).optional(),
+  /**
+   * Requests an on-demand summary of the supplied conversation.
+   *
+   * The required `compact-2026-09-04` beta is added automatically.
+   * Cannot be combined with `contextManagement`.
+   */
+  compaction: z4.object({
+    type: z4.literal("summarize"),
+    instructions: z4.string().optional()
+  }).optional(),
   contextManagement: z4.object({
     edits: z4.array(
       z4.discriminatedUnion("type", [
@@ -1277,9 +1348,8 @@ import {
 // src/get-cache-control.ts
 var MAX_CACHE_BREAKPOINTS = 4;
 function getCacheControl(providerMetadata) {
-  var _a;
-  const anthropic2 = providerMetadata == null ? void 0 : providerMetadata.anthropic;
-  const cacheControlValue = (_a = anthropic2 == null ? void 0 : anthropic2.cacheControl) != null ? _a : anthropic2 == null ? void 0 : anthropic2.cache_control;
+  const anthropic2 = providerMetadata?.anthropic;
+  const cacheControlValue = anthropic2?.cacheControl ?? anthropic2?.cache_control;
   return cacheControlValue;
 }
 var CacheControlValidator = class {
@@ -1369,103 +1439,114 @@ var advisor_20260301 = (args) => {
   return factory(args);
 };
 
-// src/tool/text-editor_20250728.ts
+// src/tool/computer-toolset_20260801.ts
 import {
   createProviderDefinedToolFactory,
   lazySchema as lazySchema5,
   zodSchema as zodSchema5
 } from "@ai-sdk/provider-utils";
 import { z as z6 } from "zod/v4";
-var textEditor_20250728ArgsSchema = lazySchema5(
+var computerToolset_20260801Members = [
+  "screenshot",
+  "zoom",
+  "left_click",
+  "right_click",
+  "middle_click",
+  "double_click",
+  "triple_click",
+  "left_click_drag",
+  "mouse_move",
+  "left_mouse_down",
+  "left_mouse_up",
+  "cursor_position",
+  "scroll",
+  "type",
+  "key",
+  "hold_key",
+  "wait"
+];
+var computerToolset_20260801InputSchema = lazySchema5(
   () => zodSchema5(
     z6.object({
-      maxCharacters: z6.number().optional()
+      action: z6.enum(computerToolset_20260801Members),
+      coordinate: z6.tuple([z6.number().int(), z6.number().int()]).optional(),
+      duration: z6.number().optional(),
+      region: z6.tuple([
+        z6.number().int(),
+        z6.number().int(),
+        z6.number().int(),
+        z6.number().int()
+      ]).optional(),
+      repeat: z6.number().int().optional(),
+      scroll_amount: z6.number().optional(),
+      scroll_direction: z6.enum(["up", "down", "left", "right"]).optional(),
+      start_coordinate: z6.tuple([z6.number().int(), z6.number().int()]).optional(),
+      text: z6.string().optional()
     })
   )
 );
-var textEditor_20250728InputSchema = lazySchema5(
+var computerToolset_20260801ArgsSchema = lazySchema5(
   () => zodSchema5(
     z6.object({
-      command: z6.enum(["view", "create", "str_replace", "insert"]),
-      path: z6.string(),
-      file_text: z6.string().optional(),
-      insert_line: z6.number().int().optional(),
-      new_str: z6.string().optional(),
-      insert_text: z6.string().optional(),
-      old_str: z6.string().optional(),
-      view_range: z6.array(z6.number().int()).optional()
+      configs: z6.partialRecord(
+        z6.enum(computerToolset_20260801Members),
+        z6.object({
+          enabled: z6.boolean().optional(),
+          deferLoading: z6.boolean().optional()
+        })
+      ).optional()
     })
   )
 );
-var factory2 = createProviderDefinedToolFactory({
-  id: "anthropic.text_editor_20250728",
-  inputSchema: textEditor_20250728InputSchema
+var computerToolset_20260801 = createProviderDefinedToolFactory({
+  id: "anthropic.computer_toolset_20260801",
+  inputSchema: computerToolset_20260801InputSchema
 });
-var textEditor_20250728 = (args = {}) => {
-  return factory2(args);
-};
 
-// src/tool/web-search_20260209.ts
+// src/tool/text-editor_20250728.ts
 import {
-  createProviderExecutedToolFactory as createProviderExecutedToolFactory2,
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory2,
   lazySchema as lazySchema6,
   zodSchema as zodSchema6
 } from "@ai-sdk/provider-utils";
 import { z as z7 } from "zod/v4";
-var webSearch_20260209ArgsSchema = lazySchema6(
+var textEditor_20250728ArgsSchema = lazySchema6(
   () => zodSchema6(
     z7.object({
-      maxUses: z7.number().optional(),
-      allowedDomains: z7.array(z7.string()).optional(),
-      blockedDomains: z7.array(z7.string()).optional(),
-      userLocation: z7.object({
-        type: z7.literal("approximate"),
-        city: z7.string().optional(),
-        region: z7.string().optional(),
-        country: z7.string().optional(),
-        timezone: z7.string().optional()
-      }).optional()
+      maxCharacters: z7.number().optional()
     })
   )
 );
-var webSearch_20260209OutputSchema = lazySchema6(
-  () => zodSchema6(
-    z7.array(
-      z7.object({
-        url: z7.string(),
-        title: z7.string().nullable(),
-        pageAge: z7.string().nullable(),
-        encryptedContent: z7.string(),
-        type: z7.literal("web_search_result")
-      })
-    )
-  )
-);
-var webSearch_20260209InputSchema = lazySchema6(
+var textEditor_20250728InputSchema = lazySchema6(
   () => zodSchema6(
     z7.object({
-      query: z7.string()
+      command: z7.enum(["view", "create", "str_replace", "insert"]),
+      path: z7.string(),
+      file_text: z7.string().optional(),
+      insert_line: z7.number().int().optional(),
+      new_str: z7.string().optional(),
+      insert_text: z7.string().optional(),
+      old_str: z7.string().optional(),
+      view_range: z7.array(z7.number().int()).optional()
     })
   )
 );
-var factory3 = createProviderExecutedToolFactory2({
-  id: "anthropic.web_search_20260209",
-  inputSchema: webSearch_20260209InputSchema,
-  outputSchema: webSearch_20260209OutputSchema,
-  supportsDeferredResults: true
+var factory2 = createProviderDefinedToolFactory2({
+  id: "anthropic.text_editor_20250728",
+  inputSchema: textEditor_20250728InputSchema
 });
-var webSearch_20260209 = (args = {}) => {
-  return factory3(args);
+var textEditor_20250728 = (args = {}) => {
+  return factory2(args);
 };
 
-// src/tool/web-search_20250305.ts
+// src/tool/web-search_20260318.ts
 import {
-  createProviderExecutedToolFactory as createProviderExecutedToolFactory3,
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory2,
   lazySchema as lazySchema7,
   zodSchema as zodSchema7
 } from "@ai-sdk/provider-utils";
 import { z as z8 } from "zod/v4";
-var webSearch_20250305ArgsSchema = lazySchema7(
+var webSearch_20260318ArgsSchema = lazySchema7(
   () => zodSchema7(
     z8.object({
       maxUses: z8.number().optional(),
@@ -1477,11 +1558,12 @@ var webSearch_20250305ArgsSchema = lazySchema7(
         region: z8.string().optional(),
         country: z8.string().optional(),
         timezone: z8.string().optional()
-      }).optional()
+      }).optional(),
+      responseInclusion: z8.enum(["full", "excluded"]).optional()
     })
   )
 );
-var webSearch_20250305OutputSchema = lazySchema7(
+var webSearch_20260318OutputSchema = lazySchema7(
   () => zodSchema7(
     z8.array(
       z8.object({
@@ -1494,143 +1576,312 @@ var webSearch_20250305OutputSchema = lazySchema7(
     )
   )
 );
-var webSearch_20250305InputSchema = lazySchema7(
+var webSearch_20260318InputSchema = lazySchema7(
   () => zodSchema7(
     z8.object({
       query: z8.string()
     })
   )
 );
-var factory4 = createProviderExecutedToolFactory3({
-  id: "anthropic.web_search_20250305",
-  inputSchema: webSearch_20250305InputSchema,
-  outputSchema: webSearch_20250305OutputSchema,
+var factory3 = createProviderExecutedToolFactory2({
+  id: "anthropic.web_search_20260318",
+  inputSchema: webSearch_20260318InputSchema,
+  outputSchema: webSearch_20260318OutputSchema,
   supportsDeferredResults: true
 });
-var webSearch_20250305 = (args = {}) => {
-  return factory4(args);
+var webSearch_20260318 = (args = {}) => {
+  return factory3(args);
 };
 
-// src/tool/web-fetch-20260209.ts
+// src/tool/web-search_20260209.ts
 import {
-  createProviderExecutedToolFactory as createProviderExecutedToolFactory4,
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory3,
   lazySchema as lazySchema8,
   zodSchema as zodSchema8
 } from "@ai-sdk/provider-utils";
 import { z as z9 } from "zod/v4";
-var webFetch_20260209ArgsSchema = lazySchema8(
+var webSearch_20260209ArgsSchema = lazySchema8(
   () => zodSchema8(
     z9.object({
       maxUses: z9.number().optional(),
       allowedDomains: z9.array(z9.string()).optional(),
       blockedDomains: z9.array(z9.string()).optional(),
-      citations: z9.object({ enabled: z9.boolean() }).optional(),
-      maxContentTokens: z9.number().optional()
+      userLocation: z9.object({
+        type: z9.literal("approximate"),
+        city: z9.string().optional(),
+        region: z9.string().optional(),
+        country: z9.string().optional(),
+        timezone: z9.string().optional()
+      }).optional()
     })
   )
 );
-var webFetch_20260209OutputSchema = lazySchema8(
+var webSearch_20260209OutputSchema = lazySchema8(
   () => zodSchema8(
-    z9.object({
-      type: z9.literal("web_fetch_result"),
-      url: z9.string(),
-      content: z9.object({
-        type: z9.literal("document"),
+    z9.array(
+      z9.object({
+        url: z9.string(),
         title: z9.string().nullable(),
-        citations: z9.object({ enabled: z9.boolean() }).optional(),
-        source: z9.union([
-          z9.object({
-            type: z9.literal("base64"),
-            mediaType: z9.literal("application/pdf"),
-            data: z9.string()
-          }),
-          z9.object({
-            type: z9.literal("text"),
-            mediaType: z9.literal("text/plain"),
-            data: z9.string()
-          })
-        ])
-      }),
-      retrievedAt: z9.string().nullable()
-    })
+        pageAge: z9.string().nullable(),
+        encryptedContent: z9.string(),
+        type: z9.literal("web_search_result")
+      })
+    )
   )
 );
-var webFetch_20260209InputSchema = lazySchema8(
+var webSearch_20260209InputSchema = lazySchema8(
   () => zodSchema8(
     z9.object({
-      url: z9.string()
+      query: z9.string()
     })
   )
 );
-var factory5 = createProviderExecutedToolFactory4({
-  id: "anthropic.web_fetch_20260209",
-  inputSchema: webFetch_20260209InputSchema,
-  outputSchema: webFetch_20260209OutputSchema,
+var factory4 = createProviderExecutedToolFactory3({
+  id: "anthropic.web_search_20260209",
+  inputSchema: webSearch_20260209InputSchema,
+  outputSchema: webSearch_20260209OutputSchema,
   supportsDeferredResults: true
 });
-var webFetch_20260209 = (args = {}) => {
-  return factory5(args);
+var webSearch_20260209 = (args = {}) => {
+  return factory4(args);
 };
 
-// src/tool/web-fetch-20250910.ts
+// src/tool/web-search_20250305.ts
 import {
-  createProviderExecutedToolFactory as createProviderExecutedToolFactory5,
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory4,
   lazySchema as lazySchema9,
   zodSchema as zodSchema9
 } from "@ai-sdk/provider-utils";
 import { z as z10 } from "zod/v4";
-var webFetch_20250910ArgsSchema = lazySchema9(
+var webSearch_20250305ArgsSchema = lazySchema9(
   () => zodSchema9(
     z10.object({
       maxUses: z10.number().optional(),
       allowedDomains: z10.array(z10.string()).optional(),
       blockedDomains: z10.array(z10.string()).optional(),
-      citations: z10.object({ enabled: z10.boolean() }).optional(),
-      maxContentTokens: z10.number().optional()
+      userLocation: z10.object({
+        type: z10.literal("approximate"),
+        city: z10.string().optional(),
+        region: z10.string().optional(),
+        country: z10.string().optional(),
+        timezone: z10.string().optional()
+      }).optional()
     })
   )
 );
-var webFetch_20250910OutputSchema = lazySchema9(
+var webSearch_20250305OutputSchema = lazySchema9(
   () => zodSchema9(
-    z10.object({
-      type: z10.literal("web_fetch_result"),
-      url: z10.string(),
-      content: z10.object({
-        type: z10.literal("document"),
+    z10.array(
+      z10.object({
+        url: z10.string(),
         title: z10.string().nullable(),
-        citations: z10.object({ enabled: z10.boolean() }).optional(),
-        source: z10.union([
-          z10.object({
-            type: z10.literal("base64"),
-            mediaType: z10.literal("application/pdf"),
-            data: z10.string()
+        pageAge: z10.string().nullable(),
+        encryptedContent: z10.string(),
+        type: z10.literal("web_search_result")
+      })
+    )
+  )
+);
+var webSearch_20250305InputSchema = lazySchema9(
+  () => zodSchema9(
+    z10.object({
+      query: z10.string()
+    })
+  )
+);
+var factory5 = createProviderExecutedToolFactory4({
+  id: "anthropic.web_search_20250305",
+  inputSchema: webSearch_20250305InputSchema,
+  outputSchema: webSearch_20250305OutputSchema,
+  supportsDeferredResults: true
+});
+var webSearch_20250305 = (args = {}) => {
+  return factory5(args);
+};
+
+// src/tool/web-fetch-20260318.ts
+import {
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory5,
+  lazySchema as lazySchema10,
+  zodSchema as zodSchema10
+} from "@ai-sdk/provider-utils";
+import { z as z11 } from "zod/v4";
+var webFetch_20260318ArgsSchema = lazySchema10(
+  () => zodSchema10(
+    z11.object({
+      maxUses: z11.number().optional(),
+      allowedDomains: z11.array(z11.string()).optional(),
+      blockedDomains: z11.array(z11.string()).optional(),
+      citations: z11.object({ enabled: z11.boolean() }).optional(),
+      maxContentTokens: z11.number().optional(),
+      useCache: z11.boolean().optional(),
+      responseInclusion: z11.enum(["full", "excluded"]).optional()
+    })
+  )
+);
+var webFetch_20260318OutputSchema = lazySchema10(
+  () => zodSchema10(
+    z11.object({
+      type: z11.literal("web_fetch_result"),
+      url: z11.string(),
+      content: z11.object({
+        type: z11.literal("document"),
+        title: z11.string().nullable(),
+        citations: z11.object({ enabled: z11.boolean() }).optional(),
+        source: z11.union([
+          z11.object({
+            type: z11.literal("base64"),
+            mediaType: z11.literal("application/pdf"),
+            data: z11.string()
           }),
-          z10.object({
-            type: z10.literal("text"),
-            mediaType: z10.literal("text/plain"),
-            data: z10.string()
+          z11.object({
+            type: z11.literal("text"),
+            mediaType: z11.literal("text/plain"),
+            data: z11.string()
           })
         ])
       }),
-      retrievedAt: z10.string().nullable()
+      retrievedAt: z11.string().nullable()
     })
   )
 );
-var webFetch_20250910InputSchema = lazySchema9(
-  () => zodSchema9(
-    z10.object({
-      url: z10.string()
+var webFetch_20260318InputSchema = lazySchema10(
+  () => zodSchema10(
+    z11.object({
+      url: z11.string()
     })
   )
 );
 var factory6 = createProviderExecutedToolFactory5({
+  id: "anthropic.web_fetch_20260318",
+  inputSchema: webFetch_20260318InputSchema,
+  outputSchema: webFetch_20260318OutputSchema,
+  supportsDeferredResults: true
+});
+var webFetch_20260318 = (args = {}) => {
+  return factory6(args);
+};
+
+// src/tool/web-fetch-20260209.ts
+import {
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory6,
+  lazySchema as lazySchema11,
+  zodSchema as zodSchema11
+} from "@ai-sdk/provider-utils";
+import { z as z12 } from "zod/v4";
+var webFetch_20260209ArgsSchema = lazySchema11(
+  () => zodSchema11(
+    z12.object({
+      maxUses: z12.number().optional(),
+      allowedDomains: z12.array(z12.string()).optional(),
+      blockedDomains: z12.array(z12.string()).optional(),
+      citations: z12.object({ enabled: z12.boolean() }).optional(),
+      maxContentTokens: z12.number().optional()
+    })
+  )
+);
+var webFetch_20260209OutputSchema = lazySchema11(
+  () => zodSchema11(
+    z12.object({
+      type: z12.literal("web_fetch_result"),
+      url: z12.string(),
+      content: z12.object({
+        type: z12.literal("document"),
+        title: z12.string().nullable(),
+        citations: z12.object({ enabled: z12.boolean() }).optional(),
+        source: z12.union([
+          z12.object({
+            type: z12.literal("base64"),
+            mediaType: z12.literal("application/pdf"),
+            data: z12.string()
+          }),
+          z12.object({
+            type: z12.literal("text"),
+            mediaType: z12.literal("text/plain"),
+            data: z12.string()
+          })
+        ])
+      }),
+      retrievedAt: z12.string().nullable()
+    })
+  )
+);
+var webFetch_20260209InputSchema = lazySchema11(
+  () => zodSchema11(
+    z12.object({
+      url: z12.string()
+    })
+  )
+);
+var factory7 = createProviderExecutedToolFactory6({
+  id: "anthropic.web_fetch_20260209",
+  inputSchema: webFetch_20260209InputSchema,
+  outputSchema: webFetch_20260209OutputSchema,
+  supportsDeferredResults: true
+});
+var webFetch_20260209 = (args = {}) => {
+  return factory7(args);
+};
+
+// src/tool/web-fetch-20250910.ts
+import {
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory7,
+  lazySchema as lazySchema12,
+  zodSchema as zodSchema12
+} from "@ai-sdk/provider-utils";
+import { z as z13 } from "zod/v4";
+var webFetch_20250910ArgsSchema = lazySchema12(
+  () => zodSchema12(
+    z13.object({
+      maxUses: z13.number().optional(),
+      allowedDomains: z13.array(z13.string()).optional(),
+      blockedDomains: z13.array(z13.string()).optional(),
+      citations: z13.object({ enabled: z13.boolean() }).optional(),
+      maxContentTokens: z13.number().optional()
+    })
+  )
+);
+var webFetch_20250910OutputSchema = lazySchema12(
+  () => zodSchema12(
+    z13.object({
+      type: z13.literal("web_fetch_result"),
+      url: z13.string(),
+      content: z13.object({
+        type: z13.literal("document"),
+        title: z13.string().nullable(),
+        citations: z13.object({ enabled: z13.boolean() }).optional(),
+        source: z13.union([
+          z13.object({
+            type: z13.literal("base64"),
+            mediaType: z13.literal("application/pdf"),
+            data: z13.string()
+          }),
+          z13.object({
+            type: z13.literal("text"),
+            mediaType: z13.literal("text/plain"),
+            data: z13.string()
+          })
+        ])
+      }),
+      retrievedAt: z13.string().nullable()
+    })
+  )
+);
+var webFetch_20250910InputSchema = lazySchema12(
+  () => zodSchema12(
+    z13.object({
+      url: z13.string()
+    })
+  )
+);
+var factory8 = createProviderExecutedToolFactory7({
   id: "anthropic.web_fetch_20250910",
   inputSchema: webFetch_20250910InputSchema,
   outputSchema: webFetch_20250910OutputSchema,
   supportsDeferredResults: true
 });
 var webFetch_20250910 = (args = {}) => {
-  return factory6(args);
+  return factory8(args);
 };
 
 // src/anthropic-prepare-tools.ts
@@ -1642,10 +1893,10 @@ async function prepareTools({
   cacheControlValidator,
   supportsStructuredOutput,
   supportsStrictTools,
-  defaultEagerInputStreaming = false
+  defaultEagerInputStreaming = false,
+  rejectsForcedToolUse = false
 }) {
-  var _a, _b;
-  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
+  tools = tools?.length ? tools : void 0;
   const toolWarnings = [];
   const betas = /* @__PURE__ */ new Set();
   const validator = cacheControlValidator || new CacheControlValidator();
@@ -1660,10 +1911,10 @@ async function prepareTools({
           type: "tool definition",
           canCache: true
         });
-        const anthropicOptions = (_a = tool.providerOptions) == null ? void 0 : _a.anthropic;
-        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;
+        const anthropicOptions = tool.providerOptions?.anthropic;
+        const eagerInputStreaming = anthropicOptions?.eagerInputStreaming ?? defaultEagerInputStreaming;
+        const deferLoading = anthropicOptions?.deferLoading;
+        const allowedCallers = anthropicOptions?.allowedCallers;
         if (!supportsStrictTools && tool.strict != null) {
           toolWarnings.push({
             type: "unsupported",
@@ -1745,6 +1996,31 @@ async function prepareTools({
             });
             break;
           }
+          case "anthropic.computer_toolset_20260801": {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: computerToolset_20260801ArgsSchema
+            });
+            const configs = args.configs != null ? Object.fromEntries(
+              Object.entries(args.configs).map(([member, config]) => [
+                member,
+                {
+                  ...config?.enabled != null && {
+                    enabled: config.enabled
+                  },
+                  ...config?.deferLoading != null && {
+                    defer_loading: config.deferLoading
+                  }
+                }
+              ])
+            ) : void 0;
+            anthropicTools2.push({
+              type: "computer_toolset_20260801",
+              ...configs != null && { configs },
+              cache_control: void 0
+            });
+            break;
+          }
           case "anthropic.computer_20241022": {
             betas.add("computer-use-2024-10-22");
             anthropicTools2.push({
@@ -1859,6 +2135,25 @@ async function prepareTools({
             });
             break;
           }
+          case "anthropic.web_fetch_20260318": {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: webFetch_20260318ArgsSchema
+            });
+            anthropicTools2.push({
+              type: "web_fetch_20260318",
+              name: "web_fetch",
+              max_uses: args.maxUses,
+              allowed_domains: args.allowedDomains,
+              blocked_domains: args.blockedDomains,
+              citations: args.citations,
+              max_content_tokens: args.maxContentTokens,
+              use_cache: args.useCache,
+              response_inclusion: args.responseInclusion,
+              cache_control: void 0
+            });
+            break;
+          }
           case "anthropic.web_search_20250305": {
             const args = await validateTypes({
               value: tool.args,
@@ -1892,6 +2187,23 @@ async function prepareTools({
             });
             break;
           }
+          case "anthropic.web_search_20260318": {
+            const args = await validateTypes({
+              value: tool.args,
+              schema: webSearch_20260318ArgsSchema
+            });
+            anthropicTools2.push({
+              type: "web_search_20260318",
+              name: "web_search",
+              max_uses: args.maxUses,
+              allowed_domains: args.allowedDomains,
+              blocked_domains: args.blockedDomains,
+              user_location: args.userLocation,
+              response_inclusion: args.responseInclusion,
+              cache_control: void 0
+            });
+            break;
+          }
           case "anthropic.tool_search_regex_20251119": {
             anthropicTools2.push({
               type: "tool_search_tool_regex_20251119",
@@ -1964,6 +2276,22 @@ async function prepareTools({
         betas
       };
     case "required":
+      if (rejectsForcedToolUse) {
+        toolWarnings.push({
+          type: "unsupported",
+          feature: "toolChoice",
+          details: `toolChoice 'required' is not supported by this model because it rejects forced tool use. Using 'auto' instead. Instruct the model to use a tool in the prompt and verify that a tool call was made.`
+        });
+        return {
+          tools: anthropicTools2,
+          toolChoice: {
+            type: "auto",
+            disable_parallel_tool_use: disableParallelToolUse
+          },
+          toolWarnings,
+          betas
+        };
+      }
       return {
         tools: anthropicTools2,
         toolChoice: {
@@ -1976,6 +2304,24 @@ async function prepareTools({
     case "none":
       return { tools: void 0, toolChoice: void 0, toolWarnings, betas };
     case "tool":
+      if (rejectsForcedToolUse) {
+        toolWarnings.push({
+          type: "unsupported",
+          feature: "toolChoice",
+          details: `toolChoice 'tool' is not supported by this model because it rejects forced tool use. Only the '${toolChoice.toolName}' tool is sent with 'auto' tool choice. Instruct the model to use the tool in the prompt and verify that a tool call was made.`
+        });
+        return {
+          tools: anthropicTools2.filter(
+            (tool) => "name" in tool && tool.name === toolChoice.toolName
+          ),
+          toolChoice: {
+            type: "auto",
+            disable_parallel_tool_use: disableParallelToolUse
+          },
+          toolWarnings,
+          betas
+        };
+      }
       return {
         tools: anthropicTools2,
         toolChoice: {
@@ -2000,13 +2346,12 @@ function convertAnthropicUsage({
   usage,
   rawUsage
 }) {
-  var _a, _b, _c, _d, _e;
-  const cacheCreationTokens = (_a = usage.cache_creation_input_tokens) != null ? _a : 0;
-  const cacheReadTokens = (_b = usage.cache_read_input_tokens) != null ? _b : 0;
-  const reasoningTokens = (_d = (_c = usage.output_tokens_details) == null ? void 0 : _c.thinking_tokens) != null ? _d : void 0;
+  const cacheCreationTokens = usage.cache_creation_input_tokens ?? 0;
+  const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
+  const reasoningTokens = usage.output_tokens_details?.thinking_tokens ?? void 0;
   let inputTokens;
   let outputTokens;
-  const servedByFallback = (_e = usage.iterations) == null ? void 0 : _e.some(
+  const servedByFallback = usage.iterations?.some(
     (iter) => iter.type === "fallback_message"
   );
   if (usage.iterations && usage.iterations.length > 0 && !servedByFallback) {
@@ -2043,7 +2388,7 @@ function convertAnthropicUsage({
       text: reasoningTokens == null ? void 0 : outputTokens - reasoningTokens,
       reasoning: reasoningTokens
     },
-    raw: rawUsage != null ? rawUsage : usage
+    raw: rawUsage ?? usage
   };
 }
 
@@ -2065,145 +2410,145 @@ import {
 
 // src/tool/code-execution_20250522.ts
 import {
-  createProviderExecutedToolFactory as createProviderExecutedToolFactory6,
-  lazySchema as lazySchema10,
-  zodSchema as zodSchema10
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory8,
+  lazySchema as lazySchema13,
+  zodSchema as zodSchema13
 } from "@ai-sdk/provider-utils";
-import { z as z11 } from "zod/v4";
-var codeExecution_20250522OutputSchema = lazySchema10(
-  () => zodSchema10(
-    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()
+import { z as z14 } from "zod/v4";
+var codeExecution_20250522OutputSchema = lazySchema13(
+  () => zodSchema13(
+    z14.object({
+      type: z14.literal("code_execution_result"),
+      stdout: z14.string(),
+      stderr: z14.string(),
+      return_code: z14.number(),
+      content: z14.array(
+        z14.object({
+          type: z14.literal("code_execution_output"),
+          file_id: z14.string()
         })
       ).optional().default([])
     })
   )
 );
-var codeExecution_20250522InputSchema = lazySchema10(
-  () => zodSchema10(
-    z11.object({
-      code: z11.string()
+var codeExecution_20250522InputSchema = lazySchema13(
+  () => zodSchema13(
+    z14.object({
+      code: z14.string()
     })
   )
 );
-var factory7 = createProviderExecutedToolFactory6({
+var factory9 = createProviderExecutedToolFactory8({
   id: "anthropic.code_execution_20250522",
   inputSchema: codeExecution_20250522InputSchema,
   outputSchema: codeExecution_20250522OutputSchema
 });
 var codeExecution_20250522 = (args = {}) => {
-  return factory7(args);
+  return factory9(args);
 };
 
 // src/tool/code-execution_20250825.ts
 import {
-  createProviderExecutedToolFactory as createProviderExecutedToolFactory7,
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory9,
   experimental_toolCaller,
-  lazySchema as lazySchema11,
-  zodSchema as zodSchema11
+  lazySchema as lazySchema14,
+  zodSchema as zodSchema14
 } from "@ai-sdk/provider-utils";
-import { z as z12 } from "zod/v4";
-var codeExecution_20250825OutputSchema = lazySchema11(
-  () => zodSchema11(
-    z12.discriminatedUnion("type", [
-      z12.object({
-        type: z12.literal("code_execution_result"),
-        stdout: z12.string(),
-        stderr: z12.string(),
-        return_code: z12.number(),
-        content: z12.array(
-          z12.object({
-            type: z12.literal("code_execution_output"),
-            file_id: z12.string()
+import { z as z15 } from "zod/v4";
+var codeExecution_20250825OutputSchema = lazySchema14(
+  () => zodSchema14(
+    z15.discriminatedUnion("type", [
+      z15.object({
+        type: z15.literal("code_execution_result"),
+        stdout: z15.string(),
+        stderr: z15.string(),
+        return_code: z15.number(),
+        content: z15.array(
+          z15.object({
+            type: z15.literal("code_execution_output"),
+            file_id: z15.string()
           })
         ).optional().default([])
       }),
-      z12.object({
-        type: z12.literal("bash_code_execution_result"),
-        content: z12.array(
-          z12.object({
-            type: z12.literal("bash_code_execution_output"),
-            file_id: z12.string()
+      z15.object({
+        type: z15.literal("bash_code_execution_result"),
+        content: z15.array(
+          z15.object({
+            type: z15.literal("bash_code_execution_output"),
+            file_id: z15.string()
           })
         ),
-        stdout: z12.string(),
-        stderr: z12.string(),
-        return_code: z12.number()
+        stdout: z15.string(),
+        stderr: z15.string(),
+        return_code: z15.number()
       }),
-      z12.object({
-        type: z12.literal("bash_code_execution_tool_result_error"),
-        error_code: z12.string()
+      z15.object({
+        type: z15.literal("bash_code_execution_tool_result_error"),
+        error_code: z15.string()
       }),
-      z12.object({
-        type: z12.literal("text_editor_code_execution_tool_result_error"),
-        error_code: z12.string()
+      z15.object({
+        type: z15.literal("text_editor_code_execution_tool_result_error"),
+        error_code: z15.string()
       }),
-      z12.object({
-        type: z12.literal("text_editor_code_execution_view_result"),
-        content: z12.string(),
-        file_type: z12.string(),
-        num_lines: z12.number().nullable(),
-        start_line: z12.number().nullable(),
-        total_lines: z12.number().nullable()
+      z15.object({
+        type: z15.literal("text_editor_code_execution_view_result"),
+        content: z15.string(),
+        file_type: z15.string(),
+        num_lines: z15.number().nullable(),
+        start_line: z15.number().nullable(),
+        total_lines: z15.number().nullable()
       }),
-      z12.object({
-        type: z12.literal("text_editor_code_execution_create_result"),
-        is_file_update: z12.boolean()
+      z15.object({
+        type: z15.literal("text_editor_code_execution_create_result"),
+        is_file_update: z15.boolean()
       }),
-      z12.object({
-        type: z12.literal("text_editor_code_execution_str_replace_result"),
-        lines: z12.array(z12.string()).nullable(),
-        new_lines: z12.number().nullable(),
-        new_start: z12.number().nullable(),
-        old_lines: z12.number().nullable(),
-        old_start: z12.number().nullable()
+      z15.object({
+        type: z15.literal("text_editor_code_execution_str_replace_result"),
+        lines: z15.array(z15.string()).nullable(),
+        new_lines: z15.number().nullable(),
+        new_start: z15.number().nullable(),
+        old_lines: z15.number().nullable(),
+        old_start: z15.number().nullable()
       })
     ])
   )
 );
-var codeExecution_20250825InputSchema = lazySchema11(
-  () => zodSchema11(
-    z12.discriminatedUnion("type", [
+var codeExecution_20250825InputSchema = lazySchema14(
+  () => zodSchema14(
+    z15.discriminatedUnion("type", [
       // Programmatic tool calling format (mapped from { code } by AI SDK)
-      z12.object({
-        type: z12.literal("programmatic-tool-call"),
-        code: z12.string()
+      z15.object({
+        type: z15.literal("programmatic-tool-call"),
+        code: z15.string()
       }),
-      z12.object({
-        type: z12.literal("bash_code_execution"),
-        command: z12.string()
+      z15.object({
+        type: z15.literal("bash_code_execution"),
+        command: z15.string()
       }),
-      z12.discriminatedUnion("command", [
-        z12.object({
-          type: z12.literal("text_editor_code_execution"),
-          command: z12.literal("view"),
-          path: z12.string()
+      z15.discriminatedUnion("command", [
+        z15.object({
+          type: z15.literal("text_editor_code_execution"),
+          command: z15.literal("view"),
+          path: z15.string()
         }),
-        z12.object({
-          type: z12.literal("text_editor_code_execution"),
-          command: z12.literal("create"),
-          path: z12.string(),
-          file_text: z12.string().nullish()
+        z15.object({
+          type: z15.literal("text_editor_code_execution"),
+          command: z15.literal("create"),
+          path: z15.string(),
+          file_text: z15.string().nullish()
         }),
-        z12.object({
-          type: z12.literal("text_editor_code_execution"),
-          command: z12.literal("str_replace"),
-          path: z12.string(),
-          old_str: z12.string(),
-          new_str: z12.string()
+        z15.object({
+          type: z15.literal("text_editor_code_execution"),
+          command: z15.literal("str_replace"),
+          path: z15.string(),
+          old_str: z15.string(),
+          new_str: z15.string()
         })
       ])
     ])
   )
 );
-var factory8 = createProviderExecutedToolFactory7({
+var factory10 = createProviderExecutedToolFactory9({
   id: "anthropic.code_execution_20250825",
   inputSchema: codeExecution_20250825InputSchema,
   outputSchema: codeExecution_20250825OutputSchema,
@@ -2213,18 +2558,17 @@ var factory8 = createProviderExecutedToolFactory7({
   supportsDeferredResults: true
 });
 var codeExecution_20250825 = (args = {}) => {
-  return experimental_toolCaller(factory8(args), {
+  return experimental_toolCaller(factory10(args), {
     type: "provider",
     prepareProviderOptions: (providerOptions) => {
-      var _a;
-      const anthropicOptions = providerOptions == null ? void 0 : providerOptions.anthropic;
+      const anthropicOptions = providerOptions?.anthropic;
       return {
         ...providerOptions,
         anthropic: {
           ...anthropicOptions,
           allowedCallers: [
             .../* @__PURE__ */ new Set([
-              ...(_a = anthropicOptions == null ? void 0 : anthropicOptions.allowedCallers) != null ? _a : [],
+              ...anthropicOptions?.allowedCallers ?? [],
               "code_execution_20250825"
             ])
           ]
@@ -2236,135 +2580,134 @@ var codeExecution_20250825 = (args = {}) => {
 
 // src/tool/code-execution_20260120.ts
 import {
-  createProviderExecutedToolFactory as createProviderExecutedToolFactory8,
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory10,
   experimental_toolCaller as experimental_toolCaller2,
-  lazySchema as lazySchema12,
-  zodSchema as zodSchema12
+  lazySchema as lazySchema15,
+  zodSchema as zodSchema15
 } from "@ai-sdk/provider-utils";
-import { z as z13 } from "zod/v4";
-var codeExecution_20260120OutputSchema = lazySchema12(
-  () => zodSchema12(
-    z13.discriminatedUnion("type", [
-      z13.object({
-        type: z13.literal("code_execution_result"),
-        stdout: z13.string(),
-        stderr: z13.string(),
-        return_code: z13.number(),
-        content: z13.array(
-          z13.object({
-            type: z13.literal("code_execution_output"),
-            file_id: z13.string()
+import { z as z16 } from "zod/v4";
+var codeExecution_20260120OutputSchema = lazySchema15(
+  () => zodSchema15(
+    z16.discriminatedUnion("type", [
+      z16.object({
+        type: z16.literal("code_execution_result"),
+        stdout: z16.string(),
+        stderr: z16.string(),
+        return_code: z16.number(),
+        content: z16.array(
+          z16.object({
+            type: z16.literal("code_execution_output"),
+            file_id: z16.string()
           })
         ).optional().default([])
       }),
-      z13.object({
-        type: z13.literal("encrypted_code_execution_result"),
-        encrypted_stdout: z13.string(),
-        stderr: z13.string(),
-        return_code: z13.number(),
-        content: z13.array(
-          z13.object({
-            type: z13.literal("code_execution_output"),
-            file_id: z13.string()
+      z16.object({
+        type: z16.literal("encrypted_code_execution_result"),
+        encrypted_stdout: z16.string(),
+        stderr: z16.string(),
+        return_code: z16.number(),
+        content: z16.array(
+          z16.object({
+            type: z16.literal("code_execution_output"),
+            file_id: z16.string()
           })
         ).optional().default([])
       }),
-      z13.object({
-        type: z13.literal("bash_code_execution_result"),
-        content: z13.array(
-          z13.object({
-            type: z13.literal("bash_code_execution_output"),
-            file_id: z13.string()
+      z16.object({
+        type: z16.literal("bash_code_execution_result"),
+        content: z16.array(
+          z16.object({
+            type: z16.literal("bash_code_execution_output"),
+            file_id: z16.string()
           })
         ),
-        stdout: z13.string(),
-        stderr: z13.string(),
-        return_code: z13.number()
+        stdout: z16.string(),
+        stderr: z16.string(),
+        return_code: z16.number()
       }),
-      z13.object({
-        type: z13.literal("bash_code_execution_tool_result_error"),
-        error_code: z13.string()
+      z16.object({
+        type: z16.literal("bash_code_execution_tool_result_error"),
+        error_code: z16.string()
       }),
-      z13.object({
-        type: z13.literal("text_editor_code_execution_tool_result_error"),
-        error_code: z13.string()
+      z16.object({
+        type: z16.literal("text_editor_code_execution_tool_result_error"),
+        error_code: z16.string()
       }),
-      z13.object({
-        type: z13.literal("text_editor_code_execution_view_result"),
-        content: z13.string(),
-        file_type: z13.string(),
-        num_lines: z13.number().nullable(),
-        start_line: z13.number().nullable(),
-        total_lines: z13.number().nullable()
+      z16.object({
+        type: z16.literal("text_editor_code_execution_view_result"),
+        content: z16.string(),
+        file_type: z16.string(),
+        num_lines: z16.number().nullable(),
+        start_line: z16.number().nullable(),
+        total_lines: z16.number().nullable()
       }),
-      z13.object({
-        type: z13.literal("text_editor_code_execution_create_result"),
-        is_file_update: z13.boolean()
+      z16.object({
+        type: z16.literal("text_editor_code_execution_create_result"),
+        is_file_update: z16.boolean()
       }),
-      z13.object({
-        type: z13.literal("text_editor_code_execution_str_replace_result"),
-        lines: z13.array(z13.string()).nullable(),
-        new_lines: z13.number().nullable(),
-        new_start: z13.number().nullable(),
-        old_lines: z13.number().nullable(),
-        old_start: z13.number().nullable()
+      z16.object({
+        type: z16.literal("text_editor_code_execution_str_replace_result"),
+        lines: z16.array(z16.string()).nullable(),
+        new_lines: z16.number().nullable(),
+        new_start: z16.number().nullable(),
+        old_lines: z16.number().nullable(),
+        old_start: z16.number().nullable()
       })
     ])
   )
 );
-var codeExecution_20260120InputSchema = lazySchema12(
-  () => zodSchema12(
-    z13.discriminatedUnion("type", [
-      z13.object({
-        type: z13.literal("programmatic-tool-call"),
-        code: z13.string()
+var codeExecution_20260120InputSchema = lazySchema15(
+  () => zodSchema15(
+    z16.discriminatedUnion("type", [
+      z16.object({
+        type: z16.literal("programmatic-tool-call"),
+        code: z16.string()
       }),
-      z13.object({
-        type: z13.literal("bash_code_execution"),
-        command: z13.string()
+      z16.object({
+        type: z16.literal("bash_code_execution"),
+        command: z16.string()
       }),
-      z13.discriminatedUnion("command", [
-        z13.object({
-          type: z13.literal("text_editor_code_execution"),
-          command: z13.literal("view"),
-          path: z13.string()
+      z16.discriminatedUnion("command", [
+        z16.object({
+          type: z16.literal("text_editor_code_execution"),
+          command: z16.literal("view"),
+          path: z16.string()
         }),
-        z13.object({
-          type: z13.literal("text_editor_code_execution"),
-          command: z13.literal("create"),
-          path: z13.string(),
-          file_text: z13.string().nullish()
+        z16.object({
+          type: z16.literal("text_editor_code_execution"),
+          command: z16.literal("create"),
+          path: z16.string(),
+          file_text: z16.string().nullish()
         }),
-        z13.object({
-          type: z13.literal("text_editor_code_execution"),
-          command: z13.literal("str_replace"),
-          path: z13.string(),
-          old_str: z13.string(),
-          new_str: z13.string()
+        z16.object({
+          type: z16.literal("text_editor_code_execution"),
+          command: z16.literal("str_replace"),
+          path: z16.string(),
+          old_str: z16.string(),
+          new_str: z16.string()
         })
       ])
     ])
   )
 );
-var factory9 = createProviderExecutedToolFactory8({
+var factory11 = createProviderExecutedToolFactory10({
   id: "anthropic.code_execution_20260120",
   inputSchema: codeExecution_20260120InputSchema,
   outputSchema: codeExecution_20260120OutputSchema,
   supportsDeferredResults: true
 });
 var codeExecution_20260120 = (args = {}) => {
-  return experimental_toolCaller2(factory9(args), {
+  return experimental_toolCaller2(factory11(args), {
     type: "provider",
     prepareProviderOptions: (providerOptions) => {
-      var _a;
-      const anthropicOptions = providerOptions == null ? void 0 : providerOptions.anthropic;
+      const anthropicOptions = providerOptions?.anthropic;
       return {
         ...providerOptions,
         anthropic: {
           ...anthropicOptions,
           allowedCallers: [
             .../* @__PURE__ */ new Set([
-              ...(_a = anthropicOptions == null ? void 0 : anthropicOptions.allowedCallers) != null ? _a : [],
+              ...anthropicOptions?.allowedCallers ?? [],
               "code_execution_20260120"
             ])
           ]
@@ -2376,24 +2719,24 @@ var codeExecution_20260120 = (args = {}) => {
 
 // src/tool/tool-search-regex_20251119.ts
 import {
-  createProviderExecutedToolFactory as createProviderExecutedToolFactory9,
-  lazySchema as lazySchema13,
-  zodSchema as zodSchema13
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory11,
+  lazySchema as lazySchema16,
+  zodSchema as zodSchema16
 } from "@ai-sdk/provider-utils";
-import { z as z14 } from "zod/v4";
-var toolSearchRegex_20251119OutputSchema = lazySchema13(
-  () => zodSchema13(
-    z14.array(
-      z14.object({
-        type: z14.literal("tool_reference"),
-        toolName: z14.string()
+import { z as z17 } from "zod/v4";
+var toolSearchRegex_20251119OutputSchema = lazySchema16(
+  () => zodSchema16(
+    z17.array(
+      z17.object({
+        type: z17.literal("tool_reference"),
+        toolName: z17.string()
       })
     )
   )
 );
-var toolSearchRegex_20251119InputSchema = lazySchema13(
-  () => zodSchema13(
-    z14.object({
+var toolSearchRegex_20251119InputSchema = lazySchema16(
+  () => zodSchema16(
+    z17.object({
       /**
        * A regex pattern to search for tools.
        * Uses Python re.search() syntax. Maximum 200 characters.
@@ -2404,22 +2747,22 @@ var toolSearchRegex_20251119InputSchema = lazySchema13(
        * - "database.*query|query.*database" - OR patterns for flexibility
        * - "(?i)slack" - case-insensitive search
        */
-      pattern: z14.string(),
+      pattern: z17.string(),
       /**
        * Maximum number of tools to return. Optional.
        */
-      limit: z14.number().optional()
+      limit: z17.number().optional()
     })
   )
 );
-var factory10 = createProviderExecutedToolFactory9({
+var factory12 = createProviderExecutedToolFactory11({
   id: "anthropic.tool_search_regex_20251119",
   inputSchema: toolSearchRegex_20251119InputSchema,
   outputSchema: toolSearchRegex_20251119OutputSchema,
   supportsDeferredResults: true
 });
 var toolSearchRegex_20251119 = (args = {}) => {
-  return factory10(args);
+  return factory12(args);
 };
 
 // src/convert-to-anthropic-prompt.ts
@@ -2436,8 +2779,8 @@ function extractErrorValue(value) {
     } else if (typeof value === "object" && value !== null) {
       return value;
     }
-  } catch (e) {
-    const extractedErrorCode = value == null ? void 0 : value.errorCode;
+  } catch {
+    const extractedErrorCode = value?.errorCode;
     return {
       errorCode: typeof extractedErrorCode === "string" ? extractedErrorCode : "unavailable"
     };
@@ -2449,31 +2792,30 @@ async function convertToAnthropicPrompt({
   sendReasoning,
   warnings,
   cacheControlValidator,
-  toolNameMapping
+  toolNameMapping,
+  toolsetNames = {}
 }) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v;
   const betas = /* @__PURE__ */ new Set();
   const blocks = groupIntoBlocks(prompt);
   const validator = cacheControlValidator || new CacheControlValidator();
   let system = void 0;
   const messages = [];
+  let lastUserMessageIndex = -1;
   async function shouldEnableCitations(providerMetadata) {
-    var _a2, _b2;
     const anthropicOptions = await parseProviderOptions({
       provider: "anthropic",
       providerOptions: providerMetadata,
       schema: anthropicFilePartProviderOptions
     });
-    return (_b2 = (_a2 = anthropicOptions == null ? void 0 : anthropicOptions.citations) == null ? void 0 : _a2.enabled) != null ? _b2 : false;
+    return anthropicOptions?.citations?.enabled ?? false;
   }
   async function shouldUseContainerUpload(providerMetadata) {
-    var _a2;
     const anthropicOptions = await parseProviderOptions({
       provider: "anthropic",
       providerOptions: providerMetadata,
       schema: anthropicFilePartProviderOptions
     });
-    return (_a2 = anthropicOptions == null ? void 0 : anthropicOptions.containerUpload) != null ? _a2 : false;
+    return anthropicOptions?.containerUpload ?? false;
   }
   async function getDocumentMetadata(providerMetadata) {
     const anthropicOptions = await parseProviderOptions({
@@ -2482,8 +2824,8 @@ async function convertToAnthropicPrompt({
       schema: anthropicFilePartProviderOptions
     });
     return {
-      title: anthropicOptions == null ? void 0 : anthropicOptions.title,
-      context: anthropicOptions == null ? void 0 : anthropicOptions.context
+      title: anthropicOptions?.title,
+      context: anthropicOptions?.context
     };
   }
   for (let i = 0; i < blocks.length; i++) {
@@ -2499,9 +2841,9 @@ async function convertToAnthropicPrompt({
             providerOptions,
             schema: anthropicSystemMessageProviderOptions
           });
-          const toolChanges = (_a = systemMessageOptions == null ? void 0 : systemMessageOptions.toolChanges) != null ? _a : [];
+          const toolChanges = systemMessageOptions?.toolChanges ?? [];
           const content = [];
-          if (text !== "" || toolChanges.length === 0 && (systemMessageOptions == null ? void 0 : systemMessageOptions.clearAt) == null && (systemMessageOptions == null ? void 0 : systemMessageOptions.effort) == null) {
+          if (text !== "" || toolChanges.length === 0 && systemMessageOptions?.clearAt == null && systemMessageOptions?.effort == null) {
             content.push({
               type: "text",
               text,
@@ -2522,8 +2864,8 @@ async function convertToAnthropicPrompt({
           }
           convertedMessages.push({
             content,
-            clearAt: systemMessageOptions == null ? void 0 : systemMessageOptions.clearAt,
-            effort: systemMessageOptions == null ? void 0 : systemMessageOptions.effort,
+            clearAt: systemMessageOptions?.clearAt,
+            effort: systemMessageOptions?.effort,
             toolChangeCount: toolChanges.length
           });
         }
@@ -2542,10 +2884,17 @@ async function convertToAnthropicPrompt({
             });
           }
           for (const message of convertedMessages) {
-            if (message.clearAt != null || message.effort != null) {
+            if (message.content.length === 0 && message.clearAt == null && message.effort != null) {
+              messages.push({
+                role: "system",
+                content: [],
+                output_config: { effort: message.effort }
+              });
+              betas.add("mid-conversation-output-config-2026-07-01");
+            } else if (message.clearAt != null || message.effort != null) {
               warnings.push({
                 type: "other",
-                message: "clearAt and effort on the initial system message are not supported by Anthropic. These options have been ignored."
+                message: "clearAt and effort on this initial system message are not supported by Anthropic. Use a separate effort-only system message with empty content to set effort. These options have been ignored."
               });
             }
           }
@@ -2572,7 +2921,7 @@ async function convertToAnthropicPrompt({
               betas.add("mid-conversation-system-clear-at-2026-08-21");
             }
             if (message.effort != null) {
-              betas.add("mid-conversation-effort-2026-08-01");
+              betas.add("mid-conversation-output-config-2026-07-01");
             }
           }
         }
@@ -2584,16 +2933,19 @@ async function convertToAnthropicPrompt({
           const { role, content } = message;
           switch (role) {
             case "user": {
+              if (content.length > 0) {
+                lastUserMessageIndex = messages.length;
+              }
               for (let j = 0; j < content.length; j++) {
                 const part = content[j];
                 const isLastPart = j === content.length - 1;
-                const cacheControl = (_b = validator.getCacheControl(part.providerOptions, {
+                const cacheControl = validator.getCacheControl(part.providerOptions, {
                   type: "user message part",
                   canCache: true
-                })) != null ? _b : isLastPart ? validator.getCacheControl(message.providerOptions, {
+                }) ?? (isLastPart ? validator.getCacheControl(message.providerOptions, {
                   type: "user message",
                   canCache: true
-                }) : void 0;
+                }) : void 0);
                 switch (part.type) {
                   case "text": {
                     anthropicContent.push({
@@ -2645,7 +2997,7 @@ async function convertToAnthropicPrompt({
                             media_type: "text/plain",
                             data: part.data.text
                           },
-                          title: (_c = metadata.title) != null ? _c : part.filename,
+                          title: metadata.title ?? part.filename,
                           ...metadata.context && {
                             context: metadata.context
                           },
@@ -2690,7 +3042,7 @@ async function convertToAnthropicPrompt({
                               media_type: "application/pdf",
                               data: convertToBase64(part.data.data)
                             },
-                            title: (_d = metadata.title) != null ? _d : part.filename,
+                            title: metadata.title ?? part.filename,
                             ...metadata.context && {
                               context: metadata.context
                             },
@@ -2718,7 +3070,7 @@ async function convertToAnthropicPrompt({
                                 part.data.data
                               )
                             },
-                            title: (_e = metadata.title) != null ? _e : part.filename,
+                            title: metadata.title ?? part.filename,
                             ...metadata.context && {
                               context: metadata.context
                             },
@@ -2748,25 +3100,24 @@ async function convertToAnthropicPrompt({
                   continue;
                 }
                 const output = part.output;
-                const outputProviderOptions = "providerOptions" in output ? output.providerOptions : output.type === "content" ? (_f = output.value.find(
+                const outputProviderOptions = "providerOptions" in output ? output.providerOptions : output.type === "content" ? output.value.find(
                   (contentPart) => contentPart.providerOptions != null
-                )) == null ? void 0 : _f.providerOptions : void 0;
+                )?.providerOptions : void 0;
                 const isLastPart = i2 === content.length - 1;
-                const cacheControl = (_h = (_g = validator.getCacheControl(part.providerOptions, {
+                const cacheControl = validator.getCacheControl(part.providerOptions, {
                   type: "tool result part",
                   canCache: true
-                })) != null ? _g : validator.getCacheControl(outputProviderOptions, {
+                }) ?? validator.getCacheControl(outputProviderOptions, {
                   type: "tool result output",
                   canCache: true
-                })) != null ? _h : isLastPart ? validator.getCacheControl(message.providerOptions, {
+                }) ?? (isLastPart ? validator.getCacheControl(message.providerOptions, {
                   type: "tool result message",
                   canCache: true
-                }) : void 0;
+                }) : void 0);
                 let contentValue;
                 switch (output.type) {
                   case "content":
                     contentValue = output.value.map((contentPart) => {
-                      var _a2;
                       switch (contentPart.type) {
                         case "text":
                           return {
@@ -2836,8 +3187,8 @@ async function convertToAnthropicPrompt({
                           return void 0;
                         }
                         case "custom": {
-                          const anthropicOptions = (_a2 = contentPart.providerOptions) == null ? void 0 : _a2.anthropic;
-                          if ((anthropicOptions == null ? void 0 : anthropicOptions.type) === "tool-reference") {
+                          const anthropicOptions = contentPart.providerOptions?.anthropic;
+                          if (anthropicOptions?.type === "tool-reference") {
                             return {
                               type: "tool_reference",
                               tool_name: anthropicOptions.toolName
@@ -2864,7 +3215,7 @@ async function convertToAnthropicPrompt({
                     contentValue = output.value;
                     break;
                   case "execution-denied":
-                    contentValue = (_i = output.reason) != null ? _i : "Tool call execution denied.";
+                    contentValue = output.reason ?? "Tool call execution denied.";
                     break;
                   case "json":
                   case "error-json":
@@ -2872,9 +3223,15 @@ async function convertToAnthropicPrompt({
                     contentValue = JSON.stringify(output.value);
                     break;
                 }
+                const toolsetName = getAnthropicToolsetName({
+                  toolName: part.toolName,
+                  providerOptions: part.providerOptions,
+                  toolsetNames
+                });
                 anthropicContent.push({
                   type: "tool_result",
                   tool_use_id: part.toolCallId,
+                  ...toolsetName != null && { toolset_name: toolsetName },
                   content: contentValue,
                   is_error: output.type === "error-text" || output.type === "error-json" ? true : void 0,
                   cache_control: cacheControl
@@ -2901,20 +3258,29 @@ async function convertToAnthropicPrompt({
           for (let k = 0; k < content.length; k++) {
             const part = content[k];
             const isLastContentPart = k === content.length - 1;
-            const cacheControl = (_j = validator.getCacheControl(part.providerOptions, {
+            const cacheControl = validator.getCacheControl(part.providerOptions, {
               type: "assistant message part",
               canCache: true
-            })) != null ? _j : isLastContentPart ? validator.getCacheControl(message.providerOptions, {
+            }) ?? (isLastContentPart ? validator.getCacheControl(message.providerOptions, {
               type: "assistant message",
               canCache: true
-            }) : void 0;
+            }) : void 0);
             switch (part.type) {
               case "text": {
-                const textMetadata = (_k = part.providerOptions) == null ? void 0 : _k.anthropic;
-                if ((textMetadata == null ? void 0 : textMetadata.type) === "compaction") {
+                const textMetadata = part.providerOptions?.anthropic;
+                if (textMetadata?.type === "compaction") {
+                  if (part.text === "") {
+                    break;
+                  }
+                  if (typeof textMetadata.signature === "string") {
+                    betas.add("compact-2026-09-04");
+                  }
                   anthropicContent.push({
                     type: "compaction",
                     content: part.text,
+                    ...typeof textMetadata.signature === "string" && {
+                      signature: textMetadata.signature
+                    },
                     cache_control: cacheControl
                   });
                 } else {
@@ -2926,7 +3292,7 @@ async function convertToAnthropicPrompt({
                       // in pre-filled assistant responses
                       isLastBlock && isLastMessage && isLastContentPart ? part.text.trim() : part.text
                     ),
-                    ...(textMetadata == null ? void 0 : textMetadata.citations) != null && {
+                    ...textMetadata?.citations != null && {
                       citations: textMetadata.citations
                     },
                     cache_control: cacheControl
@@ -2987,10 +3353,10 @@ async function convertToAnthropicPrompt({
                   const providerToolName = toolNameMapping.toProviderToolName(
                     part.toolName
                   );
-                  const isMcpToolUse = ((_m = (_l = part.providerOptions) == null ? void 0 : _l.anthropic) == null ? void 0 : _m.type) === "mcp-tool-use";
+                  const isMcpToolUse = part.providerOptions?.anthropic?.type === "mcp-tool-use";
                   if (isMcpToolUse) {
                     mcpToolUseIds.add(part.toolCallId);
-                    const serverName = (_o = (_n = part.providerOptions) == null ? void 0 : _n.anthropic) == null ? void 0 : _o.serverName;
+                    const serverName = part.providerOptions?.anthropic?.serverName;
                     if (serverName == null || typeof serverName !== "string") {
                       warnings.push({
                         type: "other",
@@ -3072,6 +3438,33 @@ async function convertToAnthropicPrompt({
                   }
                   break;
                 }
+                const toolsetName = getAnthropicToolsetName({
+                  toolName: part.toolName,
+                  providerOptions: part.providerOptions,
+                  toolsetNames
+                });
+                if (toolsetName != null) {
+                  const { action, ...memberInput } = toAnthropicToolInput(
+                    part.input
+                  );
+                  if (typeof action !== "string") {
+                    warnings.push({
+                      type: "other",
+                      message: `toolset tool call for tool ${part.toolName} is missing the action`
+                    });
+                    break;
+                  }
+                  anthropicContent.push({
+                    type: "tool_use",
+                    id: part.toolCallId,
+                    name: action,
+                    toolset_name: toolsetName,
+                    input: memberInput,
+                    ...caller && { caller },
+                    cache_control: cacheControl
+                  });
+                  break;
+                }
                 anthropicContent.push({
                   type: "tool_use",
                   id: part.toolCallId,
@@ -3113,7 +3506,7 @@ async function convertToAnthropicPrompt({
                       } else if (typeof output.value === "object" && output.value !== null) {
                         errorInfo = output.value;
                       }
-                    } catch (e) {
+                    } catch {
                     }
                     if (errorInfo.type === "code_execution_tool_result_error") {
                       anthropicContent.push({
@@ -3121,7 +3514,7 @@ async function convertToAnthropicPrompt({
                         tool_use_id: part.toolCallId,
                         content: {
                           type: "code_execution_tool_result_error",
-                          error_code: (_p = errorInfo.errorCode) != null ? _p : "unknown"
+                          error_code: errorInfo.errorCode ?? "unknown"
                         },
                         cache_control: cacheControl
                       });
@@ -3132,7 +3525,7 @@ async function convertToAnthropicPrompt({
                         cache_control: cacheControl,
                         content: {
                           type: "bash_code_execution_tool_result_error",
-                          error_code: (_q = errorInfo.errorCode) != null ? _q : "unknown"
+                          error_code: errorInfo.errorCode ?? "unknown"
                         }
                       });
                     }
@@ -3165,7 +3558,7 @@ async function convertToAnthropicPrompt({
                         stdout: codeExecutionOutput.stdout,
                         stderr: codeExecutionOutput.stderr,
                         return_code: codeExecutionOutput.return_code,
-                        content: (_r = codeExecutionOutput.content) != null ? _r : []
+                        content: codeExecutionOutput.content ?? []
                       },
                       cache_control: cacheControl
                     });
@@ -3183,7 +3576,7 @@ async function convertToAnthropicPrompt({
                           encrypted_stdout: codeExecutionOutput.encrypted_stdout,
                           stderr: codeExecutionOutput.stderr,
                           return_code: codeExecutionOutput.return_code,
-                          content: (_s = codeExecutionOutput.content) != null ? _s : []
+                          content: codeExecutionOutput.content ?? []
                         },
                         cache_control: cacheControl
                       });
@@ -3202,7 +3595,7 @@ async function convertToAnthropicPrompt({
                           stdout: codeExecutionOutput.stdout,
                           stderr: codeExecutionOutput.stderr,
                           return_code: codeExecutionOutput.return_code,
-                          content: (_t = codeExecutionOutput.content) != null ? _t : []
+                          content: codeExecutionOutput.content ?? []
                         },
                         cache_control: cacheControl
                       });
@@ -3240,7 +3633,7 @@ async function convertToAnthropicPrompt({
                       tool_use_id: part.toolCallId,
                       content: {
                         type: "web_fetch_tool_result_error",
-                        error_code: (_u = extractErrorValue(output.value).errorCode) != null ? _u : "unavailable"
+                        error_code: extractErrorValue(output.value).errorCode ?? "unavailable"
                       },
                       ...caller && { caller },
                       cache_control: cacheControl
@@ -3289,7 +3682,7 @@ async function convertToAnthropicPrompt({
                       tool_use_id: part.toolCallId,
                       content: {
                         type: "web_search_tool_result_error",
-                        error_code: (_v = extractErrorValue(output.value).errorCode) != null ? _v : "unavailable"
+                        error_code: extractErrorValue(output.value).errorCode ?? "unavailable"
                       },
                       ...caller && { caller },
                       cache_control: cacheControl
@@ -3411,10 +3804,12 @@ async function convertToAnthropicPrompt({
             }
           }
         }
-        messages.push({
-          role: "assistant",
-          content: moveToolUseBlocksToEnd(anthropicContent)
-        });
+        if (anthropicContent.length > 0) {
+          messages.push({
+            role: "assistant",
+            content: moveToolUseBlocksToEnd(anthropicContent)
+          });
+        }
         break;
       }
       default: {
@@ -3423,6 +3818,42 @@ async function convertToAnthropicPrompt({
       }
     }
   }
+  const codeExecutionToolCallIds = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    if (message.role !== "assistant") {
+      continue;
+    }
+    for (const part of message.content) {
+      if (part.type === "server_tool_use" && part.name === "code_execution") {
+        codeExecutionToolCallIds.add(part.id);
+      }
+    }
+  }
+  const warnedToolCallIds = /* @__PURE__ */ new Set();
+  for (let i = 0; i < lastUserMessageIndex; i++) {
+    const message = messages[i];
+    if (message.role !== "assistant") {
+      continue;
+    }
+    for (const part of message.content) {
+      if (!("caller" in part)) {
+        continue;
+      }
+      const caller = part.caller;
+      if (caller == null || caller.type === "direct" || codeExecutionToolCallIds.has(caller.tool_id)) {
+        continue;
+      }
+      const toolCallId = "id" in part ? part.id : part.tool_use_id;
+      delete part.caller;
+      if (!warnedToolCallIds.has(toolCallId)) {
+        warnedToolCallIds.add(toolCallId);
+        warnings.push({
+          type: "other",
+          message: `Omitted caller metadata for tool ${toolCallId} because source code execution tool ${caller.tool_id} is missing from the conversation history.`
+        });
+      }
+    }
+  }
   return {
     prompt: { system, messages },
     betas
@@ -3435,7 +3866,7 @@ function groupIntoBlocks(prompt) {
     const { role } = message;
     switch (role) {
       case "system": {
-        if ((currentBlock == null ? void 0 : currentBlock.type) !== "system") {
+        if (currentBlock?.type !== "system") {
           currentBlock = { type: "system", messages: [] };
           blocks.push(currentBlock);
         }
@@ -3443,7 +3874,7 @@ function groupIntoBlocks(prompt) {
         break;
       }
       case "assistant": {
-        if ((currentBlock == null ? void 0 : currentBlock.type) !== "assistant") {
+        if (currentBlock?.type !== "assistant") {
           currentBlock = { type: "assistant", messages: [] };
           blocks.push(currentBlock);
         }
@@ -3451,7 +3882,7 @@ function groupIntoBlocks(prompt) {
         break;
       }
       case "user": {
-        if ((currentBlock == null ? void 0 : currentBlock.type) !== "user") {
+        if (currentBlock?.type !== "user") {
           currentBlock = { type: "user", messages: [] };
           blocks.push(currentBlock);
         }
@@ -3459,7 +3890,7 @@ function groupIntoBlocks(prompt) {
         break;
       }
       case "tool": {
-        if ((currentBlock == null ? void 0 : currentBlock.type) !== "user") {
+        if (currentBlock?.type !== "user") {
           currentBlock = { type: "user", messages: [] };
           blocks.push(currentBlock);
         }
@@ -3495,16 +3926,27 @@ function moveToolUseBlocksToEnd(content) {
   flushSegment();
   return result;
 }
+function getAnthropicToolsetName({
+  toolName,
+  providerOptions,
+  toolsetNames
+}) {
+  const fromTools = toolsetNames[toolName];
+  if (fromTools != null) {
+    return fromTools;
+  }
+  const fromMetadata = providerOptions?.anthropic?.toolsetName;
+  return typeof fromMetadata === "string" ? fromMetadata : void 0;
+}
 function getAnthropicCaller(providerOptions) {
-  var _a;
-  const caller = (_a = providerOptions == null ? void 0 : providerOptions.anthropic) == null ? void 0 : _a.caller;
-  if (((caller == null ? void 0 : caller.type) === "code_execution_20250825" || (caller == null ? void 0 : caller.type) === "code_execution_20260120") && caller.toolId) {
+  const caller = providerOptions?.anthropic?.caller;
+  if ((caller?.type === "code_execution_20250825" || caller?.type === "code_execution_20260120") && caller.toolId) {
     return {
       type: caller.type,
       tool_id: caller.toolId
     };
   }
-  return (caller == null ? void 0 : caller.type) === "direct" ? { type: "direct" } : void 0;
+  return caller?.type === "direct" ? { type: "direct" } : void 0;
 }
 function toAnthropicToolInput(input) {
   return typeof input === "object" && input !== null && !Array.isArray(input) ? input : { rawInvalidInput: input };
@@ -3680,14 +4122,13 @@ function formatConstraintValue(value) {
 
 // src/anthropic-language-model.ts
 function createAnthropicStreamError(error) {
-  var _a, _b, _c;
   const inferredMetadata = getAnthropicStreamErrorMetadata(error.type);
   return createProviderStreamError({
     message: error.message,
     type: error.type,
-    code: (_a = error.code) != null ? _a : void 0,
-    statusCode: (_b = error.statusCode) != null ? _b : inferredMetadata.statusCode,
-    isRetryable: (_c = error.isRetryable) != null ? _c : inferredMetadata.isRetryable,
+    code: error.code ?? void 0,
+    statusCode: error.statusCode ?? inferredMetadata.statusCode,
+    isRetryable: error.isRetryable ?? inferredMetadata.isRetryable,
     data: "data" in error ? error.data : error
   });
 }
@@ -3715,14 +4156,13 @@ function getAnthropicStreamErrorMetadata(type) {
   }
 }
 function createCitationSource(citation, citationDocuments, generateId4) {
-  var _a, _b;
   if (citation.type === "web_search_result_location") {
     return {
       type: "source",
       sourceType: "url",
       id: generateId4(),
       url: citation.url,
-      title: (_a = citation.title) != null ? _a : void 0,
+      title: citation.title ?? void 0,
       providerMetadata: {
         anthropic: {
           citedText: citation.cited_text,
@@ -3743,7 +4183,7 @@ function createCitationSource(citation, citationDocuments, generateId4) {
     sourceType: "document",
     id: generateId4(),
     mediaType: documentInfo.mediaType,
-    title: (_b = citation.document_title) != null ? _b : documentInfo.title,
+    title: citation.document_title ?? documentInfo.title,
     filename: documentInfo.filename,
     providerMetadata: {
       anthropic: citation.type === "page_location" ? {
@@ -3768,6 +4208,24 @@ function getAnthropicCallerMetadata(caller) {
   const callerInfo = getAnthropicCallerInfo(caller);
   return callerInfo == null ? {} : { providerMetadata: { anthropic: { caller: callerInfo } } };
 }
+function getAnthropicToolsetNames(tools) {
+  const toolsetNames = {};
+  for (const tool of tools ?? []) {
+    if (tool.type === "provider" && tool.id === "anthropic.computer_toolset_20260801") {
+      toolsetNames[tool.name] = "computer";
+    }
+  }
+  return toolsetNames;
+}
+function toToolsetMemberInput({
+  memberName,
+  input
+}) {
+  return {
+    action: memberName,
+    ...typeof input === "object" && input !== null && !Array.isArray(input) ? input : {}
+  };
+}
 function getProviderOptionsName(provider) {
   const dotIndex = provider.indexOf(".");
   return dotIndex === -1 ? provider : provider.substring(0, dotIndex);
@@ -3775,10 +4233,9 @@ function getProviderOptionsName(provider) {
 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 : generateId;
+    this.generateId = config.generateId ?? generateId;
   }
   static [WORKFLOW_SERIALIZE](model) {
     return serializeModelOptions({
@@ -3796,8 +4253,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
     return this.config.provider;
   }
   get supportedUrls() {
-    var _a, _b, _c;
-    return (_c = (_b = (_a = this.config).supportedUrls) == null ? void 0 : _b.call(_a)) != null ? _c : {};
+    return this.config.supportedUrls?.() ?? {};
   }
   static async prepareRequest({
     modelId,
@@ -3821,7 +4277,6 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
       stream
     }
   }) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
     const warnings = [];
     if (frequencyPenalty != null) {
       warnings.push({ type: "unsupported", feature: "frequencyPenalty" });
@@ -3847,7 +4302,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
       });
       temperature = 0;
     }
-    if ((responseFormat == null ? void 0 : responseFormat.type) === "json") {
+    if (responseFormat?.type === "json") {
       if (responseFormat.schema == null) {
         warnings.push({
           type: "unsupported",
@@ -3870,8 +4325,8 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
     const usedCustomProviderKey = customProviderOptions != null;
     const anthropicOptions = Object.assign(
       {},
-      canonicalOptions != null ? canonicalOptions : {},
-      customProviderOptions != null ? customProviderOptions : {}
+      canonicalOptions ?? {},
+      customProviderOptions ?? {}
     );
     const {
       maxOutputTokens: maxOutputTokensForModel,
@@ -3880,6 +4335,9 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
       rejectsSamplingParameters,
       supportsXhighEffort,
       rejectsThinkingDisabledAboveHighEffort,
+      rejectsThinkingDisabled,
+      rejectsForcedToolUse,
+      supportsBetweenToolsThinking,
       isKnownModel
     } = getModelCapabilities(modelId);
     if (!isKnownModel && maxOutputTokens == null) {
@@ -3916,24 +4374,39 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
       }
     }
     const isAnthropicModel = isKnownModel || modelId.includes("claude-");
-    const supportsStructuredOutput = ((_a = config.supportsNativeStructuredOutput) != null ? _a : true) && modelSupportsStructuredOutput;
-    const supportsStrictTools = ((_b = config.supportsStrictTools) != null ? _b : true) && modelSupportsStructuredOutput;
-    const structureOutputMode = (_c = anthropicOptions == null ? void 0 : anthropicOptions.structuredOutputMode) != null ? _c : "auto";
-    const useStructuredOutput = structureOutputMode === "outputFormat" || structureOutputMode === "auto" && supportsStructuredOutput;
-    const jsonResponseTool = (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !useStructuredOutput ? {
+    const supportsStructuredOutput = (config.supportsNativeStructuredOutput ?? true) && modelSupportsStructuredOutput;
+    const supportsStrictTools = (config.supportsStrictTools ?? true) && modelSupportsStructuredOutput;
+    const structureOutputMode = anthropicOptions?.structuredOutputMode ?? "auto";
+    let useStructuredOutput = structureOutputMode === "outputFormat" || structureOutputMode === "auto" && supportsStructuredOutput;
+    if (!useStructuredOutput && rejectsForcedToolUse && supportsStructuredOutput && responseFormat?.type === "json" && responseFormat.schema != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "providerOptions.anthropic.structuredOutputMode",
+        details: `structuredOutputMode 'jsonTool' is not supported by ${modelId} because it rejects forced tool use. Using 'outputFormat' instead.`
+      });
+      useStructuredOutput = true;
+    }
+    const jsonResponseTool = responseFormat?.type === "json" && responseFormat.schema != null && !useStructuredOutput ? {
       type: "function",
       name: "json",
       description: "Respond with a JSON object.",
       inputSchema: responseFormat.schema
     } : void 0;
-    if (jsonResponseTool != null && (anthropicOptions == null ? void 0 : anthropicOptions.disableParallelToolUse) === false) {
+    if (jsonResponseTool != null && anthropicOptions?.disableParallelToolUse === false) {
       warnings.push({
         type: "unsupported",
         feature: "providerOptions.anthropic.disableParallelToolUse",
         details: "`disableParallelToolUse: false` is ignored when using the JSON response tool. Parallel tool use is disabled to ensure a single coherent JSON tool call."
       });
     }
-    const contextManagement = anthropicOptions == null ? void 0 : anthropicOptions.contextManagement;
+    const contextManagement = anthropicOptions?.contextManagement;
+    const compaction = anthropicOptions?.compaction;
+    if (contextManagement != null && compaction != null) {
+      throw new InvalidArgumentError({
+        argument: "providerOptions",
+        message: "Anthropic provider options `compaction` and `contextManagement` cannot be used together."
+      });
+    }
     const cacheControlValidator = new CacheControlValidator();
     const toolNameMapping = createToolNameMapping({
       tools,
@@ -3943,6 +4416,8 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
         "anthropic.code_execution_20260120": "code_execution",
         "anthropic.computer_20241022": "computer",
         "anthropic.computer_20250124": "computer",
+        "anthropic.computer_20251124": "computer",
+        "anthropic.computer_toolset_20260801": "computer",
         "anthropic.text_editor_20241022": "str_replace_editor",
         "anthropic.text_editor_20250124": "str_replace_editor",
         "anthropic.text_editor_20250429": "str_replace_based_edit_tool",
@@ -3952,25 +4427,32 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
         "anthropic.memory_20250818": "memory",
         "anthropic.web_search_20250305": "web_search",
         "anthropic.web_search_20260209": "web_search",
+        "anthropic.web_search_20260318": "web_search",
         "anthropic.web_fetch_20250910": "web_fetch",
         "anthropic.web_fetch_20260209": "web_fetch",
+        "anthropic.web_fetch_20260318": "web_fetch",
         "anthropic.tool_search_regex_20251119": "tool_search_tool_regex",
         "anthropic.tool_search_bm25_20251119": "tool_search_tool_bm25",
         "anthropic.advisor_20260301": "advisor"
       }
     });
+    const toolsetNames = getAnthropicToolsetNames(tools);
     const { prompt: messagesPrompt, betas } = await convertToAnthropicPrompt({
       prompt,
-      sendReasoning: (_d = anthropicOptions == null ? void 0 : anthropicOptions.sendReasoning) != null ? _d : true,
+      sendReasoning: anthropicOptions?.sendReasoning ?? true,
       warnings,
       cacheControlValidator,
-      toolNameMapping
+      toolNameMapping,
+      toolsetNames
     });
-    if (isCustomReasoning(reasoning) && (anthropicOptions == null ? void 0 : anthropicOptions.effort) == null) {
+    if (isCustomReasoning(reasoning) && anthropicOptions?.effort == null) {
       const reasoningConfig = resolveAnthropicReasoningConfig({
         reasoning,
+        modelId,
         supportsAdaptiveThinking,
         supportsXhighEffort,
+        rejectsThinkingDisabled,
+        supportsBetweenToolsThinking,
         maxOutputTokensForModel,
         warnings
       });
@@ -3978,12 +4460,37 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
         if (anthropicOptions.thinking == null) {
           anthropicOptions.thinking = reasoningConfig.thinking;
         }
-        if (reasoningConfig.effort != null && ((_e = anthropicOptions.thinking) == null ? void 0 : _e.type) !== "disabled") {
+        if (reasoningConfig.effort != null && anthropicOptions.thinking?.type !== "disabled") {
           anthropicOptions.effort = reasoningConfig.effort;
         }
       }
     }
-    if (rejectsThinkingDisabledAboveHighEffort && ((_f = anthropicOptions == null ? void 0 : anthropicOptions.thinking) == null ? void 0 : _f.type) === "disabled" && (anthropicOptions.effort === "xhigh" || anthropicOptions.effort === "max")) {
+    if (rejectsThinkingDisabled && anthropicOptions?.thinking != null) {
+      const thinking = anthropicOptions.thinking;
+      if (thinking.type === "disabled" && supportsBetweenToolsThinking) {
+        warnings.push({
+          type: "unsupported",
+          feature: "providerOptions.anthropic.thinking",
+          details: `thinking cannot be disabled for ${modelId}. Using 'between_tools' thinking, the lowest thinking setting, instead.`
+        });
+        anthropicOptions.thinking = { type: "between_tools" };
+      } else if (thinking.type === "disabled") {
+        warnings.push({
+          type: "unsupported",
+          feature: "providerOptions.anthropic.thinking",
+          details: `thinking cannot be disabled for ${modelId}; it always uses adaptive thinking. The thinking setting has been removed. Lower 'effort' to reduce thinking.`
+        });
+        anthropicOptions.thinking = void 0;
+      } else if (thinking.type === "enabled") {
+        warnings.push({
+          type: "unsupported",
+          feature: "providerOptions.anthropic.thinking",
+          details: `budget-based thinking is not supported by ${modelId}; it always uses adaptive thinking. Using adaptive thinking instead. Use 'effort' to control how much the model thinks.`
+        });
+        anthropicOptions.thinking = { type: "adaptive" };
+      }
+    }
+    if (rejectsThinkingDisabledAboveHighEffort && anthropicOptions?.thinking?.type === "disabled" && (anthropicOptions.effort === "xhigh" || anthropicOptions.effort === "max")) {
       warnings.push({
         type: "unsupported",
         feature: "providerOptions.anthropic.effort",
@@ -3991,13 +4498,21 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
       });
       anthropicOptions.effort = "high";
     }
-    const thinkingType = (_g = anthropicOptions == null ? void 0 : anthropicOptions.thinking) == null ? void 0 : _g.type;
-    const isThinking = thinkingType === "enabled" || thinkingType === "adaptive";
-    const thinkingBlockBinding = (anthropicOptions == null ? void 0 : anthropicOptions.thinking) != null && "blockBinding" in anthropicOptions.thinking ? anthropicOptions.thinking.blockBinding : void 0;
+    if (anthropicOptions?.thinking?.type === "between_tools" && (anthropicOptions.effort === "xhigh" || anthropicOptions.effort === "max")) {
+      warnings.push({
+        type: "unsupported",
+        feature: "providerOptions.anthropic.effort",
+        details: `effort '${anthropicOptions.effort}' is not supported with 'between_tools' thinking. The effort has been lowered to 'high'.`
+      });
+      anthropicOptions.effort = "high";
+    }
+    const thinkingType = anthropicOptions?.thinking?.type;
+    const isThinking = thinkingType === "enabled" || thinkingType === "adaptive" || thinkingType === "between_tools";
+    const thinkingBlockBinding = anthropicOptions?.thinking != null && "blockBinding" in anthropicOptions.thinking ? anthropicOptions.thinking.blockBinding : void 0;
     const sendThinking = isThinking || thinkingType === "disabled" || thinkingBlockBinding != null;
-    let thinkingBudget = thinkingType === "enabled" ? (_h = anthropicOptions == null ? void 0 : anthropicOptions.thinking) == null ? void 0 : _h.budgetTokens : void 0;
-    const thinkingDisplay = thinkingType === "adaptive" ? (_i = anthropicOptions == null ? void 0 : anthropicOptions.thinking) == null ? void 0 : _i.display : void 0;
-    const maxTokens = maxOutputTokens != null ? maxOutputTokens : maxOutputTokensForModel;
+    let thinkingBudget = thinkingType === "enabled" ? anthropicOptions?.thinking?.budgetTokens : void 0;
+    const thinkingDisplay = thinkingType === "adaptive" ? anthropicOptions?.thinking?.display : void 0;
+    const maxTokens = maxOutputTokens ?? maxOutputTokensForModel;
     const baseArgs = {
       // model id:
       model: modelId,
@@ -4020,12 +4535,12 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
           }
         }
       },
-      ...((anthropicOptions == null ? void 0 : anthropicOptions.effort) || (anthropicOptions == null ? void 0 : anthropicOptions.taskBudget) || useStructuredOutput && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null) && {
+      ...(anthropicOptions?.effort || anthropicOptions?.taskBudget || useStructuredOutput && responseFormat?.type === "json" && responseFormat.schema != null) && {
         output_config: {
-          ...(anthropicOptions == null ? void 0 : anthropicOptions.effort) && {
+          ...anthropicOptions?.effort && {
             effort: anthropicOptions.effort
           },
-          ...(anthropicOptions == null ? void 0 : anthropicOptions.taskBudget) && {
+          ...anthropicOptions?.taskBudget && {
             task_budget: {
               type: anthropicOptions.taskBudget.type,
               total: anthropicOptions.taskBudget.total,
@@ -4034,7 +4549,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
               }
             }
           },
-          ...useStructuredOutput && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && {
+          ...useStructuredOutput && responseFormat?.type === "json" && responseFormat.schema != null && {
             format: {
               type: "json_schema",
               schema: sanitizeJsonSchema(responseFormat.schema)
@@ -4042,26 +4557,26 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
           }
         }
       },
-      ...(anthropicOptions == null ? void 0 : anthropicOptions.speed) && {
+      ...anthropicOptions?.speed && {
         speed: anthropicOptions.speed
       },
-      ...(anthropicOptions == null ? void 0 : anthropicOptions.serviceTier) && {
+      ...anthropicOptions?.serviceTier && {
         service_tier: anthropicOptions.serviceTier
       },
-      ...(anthropicOptions == null ? void 0 : anthropicOptions.inferenceGeo) && {
+      ...anthropicOptions?.inferenceGeo && {
         inference_geo: anthropicOptions.inferenceGeo
       },
-      ...(anthropicOptions == null ? void 0 : anthropicOptions.fallbacks) != null && (anthropicOptions.fallbacks === "default" || anthropicOptions.fallbacks.length > 0) && {
+      ...anthropicOptions?.fallbacks != null && (anthropicOptions.fallbacks === "default" || anthropicOptions.fallbacks.length > 0) && {
         fallbacks: anthropicOptions.fallbacks
       },
-      ...(anthropicOptions == null ? void 0 : anthropicOptions.cacheControl) && {
+      ...anthropicOptions?.cacheControl && {
         cache_control: anthropicOptions.cacheControl
       },
-      ...((_j = anthropicOptions == null ? void 0 : anthropicOptions.metadata) == null ? void 0 : _j.userId) != null && {
+      ...anthropicOptions?.metadata?.userId != null && {
         metadata: { user_id: anthropicOptions.metadata.userId }
       },
       // mcp servers:
-      ...(anthropicOptions == null ? void 0 : anthropicOptions.mcpServers) && anthropicOptions.mcpServers.length > 0 && {
+      ...anthropicOptions?.mcpServers && anthropicOptions.mcpServers.length > 0 && {
         mcp_servers: anthropicOptions.mcpServers.map((server) => ({
           type: server.type,
           name: server.name,
@@ -4074,7 +4589,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
         }))
       },
       // container: For programmatic tool calling (just an ID string) or agent skills (object with id and skills)
-      ...(anthropicOptions == null ? void 0 : anthropicOptions.container) && {
+      ...anthropicOptions?.container && {
         container: anthropicOptions.container.skills && anthropicOptions.container.skills.length > 0 ? (
           // Object format when skills are provided (agent skills feature)
           {
@@ -4096,6 +4611,22 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
       // prompt:
       system: messagesPrompt.system,
       messages: messagesPrompt.messages,
+      ...anthropicOptions?.safeguards && anthropicOptions.safeguards.length > 0 && {
+        safeguards: anthropicOptions.safeguards.map((safeguard) => ({
+          type: safeguard.type,
+          ...safeguard.classifierContext !== void 0 && {
+            classifier_context: safeguard.classifierContext
+          }
+        }))
+      },
+      ...compaction && {
+        compaction: {
+          type: compaction.type,
+          ...compaction.instructions !== void 0 && {
+            instructions: compaction.instructions
+          }
+        }
+      },
       ...contextManagement && {
         context_management: {
           edits: contextManagement.edits.map((edit) => {
@@ -4184,7 +4715,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
           details: "topP is not supported when thinking is enabled"
         });
       }
-      baseArgs.max_tokens = maxTokens + (thinkingBudget != null ? thinkingBudget : 0);
+      baseArgs.max_tokens = maxTokens + (thinkingBudget ?? 0);
     } else {
       if (isAnthropicModel && topP != null && temperature != null) {
         warnings.push({
@@ -4205,32 +4736,38 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
       }
       baseArgs.max_tokens = maxOutputTokensForModel;
     }
-    if ((anthropicOptions == null ? void 0 : anthropicOptions.mcpServers) && anthropicOptions.mcpServers.length > 0) {
+    if (anthropicOptions?.mcpServers && anthropicOptions.mcpServers.length > 0) {
       betas.add("mcp-client-2025-04-04");
     }
+    if (anthropicOptions?.safeguards && anthropicOptions.safeguards.length > 0) {
+      betas.add("dangerous-tool-use-2026-09-03");
+    }
+    if (compaction) {
+      betas.add("compact-2026-09-04");
+    }
     if (contextManagement) {
       betas.add("context-management-2025-06-27");
       if (contextManagement.edits.some((e) => e.type === "compact_20260112")) {
         betas.add("compact-2026-01-12");
       }
     }
-    if ((anthropicOptions == null ? void 0 : anthropicOptions.container) && anthropicOptions.container.skills && anthropicOptions.container.skills.length > 0) {
+    if (anthropicOptions?.container && anthropicOptions.container.skills && anthropicOptions.container.skills.length > 0) {
       betas.add("code-execution-2025-08-25");
       betas.add("skills-2025-10-02");
       betas.add("files-api-2025-04-14");
-      if (!(tools == null ? void 0 : tools.some(
+      if (!tools?.some(
         (tool) => tool.type === "provider" && (tool.id === "anthropic.code_execution_20250825" || tool.id === "anthropic.code_execution_20260120")
-      ))) {
+      )) {
         warnings.push({
           type: "other",
           message: "code execution tool is required when using skills"
         });
       }
     }
-    if (anthropicOptions == null ? void 0 : anthropicOptions.taskBudget) {
+    if (anthropicOptions?.taskBudget) {
       betas.add("task-budgets-2026-03-13");
     }
-    if ((anthropicOptions == null ? void 0 : anthropicOptions.speed) === "fast") {
+    if (anthropicOptions?.speed === "fast") {
       betas.add("fast-mode-2026-02-01");
     }
     if (thinkingDisplay === "updates") {
@@ -4239,12 +4776,12 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
     if (thinkingBlockBinding != null) {
       betas.add("thinking-binding-controls-2026-08-01");
     }
-    if ((anthropicOptions == null ? void 0 : anthropicOptions.fallbacks) === "default") {
+    if (anthropicOptions?.fallbacks === "default") {
       betas.add("server-side-fallback-2026-07-01");
-    } else if ((anthropicOptions == null ? void 0 : anthropicOptions.fallbacks) && anthropicOptions.fallbacks.length > 0) {
+    } else if (anthropicOptions?.fallbacks && anthropicOptions.fallbacks.length > 0) {
       betas.add("server-side-fallback-2026-06-01");
     }
-    const defaultEagerInputStreaming = stream && ((_k = anthropicOptions == null ? void 0 : anthropicOptions.toolStreaming) != null ? _k : true);
+    const defaultEagerInputStreaming = stream && (anthropicOptions?.toolStreaming ?? true);
     const {
       tools: anthropicTools2,
       toolChoice: anthropicToolChoice,
@@ -4252,21 +4789,23 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
       betas: toolsBetas
     } = await prepareTools(
       jsonResponseTool != null ? {
-        tools: [...tools != null ? tools : [], jsonResponseTool],
+        tools: [...tools ?? [], jsonResponseTool],
         toolChoice: { type: "required" },
         disableParallelToolUse: true,
         cacheControlValidator,
         supportsStructuredOutput: false,
         supportsStrictTools,
-        defaultEagerInputStreaming
+        defaultEagerInputStreaming,
+        rejectsForcedToolUse
       } : {
-        tools: tools != null ? tools : [],
+        tools: tools ?? [],
         toolChoice,
-        disableParallelToolUse: anthropicOptions == null ? void 0 : anthropicOptions.disableParallelToolUse,
+        disableParallelToolUse: anthropicOptions?.disableParallelToolUse,
         cacheControlValidator,
         supportsStructuredOutput,
         supportsStrictTools,
-        defaultEagerInputStreaming
+        defaultEagerInputStreaming,
+        rejectsForcedToolUse
       }
     );
     const cacheWarnings = cacheControlValidator.getWarnings();
@@ -4283,7 +4822,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
         ...betas,
         ...toolsBetas,
         ...userSuppliedBetas,
-        ...(_l = anthropicOptions == null ? void 0 : anthropicOptions.anthropicBeta) != null ? _l : []
+        ...anthropicOptions?.anthropicBeta ?? []
       ]),
       usesJsonResponseTool: jsonResponseTool != null,
       toolNameMapping,
@@ -4309,10 +4848,9 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
     );
   }
   async getBetasFromHeaders(requestHeaders) {
-    var _a, _b;
     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 : "";
+    const configBetaHeader = configHeaders?.["anthropic-beta"] ?? "";
+    const requestBetaHeader = requestHeaders?.["anthropic-beta"] ?? "";
     return new Set(
       [
         ...configBetaHeader.toLowerCase().split(","),
@@ -4321,38 +4859,33 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
     );
   }
   buildRequestUrl(isStreaming) {
-    var _a, _b, _c;
-    return (_c = (_b = (_a = this.config).buildRequestUrl) == null ? void 0 : _b.call(_a, this.config.baseURL, isStreaming)) != null ? _c : `${this.config.baseURL}/messages`;
+    return this.config.buildRequestUrl?.(this.config.baseURL, isStreaming) ?? `${this.config.baseURL}/messages`;
   }
   transformRequestBody(args, betas) {
-    var _a, _b, _c;
-    return (_c = (_b = (_a = this.config).transformRequestBody) == null ? void 0 : _b.call(_a, args, betas)) != null ? _c : args;
+    return this.config.transformRequestBody?.(args, betas) ?? args;
   }
   extractCitationDocuments(prompt) {
     const isCitationPart = (part) => {
-      var _a, _b;
       if (part.type !== "file") {
         return false;
       }
       if (part.mediaType !== "application/pdf" && part.mediaType !== "text/plain") {
         return false;
       }
-      const anthropic2 = (_a = part.providerOptions) == null ? void 0 : _a.anthropic;
-      const citationsConfig = anthropic2 == null ? void 0 : anthropic2.citations;
-      return (_b = citationsConfig == null ? void 0 : citationsConfig.enabled) != null ? _b : false;
+      const anthropic2 = part.providerOptions?.anthropic;
+      const citationsConfig = anthropic2?.citations;
+      return citationsConfig?.enabled ?? false;
     };
     return prompt.filter((message) => message.role === "user").flatMap((message) => message.content).filter(isCitationPart).map((part) => {
-      var _a;
       const filePart = part;
       return {
-        title: (_a = filePart.filename) != null ? _a : "Untitled Document",
+        title: filePart.filename ?? "Untitled Document",
         filename: filePart.filename,
         mediaType: filePart.mediaType
       };
     });
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
     const {
       args,
       warnings,
@@ -4369,9 +4902,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
     const citationDocuments = [
       ...this.extractCitationDocuments(options.prompt)
     ];
-    const markCodeExecutionDynamic = hasWebTool20260209WithoutCodeExecution(
-      args.tools
-    );
+    const markCodeExecutionDynamic = hasDynamicFilteringWebToolWithoutCodeExecution(args.tools);
     const {
       responseHeaders,
       value: response,
@@ -4395,7 +4926,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
       switch (part.type) {
         case "text": {
           if (!usesJsonResponseTool) {
-            const webSearchCitations = (_a = part.citations) == null ? void 0 : _a.filter(
+            const webSearchCitations = part.citations?.filter(
               (citation) => citation.type === "web_search_result_location"
             );
             content.push({
@@ -4457,12 +4988,18 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
           break;
         }
         case "compaction": {
+          if (!part.content) {
+            break;
+          }
           content.push({
             type: "text",
             text: part.content,
             providerMetadata: {
               anthropic: {
-                type: "compaction"
+                type: "compaction",
+                ...part.signature != null && {
+                  signature: part.signature
+                }
               }
             }
           });
@@ -4476,6 +5013,24 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
               type: "text",
               text: JSON.stringify(part.input)
             });
+          } else if (part.toolset_name != null) {
+            content.push({
+              type: "tool-call",
+              toolCallId: part.id,
+              toolName: toolNameMapping.toCustomToolName(part.toolset_name),
+              input: JSON.stringify(
+                toToolsetMemberInput({
+                  memberName: part.name,
+                  input: part.input
+                })
+              ),
+              providerMetadata: {
+                anthropic: {
+                  toolsetName: part.toolset_name,
+                  ...getAnthropicCallerMetadata(part.caller).providerMetadata?.anthropic
+                }
+              }
+            });
           } else {
             content.push({
               type: "tool-call",
@@ -4573,7 +5128,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
         case "web_fetch_tool_result": {
           if (part.content.type === "web_fetch_result") {
             citationDocuments.push({
-              title: (_b = part.content.content.title) != null ? _b : part.content.url,
+              title: part.content.content.title ?? part.content.url,
               mediaType: part.content.content.source.media_type
             });
             content.push({
@@ -4618,16 +5173,13 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
               type: "tool-result",
               toolCallId: part.tool_use_id,
               toolName: toolNameMapping.toCustomToolName("web_search"),
-              result: part.content.map((result) => {
-                var _a2;
-                return {
-                  url: result.url,
-                  ...result.title != null ? { title: result.title } : {},
-                  pageAge: (_a2 = result.page_age) != null ? _a2 : null,
-                  encryptedContent: result.encrypted_content,
-                  type: result.type
-                };
-              }),
+              result: part.content.map((result) => ({
+                url: result.url,
+                ...result.title != null ? { title: result.title } : {},
+                pageAge: result.page_age ?? null,
+                encryptedContent: result.encrypted_content,
+                type: result.type
+              })),
               ...getAnthropicCallerMetadata(part.caller)
             });
             for (const result of part.content) {
@@ -4639,7 +5191,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                 ...result.title != null ? { title: result.title } : {},
                 providerMetadata: {
                   anthropic: {
-                    pageAge: (_c = result.page_age) != null ? _c : null
+                    pageAge: result.page_age ?? null
                   }
                 }
               });
@@ -4671,7 +5223,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                 stdout: part.content.stdout,
                 stderr: part.content.stderr,
                 return_code: part.content.return_code,
-                content: (_d = part.content.content) != null ? _d : []
+                content: part.content.content ?? []
               }
             });
           } else if (part.content.type === "encrypted_code_execution_result") {
@@ -4684,7 +5236,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                 encrypted_stdout: part.content.encrypted_stdout,
                 stderr: part.content.stderr,
                 return_code: part.content.return_code,
-                content: (_e = part.content.content) != null ? _e : []
+                content: part.content.content ?? []
               }
             });
           } else if (part.content.type === "code_execution_tool_result_error") {
@@ -4812,25 +5364,25 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
           finishReason: response.stop_reason,
           isJsonResponseFromTool
         }),
-        raw: (_f = response.stop_reason) != null ? _f : void 0
+        raw: response.stop_reason ?? void 0
       },
       usage: convertAnthropicUsage({ usage: response.usage }),
       request: { body: args },
       response: {
-        id: (_g = response.id) != null ? _g : void 0,
-        modelId: (_h = response.model) != null ? _h : void 0,
+        id: response.id ?? void 0,
+        modelId: response.model ?? void 0,
         headers: responseHeaders,
         body: rawResponse
       },
       warnings,
       providerMetadata: (() => {
-        var _a2, _b2, _c2, _d2;
         const stopDetails = mapAnthropicStopDetails(response.stop_details);
         const anthropicMetadata = {
           usage: response.usage,
-          stopSequence: (_a2 = response.stop_sequence) != null ? _a2 : null,
+          stopSequence: response.stop_sequence ?? null,
           ...stopDetails != null ? { stopDetails } : {},
           ...response.input_transformations != null ? { inputTransformations: response.input_transformations } : {},
+          ...response.safeguard_results != null ? { safeguardResults: response.safeguard_results } : {},
           iterations: response.usage.iterations ? response.usage.iterations.map(
             (iter) => ({
               type: iter.type,
@@ -4848,15 +5400,15 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
           container: response.container ? {
             expiresAt: response.container.expires_at,
             id: response.container.id,
-            skills: (_c2 = (_b2 = response.container.skills) == null ? void 0 : _b2.map((skill) => ({
+            skills: response.container.skills?.map((skill) => ({
               type: skill.type,
               skillId: skill.skill_id,
               version: skill.version
-            }))) != null ? _c2 : null
+            })) ?? null
           } : null,
-          contextManagement: (_d2 = mapAnthropicResponseContextManagement(
+          contextManagement: mapAnthropicResponseContextManagement(
             response.context_management
-          )) != null ? _d2 : null
+          ) ?? null
         };
         const providerMetadata = {
           anthropic: anthropicMetadata
@@ -4870,7 +5422,6 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
   }
   async doStream(options) {
     "use step";
-    var _a, _b, _c, _d;
     const {
       args: body,
       warnings,
@@ -4887,9 +5438,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
     const citationDocuments = [
       ...this.extractCitationDocuments(options.prompt)
     ];
-    const markCodeExecutionDynamic = hasWebTool20260209WithoutCodeExecution(
-      body.tools
-    );
+    const markCodeExecutionDynamic = hasDynamicFilteringWebToolWithoutCodeExecution(body.tools);
     const url = this.buildRequestUrl(true);
     const { responseHeaders, value: response } = await postJsonToApi({
       url,
@@ -4919,6 +5468,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
     let stopSequence = null;
     let stopDetails = void 0;
     let inputTransformations;
+    let safeguardResults;
     let container = null;
     let isJsonResponseFromTool = false;
     let isMessageOpen = false;
@@ -4932,7 +5482,6 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
           controller.enqueue({ type: "stream-start", warnings });
         },
         transform(chunk, controller) {
-          var _a2, _b2, _c2, _d2, _e, _f, _g, _h, _i, _j, _k, _l, _m;
           if (hasInvalidMessageSequence) {
             return;
           }
@@ -5001,10 +5550,20 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                     id: String(value.index),
                     providerMetadata: {
                       anthropic: {
-                        type: "compaction"
+                        type: "compaction",
+                        ...part.signature != null && {
+                          signature: part.signature
+                        }
                       }
                     }
                   });
+                  if (part.signature != null && part.content != null && part.content !== "") {
+                    controller.enqueue({
+                      type: "text-delta",
+                      id: String(value.index),
+                      delta: part.content
+                    });
+                  }
                   return;
                 }
                 case "tool_use": {
@@ -5019,6 +5578,29 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                       type: "text-start",
                       id: String(value.index)
                     });
+                  } else if (part.toolset_name != null) {
+                    const callerInfo = getAnthropicCallerInfo(part.caller);
+                    const customToolName = toolNameMapping.toCustomToolName(
+                      part.toolset_name
+                    );
+                    const hasNonEmptyInput = part.input && Object.keys(part.input).length > 0;
+                    contentBlocks[value.index] = {
+                      type: "tool-call",
+                      toolCallId: part.id,
+                      toolName: customToolName,
+                      input: hasNonEmptyInput ? JSON.stringify(part.input) : "",
+                      firstDelta: true,
+                      toolset: {
+                        name: part.toolset_name,
+                        memberName: part.name
+                      },
+                      ...callerInfo && { caller: callerInfo }
+                    };
+                    controller.enqueue({
+                      type: "tool-input-start",
+                      id: part.id,
+                      toolName: customToolName
+                    });
                   } else {
                     const callerInfo = getAnthropicCallerInfo(part.caller);
                     const hasNonEmptyInput = part.input && Object.keys(part.input).length > 0;
@@ -5127,7 +5709,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                 case "web_fetch_tool_result": {
                   if (part.content.type === "web_fetch_result") {
                     citationDocuments.push({
-                      title: (_a2 = part.content.content.title) != null ? _a2 : part.content.url,
+                      title: part.content.content.title ?? part.content.url,
                       mediaType: part.content.content.source.media_type
                     });
                     controller.enqueue({
@@ -5172,16 +5754,13 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                       type: "tool-result",
                       toolCallId: part.tool_use_id,
                       toolName: toolNameMapping.toCustomToolName("web_search"),
-                      result: part.content.map((result) => {
-                        var _a3;
-                        return {
-                          url: result.url,
-                          ...result.title != null ? { title: result.title } : {},
-                          pageAge: (_a3 = result.page_age) != null ? _a3 : null,
-                          encryptedContent: result.encrypted_content,
-                          type: result.type
-                        };
-                      }),
+                      result: part.content.map((result) => ({
+                        url: result.url,
+                        ...result.title != null ? { title: result.title } : {},
+                        pageAge: result.page_age ?? null,
+                        encryptedContent: result.encrypted_content,
+                        type: result.type
+                      })),
                       ...getAnthropicCallerMetadata(part.caller)
                     });
                     for (const result of part.content) {
@@ -5193,7 +5772,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                         ...result.title != null ? { title: result.title } : {},
                         providerMetadata: {
                           anthropic: {
-                            pageAge: (_b2 = result.page_age) != null ? _b2 : null
+                            pageAge: result.page_age ?? null
                           }
                         }
                       });
@@ -5225,7 +5804,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                         stdout: part.content.stdout,
                         stderr: part.content.stderr,
                         return_code: part.content.return_code,
-                        content: (_c2 = part.content.content) != null ? _c2 : []
+                        content: part.content.content ?? []
                       }
                     });
                   } else if (part.content.type === "encrypted_code_execution_result") {
@@ -5238,7 +5817,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                         encrypted_stdout: part.content.encrypted_stdout,
                         stderr: part.content.stderr,
                         return_code: part.content.return_code,
-                        content: (_d2 = part.content.content) != null ? _d2 : []
+                        content: part.content.content ?? []
                       }
                     });
                   } else if (part.content.type === "code_execution_tool_result_error") {
@@ -5418,6 +5997,25 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                   case "tool-call":
                     const isJsonResponseTool = usesJsonResponseTool && contentBlock.toolName === "json";
                     if (!isJsonResponseTool) {
+                      if (contentBlock.toolset != null) {
+                        let memberInput = {};
+                        try {
+                          memberInput = contentBlock.input === "" ? {} : secureJsonParse2(contentBlock.input);
+                        } catch {
+                          memberInput = void 0;
+                        }
+                        contentBlock.input = memberInput === void 0 ? contentBlock.input : JSON.stringify(
+                          toToolsetMemberInput({
+                            memberName: contentBlock.toolset.memberName,
+                            input: memberInput
+                          })
+                        );
+                        controller.enqueue({
+                          type: "tool-input-delta",
+                          id: contentBlock.toolCallId,
+                          delta: contentBlock.input
+                        });
+                      }
                       controller.enqueue({
                         type: "tool-input-end",
                         id: contentBlock.toolCallId
@@ -5432,7 +6030,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                               ...parsed
                             });
                           }
-                        } catch (e) {
+                        } catch {
                         }
                       }
                       controller.enqueue({
@@ -5446,10 +6044,15 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                         // tool was not explicitly provided. We therefore bypass the general validation by marking the
                         // tool as dynamic.
                         ...markCodeExecutionDynamic && contentBlock.providerToolName === "code_execution" ? { dynamic: true } : {},
-                        ...contentBlock.caller && {
+                        ...(contentBlock.caller || contentBlock.toolset) && {
                           providerMetadata: {
                             anthropic: {
-                              caller: contentBlock.caller
+                              ...contentBlock.toolset && {
+                                toolsetName: contentBlock.toolset.name
+                              },
+                              ...contentBlock.caller && {
+                                caller: contentBlock.caller
+                              }
                             }
                           }
                         }
@@ -5516,7 +6119,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                     return;
                   }
                   if (isJsonResponseFromTool) {
-                    if ((contentBlock == null ? void 0 : contentBlock.type) !== "text") {
+                    if (contentBlock?.type !== "text") {
                       return;
                     }
                     controller.enqueue({
@@ -5525,7 +6128,11 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                       delta
                     });
                   } else {
-                    if ((contentBlock == null ? void 0 : contentBlock.type) !== "tool-call") {
+                    if (contentBlock?.type !== "tool-call") {
+                      return;
+                    }
+                    if (contentBlock.toolset != null) {
+                      contentBlock.input += delta;
                       return;
                     }
                     if (contentBlock.firstDelta && contentBlock.providerToolInputType != null) {
@@ -5544,7 +6151,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                 case "citations_delta": {
                   const citation = value.delta.citation;
                   const contentBlock = contentBlocks[value.index];
-                  if ((contentBlock == null ? void 0 : contentBlock.type) === "text" && citation.type === "web_search_result_location") {
+                  if (contentBlock?.type === "text" && citation.type === "web_search_result_location") {
                     contentBlock.citations.push(citation);
                   }
                   const source = createCitationSource(
@@ -5583,8 +6190,8 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
               isMessageOpen = true;
               activeMessageId = value.message.id;
               usage.input_tokens = value.message.usage.input_tokens;
-              usage.cache_read_input_tokens = (_e = value.message.usage.cache_read_input_tokens) != null ? _e : 0;
-              usage.cache_creation_input_tokens = (_f = value.message.usage.cache_creation_input_tokens) != null ? _f : 0;
+              usage.cache_read_input_tokens = value.message.usage.cache_read_input_tokens ?? 0;
+              usage.cache_creation_input_tokens = value.message.usage.cache_creation_input_tokens ?? 0;
               rawUsage = {
                 ...value.message.usage
               };
@@ -5609,8 +6216,8 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
               }
               controller.enqueue({
                 type: "response-metadata",
-                id: (_g = value.message.id) != null ? _g : void 0,
-                modelId: (_h = value.message.model) != null ? _h : void 0
+                id: value.message.id ?? void 0,
+                modelId: value.message.model ?? void 0
               });
               if (value.message.content != null) {
                 for (let contentIndex = 0; contentIndex < value.message.content.length; contentIndex++) {
@@ -5622,7 +6229,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                       id: part.id,
                       toolName: part.name
                     });
-                    const inputStr = JSON.stringify((_i = part.input) != null ? _i : {});
+                    const inputStr = JSON.stringify(part.input ?? {});
                     controller.enqueue({
                       type: "tool-input-delta",
                       id: part.id,
@@ -5672,18 +6279,18 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                   finishReason: value.delta.stop_reason,
                   isJsonResponseFromTool
                 }),
-                raw: (_j = value.delta.stop_reason) != null ? _j : void 0
+                raw: value.delta.stop_reason ?? void 0
               };
-              stopSequence = (_k = value.delta.stop_sequence) != null ? _k : null;
+              stopSequence = value.delta.stop_sequence ?? null;
               stopDetails = mapAnthropicStopDetails(value.delta.stop_details);
               container = value.delta.container != null ? {
                 expiresAt: value.delta.container.expires_at,
                 id: value.delta.container.id,
-                skills: (_m = (_l = value.delta.container.skills) == null ? void 0 : _l.map((skill) => ({
+                skills: value.delta.container.skills?.map((skill) => ({
                   type: skill.type,
                   skillId: skill.skill_id,
                   version: skill.version
-                }))) != null ? _m : null
+                })) ?? null
               } : null;
               if (value.context_management) {
                 contextManagement = mapAnthropicResponseContextManagement(
@@ -5693,6 +6300,9 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
               if (value.input_transformations != null) {
                 inputTransformations = value.input_transformations;
               }
+              if (value.delta.safeguard_results != null) {
+                safeguardResults = value.delta.safeguard_results;
+              }
               rawUsage = {
                 ...rawUsage,
                 ...value.usage
@@ -5703,10 +6313,11 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
               isMessageOpen = false;
               activeMessageId = void 0;
               const anthropicMetadata = {
-                usage: rawUsage != null ? rawUsage : null,
+                usage: rawUsage ?? null,
                 stopSequence,
                 ...stopDetails != null ? { stopDetails } : {},
                 ...inputTransformations != null ? { inputTransformations } : {},
+                ...safeguardResults != null ? { safeguardResults } : {},
                 iterations: usage.iterations ? usage.iterations.map(
                   (iter) => ({
                     type: iter.type,
@@ -5758,10 +6369,10 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
     try {
       await firstChunkReader.read();
       let result = await firstChunkReader.read();
-      if (((_a = result.value) == null ? void 0 : _a.type) === "raw") {
+      if (result.value?.type === "raw") {
         result = await firstChunkReader.read();
       }
-      if (((_b = result.value) == null ? void 0 : _b.type) === "error") {
+      if (result.value?.type === "error") {
         const error = result.value.error;
         if (!isProviderStreamError(error)) {
           throw new Error("Expected a normalized Anthropic stream error");
@@ -5770,10 +6381,10 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
           message: error.message,
           url,
           requestBodyValues: body,
-          statusCode: (_c = error.statusCode) != null ? _c : 500,
+          statusCode: error.statusCode ?? 500,
           responseHeaders,
           responseBody: JSON.stringify(error.data),
-          isRetryable: (_d = error.isRetryable) != null ? _d : false
+          isRetryable: error.isRetryable ?? false
         });
       }
     } finally {
@@ -5789,7 +6400,33 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
   }
 };
 function getModelCapabilities(modelId) {
-  if (modelId.includes("claude-opus-5")) {
+  if (modelId.includes("claude-sonnet-5-5")) {
+    return {
+      maxOutputTokens: 128e3,
+      supportsStructuredOutput: true,
+      supportsAdaptiveThinking: true,
+      rejectsSamplingParameters: true,
+      supportsXhighEffort: true,
+      rejectsThinkingDisabledAboveHighEffort: true,
+      rejectsThinkingDisabled: true,
+      rejectsForcedToolUse: true,
+      supportsBetweenToolsThinking: true,
+      isKnownModel: true
+    };
+  } else if (modelId.includes("claude-opus-5-5")) {
+    return {
+      maxOutputTokens: 128e3,
+      supportsStructuredOutput: true,
+      supportsAdaptiveThinking: true,
+      rejectsSamplingParameters: true,
+      supportsXhighEffort: true,
+      rejectsThinkingDisabledAboveHighEffort: true,
+      rejectsThinkingDisabled: true,
+      rejectsForcedToolUse: true,
+      supportsBetweenToolsThinking: false,
+      isKnownModel: true
+    };
+  } else if (modelId.includes("claude-opus-5")) {
     return {
       maxOutputTokens: 128e3,
       supportsStructuredOutput: true,
@@ -5797,9 +6434,38 @@ function getModelCapabilities(modelId) {
       rejectsSamplingParameters: true,
       supportsXhighEffort: true,
       rejectsThinkingDisabledAboveHighEffort: true,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
+      isKnownModel: true
+    };
+  } else if (modelId.includes("claude-fable-5-1")) {
+    return {
+      maxOutputTokens: 128e3,
+      supportsStructuredOutput: true,
+      supportsAdaptiveThinking: true,
+      rejectsSamplingParameters: true,
+      supportsXhighEffort: true,
+      rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: true,
+      rejectsForcedToolUse: true,
+      supportsBetweenToolsThinking: false,
+      isKnownModel: true
+    };
+  } else if (modelId.includes("claude-fable-5")) {
+    return {
+      maxOutputTokens: 128e3,
+      supportsStructuredOutput: true,
+      supportsAdaptiveThinking: true,
+      rejectsSamplingParameters: true,
+      supportsXhighEffort: true,
+      rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: true,
+      rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true
     };
-  } else if (modelId.includes("claude-opus-4-8") || modelId.includes("claude-opus-4-7") || modelId.includes("claude-fable-5") || modelId.includes("claude-sonnet-5")) {
+  } else if (modelId.includes("claude-opus-4-8") || modelId.includes("claude-opus-4-7") || modelId.includes("claude-sonnet-5")) {
     return {
       maxOutputTokens: 128e3,
       supportsStructuredOutput: true,
@@ -5807,6 +6473,9 @@ function getModelCapabilities(modelId) {
       rejectsSamplingParameters: true,
       supportsXhighEffort: true,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true
     };
   } else if (modelId.includes("claude-sonnet-4-6") || modelId.includes("claude-opus-4-6")) {
@@ -5817,6 +6486,9 @@ function getModelCapabilities(modelId) {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true
     };
   } else if (modelId.includes("claude-sonnet-4-5") || modelId.includes("claude-opus-4-5") || modelId.includes("claude-haiku-4-5")) {
@@ -5827,6 +6499,9 @@ function getModelCapabilities(modelId) {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true
     };
   } else if (modelId.includes("claude-opus-4-1")) {
@@ -5837,6 +6512,9 @@ function getModelCapabilities(modelId) {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true
     };
   } else if (/claude-sonnet-4(?:-|@)/.test(modelId)) {
@@ -5847,6 +6525,9 @@ function getModelCapabilities(modelId) {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true
     };
   } else if (/claude-opus-4(?:-|@)/.test(modelId)) {
@@ -5857,6 +6538,9 @@ function getModelCapabilities(modelId) {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true
     };
   } else if (modelId.includes("claude-3-haiku")) {
@@ -5867,6 +6551,9 @@ function getModelCapabilities(modelId) {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: true
     };
   } else if (/claude-(?:instant(?:-|$)|v?2(?=$|[-.:])|3(?=$|[-.]))/.test(modelId)) {
@@ -5877,6 +6564,9 @@ function getModelCapabilities(modelId) {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: false
     };
   } else if (modelId.includes("claude-")) {
@@ -5887,6 +6577,9 @@ function getModelCapabilities(modelId) {
       rejectsSamplingParameters: true,
       supportsXhighEffort: true,
       rejectsThinkingDisabledAboveHighEffort: true,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: false
     };
   } else {
@@ -5897,19 +6590,22 @@ function getModelCapabilities(modelId) {
       rejectsSamplingParameters: false,
       supportsXhighEffort: false,
       rejectsThinkingDisabledAboveHighEffort: false,
+      rejectsThinkingDisabled: false,
+      rejectsForcedToolUse: false,
+      supportsBetweenToolsThinking: false,
       isKnownModel: false
     };
   }
 }
-function hasWebTool20260209WithoutCodeExecution(tools) {
+function hasDynamicFilteringWebToolWithoutCodeExecution(tools) {
   if (!tools) {
     return false;
   }
-  let hasWebTool20260209 = false;
+  let hasDynamicFilteringWebTool = false;
   let hasCodeExecutionTool = false;
   for (const tool of tools) {
-    if ("type" in tool && (tool.type === "web_fetch_20260209" || tool.type === "web_search_20260209")) {
-      hasWebTool20260209 = true;
+    if ("type" in tool && (tool.type === "web_fetch_20260209" || tool.type === "web_fetch_20260318" || tool.type === "web_search_20260209" || tool.type === "web_search_20260318")) {
+      hasDynamicFilteringWebTool = true;
       continue;
     }
     if ("type" in tool && (tool.type === "code_execution_20250522" || tool.type === "code_execution_20250825" || tool.type === "code_execution_20260120")) {
@@ -5917,12 +6613,15 @@ function hasWebTool20260209WithoutCodeExecution(tools) {
       break;
     }
   }
-  return hasWebTool20260209 && !hasCodeExecutionTool;
+  return hasDynamicFilteringWebTool && !hasCodeExecutionTool;
 }
 function resolveAnthropicReasoningConfig({
   reasoning,
+  modelId,
   supportsAdaptiveThinking,
   supportsXhighEffort,
+  rejectsThinkingDisabled,
+  supportsBetweenToolsThinking,
   maxOutputTokensForModel,
   warnings
 }) {
@@ -5930,6 +6629,17 @@ function resolveAnthropicReasoningConfig({
     return void 0;
   }
   if (reasoning === "none") {
+    if (supportsBetweenToolsThinking) {
+      return { thinking: { type: "between_tools" } };
+    }
+    if (rejectsThinkingDisabled) {
+      warnings.push({
+        type: "compatibility",
+        feature: "reasoning",
+        details: `reasoning 'none' is not supported by ${modelId}; it always uses adaptive thinking. Using effort 'low' to minimize thinking instead.`
+      });
+      return { effort: "low" };
+    }
     return { thinking: { type: "disabled" } };
   }
   if (supportsAdaptiveThinking) {
@@ -5999,7 +6709,7 @@ function mapAnthropicStopDetails(stopDetails) {
 
 // src/anthropic-batch.ts
 import {
-  InvalidArgumentError,
+  InvalidArgumentError as InvalidArgumentError2,
   InvalidResponseDataError as InvalidResponseDataError2,
   UnsupportedFunctionalityError as UnsupportedFunctionalityError3
 } from "@ai-sdk/provider";
@@ -6011,47 +6721,47 @@ import {
   generateId as generateId2,
   getFromApi,
   isRecord as isRecord2,
-  lazySchema as lazySchema14,
+  lazySchema as lazySchema17,
   normalizeBatchRequestCounts,
   normalizeHeaders,
   parseProviderOptions as parseProviderOptions3,
   postJsonToApi as postJsonToApi2,
   resolve as resolve2,
   safeValidateTypes,
-  zodSchema as zodSchema14
+  zodSchema as zodSchema17
 } from "@ai-sdk/provider-utils";
-import { z as z15 } from "zod/v4";
+import { z as z18 } from "zod/v4";
 var anthropicBatchRequestIdPattern = /^[A-Za-z0-9_-]{1,64}$/;
 var anthropicBatchProviderOptionsSchema = anthropicLanguageModelOptions.pick({
   anthropicBeta: true
 });
-var anthropicBatchResponseZodSchema = () => z15.object({
-  id: z15.string(),
-  type: z15.literal("message_batch"),
-  processing_status: z15.string(),
-  request_counts: z15.object({
-    processing: z15.number(),
-    succeeded: z15.number(),
-    errored: z15.number(),
-    canceled: z15.number(),
-    expired: z15.number()
+var anthropicBatchResponseZodSchema = () => z18.object({
+  id: z18.string(),
+  type: z18.literal("message_batch"),
+  processing_status: z18.string(),
+  request_counts: z18.object({
+    processing: z18.number(),
+    succeeded: z18.number(),
+    errored: z18.number(),
+    canceled: z18.number(),
+    expired: z18.number()
   }),
-  created_at: z15.string(),
-  expires_at: z15.string(),
-  archived_at: z15.string().nullish(),
-  cancel_initiated_at: z15.string().nullish(),
-  ended_at: z15.string().nullish(),
-  results_url: z15.string().nullish()
+  created_at: z18.string(),
+  expires_at: z18.string(),
+  archived_at: z18.string().nullish(),
+  cancel_initiated_at: z18.string().nullish(),
+  ended_at: z18.string().nullish(),
+  results_url: z18.string().nullish()
 });
-var anthropicBatchResponseSchema = lazySchema14(
-  () => zodSchema14(anthropicBatchResponseZodSchema())
+var anthropicBatchResponseSchema = lazySchema17(
+  () => zodSchema17(anthropicBatchResponseZodSchema())
 );
-var anthropicBatchListResponseSchema = lazySchema14(
-  () => zodSchema14(
-    z15.object({
-      data: z15.array(anthropicBatchResponseZodSchema()),
-      has_more: z15.boolean(),
-      last_id: z15.string().nullish()
+var anthropicBatchListResponseSchema = lazySchema17(
+  () => zodSchema17(
+    z18.object({
+      data: z18.array(anthropicBatchResponseZodSchema()),
+      has_more: z18.boolean(),
+      last_id: z18.string().nullish()
     })
   )
 );
@@ -6074,34 +6784,34 @@ var knownAnthropicBatchContentTypes = /* @__PURE__ */ new Set([
   "web_fetch_tool_result",
   "web_search_tool_result"
 ]);
-var anthropicBatchResultSchema = lazySchema14(
-  () => zodSchema14(
-    z15.discriminatedUnion("type", [
-      z15.object({
-        type: z15.literal("succeeded"),
-        message: z15.unknown()
+var anthropicBatchResultSchema = lazySchema17(
+  () => zodSchema17(
+    z18.discriminatedUnion("type", [
+      z18.object({
+        type: z18.literal("succeeded"),
+        message: z18.unknown()
       }),
-      z15.object({
-        type: z15.literal("errored"),
-        error: z15.object({
-          type: z15.literal("error"),
-          error: z15.object({
-            type: z15.string(),
-            message: z15.string()
+      z18.object({
+        type: z18.literal("errored"),
+        error: z18.object({
+          type: z18.literal("error"),
+          error: z18.object({
+            type: z18.string(),
+            message: z18.string()
           }),
-          request_id: z15.string().nullish()
+          request_id: z18.string().nullish()
         })
       }),
-      z15.object({ type: z15.literal("canceled") }),
-      z15.object({ type: z15.literal("expired") })
+      z18.object({ type: z18.literal("canceled") }),
+      z18.object({ type: z18.literal("expired") })
     ])
   )
 );
-var anthropicBatchResultLineSchema = lazySchema14(
-  () => zodSchema14(
-    z15.object({
-      custom_id: z15.string(),
-      result: z15.unknown()
+var anthropicBatchResultLineSchema = lazySchema17(
+  () => zodSchema17(
+    z18.object({
+      custom_id: z18.string(),
+      result: z18.unknown()
     })
   )
 );
@@ -6120,10 +6830,9 @@ var AnthropicBatch = class {
   constructor(options) {
     this.options = options;
     this.specificationVersion = "v4";
-    var _a;
     this.provider = options.provider;
     this.supportedUrls = options.supportedUrls;
-    this.generateId = (_a = options.config.generateId) != null ? _a : generateId2;
+    this.generateId = options.config.generateId ?? generateId2;
   }
   async doStartBatch({
     requests,
@@ -6132,7 +6841,6 @@ var AnthropicBatch = class {
     abortSignal,
     webhookUrl
   }) {
-    var _a, _b, _c, _d;
     assertTextBatchRequests(requests);
     validateRequestIds(requests);
     const explicitBatchBetas = new Set(
@@ -6178,7 +6886,7 @@ var AnthropicBatch = class {
           message: `Anthropic Message Batches cannot decode the JSON-tool structured-output fallback (request "${request.id}") because batch results are retrieved independently of the start call. Use a model that supports native output_format structured outputs.`
         });
       }
-      const aliasedProviderTool = (_a = request.options.tools) == null ? void 0 : _a.find(
+      const aliasedProviderTool = request.options.tools?.find(
         (tool) => tool.type === "provider" && prepared.toolNameMapping.toProviderToolName(tool.name) !== tool.name
       );
       if (aliasedProviderTool != null) {
@@ -6187,11 +6895,10 @@ var AnthropicBatch = class {
           message: `Anthropic Message Batches cannot restore the custom provider-tool name "${aliasedProviderTool.name}" when results are retrieved independently of the start call (request "${request.id}"). Use the provider's canonical tool name.`
         });
       }
-      const body = (_d = (_c = (_b = this.options.config).transformRequestBody) == null ? void 0 : _c.call(
-        _b,
+      const body = this.options.config.transformRequestBody?.(
         prepared.args,
         prepared.betas
-      )) != null ? _d : prepared.args;
+      ) ?? prepared.args;
       validateAnthropicBatchBody({
         body,
         requestId: request.id
@@ -6268,13 +6975,13 @@ var AnthropicBatch = class {
   async doGetBatchResults(options) {
     const batch = await this.retrieveBatch(options);
     if (convertAnthropicBatchStatus(batch).status === "pending") {
-      throw new InvalidArgumentError({
+      throw new InvalidArgumentError2({
         argument: "batchId",
         message: `Anthropic batch "${options.batchId}" is not complete.`
       });
     }
     if (batch.archived_at != null) {
-      throw new InvalidArgumentError({
+      throw new InvalidArgumentError2({
         argument: "batchId",
         message: `Anthropic batch "${options.batchId}" results are no longer available.`
       });
@@ -6346,7 +7053,6 @@ async function getAnthropicBatchProviderBetas({
   provider,
   providerOptions
 }) {
-  var _a;
   const providerOptionsName = provider.split(".")[0];
   const canonicalOptions = await parseProviderOptions3({
     provider: "anthropic",
@@ -6360,22 +7066,22 @@ async function getAnthropicBatchProviderBetas({
   }) : void 0;
   const anthropicOptions = Object.assign(
     {},
-    canonicalOptions != null ? canonicalOptions : {},
-    customOptions != null ? customOptions : {}
+    canonicalOptions ?? {},
+    customOptions ?? {}
   );
-  return (_a = anthropicOptions.anthropicBeta) != null ? _a : [];
+  return anthropicOptions.anthropicBeta ?? [];
 }
 function validateRequestIds(requests) {
   const ids = /* @__PURE__ */ new Set();
   for (const request of requests) {
     if (!anthropicBatchRequestIdPattern.test(request.id)) {
-      throw new InvalidArgumentError({
+      throw new InvalidArgumentError2({
         argument: "requests",
         message: `Anthropic batch request ID "${request.id}" must match ^[A-Za-z0-9_-]{1,64}$.`
       });
     }
     if (ids.has(request.id)) {
-      throw new InvalidArgumentError({
+      throw new InvalidArgumentError2({
         argument: "requests",
         message: `Anthropic batch request IDs must be unique; duplicate ID "${request.id}".`
       });
@@ -6403,7 +7109,6 @@ function validateAnthropicBatchBody({
   }
 }
 function convertAnthropicBatchStatus(batch) {
-  var _a, _b, _c, _d;
   const requestCounts = convertAnthropicRequestCounts(batch.request_counts);
   return {
     status: mapAnthropicBatchStatus(batch.processing_status),
@@ -6413,11 +7118,11 @@ function convertAnthropicBatchStatus(batch) {
     expiresAt: batch.expires_at,
     providerMetadata: {
       anthropic: {
-        archivedAt: (_a = batch.archived_at) != null ? _a : null,
-        cancelInitiatedAt: (_b = batch.cancel_initiated_at) != null ? _b : null,
-        endedAt: (_c = batch.ended_at) != null ? _c : null,
+        archivedAt: batch.archived_at ?? null,
+        cancelInitiatedAt: batch.cancel_initiated_at ?? null,
+        endedAt: batch.ended_at ?? null,
         requestCounts: batch.request_counts,
-        resultsUrl: (_d = batch.results_url) != null ? _d : null
+        resultsUrl: batch.results_url ?? null
       }
     }
   };
@@ -6529,7 +7234,6 @@ async function parseAnthropicBatchResponse(message) {
   return recovered.success ? recovered.value : void 0;
 }
 function convertAnthropicBatchResponse(response, generateId4) {
-  var _a, _b, _c, _d, _e, _f, _g, _h;
   const content = [];
   const mcpToolCalls = {};
   const serverToolCalls = {};
@@ -6546,7 +7250,7 @@ function convertAnthropicBatchResponse(response, generateId4) {
             }
           }
         });
-        for (const citation of (_a = part.citations) != null ? _a : []) {
+        for (const citation of part.citations ?? []) {
           const source = createCitationSource(citation, [], generateId4);
           if (source != null) {
             content.push(source);
@@ -6583,10 +7287,18 @@ function convertAnthropicBatchResponse(response, generateId4) {
         });
         break;
       case "compaction":
+        if (!part.content) {
+          break;
+        }
         content.push({
           type: "text",
           text: part.content,
-          providerMetadata: { anthropic: { type: "compaction" } }
+          providerMetadata: {
+            anthropic: {
+              type: "compaction",
+              ...part.signature != null && { signature: part.signature }
+            }
+          }
         });
         break;
       case "tool_use":
@@ -6610,7 +7322,7 @@ function convertAnthropicBatchResponse(response, generateId4) {
           toolCallId: part.id,
           toolName,
           input: JSON.stringify(
-            isCodeExecutionAlias ? { type: part.name, ...(_b = part.input) != null ? _b : {} } : part.name === "code_execution" && part.input != null && "code" in part.input && !("type" in part.input) ? { type: "programmatic-tool-call", ...part.input } : part.input
+            isCodeExecutionAlias ? { type: part.name, ...part.input } : part.name === "code_execution" && part.input != null && "code" in part.input && !("type" in part.input) ? { type: "programmatic-tool-call", ...part.input } : part.input
           ),
           providerExecuted: true,
           // Batch results are retrieved without the original request tools, so
@@ -6644,11 +7356,11 @@ function convertAnthropicBatchResponse(response, generateId4) {
         content.push({
           type: "tool-result",
           toolCallId: part.tool_use_id,
-          toolName: (_c = toolCall == null ? void 0 : toolCall.toolName) != null ? _c : "mcp",
+          toolName: toolCall?.toolName ?? "mcp",
           isError: part.is_error,
           result: part.content,
           dynamic: true,
-          ...(toolCall == null ? void 0 : toolCall.providerMetadata) != null && {
+          ...toolCall?.providerMetadata != null && {
             providerMetadata: toolCall.providerMetadata
           }
         });
@@ -6691,16 +7403,13 @@ function convertAnthropicBatchResponse(response, generateId4) {
           toolCallId: part.tool_use_id,
           toolName: "web_search",
           ...Array.isArray(part.content) ? {
-            result: part.content.map((result) => {
-              var _a2;
-              return {
-                encryptedContent: result.encrypted_content,
-                pageAge: (_a2 = result.page_age) != null ? _a2 : null,
-                ...result.title != null ? { title: result.title } : {},
-                type: result.type,
-                url: result.url
-              };
-            })
+            result: part.content.map((result) => ({
+              encryptedContent: result.encrypted_content,
+              pageAge: result.page_age ?? null,
+              ...result.title != null ? { title: result.title } : {},
+              type: result.type,
+              url: result.url
+            }))
           } : {
             isError: true,
             result: {
@@ -6720,7 +7429,7 @@ function convertAnthropicBatchResponse(response, generateId4) {
               ...result.title != null ? { title: result.title } : {},
               providerMetadata: {
                 anthropic: {
-                  pageAge: (_d = result.page_age) != null ? _d : null
+                  pageAge: result.page_age ?? null
                 }
               }
             });
@@ -6751,7 +7460,7 @@ function convertAnthropicBatchResponse(response, generateId4) {
         });
         break;
       case "tool_search_tool_result": {
-        const toolName = (_e = serverToolCalls[part.tool_use_id]) != null ? _e : "tool_search_tool_regex";
+        const toolName = serverToolCalls[part.tool_use_id] ?? "tool_search_tool_regex";
         content.push({
           type: "tool-result",
           toolCallId: part.tool_use_id,
@@ -6817,12 +7526,12 @@ function convertAnthropicBatchResponse(response, generateId4) {
       unified: mapAnthropicStopReason({
         finishReason: response.stop_reason
       }),
-      raw: (_f = response.stop_reason) != null ? _f : void 0
+      raw: response.stop_reason ?? void 0
     },
     usage: convertAnthropicUsage({ usage: response.usage }),
     response: {
-      id: (_g = response.id) != null ? _g : void 0,
-      modelId: (_h = response.model) != null ? _h : void 0
+      id: response.id ?? void 0,
+      modelId: response.model ?? void 0
     },
     warnings: [],
     providerMetadata: {
@@ -6843,13 +7552,13 @@ function anthropicCallerMetadata(caller) {
   };
 }
 function convertAnthropicMessageMetadata(response) {
-  var _a, _b, _c;
   const stopDetails = mapAnthropicStopDetails2(response.stop_details);
   return {
     usage: response.usage,
-    stopSequence: (_a = response.stop_sequence) != null ? _a : null,
+    stopSequence: response.stop_sequence ?? null,
     ...stopDetails != null ? { stopDetails } : {},
     ...response.input_transformations != null ? { inputTransformations: response.input_transformations } : {},
+    ...response.safeguard_results != null ? { safeguardResults: response.safeguard_results } : {},
     iterations: response.usage.iterations ? response.usage.iterations.map(
       (iteration) => ({
         type: iteration.type,
@@ -6865,11 +7574,11 @@ function convertAnthropicMessageMetadata(response) {
     container: response.container ? {
       expiresAt: response.container.expires_at,
       id: response.container.id,
-      skills: (_c = (_b = response.container.skills) == null ? void 0 : _b.map((skill) => ({
+      skills: response.container.skills?.map((skill) => ({
         type: skill.type,
         skillId: skill.skill_id,
         version: skill.version
-      }))) != null ? _c : null
+      })) ?? null
     } : null,
     contextManagement: mapAnthropicResponseContextManagement2(
       response.context_management
@@ -6912,20 +7621,20 @@ function mapAnthropicStopDetails2(stopDetails) {
 
 // src/tool/bash_20241022.ts
 import {
-  createProviderDefinedToolFactory as createProviderDefinedToolFactory2,
-  lazySchema as lazySchema15,
-  zodSchema as zodSchema15
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory3,
+  lazySchema as lazySchema18,
+  zodSchema as zodSchema18
 } from "@ai-sdk/provider-utils";
-import { z as z16 } from "zod/v4";
-var bash_20241022InputSchema = lazySchema15(
-  () => zodSchema15(
-    z16.object({
-      command: z16.string(),
-      restart: z16.boolean().optional()
+import { z as z19 } from "zod/v4";
+var bash_20241022InputSchema = lazySchema18(
+  () => zodSchema18(
+    z19.object({
+      command: z19.string(),
+      restart: z19.boolean().optional()
     })
   )
 );
-var bash_20241022_internal = createProviderDefinedToolFactory2({
+var bash_20241022_internal = createProviderDefinedToolFactory3({
   id: "anthropic.bash_20241022",
   inputSchema: bash_20241022InputSchema
 });
@@ -6953,20 +7662,20 @@ function bash_20241022(options = {}) {
 
 // src/tool/bash_20250124.ts
 import {
-  createProviderDefinedToolFactory as createProviderDefinedToolFactory3,
-  lazySchema as lazySchema16,
-  zodSchema as zodSchema16
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory4,
+  lazySchema as lazySchema19,
+  zodSchema as zodSchema19
 } from "@ai-sdk/provider-utils";
-import { z as z17 } from "zod/v4";
-var bash_20250124InputSchema = lazySchema16(
-  () => zodSchema16(
-    z17.object({
-      command: z17.string(),
-      restart: z17.boolean().optional()
+import { z as z20 } from "zod/v4";
+var bash_20250124InputSchema = lazySchema19(
+  () => zodSchema19(
+    z20.object({
+      command: z20.string(),
+      restart: z20.boolean().optional()
     })
   )
 );
-var bash_20250124_internal = createProviderDefinedToolFactory3({
+var bash_20250124_internal = createProviderDefinedToolFactory4({
   id: "anthropic.bash_20250124",
   inputSchema: bash_20250124InputSchema
 });
@@ -6994,15 +7703,15 @@ function bash_20250124(options = {}) {
 
 // src/tool/computer_20241022.ts
 import {
-  createProviderDefinedToolFactory as createProviderDefinedToolFactory4,
-  lazySchema as lazySchema17,
-  zodSchema as zodSchema17
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory5,
+  lazySchema as lazySchema20,
+  zodSchema as zodSchema20
 } from "@ai-sdk/provider-utils";
-import { z as z18 } from "zod/v4";
-var computer_20241022InputSchema = lazySchema17(
-  () => zodSchema17(
-    z18.object({
-      action: z18.enum([
+import { z as z21 } from "zod/v4";
+var computer_20241022InputSchema = lazySchema20(
+  () => zodSchema20(
+    z21.object({
+      action: z21.enum([
         "key",
         "type",
         "mouse_move",
@@ -7014,27 +7723,27 @@ var computer_20241022InputSchema = lazySchema17(
         "screenshot",
         "cursor_position"
       ]),
-      coordinate: z18.array(z18.number().int()).optional(),
-      text: z18.string().optional()
+      coordinate: z21.array(z21.number().int()).optional(),
+      text: z21.string().optional()
     })
   )
 );
-var computer_20241022 = createProviderDefinedToolFactory4({
+var computer_20241022 = createProviderDefinedToolFactory5({
   id: "anthropic.computer_20241022",
   inputSchema: computer_20241022InputSchema
 });
 
 // src/tool/computer_20250124.ts
 import {
-  createProviderDefinedToolFactory as createProviderDefinedToolFactory5,
-  lazySchema as lazySchema18,
-  zodSchema as zodSchema18
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory6,
+  lazySchema as lazySchema21,
+  zodSchema as zodSchema21
 } from "@ai-sdk/provider-utils";
-import { z as z19 } from "zod/v4";
-var computer_20250124InputSchema = lazySchema18(
-  () => zodSchema18(
-    z19.object({
-      action: z19.enum([
+import { z as z22 } from "zod/v4";
+var computer_20250124InputSchema = lazySchema21(
+  () => zodSchema21(
+    z22.object({
+      action: z22.enum([
         "key",
         "hold_key",
         "type",
@@ -7052,31 +7761,31 @@ var computer_20250124InputSchema = lazySchema18(
         "wait",
         "screenshot"
       ]),
-      coordinate: z19.tuple([z19.number().int(), z19.number().int()]).optional(),
-      duration: z19.number().optional(),
-      scroll_amount: z19.number().optional(),
-      scroll_direction: z19.enum(["up", "down", "left", "right"]).optional(),
-      start_coordinate: z19.tuple([z19.number().int(), z19.number().int()]).optional(),
-      text: z19.string().optional()
+      coordinate: z22.tuple([z22.number().int(), z22.number().int()]).optional(),
+      duration: z22.number().optional(),
+      scroll_amount: z22.number().optional(),
+      scroll_direction: z22.enum(["up", "down", "left", "right"]).optional(),
+      start_coordinate: z22.tuple([z22.number().int(), z22.number().int()]).optional(),
+      text: z22.string().optional()
     })
   )
 );
-var computer_20250124 = createProviderDefinedToolFactory5({
+var computer_20250124 = createProviderDefinedToolFactory6({
   id: "anthropic.computer_20250124",
   inputSchema: computer_20250124InputSchema
 });
 
 // src/tool/computer_20251124.ts
 import {
-  createProviderDefinedToolFactory as createProviderDefinedToolFactory6,
-  lazySchema as lazySchema19,
-  zodSchema as zodSchema19
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory7,
+  lazySchema as lazySchema22,
+  zodSchema as zodSchema22
 } from "@ai-sdk/provider-utils";
-import { z as z20 } from "zod/v4";
-var computer_20251124InputSchema = lazySchema19(
-  () => zodSchema19(
-    z20.object({
-      action: z20.enum([
+import { z as z23 } from "zod/v4";
+var computer_20251124InputSchema = lazySchema22(
+  () => zodSchema22(
+    z23.object({
+      action: z23.enum([
         "key",
         "hold_key",
         "type",
@@ -7095,193 +7804,193 @@ var computer_20251124InputSchema = lazySchema19(
         "screenshot",
         "zoom"
       ]),
-      coordinate: z20.tuple([z20.number().int(), z20.number().int()]).optional(),
-      duration: z20.number().optional(),
-      region: z20.tuple([
-        z20.number().int(),
-        z20.number().int(),
-        z20.number().int(),
-        z20.number().int()
+      coordinate: z23.tuple([z23.number().int(), z23.number().int()]).optional(),
+      duration: z23.number().optional(),
+      region: z23.tuple([
+        z23.number().int(),
+        z23.number().int(),
+        z23.number().int(),
+        z23.number().int()
       ]).optional(),
-      scroll_amount: z20.number().optional(),
-      scroll_direction: z20.enum(["up", "down", "left", "right"]).optional(),
-      start_coordinate: z20.tuple([z20.number().int(), z20.number().int()]).optional(),
-      text: z20.string().optional()
+      scroll_amount: z23.number().optional(),
+      scroll_direction: z23.enum(["up", "down", "left", "right"]).optional(),
+      start_coordinate: z23.tuple([z23.number().int(), z23.number().int()]).optional(),
+      text: z23.string().optional()
     })
   )
 );
-var computer_20251124 = createProviderDefinedToolFactory6({
+var computer_20251124 = createProviderDefinedToolFactory7({
   id: "anthropic.computer_20251124",
   inputSchema: computer_20251124InputSchema
 });
 
 // src/tool/memory_20250818.ts
 import {
-  createProviderDefinedToolFactory as createProviderDefinedToolFactory7,
-  lazySchema as lazySchema20,
-  zodSchema as zodSchema20
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory8,
+  lazySchema as lazySchema23,
+  zodSchema as zodSchema23
 } from "@ai-sdk/provider-utils";
-import { z as z21 } from "zod/v4";
-var memory_20250818InputSchema = lazySchema20(
-  () => zodSchema20(
-    z21.discriminatedUnion("command", [
-      z21.object({
-        command: z21.literal("view"),
-        path: z21.string(),
-        view_range: z21.tuple([z21.number(), z21.number()]).optional()
+import { z as z24 } from "zod/v4";
+var memory_20250818InputSchema = lazySchema23(
+  () => zodSchema23(
+    z24.discriminatedUnion("command", [
+      z24.object({
+        command: z24.literal("view"),
+        path: z24.string(),
+        view_range: z24.tuple([z24.number(), z24.number()]).optional()
       }),
-      z21.object({
-        command: z21.literal("create"),
-        path: z21.string(),
-        file_text: z21.string()
+      z24.object({
+        command: z24.literal("create"),
+        path: z24.string(),
+        file_text: z24.string()
       }),
-      z21.object({
-        command: z21.literal("str_replace"),
-        path: z21.string(),
-        old_str: z21.string(),
-        new_str: z21.string()
+      z24.object({
+        command: z24.literal("str_replace"),
+        path: z24.string(),
+        old_str: z24.string(),
+        new_str: z24.string()
       }),
-      z21.object({
-        command: z21.literal("insert"),
-        path: z21.string(),
-        insert_line: z21.number(),
-        insert_text: z21.string()
+      z24.object({
+        command: z24.literal("insert"),
+        path: z24.string(),
+        insert_line: z24.number(),
+        insert_text: z24.string()
       }),
-      z21.object({
-        command: z21.literal("delete"),
-        path: z21.string()
+      z24.object({
+        command: z24.literal("delete"),
+        path: z24.string()
       }),
-      z21.object({
-        command: z21.literal("rename"),
-        old_path: z21.string(),
-        new_path: z21.string()
+      z24.object({
+        command: z24.literal("rename"),
+        old_path: z24.string(),
+        new_path: z24.string()
       })
     ])
   )
 );
-var memory_20250818 = createProviderDefinedToolFactory7({
+var memory_20250818 = createProviderDefinedToolFactory8({
   id: "anthropic.memory_20250818",
   inputSchema: memory_20250818InputSchema
 });
 
 // src/tool/text-editor_20241022.ts
 import {
-  createProviderDefinedToolFactory as createProviderDefinedToolFactory8,
-  lazySchema as lazySchema21,
-  zodSchema as zodSchema21
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory9,
+  lazySchema as lazySchema24,
+  zodSchema as zodSchema24
 } from "@ai-sdk/provider-utils";
-import { z as z22 } from "zod/v4";
-var textEditor_20241022InputSchema = lazySchema21(
-  () => zodSchema21(
-    z22.object({
-      command: z22.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
-      path: z22.string(),
-      file_text: z22.string().optional(),
-      insert_line: z22.number().int().optional(),
-      new_str: z22.string().optional(),
-      insert_text: z22.string().optional(),
-      old_str: z22.string().optional(),
-      view_range: z22.array(z22.number().int()).optional()
+import { z as z25 } from "zod/v4";
+var textEditor_20241022InputSchema = lazySchema24(
+  () => zodSchema24(
+    z25.object({
+      command: z25.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
+      path: z25.string(),
+      file_text: z25.string().optional(),
+      insert_line: z25.number().int().optional(),
+      new_str: z25.string().optional(),
+      insert_text: z25.string().optional(),
+      old_str: z25.string().optional(),
+      view_range: z25.array(z25.number().int()).optional()
     })
   )
 );
-var textEditor_20241022 = createProviderDefinedToolFactory8({
+var textEditor_20241022 = createProviderDefinedToolFactory9({
   id: "anthropic.text_editor_20241022",
   inputSchema: textEditor_20241022InputSchema
 });
 
 // src/tool/text-editor_20250124.ts
 import {
-  createProviderDefinedToolFactory as createProviderDefinedToolFactory9,
-  lazySchema as lazySchema22,
-  zodSchema as zodSchema22
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory10,
+  lazySchema as lazySchema25,
+  zodSchema as zodSchema25
 } from "@ai-sdk/provider-utils";
-import { z as z23 } from "zod/v4";
-var textEditor_20250124InputSchema = lazySchema22(
-  () => zodSchema22(
-    z23.object({
-      command: z23.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
-      path: z23.string(),
-      file_text: z23.string().optional(),
-      insert_line: z23.number().int().optional(),
-      new_str: z23.string().optional(),
-      insert_text: z23.string().optional(),
-      old_str: z23.string().optional(),
-      view_range: z23.array(z23.number().int()).optional()
+import { z as z26 } from "zod/v4";
+var textEditor_20250124InputSchema = lazySchema25(
+  () => zodSchema25(
+    z26.object({
+      command: z26.enum(["view", "create", "str_replace", "insert", "undo_edit"]),
+      path: z26.string(),
+      file_text: z26.string().optional(),
+      insert_line: z26.number().int().optional(),
+      new_str: z26.string().optional(),
+      insert_text: z26.string().optional(),
+      old_str: z26.string().optional(),
+      view_range: z26.array(z26.number().int()).optional()
     })
   )
 );
-var textEditor_20250124 = createProviderDefinedToolFactory9({
+var textEditor_20250124 = createProviderDefinedToolFactory10({
   id: "anthropic.text_editor_20250124",
   inputSchema: textEditor_20250124InputSchema
 });
 
 // src/tool/text-editor_20250429.ts
 import {
-  createProviderDefinedToolFactory as createProviderDefinedToolFactory10,
-  lazySchema as lazySchema23,
-  zodSchema as zodSchema23
+  createProviderDefinedToolFactory as createProviderDefinedToolFactory11,
+  lazySchema as lazySchema26,
+  zodSchema as zodSchema26
 } from "@ai-sdk/provider-utils";
-import { z as z24 } from "zod/v4";
-var textEditor_20250429InputSchema = lazySchema23(
-  () => zodSchema23(
-    z24.object({
-      command: z24.enum(["view", "create", "str_replace", "insert"]),
-      path: z24.string(),
-      file_text: z24.string().optional(),
-      insert_line: z24.number().int().optional(),
-      new_str: z24.string().optional(),
-      insert_text: z24.string().optional(),
-      old_str: z24.string().optional(),
-      view_range: z24.array(z24.number().int()).optional()
+import { z as z27 } from "zod/v4";
+var textEditor_20250429InputSchema = lazySchema26(
+  () => zodSchema26(
+    z27.object({
+      command: z27.enum(["view", "create", "str_replace", "insert"]),
+      path: z27.string(),
+      file_text: z27.string().optional(),
+      insert_line: z27.number().int().optional(),
+      new_str: z27.string().optional(),
+      insert_text: z27.string().optional(),
+      old_str: z27.string().optional(),
+      view_range: z27.array(z27.number().int()).optional()
     })
   )
 );
-var textEditor_20250429 = createProviderDefinedToolFactory10({
+var textEditor_20250429 = createProviderDefinedToolFactory11({
   id: "anthropic.text_editor_20250429",
   inputSchema: textEditor_20250429InputSchema
 });
 
 // src/tool/tool-search-bm25_20251119.ts
 import {
-  createProviderExecutedToolFactory as createProviderExecutedToolFactory10,
-  lazySchema as lazySchema24,
-  zodSchema as zodSchema24
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory12,
+  lazySchema as lazySchema27,
+  zodSchema as zodSchema27
 } from "@ai-sdk/provider-utils";
-import { z as z25 } from "zod/v4";
-var toolSearchBm25_20251119OutputSchema = lazySchema24(
-  () => zodSchema24(
-    z25.array(
-      z25.object({
-        type: z25.literal("tool_reference"),
-        toolName: z25.string()
+import { z as z28 } from "zod/v4";
+var toolSearchBm25_20251119OutputSchema = lazySchema27(
+  () => zodSchema27(
+    z28.array(
+      z28.object({
+        type: z28.literal("tool_reference"),
+        toolName: z28.string()
       })
     )
   )
 );
-var toolSearchBm25_20251119InputSchema = lazySchema24(
-  () => zodSchema24(
-    z25.object({
+var toolSearchBm25_20251119InputSchema = lazySchema27(
+  () => zodSchema27(
+    z28.object({
       /**
        * A natural language query to search for tools.
        * Claude will use BM25 text search to find relevant tools.
        */
-      query: z25.string(),
+      query: z28.string(),
       /**
        * Maximum number of tools to return. Optional.
        */
-      limit: z25.number().optional()
+      limit: z28.number().optional()
     })
   )
 );
-var factory11 = createProviderExecutedToolFactory10({
+var factory13 = createProviderExecutedToolFactory12({
   id: "anthropic.tool_search_bm25_20251119",
   inputSchema: toolSearchBm25_20251119InputSchema,
   outputSchema: toolSearchBm25_20251119OutputSchema,
   supportsDeferredResults: true
 });
 var toolSearchBm25_20251119 = (args = {}) => {
-  return factory11(args);
+  return factory13(args);
 };
 
 // src/anthropic-tools.ts
@@ -7402,6 +8111,29 @@ var anthropicTools = {
    * @param enableZoom - Enable zoom action. Set to true to allow Claude to zoom into specific screen regions. Default: false.
    */
   computer_20251124,
+  /**
+   * The computer toolset lets Claude control a computer through screenshots,
+   * mouse, and keyboard. It replaces the versioned computer tools
+   * (`computer_20251124` and earlier) on newer models.
+   *
+   * The API returns each computer action as its own `tool_use` block with
+   * `toolset_name: 'computer'`. The AI SDK maps every member call to this tool
+   * and exposes the member name as `action`, so `execute` receives the same
+   * input shape as the older computer tools. Claude may return several actions
+   * in one turn.
+   *
+   * Coordinates are always in the pixel space of the screenshots you return;
+   * there are no display size parameters. Zoom is enabled by default.
+   *
+   * Does not require a beta header.
+   *
+   * Supported models: Claude Opus 5.5 (required; older computer tool types
+   * are rejected), Opus 5, Sonnet 5, Fable 5, Fable 5.1, Opus 4.8.
+   *
+   * @param configs - Per-member settings keyed by member name, e.g.
+   * `{ zoom: { enabled: false } }`. Omitted members keep their defaults.
+   */
+  computerToolset_20260801,
   /**
    * The memory tool enables Claude to store and retrieve information across conversations through a memory file directory.
    * Claude can create, read, update, and delete files that persist between sessions,
@@ -7469,6 +8201,18 @@ var anthropicTools = {
    * @param maxContentTokens - The max_content_tokens parameter limits the amount of content that will be included in the context.
    */
   webFetch_20260209,
+  /**
+   * Creates a web fetch tool that gives Claude direct access to real-time web content.
+   *
+   * @param maxUses - The max_uses parameter limits the number of web fetches performed
+   * @param allowedDomains - Only fetch from these domains
+   * @param blockedDomains - Never fetch from these domains
+   * @param citations - Unlike web search where citations are always enabled, citations are optional for web fetch. Set "citations": {"enabled": true} to enable Claude to cite specific passages from fetched documents.
+   * @param maxContentTokens - The max_content_tokens parameter limits the amount of content that will be included in the context.
+   * @param useCache - Whether cached content may be returned. Set to false to fetch fresh content.
+   * @param responseInclusion - Whether result blocks consumed by completed code execution calls are returned. Defaults to "full".
+   */
+  webFetch_20260318,
   /**
    * Creates a web search tool that gives Claude direct access to real-time web content.
    *
@@ -7487,6 +8231,16 @@ var anthropicTools = {
    * @param userLocation - Optional user location information to provide geographically relevant search results.
    */
   webSearch_20260209,
+  /**
+   * Creates a web search tool that gives Claude direct access to real-time web content.
+   *
+   * @param maxUses - Maximum number of web searches Claude can perform during the conversation.
+   * @param allowedDomains - Optional list of domains that Claude is allowed to search.
+   * @param blockedDomains - Optional list of domains that Claude should avoid when searching.
+   * @param userLocation - Optional user location information to provide geographically relevant search results.
+   * @param responseInclusion - Whether result blocks consumed by completed code execution calls are returned. Defaults to "full".
+   */
+  webSearch_20260318,
   /**
    * Creates a tool search tool that uses regex patterns to find tools.
    *
@@ -7528,40 +8282,40 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/skills/anthropic-skills-api.ts
-import { lazySchema as lazySchema25, zodSchema as zodSchema25 } from "@ai-sdk/provider-utils";
-import { z as z26 } from "zod/v4";
-var anthropicSkillResponseSchema = lazySchema25(
-  () => zodSchema25(
-    z26.object({
-      id: z26.string(),
-      display_title: z26.string().nullish(),
-      name: z26.string().nullish(),
-      description: z26.string().nullish(),
-      latest_version: z26.string().nullish(),
-      source: z26.string(),
-      created_at: z26.string(),
-      updated_at: z26.string()
+import { lazySchema as lazySchema28, zodSchema as zodSchema28 } from "@ai-sdk/provider-utils";
+import { z as z29 } from "zod/v4";
+var anthropicSkillResponseSchema = lazySchema28(
+  () => zodSchema28(
+    z29.object({
+      id: z29.string(),
+      display_title: z29.string().nullish(),
+      name: z29.string().nullish(),
+      description: z29.string().nullish(),
+      latest_version: z29.string().nullish(),
+      source: z29.string(),
+      created_at: z29.string(),
+      updated_at: z29.string()
     })
   )
 );
-var anthropicSkillVersionListResponseSchema = lazySchema25(
-  () => zodSchema25(
-    z26.object({
-      data: z26.array(
-        z26.object({
-          version: z26.string()
+var anthropicSkillVersionListResponseSchema = lazySchema28(
+  () => zodSchema28(
+    z29.object({
+      data: z29.array(
+        z29.object({
+          version: z29.string()
         })
       )
     })
   )
 );
-var anthropicSkillVersionResponseSchema = lazySchema25(
-  () => zodSchema25(
-    z26.object({
-      type: z26.string(),
-      skill_id: z26.string(),
-      name: z26.string().nullish(),
-      description: z26.string().nullish()
+var anthropicSkillVersionResponseSchema = lazySchema28(
+  () => zodSchema28(
+    z29.object({
+      type: z29.string(),
+      skill_id: z29.string(),
+      name: z29.string().nullish(),
+      description: z29.string().nullish()
     })
   )
 );
@@ -7605,7 +8359,6 @@ var AnthropicSkills = class {
     };
   }
   async uploadSkill(params) {
-    var _a, _b;
     const warnings = [];
     const formData = new FormData();
     if (params.displayTitle != null) {
@@ -7631,8 +8384,8 @@ var AnthropicSkills = class {
       version: response.latest_version,
       headers
     }) : {};
-    const name = (_a = versionMetadata.name) != null ? _a : response.name;
-    const description = (_b = versionMetadata.description) != null ? _b : response.description;
+    const name = versionMetadata.name ?? response.name;
+    const description = versionMetadata.description ?? response.description;
     return {
       providerReference: { anthropic: response.id },
       ...response.display_title != null ? { displayTitle: response.display_title } : {},
@@ -7652,7 +8405,7 @@ var AnthropicSkills = class {
 };
 
 // src/version.ts
-var VERSION = true ? "4.0.53" : "0.0.0-test";
+var VERSION = true ? "4.0.68" : "0.0.0-test";
 
 // src/anthropic-provider.ts
 var ANTHROPIC_API_URL = "https://api.anthropic.com";
@@ -7664,20 +8417,19 @@ function normalizeBaseURL(baseURL) {
   return baseURLWithoutTrailingSlash === ANTHROPIC_API_URL ? ANTHROPIC_API_VERSIONED_URL : baseURLWithoutTrailingSlash;
 }
 function createAnthropic(options = {}) {
-  var _a, _b, _c;
-  const baseURL = (_a = normalizeBaseURL(
+  const baseURL = normalizeBaseURL(
     loadOptionalSetting({
       settingValue: options.baseURL,
       environmentVariableName: "ANTHROPIC_BASE_URL"
     })
-  )) != null ? _a : ANTHROPIC_API_VERSIONED_URL;
-  const providerName = (_b = options.name) != null ? _b : "anthropic.messages";
+  ) ?? ANTHROPIC_API_VERSIONED_URL;
+  const providerName = options.name ?? "anthropic.messages";
   const supportedUrls = {
     "image/*": [/^https?:\/\/.*$/],
     "application/pdf": [/^https?:\/\/.*$/]
   };
   if (options.apiKey && options.authToken) {
-    throw new InvalidArgumentError2({
+    throw new InvalidArgumentError3({
       argument: "apiKey/authToken",
       message: "Both apiKey and authToken were provided. Please use only one authentication method."
     });
@@ -7696,7 +8448,7 @@ function createAnthropic(options = {}) {
         ...authHeaders,
         ...options.headers
       },
-      `ai-sdk/anthropic/${VERSION}`
+      `ai-sdk-anthropic/${VERSION}`
     );
   };
   const languageModelConfig = {
@@ -7704,7 +8456,7 @@ function createAnthropic(options = {}) {
     baseURL,
     headers: getHeaders,
     fetch: options.fetch,
-    generateId: (_c = options.generateId) != null ? _c : generateId3,
+    generateId: options.generateId ?? generateId3,
     supportedUrls: () => supportedUrls
   };
   const createChatModel = (modelId) => new AnthropicLanguageModel(modelId, languageModelConfig);
@@ -7731,6 +8483,10 @@ function createAnthropic(options = {}) {
   provider.languageModel = createChatModel;
   provider.chat = createChatModel;
   provider.messages = createChatModel;
+  provider.evaluationModel = (modelId) => new EvaluationLanguageModel({
+    model: createChatModel(modelId),
+    provider: `${providerName.replace(/\.messages$/, "")}.evaluation`
+  });
   provider.experimental_batch = createBatch;
   provider.embeddingModel = (modelId) => {
     throw new NoSuchModelError({ modelId, modelType: "embeddingModel" });
@@ -7755,9 +8511,8 @@ var anthropic = createAnthropic();
 function forwardAnthropicContainerIdFromLastStep({
   steps
 }) {
-  var _a, _b, _c;
   for (let i = steps.length - 1; i >= 0; i--) {
-    const containerId = (_c = (_b = (_a = steps[i].providerMetadata) == null ? void 0 : _a.anthropic) == null ? void 0 : _b.container) == null ? void 0 : _c.id;
+    const containerId = steps[i].providerMetadata?.anthropic?.container?.id;
     if (containerId) {
       return {
         providerOptions: {
@@ -7768,7 +8523,6 @@ function forwardAnthropicContainerIdFromLastStep({
       };
     }
   }
-  return void 0;
 }
 export {
   VERSION,