@illuma-ai/agents 1.0.90 → 1.0.94

package/src/llm/vertexai/index.js

@@ -0,0 +1,402 @@
+import { ChatGoogle } from '@langchain/google-gauth';
+import { ChatConnection } from '@langchain/google-common';
+import { isAIMessage } from '@langchain/core/messages';
+/**
+ * Fixes thought signatures on functionCall parts in the formatted Gemini request.
+ *
+ * `@langchain/google-common` stores signatures as a flat array in
+ * `additional_kwargs.signatures` (one per response part) and re-attaches them
+ * by index only when `signatures.length === parts.length`. This fails when:
+ * - The API omits a signature (length mismatch)
+ * - Streaming chunks merge with different part counts
+ * - The signature for a functionCall part is an empty string
+ *
+ * This function correlates each "model" content block in the formatted request
+ * back to its originating AI message, then re-attaches non-empty signatures
+ * that the library failed to apply.
+ */
+function fixThoughtSignatures(contents, input) {
+    // Collect AI messages that have signatures, in order
+    const aiMessages = input.filter((msg) => isAIMessage(msg) &&
+        Array.isArray(msg.additional_kwargs?.signatures) &&
+        msg.additional_kwargs.signatures.length > 0);
+    // Collect "model" content blocks from the formatted request, in order
+    const modelContents = contents.filter((c) => c.role === 'model');
+    // They should correspond 1:1 in order (both derived from the same input sequence)
+    const count = Math.min(aiMessages.length, modelContents.length);
+    for (let i = 0; i < count; i++) {
+        const msg = aiMessages[i];
+        const content = modelContents[i];
+        const signatures = msg.additional_kwargs?.signatures;
+        // Collect non-empty signatures that aren't already attached to any part
+        const attachedSignatures = new Set(content.parts
+            .map((p) => p.thoughtSignature)
+            .filter((s) => s != null && s !== ''));
+        const availableSignatures = signatures?.filter((s) => s != null && s !== '' && !attachedSignatures.has(s));
+        // Assign available signatures to functionCall parts missing one, in order
+        let sigIdx = 0;
+        for (const part of content.parts) {
+            if ('functionCall' in part &&
+                (part.thoughtSignature == null || part.thoughtSignature === '') &&
+                sigIdx < (availableSignatures?.length ?? 0)) {
+                part.thoughtSignature = availableSignatures?.[sigIdx];
+                sigIdx++;
+            }
+        }
+    }
+}
+class CustomChatConnection extends ChatConnection {
+    thinkingConfig;
+    async formatData(input, parameters) {
+        const formattedData = (await super.formatData(input, parameters));
+        if (formattedData.generationConfig?.thinkingConfig?.thinkingBudget === -1) {
+            // -1 means "let the model decide" - delete the property so the API doesn't receive an invalid value
+            if (formattedData.generationConfig.thinkingConfig.includeThoughts === false) {
+                formattedData.generationConfig.thinkingConfig.includeThoughts = true;
+            }
+            delete formattedData.generationConfig.thinkingConfig.thinkingBudget;
+        }
+        if (this.thinkingConfig?.thinkingLevel != null &&
+            this.thinkingConfig.thinkingLevel !== '') {
+            formattedData.generationConfig ??= {};
+            // thinkingLevel and thinkingBudget cannot coexist — the API rejects the request.
+            // Remove thinkingBudget when thinkingLevel is set.
+            const { thinkingBudget: _, ...existingThinkingConfig } = formattedData.generationConfig.thinkingConfig ?? {};
+            formattedData.generationConfig.thinkingConfig = {
+                ...existingThinkingConfig,
+                thinkingLevel: this.thinkingConfig.thinkingLevel,
+                ...(this.thinkingConfig.includeThoughts != null && {
+                    includeThoughts: this.thinkingConfig.includeThoughts,
+                }),
+            };
+        }
+        if (formattedData.contents) {
+            fixThoughtSignatures(formattedData.contents, input);
+            // gemini-3.1+ models reject role="function"; convert to role="user"
+            for (const content of formattedData.contents) {
+                if (content.role === 'function') {
+                    content.role = 'user';
+                }
+            }
+        }
+        return formattedData;
+    }
+}
+/**
+ * Integration with Google Vertex AI chat models.
+ *
+ * Setup:
+ * Install `@langchain/google-vertexai` and set your stringified
+ * Vertex AI credentials as an environment variable named `GOOGLE_APPLICATION_CREDENTIALS`.
+ *
+ * ```bash
+ * npm install @langchain/google-vertexai
+ * export GOOGLE_APPLICATION_CREDENTIALS="path/to/credentials"
+ * ```
+ *
+ * ## [Constructor args](https://api.js.langchain.com/classes/_langchain_google_vertexai.index.ChatVertexAI.html#constructor.new_ChatVertexAI)
+ *
+ * ## [Runtime args](https://api.js.langchain.com/interfaces/langchain_google_common_types.GoogleAIBaseLanguageModelCallOptions.html)
+ *
+ * Runtime args can be passed as the second argument to any of the base runnable methods `.invoke`. `.stream`, `.batch`, etc.
+ * They can also be passed via `.withConfig`, or the second arg in `.bindTools`, like shown in the examples below:
+ *
+ * ```typescript
+ * // When calling `.withConfig`, call options should be passed via the first argument
+ * const llmWithArgsBound = llm.withConfig({
+ *   stop: ["\n"],
+ *   tools: [...],
+ * });
+ *
+ * // When calling `.bindTools`, call options should be passed via the second argument
+ * const llmWithTools = llm.bindTools(
+ *   [...],
+ *   {
+ *     tool_choice: "auto",
+ *   }
+ * );
+ * ```
+ *
+ * ## Examples
+ *
+ * <details open>
+ * <summary><strong>Instantiate</strong></summary>
+ *
+ * ```typescript
+ * import { ChatVertexAI } from '@langchain/google-vertexai';
+ *
+ * const llm = new ChatVertexAI({
+ *   model: "gemini-1.5-pro",
+ *   temperature: 0,
+ *   // other params...
+ * });
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Invoking</strong></summary>
+ *
+ * ```typescript
+ * const input = `Translate "I love programming" into French.`;
+ *
+ * // Models also accept a list of chat messages or a formatted prompt
+ * const result = await llm.invoke(input);
+ * console.log(result);
+ * ```
+ *
+ * ```txt
+ * AIMessageChunk {
+ *   "content": "\"J'adore programmer\" \n\nHere's why this is the best translation:\n\n* **J'adore** means \"I love\" and conveys a strong passion.\n* **Programmer** is the French verb for \"to program.\"\n\nThis translation is natural and idiomatic in French. \n",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": [],
+ *   "usage_metadata": {
+ *     "input_tokens": 9,
+ *     "output_tokens": 63,
+ *     "total_tokens": 72
+ *   }
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Streaming Chunks</strong></summary>
+ *
+ * ```typescript
+ * for await (const chunk of await llm.stream(input)) {
+ *   console.log(chunk);
+ * }
+ * ```
+ *
+ * ```txt
+ * AIMessageChunk {
+ *   "content": "\"",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": []
+ * }
+ * AIMessageChunk {
+ *   "content": "J'adore programmer\" \n",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": []
+ * }
+ * AIMessageChunk {
+ *   "content": "",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {},
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": []
+ * }
+ * AIMessageChunk {
+ *   "content": "",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {
+ *     "finishReason": "stop"
+ *   },
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": [],
+ *   "usage_metadata": {
+ *     "input_tokens": 9,
+ *     "output_tokens": 8,
+ *     "total_tokens": 17
+ *   }
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Aggregate Streamed Chunks</strong></summary>
+ *
+ * ```typescript
+ * import { AIMessageChunk } from '@langchain/core/messages';
+ * import { concat } from '@langchain/core/utils/stream';
+ *
+ * const stream = await llm.stream(input);
+ * let full: AIMessageChunk | undefined;
+ * for await (const chunk of stream) {
+ *   full = !full ? chunk : concat(full, chunk);
+ * }
+ * console.log(full);
+ * ```
+ *
+ * ```txt
+ * AIMessageChunk {
+ *   "content": "\"J'adore programmer\" \n",
+ *   "additional_kwargs": {},
+ *   "response_metadata": {
+ *     "finishReason": "stop"
+ *   },
+ *   "tool_calls": [],
+ *   "tool_call_chunks": [],
+ *   "invalid_tool_calls": [],
+ *   "usage_metadata": {
+ *     "input_tokens": 9,
+ *     "output_tokens": 8,
+ *     "total_tokens": 17
+ *   }
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Bind tools</strong></summary>
+ *
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const GetWeather = {
+ *   name: "GetWeather",
+ *   description: "Get the current weather in a given location",
+ *   schema: z.object({
+ *     location: z.string().describe("The city and state, e.g. San Francisco, CA")
+ *   }),
+ * }
+ *
+ * const GetPopulation = {
+ *   name: "GetPopulation",
+ *   description: "Get the current population in a given location",
+ *   schema: z.object({
+ *     location: z.string().describe("The city and state, e.g. San Francisco, CA")
+ *   }),
+ * }
+ *
+ * const llmWithTools = llm.bindTools([GetWeather, GetPopulation]);
+ * const aiMsg = await llmWithTools.invoke(
+ *   "Which city is hotter today and which is bigger: LA or NY?"
+ * );
+ * console.log(aiMsg.tool_calls);
+ * ```
+ *
+ * ```txt
+ * [
+ *   {
+ *     name: 'GetPopulation',
+ *     args: { location: 'New York City, NY' },
+ *     id: '33c1c1f47e2f492799c77d2800a43912',
+ *     type: 'tool_call'
+ *   }
+ * ]
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Structured Output</strong></summary>
+ *
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const Joke = z.object({
+ *   setup: z.string().describe("The setup of the joke"),
+ *   punchline: z.string().describe("The punchline to the joke"),
+ *   rating: z.number().optional().describe("How funny the joke is, from 1 to 10")
+ * }).describe('Joke to tell user.');
+ *
+ * const structuredLlm = llm.withStructuredOutput(Joke, { name: "Joke" });
+ * const jokeResult = await structuredLlm.invoke("Tell me a joke about cats");
+ * console.log(jokeResult);
+ * ```
+ *
+ * ```txt
+ * {
+ *   setup: 'What do you call a cat that loves to bowl?',
+ *   punchline: 'An alley cat!'
+ * }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Usage Metadata</strong></summary>
+ *
+ * ```typescript
+ * const aiMsgForMetadata = await llm.invoke(input);
+ * console.log(aiMsgForMetadata.usage_metadata);
+ * ```
+ *
+ * ```txt
+ * { input_tokens: 9, output_tokens: 8, total_tokens: 17 }
+ * ```
+ * </details>
+ *
+ * <br />
+ *
+ * <details>
+ * <summary><strong>Stream Usage Metadata</strong></summary>
+ *
+ * ```typescript
+ * const streamForMetadata = await llm.stream(
+ *   input,
+ *   {
+ *     streamUsage: true
+ *   }
+ * );
+ * let fullForMetadata: AIMessageChunk | undefined;
+ * for await (const chunk of streamForMetadata) {
+ *   fullForMetadata = !fullForMetadata ? chunk : concat(fullForMetadata, chunk);
+ * }
+ * console.log(fullForMetadata?.usage_metadata);
+ * ```
+ *
+ * ```txt
+ * { input_tokens: 9, output_tokens: 8, total_tokens: 17 }
+ * ```
+ * </details>
+ *
+ * <br />
+ */
+export class ChatVertexAI extends ChatGoogle {
+    lc_namespace = ['langchain', 'chat_models', 'vertexai'];
+    dynamicThinkingBudget = false;
+    thinkingConfig;
+    static lc_name() {
+        return 'IllumaVertexAI';
+    }
+    constructor(fields) {
+        const dynamicThinkingBudget = fields?.thinkingBudget === -1;
+        super({
+            ...fields,
+            platformType: 'gcp',
+        });
+        this.dynamicThinkingBudget = dynamicThinkingBudget;
+        this.thinkingConfig = fields?.thinkingConfig;
+    }
+    invocationParams(options) {
+        const params = super.invocationParams(options);
+        if (this.dynamicThinkingBudget) {
+            params.maxReasoningTokens = -1;
+        }
+        return params;
+    }
+    buildConnection(fields, client) {
+        // Note: buildConnection is called from super() BEFORE this.thinkingConfig is set,
+        // so we must read thinkingConfig from `fields` directly.
+        const thinkingConfig = fields?.thinkingConfig ?? this.thinkingConfig;
+        const connection = new CustomChatConnection({ ...fields, ...this }, this.caller, client, false);
+        connection.thinkingConfig = thinkingConfig;
+        this.connection = connection;
+        const streamedConnection = new CustomChatConnection({ ...fields, ...this }, this.caller, client, true);
+        streamedConnection.thinkingConfig = thinkingConfig;
+        this.streamedConnection = streamedConnection;
+    }
+}
+//# sourceMappingURL=index.js.map

