fix(core): completions tool chunk concat behavior (#9544)

hntrl · web-flow · commit 487378bf1427 · 2025-12-03T10:35:35.000-08:00
diff --git a/.changeset/free-ends-shave.md b/.changeset/free-ends-shave.md
@@ -0,0 +1,5 @@
+---
+"@langchain/core": patch
+---
+
+fix tool chunk concat behavior (#9450)
diff --git a/libs/langchain-core/src/messages/ai.ts b/libs/langchain-core/src/messages/ai.ts
@@ -1,4 +1,3 @@
-import { parsePartialJson } from "../utils/json.js";
 import {
   BaseMessage,
   BaseMessageChunk,
@@ -21,7 +20,7 @@ import {
   ToolCallChunk,
   defaultToolCallParser,
 } from "./tool.js";
-import { Constructor } from "./utils.js";
+import { collapseToolCallChunks, Constructor } from "./utils.js";
 
 export interface AIMessageFields<
   TStructure extends MessageStructure = MessageStructure
@@ -283,77 +282,9 @@ export class AIMessageChunk<
             : undefined,
       };
     } else {
-      const toolCallChunks = fields.tool_call_chunks ?? [];
-      const groupedToolCallChunks = toolCallChunks.reduce((acc, chunk) => {
-        const matchedChunkIndex = acc.findIndex(([match]) => {
-          // If chunk has an id and index, match if both are present
-          if (
-            "id" in chunk &&
-            chunk.id &&
-            "index" in chunk &&
-            chunk.index !== undefined
-          ) {
-            return chunk.id === match.id && chunk.index === match.index;
-          }
-          // If chunk has an id, we match on id
-          if ("id" in chunk && chunk.id) {
-            return chunk.id === match.id;
-          }
-          // If chunk has an index, we match on index
-          if ("index" in chunk && chunk.index !== undefined) {
-            return chunk.index === match.index;
-          }
-          return false;
-        });
-        if (matchedChunkIndex !== -1) {
-          acc[matchedChunkIndex].push(chunk);
-        } else {
-          acc.push([chunk]);
-        }
-        return acc;
-      }, [] as ToolCallChunk[][]);
-
-      const toolCalls: ToolCall[] = [];
-      const invalidToolCalls: InvalidToolCall[] = [];
-      for (const chunks of groupedToolCallChunks) {
-        let parsedArgs: Record<string, unknown> | null = null;
-        const name = chunks[0]?.name ?? "";
-        const joinedArgs = chunks
-          .map((c) => c.args || "")
-          .join("")
-          .trim();
-        const argsStr = joinedArgs.length ? joinedArgs : "{}";
-        const id = chunks[0]?.id;
-        try {
-          parsedArgs = parsePartialJson(argsStr);
-          if (
-            !id ||
-            parsedArgs === null ||
-            typeof parsedArgs !== "object" ||
-            Array.isArray(parsedArgs)
-          ) {
-            throw new Error("Malformed tool call chunk args.");
-          }
-          toolCalls.push({
-            name,
-            args: parsedArgs,
-            id,
-            type: "tool_call",
-          });
-        } catch {
-          invalidToolCalls.push({
-            name,
-            args: argsStr,
-            id,
-            error: "Malformed args.",
-            type: "invalid_tool_call",
-          });
-        }
-      }
       initParams = {
         ...fields,
-        tool_calls: toolCalls,
-        invalid_tool_calls: invalidToolCalls,
+        ...collapseToolCallChunks(fields.tool_call_chunks ?? []),
         usage_metadata:
           fields.usage_metadata !== undefined
             ? fields.usage_metadata
diff --git a/libs/langchain-core/src/messages/base.ts b/libs/langchain-core/src/messages/base.ts
@@ -448,8 +448,10 @@ export function _mergeDicts(
       } else if (
         ["id", "name", "output_version", "model_provider"].includes(key)
       ) {
-        // Keep the incoming value for these fields
-        merged[key] = value;
+        // Keep the incoming value for these fields if its defined
+        if (value) {
+          merged[key] = value;
+        }
       } else {
         merged[key] += value;
       }
diff --git a/libs/langchain-core/src/messages/tests/ai.test.ts b/libs/langchain-core/src/messages/tests/ai.test.ts
@@ -384,6 +384,26 @@ describe("AIMessageChunk", () => {
       '{"ideas":["read about Angular 19 updates"]}'
     );
     expect(secondCall?.id).toBe("5abf542e-87f3-4899-87c6-8f7d9cb6a28d");
+
+    expect(merged.tool_calls).toHaveLength(2);
+    expect(merged.tool_calls).toEqual([
+      {
+        id: "9fb5c937-6944-4173-84be-ad1caee1cedd",
+        type: "tool_call",
+        name: "add_new_task",
+        args: {
+          tasks: ["buy tomatoes", "help child with math"],
+        },
+      },
+      {
+        id: "5abf542e-87f3-4899-87c6-8f7d9cb6a28d",
+        type: "tool_call",
+        name: "add_ideas",
+        args: {
+          ideas: ["read about Angular 19 updates"],
+        },
+      },
+    ]);
   });
 
   it("should properly merge tool call chunks that have matching indices and at least one id is blank", () => {
@@ -418,6 +438,75 @@ describe("AIMessageChunk", () => {
       '{"tasks":["buy tomatoes","help child with math"]}'
     );
     expect(firstCall?.id).toBe("9fb5c937-6944-4173-84be-ad1caee1cedd");
+
+    expect(merged.tool_calls).toHaveLength(1);
+    expect(merged.tool_calls).toEqual([
+      {
+        type: "tool_call",
+        name: "add_new_task",
+        args: {
+          tasks: ["buy tomatoes", "help child with math"],
+        },
+        id: "9fb5c937-6944-4173-84be-ad1caee1cedd",
+      },
+    ]);
+  });
+
+  // https://github.com/langchain-ai/langchainjs/issues/9450
+  it("should properly concat a string of old completions-style tool call chunks", () => {
+    const chunk1 = new AIMessageChunk({
+      tool_call_chunks: [
+        {
+          name: "get_weather",
+          args: "",
+          id: "call_7171a25538d44feea5155a",
+          index: 0,
+          type: "tool_call_chunk",
+        },
+      ],
+    });
+    const chunk2 = new AIMessageChunk({
+      tool_call_chunks: [
+        {
+          name: undefined,
+          args: '{"city": "',
+          id: "",
+          index: 0,
+          type: "tool_call_chunk",
+        },
+      ],
+    });
+    const chunk3 = new AIMessageChunk({
+      tool_call_chunks: [
+        {
+          name: undefined,
+          args: 'sf"}',
+          id: "",
+          index: 0,
+          type: "tool_call_chunk",
+        },
+      ],
+    });
+
+    const merged = chunk1.concat(chunk2).concat(chunk3);
+    expect(merged.tool_call_chunks).toHaveLength(1);
+
+    const firstCall = merged.tool_call_chunks?.[0];
+    expect(firstCall?.name).toBe("get_weather");
+    expect(firstCall?.args).toBe('{"city": "sf"}');
+    expect(firstCall?.id).toBe("call_7171a25538d44feea5155a");
+
+    expect(merged.tool_calls).toHaveLength(1);
+    expect(merged.tool_calls).toEqual([
+      {
+        type: "tool_call",
+        name: "get_weather",
+        args: {
+          city: "sf",
+        },
+        id: "call_7171a25538d44feea5155a",
+      },
+    ]);
   });
 
   it("should properly merge tool call chunks that have matching indices no IDs at all", () => {
diff --git a/libs/langchain-core/src/messages/utils.ts b/libs/langchain-core/src/messages/utils.ts
@@ -1,6 +1,7 @@
 import { addLangChainErrorFields } from "../errors/index.js";
 import { SerializedConstructor } from "../load/serializable.js";
 import { _isToolCall } from "../tools/utils.js";
+import { parsePartialJson } from "../utils/json.js";
 import { AIMessage, AIMessageChunk, AIMessageChunkFields } from "./ai.js";
 import {
   BaseMessageLike,
@@ -20,7 +21,13 @@ import {
 import { HumanMessage, HumanMessageChunk } from "./human.js";
 import { RemoveMessage } from "./modifier.js";
 import { SystemMessage, SystemMessageChunk } from "./system.js";
-import { ToolCall, ToolMessage, ToolMessageFields } from "./tool.js";
+import {
+  InvalidToolCall,
+  ToolCall,
+  ToolCallChunk,
+  ToolMessage,
+  ToolMessageFields,
+} from "./tool.js";
 
 export type $Expand<T> = T extends infer U ? { [K in keyof U]: U[K] } : never;
 
@@ -445,3 +452,107 @@ export function convertToChunk(message: BaseMessage) {
     throw new Error("Unknown message type.");
   }
 }
+
+/**
+ * Collapses an array of tool call chunks into complete tool calls.
+ *
+ * This function groups tool call chunks by their id and/or index, then attempts to
+ * parse and validate the accumulated arguments for each group. Successfully parsed
+ * tool calls are returned as valid `ToolCall` objects, while malformed ones are
+ * returned as `InvalidToolCall` objects.
+ *
+ * @param chunks - An array of `ToolCallChunk` objects to collapse
+ * @returns An object containing:
+ *   - `tool_call_chunks`: The original input chunks
+ *   - `tool_calls`: An array of successfully parsed and validated tool calls
+ *   - `invalid_tool_calls`: An array of tool calls that failed parsing or validation
+ *
+ * @remarks
+ * Chunks are grouped using the following matching logic:
+ * - If a chunk has both an id and index, it matches chunks with the same id and index
+ * - If a chunk has only an id, it matches chunks with the same id
+ * - If a chunk has only an index, it matches chunks with the same index
+ *
+ * For each group, the function:
+ * 1. Concatenates all `args` strings from the chunks
+ * 2. Attempts to parse the concatenated string as JSON
+ * 3. Validates that the result is a non-null object with a valid id
+ * 4. Creates either a `ToolCall` (if valid) or `InvalidToolCall` (if invalid)
+ */
+export function collapseToolCallChunks(chunks: ToolCallChunk[]): {
+  tool_call_chunks: ToolCallChunk[];
+  tool_calls: ToolCall[];
+  invalid_tool_calls: InvalidToolCall[];
+} {
+  const groupedToolCallChunks = chunks.reduce((acc, chunk) => {
+    const matchedChunkIndex = acc.findIndex(([match]) => {
+      // If chunk has an id and index, match if both are present
+      if (
+        "id" in chunk &&
+        chunk.id &&
+        "index" in chunk &&
+        chunk.index !== undefined
+      ) {
+        return chunk.id === match.id && chunk.index === match.index;
+      }
+      // If chunk has an id, we match on id
+      if ("id" in chunk && chunk.id) {
+        return chunk.id === match.id;
+      }
+      // If chunk has an index, we match on index
+      if ("index" in chunk && chunk.index !== undefined) {
+        return chunk.index === match.index;
+      }
+      return false;
+    });
+    if (matchedChunkIndex !== -1) {
+      acc[matchedChunkIndex].push(chunk);
+    } else {
+      acc.push([chunk]);
+    }
+    return acc;
+  }, [] as ToolCallChunk[][]);
+
+  const toolCalls: ToolCall[] = [];
+  const invalidToolCalls: InvalidToolCall[] = [];
+  for (const chunks of groupedToolCallChunks) {
+    let parsedArgs: Record<string, unknown> | null = null;
+    const name = chunks[0]?.name ?? "";
+    const joinedArgs = chunks
+      .map((c) => c.args || "")
+      .join("")
+      .trim();
+    const argsStr = joinedArgs.length ? joinedArgs : "{}";
+    const id = chunks[0]?.id;
+    try {
+      parsedArgs = parsePartialJson(argsStr);
+      if (
+        !id ||
+        parsedArgs === null ||
+        typeof parsedArgs !== "object" ||
+        Array.isArray(parsedArgs)
+      ) {
+        throw new Error("Malformed tool call chunk args.");
+      }
+      toolCalls.push({
+        name,
+        args: parsedArgs,
+        id,
+        type: "tool_call",
+      });
+    } catch {
+      invalidToolCalls.push({
+        name,
+        args: argsStr,
+        id,
+        error: "Malformed args.",
+        type: "invalid_tool_call",
+      });
+    }
+  }
+  return {
+    tool_call_chunks: chunks,
+    tool_calls: toolCalls,
+    invalid_tool_calls: invalidToolCalls,
+  };
+}

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"@langchain/core": patch
 +---
++
 +fix tool chunk concat behavior (#9450)