@librechat/agents 1.8.7 → 1.8.9

package/dist/types/llm/anthropic/types.d.ts

@@ -18,3 +18,7 @@ export type AnthropicToolChoice = {
     name: string;
 } | 'any' | 'auto' | 'none' | string;
 export type ChatAnthropicToolType = AnthropicTool | BindToolsInput;
+export type AnthropicTextBlockParam = Anthropic.Messages.TextBlockParam;
+export type AnthropicImageBlockParam = Anthropic.Messages.ImageBlockParam;
+export type AnthropicToolUseBlockParam = Anthropic.Messages.ToolUseBlockParam;
+export type AnthropicToolResultBlockParam = Anthropic.Messages.ToolResultBlockParam;

package/dist/types/llm/anthropic/utils/message_inputs.d.ts

@@ -3,7 +3,7 @@
  */
 import { BaseMessage } from '@langchain/core/messages';
 import { ToolCall } from '@langchain/core/messages/tool';
-import type { AnthropicMessageCreateParams, AnthropicToolResponse } from '@/llm/anthropic/types';
+import type { AnthropicToolResponse, AnthropicMessageCreateParams } from '@/llm/anthropic/types';
 export declare function _convertLangChainToolCallToAnthropic(toolCall: ToolCall): AnthropicToolResponse;
 /**
  * Formats messages as a prompt for the model.

package/dist/types/llm/text.d.ts

@@ -1,21 +1,21 @@
-import { Readable } from 'stream';
-import type { ReadableOptions } from 'stream';
-export interface TextStreamOptions extends ReadableOptions {
+export interface TextStreamOptions {
     minChunkSize?: number;
     maxChunkSize?: number;
     delay?: number;
+    firstWordChunk?: boolean;
 }
 export type ProgressCallback = (chunk: string) => void;
 export type PostChunkCallback = (chunk: string) => void;
-export declare class TextStream extends Readable {
+export declare class TextStream {
     private text;
     private currentIndex;
     private minChunkSize;
     private maxChunkSize;
     private delay;
+    private firstWordChunk;
     constructor(text: string, options?: TextStreamOptions);
-    _read(): void;
     private randomInt;
-    processTextStream(progressCallback: ProgressCallback): Promise<void>;
+    private static readonly BOUNDARIES;
+    private findFirstWordBoundary;
     generateText(progressCallback?: ProgressCallback): AsyncGenerator<string, void, unknown>;
 }

package/dist/types/stream.d.ts

@@ -1,6 +1,8 @@
+import type { ToolCall } from '@langchain/core/messages/tool';
 import type { Graph } from '@/graphs';
 import type * as t from '@/types';
 import { GraphEvents } from '@/common';
+export declare const handleToolCalls: (toolCalls?: ToolCall[], metadata?: Record<string, unknown>, graph?: Graph) => void;
 export declare class ChatModelStreamHandler implements t.EventHandler {
     handle(event: string, data: t.StreamEventData, metadata?: Record<string, unknown>, graph?: Graph): void;
 }

package/dist/types/types/llm.d.ts

@@ -5,12 +5,14 @@ import { ChatMistralAI } from '@langchain/mistralai';
 import { ChatBedrockConverse } from '@langchain/aws';
 import { ChatVertexAI } from '@langchain/google-vertexai';
 import { BedrockChat } from '@langchain/community/chat_models/bedrock/web';
+import { ChatGoogleGenerativeAI } from '@langchain/google-genai';
 import type { Runnable } from '@langchain/core/runnables';
 import type { StructuredTool } from '@langchain/core/tools';
 import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
 import type { BedrockChatFields } from '@langchain/community/chat_models/bedrock/web';
 import type { ChatOpenAIFields } from '@langchain/openai';
 import type { OpenAI as OpenAIClient } from 'openai';
+import type { GoogleGenerativeAIChatInput } from '@langchain/google-genai';
 import type { ChatVertexAIInput } from '@langchain/google-vertexai';
 import type { ChatBedrockConverseInput } from '@langchain/aws';
 import type { ChatMistralAIInput } from '@langchain/mistralai';
@@ -26,7 +28,8 @@ export type MistralAIClientOptions = ChatMistralAIInput;
 export type VertexAIClientOptions = ChatVertexAIInput;
 export type BedrockClientOptions = BedrockChatFields;
 export type BedrockConverseClientOptions = ChatBedrockConverseInput;
-export type ClientOptions = OpenAIClientOptions | OllamaClientOptions | AnthropicClientOptions | MistralAIClientOptions | VertexAIClientOptions | BedrockClientOptions | BedrockConverseClientOptions;
+export type GoogleClientOptions = GoogleGenerativeAIChatInput;
+export type ClientOptions = OpenAIClientOptions | OllamaClientOptions | AnthropicClientOptions | MistralAIClientOptions | VertexAIClientOptions | BedrockClientOptions | BedrockConverseClientOptions | GoogleClientOptions;
 export type LLMConfig = {
     provider: Providers;
 } & ClientOptions;
@@ -38,6 +41,7 @@ export type ProviderOptionsMap = {
     [Providers.VERTEXAI]: VertexAIClientOptions;
     [Providers.BEDROCK_LEGACY]: BedrockClientOptions;
     [Providers.BEDROCK]: BedrockConverseClientOptions;
+    [Providers.GOOGLE]: GoogleClientOptions;
 };
 export type ChatModelMap = {
     [Providers.OPENAI]: ChatOpenAI;
@@ -47,6 +51,7 @@ export type ChatModelMap = {
     [Providers.VERTEXAI]: ChatVertexAI;
     [Providers.BEDROCK_LEGACY]: BedrockChat;
     [Providers.BEDROCK]: ChatBedrockConverse;
+    [Providers.GOOGLE]: ChatGoogleGenerativeAI;
 };
 export type ChatModelConstructorMap = {
     [P in Providers]: new (config: ProviderOptionsMap[P]) => ChatModelMap[P];

package/dist/types/utils/index.d.ts

@@ -1,2 +1,3 @@
 export * from './graph';
+export * from './misc';
 export * from './run';

package/dist/types/utils/misc.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Recursively unescapes all string values in an object
+ * @param obj The object to unescape
+ * @returns The unescaped object
+ */
+export declare function unescapeObject(obj: unknown, key?: string): unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "1.8.7",
+  "version": "1.8.9",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -42,10 +42,10 @@
     "start:cli": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/cli.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
     "content": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/content.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
     "stream": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/stream.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