package/src/llm/vertexai/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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"}

package/src/llm/vertexai/index.ts

@@ -1,14 +1,85 @@
 import { ChatGoogle } from '@langchain/google-gauth';
 import { ChatConnection } from '@langchain/google-common';
 import type {
+  GeminiContent,
   GeminiRequest,
   GoogleAIModelRequestParams,
   GoogleAbstractedClient,
 } from '@langchain/google-common';
 import type { BaseMessage } from '@langchain/core/messages';
-import type { VertexAIClientOptions } from '@/types';
+import { isAIMessage } from '@langchain/core/messages';
+import type { GoogleThinkingConfig, VertexAIClientOptions } from '@/types';
+
+type AdditionalKwargs =
+  | undefined
+  | (BaseMessage['additional_kwargs'] & {
+      signatures?: Array<string | undefined>;
+    });
+
+/**
+ * Fixes thought signatures on functionCall parts in the formatted Gemini request.
+ *
+ * `@langchain/google-common` stores signatures as a flat array in
+ * `additional_kwargs.signatures` (one per response part) and re-attaches them
+ * by index only when `signatures.length === parts.length`. This fails when:
+ * - The API omits a signature (length mismatch)
+ * - Streaming chunks merge with different part counts
+ * - The signature for a functionCall part is an empty string
+ *
+ * This function correlates each "model" content block in the formatted request
+ * back to its originating AI message, then re-attaches non-empty signatures
+ * that the library failed to apply.
+ */
+function fixThoughtSignatures(
+  contents: GeminiContent[],
+  input: BaseMessage[]
+): void {
+  // Collect AI messages that have signatures, in order
+  const aiMessages = input.filter(
+    (msg) =>
+      isAIMessage(msg) &&
+      Array.isArray((msg.additional_kwargs as AdditionalKwargs)?.signatures) &&
+      (msg.additional_kwargs.signatures as string[]).length > 0
+  );
+
+  // Collect "model" content blocks from the formatted request, in order
+  const modelContents = contents.filter((c) => c.role === 'model');
+
+  // They should correspond 1:1 in order (both derived from the same input sequence)
+  const count = Math.min(aiMessages.length, modelContents.length);
+  for (let i = 0; i < count; i++) {
+    const msg = aiMessages[i];
+    const content = modelContents[i];
+    const signatures = (msg.additional_kwargs as AdditionalKwargs)?.signatures;
+
+    // Collect non-empty signatures that aren't already attached to any part
+    const attachedSignatures = new Set(
+      content.parts
+        .map((p) => p.thoughtSignature)
+        .filter((s): s is string => s != null && s !== '')
+    );
+    const availableSignatures = signatures?.filter(
+      (s) => s != null && s !== '' && !attachedSignatures.has(s)
+    );
+
+    // Assign available signatures to functionCall parts missing one, in order
+    let sigIdx = 0;
+    for (const part of content.parts) {
+      if (
+        'functionCall' in part &&
+        (part.thoughtSignature == null || part.thoughtSignature === '') &&
+        sigIdx < (availableSignatures?.length ?? 0)
+      ) {
+        part.thoughtSignature = availableSignatures?.[sigIdx];
+        sigIdx++;
+      }
+    }
+  }
+}
 
 class CustomChatConnection extends ChatConnection<VertexAIClientOptions> {
+  thinkingConfig?: GoogleThinkingConfig;
+
   async formatData(
     input: BaseMessage[],
     parameters: GoogleAIModelRequestParams
@@ -26,6 +97,36 @@ class CustomChatConnection extends ChatConnection<VertexAIClientOptions> {
       }
       delete formattedData.generationConfig.thinkingConfig.thinkingBudget;
     }
+    if (
+      this.thinkingConfig?.thinkingLevel != null &&
+      this.thinkingConfig.thinkingLevel !== ''
+    ) {
+      formattedData.generationConfig ??= {};
+      // thinkingLevel and thinkingBudget cannot coexist — the API rejects the request.
+      // Remove thinkingBudget when thinkingLevel is set.
+      const { thinkingBudget: _, ...existingThinkingConfig } =
+        (formattedData.generationConfig.thinkingConfig as
+          | Record<string, unknown>
+          | undefined) ?? {};
+      (
+        formattedData.generationConfig as Record<string, unknown>
+      ).thinkingConfig = {
+        ...existingThinkingConfig,
+        thinkingLevel: this.thinkingConfig.thinkingLevel,
+        ...(this.thinkingConfig.includeThoughts != null && {
+          includeThoughts: this.thinkingConfig.includeThoughts,
+        }),
+      };
+    }
+    if (formattedData.contents) {
+      fixThoughtSignatures(formattedData.contents, input);
+      // gemini-3.1+ models reject role="function"; convert to role="user"
+      for (const content of formattedData.contents) {
+        if (content.role === 'function') {
+          (content as { role: string }).role = 'user';
+        }
+      }
+    }
     return formattedData;
   }
 }
