fix(agents): guard OpenAI strict tool diagnostics

vincentkoc · vincentkoc · commit fbff21b6dc69 · 2026-06-04T08:25:05.000+02:00
diff --git a/src/agents/openai-tool-schema.test.ts b/src/agents/openai-tool-schema.test.ts
@@ -1,6 +1,7 @@
 import { beforeEach, describe, expect, it } from "vitest";
 import {
   clearOpenAIToolSchemaCacheForTest,
+  findOpenAIStrictToolSchemaDiagnostics,
   isStrictOpenAIJsonSchemaCompatible,
   normalizeStrictOpenAIJsonSchema,
   resolveOpenAIStrictToolFlagForInventory,
@@ -91,4 +92,26 @@ describe("OpenAI strict tool schema normalization", () => {
       }),
     ).toBe(third);
   });
+
+  it("reports unreadable strict tool parameters without throwing", () => {
+    const unreadable = {
+      name: "fuzzplugin_unreadable",
+      parameters: { type: "object", properties: {} },
+    };
+    Object.defineProperty(unreadable, "parameters", {
+      enumerable: true,
+      get() {
+        throw new Error("fuzzplugin parameters getter exploded");
+      },
+    });
+
+    expect(resolveOpenAIStrictToolFlagForInventory([unreadable], true)).toBe(false);
+    expect(findOpenAIStrictToolSchemaDiagnostics([unreadable])).toEqual([
+      {
+        toolIndex: 0,
+        toolName: "fuzzplugin_unreadable",
+        violations: ["fuzzplugin_unreadable.parameters is unreadable"],
+      },
+    ]);
+  });
 });
diff --git a/src/agents/openai-tool-schema.ts b/src/agents/openai-tool-schema.ts
@@ -18,9 +18,50 @@ type ToolWithParameters = {
   parameters: unknown;
 };
 
+type ToolFieldRead<TField extends keyof ToolWithParameters> =
+  | { readable: true; value: ToolWithParameters[TField] }
+  | { readable: false };
+
 const MAX_STRICT_SCHEMA_CACHE_ENTRIES_PER_SCHEMA = 8;
 let strictOpenAISchemaCache = new WeakMap<object, Array<{ key: string; value: unknown }>>();
 
+function readToolField<TField extends keyof ToolWithParameters>(
+  tool: ToolWithParameters,
+  field: TField,
+): ToolFieldRead<TField> {
+  try {
+    return { readable: true, value: tool[field] };
+  } catch {
+    return { readable: false };
+  }
+}
+
+function readToolName(tool: ToolWithParameters, toolIndex: number): {
+  toolName: string;
+  diagnosticToolName?: string;
+  violations: string[];
+} {
+  const nameRead = readToolField(tool, "name");
+  if (!nameRead.readable) {
+    const toolName = `tool[${toolIndex}]`;
+    return {
+      toolName,
+      violations: [`${toolName}.name is unreadable`],
+    };
+  }
+  if (typeof nameRead.value === "string" && nameRead.value) {
+    return {
+      toolName: nameRead.value,
+      diagnosticToolName: nameRead.value,
+      violations: [],
+    };
+  }
+  return {
+    toolName: `tool[${toolIndex}]`,
+    violations: [],
+  };
+}
+
 function resolveToolSchemaModelCompat(
   compat: ToolSchemaCompatInput | null | undefined,
 ): ModelCompatConfig | undefined {
@@ -179,18 +220,33 @@ export function findOpenAIStrictToolSchemaDiagnostics(
   tools: readonly ToolWithParameters[],
 ): OpenAIStrictToolSchemaDiagnostic[] {
   return tools.flatMap((tool, toolIndex) => {
+    const nameRead = readToolName(tool, toolIndex);
+    const parametersRead = readToolField(tool, "parameters");
+    if (!parametersRead.readable) {
+      return [
+        {
+          toolIndex,
+          ...(nameRead.diagnosticToolName ? { toolName: nameRead.diagnosticToolName } : {}),
+          violations: [
+            ...nameRead.violations,
+            `${nameRead.toolName}.parameters is unreadable`,
+          ],
+        },
+      ];
+    }
     const violations = findStrictOpenAIJsonSchemaViolations(
-      normalizeStrictOpenAIJsonSchema(tool.parameters),
-      `${typeof tool.name === "string" && tool.name ? tool.name : `tool[${toolIndex}]`}.parameters`,
+      normalizeStrictOpenAIJsonSchema(parametersRead.value),
+      `${nameRead.toolName}.parameters`,
     );
-    if (violations.length === 0) {
+    const allViolations = [...nameRead.violations, ...violations];
+    if (allViolations.length === 0) {
       return [];
     }
     return [
       {
         toolIndex,
-        ...(typeof tool.name === "string" && tool.name ? { toolName: tool.name } : {}),
-        violations,
+        ...(nameRead.diagnosticToolName ? { toolName: nameRead.diagnosticToolName } : {}),
+        violations: allViolations,
       },
     ];
   });
@@ -317,5 +373,8 @@ export function resolveOpenAIStrictToolFlagForInventory(
   if (strict !== true) {
     return strict === false ? false : undefined;
   }
-  return tools.every((tool) => isStrictOpenAIJsonSchemaCompatible(tool.parameters));
+  return tools.every((tool) => {
+    const parametersRead = readToolField(tool, "parameters");
+    return parametersRead.readable && isStrictOpenAIJsonSchemaCompatible(parametersRead.value);
+  });
 }
