fix(claude): state strict on a translated json_schema instead of letting it default

src/adapters/anthropic-output-schema.ts

@@ -135,3 +135,35 @@ export function isAnthropicOutputSchema(schema: Record<string, unknown>): boolea
     return false;
   }
 }
+
+/**
+ * Does every object in this schema list ALL of its properties as required?
+ *
+ * OpenAI's structured-output strict mode demands exactly that, and rejects anything else with
+ * `'required' is required to be supplied and to be an array including every key in properties`.
+ * Anthropic has no such rule, so a caller's legal optional field makes an otherwise identical
+ * schema a 400 on one vendor and fine on the other.
+ *
+ * A caller that marks a field optional means it. Rewriting `required` to satisfy strict mode
+ * would silently change the contract the caller asked for, so the only honest answer is to stop
+ * claiming strict for these schemas -- the schema is still sent and still honoured as guidance.
+ */
+export function satisfiesOpenAiStrictSchema(value: unknown): boolean {
+  if (Array.isArray(value)) return value.every(satisfiesOpenAiStrictSchema);
+  if (!value || typeof value !== "object") return true;
+  const node = value as Record<string, unknown>;
+  // `allOf` is not supported under strict Structured Outputs at all, wherever it appears.
+  if ("allOf" in node) return false;
+  const properties = node.properties;
+  if (isRecord(properties)) {
+    // An object node must list every property in `required` AND close itself to extras. The
+    // caller's schema is forwarded verbatim -- `isAnthropicOutputSchema` normalizes a CLONE for
+    // its own acceptance check -- so an object that never said `additionalProperties: false`
+    // reaches the wire without it and is refused, however complete its `required` is.
+    if (node.additionalProperties !== false) return false;
+    const keys = Object.keys(properties);
+    const required = Array.isArray(node.required) ? node.required : [];
+    if (keys.some(key => !required.includes(key))) return false;
+  }
+  return Object.values(node).every(satisfiesOpenAiStrictSchema);
+}

src/claude/inbound-model-options.ts

@@ -1,5 +1,5 @@
 import type { OcxClaudeCodeConfig } from "../types";
-import { isAnthropicOutputSchema } from "../adapters/anthropic-output-schema";
+import { isAnthropicOutputSchema, satisfiesOpenAiStrictSchema } from "../adapters/anthropic-output-schema";
 import { resolveAlias } from "./alias";
 import { stripOneMillionMarker } from "./context-windows";
 import { isUnresolvedDesktop3pAlias, resolveDesktop3pAlias } from "./desktop-3p";
@@ -104,7 +104,18 @@ export function formatFromOutputConfig(outputConfig: unknown): Rec | undefined {
     || !isRec(format.schema)
     || !isAnthropicOutputSchema(format.schema)
   ) return undefined;
-  return { type: "json_schema", name: "response", schema: format.schema };
+  // `strict` is stated rather than left to the destination's default. A schema with an optional
+  // property is legal to Anthropic and a hard 400 under OpenAI strict mode ("'required' ... an
+  // array including every key in properties"), which takes down every structured-output turn on
+  // a route whose canonical target is unavailable. Satisfying strict by adding the missing keys
+  // to `required` would change the caller's contract, so the optionality is preserved and the
+  // strict claim is dropped instead.
+  return {
+    type: "json_schema",
+    name: "response",
+    schema: format.schema,
+    strict: satisfiesOpenAiStrictSchema(format.schema),
+  };
 }
 
 /**

tests/claude-integration/claude-inbound.test.ts

@@ -273,8 +273,70 @@ describe("claude inbound translation", () => {
       output_config: { format: { type: "json_schema", schema } },
     });
 
-    expect(body.text).toEqual({ format: { type: "json_schema", name: "response", schema } });
-    expect(parseRequest(body).options.textFormat).toEqual({ type: "json_schema", name: "response", schema });
+    expect(body.text).toEqual({ format: { type: "json_schema", name: "response", schema, strict: true } });
+    expect(parseRequest(body).options.textFormat).toEqual({ type: "json_schema", name: "response", schema, strict: true });
+  });
+
+  test("an optional property drops the strict claim instead of rewriting required", () => {
+    const optional = {
+      type: "object",
+      properties: { answer: { type: "string" }, note: { type: "string" } },
+      required: ["answer"],
+      additionalProperties: false,
+    };
+    const body = anthropicToResponsesBody({
+      model: "claude-sonnet-5",
+      max_tokens: 256,
+      messages: [{ role: "user", content: "Return JSON" }],
+      output_config: { format: { type: "json_schema", schema: optional } },
+    });
+
+    // OpenAI strict mode 400s on a schema whose `required` omits any property; Anthropic allows
+    // it. Say strict: false rather than leave the destination's default to decide -- and leave
+    // `required` exactly as the caller wrote it.
+    expect(body.text).toEqual({ format: { type: "json_schema", name: "response", schema: optional, strict: false } });
+    expect((body.text as { format: { schema: { required: string[] } } }).format.schema.required).toEqual(["answer"]);
+    expect(parseRequest(body).options.textFormat?.strict).toBe(false);
+  });
+
+  test("an open object drops the strict claim even when every property is required", () => {
+    // `isAnthropicOutputSchema` normalizes a CLONE, so an object that never stated
+    // `additionalProperties: false` is forwarded verbatim and refused by strict mode however
+    // complete its `required` is.
+    const open = {
+      type: "object",
+      properties: { answer: { type: "string" } },
+      required: ["answer"],
+    };
+    const body = anthropicToResponsesBody({
+      model: "claude-sonnet-5",
+      max_tokens: 256,
+      messages: [{ role: "user", content: "Return JSON" }],
+      output_config: { format: { type: "json_schema", schema: open } },
+    });
+
+    expect(body.text).toEqual({ format: { type: "json_schema", name: "response", schema: open, strict: false } });
+    expect(parseRequest(body).options.textFormat?.strict).toBe(false);
+  });
+
+  test("allOf drops the strict claim; strict Structured Outputs does not support it", () => {
+    const composed = {
+      type: "object",
+      properties: {
+        answer: { allOf: [{ type: "string" }, { type: "string", minLength: 1 }] },
+      },
+      required: ["answer"],
+      additionalProperties: false,
+    };
+    const body = anthropicToResponsesBody({
+      model: "claude-sonnet-5",
+      max_tokens: 256,
+      messages: [{ role: "user", content: "Return JSON" }],
+      output_config: { format: { type: "json_schema", schema: composed } },
+    });
+
+    expect(body.text).toEqual({ format: { type: "json_schema", name: "response", schema: composed, strict: false } });
+    expect(parseRequest(body).options.textFormat?.strict).toBe(false);
   });
 
   test("structured output rejects unsupported schemas and preserves root references", () => {
@@ -300,7 +362,7 @@ describe("claude inbound translation", () => {
 
     expect(invalid.text).toBeUndefined();
     expect(referenced.text).toEqual({
-      format: { type: "json_schema", name: "response", schema: refSchema },
+      format: { type: "json_schema", name: "response", schema: refSchema, strict: false },
     });
   });