fix(genai): round-trip thinking content blocks in multi-turn convos (#10415)

Author: pawel-twardziak

.changeset/round-trip-thinking-content.md

@@ -0,0 +1,6 @@
+---
+"@langchain/google-genai": patch
+"@langchain/google": patch
+---
+
+fix(genai): round-trip thinking content blocks in multi-turn convos

libs/providers/langchain-google-genai/src/tests/common.test.ts

@@ -1,8 +1,10 @@
 import { describe, test, expect } from "vitest";
 import {
   convertResponseContentToChatGenerationChunk,
+  convertMessageContentToParts,
   mapGenerateContentResultToChatResult,
 } from "../utils/common.js";
+import { AIMessage } from "@langchain/core/messages";
 import type {
   EnhancedGenerateContentResponse,
   FinishReason,
@@ -269,3 +271,108 @@ describe("Streaming thinking content handling", () => {
     expect(Array.isArray(content)).toBe(true);
   });
 });
+
+// https://github.com/langchain-ai/langchainjs/issues/10103
+describe("Round-trip thinking content handling", () => {
+  test("thinking block with signature converts back to Gemini part", () => {
+    const message = new AIMessage({
+      content: [
+        {
+          type: "thinking",
+          thinking: "Let me reason about this...",
+          signature: "sig123",
+        },
+        { type: "text", text: "The answer is 42." },
+      ],
+    });
+
+    const parts = convertMessageContentToParts(message, true, []);
+
+    expect(parts).toHaveLength(2);
+    expect(parts[0]).toEqual({
+      text: "Let me reason about this...",
+      thought: true,
+      thoughtSignature: "sig123",
+    });
+    expect(parts[1]).toEqual({ text: "The answer is 42." });
+  });
+
+  test("thinking block without signature converts back without thoughtSignature", () => {
+    const message = new AIMessage({
+      content: [
+        { type: "thinking", thinking: "Some thinking" },
+        { type: "text", text: "Some answer" },
+      ],
+    });
+
+    const parts = convertMessageContentToParts(message, true, []);
+
+    expect(parts).toHaveLength(2);
+    expect(parts[0]).toEqual({
+      text: "Some thinking",
+      thought: true,
+    });
+    expect(parts[0]).not.toHaveProperty("thoughtSignature");
+    expect(parts[1]).toEqual({ text: "Some answer" });
+  });
+
+  test("thinking-only content (no text block) works", () => {
+    const message = new AIMessage({
+      content: [
+        {
+          type: "thinking",
+          thinking: "Only thinking, no answer",
+          signature: "sigABC",
+        },
+      ],
+    });
+
+    const parts = convertMessageContentToParts(message, true, []);
+
+    expect(parts).toHaveLength(1);
+    expect(parts[0]).toEqual({
+      text: "Only thinking, no answer",
+      thought: true,
+      thoughtSignature: "sigABC",
+    });
+  });
+
+  test("full round-trip: Gemini response -> LangChain -> Gemini parts", () => {
+    const originalParts = [
+      {
+        text: "Let me think step by step...",
+        thought: true,
+        thoughtSignature: "roundtrip-sig",
+      },
+      {
+        text: "The final answer is 7.",
+      },
+    ] as GoogleGenerativeAIPart[];
+
+    // Gemini response -> LangChain AIMessage
+    const mockResponse = createMockResponse([
+      {
+        content: { role: "model", parts: originalParts },
+        finishReason: "STOP" as FinishReason,
+        index: 0,
+        safetyRatings: [],
+      },
+    ]);
+
+    const chatResult = mapGenerateContentResultToChatResult(mockResponse);
+    const aiMessage = chatResult.generations[0].message;
+
+    // LangChain AIMessage -> Gemini parts (outgoing direction)
+    const roundTrippedParts = convertMessageContentToParts(aiMessage, true, []);
+
+    expect(roundTrippedParts).toHaveLength(2);
+    expect(roundTrippedParts[0]).toEqual({
+      text: "Let me think step by step...",
+      thought: true,
+      thoughtSignature: "roundtrip-sig",
+    });
+    expect(roundTrippedParts[1]).toEqual({
+      text: "The final answer is 7.",
+    });
+  });
+});

libs/providers/langchain-google-genai/src/utils/common.ts

@@ -429,6 +429,19 @@ function _convertLangChainContentToPart(
         data: content.data,
       },
     };
+  } else if (content.type === "thinking") {
+    const thinkingContent = content as {
+      type: "thinking";
+      thinking: string;
+      signature?: string;
+    };
+    return {
+      text: thinkingContent.thinking,
+      thought: true,
+      ...(thinkingContent.signature
+        ? { thoughtSignature: thinkingContent.signature }
+        : {}),
+    } as Part;
   } else if ("functionCall" in content) {
     // No action needed here — function calls will be added later from message.tool_calls
     return undefined;

libs/providers/langchain-google/src/converters/tests/messages.test.ts

@@ -258,11 +258,12 @@ describe("convertMessagesToGeminiContents", () => {
 
     const contents = convertMessagesToGeminiContents(messages);
 
-    // Should produce: user, function (single merged turn)
-    // The AIMessage with empty content and tool_calls produces no model content block
-    expect(contents).toHaveLength(2);
+    // Should produce: user, model (functionCall parts), function (single merged turn)
+    expect(contents).toHaveLength(3);
 
-    const functionTurn = contents[1];
+    expect(contents[1].role).toBe("model");
+
+    const functionTurn = contents[2];
     expect(functionTurn.role).toBe("function");
     expect(functionTurn.parts).toHaveLength(2);
 
@@ -445,18 +446,16 @@ describe("convertMessagesToGeminiContents", () => {
 
     const contents = convertMessagesToGeminiContents(messages);
 
+    // Consecutive ToolMessages with the same "function" role are merged into one content
     const toolResponseContents = contents.filter((c) => c.role === "function");
-    expect(toolResponseContents).toHaveLength(2);
-
-    const firstResponse = toolResponseContents[0].parts.find(
-      (p) => "functionResponse" in p && p.functionResponse
-    ) as Gemini.Part.FunctionResponse;
-    expect(firstResponse.functionResponse!.name).toBe("get_weather");
+    expect(toolResponseContents).toHaveLength(1);
 
-    const secondResponse = toolResponseContents[1].parts.find(
+    const mergedParts = toolResponseContents[0].parts.filter(
       (p) => "functionResponse" in p && p.functionResponse
-    ) as Gemini.Part.FunctionResponse;
-    expect(secondResponse.functionResponse!.name).toBe("get_time");
+    ) as Gemini.Part.FunctionResponse[];
+    expect(mergedParts).toHaveLength(2);
+    expect(mergedParts[0].functionResponse!.name).toBe("get_weather");
+    expect(mergedParts[1].functionResponse!.name).toBe("get_time");
   });
 
   test("passes tool_call_id through as functionResponse.id (v1 standard path)", () => {