fix(google-common): pass structured objects directly in FunctionResponse

Previously, toolMessageToContent always stringified the ToolMessage
content and then attempted to parse it back with JSON.parse, wrapping
the result in { content: parsed }. This caused structured tool results
to be double-serialized when sent to the Gemini API.

The Gemini API's FunctionResponse.response field accepts any JSON
object directly (Struct format), so this change:

- Passes parsed JSON objects directly as the response (no wrapping)
- Wraps non-object values (strings, arrays) in { result: value }
- Handles ContentBlock[] arrays by extracting text content
- Handles plain object content passed via type coercion

Fixes #10439

Author: jackjin1997

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

@@ -1092,3 +1092,92 @@ describe("gemini empty text content handling", () => {
     expect(textPart.text).toBe("I am doing well");
   });
 });
+
+describe("gemini tool message formatting", () => {
+  test("passes JSON string content as structured object in FunctionResponse", async () => {
+    const api = getGeminiAPI();
+    const messages = [
+      new HumanMessage("What is the weather?"),
+      new AIMessage({
+        content: "",
+        tool_calls: [
+          { id: "call_1", name: "get_weather", args: { city: "SF" } },
+        ],
+      }),
+      new ToolMessage({
+        tool_call_id: "call_1",
+        content: JSON.stringify({ temperature: 72, unit: "F" }),
+      }),
+    ];
+
+    const formatted = (await api.formatData(messages, {})) as GeminiRequest;
+    const functionContent = formatted.contents?.find(
+      (c) => c.role === "function"
+    );
+    expect(functionContent).toBeDefined();
+
+    const part = functionContent?.parts[0] as any;
+    expect(part.functionResponse).toBeDefined();
+    expect(part.functionResponse.name).toBe("get_weather");
+    // Response should be a parsed object, not a string
+    expect(typeof part.functionResponse.response).toBe("object");
+    expect(part.functionResponse.response.temperature).toBe(72);
+    expect(part.functionResponse.response.unit).toBe("F");
+  });
+
+  test("wraps plain string content in result field", async () => {
+    const api = getGeminiAPI();
+    const messages = [
+      new HumanMessage("What is the weather?"),
+      new AIMessage({
+        content: "",
+        tool_calls: [
+          { id: "call_1", name: "get_weather", args: { city: "SF" } },
+        ],
+      }),
+      new ToolMessage({
+        tool_call_id: "call_1",
+        content: "It is sunny and 72°F",
+      }),
+    ];
+
+    const formatted = (await api.formatData(messages, {})) as GeminiRequest;
+    const functionContent = formatted.contents?.find(
+      (c) => c.role === "function"
+    );
+    const part = functionContent?.parts[0] as any;
+    expect(part.functionResponse.response).toEqual({
+      result: "It is sunny and 72°F",
+    });
+  });
+
+  test("passes JSON array content wrapped in result field", async () => {
+    const api = getGeminiAPI();
+    const messages = [
+      new HumanMessage("Search for restaurants"),
+      new AIMessage({
+        content: "",
+        tool_calls: [
+          { id: "call_1", name: "search", args: { query: "restaurants" } },
+        ],
+      }),
+      new ToolMessage({
+        tool_call_id: "call_1",
+        content: JSON.stringify([
+          { name: "Restaurant A" },
+          { name: "Restaurant B" },
+        ]),
+      }),
+    ];
+
+    const formatted = (await api.formatData(messages, {})) as GeminiRequest;
+    const functionContent = formatted.contents?.find(
+      (c) => c.role === "function"
+    );
+    const part = functionContent?.parts[0] as any;
+    expect(part.functionResponse.response.result).toEqual([
+      { name: "Restaurant A" },
+      { name: "Restaurant B" },
+    ]);
+  });
+});

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

@@ -880,54 +880,85 @@ export function getGeminiAPI(config?: GeminiAPIConfig): GoogleAIAPI {
     message: ToolMessage,
     prevMessage: BaseMessage
   ): GeminiContent[] {
-    const contentStr =
-      typeof message.content === "string"
-        ? message.content
-        : (message.content as ContentBlock[]).reduce(
-            (acc: string, content: ContentBlock) => {
-              if (content.type === "text") {
-                return acc + content.text;
-              } else {
-                return acc;
-              }
-            },
-            ""
-          );
     // Hacky :(
     const responseName =
       (isAIMessage(prevMessage) && !!prevMessage.tool_calls?.length
         ? prevMessage.tool_calls[0].name
         : prevMessage.name) ?? message.tool_call_id;
-    try {
-      const content = JSON.parse(contentStr);
-      return [
-        {
-          role: "function",
-          parts: [
-            {
-              functionResponse: {
-                name: responseName,
-                response: { content },
-              },
-            },
-          ],
-        },
-      ];
-    } catch (_) {
-      return [
-        {
-          role: "function",
-          parts: [
-            {
-              functionResponse: {
-                name: responseName,
-                response: { content: contentStr },
-              },
-            },
-          ],
-        },
-      ];
+
+    // Build the response object for Gemini's FunctionResponse.
+    // The Gemini API accepts any JSON object as the response field,
+    // so we pass structured content through as-is when possible
+    // instead of serializing it to a string.
+    let response: Record<string, unknown>;
+
+    if (typeof message.content === "string") {
+      // String content: try to parse as JSON to recover structured data
+      try {
+        const parsed = JSON.parse(message.content);
+        response =
+          typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : { result: parsed };
+      } catch (_) {
+        response = { result: message.content };
+      }
+    } else if (Array.isArray(message.content)) {
+      // Content block array: check if it looks like ContentBlock[] or a
+      // plain data array the caller passed via type coercion.
+      const hasContentBlocks = message.content.some(
+        (item: unknown) =>
+          typeof item === "object" &&
+          item !== null &&
+          "type" in item &&
+          typeof (item as Record<string, unknown>).type === "string"
+      );
+
+      if (hasContentBlocks) {
+        // Standard ContentBlock[] — extract text blocks
+        const text = (message.content as ContentBlock[]).reduce(
+          (acc: string, block: ContentBlock) =>
+            block.type === "text" ? acc + block.text : acc,
+          ""
+        );
+        try {
+          const parsed = JSON.parse(text);
+          response =
+            typeof parsed === "object" &&
+            parsed !== null &&
+            !Array.isArray(parsed)
+              ? parsed
+              : { result: parsed };
+        } catch (_) {
+          response = { result: text };
+        }
+      } else {
+        // Plain array passed as content (e.g. tool returning a list)
+        response = { result: message.content };
+      }
+    } else if (
+      typeof message.content === "object" &&
+      message.content !== null
+    ) {
+      // Already a structured object — pass through directly
+      response = message.content as Record<string, unknown>;
+    } else {
+      response = { result: String(message.content) };
     }
+
+    return [
+      {
+        role: "function",
+        parts: [
+          {
+            functionResponse: {
+              name: responseName,
+              response,
+            },
+          },
+        ],
+      },
+    ];
   }
 
   async function baseMessageToContent(