fix(providers): skip unreadable Mistral tool schemas

vincentkoc · vincentkoc · commit 82892ecd7e54 · 2026-06-04T10:16:50.000+02:00
diff --git a/src/llm/providers/mistral.test.ts b/src/llm/providers/mistral.test.ts
@@ -16,7 +16,7 @@ vi.mock("@mistralai/mistralai", () => ({
   },
 }));
 
-import { streamSimpleMistral } from "./mistral.js";
+import { streamMistral, streamSimpleMistral } from "./mistral.js";
 
 function makeMistralModel(): Model<"mistral-conversations"> {
   return {
@@ -37,6 +37,24 @@ const context = {
   messages: [{ role: "user", content: "hello", timestamp: 0 }],
 } satisfies Context;
 
+function makeUnreadableParameterTool() {
+  const tool = {
+    name: "broken_tool",
+    description: "broken tool",
+    parameters: { type: "object", properties: {} },
+    async execute() {
+      return { content: [{ type: "text", text: "broken" }] };
+    },
+  };
+  Object.defineProperty(tool, "parameters", {
+    enumerable: true,
+    get() {
+      throw new Error("fuzzplugin parameters getter exploded");
+    },
+  });
+  return tool;
+}
+
 describe("Mistral provider", () => {
   beforeEach(() => {
     mistralMockState.payloads = [];
@@ -53,4 +71,82 @@ describe("Mistral provider", () => {
     expect(result.stopReason).toBe("error");
     expect((mistralMockState.payloads[0] as { stop?: unknown }).stop).toEqual(["STOP"]);
   });
+
+  it("skips unreadable tool schemas while preserving healthy Mistral tools", async () => {
+    const stream = streamMistral(
+      makeMistralModel(),
+      {
+        ...context,
+        tools: [
+          makeUnreadableParameterTool(),
+          {
+            name: "healthy_tool",
+            description: "healthy tool",
+            parameters: {
+              type: "object",
+              properties: {
+                query: { type: "string" },
+              },
+            },
+            async execute() {
+              return { content: [{ type: "text", text: "ok" }] };
+            },
+          },
+        ] as never,
+      },
+      {
+        apiKey: "sk-mistral-provider",
+      },
+    );
+
+    const result = await stream.result();
+
+    expect(result.stopReason).toBe("error");
+    expect((mistralMockState.payloads[0] as { tools?: unknown[] }).tools).toEqual([
+      {
+        type: "function",
+        function: {
+          name: "healthy_tool",
+          description: "healthy tool",
+          parameters: {
+            type: "object",
+            properties: {
+              query: { type: "string" },
+            },
+          },
+          strict: false,
+        },
+      },
+    ]);
+  });
+
+  it("fails locally when a pinned Mistral tool choice is skipped", async () => {
+    const stream = streamMistral(
+      makeMistralModel(),
+      {
+        ...context,
+        tools: [
+          makeUnreadableParameterTool(),
+          {
+            name: "healthy_tool",
+            description: "healthy tool",
+            parameters: { type: "object", properties: {} },
+            async execute() {
+              return { content: [{ type: "text", text: "ok" }] };
+            },
+          },
+        ] as never,
+      },
+      {
+        apiKey: "sk-mistral-provider",
+        toolChoice: { type: "function", function: { name: "broken_tool" } },
+      },
+    );
+
+    const result = await stream.result();
+
+    expect(result.stopReason).toBe("error");
+    expect(result.errorMessage).toContain('Mistral tool_choice requested unavailable tool "broken_tool"');
+    expect(mistralMockState.payloads).toHaveLength(0);
+  });
 });
diff --git a/src/llm/providers/mistral.ts b/src/llm/providers/mistral.ts
@@ -274,9 +274,14 @@ function buildChatPayload(
     stream: true,
     messages: toChatMessages(messages, model.input.includes("image")),
   };
+  let convertedToolNames: Set<string> | undefined;
 
   if (context.tools?.length) {
-    payload.tools = toFunctionTools(context.tools);
+    const tools = toFunctionTools(context.tools);
+    convertedToolNames = new Set(tools.map((tool) => tool.function.name));
+    if (tools.length > 0) {
+      payload.tools = tools;
+    }
   }
   if (options?.temperature !== undefined) {
     payload.temperature = options.temperature;
@@ -288,7 +293,10 @@ function buildChatPayload(
     payload.stop = options.stop;
   }
   if (options?.toolChoice) {
-    payload.toolChoice = mapToolChoice(options.toolChoice);
+    const toolChoice = mapToolChoice(options.toolChoice, convertedToolNames);
+    if (toolChoice) {
+      payload.toolChoice = toolChoice;
+    }
   }
   if (options?.promptMode) {
     payload.promptMode = options.promptMode;
@@ -506,15 +514,21 @@ async function consumeChatStream(
 }
 
 function toFunctionTools(tools: Tool[]): Array<FunctionTool & { type: "function" }> {
-  return tools.map((tool) => ({
-    type: "function",
-    function: {
-      name: tool.name,
-      description: tool.description,
-      parameters: stripSymbolKeys(tool.parameters) as Record<string, unknown>,
-      strict: false,
-    },
-  }));
+  return tools.flatMap((tool) => {
+    try {
+      return {
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: stripSymbolKeys(tool.parameters) as Record<string, unknown>,
+          strict: false,
+        },
+      };
+    } catch {
+      return [];
+    }
+  });
 }
 
 function stripSymbolKeys(value: unknown): unknown {
@@ -687,6 +701,7 @@ function mapReasoningEffort(
 
 function mapToolChoice(
   choice: MistralOptions["toolChoice"],
+  convertedToolNames?: ReadonlySet<string>,
 ):
   | "auto"
   | "none"
@@ -697,9 +712,20 @@ function mapToolChoice(
   if (!choice) {
     return undefined;
   }
+  if (convertedToolNames && convertedToolNames.size === 0) {
+    if (choice === "none" || choice === "auto") {
+      return choice === "none" ? "none" : undefined;
+    }
+    throw new Error("Mistral tool_choice requires a tool, but no tools survived schema conversion");
+  }
   if (choice === "auto" || choice === "none" || choice === "any" || choice === "required") {
     return choice;
   }
+  if (convertedToolNames && !convertedToolNames.has(choice.function.name)) {
+    throw new Error(
+      `Mistral tool_choice requested unavailable tool "${choice.function.name}" after schema conversion`,
+    );
+  }
   return {
     type: "function",
     function: { name: choice.function.name },
