@ai-sdk/anthropic 3.0.80 → 3.0.82

package/dist/internal/index.mjs

@@ -42,6 +42,12 @@ import {
   zodSchema as zodSchema2
 } from "@ai-sdk/provider-utils";
 import { z as z2 } from "zod/v4";
+var anthropicStopDetailsSchema = z2.object({
+  type: z2.string(),
+  category: z2.string().nullish(),
+  explanation: z2.string().nullish(),
+  recommended_model: z2.string().nullish()
+});
 var anthropicMessagesResponseSchema = lazySchema2(
   () => zodSchema2(
     z2.object({
@@ -327,34 +333,37 @@ var anthropicMessagesResponseSchema = lazySchema2(
                 error_code: z2.string()
               })
             ])
+          }),
+          // Server-side fallback marker. Parsed so the response validates, but
+          // dropped from the content output (the AI SDK has no model-hop
+          // primitive). The hop remains observable via usage.iterations.
+          z2.object({
+            type: z2.literal("fallback")
           })
         ])
       ),
       stop_reason: z2.string().nullish(),
       stop_sequence: z2.string().nullish(),
+      stop_details: anthropicStopDetailsSchema.nullish(),
       usage: z2.looseObject({
         input_tokens: z2.number(),
         output_tokens: z2.number(),
         cache_creation_input_tokens: z2.number().nullish(),
         cache_read_input_tokens: z2.number().nullish(),
         iterations: z2.array(
-          z2.union([
-            z2.object({
-              type: z2.union([z2.literal("compaction"), z2.literal("message")]),
-              input_tokens: z2.number(),
-              output_tokens: z2.number(),
-              cache_creation_input_tokens: z2.number().nullish(),
-              cache_read_input_tokens: z2.number().nullish()
-            }),
-            z2.object({
-              type: z2.literal("advisor_message"),
-              model: z2.string(),
-              input_tokens: z2.number(),
-              output_tokens: z2.number(),
-              cache_creation_input_tokens: z2.number().nullish(),
-              cache_read_input_tokens: z2.number().nullish()
-            })
-          ])
+          z2.object({
+            type: z2.union([
+              z2.literal("compaction"),
+              z2.literal("message"),
+              z2.literal("advisor_message"),
+              z2.literal("fallback_message")
+            ]),
+            model: z2.string().nullish(),
+            input_tokens: z2.number(),
+            output_tokens: z2.number(),
+            cache_creation_input_tokens: z2.number().nullish(),
+            cache_read_input_tokens: z2.number().nullish()
+          })
         ).nullish()
       }),
       container: z2.object({
@@ -689,6 +698,11 @@ var anthropicMessagesChunkSchema = lazySchema2(
                 error_code: z2.string()
               })
             ])
+          }),
+          // Server-side fallback marker; dropped from content output (see the
+          // response schema). The hop remains observable via usage.iterations.
+          z2.object({
+            type: z2.literal("fallback")
           })
         ])
       }),