@@ -315,6 +416,7 @@ class CustomChatConnection extends ChatConnection<VertexAIClientOptions> {
 export class ChatVertexAI extends ChatGoogle {
   lc_namespace = ['langchain', 'chat_models', 'vertexai'];
   dynamicThinkingBudget = false;
+  thinkingConfig?: GoogleThinkingConfig;
 
   static lc_name(): 'IllumaVertexAI' {
     return 'IllumaVertexAI';
@@ -327,6 +429,7 @@ export class ChatVertexAI extends ChatGoogle {
       platformType: 'gcp',
     });
     this.dynamicThinkingBudget = dynamicThinkingBudget;
+    this.thinkingConfig = fields?.thinkingConfig;
   }
   invocationParams(
     options?: this['ParsedCallOptions'] | undefined
@@ -337,23 +440,30 @@ export class ChatVertexAI extends ChatGoogle {
     }
     return params;
   }
-
   buildConnection(
-    fields: VertexAIClientOptions,
+    fields: VertexAIClientOptions | undefined,
     client: GoogleAbstractedClient
   ): void {
-    this.connection = new CustomChatConnection(
+    // Note: buildConnection is called from super() BEFORE this.thinkingConfig is set,
+    // so we must read thinkingConfig from `fields` directly.
+    const thinkingConfig = fields?.thinkingConfig ?? this.thinkingConfig;
+
+    const connection = new CustomChatConnection(
       { ...fields, ...this },
       this.caller,
       client,
       false
     );
+    connection.thinkingConfig = thinkingConfig;
+    this.connection = connection;
 
-    this.streamedConnection = new CustomChatConnection(
+    const streamedConnection = new CustomChatConnection(
       { ...fields, ...this },
       this.caller,
       client,
       true
     );
+    streamedConnection.thinkingConfig = thinkingConfig;
+    this.streamedConnection = streamedConnection;
   }
 }

package/src/llm/vertexai/llm.spec.ts

@@ -0,0 +1,114 @@
+import { config } from 'dotenv';
+config();
+import { test, describe, jest } from '@jest/globals';
+
+jest.setTimeout(90000);
+import {
+  AIMessageChunk,
+  HumanMessage,
+  ToolMessage,
+} from '@langchain/core/messages';
+import { tool } from '@langchain/core/tools';
+import { z } from 'zod/v3';
+import { ChatVertexAI } from './index';
+
+const gemini3Models = [
+  'gemini-3-pro-preview',
+  'gemini-3-flash-preview',
+  'gemini-3.1-flash-lite-preview',
+];
+
+const weatherTool = tool(async () => 'The weather is 80 degrees and sunny', {
+  name: 'weather',
+  description: 'Gets the current weather in a given location',
+  schema: z.object({
+    location: z.string().describe('The city to get the weather for'),
+  }),
+});
+
+describe.each(gemini3Models)(
+  'Vertex AI reasoning with thinkingLevel (%s)',
+  (modelName) => {
+    const model = new ChatVertexAI({
+      model: modelName,
+      location: 'global',
+      maxRetries: 2,
+      thinkingConfig: {
+        thinkingLevel: 'HIGH',
+        includeThoughts: true,
+      },
+    });
+
+    test('invoke with thinkingLevel produces a response with reasoning tokens', async () => {
+      const result = await model.invoke('What is 2+2? Think step by step.');
+      expect(result.content).toBeDefined();
+      const reasoningTokens = (result.usage_metadata as Record<string, unknown>)
+        ?.output_token_details;
+      expect(reasoningTokens).toBeDefined();
+      expect(
+        (reasoningTokens as Record<string, number>)?.reasoning
+      ).toBeGreaterThan(0);
+    });
+  }
+);
+
+describe.each(gemini3Models)(
+  'Vertex AI tool calling with thought signatures (%s)',
+  (modelName) => {
+    const model = new ChatVertexAI({
+      model: modelName,
+      location: 'global',
+      maxRetries: 2,
+    });
+    const modelWithTools = model.bindTools([weatherTool]);
+
+    test('invoke: tool call completes round-trip with thought signature', async () => {
+      const result = await modelWithTools.invoke(
+        'What is the current weather in San Francisco?'
+      );
+      expect(result.tool_calls).toBeDefined();
+      expect(result.tool_calls!.length).toBeGreaterThanOrEqual(1);
+      expect(result.tool_calls![0].id).toBeDefined();
+
+      const toolMessage = new ToolMessage({
+        content: 'The weather is 80 degrees and sunny',
+        tool_call_id: result.tool_calls![0].id ?? '',
+      });
+
+      // Critical round-trip: sending the function call + tool result back to the API.
+      // Without proper thought_signature handling, this fails with
+      // "function call X is missing a thought_signature"
+      const finalResult = await model.invoke([
+        new HumanMessage('What is the current weather in San Francisco?'),
+        result,
+        toolMessage,
+      ]);
+      expect(finalResult.content).toBeDefined();
+    });
+
+    test('stream: tool call completes round-trip with thought signature', async () => {
+      let finalChunk: AIMessageChunk | undefined;
+      for await (const chunk of await modelWithTools.stream(
+        'What is the current weather in San Francisco?'
+      )) {
+        finalChunk = finalChunk ? finalChunk.concat(chunk) : chunk;
+      }
+      expect(finalChunk).toBeDefined();
+      expect(finalChunk?.tool_calls).toBeDefined();
+      expect(finalChunk?.tool_calls!.length).toBeGreaterThanOrEqual(1);
+
+      const toolMessage = new ToolMessage({
+        content: 'The weather is 80 degrees and sunny',
+        tool_call_id: finalChunk?.tool_calls![0].id ?? '',
+      });
+
+      // Round-trip: send tool result back — verifies thought_signature handling
+      const finalResult = await model.invoke([
+        new HumanMessage('What is the current weather in San Francisco?'),
+        finalChunk!,
+        toolMessage,
+      ]);
+      expect(finalResult.content).toBeDefined();
+    });
+  }
+);