@velum-labs/routekit-gateway 1.0.7 → 1.0.8

package/dist/providers/anthropic-codec.js

@@ -135,6 +135,114 @@ function anthropicToolChoice(choice, parallelToolCalls) {
         ? { type: "tool", name: fn.name, ...disableParallel }
         : undefined;
 }
+const ANTHROPIC_SUPPORTED_SCHEMA_KEYWORDS = new Set([
+    "$defs",
+    "$ref",
+    "additionalProperties",
+    "allOf",
+    "anyOf",
+    "const",
+    "description",
+    "enum",
+    "format",
+    "items",
+    "minItems",
+    "oneOf",
+    "pattern",
+    "properties",
+    "required",
+    "title",
+    "type"
+]);
+const ANTHROPIC_SUPPORTED_STRING_FORMATS = new Set([
+    "date",
+    "date-time",
+    "duration",
+    "email",
+    "hostname",
+    "ipv4",
+    "ipv6",
+    "time",
+    "uri",
+    "uuid"
+]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cloneSchemaValue(value) {
+    if (Array.isArray(value))
+        return value.map(cloneSchemaValue);
+    if (!isRecord(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, cloneSchemaValue(child)]));
+}
+function sanitizedSchemaMap(value) {
+    if (!isRecord(value))
+        return cloneSchemaValue(value);
+    return Object.fromEntries(Object.entries(value).map(([key, schema]) => [key, anthropicStructuredOutputSchema(schema)]));
+}
+/**
+ * Anthropic structured outputs accept only a subset of JSON Schema. Match the
+ * documented SDK behavior by retaining that subset, converting `oneOf` to
+ * `anyOf`, and moving omitted constraints into descriptions for model guidance.
+ * Callers remain responsible for validating the parsed response against the
+ * original schema.
+ */
+function anthropicStructuredOutputSchema(schema) {
+    if (!isRecord(schema))
+        return cloneSchemaValue(schema);
+    if (typeof schema.$ref === "string")
+        return { $ref: schema.$ref };
+    const sanitized = {};
+    const deferredConstraints = [];
+    let oneOf;
+    for (const [key, value] of Object.entries(schema)) {
+        if (!ANTHROPIC_SUPPORTED_SCHEMA_KEYWORDS.has(key) ||
+            (key === "minItems" && value !== 0 && value !== 1) ||
+            (key === "format" &&
+                (typeof value !== "string" || !ANTHROPIC_SUPPORTED_STRING_FORMATS.has(value)))) {
+            deferredConstraints.push([key, cloneSchemaValue(value)]);
+            continue;
+        }
+        if (key === "$defs" || key === "properties") {
+            sanitized[key] = sanitizedSchemaMap(value);
+            continue;
+        }
+        if ((key === "allOf" || key === "anyOf") && Array.isArray(value)) {
+            sanitized[key] = value.map(anthropicStructuredOutputSchema);
+            continue;
+        }
+        if (key === "oneOf") {
+            oneOf = value;
+            continue;
+        }
+        if (key === "additionalProperties" || key === "items") {
+            sanitized[key] = Array.isArray(value)
+                ? value.map(anthropicStructuredOutputSchema)
+                : anthropicStructuredOutputSchema(value);
+            continue;
+        }
+        sanitized[key] = cloneSchemaValue(value);
+    }
+    if (oneOf !== undefined) {
+        if (!Object.hasOwn(sanitized, "anyOf") && Array.isArray(oneOf)) {
+            sanitized.anyOf = oneOf.map(anthropicStructuredOutputSchema);
+        }
+        else {
+            deferredConstraints.push(["oneOf", cloneSchemaValue(oneOf)]);
+        }
+    }
+    if (deferredConstraints.length > 0) {
+        const constraintDescription = `{${deferredConstraints
+            .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+            .join(", ")}}`;
+        sanitized.description =
+            typeof sanitized.description === "string" && sanitized.description.length > 0
+                ? `${sanitized.description}\n\n${constraintDescription}`
+                : constraintDescription;
+    }
+    return sanitized;
+}
 function anthropicStructuredOutputFormat(responseFormat) {
     if (responseFormat?.type !== "json_schema" ||
         typeof responseFormat.json_schema?.schema !== "object" ||
@@ -143,7 +251,22 @@ function anthropicStructuredOutputFormat(responseFormat) {
     }
     return {
         type: "json_schema",
-        schema: responseFormat.json_schema.schema
+        schema: anthropicStructuredOutputSchema(responseFormat.json_schema.schema)
+    };
+}
+function sanitizedAnthropicOutputConfig(outputConfig) {
+    if (outputConfig === undefined)
+        return undefined;
+    const format = outputConfig.format;
+    if (!isRecord(format) || format.type !== "json_schema" || !isRecord(format.schema)) {
+        return outputConfig;
+    }
+    return {
+        ...outputConfig,
+        format: {
+            ...format,
+            schema: anthropicStructuredOutputSchema(format.schema)
+        }
     };
 }
 export function anthropicMessages(body, model) {
@@ -211,7 +334,7 @@ export function anthropicMessages(body, model) {
     const translatedOutput = selection.mode === "effort" ? { effort: selection.effort } : undefined;
     const thinking = metadata?.thinking ?? translatedThinking;
     const structuredOutputFormat = anthropicStructuredOutputFormat(body.response_format);
-    const outputConfig = metadata?.output_config != null
+    const outputConfig = sanitizedAnthropicOutputConfig(metadata?.output_config != null
         ? {
             ...metadata.output_config,
             ...(structuredOutputFormat !== undefined &&
@@ -224,7 +347,7 @@ export function anthropicMessages(body, model) {
                 ...translatedOutput,
                 ...(structuredOutputFormat !== undefined ? { format: structuredOutputFormat } : {})
             }
-            : undefined;
+            : undefined);
     const toolChoice = anthropicToolChoice(body.tool_choice, body.parallel_tool_calls);
     return {
         model,
@@ -246,7 +369,7 @@ export function anthropicMessages(body, model) {
                         {
                             name: tool.function.name,
                             description: tool.function.description,
-                            input_schema: tool.function.parameters ?? { type: "object" }
+                            input_schema: anthropicStructuredOutputSchema(tool.function.parameters ?? { type: "object" })
                         }
                     ])
             }

package/dist/test/provider-validation-anthropic.test.js

@@ -35,6 +35,177 @@ test("Responses JSON schemas reach Anthropic as native structured output formats
         }
     });
 });
