fix(agents): skip unreadable Anthropic tool schemas

vincentkoc · vincentkoc · commit 9a29bd9750e3 · 2026-06-03T00:21:21.000+02:00
diff --git a/src/agents/anthropic-transport-stream.test.ts b/src/agents/anthropic-transport-stream.test.ts
@@ -649,6 +649,16 @@ describe("anthropic transport stream", () => {
         },
       },
     });
+    const unreadableNameTool = {
+      description: "Broken name",
+      parameters: { type: "object", properties: {} },
+    };
+    Object.defineProperty(unreadableNameTool, "name", {
+      enumerable: true,
+      get() {
+        throw new Error("anthropic tool name exploded");
+      },
+    });
     const streamFn = createAnthropicMessagesTransportStreamFn();
     const stream = await Promise.resolve(
       streamFn(
@@ -657,6 +667,7 @@ describe("anthropic transport stream", () => {
           systemPrompt: "Follow policy.",
           messages: [{ role: "user", content: "Read the file" }],
           tools: [
+            unreadableNameTool,
             {
               name: "read",
               description: "Read a file",
@@ -1221,6 +1232,25 @@ describe("anthropic transport stream", () => {
   });
 
   it("skips malformed tools when building Anthropic payloads", async () => {
+    const unreadableParametersTool = {
+      name: "bad_parameters_tool",
+      description: "unreadable schema",
+      execute: async () => ({ content: [{ type: "text", text: "bad" }] }),
+    };
+    Object.defineProperty(unreadableParametersTool, "parameters", {
+      enumerable: true,
+      get() {
+        throw new Error("anthropic tool parameters exploded");
+      },
+    });
+    const unreadablePropertiesSchema: Record<string, unknown> = { type: "object" };
+    Object.defineProperty(unreadablePropertiesSchema, "properties", {
+      enumerable: true,
+      get() {
+        throw new Error("anthropic tool properties exploded");
+      },
+    });
+
     await runTransportStream(
       makeAnthropicTransportModel(),
       {
@@ -1231,6 +1261,21 @@ describe("anthropic transport stream", () => {
             description: "missing schema",
             execute: async () => ({ content: [{ type: "text", text: "bad" }] }),
           },
+          unreadableParametersTool,
+          {
+            name: "bad_properties_tool",
+            description: "unreadable properties",
+            parameters: unreadablePropertiesSchema,
+          },
+          {
+            name: "null_schema_fields_tool",
+            description: "null schema fields",
+            parameters: {
+              type: "object",
+              properties: null,
+              required: null,
+            },
+          },
           {
             name: "good_plugin_tool",
             description: "valid schema",
@@ -1250,8 +1295,13 @@ describe("anthropic transport stream", () => {
     );
 
     const tools = requireArray(latestAnthropicRequest().payload.tools, "tools");
-    expect(tools).toHaveLength(1);
-    const tool = requireRecord(tools[0], "tool");
+    expect(tools).toHaveLength(2);
+    const nullFieldTool = findRecord(tools, (record) => record.name === "null_schema_fields_tool");
+    expect(requireRecord(nullFieldTool.input_schema, "input schema")).toMatchObject({
+      properties: {},
+      required: [],
+    });
+    const tool = findRecord(tools, (record) => record.name === "good_plugin_tool");
     expect(tool.name).toBe("good_plugin_tool");
     expect(requireRecord(tool.input_schema, "input schema").properties).toEqual({
       query: { type: "string" },
diff --git a/src/agents/anthropic-transport-stream.ts b/src/agents/anthropic-transport-stream.ts
@@ -243,11 +243,16 @@ function toClaudeCodeName(name: string): string {
 function fromClaudeCodeName(name: string, tools: Context["tools"] | undefined): string {
   if (tools && tools.length > 0) {
     const lowerName = normalizeLowercaseStringOrEmpty(name);
-    const matchedTool = tools.find(
-      (tool) => normalizeLowercaseStringOrEmpty(tool.name) === lowerName,
-    );
-    if (matchedTool) {
-      return matchedTool.name;
+    for (const tool of tools) {
+      let toolName: unknown;
+      try {
+        toolName = tool.name;
+      } catch {
+        continue;
+      }
+      if (typeof toolName === "string" && normalizeLowercaseStringOrEmpty(toolName) === lowerName) {
+        return toolName;
+      }
     }
   }
   return name;
@@ -474,6 +479,31 @@ function ensureNonEmptyAnthropicMessages(messages: Array<Record<string, unknown>
     : [{ role: "user", content: EMPTY_ANTHROPIC_MESSAGES_FALLBACK_TEXT }];
 }
 
+type AnthropicToolCandidate = NonNullable<Context["tools"]>[number];
+type AnthropicToolFieldRead = { readable: true; value: unknown } | { readable: false };
+
+function readAnthropicToolField(
+  tool: AnthropicToolCandidate,
+  field: "name" | "description" | "parameters",
+): AnthropicToolFieldRead {
+  try {
+    return { readable: true, value: (tool as unknown as Record<string, unknown>)[field] };
+  } catch {
+    return { readable: false };
+  }
+}
+
+function readAnthropicSchemaField(
+  schema: Record<string, unknown>,
+  field: "properties" | "required",
+): AnthropicToolFieldRead {
+  try {
+    return { readable: true, value: schema[field] };
+  } catch {
+    return { readable: false };
+  }
+}
+
 function convertAnthropicTools(tools: Context["tools"], isOAuthToken: boolean) {
   if (!tools) {
     return [];
@@ -490,20 +520,43 @@ 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 nameRead = readAnthropicToolField(tool, "name");
+    const parametersRead = readAnthropicToolField(tool, "parameters");
+    if (!nameRead.readable || !parametersRead.readable) {
+      continue;
+    }
+    const rawParameters = parametersRead.value;
     const parameters =
-      tool.parameters && typeof tool.parameters === "object" && !Array.isArray(tool.parameters)
-        ? (tool.parameters as Record<string, unknown>)
+      rawParameters && typeof rawParameters === "object" && !Array.isArray(rawParameters)
+        ? (rawParameters as Record<string, unknown>)
         : undefined;
-    if (!parameters) {
+    if (typeof nameRead.value !== "string" || !parameters) {
+      continue;
+    }
+    const propertiesRead = readAnthropicSchemaField(parameters, "properties");
+    const requiredRead = readAnthropicSchemaField(parameters, "required");
+    const descriptionRead = readAnthropicToolField(tool, "description");
+    if (!propertiesRead.readable || !requiredRead.readable) {
+      continue;
+    }
+    const properties = propertiesRead.value;
+    const required = requiredRead.value;
+    if (
+      (properties !== undefined && properties !== null && typeof properties !== "object") ||
+      (required !== undefined && required !== null && !Array.isArray(required))
+    ) {
       continue;
     }
     converted.push({
-      name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name,
-      description: tool.description,
+      name: isOAuthToken ? toClaudeCodeName(nameRead.value) : nameRead.value,
+      description:
+        descriptionRead.readable && typeof descriptionRead.value === "string"
+          ? descriptionRead.value
+          : undefined,
       input_schema: {
         type: "object",
-        properties: parameters.properties || {},
-        required: parameters.required || [],
+        properties: properties ?? {},
+        required: required ?? [],
       },
     });
   }
