fix(@langchain/mistralai): Added logic to ensure toolCalls have corresponding toolResponses when sending messages to the Mistral API (#9023)

Author: Zozman

.changeset/real-dogs-listen.md

@@ -0,0 +1,5 @@
+---
+"@langchain/mistralai": patch
+---
+
+Added logic to ensure toolCalls have corresponding toolResponses when sending messages to the Mistral API

libs/langchain-mistralai/src/chat_models.ts

@@ -221,7 +221,7 @@ export interface ChatMistralAIInput
   numCompletions?: number;
 }
 
-function convertMessagesToMistralMessages(
+export function convertMessagesToMistralMessages(
   messages: Array<BaseMessage>
 ): Array<MistralAIMessage> {
   const getRole = (role: MessageType) => {
@@ -323,35 +323,80 @@ function convertMessagesToMistralMessages(
     return undefined;
   };
 
-  return messages.map((message) => {
+  // Build a set of toolCallIds that have corresponding tool responses present
+  // to ensure 1:1 assistant toolCalls <-> tool responses.
+  const toolResponseIds = new Set<string>();
+  for (const m of messages) {
+    if ("tool_call_id" in m && typeof m.tool_call_id === "string") {
+      toolResponseIds.add(
+        _convertToolCallIdToMistralCompatible(m.tool_call_id)
+      );
+    }
+  }
+
+  return messages.flatMap((message) => {
     const toolCalls = getTools(message);
     const content = getContent(message.content, message.getType());
     if ("tool_call_id" in message && typeof message.tool_call_id === "string") {
-      return {
-        role: getRole(message.getType()),
-        content,
-        name: message.name,
-        toolCallId: _convertToolCallIdToMistralCompatible(message.tool_call_id),
-      };
+      return [
+        {
+          role: getRole(message.getType()),
+          content,
+          name: message.name,
+          toolCallId: _convertToolCallIdToMistralCompatible(
+            message.tool_call_id
+          ),
+        } as MistralAIMessage,
+      ];
       // Mistral "assistant" role can only support either content or tool calls but not both
     } else if (isAIMessage(message)) {
       if (toolCalls === undefined) {
-        return {
-          role: getRole(message.getType()),
-          content,
-        };
+        return [
+          {
+            role: getRole(message.getType()),
+            content,
+          } as MistralAIMessage,
+        ];
       } else {
-        return {
-          role: getRole(message.getType()),
-          toolCalls,
-        };
+        // Filter out toolCalls that do not have a matching tool response later in the list
+        const filteredToolCalls = toolCalls.filter((tc) =>
+          toolResponseIds.has(
+            _convertToolCallIdToMistralCompatible(tc.id ?? "")
+          )
+        );
+
+        if (filteredToolCalls.length === 0) {
+          // If there are no matching tool responses, and there's no content, drop this message
+          const isEmptyContent =
+            (typeof content === "string" && content.trim() === "") ||
+            (Array.isArray(content) && content.length === 0);
+          if (isEmptyContent) {
+            return [];
+          }
+          // Otherwise, send content only
+          return [
+            {
+              role: getRole(message.getType()),
+              content,
+            } as MistralAIMessage,
+          ];
+        }
+
+        return [
+          {
+            role: getRole(message.getType()),
+            toolCalls: filteredToolCalls as MistralAIToolCall[],
+          } as MistralAIMessage,
+        ];
       }
     }
 
-    return {
-      role: getRole(message.getType()),
-      content,
-    };
+    return [
+      {
+        role: getRole(message.getType()),
+        content,
+      } as MistralAIMessage,
+    ];
   }) as MistralAIMessage[];
 }
 

libs/langchain-mistralai/src/tests/chat_models.test.ts

@@ -1,4 +1,8 @@
-import { ChatMistralAI } from "../chat_models.js";
+import { AIMessage, HumanMessage, ToolMessage } from "@langchain/core/messages";
+import {
+  ChatMistralAI,
+  convertMessagesToMistralMessages,
+} from "../chat_models.js";
 import {
   _isValidMistralToolCallId,
   _convertToolCallIdToMistralCompatible,
@@ -38,3 +42,48 @@ test("Serialization", () => {
     `{"lc":1,"type":"constructor","id":["langchain","chat_models","mistralai","ChatMistralAI"],"kwargs":{"mistral_api_key":{"lc":1,"type":"secret","id":["MISTRAL_API_KEY"]}}}`
   );
 });
+
+/**
+ * Test to make sure that the logic in convertMessagesToMistralMessages that makes sure
+ * tool calls are only included if there is a corresponding ToolMessage works as expected
+ *
+ * Or else the Mistral API will reject the request
+ */
+test("convertMessagesToMistralMessages converts roles and filters toolCalls", () => {
+  const msgs = [
+    new HumanMessage("hi"),
+    new AIMessage({
+      content: "",
+      tool_calls: [
+        {
+          id: "123456789",
+          name: "extract-1",
+          args: { answer: "x" },
+          type: "tool_call",
+        },
+        { id: "ORPHAN123", name: "noop", args: {}, type: "tool_call" },
+      ],
+    }),
+    new ToolMessage({ tool_call_id: "123456789", content: "result payload" }),
+  ];
+
+  const converted = convertMessagesToMistralMessages(msgs) as {
+    role: "user" | "assistant" | "tool";
+    toolCalls?: { id: string; name: string; args: Record<string, unknown> }[];
+    toolCallId?: string;
+  }[];
+  // Expect user, assistant (toolCalls), tool
+  const roles = converted.map((m) => m.role);
+  expect(roles).toContain("user");
+  expect(roles).toContain("assistant");
+  expect(roles).toContain("tool");
+
+  const assistantMsg = converted.find((m) => Array.isArray(m.toolCalls)) as {
+    toolCalls: { id: string }[];
+  };
+  expect(assistantMsg.toolCalls.length).toBe(1);
+  expect(assistantMsg.toolCalls[0].id).toBe("123456789");
+
+  const toolMsg = converted.find((m) => m.role === "tool");
+  expect(toolMsg?.toolCallId).toBe("123456789");
+});