-    "code_exec": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/code_exec.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
+    "code_exec": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/code_exec.ts --provider 'google' --name 'Jo' --location 'New York, NY'",
     "image": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/image.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
     "code_exec_simple": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/code_exec_simple.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
-    "simple": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/simple.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
+    "simple": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/simple.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
     "memory": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/memory.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
     "tool-test": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/tools.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
     "abort": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/abort.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
@@ -70,12 +70,13 @@
     "@aws-crypto/sha256-js": "^5.2.0",
     "@aws-sdk/credential-provider-node": "^3.613.0",
     "@aws-sdk/types": "^3.609.0",
-    "@langchain/anthropic": "^0.3.8",
+    "@langchain/anthropic": "^0.3.11",
     "@langchain/aws": "^0.1.2",
     "@langchain/community": "^0.3.14",
-    "@langchain/core": "^0.3.18",
-    "@langchain/google-vertexai": "^0.1.2",
-    "@langchain/langgraph": "^0.2.19",
+    "@langchain/core": "^0.3.26",
+    "@langchain/google-genai": "^0.1.6",
+    "@langchain/google-vertexai": "^0.1.5",
+    "@langchain/langgraph": "^0.2.34",
     "@langchain/mistralai": "^0.0.26",
     "@langchain/ollama": "^0.1.1",
     "@langchain/openai": "^0.3.14",

package/src/common/enum.ts

