@librechat/agents 3.1.54 → 3.1.56

package/src/messages/format.ts

@@ -6,7 +6,6 @@ import {
   BaseMessage,
   HumanMessage,
   SystemMessage,
-  getBufferString,
 } from '@langchain/core/messages';
 import type { MessageContentImageUrl } from '@langchain/core/messages';
 import type { ToolCall } from '@langchain/core/messages/tool';
@@ -998,6 +997,113 @@ export function shiftIndexTokenCountMap(
   return shiftedMap;
 }
 
+/** Block types that contain binary image data and must be preserved structurally. */
+const IMAGE_BLOCK_TYPES = new Set(['image_url', 'image']);
+
+/** Checks whether a BaseMessage is a tool-role message. */
+const isToolMessage = (m: BaseMessage): boolean =>
+  m instanceof ToolMessage || ('role' in m && (m as any).role === 'tool');
+
+/** Flushes accumulated text chunks into `parts` as a single text block. */
+function flushTextChunks(
+  textChunks: string[],
+  parts: MessageContentComplex[]
+): void {
+  if (textChunks.length === 0) {
+    return;
+  }
+  parts.push({
+    type: ContentTypes.TEXT,
+    text: textChunks.join('\n'),
+  } as MessageContentComplex);
+  textChunks.length = 0;
+}
+
+/**
+ * Appends a single message's content to the running `textChunks` / `parts`
+ * accumulators.  Image blocks are shallow-copied into `parts` as-is so that
+ * binary data (base64 images) never becomes text tokens.  All other block
+ * types are serialized to text — unrecognized types are JSON-serialized
+ * rather than silently dropped.
+ *
+ * When `content` is an array containing tool_use blocks, `tool_calls` is NOT
+ * additionally serialized (avoiding double output).  `tool_calls` is used as
+ * a fallback when `content` is a plain string or an array with no tool_use.
+ */
+function appendMessageContent(
+  msg: BaseMessage,
+  role: string,
+  textChunks: string[],
+  parts: MessageContentComplex[]
+): void {
+  const { content } = msg;
+
+  if (typeof content === 'string') {
+    if (content) {
+      textChunks.push(`${role}: ${content}`);
+    }
+    appendToolCalls(msg, role, textChunks);
+    return;
+  }
+
+  if (!Array.isArray(content)) {
+    appendToolCalls(msg, role, textChunks);
+    return;
+  }
+
+  let hasToolUseBlock = false;
+
+  for (const block of content as ExtendedMessageContent[]) {
+    if (IMAGE_BLOCK_TYPES.has(block.type ?? '')) {
+      flushTextChunks(textChunks, parts);
+      parts.push({ ...block } as MessageContentComplex);
+      continue;
+    }
+
+    if (block.type === 'tool_use') {
+      hasToolUseBlock = true;
+      textChunks.push(
+        `${role}: [tool_use] ${String(block.name ?? '')} ${JSON.stringify(block.input ?? {})}`
+      );
+      continue;
+    }
+
+    const text = block.text ?? block.input;
+    if (typeof text === 'string' && text) {
+      textChunks.push(`${role}: ${text}`);
+      continue;
+    }
+
+    // Fallback: serialize unrecognized block types to preserve context
+    if (block.type != null && block.type !== '') {
+      textChunks.push(`${role}: [${block.type}] ${JSON.stringify(block)}`);
+    }
+  }
+
+  // If content array had no tool_use blocks, fall back to tool_calls metadata
+  // (handles edge case: empty content array with tool_calls populated)
+  if (!hasToolUseBlock) {
+    appendToolCalls(msg, role, textChunks);
+  }
+}
+
+function appendToolCalls(
+  msg: BaseMessage,
+  role: string,
+  textChunks: string[]
+): void {
+  if (role !== 'AI') {
+    return;
+  }
+  const aiMsg = msg as AIMessage;
+  if (!aiMsg.tool_calls || aiMsg.tool_calls.length === 0) {
+    return;
+  }
+  for (const tc of aiMsg.tool_calls) {
+    textChunks.push(`AI: [tool_call] ${tc.name}(${JSON.stringify(tc.args)})`);
+  }
+}
+
 /**
  * Ensures compatibility when switching from a non-thinking agent to a thinking-enabled agent.
  * Converts AI messages with tool calls (that lack thinking/reasoning blocks) into buffer strings,
@@ -1021,19 +1127,27 @@ export function ensureThinkingBlockInMessages(
     return messages;
   }
 
-  // If the last message is already a HumanMessage, there is no trailing tool
-  // sequence to convert — return early to preserve prompt caching and avoid
-  // redundant token overhead from re-processing the entire history.
-  const lastMsg = messages[messages.length - 1];
-  const lastIsHuman =
-    lastMsg instanceof HumanMessage ||
-    ('role' in lastMsg && (lastMsg as any).role === 'user');
-  if (lastIsHuman) {
+  // Find the last HumanMessage. Only the trailing sequence after it needs
+  // validation — earlier messages are history already accepted by the provider.
+  let lastHumanIndex = -1;
+  for (let k = messages.length - 1; k >= 0; k--) {
+    const m = messages[k];
+    if (
+      m instanceof HumanMessage ||
+      ('role' in m && (m as any).role === 'user')
+    ) {
+      lastHumanIndex = k;
+      break;
+    }
+  }
+
+  if (lastHumanIndex === messages.length - 1) {
     return messages;
   }
 
-  const result: BaseMessage[] = [];
-  let i = 0;
+  const result: BaseMessage[] =
+    lastHumanIndex >= 0 ? messages.slice(0, lastHumanIndex + 1) : [];
+  let i = lastHumanIndex + 1;
 
   while (i < messages.length) {
     const msg = messages[i];
@@ -1059,21 +1173,24 @@ export function ensureThinkingBlockInMessages(
     let hasThinkingBlock = false;
 
     if (contentIsArray && aiMsg.content.length > 0) {
-      const content = aiMsg.content as ExtendedMessageContent[];
-      hasToolUse =
-        hasToolUse ||
-        content.some((c) => typeof c === 'object' && c.type === 'tool_use');
-      // Check ALL content blocks for thinking/reasoning, not just [0].
-      // Bedrock may emit a whitespace text chunk before the thinking block,
-      // pushing the reasoning_content to index 1+.
-      hasThinkingBlock = content.some(
-        (c) =>
-          typeof c === 'object' &&
-          (c.type === ContentTypes.THINKING ||
-            c.type === ContentTypes.REASONING_CONTENT ||
-            c.type === ContentTypes.REASONING ||
-            c.type === 'redacted_thinking')
-      );
+      for (const c of aiMsg.content as ExtendedMessageContent[]) {
+        if (typeof c !== 'object') {
+          continue;
+        }
+        if (c.type === 'tool_use') {
+          hasToolUse = true;
+        } else if (
+          c.type === ContentTypes.THINKING ||
+          c.type === ContentTypes.REASONING_CONTENT ||
+          c.type === ContentTypes.REASONING ||
+          c.type === 'redacted_thinking'
+        ) {
+          hasThinkingBlock = true;
+        }
+        if (hasToolUse && hasThinkingBlock) {
+          break;
+        }
+      }
     }
 
     // Bedrock also stores reasoning in additional_kwargs (may not be in content array)
@@ -1100,28 +1217,22 @@ export function ensureThinkingBlockInMessages(
         continue;
       }
 
-      // Collect the AI message and any following tool messages
-      const toolSequence: BaseMessage[] = [msg];
-      let j = i + 1;
+      // Build structured content in a single pass over the AI + following
+      // ToolMessages — preserves image blocks as-is to avoid serializing
+      // binary data as text (which caused 174× token amplification).
+      const parts: MessageContentComplex[] = [];
+      const textChunks: string[] = ['[Previous agent context]'];
+
+      appendMessageContent(msg, 'AI', textChunks, parts);
 
-      // Look ahead for tool messages that belong to this AI message
-      const isToolMsg = (m: BaseMessage): boolean =>
-        m instanceof ToolMessage || ('role' in m && (m as any).role === 'tool');
-      while (j < messages.length && isToolMsg(messages[j])) {
-        toolSequence.push(messages[j]);
+      let j = i + 1;
+      while (j < messages.length && isToolMessage(messages[j])) {
+        appendMessageContent(messages[j], 'Tool', textChunks, parts);
         j++;
       }
 
-      // Convert the sequence to a buffer string and wrap in a HumanMessage
-      // This avoids the thinking block requirement which only applies to AI messages
-      const bufferString = getBufferString(toolSequence);
-      result.push(
-        new HumanMessage({
-          content: `[Previous agent context]\n${bufferString}`,
-        })
-      );
-
-      // Skip the messages we've processed
+      flushTextChunks(textChunks, parts);
+      result.push(new HumanMessage({ content: parts }));
       i = j;
     } else {
       // Keep the message as is

package/src/run.ts

@@ -16,9 +16,9 @@ import {
   createCompletionTitleRunnable,
   createTitleRunnable,
 } from '@/utils/title';
+import { createTokenCounter, encodingForModel } from '@/utils/tokens';
 import { GraphEvents, Callback, TitleMethod } from '@/common';
 import { MultiAgentGraph } from '@/graphs/MultiAgentGraph';
-import { createTokenCounter } from '@/utils/tokens';
 import { StandardGraph } from '@/graphs/Graph';
 import { HandlerRegistry } from '@/events';
 import { isOpenAILike } from '@/utils/llm';
@@ -166,7 +166,11 @@ export class Run<_T extends t.BaseGraphState> {
   ): Promise<Run<T>> {
     /** Create tokenCounter if indexTokenCountMap is provided but tokenCounter is not */
     if (config.indexTokenCountMap && !config.tokenCounter) {
-      config.tokenCounter = await createTokenCounter();
+      const gc = config.graphConfig;
+      const clientOpts =
+        'agents' in gc ? gc.agents[0]?.clientOptions : gc.clientOptions;
+      const model = (clientOpts as { model?: string } | undefined)?.model ?? '';
+      config.tokenCounter = await createTokenCounter(encodingForModel(model));
     }
     return new Run<T>(config);
   }

