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

Author: hntrl

.changeset/soft-students-melt.md

@@ -0,0 +1,5 @@
+---
+"@langchain/mistralai": patch
+---
+
+roll back toolCall and response pairing

libs/langchain-mistralai/src/chat_models.ts

@@ -221,7 +221,7 @@ export interface ChatMistralAIInput
   numCompletions?: number;
 }
 
-export function convertMessagesToMistralMessages(
+function convertMessagesToMistralMessages(
   messages: Array<BaseMessage>
 ): Array<MistralAIMessage> {
   const getRole = (role: MessageType) => {
@@ -323,80 +323,35 @@ export function convertMessagesToMistralMessages(
     return undefined;
   };
 
-  // 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) => {
+  return messages.map((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
-          ),
-        } as MistralAIMessage,
-      ];
+      return {
+        role: getRole(message.getType()),
+        content,
+        name: message.name,
+        toolCallId: _convertToolCallIdToMistralCompatible(message.tool_call_id),
+      };
       // 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,
-          } as MistralAIMessage,
-        ];
+        return {
+          role: getRole(message.getType()),
+          content,
+        };
       } else {
-        // 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()),
+          toolCalls,
+        };
       }
     }
 
-    return [
-      {
-        role: getRole(message.getType()),
-        content,
-      } as MistralAIMessage,
-    ];
+    return {
+      role: getRole(message.getType()),
+      content,
+    };
   }) as MistralAIMessage[];
 }
 

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

@@ -1,8 +1,4 @@
-import { AIMessage, HumanMessage, ToolMessage } from "@langchain/core/messages";
-import {
-  ChatMistralAI,
-  convertMessagesToMistralMessages,
-} from "../chat_models.js";
+import { ChatMistralAI } from "../chat_models.js";
 import {
   _isValidMistralToolCallId,
   _convertToolCallIdToMistralCompatible,
@@ -42,48 +38,3 @@ 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");
-});