@ai-sdk/anthropic 3.0.136 → 3.0.137

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @ai-sdk/anthropic
 
+## 3.0.137
+
+### Patch Changes
+
+- 7f91bae: fix(anthropic): use native structured outputs for Claude models that reject forced tool use (Sonnet 5.5, Opus 5.5, Fable 5.1) even when the provider disables them by default, as Amazon Bedrock and Google Vertex do. Self-referencing schemas keep the JSON response tool. Also keep `definitions` and `$defs` next to a top-level `$ref` when sanitizing structured output schemas, so the reference still resolves.
+- 210ca0a: fix(anthropic): when the JSON response tool is in use but the model answers in text without calling it (for example with manual thinking, where the forced tool choice is downgraded to `auto`), return the final answer text instead of dropping it. Text before a tool call, result, or message continuation is still dropped.
+- 7f91bae: fix(anthropic): keep the JSON response tool for schemas that native structured outputs cannot represent when upgrading models that reject forced tool use. Schemas with open objects (maps, free-form objects) would otherwise come back as `{}`, and schemas with more than 10 optional properties can be rejected as too complex.
+
 ## 3.0.136
 
 ### Patch Changes

package/dist/index.js

@@ -32,7 +32,7 @@ var import_provider4 = require("@ai-sdk/provider");
 var import_provider_utils28 = require("@ai-sdk/provider-utils");
 
 // src/version.ts
-var VERSION = true ? "3.0.136" : "0.0.0-test";
+var VERSION = true ? "3.0.137" : "0.0.0-test";
 
 // src/anthropic-messages-language-model.ts
 var import_provider3 = require("@ai-sdk/provider");