package/src/scripts/bedrock-cache-debug.ts

@@ -9,13 +9,13 @@
  */
 import { config } from 'dotenv';
 config();
-import { HumanMessage } from '@langchain/core/messages';
-import type { AIMessageChunk } from '@langchain/core/messages';
 import { concat } from '@langchain/core/utils/stream';
+import { HumanMessage } from '@langchain/core/messages';
 import {
-  ConverseStreamCommand,
   BedrockRuntimeClient,
+  ConverseStreamCommand,
 } from '@aws-sdk/client-bedrock-runtime';
+import type { AIMessageChunk } from '@langchain/core/messages';
 import { CustomChatBedrockConverse } from '@/llm/bedrock';
 
 const region = process.env.BEDROCK_AWS_REGION ?? 'us-east-1';
@@ -62,12 +62,12 @@ async function rawSdkCall(): Promise<void> {
         console.log('\nSpecific cache fields:');
         console.log(
           '  cacheReadInputTokens:',
-          (event.metadata.usage as Record<string, unknown>)
+          (event.metadata.usage as unknown as Record<string, unknown>)
             ?.cacheReadInputTokens
         );
         console.log(
           '  cacheWriteInputTokens:',
-          (event.metadata.usage as Record<string, unknown>)
+          (event.metadata.usage as unknown as Record<string, unknown>)
             ?.cacheWriteInputTokens
         );
       }
