fix(anthropic): strip Codex's Responses-only encrypted marker from tool input_schema (#85)

Author: lidge-jun

src/adapters/anthropic.ts

@@ -487,9 +487,37 @@ function toolsToAnthropicFormat(parsed: OcxParsedRequest, toolNames: { toWire: (
   return converted;
 }
 
+// Codex multi-agent v2 stamps a Responses-only `encrypted: true` marker on
+// collaboration tool schemas (openai/codex 5f4d06ef; issue #85). It is an
+// annotation for the ChatGPT backend only. Anthropic input_schema is strict
+// JSON Schema; strip the marker defensively everywhere it can appear as a
+// schema keyword, while preserving properties literally named "encrypted".
+const ENCRYPTED_MARKER_NAME_BAG_KEYS = new Set(["properties", "patternProperties", "$defs", "definitions"]);
+const ENCRYPTED_MARKER_LITERAL_VALUE_KEYS = new Set(["const", "default", "enum", "examples"]);
+
+function stripEncryptedMarker(node: unknown, inNameBag = false): unknown {
+  if (Array.isArray(node)) return node.map(item => stripEncryptedMarker(item));
+  if (!node || typeof node !== "object") return node;
+
+  const out: Record<string, unknown> = {};
+
+  for (const [key, value] of Object.entries(node as Record<string, unknown>)) {
+    if (inNameBag) {
+      out[key] = stripEncryptedMarker(value);
+    } else if (key !== "encrypted") {
+      out[key] = ENCRYPTED_MARKER_LITERAL_VALUE_KEYS.has(key)
+        ? value
+        : stripEncryptedMarker(value, ENCRYPTED_MARKER_NAME_BAG_KEYS.has(key));
+    }
+  }
+
+  return out;
+}
+
 function normalizeAnthropicInputSchema(schema: unknown): Record<string, unknown> {
-  const obj = schema && typeof schema === "object" && !Array.isArray(schema)
-    ? schema as Record<string, unknown>
+  const stripped = stripEncryptedMarker(schema);
+  const obj = stripped && typeof stripped === "object" && !Array.isArray(stripped)
+    ? stripped as Record<string, unknown>
     : {};
   // Anthropic rejects root-level missing type and oneOf/anyOf/allOf in input_schema.
   // Normalize the root only: ensure type:"object" + properties, flatten root composition

tests/anthropic-tool-schema.test.ts

@@ -106,4 +106,79 @@ describe("anthropic tool input_schema normalization", () => {
       },
     });
   });
+
+  test("strips Codex's Responses-only encrypted marker from collaboration schemas", () => {
+    const inputSchema = toolSchema({
+      type: "object",
+      properties: {
+        message: { type: "string", encrypted: true },
+      },
+      required: ["message"],
+    });
+
+    expect(JSON.stringify(inputSchema)).not.toContain('"encrypted"');
+    expect(inputSchema.properties).toEqual({ message: { type: "string" } });
+    expect(inputSchema.required).toEqual(["message"]);
+  });
+
+  test("preserves a property literally named encrypted", () => {
+    expect(toolSchema({
+      type: "object",
+      properties: { encrypted: { type: "boolean" } },
+    }).properties).toEqual({ encrypted: { type: "boolean" } });
+  });
+
+  test("strips the marker under items, nested properties, and flattened root anyOf branches", () => {
+    const inputSchema = toolSchema({
+      type: "object",
+      properties: {
+        list: { type: "array", items: { type: "string", encrypted: true } },
+        outer: {
+          type: "object",
+          properties: { nested: { type: "number", encrypted: true } },
+        },
+      },
+      anyOf: [
+        { type: "object", properties: { fromBranch: { type: "boolean", encrypted: true } } },
+      ],
+    });
+
+    const properties = inputSchema.properties as Record<string, Record<string, unknown>>;
+    expect((properties.list.items as Record<string, unknown>).encrypted).toBeUndefined();
+    expect(((properties.outer.properties as Record<string, Record<string, unknown>>).nested).encrypted).toBeUndefined();
+    expect(properties.fromBranch.encrypted).toBeUndefined();
+  });
+
+  test("preserves literal encrypted values, required names, and encrypted definition names", () => {
+    const inputSchema = toolSchema({
+      type: "object",
+      default: { encrypted: true },
+      required: ["encrypted"],
+      $defs: { encrypted: { type: "string" } },
+      properties: {
+        constant: { const: { encrypted: true } },
+        choices: { enum: [{ encrypted: true }] },
+      },
+    });
+
+    expect(inputSchema.default).toEqual({ encrypted: true });
+    expect(inputSchema.required).toEqual(["encrypted"]);
+    expect(inputSchema.$defs).toEqual({ encrypted: { type: "string" } });
+    expect(inputSchema.properties).toEqual({
+      constant: { const: { encrypted: true } },
+      choices: { enum: [{ encrypted: true }] },
+    });
+  });
+
+  test("does not mutate the input schema", () => {
+    const schema = {
+      type: "object",
+      properties: { message: { type: "string", encrypted: true } },
+    };
+    const before = structuredClone(schema);
+
+    toolSchema(schema);
+
+    expect(schema).toEqual(before);
+  });
 });