@@ -74,6 +74,7 @@ export enum Providers {
   ANTHROPIC = 'anthropic',
   MISTRALAI = 'mistralai',
   OLLAMA = 'ollama',
+  GOOGLE = 'google',
 }
 
 export enum GraphNodeKeys {

package/src/events.ts

@@ -2,6 +2,8 @@
 // src/events.ts
 import type { Graph } from '@/graphs';
 import type * as t from '@/types';
+import { handleToolCalls } from '@/stream';
+import { Providers } from '@/common';
 
 export class HandlerRegistry {
   private handlers: Map<string, t.EventHandler> = new Map();
@@ -28,6 +30,12 @@ export class ModelEndHandler implements t.EventHandler {
     console.dir({
       usage,
     }, { depth: null });
+
+    if (metadata.provider !== Providers.GOOGLE) {
+      return;
+    }
+
+    handleToolCalls(data?.output?.tool_calls, metadata, graph);
   }
 }
 
@@ -58,7 +66,7 @@ export class TestLLMStreamHandler implements t.EventHandler {
   handle(event: string, data: t.StreamEventData | undefined): void {
     const chunk = data?.chunk;
     const  isMessageChunk = !!(chunk && 'message' in chunk);
-    const msg = isMessageChunk && chunk.message;
+    const msg = isMessageChunk ? chunk.message : undefined;
     if (msg && msg.tool_call_chunks && msg.tool_call_chunks.length > 0) {
       console.log(msg.tool_call_chunks);
     } else if (msg && msg.content) {

package/src/llm/anthropic/llm.ts

@@ -84,7 +84,7 @@ export class CustomAnthropic extends ChatAnthropicMessages {
     );
 
     for await (const data of stream) {
-      if (options.signal?.aborted) {
+      if (options.signal?.aborted === true) {
         stream.controller.abort();
         throw new Error('AbortError: User aborted the request.');
       }

package/src/llm/anthropic/types.ts

@@ -10,6 +10,7 @@ export type AnthropicToolResponse = {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   input: Record<string, any>;
 };
+
 export type AnthropicMessageParam = Anthropic.MessageParam;
 export type AnthropicMessageResponse =
   | Anthropic.ContentBlock
@@ -29,4 +30,9 @@ export type AnthropicToolChoice =
   | 'auto'
   | 'none'
   | string;
-export type ChatAnthropicToolType = AnthropicTool | BindToolsInput;
+export type ChatAnthropicToolType = AnthropicTool | BindToolsInput;
+export type AnthropicTextBlockParam = Anthropic.Messages.TextBlockParam;
+export type AnthropicImageBlockParam = Anthropic.Messages.ImageBlockParam;
+export type AnthropicToolUseBlockParam = Anthropic.Messages.ToolUseBlockParam;
+export type AnthropicToolResultBlockParam =
+  Anthropic.Messages.ToolResultBlockParam;

package/src/llm/anthropic/utils/message_inputs.ts

@@ -1,19 +1,25 @@
+/* eslint-disable no-console */
 /**
  * This util file contains functions for converting LangChain messages to Anthropic messages.
  */
 import {
-  BaseMessage,
-  SystemMessage,
-  HumanMessage,
   AIMessage,
+  BaseMessage,
   ToolMessage,
-  MessageContent,
   isAIMessage,
+  HumanMessage,
+  SystemMessage,
+  MessageContent,
 } from '@langchain/core/messages';
 import { ToolCall } from '@langchain/core/messages/tool';
 import type {
-  AnthropicMessageCreateParams,
   AnthropicToolResponse,
+  AnthropicMessageParam,
+  AnthropicTextBlockParam,
+  AnthropicImageBlockParam,
+  AnthropicToolUseBlockParam,
+  AnthropicMessageCreateParams,
+  AnthropicToolResultBlockParam,
 } from '@/llm/anthropic/types';
 
 function _formatImage(imageUrl: string): { type: string; media_type: string; data: string } {
@@ -130,7 +136,7 @@ function _formatContent(content: MessageContent): string | Record<string, any>[]
           ...(cacheControl ? { cache_control: cacheControl } : {}),
         };
       } else if (
-        textTypes.find((t) => t === contentPart.type) &&
+        textTypes.find((t) => t === contentPart.type) != null &&
         'text' in contentPart
       ) {
         // Assuming contentPart is of type MessageContentText here
@@ -139,7 +145,7 @@ function _formatContent(content: MessageContent): string | Record<string, any>[]
           text: contentPart.text,
           ...(cacheControl ? { cache_control: cacheControl } : {}),
         };
-      } else if (toolTypes.find((t) => t === contentPart.type)) {
+      } else if (toolTypes.find((t) => t === contentPart.type) != null) {
         const contentPartCopy = { ...contentPart };
         if ('index' in contentPartCopy) {
           // Anthropic does not support passing the index field here, so we remove it.
@@ -252,7 +258,79 @@ export function _convertMessagesToAnthropicPayload(
     }
   });
   return {
-    messages: formattedMessages,
+    messages: mergeMessages(formattedMessages as AnthropicMessageCreateParams['messages']),
     system,
   } as AnthropicMessageCreateParams;
+}
+
+function mergeMessages(messages?: AnthropicMessageCreateParams['messages']): AnthropicMessageParam[] {
+  if (!messages || messages.length <= 1) {
+    return messages ?? [];
+  }
+
+  const result: AnthropicMessageCreateParams['messages'] = [];
+  let currentMessage = messages[0];
+
+  const normalizeContent = (
+    content:
+      | string
+      | Array<
+          | AnthropicTextBlockParam
+          | AnthropicImageBlockParam
+          | AnthropicToolUseBlockParam
+          | AnthropicToolResultBlockParam
+        >
+  ): Array<
+    | AnthropicTextBlockParam
+    | AnthropicImageBlockParam
+    | AnthropicToolUseBlockParam
+    | AnthropicToolResultBlockParam
+  > => {
+    if (typeof content === 'string') {
+      return [
+        {
+          type: 'text',
+          text: content,
+        },
+      ];
+    }
+    return content;
+  };
+
+  const isToolResultMessage = (msg: (typeof messages)[0]): boolean => {
+    if (msg.role !== 'user') return false;
+
+    if (typeof msg.content === 'string') {
+      return false;
+    }
+
+    return (
+      Array.isArray(msg.content) &&
+      msg.content.every((item) => item.type === 'tool_result')
+    );
+  };
+
+  for (let i = 1; i < messages.length; i += 1) {
+    const nextMessage = messages[i];
+
+    if (
+      isToolResultMessage(currentMessage) &&
+      isToolResultMessage(nextMessage)
+    ) {
+      // Merge the messages by combining their content arrays
+      currentMessage = {
+        ...currentMessage,
+        content: [
+          ...normalizeContent(currentMessage.content),
+          ...normalizeContent(nextMessage.content),
+        ],
+      };
+    } else {
+      result.push(currentMessage);
+      currentMessage = nextMessage;
+    }
+  }
+
+  result.push(currentMessage);
+  return result;
 }

package/src/llm/providers.ts

@@ -2,13 +2,14 @@
 import { ChatOpenAI } from '@langchain/openai';
 import { ChatOllama } from '@langchain/ollama';
 import { ChatBedrockConverse } from '@langchain/aws';
-import { ChatAnthropic } from '@langchain/anthropic';
+// import { ChatAnthropic } from '@langchain/anthropic';
 import { ChatMistralAI } from '@langchain/mistralai';
 import { ChatVertexAI } from '@langchain/google-vertexai';
+import { ChatGoogleGenerativeAI } from '@langchain/google-genai';
 import { BedrockChat } from '@langchain/community/chat_models/bedrock/web';
 import type { ChatModelConstructorMap, ProviderOptionsMap, ChatModelMap } from '@/types';
 import { Providers } from '@/common';
-// import { CustomAnthropic } from '@/llm/anthropic/llm';
+import { CustomAnthropic } from '@/llm/anthropic/llm';
 
 export const llmProviders: Partial<ChatModelConstructorMap> = {
   [Providers.OPENAI]: ChatOpenAI,
@@ -17,8 +18,9 @@ export const llmProviders: Partial<ChatModelConstructorMap> = {
   [Providers.BEDROCK_LEGACY]: BedrockChat,
   [Providers.MISTRALAI]: ChatMistralAI,
   [Providers.BEDROCK]: ChatBedrockConverse,
-  // [Providers.ANTHROPIC]: CustomAnthropic,
-  [Providers.ANTHROPIC]: ChatAnthropic,
+  [Providers.ANTHROPIC]: CustomAnthropic,
+  // [Providers.ANTHROPIC]: ChatAnthropic,
+  [Providers.GOOGLE]: ChatGoogleGenerativeAI,
 };
 
 export const manualToolStreamProviders = new Set<Providers | string>([Providers.ANTHROPIC, Providers.BEDROCK, Providers.OLLAMA]);

package/src/llm/text.ts

@@ -1,73 +1,52 @@
 /* eslint-disable no-console */
-import { Readable } from 'stream';
-import type { ReadableOptions } from 'stream';
-export interface TextStreamOptions extends ReadableOptions {
+export interface TextStreamOptions {
   minChunkSize?: number;
   maxChunkSize?: number;
   delay?: number;
+  firstWordChunk?: boolean;
 }
 
 export type ProgressCallback = (chunk: string) => void;
 export type PostChunkCallback = (chunk: string) => void;
 
-export class TextStream extends Readable {
+export class TextStream {
   private text: string;
   private currentIndex: number;
   private minChunkSize: number;
   private maxChunkSize: number;
   private delay: number;
+  private firstWordChunk: boolean;
 
   constructor(text: string, options: TextStreamOptions = {}) {
-    super(options);
     this.text = text;
     this.currentIndex = 0;
-    this.minChunkSize = options.minChunkSize ?? 2;
-    this.maxChunkSize = options.maxChunkSize ?? 4;
-    this.delay = options.delay ?? 20; // Time in milliseconds
-  }
-
-  _read(): void {
-    const { delay, minChunkSize, maxChunkSize } = this;
-
-    if (this.currentIndex < this.text.length) {
-      setTimeout(() => {
-        const remainingChars = this.text.length - this.currentIndex;
-        const chunkSize = Math.min(this.randomInt(minChunkSize, maxChunkSize + 1), remainingChars);
-
-        const chunk = this.text.slice(this.currentIndex, this.currentIndex + chunkSize);
-        this.push(chunk);
-        this.currentIndex += chunkSize;
-      }, delay);
-    } else {
-      this.push(null); // signal end of data
-    }
+    this.minChunkSize = options.minChunkSize ?? 4;
+    this.maxChunkSize = options.maxChunkSize ?? 8;
+    this.delay = options.delay ?? 20;
+    this.firstWordChunk = options.firstWordChunk ?? true;
   }
 
   private randomInt(min: number, max: number): number {
     return Math.floor(Math.random() * (max - min)) + min;
   }
 
-  async processTextStream(progressCallback: ProgressCallback): Promise<void> {
-    const streamPromise = new Promise<void>((resolve, reject) => {
-      this.on('data', (chunk) => {
-        progressCallback(chunk.toString());
-      });
+  private static readonly BOUNDARIES = new Set([' ', '.', ',', '!', '?', ';', ':']);
 
-      this.on('end', () => {
-        resolve();
-      });
+  private findFirstWordBoundary(text: string, minSize: number): number {
+    if (minSize >= text.length) return text.length;
 
-      this.on('error', (err) => {
-        reject(err);
-      });
-    });
+    // Ensure we meet the minimum size first
+    let pos = minSize;
 
-    try {
-      await streamPromise;
-    } catch (err) {
-      console.error('[processTextStream] Error in text stream:', err);
-      // Handle the error appropriately, e.g., return an error message or throw an error
+    // Look forward until we find a boundary
+    while (pos < text.length) {
+      if (TextStream.BOUNDARIES.has(text[pos])) {
+        return pos + 1; // Include the boundary character
+      }
+      pos++;
     }
+
+    return text.length; // If no boundary found, return entire remaining text
   }
 
   async *generateText(progressCallback?: ProgressCallback): AsyncGenerator<string, void, unknown> {
@@ -76,11 +55,17 @@ export class TextStream extends Readable {
     while (this.currentIndex < this.text.length) {
       await new Promise(resolve => setTimeout(resolve, delay));
 
-      const remainingChars = this.text.length - this.currentIndex;
-      const chunkSize = Math.min(this.randomInt(minChunkSize, maxChunkSize + 1), remainingChars);
+      const remainingText = this.text.slice(this.currentIndex);
+      let chunkSize: number;
 
-      const chunk = this.text.slice(this.currentIndex, this.currentIndex + chunkSize);
+      if (this.firstWordChunk) {
+        chunkSize = this.findFirstWordBoundary(remainingText, minChunkSize);
+      } else {
+        const remainingChars = remainingText.length;
+        chunkSize = Math.min(this.randomInt(minChunkSize, maxChunkSize + 1), remainingChars);
+      }
 
+      const chunk = this.text.slice(this.currentIndex, this.currentIndex + chunkSize);
       progressCallback?.(chunk);
 
       yield chunk;

package/src/messages.ts

@@ -33,7 +33,7 @@ User: ${userMessage[1]}
 
 const modifyContent = (messageType: string, content: t.ExtendedMessageContent[]): t.ExtendedMessageContent[] => {
   return content.map(item => {
-    if (item && typeof item === 'object' && 'type' in item && item.type) {
+    if (item && typeof item === 'object' && 'type' in item && item.type != null && item.type) {
       let newType = item.type;
       if (newType.endsWith('_delta')) {
         newType = newType.replace('_delta', '');
@@ -80,9 +80,9 @@ export function formatAnthropicMessage(message: AIMessageChunk): AIMessage {
     formattedContent = message.content.reduce<t.ExtendedMessageContent[]>((acc, item) => {
       if (typeof item === 'object' && item !== null) {
         const extendedItem = item as t.ExtendedMessageContent;
-        if (extendedItem.type === 'text' && extendedItem.text) {
+        if (extendedItem.type === 'text' && extendedItem.text != null && extendedItem.text) {
           acc.push({ type: 'text', text: extendedItem.text });
-        } else if (extendedItem.type === 'tool_use' && extendedItem.id) {
+        } else if (extendedItem.type === 'tool_use' && extendedItem.id != null && extendedItem.id) {
           const toolCall = toolCallMap.get(extendedItem.id);
           if (toolCall) {
             acc.push({
@@ -92,7 +92,7 @@ export function formatAnthropicMessage(message: AIMessageChunk): AIMessage {
               input: toolCall.args as unknown as string
             });
           }
-        } else if ('input' in extendedItem && extendedItem.input) {
+        } else if ('input' in extendedItem && extendedItem.input != null && extendedItem.input) {
           try {
             const parsedInput = JSON.parse(extendedItem.input);
             const toolCall = message.tool_calls?.find(tc => tc.args.input === parsedInput.input);
@@ -210,14 +210,14 @@ export function convertMessagesToContent(messages: BaseMessage[]): t.MessageCont
 }
 
 export function formatAnthropicArtifactContent(messages: BaseMessage[]): void {
-  const lastMessageY = messages[messages.length - 1];
-  if (!(lastMessageY instanceof ToolMessage)) return;
+  const lastMessage = messages[messages.length - 1];
+  if (!(lastMessage instanceof ToolMessage)) return;
 
   // Find the latest AIMessage with tool_calls that this tool message belongs to
   const latestAIParentIndex = findLastIndex(messages,
     msg => (msg instanceof AIMessageChunk &&
           (msg.tool_calls?.length ?? 0) > 0 &&
-          msg.tool_calls?.some(tc => tc.id === lastMessageY.tool_call_id)) ?? false
+          msg.tool_calls?.some(tc => tc.id === lastMessage.tool_call_id)) ?? false
   );
 
   if (latestAIParentIndex === -1) return;
@@ -233,70 +233,19 @@ export function formatAnthropicArtifactContent(messages: BaseMessage[]): void {
 
   if (!hasArtifactContent) return;
 
-  // Now we know we need to process these messages
   const message = messages[latestAIParentIndex] as AIMessageChunk;
   const toolCallIds = message.tool_calls?.map(tc => tc.id) ?? [];
-  const toolMessages: ToolMessage[] = [];
-  let lastToolIndex = latestAIParentIndex;
 
-  // Collect all corresponding ToolMessages
   for (let j = latestAIParentIndex + 1; j < messages.length; j++) {
-    const potentialToolMessage = messages[j];
-    if (potentialToolMessage instanceof ToolMessage &&
-        toolCallIds.includes(potentialToolMessage.tool_call_id)) {
-
-      const hasContentArtifacts = potentialToolMessage.artifact != null &&
-        Array.isArray(potentialToolMessage.artifact?.content) &&
-        Array.isArray(potentialToolMessage.content);
-
-      if (hasContentArtifacts) {
-        potentialToolMessage.content = potentialToolMessage.content.concat(potentialToolMessage.artifact?.content);
-      }
-
-      toolMessages.push(potentialToolMessage);
-      lastToolIndex = Math.max(lastToolIndex, j);
+    const msg = messages[j];
+    if (msg instanceof ToolMessage &&
+        toolCallIds.includes(msg.tool_call_id) &&
+        msg.artifact != null &&
+        Array.isArray(msg.artifact?.content) &&
+        Array.isArray(msg.content)) {
+      msg.content = msg.content.concat(msg.artifact.content);
     }
   }
-
-  // Rest of the function remains the same...
-  if (toolMessages.length > 1) {
-    // Keep only first tool call in original AI message
-    const originalContent = Array.isArray(message.content) ? message.content : [];
-    message.content = [
-      originalContent.find(c => c.type === 'text'),
-      originalContent.find(c => c.type === 'tool_use' && c.id === toolCallIds[0])
-    ].filter(Boolean) as t.ExtendedMessageContent[];
-
-    message.tool_calls = [message.tool_calls![0]];
-    if (message.tool_call_chunks) {
-      message.tool_call_chunks = [message.tool_call_chunks[0]];
-    }
-
-    const newMessages: BaseMessage[] = [];
-    newMessages.push(toolMessages[0]);
-
-    // Create new AI+Tool message pairs for remaining tool calls
-    for (let k = 1; k < toolMessages.length; k++) {
-      const relevantToolCall = message.lc_kwargs.tool_calls[k];
-      const relevantToolChunk = message.lc_kwargs.tool_call_chunks?.[k];
-      const relevantToolUse = originalContent.find(c =>
-        c.type === 'tool_use' && c.id === toolCallIds[k]
-      );
-
-      const newAIMessage = new AIMessage({
-        content: [
-          originalContent.find(c => c.type === 'text'),
-          relevantToolUse
-        ].filter(Boolean),
-        tool_calls: [relevantToolCall],
-        tool_call_chunks: relevantToolChunk != null ? [relevantToolChunk] : undefined,
-        additional_kwargs: { ...message.additional_kwargs }
-      } as AIMessageChunk);
-      newMessages.push(newAIMessage, toolMessages[k]);
-    }
-
-    messages.splice(latestAIParentIndex  + 1, lastToolIndex - latestAIParentIndex , ...newMessages);
-  }
 }
 
 export function formatOpenAIArtifactContent(messages: BaseMessage[]): void {

package/src/scripts/args.ts

@@ -20,7 +20,7 @@ export async function getArgs(): Promise<{ userName: string; location: string; p
       alias: 'p',
       type: 'string',
       description: 'LLM provider',
-      choices: ['openAI', 'anthropic', 'mistralai', 'vertexai', 'bedrock', 'ollama'],
+      choices: ['openAI', 'anthropic', 'mistralai', 'vertexai', 'bedrock', 'ollama', 'google'],
       default: 'openAI'
     })
     .help()

package/src/scripts/code_exec.ts

@@ -171,6 +171,10 @@ process.on('unhandledRejection', (reason, promise) => {
   process.exit(1);
 });
 
+process.on('uncaughtException', (err) => {
+  console.error('Uncaught Exception:', err);
+});
+
 testCodeExecution().catch((err) => {
   console.error(err);
   console.log('Conversation history:');

package/src/scripts/simple.ts

@@ -117,6 +117,10 @@ process.on('unhandledRejection', (reason, promise) => {
   process.exit(1);
 });
 
+process.on('uncaughtException', (err) => {
+  console.error('Uncaught Exception:', err);
+});
+
 testStandardStreaming().catch((err) => {
   console.error(err);
   console.log('Conversation history:');