@@ -98,12 +98,12 @@ async function rawSdkCall(): Promise<void> {
         console.log('\nSpecific cache fields:');
         console.log(
           '  cacheReadInputTokens:',
-          (event.metadata.usage as Record<string, unknown>)
+          (event.metadata.usage as unknown as Record<string, unknown>)
             ?.cacheReadInputTokens
         );
         console.log(
           '  cacheWriteInputTokens:',
-          (event.metadata.usage as Record<string, unknown>)
+          (event.metadata.usage as unknown as Record<string, unknown>)
             ?.cacheWriteInputTokens
         );
       }
@@ -177,17 +177,17 @@ async function wrapperStreamCallWithCachePoint(): Promise<void> {
         const chunk = handleConverseStreamMetadata(event.metadata, {
           streamUsage: true,
         });
+        const msg = chunk.message as AIMessageChunk;
         console.log(
           'handleConverseStreamMetadata output usage_metadata:',
-          JSON.stringify(chunk.message.usage_metadata)
+          JSON.stringify(msg.usage_metadata)
         );
 
-        const hasDetails =
-          chunk.message.usage_metadata?.input_token_details != null;
+        const hasDetails = msg.usage_metadata?.input_token_details != null;
         console.log(
           `Has input_token_details: ${hasDetails}`,
           hasDetails
-            ? JSON.stringify(chunk.message.usage_metadata!.input_token_details)
+            ? JSON.stringify(msg.usage_metadata!.input_token_details)
             : '(MISSING - BUG!)'
         );
       }