+test("Anthropic structured outputs defer unsupported JSON Schema constraints", () => {
+    const schema = {
+        type: "object",
+        additionalProperties: false,
+        required: ["minimum", "scores", "labels"],
+        properties: {
+            minimum: { type: "integer", minimum: 1, maximum: 16_384 },
+            scores: {
+                type: "array",
+                minItems: 20,
+                maxItems: 20,
+                items: { type: "number", minimum: 0, maximum: 1 }
+            },
+            labels: {
+                type: "array",
+                minItems: 1,
+                items: { type: "string", minLength: 1, maxLength: 128 }
+            }
+        }
+    };
+    const original = structuredClone(schema);
+    const outbound = anthropicMessages({
+        model: "claude-opus-5",
+        messages: [{ role: "user", content: "author evaluations" }],
+        response_format: {
+            type: "json_schema",
+            json_schema: { name: "routekit_evaluations", schema, strict: true }
+        }
+    }, "claude-opus-5");
+    assert.deepEqual(schema, original);
+    assert.deepEqual(outbound.output_config, {
+        format: {
+            type: "json_schema",
+            schema: {
+                type: "object",
+                additionalProperties: false,
+                required: ["minimum", "scores", "labels"],
+                properties: {
+                    minimum: {
+                        type: "integer",
+                        description: "{minimum: 1, maximum: 16384}"
+                    },
+                    scores: {
+                        type: "array",
+                        items: {
+                            type: "number",
+                            description: "{minimum: 0, maximum: 1}"
+                        },
+                        description: "{minItems: 20, maxItems: 20}"
+                    },
+                    labels: {
+                        type: "array",
+                        minItems: 1,
+                        items: {
+                            type: "string",
+                            description: "{minLength: 1, maxLength: 128}"
+                        }
+                    }
+                }
+            }
+        }
+    });
+    const nativeOutbound = anthropicMessages(anthropicToChat({
+        model: "claude-opus-5",
+        messages: [{ role: "user", content: "author evaluations" }],
+        output_config: {
+            format: { type: "json_schema", schema }
+        }
+    }, "claude-opus-5"), "claude-opus-5");
+    assert.deepEqual(nativeOutbound.output_config, outbound.output_config);
+});
+test("Anthropic tool input schemas defer unsupported JSON Schema constraints", () => {
+    const parameters = {
+        type: "object",
+        additionalProperties: false,
+        required: ["limit", "scores"],
+        properties: {
+            limit: { type: "integer", minimum: 1, maximum: 16_384 },
+            scores: {
+                type: "array",
+                minItems: 20,
+                maxItems: 20,
+                items: { type: "number", minimum: 0, maximum: 1 }
+            }
+        }
+    };
+    const original = structuredClone(parameters);
+    const outbound = anthropicMessages({
+        model: "claude-opus-5",
+        messages: [{ role: "user", content: "score the inputs" }],
+        tools: [
+            {
+                type: "function",
+                function: {
+                    name: "score_inputs",
+                    description: "score structured inputs",
+                    parameters
+                }
+            }
+        ]
+    }, "claude-opus-5");
+    assert.deepEqual(parameters, original);
+    assert.deepEqual(outbound.tools, [
+        {
+            name: "score_inputs",
+            description: "score structured inputs",
+            input_schema: {
+                type: "object",
+                additionalProperties: false,
+                required: ["limit", "scores"],
+                properties: {
+                    limit: {
+                        type: "integer",
+                        description: "{minimum: 1, maximum: 16384}"
+                    },
+                    scores: {
+                        type: "array",
+                        items: {
+                            type: "number",
+                            description: "{minimum: 0, maximum: 1}"
+                        },
+                        description: "{minItems: 20, maxItems: 20}"
+                    }
+                }
+            }
+        }
+    ]);
+});
+test("Anthropic structured outputs keep only supported schema keywords and formats", () => {
+    const outbound = anthropicMessages({
+        model: "claude-opus-5",
+        messages: [{ role: "user", content: "return a structured value" }],
+        response_format: {
+            type: "json_schema",
+            json_schema: {
+                name: "routekit_supported_schema",
+                strict: true,
+                schema: {
+                    type: "object",
+                    minProperties: 1,
+                    properties: {
+                        identifier: {
+                            type: "string",
+                            pattern: "^[a-z]+$",
+                            format: "regex"
+                        },
+                        createdAt: {
+                            type: "string",
+                            format: "date-time"
+                        },
+                        choice: {
+                            oneOf: [{ const: "one" }, { const: "two" }]
+                        }
+                    },
+                    required: ["identifier", "createdAt", "choice"],
+                    additionalProperties: false
+                }
+            }
+        }
+    }, "claude-opus-5");
+    const schema = outbound.output_config.format.schema;
+    const properties = schema.properties;
+    assert.equal(schema.minProperties, undefined);
+    assert.match(schema.description, /minProperties/u);
+    assert.equal(properties.identifier.format, undefined);
+    assert.equal(properties.identifier.pattern, "^[a-z]+$");
+    assert.match(properties.identifier.description, /format/u);
+    assert.equal(properties.createdAt.format, "date-time");
+    assert.equal(properties.choice.oneOf, undefined);
+    assert.deepEqual(properties.choice.anyOf, [{ const: "one" }, { const: "two" }]);
+});
 test("direct provider backends reject malformed reasoning controls before transport", async () => {
     const cases = [
         {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-gateway",
   "private": false,
-  "version": "1.0.7",
+  "version": "1.0.8",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/routekit.git",
@@ -45,12 +45,12 @@
     "@aws-sdk/client-bedrock": "3.1095.0",
     "@aws-sdk/client-bedrock-runtime": "3.1095.0",
     "effect": "4.0.0-rc.108",
-    "@velum-labs/routekit-config-core": "1.0.7",
-    "@velum-labs/routekit-contracts": "1.0.7",
-    "@velum-labs/routekit-eval-contracts": "1.0.7",
-    "@velum-labs/routekit-eval-core": "1.0.7",
-    "@velum-labs/routekit-registry": "1.0.7",
-    "@velum-labs/routekit-runtime": "1.0.7"
+    "@velum-labs/routekit-config-core": "1.0.8",
+    "@velum-labs/routekit-contracts": "1.0.8",
+    "@velum-labs/routekit-eval-contracts": "1.0.8",
+    "@velum-labs/routekit-eval-core": "1.0.8",
+    "@velum-labs/routekit-registry": "1.0.8",
+    "@velum-labs/routekit-runtime": "1.0.8"
   },
   "keywords": [
     "routekit",