@librechat/agents 3.1.53 → 3.1.55

package/src/llm/vertexai/index.ts

@@ -1,13 +1,82 @@
 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 { 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;
 
@@ -28,15 +97,36 @@ class CustomChatConnection extends ChatConnection<VertexAIClientOptions> {
       }
       delete formattedData.generationConfig.thinkingConfig.thinkingBudget;
     }
-    if (this.thinkingConfig?.thinkingLevel) {
+    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 = {
-        ...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 as { role: string }).role = 'user';
+        }
+      }
+    }
     return formattedData;
   }
 }
@@ -350,18 +440,21 @@ export class ChatVertexAI extends ChatGoogle {
     }
     return params;
   }
-
   buildConnection(
-    fields: VertexAIClientOptions,
+    fields: VertexAIClientOptions | undefined,
     client: GoogleAbstractedClient
   ): void {
+    // 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 = this.thinkingConfig;
+    connection.thinkingConfig = thinkingConfig;
     this.connection = connection;
 
     const streamedConnection = new CustomChatConnection(
@@ -370,7 +463,7 @@ export class ChatVertexAI extends ChatGoogle {
       client,
       true
     );
-    streamedConnection.thinkingConfig = this.thinkingConfig;
+    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();
+    });
+  }
+);

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

@@ -0,0 +1,250 @@
+/**
+ * Debug script to investigate cache token omission in Bedrock responses.
+ *
+ * This script:
+ * 1. Makes a streaming call to Bedrock and logs the raw metadata event
+ * 2. Shows exactly what fields the AWS SDK returns in usage (including cache tokens)
+ * 3. Shows what our handleConverseStreamMetadata produces vs what it should produce
+ * 4. Makes a multi-turn call to trigger caching and verify cache tokens appear
+ */
+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 {
+  ConverseStreamCommand,
+  BedrockRuntimeClient,
+} from '@aws-sdk/client-bedrock-runtime';
+import { CustomChatBedrockConverse } from '@/llm/bedrock';
+
+const region = process.env.BEDROCK_AWS_REGION ?? 'us-east-1';
+const credentials = {
+  accessKeyId: process.env.BEDROCK_AWS_ACCESS_KEY_ID!,
+  secretAccessKey: process.env.BEDROCK_AWS_SECRET_ACCESS_KEY!,
+};
+
+const MODEL_ID = 'us.anthropic.claude-sonnet-4-5-20250929-v1:0';
+
+// A long system prompt to increase likelihood of cache usage
+// Bedrock requires minimum 1024 tokens for prompt caching to activate
+const SYSTEM_PROMPT = `You are an expert assistant. Here is a large context block to help trigger cache behavior:
+
+${Array(200).fill('This is padding content to make the prompt large enough to trigger Bedrock prompt caching. The minimum requirement for Anthropic models on Bedrock is 1024 tokens in the cached prefix. We need to ensure this prompt is well above that threshold. ').join('')}
+
+When answering, be brief and direct.`;
+
+async function rawSdkCall(): Promise<void> {
+  console.log('='.repeat(60));
+  console.log('TEST 1: Raw AWS SDK call - inspect metadata.usage directly');
+  console.log('='.repeat(60));
+
+  const client = new BedrockRuntimeClient({ region, credentials });
+
+  // First call - should create cache
+  // Use cachePoint block to explicitly enable prompt caching
+  console.log('\n--- Call 1 (cache write expected) ---');
+  const command1 = new ConverseStreamCommand({
+    modelId: MODEL_ID,
+    system: [{ text: SYSTEM_PROMPT }, { cachePoint: { type: 'default' } }],
+    messages: [{ role: 'user', content: [{ text: 'What is 2+2?' }] }],
+    inferenceConfig: { maxTokens: 100 },
+  });
+
+  const response1 = await client.send(command1);
+  if (response1.stream) {
+    for await (const event of response1.stream) {
+      if (event.metadata != null) {
+        console.log('\nRAW metadata event (Call 1):');
+        console.dir(event.metadata, { depth: null });
+        console.log('\nRAW metadata.usage:');
+        console.dir(event.metadata.usage, { depth: null });
+        console.log('\nSpecific cache fields:');
+        console.log(
+          '  cacheReadInputTokens:',
+          (event.metadata.usage as Record<string, unknown>)
+            ?.cacheReadInputTokens
+        );
+        console.log(
+          '  cacheWriteInputTokens:',
+          (event.metadata.usage as Record<string, unknown>)
+            ?.cacheWriteInputTokens
+        );
+      }
+    }
+  }
+
+  // Second call - should read from cache
+  console.log('\n--- Call 2 (cache read expected) ---');
+  const command2 = new ConverseStreamCommand({
+    modelId: MODEL_ID,
+    system: [{ text: SYSTEM_PROMPT }, { cachePoint: { type: 'default' } }],
+    messages: [
+      { role: 'user', content: [{ text: 'What is 2+2?' }] },
+      { role: 'assistant', content: [{ text: '4' }] },
+      { role: 'user', content: [{ text: 'And what is 3+3?' }] },
+    ],
+    inferenceConfig: { maxTokens: 100 },
+  });
+
+  const response2 = await client.send(command2);
+  if (response2.stream) {
+    for await (const event of response2.stream) {
+      if (event.metadata != null) {
+        console.log('\nRAW metadata event (Call 2):');
+        console.dir(event.metadata, { depth: null });
+        console.log('\nRAW metadata.usage:');
+        console.dir(event.metadata.usage, { depth: null });
+        console.log('\nSpecific cache fields:');
+        console.log(
+          '  cacheReadInputTokens:',
+          (event.metadata.usage as Record<string, unknown>)
+            ?.cacheReadInputTokens
+        );
+        console.log(
+          '  cacheWriteInputTokens:',
+          (event.metadata.usage as Record<string, unknown>)
+            ?.cacheWriteInputTokens
+        );
+      }
+    }
+  }
+}
+
+async function wrapperStreamCallNoCachePoint(): Promise<void> {
+  console.log('\n' + '='.repeat(60));
+  console.log(
+    'TEST 2: CustomChatBedrockConverse stream (NO cachePoint) - check usage_metadata'
+  );
+  console.log('='.repeat(60));
+  console.log('(Without cachePoint, Bedrock does NOT return cache tokens)');
+
+  const model = new CustomChatBedrockConverse({
+    model: MODEL_ID,
+    region,
+    credentials,
+    maxTokens: 100,
+    streaming: true,
+    streamUsage: true,
+  });
+
+  console.log('\n--- Wrapper Call (no cachePoint) ---');
+  const messages1 = [new HumanMessage(SYSTEM_PROMPT + '\n\nWhat is 2+2?')];
+  let finalChunk1: AIMessageChunk | undefined;
+
+  for await (const chunk of await model.stream(messages1)) {
+    finalChunk1 = finalChunk1 ? concat(finalChunk1, chunk) : chunk;
+  }
+
+  console.log(
+    '\nFinal usage_metadata:',
+    JSON.stringify(finalChunk1!.usage_metadata)
+  );
+  console.log('(No cache tokens expected since no cachePoint block was sent)');
+}
+
+async function wrapperStreamCallWithCachePoint(): Promise<void> {
+  console.log('\n' + '='.repeat(60));
+  console.log(
+    'TEST 3: Raw SDK with cachePoint -> verify handleConverseStreamMetadata extracts cache tokens'
+  );
+  console.log('='.repeat(60));
+
+  // We use the raw SDK with cachePoint to trigger caching, then verify
+  // that our handleConverseStreamMetadata function properly extracts cache fields
+  const { handleConverseStreamMetadata } = await import(
+    '@/llm/bedrock/utils/message_outputs'
+  );
+
+  const client = new BedrockRuntimeClient({ region, credentials });
+
+  // Call 1 - establish cache
+  console.log('\n--- Call 1 (cache write) ---');
+  const command1 = new ConverseStreamCommand({
+    modelId: MODEL_ID,
+    system: [{ text: SYSTEM_PROMPT }, { cachePoint: { type: 'default' } }],
+    messages: [{ role: 'user', content: [{ text: 'What is 2+2?' }] }],
+    inferenceConfig: { maxTokens: 100 },
+  });
+
+  const response1 = await client.send(command1);
+  if (response1.stream) {
+    for await (const event of response1.stream) {
+      if (event.metadata != null) {
+        console.log('Raw usage:', JSON.stringify(event.metadata.usage));
+
+        // Test our handler
+        const chunk = handleConverseStreamMetadata(event.metadata, {
+          streamUsage: true,
+        });
+        console.log(
+          'handleConverseStreamMetadata output usage_metadata:',
+          JSON.stringify(chunk.message.usage_metadata)
+        );
+
+        const hasDetails =
+          chunk.message.usage_metadata?.input_token_details != null;
+        console.log(
+          `Has input_token_details: ${hasDetails}`,
+          hasDetails
+            ? JSON.stringify(chunk.message.usage_metadata!.input_token_details)
+            : '(MISSING - BUG!)'
+        );
+      }
+    }
+  }
+
+  // Call 2 - read from cache
+  console.log('\n--- Call 2 (cache read) ---');
+  const command2 = new ConverseStreamCommand({
+    modelId: MODEL_ID,
+    system: [{ text: SYSTEM_PROMPT }, { cachePoint: { type: 'default' } }],
+    messages: [
+      { role: 'user', content: [{ text: 'What is 2+2?' }] },
+      { role: 'assistant', content: [{ text: '4' }] },
+      { role: 'user', content: [{ text: 'What is 3+3?' }] },
+    ],
+    inferenceConfig: { maxTokens: 100 },
+  });
+
+  const response2 = await client.send(command2);
+  if (response2.stream) {
+    for await (const event of response2.stream) {
+      if (event.metadata != null) {
+        console.log('Raw usage:', JSON.stringify(event.metadata.usage));
+
+        const chunk = handleConverseStreamMetadata(event.metadata, {
+          streamUsage: true,
+        });
+        console.log(
+          'handleConverseStreamMetadata output usage_metadata:',
+          JSON.stringify(chunk.message.usage_metadata)
+        );
+
+        const hasDetails =
+          chunk.message.usage_metadata?.input_token_details != null;
+        console.log(
+          `Has input_token_details: ${hasDetails}`,
+          hasDetails
+            ? JSON.stringify(chunk.message.usage_metadata!.input_token_details)
+            : '(MISSING - BUG!)'
+        );
+      }
+    }
+  }
+}
+
+async function main(): Promise<void> {
+  console.log('Bedrock Cache Token Debug Script');
+  console.log(`Model: ${MODEL_ID}`);
+  console.log(`Region: ${region}\n`);
+
+  await rawSdkCall();
+  await wrapperStreamCallNoCachePoint();
+  await wrapperStreamCallWithCachePoint();
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});

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);
+});