@@ -216,17 +216,17 @@ async function wrapperStreamCallWithCachePoint(): Promise<void> {
         const chunk = handleConverseStreamMetadata(event.metadata, {
           streamUsage: true,
         });
+        const msg = chunk.message as AIMessageChunk;
         console.log(
           'handleConverseStreamMetadata output usage_metadata:',
-          JSON.stringify(chunk.message.usage_metadata)
+          JSON.stringify(msg.usage_metadata)
         );
 
-        const hasDetails =
-          chunk.message.usage_metadata?.input_token_details != null;
+        const hasDetails = msg.usage_metadata?.input_token_details != null;
         console.log(
           `Has input_token_details: ${hasDetails}`,
           hasDetails
-            ? JSON.stringify(chunk.message.usage_metadata!.input_token_details)
+            ? JSON.stringify(msg.usage_metadata!.input_token_details)
             : '(MISSING - BUG!)'
         );
       }

package/src/scripts/code_exec_multi_session.ts

@@ -44,8 +44,8 @@ function printSessionContext(run: Run<t.IState>, label: string): void {
   }
 
   console.log(`  Latest session_id: ${session.session_id}`);
-  console.log(`  Files tracked: ${session.files.length}`);
-  for (const file of session.files) {
+  console.log(`  Files tracked: ${session.files?.length ?? 0}`);
+  for (const file of session.files ?? []) {
     console.log(`    - ${file.name} (session: ${file.session_id})`);
   }
 }
