fix(agents): materialize OpenAI tool schemas

vincentkoc · vincentkoc · commit a9773e25372e · 2026-06-01T10:45:52.000+02:00
diff --git a/src/agents/openai-tool-schema.test.ts b/src/agents/openai-tool-schema.test.ts
@@ -2,6 +2,7 @@ import { beforeEach, describe, expect, it } from "vitest";
 import {
   clearOpenAIToolSchemaCacheForTest,
   isStrictOpenAIJsonSchemaCompatible,
+  normalizeOpenAIStrictToolParameters,
   normalizeStrictOpenAIJsonSchema,
   resolveOpenAIStrictToolFlagForInventory,
 } from "./openai-tool-schema.js";
@@ -91,4 +92,43 @@ describe("OpenAI strict tool schema normalization", () => {
       }),
     ).toBe(third);
   });
+
+  it("shapes OpenAI tool schemas from their JSON view before raw object traversal", () => {
+    const schema = new Proxy(
+      {
+        toJSON() {
+          return {
+            type: "object",
+            properties: {
+              query: { type: "string" },
+            },
+            required: ["query"],
+          };
+        },
+      },
+      {
+        ownKeys() {
+          throw new Error("raw schema traversal");
+        },
+      },
+    );
+
+    expect(normalizeStrictOpenAIJsonSchema(schema)).toEqual({
+      type: "object",
+      properties: {
+        query: { type: "string" },
+      },
+      required: ["query"],
+      additionalProperties: false,
+    });
+    expect(normalizeOpenAIStrictToolParameters(schema, false)).toMatchObject({
+      type: "object",
+      properties: {
+        query: { type: "string" },
+      },
+    });
+    expect(
+      resolveOpenAIStrictToolFlagForInventory([{ name: "lookup", parameters: schema }], true),
+    ).toBe(true);
+  });
 });
diff --git a/src/agents/openai-tool-schema.ts b/src/agents/openai-tool-schema.ts
@@ -14,6 +14,7 @@ type ToolWithParameters = {
 
 const MAX_STRICT_SCHEMA_CACHE_ENTRIES_PER_SCHEMA = 8;
 let strictOpenAISchemaCache = new WeakMap<object, Array<{ key: string; value: unknown }>>();
+let openAISchemaInputCache = new WeakMap<object, unknown>();
 
 function resolveToolSchemaModelCompat(
   compat: ToolSchemaCompatInput | null | undefined,
@@ -63,13 +64,33 @@ function rememberStrictOpenAISchema(schema: object, key: string, value: unknown)
 
 export function clearOpenAIToolSchemaCacheForTest(): void {
   strictOpenAISchemaCache = new WeakMap();
+  openAISchemaInputCache = new WeakMap();
+}
+
+function materializeOpenAIToolSchemaInput(schema: unknown): unknown {
+  const schemaInput = schema ?? {};
+  if (!schemaInput || typeof schemaInput !== "object") {
+    return schemaInput;
+  }
+  if (openAISchemaInputCache.has(schemaInput)) {
+    return openAISchemaInputCache.get(schemaInput);
+  }
+  let materialized: unknown;
+  try {
+    const text = JSON.stringify(schemaInput);
+    materialized = text ? JSON.parse(text) : {};
+  } catch {
+    materialized = {};
+  }
+  openAISchemaInputCache.set(schemaInput, materialized);
+  return materialized;
 }
 
 export function normalizeStrictOpenAIJsonSchema(
   schema: unknown,
   modelCompat?: ToolSchemaCompatInput | null,
 ): unknown {
-  const schemaInput = schema ?? {};
+  const schemaInput = materializeOpenAIToolSchemaInput(schema);
   if (!schemaInput || typeof schemaInput !== "object") {
     return normalizeStrictOpenAIJsonSchemaRecursive(
       normalizeToolParameterSchema(schemaInput, {
@@ -147,10 +168,11 @@ export function normalizeOpenAIStrictToolParameters<T>(
   modelCompat?: ToolSchemaCompatInput | null,
 ): T {
   const toolSchemaCompat = resolveToolSchemaModelCompat(modelCompat);
+  const schemaInput = materializeOpenAIToolSchemaInput(schema);
   if (!strict) {
-    return normalizeToolParameterSchema(schema ?? {}, { modelCompat: toolSchemaCompat }) as T;
+    return normalizeToolParameterSchema(schemaInput ?? {}, { modelCompat: toolSchemaCompat }) as T;
   }
-  return normalizeStrictOpenAIJsonSchema(schema, toolSchemaCompat) as T;
+  return normalizeStrictOpenAIJsonSchema(schemaInput, toolSchemaCompat) as T;
 }
 
 export function isStrictOpenAIJsonSchemaCompatible(schema: unknown): boolean {