@@ -3585,9 +3585,8 @@ function sanitizeDefinition(definition) {
 }
 function sanitizeSchema(schema) {
   const result = {};
-  const schemaWithDefs = schema;
   if (schema.$ref != null) {
-    return { $ref: schema.$ref };
+    return { $ref: schema.$ref, ...sanitizeSchemaDefinitions(schema) };
   }
   if (schema.$schema != null) {
     result.$schema = schema.$schema;
@@ -3621,23 +3620,7 @@ function sanitizeSchema(schema) {
   if (schema.allOf != null) {
     result.allOf = schema.allOf.map(sanitizeDefinition);
   }
-  if (schema.definitions != null) {
-    result.definitions = Object.fromEntries(
-      Object.entries(schema.definitions).map(([name, definition]) => [
-        name,
-        sanitizeDefinition(definition)
-      ])
-    );
-  }
-  if (schemaWithDefs.$defs != null) {
-    const resultWithDefs = result;
-    resultWithDefs.$defs = Object.fromEntries(
-      Object.entries(schemaWithDefs.$defs).map(([name, definition]) => [
-        name,
-        sanitizeDefinition(definition)
-      ])
-    );
-  }
+  Object.assign(result, sanitizeSchemaDefinitions(schema));
   if (schema.type === "object" || schema.properties != null) {
     if (schema.properties != null) {
       result.properties = Object.fromEntries(
@@ -3665,6 +3648,21 @@ ${constraintDescription}`;
   }
   return result;
 }
+function sanitizeSchemaDefinitions(schema) {
+  const { $defs } = schema;
+  const sanitizeAll = (definitions) => Object.fromEntries(
+    Object.entries(definitions).map(([name, definition]) => [
+      name,
+      sanitizeDefinition(definition)
+    ])
+  );
+  return {
+    ...schema.definitions != null && {
+      definitions: sanitizeAll(schema.definitions)
+    },
+    ...$defs != null && { $defs: sanitizeAll($defs) }
+  };
+}
 function getConstraintDescription(schema) {
   const descriptions = DESCRIPTION_CONSTRAINT_KEYS.flatMap((key) => {
     const value = schema[key];
@@ -3691,6 +3689,187 @@ function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/has-circular-schema-reference.ts
+var SCHEMA_MAP_KEYWORDS = /* @__PURE__ */ new Set([
+  "dependentSchemas",
+  "patternProperties",
+  "properties"
+]);
+var DATA_KEYWORDS = /* @__PURE__ */ new Set(["const", "default", "enum", "examples"]);
+function hasCircularSchemaReference(schema) {
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (pointer) => {
+    if (visiting.has(pointer)) {
+      return true;
+    }
+    if (visited.has(pointer)) {
+      return false;
+    }
+    const target = resolveSchemaPointer(schema, pointer);
+    if (target === void 0) {
+      return false;
+    }
+    visiting.add(pointer);
+    const isCircular = collectLocalRefs(target).some(visit);
+    visiting.delete(pointer);
+    visited.add(pointer);
+    return isCircular;
+  };
+  return visit("#");
+}
+function collectLocalRefs(node, refs = []) {
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      collectLocalRefs(item, refs);
+    }
+    return refs;
+  }
+  if (!isRecord(node)) {
+    return refs;
+  }
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "$ref") {
+      if (typeof value === "string" && value.startsWith("#")) {
+        refs.push(value);
+      }
+    } else if (SCHEMA_MAP_KEYWORDS.has(key) && isRecord(value)) {
+      for (const subschema of Object.values(value)) {
+        collectLocalRefs(subschema, refs);
+      }
+    } else if (
+      // definitions are only reached through a `$ref`:
+      key !== "$defs" && key !== "definitions" && !DATA_KEYWORDS.has(key)
+    ) {
+      collectLocalRefs(value, refs);
+    }
+  }
+  return refs;
+}
+function resolveSchemaPointer(schema, pointer) {
+  if (pointer === "#") {
+    return schema;
+  }
+  if (!pointer.startsWith("#/")) {
+    return void 0;
+  }
+  let decodedPointer;
+  try {
+    decodedPointer = decodeURIComponent(pointer.slice(2));
+  } catch (e) {
+    return void 0;
+  }
+  let current = schema;
+  for (const rawSegment of decodedPointer.split("/")) {
+    const segment = rawSegment.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (Array.isArray(current)) {
+      current = current[Number(segment)];
+    } else if (isRecord(current)) {
+      current = current[segment];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/supports-native-structured-output-schema.ts
+var MAX_OPTIONAL_PROPERTIES = 10;
+var SUBSCHEMA_KEYWORDS = [
+  "additionalProperties",
+  "contains",
+  "else",
+  "if",
+  "items",
+  "not",
+  "then"
+];
+var SUBSCHEMA_LIST_KEYWORDS = ["allOf", "anyOf", "oneOf", "prefixItems"];
+var SUBSCHEMA_MAP_KEYWORDS = [
+  "dependentSchemas",
+  "patternProperties",
+  "properties"
+];
+function supportsNativeStructuredOutputSchema(schema) {
+  if (hasCircularSchemaReference(schema)) {
+    return false;
+  }
+  const { optionalProperties, hasOpenObject } = getSchemaStats(
+    schema,
+    schema,
+    /* @__PURE__ */ new Map()
+  );
+  return !hasOpenObject && optionalProperties <= MAX_OPTIONAL_PROPERTIES;
+}
+function getSchemaStats(node, root, refStats) {
+  const stats = { optionalProperties: 0, hasOpenObject: false };
+  if (!isRecord(node)) {
+    return stats;
+  }
+  const add = (child) => {
+    const childStats = getSchemaStats(child, root, refStats);
+    stats.optionalProperties += childStats.optionalProperties;
+    stats.hasOpenObject || (stats.hasOpenObject = childStats.hasOpenObject);
+  };
+  if (typeof node.$ref === "string" && node.$ref.startsWith("#")) {
+    let resolved = refStats.get(node.$ref);
+    if (resolved == null) {
+      resolved = getSchemaStats(
+        resolveSchemaPointer(root, node.$ref),
+        root,
+        refStats
+      );
+      refStats.set(node.$ref, resolved);
+    }
+    stats.optionalProperties += resolved.optionalProperties;
+    stats.hasOpenObject || (stats.hasOpenObject = resolved.hasOpenObject);
+  }
+  if (isOpenObject(node)) {
+    stats.hasOpenObject = true;
+  }
+  if (isRecord(node.properties)) {
+    const required = new Set(Array.isArray(node.required) ? node.required : []);
+    stats.optionalProperties += Object.keys(node.properties).filter(
+      (name) => !required.has(name)
+    ).length;
+  }
+  for (const keyword of SUBSCHEMA_KEYWORDS) {
+    const value = node[keyword];
+    if (Array.isArray(value)) {
+      value.forEach(add);
+    } else {
+      add(value);
+    }
+  }
+  for (const keyword of SUBSCHEMA_LIST_KEYWORDS) {
+    const value = node[keyword];
+    if (Array.isArray(value)) {
+      value.forEach(add);
+    }
+  }
+  for (const keyword of SUBSCHEMA_MAP_KEYWORDS) {
+    const value = node[keyword];
+    if (isRecord(value)) {
+      Object.values(value).forEach(add);
+    }
+  }
+  return stats;
+}
+function isOpenObject(node) {
+  const { additionalProperties, patternProperties, properties, type } = node;
+  if (additionalProperties === true || isRecord(additionalProperties)) {
+    return true;
+  }
+  if (isRecord(patternProperties) && Object.keys(patternProperties).length > 0) {
+    return true;
+  }
+  const isObjectType = type === "object" || Array.isArray(type) && type.includes("object");
+  return isObjectType && properties == null && additionalProperties !== false;
+}
+
 // src/anthropic-messages-language-model.ts
 function createCitationSource(citation, citationDocuments, generateId3) {
   var _a;
@@ -3764,6 +3943,31 @@ function toToolsetMemberInput({
     ...typeof input === "object" && input !== null && !Array.isArray(input) ? input : {}
   };
 }
+var TEXT_OR_THINKING_BLOCK_TYPES = /* @__PURE__ */ new Set([
+  "redacted_thinking",
+  "text",
+  "thinking"
+]);
+function isContinuationStopReason(stopReason) {
+  return stopReason === "pause_turn" || stopReason === "tool_use";
+}
+function getJsonResponseToolFallbackText(content, stopReason) {
+  const text = /* @__PURE__ */ new Set();
+  if (isContinuationStopReason(stopReason)) {
+    return text;
+  }
+  for (const part of content) {
+    if (part.type === "tool_use" && part.name === "json") {
+      return /* @__PURE__ */ new Set();
+    }
+    if (part.type === "text") {
+      text.add(part);
+    } else if (!TEXT_OR_THINKING_BLOCK_TYPES.has(part.type)) {
+      text.clear();
+    }
+  }
+  return text;
+}
 var AnthropicMessagesLanguageModel = class {
   constructor(modelId, config) {
     this.specificationVersion = "v3";
@@ -3911,7 +4115,7 @@ var AnthropicMessagesLanguageModel = class {
     const supportsStrictTools = ((_c = this.config.supportsStrictTools) != null ? _c : true) && modelSupportsStructuredOutput;
     const structureOutputMode = (_d = anthropicOptions == null ? void 0 : anthropicOptions.structuredOutputMode) != null ? _d : "auto";
     let useStructuredOutput = structureOutputMode === "outputFormat" || structureOutputMode === "auto" && supportsStructuredOutput;
-    if (!useStructuredOutput && rejectsForcedToolUse && supportsStructuredOutput && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null) {
+    if (!useStructuredOutput && rejectsForcedToolUse && modelSupportsStructuredOutput && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && supportsNativeStructuredOutputSchema(responseFormat.schema)) {
       warnings.push({
         type: "unsupported",
         feature: "providerOptions.anthropic.structuredOutputMode",
@@ -4417,10 +4621,11 @@ var AnthropicMessagesLanguageModel = class {
     const mcpToolCalls = {};
     const serverToolCalls = {};
     let isJsonResponseFromTool = false;
+    const jsonResponseToolFallbackText = usesJsonResponseTool ? getJsonResponseToolFallbackText(response.content, response.stop_reason) : void 0;
     for (const part of response.content) {
       switch (part.type) {
         case "text": {
-          if (!usesJsonResponseTool) {
+          if (jsonResponseToolFallbackText == null || jsonResponseToolFallbackText.has(part)) {
             const webSearchCitations = (_a = part.citations) == null ? void 0 : _a.filter(
               (citation) => citation.type === "web_search_result_location"
             );
@@ -4956,6 +5161,15 @@ var AnthropicMessagesLanguageModel = class {
     let safeguardResults;
     let container = null;
     let isJsonResponseFromTool = false;
+    const heldBackText = [];
+    const heldBackTextByIndex = /* @__PURE__ */ new Map();
+    const createTextEnd = (id, citations) => ({
+      type: "text-end",
+      id,
+      ...citations.length > 0 && {
+        providerMetadata: { anthropic: { citations } }
+      }
+    });
     let isMessageOpen = false;
     let activeMessageId;
     let hasInvalidMessageSequence = false;
@@ -4967,7 +5181,7 @@ var AnthropicMessagesLanguageModel = class {
           controller.enqueue({ type: "stream-start", warnings });
         },
         transform(chunk, controller) {
-          var _a2, _b2, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+          var _a2, _b2, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
           if (hasInvalidMessageSequence) {
             return;
           }
@@ -4990,9 +5204,19 @@ var AnthropicMessagesLanguageModel = class {
                 return;
               }
               blockType = contentBlockType;
+              if (!TEXT_OR_THINKING_BLOCK_TYPES.has(contentBlockType)) {
+                heldBackText.length = 0;
+              }
               switch (contentBlockType) {
                 case "text": {
                   if (usesJsonResponseTool) {
+                    const entry = {
+                      id: String(value.index),
+                      text: "",
+                      citations: []
+                    };
+                    heldBackText.push(entry);
+                    heldBackTextByIndex.set(value.index, entry);
                     return;
                   }
                   contentBlocks[value.index] = {
@@ -5447,17 +5671,12 @@ var AnthropicMessagesLanguageModel = class {
                 const contentBlock = contentBlocks[value.index];
                 switch (contentBlock.type) {
                   case "text": {
-                    controller.enqueue({
-                      type: "text-end",
-                      id: String(value.index),
-                      ...contentBlock.citations.length > 0 && {
-                        providerMetadata: {
-                          anthropic: {
-                            citations: contentBlock.citations
-                          }
-                        }
-                      }
-                    });
+                    controller.enqueue(
+                      createTextEnd(
+                        String(value.index),
+                        contentBlock.citations
+                      )
+                    );
                     break;
                   }
                   case "reasoning": {
@@ -5543,6 +5762,10 @@ var AnthropicMessagesLanguageModel = class {
               switch (deltaType) {
                 case "text_delta": {
                   if (usesJsonResponseTool) {
+                    const entry = heldBackTextByIndex.get(value.index);
+                    if (entry != null) {
+                      entry.text += value.delta.text;
+                    }
                     return;
                   }
                   controller.enqueue({
@@ -5624,8 +5847,11 @@ var AnthropicMessagesLanguageModel = class {
                 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") {
-                    contentBlock.citations.push(citation);
+                  if (citation.type === "web_search_result_location") {
+                    if ((contentBlock == null ? void 0 : contentBlock.type) === "text") {
+                      contentBlock.citations.push(citation);
+                    }
+                    (_e = heldBackTextByIndex.get(value.index)) == null ? void 0 : _e.citations.push(citation);
                   }
                   const source = createCitationSource(
                     citation,
@@ -5662,13 +5888,14 @@ var AnthropicMessagesLanguageModel = class {
               }
               isMessageOpen = true;
               activeMessageId = value.message.id;
+              heldBackTextByIndex.clear();
               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 = (_f = value.message.usage.cache_read_input_tokens) != null ? _f : 0;
+              usage.cache_creation_input_tokens = (_g = value.message.usage.cache_creation_input_tokens) != null ? _g : 0;
               rawUsage = {
                 ...value.message.usage
               };
-              cacheCreationInputTokens = (_g = value.message.usage.cache_creation_input_tokens) != null ? _g : null;
+              cacheCreationInputTokens = (_h = value.message.usage.cache_creation_input_tokens) != null ? _h : null;
               if (value.message.input_transformations != null) {
                 inputTransformations = value.message.input_transformations;
               }
@@ -5690,8 +5917,8 @@ var AnthropicMessagesLanguageModel = class {
               }
               controller.enqueue({
                 type: "response-metadata",
-                id: (_h = value.message.id) != null ? _h : void 0,
-                modelId: (_i = value.message.model) != null ? _i : void 0
+                id: (_i = value.message.id) != null ? _i : void 0,
+                modelId: (_j = value.message.model) != null ? _j : void 0
               });
               if (value.message.content != null) {
                 for (let contentIndex = 0; contentIndex < value.message.content.length; contentIndex++) {
@@ -5703,7 +5930,7 @@ var AnthropicMessagesLanguageModel = class {
                       id: part.id,
                       toolName: part.name
                     });
-                    const inputStr = JSON.stringify((_j = part.input) != null ? _j : {});
+                    const inputStr = JSON.stringify((_k = part.input) != null ? _k : {});
                     controller.enqueue({
                       type: "tool-input-delta",
                       id: part.id,
@@ -5754,18 +5981,18 @@ var AnthropicMessagesLanguageModel = class {
                   finishReason: value.delta.stop_reason,
                   isJsonResponseFromTool
                 }),
-                raw: (_k = value.delta.stop_reason) != null ? _k : void 0
+                raw: (_l = value.delta.stop_reason) != null ? _l : void 0
               };
-              stopSequence = (_l = value.delta.stop_sequence) != null ? _l : null;
+              stopSequence = (_m = value.delta.stop_sequence) != null ? _m : null;
               stopDetails = mapAnthropicStopDetails(value.delta.stop_details);
               container = value.delta.container != null ? {
                 expiresAt: value.delta.container.expires_at,
                 id: value.delta.container.id,
-                skills: (_n = (_m = value.delta.container.skills) == null ? void 0 : _m.map((skill) => ({
+                skills: (_o = (_n = value.delta.container.skills) == null ? void 0 : _n.map((skill) => ({
                   type: skill.type,
                   skillId: skill.skill_id,
                   version: skill.version
-                }))) != null ? _n : null
+                }))) != null ? _o : null
               } : null;
               if (value.context_management) {
                 contextManagement = mapAnthropicResponseContextManagement(
@@ -5817,6 +6044,15 @@ var AnthropicMessagesLanguageModel = class {
               if (usedCustomProviderKey && providerOptionsName !== "anthropic") {
                 providerMetadata[providerOptionsName] = anthropicMetadata;
               }
+              if (!isJsonResponseFromTool && !isContinuationStopReason(finishReason.raw)) {
+                for (const { id, text, citations } of heldBackText) {
+                  if (text.length === 0) continue;
+                  controller.enqueue({ type: "text-start", id });
+                  controller.enqueue({ type: "text-delta", id, delta: text });
+                  controller.enqueue(createTextEnd(id, citations));
+                }
+              }
+              heldBackText.length = 0;
               controller.enqueue({
                 type: "finish",
                 finishReason,