fix(agents): guard Anthropic tool schema conversion

vincentkoc · vincentkoc · commit c5fe109329f5 · 2026-06-04T09:43:21.000+02:00
diff --git a/src/agents/anthropic-transport-stream.test.ts b/src/agents/anthropic-transport-stream.test.ts
@@ -1258,6 +1258,69 @@ describe("anthropic transport stream", () => {
     });
   });
 
+  it("skips tools with unreadable schemas when building Anthropic payloads", async () => {
+    const unreadableTool = {
+      name: "bad_plugin_tool",
+      description: "unreadable schema",
+      parameters: {
+        type: "object",
+        properties: {},
+      },
+      execute: async () => ({ content: [{ type: "text", text: "bad" }] }),
+    };
+    Object.defineProperty(unreadableTool, "parameters", {
+      enumerable: true,
+      get() {
+        throw new Error("fuzzplugin parameters getter exploded");
+      },
+    });
+    const unreadablePropertiesTool = {
+      name: "bad_nested_plugin_tool",
+      description: "unreadable nested schema",
+      parameters: {
+        type: "object",
+        properties: {},
+      },
+      execute: async () => ({ content: [{ type: "text", text: "bad" }] }),
+    };
+    Object.defineProperty(unreadablePropertiesTool.parameters, "properties", {
+      enumerable: true,
+      get() {
+        throw new Error("fuzzplugin properties getter exploded");
+      },
+    });
+
+    await runTransportStream(
+      makeAnthropicTransportModel(),
+      {
+        messages: [{ role: "user", content: "hello" }],
+        tools: [
+          unreadableTool,
+          unreadablePropertiesTool,
+          {
+            name: "good_plugin_tool",
+            description: "valid schema",
+            parameters: {
+              type: "object",
+              properties: {
+                query: { type: "string" },
+              },
+              required: ["query"],
+            },
+          },
+        ],
+      } as unknown as AnthropicStreamContext,
+      {
+        apiKey: "sk-ant-api",
+      } as AnthropicStreamOptions,
+    );
+
+    const tools = requireArray(latestAnthropicRequest().payload.tools, "tools");
+    expect(tools).toHaveLength(1);
+    const tool = requireRecord(tools[0], "tool");
+    expect(tool.name).toBe("good_plugin_tool");
+  });
+
   it("coerces replayed malformed tool-call args to an object for Anthropic payloads", async () => {
     const model = makeAnthropicTransportModel({
       requestTransport: {
diff --git a/src/agents/anthropic-transport-stream.ts b/src/agents/anthropic-transport-stream.ts
@@ -490,26 +490,58 @@ function convertAnthropicTools(tools: Context["tools"], isOAuthToken: boolean) {
   for (const tool of tools) {
     // Main quarantine happens when plugin tools materialize; this keeps Anthropic
     // safe for direct/custom tool arrays that bypass the plugin registry.
-    const parameters =
-      tool.parameters && typeof tool.parameters === "object" && !Array.isArray(tool.parameters)
-        ? (tool.parameters as Record<string, unknown>)
-        : undefined;
-    if (!parameters) {
+    const snapshot = readAnthropicToolSnapshot(tool);
+    if (!snapshot) {
       continue;
     }
     converted.push({
-      name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name,
-      description: tool.description,
+      name: isOAuthToken ? toClaudeCodeName(snapshot.name) : snapshot.name,
+      ...(snapshot.description !== undefined ? { description: snapshot.description } : {}),
       input_schema: {
         type: "object",
-        properties: parameters.properties || {},
-        required: parameters.required || [],
+        properties: snapshot.properties,
+        required: snapshot.required,
       },
     });
   }
   return converted;
 }
 
+type AnthropicToolSnapshot = {
+  name: string;
+  description?: string;
+  properties: unknown;
+  required: unknown;
+};
+
+function readAnthropicToolSnapshot(
+  tool: NonNullable<Context["tools"]>[number],
+): AnthropicToolSnapshot | undefined {
+  try {
+    const name = tool.name;
+    const parameters = tool.parameters;
+    if (
+      typeof name !== "string" ||
+      !name.trim() ||
+      !parameters ||
+      typeof parameters !== "object" ||
+      Array.isArray(parameters)
+    ) {
+      return undefined;
+    }
+    const description = typeof tool.description === "string" ? tool.description : undefined;
+    const record = parameters as Record<string, unknown>;
+    return {
+      name,
+      ...(description !== undefined ? { description } : {}),
+      properties: record.properties || {},
+      required: record.required || [],
+    };
+  } catch {
+    return undefined;
+  }
+}
+
 function parseAnthropicToolCallArguments(inputJson: string): unknown {
   return parseJsonObjectPreservingUnsafeIntegers(inputJson) ?? parseStreamingJson(inputJson);
 }
