@ai-sdk/anthropic 2.0.78 → 2.0.80

package/dist/internal/index.mjs

@@ -36,7 +36,10 @@ var anthropicFailedResponseHandler = createJsonErrorResponseHandler({
 });
 
 // src/anthropic-messages-api.ts
-import { lazySchema as lazySchema2, zodSchema as zodSchema2 } from "@ai-sdk/provider-utils";
+import {
+  lazySchema as lazySchema2,
+  zodSchema as zodSchema2
+} from "@ai-sdk/provider-utils";
 import { z as z2 } from "zod/v4";
 var anthropicMessagesResponseSchema = lazySchema2(
   () => zodSchema2(
@@ -824,9 +827,12 @@ var CacheControlValidator = class {
 };
 
 // src/tool/text-editor_20250728.ts
-import { createProviderDefinedToolFactory } from "@ai-sdk/provider-utils";
+import {
+  createProviderDefinedToolFactory,
+  lazySchema as lazySchema3,
+  zodSchema as zodSchema3
+} from "@ai-sdk/provider-utils";
 import { z as z4 } from "zod/v4";
-import { lazySchema as lazySchema3, zodSchema as zodSchema3 } from "@ai-sdk/provider-utils";
 var textEditor_20250728ArgsSchema = lazySchema3(
   () => zodSchema3(
     z4.object({
@@ -1412,19 +1418,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": {
@@ -1938,6 +1945,152 @@ function mapAnthropicStopReason({
   }
 }
 
+// src/sanitize-json-schema.ts
+var SUPPORTED_STRING_FORMATS = /* @__PURE__ */ new Set([
+  "date-time",
+  "time",
+  "date",
+  "duration",
+  "email",
+  "hostname",
+  "uri",
+  "ipv4",
+  "ipv6",
+  "uuid"
+]);
+var DESCRIPTION_CONSTRAINT_KEYS = [
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "minItems",
+  "maxItems",
+  "uniqueItems",
+  "minProperties",
+  "maxProperties",
+  "not"
+];
+function sanitizeJsonSchema(schema) {
+  return sanitizeSchema(schema);
+}
+function sanitizeDefinition(definition) {
+  if (typeof definition === "boolean" || !isPlainObject(definition)) {
+    return definition;
+  }
+  return sanitizeSchema(definition);
+}
+function sanitizeSchema(schema) {
+  const result = {};
+  const schemaWithDefs = schema;
+  if (schema.$ref != null) {
+    return { $ref: schema.$ref };
+  }
+  if (schema.$schema != null) {
+    result.$schema = schema.$schema;
+  }
+  if (schema.$id != null) {
+    result.$id = schema.$id;
+  }
+  if (schema.title != null) {
+    result.title = schema.title;
+  }
+  if (schema.description != null) {
+    result.description = schema.description;
+  }
+  if (schema.default !== void 0) {
+    result.default = schema.default;
+  }
+  if (schema.const !== void 0) {
+    result.const = schema.const;
+  }
+  if (schema.enum != null) {
+    result.enum = schema.enum;
+  }
+  if (schema.type != null) {
+    result.type = schema.type;
+  }
+  if (schema.anyOf != null) {
+    result.anyOf = schema.anyOf.map(sanitizeDefinition);
+  } else if (schema.oneOf != null) {
+    result.anyOf = schema.oneOf.map(sanitizeDefinition);
+  }
+  if (schema.allOf != null) {
+    result.allOf = schema.allOf.map(sanitizeDefinition);
+  }
+  if (schema.definitions != null) {
+    result.definitions = Object.fromEntries(
+      Object.entries(schema.definitions).map(([name, definition]) => [
+        name,
+        sanitizeDefinition(definition)
+      ])
+    );
+  }
+  if (schemaWithDefs.$defs != null) {
+    const resultWithDefs = result;
+    resultWithDefs.$defs = Object.fromEntries(
+      Object.entries(schemaWithDefs.$defs).map(([name, definition]) => [
+        name,
+        sanitizeDefinition(definition)
+      ])
+    );
+  }
+  if (schema.type === "object" || schema.properties != null) {
+    if (schema.properties != null) {
+      result.properties = Object.fromEntries(
+        Object.entries(schema.properties).map(([name, definition]) => [
+          name,
+          sanitizeDefinition(definition)
+        ])
+      );
+    }
+    result.additionalProperties = false;
+    if (schema.required != null) {
+      result.required = schema.required;
+    }
+  }
+  if (schema.items != null) {
+    result.items = Array.isArray(schema.items) ? schema.items.map(sanitizeDefinition) : sanitizeDefinition(schema.items);
+  }
+  if (typeof schema.format === "string" && SUPPORTED_STRING_FORMATS.has(schema.format)) {
+    result.format = schema.format;
+  }
+  const constraintDescription = getConstraintDescription(schema);
+  if (constraintDescription != null) {
+    result.description = result.description == null ? constraintDescription : `${result.description}
+${constraintDescription}`;
+  }
+  return result;
+}
+function getConstraintDescription(schema) {
+  const descriptions = DESCRIPTION_CONSTRAINT_KEYS.flatMap((key) => {
+    const value = schema[key];
+    if (value == null || value === false) {
+      return [];
+    }
+    return `${formatConstraintName(key)}: ${formatConstraintValue(value)}`;
+  });
+  if (typeof schema.format === "string" && !SUPPORTED_STRING_FORMATS.has(schema.format)) {
+    descriptions.push(`format: ${schema.format}`);
+  }
+  return descriptions.length === 0 ? void 0 : `${descriptions.join("; ")}.`;
+}
+function formatConstraintName(key) {
+  return key.replace(/[A-Z]/g, (match) => ` ${match.toLowerCase()}`);
+}
+function formatConstraintValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/anthropic-messages-language-model.ts
 function createCitationSource(citation, citationDocuments, generateId2) {
   var _a;
@@ -2144,7 +2297,7 @@ var AnthropicMessagesLanguageModel = class {
           ...useStructuredOutput && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && {
             format: {
               type: "json_schema",
-              schema: responseFormat.schema
+              schema: sanitizeJsonSchema(responseFormat.schema)
             }
           }
         }
@@ -2161,13 +2314,6 @@ var AnthropicMessagesLanguageModel = class {
       ...((_f = anthropicOptions == null ? void 0 : anthropicOptions.metadata) == null ? void 0 : _f.userId) != null && {
         metadata: { user_id: anthropicOptions.metadata.userId }
       },
-      // structured output:
-      ...useStructuredOutput && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && {
-        output_format: {
-          type: "json_schema",
-          schema: responseFormat.schema
-        }
-      },
       // container with agent skills:
       ...(anthropicOptions == null ? void 0 : anthropicOptions.container) && {
         container: {
@@ -3308,7 +3454,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")) {
     return {
       maxOutputTokens: 128e3,
       supportsStructuredOutput: true,