fix(openai): skip unreadable responses tool schemas

vincentkoc · vincentkoc · commit 1f58a7d90f2c · 2026-06-04T17:37:07.000+02:00
diff --git a/src/agents/openai-transport-stream.test.ts b/src/agents/openai-transport-stream.test.ts
@@ -1,5 +1,5 @@
 import { createServer } from "node:http";
-import type { Api, Model } from "openclaw/plugin-sdk/llm";
+import type { Api, Model, Tool } from "openclaw/plugin-sdk/llm";
 import { describe, expect, it, vi } from "vitest";
 import {
   buildOpenAIResponsesParams,
@@ -4608,6 +4608,69 @@ describe("openai transport stream", () => {
     });
   });
 
+  it("skips unreadable responses transport tools without downgrading healthy strict tools", () => {
+    const { proxy, revoke } = Proxy.revocable({}, {});
+    revoke();
+    const brokenDescriptor = {
+      get name(): string {
+        throw new Error("tool name unavailable");
+      },
+      description: "Broken",
+      parameters: {},
+    } as Tool;
+    const brokenSchema = {
+      name: "broken_schema",
+      description: "Broken",
+      parameters: proxy,
+    } as unknown as Tool;
+
+    const params = buildOpenAIResponsesParams(
+      {
+        id: "gpt-5.4",
+        name: "GPT-5.4",
+        api: "openai-responses",
+        provider: "openai",
+        baseUrl: "https://api.openai.com/v1",
+        reasoning: true,
+        input: ["text"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 200000,
+        maxTokens: 8192,
+      } satisfies Model<"openai-responses">,
+      {
+        systemPrompt: "system",
+        messages: [],
+        tools: [
+          brokenDescriptor,
+          brokenSchema,
+          {
+            name: "lookup_weather",
+            description: "Get forecast",
+            parameters: {},
+          },
+        ],
+      } as never,
+      undefined,
+    ) as {
+      tools?: Array<{ name?: string; strict?: boolean; parameters?: Record<string, unknown> }>;
+    };
+
+    expect(params.tools).toEqual([
+      {
+        type: "function",
+        name: "lookup_weather",
+        description: "Get forecast",
+        strict: true,
+        parameters: {
+          type: "object",
+          properties: {},
+          required: [],
+          additionalProperties: false,
+        },
+      },
+    ]);
+  });
+
   it("passes explicit Responses tool_choice when tools are present", () => {
     const params = buildOpenAIResponsesParams(
       {
diff --git a/src/agents/openai-transport-stream.ts b/src/agents/openai-transport-stream.ts
@@ -26,6 +26,7 @@ import { calculateCost } from "../llm/model-utils.js";
 import { resolveAzureDeploymentNameFromMap } from "../llm/providers/azure-deployment-map.js";
 import { convertMessages } from "../llm/providers/openai-completions.js";
 import { clampOpenAIPromptCacheKey } from "../llm/providers/openai-prompt-cache.js";
+import { convertResponsesTools as convertOpenAIResponsesTools } from "../llm/providers/openai-responses-tools.js";
 import type { Api, Context, Model } from "../llm/types.js";
 import { createAssistantMessageEventStream } from "../llm/utils/event-stream.js";
 import { parseStreamingJson } from "../llm/utils/json-parse.js";
@@ -1274,33 +1275,6 @@ function convertResponsesMessages(
   return messages;
 }
 
-function convertResponsesTools(
-  tools: NonNullable<Context["tools"]>,
-  model: OpenAIModeModel,
-  options?: { strict?: boolean | null },
-): FunctionTool[] {
-  const strict = resolveOpenAIStrictToolFlagWithDiagnostics(tools, options?.strict, {
-    transport: "responses",
-    model,
-  });
-  return sortTransportToolsByName(tools).map((tool): FunctionTool => {
-    const result = {
-      type: "function" as const,
-      name: tool.name,
-      description: tool.description,
-      parameters: normalizeOpenAIStrictToolParameters(
-        tool.parameters,
-        strict === true,
-        model.compat,
-      ) as Record<string, unknown>,
-    } as FunctionTool;
-    if (strict !== undefined) {
-      result.strict = strict;
-    }
-    return result;
-  });
-}
-
 function resolveOpenAIStrictToolFlagWithDiagnostics(
   tools: NonNullable<Context["tools"]>,
   strictSetting: boolean | null | undefined,
@@ -2257,11 +2231,12 @@ export function buildOpenAIResponsesParams(
     params.service_tier = options.serviceTier;
   }
   if (context.tools) {
-    params.tools = convertResponsesTools(context.tools, model as OpenAIModeModel, {
+    params.tools = convertOpenAIResponsesTools(context.tools, {
+      model: model as OpenAIModeModel,
       strict: resolveOpenAIStrictToolSetting(model as OpenAIModeModel, {
         transport: "stream",
       }),
-    });
+    }) as FunctionTool[];
     if (options?.toolChoice) {
       params.tool_choice = options.toolChoice;
     }
diff --git a/src/llm/providers/openai-responses-shared.test.ts b/src/llm/providers/openai-responses-shared.test.ts
@@ -122,6 +122,115 @@ describe("convertResponsesTools", () => {
       convertResponsesTools([zeta, alpha]).map((tool) => expectResponsesFunctionTool(tool).name),
     ).toEqual(["alpha", "zeta"]);
   });
+
+  it("skips unreadable tool descriptors while preserving healthy tools", () => {
+    const broken = {
+      get name(): string {
+        const error = new Error("tool name unavailable");
+        error.toString = () => {
+          throw new Error("unprintable tool error");
+        };
+        throw error;
+      },
+      description: "Broken",
+      parameters: {},
+    } as Tool;
+    const healthy = {
+      name: "lookup_weather",
+      description: "Get forecast",
+      parameters: {},
+    } satisfies Tool;
+
+    const converted = convertResponsesTools([broken, healthy], { model: nativeOpenAIModel });
+
+    expect(converted).toEqual([
+      {
+        type: "function",
+        name: "lookup_weather",
+        description: "Get forecast",
+        strict: true,
+        parameters: {
+          type: "object",
+          properties: {},
+          required: [],
+          additionalProperties: false,
+        },
+      },
+    ]);
+  });
+
+  it("skips unreadable schemas without downgrading healthy strict tools", () => {
+    const { proxy, revoke } = Proxy.revocable({}, {});
+    revoke();
+    const broken = {
+      name: "broken_schema",
+      description: "Broken",
+      parameters: proxy,
+    } as unknown as Tool;
+    const healthy = {
+      name: "lookup_weather",
+      description: "Get forecast",
+      parameters: {},
+    } satisfies Tool;
+
+    const converted = convertResponsesTools([broken, healthy], { model: nativeOpenAIModel });
+
+    expect(converted).toEqual([
+      {
+        type: "function",
+        name: "lookup_weather",
+        description: "Get forecast",
+        strict: true,
+        parameters: {
+          type: "object",
+          properties: {},
+          required: [],
+          additionalProperties: false,
+        },
+      },
+    ]);
+  });
+
+  it("keeps valid shared schemas while skipping cyclic schemas", () => {
+    const sharedProperty = { type: "string" };
+    const sharedSchema = {
+      type: "object",
+      properties: {
+        first: sharedProperty,
+        second: sharedProperty,
+      },
+      required: ["first", "second"],
+      additionalProperties: false,
+    } satisfies Tool["parameters"];
+    const cyclicSchema: Record<string, unknown> = { type: "object" };
+    cyclicSchema.properties = { self: cyclicSchema };
+
+    const converted = convertResponsesTools(
+      [
+        {
+          name: "cyclic_schema",
+          description: "Broken",
+          parameters: cyclicSchema,
+        } as Tool,
+        {
+          name: "shared_schema",
+          description: "Shared",
+          parameters: sharedSchema,
+        },
+      ],
+      { model: nativeOpenAIModel },
+    );
+
+    expect(converted).toEqual([
+      {
+        type: "function",
+        name: "shared_schema",
+        description: "Shared",
+        strict: true,
+        parameters: sharedSchema,
+      },
+    ]);
+  });
 });
 
 describe("convertResponsesMessages", () => {
diff --git a/src/llm/providers/openai-responses-tools.ts b/src/llm/providers/openai-responses-tools.ts