@@ -199,25 +199,20 @@ Tell me what version it shows.
     | undefined;
 
   if (finalSession) {
-    const uniqueSessionIds = new Set(
-      finalSession.files.map((f) => f.session_id)
-    );
-    console.log(`\nTotal files tracked: ${finalSession.files.length}`);
+    const files = finalSession.files ?? [];
+    const uniqueSessionIds = new Set(files.map((f) => f.session_id));
+    console.log(`\nTotal files tracked: ${files.length}`);
     console.log(`Unique session_ids: ${uniqueSessionIds.size}`);
     console.log('\nFiles:');
-    for (const file of finalSession.files) {
+    for (const file of files) {
       console.log(
         `  - ${file.name} (session: ${file.session_id?.slice(0, 20)}...)`
       );
     }
 
     // Verify expectations
-    const fileACount = finalSession.files.filter(
-      (f) => f.name === 'file_a.txt'
-    ).length;
-    const fileBCount = finalSession.files.filter(
-      (f) => f.name === 'file_b.txt'
-    ).length;
+    const fileACount = files.filter((f) => f.name === 'file_a.txt').length;
+    const fileBCount = files.filter((f) => f.name === 'file_b.txt').length;
 
     console.log('\n✓ Checks:');
     console.log(`  file_a.txt count: ${fileACount} (expected: 1, latest wins)`);

package/src/scripts/image.ts

@@ -1,4 +1,4 @@
-// src/scripts/cli.ts
+// src/scripts/image.ts
 import { config } from 'dotenv';
 config();
 import { HumanMessage, AIMessage, BaseMessage } from '@langchain/core/messages';
@@ -10,6 +10,7 @@ import {
   ModelEndHandler,
   createMetadataAggregator,
 } from '@/events';
+// @ts-expect-error — example module not in current codebase
 import { fetchRandomImageTool, fetchRandomImageURL } from '@/tools/example';
 import { getLLMConfig } from '@/utils/llmConfig';
 import { getArgs } from '@/scripts/args';

package/src/scripts/multi-agent-parallel-start.ts

@@ -25,8 +25,7 @@ async function testParallelFromStart() {
   console.log('Testing Parallel From Start Multi-Agent System...\n');
 
   // Set up content aggregator
-  const { contentParts, aggregateContent, contentMetadataMap } =
-    createContentAggregator();
+  const { contentParts, aggregateContent, stepMap } = createContentAggregator();
 
   // Define two agents - both have NO incoming edges, so they run in parallel from the start
   const agents: t.AgentInputs[] = [
@@ -253,8 +252,8 @@ async function testParallelFromStart() {
     console.log('Final content parts:', contentParts.length, 'parts');
     console.log('\n=== Content Parts (clean, no metadata) ===');
     console.dir(contentParts, { depth: null });
-    console.log('\n=== Content Metadata Map (separate from content) ===');
-    console.dir(Object.fromEntries(contentMetadataMap), { depth: null });
+    console.log('\n=== Step Map (separate from content) ===');
+    console.dir(Object.fromEntries(stepMap), { depth: null });
 
     await sleep(3000);
   } catch (error) {

package/src/scripts/multi-agent-sequence.ts

@@ -22,8 +22,7 @@ async function testSequentialMultiAgent() {
   console.log('Testing Sequential Multi-Agent System (A → B → C)...\n');
 
   // Set up content aggregator
-  const { contentParts, aggregateContent, contentMetadataMap } =
-    createContentAggregator();
+  const { contentParts, aggregateContent, stepMap } = createContentAggregator();
 
   // Define three simple agents
   const agents: t.AgentInputs[] = [
@@ -198,8 +197,8 @@ async function testSequentialMultiAgent() {
     console.log(`Total content parts: ${contentParts.length}`);
     console.log('\n=== Content Parts (clean, no metadata) ===');
     console.dir(contentParts, { depth: null });
-    console.log('\n=== Content Metadata Map (separate from content) ===');
-    console.dir(Object.fromEntries(contentMetadataMap), { depth: null });
+    console.log('\n=== Step Map (separate from content) ===');
+    console.dir(Object.fromEntries(stepMap), { depth: null });
 
     // Display the sequential responses
     const aiMessages = conversationHistory.filter(

package/src/scripts/single-agent-metadata-test.ts

@@ -20,8 +20,7 @@ async function testSingleAgent() {
   console.log('Testing Single Agent with Metadata Logging...\n');
 
   // Set up content aggregator
-  const { contentParts, aggregateContent, contentMetadataMap } =
-    createContentAggregator();
+  const { contentParts, aggregateContent, stepMap } = createContentAggregator();
 
   const startTime = Date.now();
 
@@ -183,10 +182,8 @@ async function testSingleAgent() {
     console.log('Final content parts:', contentParts.length, 'parts');
     console.log('\n=== Content Parts (clean, no metadata) ===');
     console.dir(contentParts, { depth: null });
-    console.log(
-      '\n=== Content Metadata Map (should be empty for single-agent) ==='
-    );
-    console.dir(Object.fromEntries(contentMetadataMap), { depth: null });
+    console.log('\n=== Step Map (should be empty for single-agent) ===');
+    console.dir(Object.fromEntries(stepMap), { depth: null });
     console.log('====================================\n');
 
     await sleep(3000);

package/src/scripts/test-tool-before-handoff-role-order.ts

@@ -42,10 +42,9 @@ async function testToolBeforeHandoffRoleOrder(): Promise<void> {
   let handoffOccurred = false;
 
   const customHandlers = {
-    [GraphEvents.TOOL_END]: new ToolEndHandler(undefined, (name?: string) => {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(async () => {
       toolCallCount++;
-      console.log(`\n  Tool completed: ${name} (total: ${toolCallCount})`);
-      return true;
+      console.log(`\n  Tool completed (total: ${toolCallCount})`);
     }),
     [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
     [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),

package/src/scripts/test-tools-before-handoff.ts

@@ -28,9 +28,8 @@ async function testToolsBeforeHandoff() {
 
   // Create custom handlers
   const customHandlers = {
-    [GraphEvents.TOOL_END]: new ToolEndHandler(undefined, (name?: string) => {
-      console.log(`\n✅ Tool completed: ${name}`);
-      return true;
+    [GraphEvents.TOOL_END]: new ToolEndHandler(async () => {
+      console.log('\n✅ Tool completed');
     }),
     [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
     [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),

package/src/scripts/thinking-vertexai.ts

@@ -0,0 +1,168 @@
+// src/scripts/thinking-vertexai.ts
+import { config } from 'dotenv';
+config();
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import type { UsageMetadata } from '@langchain/core/messages';
+import * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { GraphEvents, Providers } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+
+const conversationHistory: BaseMessage[] = [];
+let _contentParts: t.MessageContentComplex[] = [];
+const collectedUsage: UsageMetadata[] = [];
+
+async function testVertexAIThinking(): Promise<void> {
+  const { userName } = await getArgs();
+  const instructions = `You are a helpful AI assistant for ${userName}. When answering questions, be thorough in your reasoning.`;
+  const { contentParts, aggregateContent } = createContentAggregator();
+  _contentParts = contentParts as t.MessageContentComplex[];
+
+  // Set up event handlers
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
+        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (event: GraphEvents.ON_RUN_STEP, data: t.RunStep) => {
+        aggregateContent({ event, data });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.RunStepDeltaEvent
+      ) => {
+        aggregateContent({ event, data });
+      },
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.MessageDeltaEvent
+      ) => {
+        aggregateContent({ event, data });
+      },
+    },
+    [GraphEvents.ON_REASONING_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_REASONING_DELTA,
+        data: t.ReasoningDeltaEvent
+      ) => {
+        console.log(
+          '[ON_REASONING_DELTA]',
+          JSON.stringify(data.delta.content?.[0]).slice(0, 100)
+        );
+        aggregateContent({ event, data });
+      },
+    },
+  };
+
+  const baseLlmConfig = getLLMConfig(Providers.VERTEXAI);
+
+  const llmConfig = {
+    ...baseLlmConfig,
+    model: 'gemini-3-flash-preview',
+    location: 'global',
+    streaming: true,
+    streamUsage: true,
+    thinkingConfig: {
+      thinkingLevel: 'HIGH',
+      includeThoughts: true,
+    },
+  };
+
+  const run = await Run.create<t.IState>({
+    runId: 'test-vertexai-thinking-id',
+    graphConfig: {
+      instructions,
+      type: 'standard',
+      llmConfig,
+    },
+    returnContent: true,
+    skipCleanup: true,
+    customHandlers: customHandlers as t.RunConfig['customHandlers'],
+  });
+
+  const streamConfig = {
+    configurable: {
+      thread_id: 'vertexai-thinking-test-thread',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  // Test 1: Regular thinking mode
+  console.log('\n\nTest 1: Vertex AI thinking mode with thinkingLevel=HIGH');
+  const userMessage1 =
+    'How many r\'s are in the word "strawberry"? Think carefully.';
+  conversationHistory.push(new HumanMessage(userMessage1));
+
+  console.log('Running first query with Vertex AI thinking enabled...');
+  const firstInputs = { messages: [...conversationHistory] };
+  await run.processStream(firstInputs, streamConfig);
+
+  // Extract and display results
+  const finalMessages = run.getRunMessages();
+  console.log('\n\nFinal messages after Test 1:');
+  console.dir(finalMessages, { depth: null });
+
+  // Test 2: Multi-turn conversation
+  console.log(
+    '\n\nTest 2: Multi-turn conversation with Vertex AI thinking enabled'
+  );
+  const userMessage2 =
+    'Now count the number of letters in "Mississippi". Explain step by step.';
+  conversationHistory.push(new HumanMessage(userMessage2));
+
+  console.log('Running second query with Vertex AI thinking enabled...');
+  const secondInputs = { messages: [...conversationHistory] };
+  await run.processStream(secondInputs, streamConfig);
+
+  const finalMessages2 = run.getRunMessages();
+  console.log('\n\nVertex AI thinking feature test completed!');
+  console.dir(finalMessages2, { depth: null });
+
+  console.log('\n\nContent parts:');
+  console.dir(_contentParts, { depth: null });
+
+  console.log('\n\nCollected usage:');
+  console.dir(collectedUsage, { depth: null });
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  console.log('Content parts:');
+  console.dir(_contentParts, { depth: null });
+  process.exit(1);
+});
+
+process.on('uncaughtException', (err) => {
+  console.error('Uncaught Exception:', err);
+});
+
+testVertexAIThinking().catch((err) => {
+  console.error(err);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  console.log('Content parts:');
+  console.dir(_contentParts, { depth: null });
+  process.exit(1);
+});