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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/anthropic",
-  "version": "4.0.0-beta.39",
+  "version": "4.0.0-beta.40",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,

package/src/anthropic-language-model.ts

@@ -60,6 +60,7 @@ import {
 import { convertToAnthropicPrompt } from './convert-to-anthropic-prompt';
 import { CacheControlValidator } from './get-cache-control';
 import { mapAnthropicStopReason } from './map-anthropic-stop-reason';
+import { sanitizeJsonSchema } from './sanitize-json-schema';
 
 function createCitationSource(
   citation: Citation,
@@ -468,7 +469,7 @@ export class AnthropicLanguageModel implements LanguageModelV4 {
             responseFormat.schema != null && {
               format: {
                 type: 'json_schema',
-                schema: responseFormat.schema,
+                schema: sanitizeJsonSchema(responseFormat.schema),
               },
             }),
         },

package/src/sanitize-json-schema.ts

@@ -0,0 +1,203 @@
+import type { JSONSchema7, JSONSchema7Definition } from '@ai-sdk/provider';
+
+const SUPPORTED_STRING_FORMATS = new Set([
+  'date-time',
+  'time',
+  'date',
+  'duration',
+  'email',
+  'hostname',
+  'uri',
+  'ipv4',
+  'ipv6',
+  'uuid',
+]);
+
+const DESCRIPTION_CONSTRAINT_KEYS = [
+  'minimum',
+  'maximum',
+  'exclusiveMinimum',
+  'exclusiveMaximum',
+  'multipleOf',
+  'minLength',
+  'maxLength',
+  'pattern',
+  'minItems',
+  'maxItems',
+  'uniqueItems',
+  'minProperties',
+  'maxProperties',
+  'not',
+] satisfies Array<keyof JSONSchema7>;
+
+/**
+ * Removes JSON Schema keywords that Anthropic rejects in
+ * `output_config.format.schema`.
+ *
+ * The full original schema is still used by AI SDK result validation. This
+ * only relaxes the schema sent to Anthropic's constrained decoder.
+ */
+export function sanitizeJsonSchema(schema: JSONSchema7): JSONSchema7 {
+  return sanitizeSchema(schema) as JSONSchema7;
+}
+
+function sanitizeDefinition(
+  definition: JSONSchema7Definition,
+): JSONSchema7Definition {
+  if (typeof definition === 'boolean' || !isPlainObject(definition)) {
+    return definition;
+  }
+
+  return sanitizeSchema(definition as JSONSchema7);
+}
+
+function sanitizeSchema(schema: JSONSchema7): JSONSchema7 {
+  const result: JSONSchema7 = {};
+  const schemaWithDefs = schema as JSONSchema7 & {
+    $defs?: Record<string, JSONSchema7Definition>;
+  };
+
+  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 !== undefined) {
+    result.default = schema.default;
+  }
+
+  if (schema.const !== undefined) {
+    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 as JSONSchema7 & {
+      $defs?: Record<string, JSONSchema7Definition>;
+    };
+    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}\n${constraintDescription}`;
+  }
+
+  return result;
+}
+
+function getConstraintDescription(schema: JSONSchema7): string | undefined {
+  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 ? undefined : `${descriptions.join('; ')}.`;
+}
+
+function formatConstraintName(key: string): string {
+  return key.replace(/[A-Z]/g, match => ` ${match.toLowerCase()}`);
+}
+
+function formatConstraintValue(value: unknown): string {
+  if (typeof value === 'string') {
+    return value;
+  }
+
+  return JSON.stringify(value);
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}