@@ -762,6 +776,7 @@ var anthropicMessagesChunkSchema = lazySchema2(
         delta: z2.object({
           stop_reason: z2.string().nullish(),
           stop_sequence: z2.string().nullish(),
+          stop_details: anthropicStopDetailsSchema.nullish(),
           container: z2.object({
             expires_at: z2.string(),
             id: z2.string(),
@@ -783,26 +798,19 @@ var anthropicMessagesChunkSchema = lazySchema2(
           cache_creation_input_tokens: z2.number().nullish(),
           cache_read_input_tokens: z2.number().nullish(),
           iterations: z2.array(
-            z2.union([
-              z2.object({
-                type: z2.union([
-                  z2.literal("compaction"),
-                  z2.literal("message")
-                ]),
-                input_tokens: z2.number(),
-                output_tokens: z2.number(),
-                cache_creation_input_tokens: z2.number().nullish(),
-                cache_read_input_tokens: z2.number().nullish()
-              }),
-              z2.object({
-                type: z2.literal("advisor_message"),
-                model: z2.string(),
-                input_tokens: z2.number(),
-                output_tokens: z2.number(),
-                cache_creation_input_tokens: z2.number().nullish(),
-                cache_read_input_tokens: z2.number().nullish()
-              })
-            ])
+            z2.object({
+              type: z2.union([
+                z2.literal("compaction"),
+                z2.literal("message"),
+                z2.literal("advisor_message"),
+                z2.literal("fallback_message")
+              ]),
+              model: z2.string().nullish(),
+              input_tokens: z2.number(),
+              output_tokens: z2.number(),
+              cache_creation_input_tokens: z2.number().nullish(),
+              cache_read_input_tokens: z2.number().nullish()
+            })
           ).nullish()
         }),
         context_management: z2.object({
@@ -1006,6 +1014,31 @@ var anthropicLanguageModelOptions = z3.object({
    * See https://platform.claude.com/docs/en/build-with-claude/data-residency
    */
   inferenceGeo: z3.enum(["us", "global"]).optional(),
+  /**
+   * Server-side fallback chain.
+   *
+   * When the primary model's safety classifiers block a turn, the API
+   * automatically retries it on the next model in the chain, server-side. A
+   * `content-filter` finish reason means the entire chain refused.
+   *
+   * Each entry is merged into the request as a direct request to that entry's
+   * model, so it must be formatted accordingly: `model` is required, and an
+   * entry may additionally override `max_tokens`, `thinking`, `output_config`,
+   * and `speed` for that attempt only (`speed` additionally requires the speed
+   * beta). The value is passed through to the API as-is.
+   *
+   * The required `server-side-fallback-2026-06-01` beta is added automatically
+   * when this option is set.
+   */
+  fallbacks: z3.array(
+    z3.object({
+      model: z3.string(),
+      max_tokens: z3.number().int().optional(),
+      thinking: z3.record(z3.string(), z3.unknown()).optional(),
+      output_config: z3.record(z3.string(), z3.unknown()).optional(),
+      speed: z3.enum(["fast", "standard"]).optional()
+    })
+  ).optional(),
   /**
    * A set of beta features to enable.
    * Allow a provider to receive the full `betas` set if it needs it.
@@ -1786,12 +1819,15 @@ function convertAnthropicMessagesUsage({
   usage,
   rawUsage
 }) {
-  var _a, _b;
+  var _a, _b, _c;
   const cacheCreationTokens = (_a = usage.cache_creation_input_tokens) != null ? _a : 0;
   const cacheReadTokens = (_b = usage.cache_read_input_tokens) != null ? _b : 0;
   let inputTokens;
   let outputTokens;
-  if (usage.iterations && usage.iterations.length > 0) {
+  const servedByFallback = (_c = usage.iterations) == null ? void 0 : _c.some(
+    (iter) => iter.type === "fallback_message"
+  );
+  if (usage.iterations && usage.iterations.length > 0 && !servedByFallback) {
     const executorIterations = usage.iterations.filter(
       (iter) => iter.type === "compaction" || iter.type === "message"
     );
@@ -2243,19 +2279,20 @@ async function convertToAnthropicMessagesPrompt({
     const type = block.type;
     switch (type) {
       case "system": {
-        if (system != null) {
-          throw new UnsupportedFunctionalityError2({
-            functionality: "Multiple system messages that are separated by user/assistant messages"
-          });
-        }
-        system = block.messages.map(({ content, providerOptions }) => ({
+        const content = block.messages.map(({ content: content2, providerOptions }) => ({
           type: "text",
-          text: content,
+          text: content2,
           cache_control: validator.getCacheControl(providerOptions, {
             type: "system message",
             canCache: true
           })
         }));
+        if (system == null) {
+          system = content;
+        } else {
+          messages.push({ role: "system", content });
+          betas.add("mid-conversation-system-2026-04-07");
+        }
         break;
       }
       case "user": {
@@ -3485,6 +3522,9 @@ var AnthropicMessagesLanguageModel = class {
       ...(anthropicOptions == null ? void 0 : anthropicOptions.inferenceGeo) && {
         inference_geo: anthropicOptions.inferenceGeo
       },
+      ...(anthropicOptions == null ? void 0 : anthropicOptions.fallbacks) && anthropicOptions.fallbacks.length > 0 && {
+        fallbacks: anthropicOptions.fallbacks
+      },
       ...(anthropicOptions == null ? void 0 : anthropicOptions.cacheControl) && {
         cache_control: anthropicOptions.cacheControl
       },
@@ -3661,6 +3701,9 @@ var AnthropicMessagesLanguageModel = class {
     if ((anthropicOptions == null ? void 0 : anthropicOptions.speed) === "fast") {
       betas.add("fast-mode-2026-02-01");
     }
+    if ((anthropicOptions == null ? void 0 : anthropicOptions.fallbacks) && anthropicOptions.fallbacks.length > 0) {
+      betas.add("server-side-fallback-2026-06-01");
+    }
     const defaultEagerInputStreaming = stream && ((_i = anthropicOptions == null ? void 0 : anthropicOptions.toolStreaming) != null ? _i : true);
     const {
       tools: anthropicTools2,
@@ -4183,6 +4226,12 @@ var AnthropicMessagesLanguageModel = class {
           }
           break;
         }
+        // Server-side fallback marker: the AI SDK has no content primitive for
+        // a model hop, so drop it. The hop is still observable via
+        // usage.iterations.
+        case "fallback": {
+          break;
+        }
       }
     }
     return {
@@ -4205,24 +4254,16 @@ var AnthropicMessagesLanguageModel = class {
       warnings,
       providerMetadata: (() => {
         var _a2, _b2, _c2, _d2, _e2;
+        const stopDetails = mapAnthropicStopDetails(response.stop_details);
         const anthropicMetadata = {
           usage: response.usage,
           cacheCreationInputTokens: (_a2 = response.usage.cache_creation_input_tokens) != null ? _a2 : null,
           stopSequence: (_b2 = response.stop_sequence) != null ? _b2 : null,
+          ...stopDetails != null ? { stopDetails } : {},
           iterations: response.usage.iterations ? response.usage.iterations.map(
-            (iter) => iter.type === "advisor_message" ? {
-              type: iter.type,
-              model: iter.model,
-              inputTokens: iter.input_tokens,
-              outputTokens: iter.output_tokens,
-              ...iter.cache_creation_input_tokens ? {
-                cacheCreationInputTokens: iter.cache_creation_input_tokens
-              } : {},
-              ...iter.cache_read_input_tokens ? {
-                cacheReadInputTokens: iter.cache_read_input_tokens
-              } : {}
-            } : {
+            (iter) => ({
               type: iter.type,
+              ...iter.model != null ? { model: iter.model } : {},
               inputTokens: iter.input_tokens,
               outputTokens: iter.output_tokens,
               ...iter.cache_creation_input_tokens ? {
@@ -4231,7 +4272,7 @@ var AnthropicMessagesLanguageModel = class {
               ...iter.cache_read_input_tokens ? {
                 cacheReadInputTokens: iter.cache_read_input_tokens
               } : {}
-            }
+            })
           ) : null,
           container: response.container ? {
             expiresAt: response.container.expires_at,
@@ -4307,6 +4348,7 @@ var AnthropicMessagesLanguageModel = class {
     let rawUsage = void 0;
     let cacheCreationInputTokens = null;
     let stopSequence = null;
+    let stopDetails = void 0;
     let container = null;
     let isJsonResponseFromTool = false;
     let blockType = void 0;
@@ -4333,6 +4375,9 @@ var AnthropicMessagesLanguageModel = class {
             case "content_block_start": {
               const part = value.content_block;
               const contentBlockType = part.type;
+              if (contentBlockType === "fallback") {
+                return;
+              }
               blockType = contentBlockType;
               switch (contentBlockType) {
                 case "text": {
@@ -5006,6 +5051,7 @@ var AnthropicMessagesLanguageModel = class {
                 raw: (_k = value.delta.stop_reason) != null ? _k : void 0
               };
               stopSequence = (_l = value.delta.stop_sequence) != null ? _l : null;
+              stopDetails = mapAnthropicStopDetails(value.delta.stop_details);
               container = value.delta.container != null ? {
                 expiresAt: value.delta.container.expires_at,
                 id: value.delta.container.id,
@@ -5031,20 +5077,11 @@ var AnthropicMessagesLanguageModel = class {
                 usage: rawUsage != null ? rawUsage : null,
                 cacheCreationInputTokens,
                 stopSequence,
+                ...stopDetails != null ? { stopDetails } : {},
                 iterations: usage.iterations ? usage.iterations.map(
-                  (iter) => iter.type === "advisor_message" ? {
-                    type: iter.type,
-                    model: iter.model,
-                    inputTokens: iter.input_tokens,
-                    outputTokens: iter.output_tokens,
-                    ...iter.cache_creation_input_tokens ? {
-                      cacheCreationInputTokens: iter.cache_creation_input_tokens
-                    } : {},
-                    ...iter.cache_read_input_tokens ? {
-                      cacheReadInputTokens: iter.cache_read_input_tokens
-                    } : {}
-                  } : {
+                  (iter) => ({
                     type: iter.type,
+                    ...iter.model != null ? { model: iter.model } : {},
                     inputTokens: iter.input_tokens,
                     outputTokens: iter.output_tokens,
                     ...iter.cache_creation_input_tokens ? {
@@ -5053,7 +5090,7 @@ var AnthropicMessagesLanguageModel = class {
                     ...iter.cache_read_input_tokens ? {
                       cacheReadInputTokens: iter.cache_read_input_tokens
                     } : {}
-                  }
+                  })
                 ) : null,
                 container,
                 contextManagement
@@ -5117,7 +5154,7 @@ var AnthropicMessagesLanguageModel = class {
   }
 };
 function getModelCapabilities(modelId) {
-  if (modelId.includes("claude-opus-4-7")) {
+  if (modelId.includes("claude-opus-4-8") || modelId.includes("claude-opus-4-7") || modelId.includes("claude-fable-5")) {
     return {
       maxOutputTokens: 128e3,
       supportsStructuredOutput: true,
@@ -5218,6 +5255,17 @@ function mapAnthropicResponseContextManagement(contextManagement) {
     }).filter((edit) => edit !== void 0)
   } : null;
 }
+function mapAnthropicStopDetails(stopDetails) {
+  if (stopDetails == null) {
+    return void 0;
+  }
+  return {
+    type: stopDetails.type,
+    ...stopDetails.category != null ? { category: stopDetails.category } : {},
+    ...stopDetails.explanation != null ? { explanation: stopDetails.explanation } : {},
+    ...stopDetails.recommended_model != null ? { recommendedModel: stopDetails.recommended_model } : {}
+  };
+}
 
 // src/tool/bash_20241022.ts
 import {
@@ -5575,7 +5623,7 @@ var anthropicTools = {
    * Supported executor models: Claude Haiku 4.5, Sonnet 4.6, Opus 4.6,
    * Opus 4.7. The advisor must be at least as capable as the executor.
    *
-   * @param model - The advisor model ID (required), e.g. `"claude-opus-4-7"`.
+   * @param model - The advisor model ID (required), e.g. `"claude-opus-4-8"`.
    * @param maxUses - Maximum advisor calls per request (per-request cap).
    * @param caching - Enables prompt caching for the advisor's transcript
    * across calls within a conversation. Worthwhile from ~3 advisor calls