@librechat/agents 2.0.4 → 2.1.0

package/src/llm/fake.ts

@@ -0,0 +1,83 @@
+import type { BaseMessage } from '@langchain/core/messages';
+import type { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import { FakeListChatModel } from '@langchain/core/utils/testing';
+
+type SplitStrategy = {
+  type: 'regex' | 'fixed';
+  value: RegExp | number;
+};
+
+export class FakeChatModel extends FakeListChatModel {
+  private splitStrategy: SplitStrategy;
+
+  constructor({
+    responses,
+    sleep,
+    emitCustomEvent,
+    splitStrategy = { type: 'regex', value: /(?<=\s+)|(?=\s+)/ }
+  }: {
+    responses: string[];
+    sleep?: number;
+    emitCustomEvent?: boolean;
+    splitStrategy?: SplitStrategy;
+  }) {
+    super({ responses, sleep, emitCustomEvent });
+    this.splitStrategy = splitStrategy;
+  }
+
+  private splitText(text: string): string[] {
+    if (this.splitStrategy.type === 'regex') {
+      return text.split(this.splitStrategy.value as RegExp);
+    } else {
+      const chunkSize = this.splitStrategy.value as number;
+      const chunks: string[] = [];
+      for (let i = 0; i < text.length; i += chunkSize) {
+        chunks.push(text.slice(i, i + chunkSize));
+      }
+      return chunks;
+    }
+  }
+
+  async *_streamResponseChunks(
+    _messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatGenerationChunk> {
+    const response = this._currentResponse();
+    this._incrementResponse();
+
+    if (this.emitCustomEvent) {
+      await runManager?.handleCustomEvent('some_test_event', {
+        someval: true,
+      });
+    }
+
+    const chunks = this.splitText(response);
+
+    for await (const chunk of chunks) {
+      await this._sleepIfRequested();
+
+      if (options.thrownErrorString != null && options.thrownErrorString) {
+        throw new Error(options.thrownErrorString);
+      }
+
+      const responseChunk = this._createResponseChunk(chunk);
+      yield responseChunk;
+      void runManager?.handleLLMNewToken(chunk);
+    }
+  }
+}
+
+export function createFakeStreamingLLM(
+  responses: string[],
+  sleep?: number,
+  splitStrategy?: SplitStrategy
+): FakeChatModel {
+  return new FakeChatModel({
+    sleep,
+    responses,
+    emitCustomEvent: true,
+    splitStrategy,
+  });
+}

package/src/llm/providers.ts

@@ -1,25 +1,27 @@
 // src/llm/providers.ts
 import { ChatOllama } from '@langchain/ollama';
+import { ChatDeepSeek } from '@langchain/deepseek';
+import { ChatMistralAI } from '@langchain/mistralai';
 import { ChatBedrockConverse } from '@langchain/aws';
 // import { ChatAnthropic } from '@langchain/anthropic';
-import { ChatMistralAI } from '@langchain/mistralai';
 import { ChatVertexAI } from '@langchain/google-vertexai';
 import { ChatOpenAI, AzureChatOpenAI } from '@langchain/openai';
 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 { Providers } from '@/common';
 
 export const llmProviders: Partial<ChatModelConstructorMap> = {
   [Providers.OPENAI]: ChatOpenAI,
-  [Providers.AZURE]: AzureChatOpenAI,
   [Providers.OLLAMA]: ChatOllama,
+  [Providers.AZURE]: AzureChatOpenAI,
   [Providers.VERTEXAI]: ChatVertexAI,
-  [Providers.BEDROCK_LEGACY]: BedrockChat,
+  [Providers.DEEPSEEK]: ChatDeepSeek,
   [Providers.MISTRALAI]: ChatMistralAI,
-  [Providers.BEDROCK]: ChatBedrockConverse,
   [Providers.ANTHROPIC]: CustomAnthropic,
+  [Providers.BEDROCK_LEGACY]: BedrockChat,
+  [Providers.BEDROCK]: ChatBedrockConverse,
   // [Providers.ANTHROPIC]: ChatAnthropic,
   [Providers.GOOGLE]: ChatGoogleGenerativeAI,
 };

package/src/scripts/simple.ts

@@ -12,10 +12,12 @@ import { GraphEvents } from '@/common';
 import { Run } from '@/run';
 
 const conversationHistory: BaseMessage[] = [];
+let _contentParts: t.MessageContentComplex[] = [];
 
 async function testStandardStreaming(): Promise<void> {
   const { userName, location, provider, currentDate } = await getArgs();
   const { contentParts, aggregateContent } = createContentAggregator();
+  _contentParts = contentParts as t.MessageContentComplex[];
   const customHandlers = {
     [GraphEvents.TOOL_END]: new ToolEndHandler(),
     [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
@@ -48,6 +50,13 @@ async function testStandardStreaming(): Promise<void> {
         aggregateContent({ event, data: data as t.MessageDeltaEvent });
       }
     },
+    [GraphEvents.ON_REASONING_DELTA]: {
+      handle: (event: GraphEvents.ON_REASONING_DELTA, data: t.StreamEventData): void => {
+        console.log('====== ON_REASONING_DELTA ======');
+        console.dir(data, { depth: null });
+        aggregateContent({ event, data: data as t.ReasoningDeltaEvent });
+      }
+    },
     [GraphEvents.TOOL_START]: {
       handle: (_event: string, data: t.StreamEventData, metadata?: Record<string, unknown>): void => {
         console.log('====== TOOL_START ======');
@@ -63,7 +72,7 @@ async function testStandardStreaming(): Promise<void> {
     graphConfig: {
       type: 'standard',
       llmConfig,
-      tools: [new TavilySearchResults()],
+      // tools: [new TavilySearchResults()],
       instructions: 'You are a friendly AI assistant. Always address the user by their name.',
       additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
     },
@@ -81,7 +90,7 @@ async function testStandardStreaming(): Promise<void> {
 
   console.log('Test 1: Simple message test');
 
-  const userMessage = `hi tell me a long story`;
+  const userMessage = `hi`;
 
   conversationHistory.push(new HumanMessage(userMessage));
 
@@ -97,23 +106,26 @@ async function testStandardStreaming(): Promise<void> {
   // console.dir(finalContentParts, { depth: null });
   console.log('\n\n====================\n\n');
   console.dir(contentParts, { depth: null });
-  const { handleLLMEnd, collected } = createMetadataAggregator();
-  const titleResult = await run.generateTitle({
-    inputText: userMessage,
-    contentParts,
-    chainOptions: {
-      callbacks: [{
-        handleLLMEnd,
-      }],
-    },
-  });
-  console.log('Generated Title:', titleResult);
-  console.log('Collected metadata:', collected);
+  // const { handleLLMEnd, collected } = createMetadataAggregator();
+  // const titleResult = await run.generateTitle({
+  //   inputText: userMessage,
+  //   contentParts,
+  //   chainOptions: {
+  //     callbacks: [{
+  //       handleLLMEnd,
+  //     }],
+  //   },
+  // });
+  // console.log('Generated Title:', titleResult);
+  // console.log('Collected metadata:', collected);
 }
 
 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);
 });
 
@@ -125,5 +137,7 @@ testStandardStreaming().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);
 });

package/src/specs/anthropic.simple.test.ts

@@ -0,0 +1,204 @@
+/* eslint-disable no-console */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// src/scripts/cli.test.ts
+import { config } from 'dotenv';
+config();
+import { Calculator } from '@langchain/community/tools/calculator';
+import { HumanMessage, BaseMessage, UsageMetadata } from '@langchain/core/messages';
+import type { StandardGraph } from '@/graphs';
+import type * as t from '@/types';
+import { ToolEndHandler, ModelEndHandler, createMetadataAggregator } from '@/events';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ContentTypes, GraphEvents, Providers } from '@/common';
+import { capitalizeFirstLetter } from './spec.utils';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+
+const provider = Providers.ANTHROPIC;
+describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
+  jest.setTimeout(30000);
+  let run: Run<t.IState>;
+  let runningHistory: BaseMessage[];
+  let collectedUsage: UsageMetadata[];
+  let conversationHistory: BaseMessage[];
+  let aggregateContent: t.ContentAggregator;
+  let contentParts: t.MessageContentComplex[];
+
+  const config = {
+    configurable: {
+      thread_id: 'conversation-num-1',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  beforeEach(async () => {
+    conversationHistory = [];
+    collectedUsage = [];
+    const { contentParts: cp, aggregateContent: ac } = createContentAggregator();
+    contentParts = cp as t.MessageContentComplex[];
+    aggregateContent = ac;
+  });
+
+  const onMessageDeltaSpy = jest.fn();
+  const onRunStepSpy = jest.fn();
+
+  afterAll(() => {
+    onMessageDeltaSpy.mockReset();
+    onRunStepSpy.mockReset();
+  });
+
+  const setupCustomHandlers = (): Record<string | GraphEvents, t.EventHandler> => ({
+    [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 => {
+        aggregateContent({ event, data: data as unknown as { result: t.ToolEndEvent; } });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (event: GraphEvents.ON_RUN_STEP, data: t.StreamEventData, metadata, graph): void => {
+        onRunStepSpy(event, data, metadata, graph);
+        aggregateContent({ event, data: data as t.RunStep });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (event: GraphEvents.ON_RUN_STEP_DELTA, data: t.StreamEventData): void => {
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+      }
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (event: GraphEvents.ON_MESSAGE_DELTA, data: t.StreamEventData, metadata, graph): void => {
+        onMessageDeltaSpy(event, data, metadata, graph);
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+      }
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (_event: string, _data: t.StreamEventData, _metadata?: Record<string, unknown>): void => {
+        // Handle tool start
+      }
+    },
+  });
+
+  test(`${capitalizeFirstLetter(provider)}: should process a simple message, generate title`, async () => {
+    const { userName, location } = await getArgs();
+    const llmConfig = getLLMConfig(provider);
+    const customHandlers = setupCustomHandlers();
+
+    run = await Run.create<t.IState>({
+      runId: 'test-run-id',
+      graphConfig: {
+        type: 'standard',
+        llmConfig,
+        tools: [new Calculator()],
+        instructions: 'You are a friendly AI assistant. Always address the user by their name.',
+        additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
+      },
+      returnContent: true,
+      customHandlers,
+    });
+
+    const userMessage = 'hi';
+    conversationHistory.push(new HumanMessage(userMessage));
+
+    const inputs = {
+      messages: conversationHistory,
+    };
+
+    const finalContentParts = await run.processStream(inputs, config);
+    expect(finalContentParts).toBeDefined();
+    const allTextParts = finalContentParts?.every((part) => part.type === ContentTypes.TEXT);
+    expect(allTextParts).toBe(true);
+    expect(collectedUsage.length).toBeGreaterThan(0);
+    expect(collectedUsage[0].input_tokens).toBeGreaterThan(0);
+    expect(collectedUsage[0].output_tokens).toBeGreaterThan(0);
+
+    const finalMessages = run.getRunMessages();
+    expect(finalMessages).toBeDefined();
+    conversationHistory.push(...finalMessages ?? []);
+    expect(conversationHistory.length).toBeGreaterThan(1);
+    runningHistory = conversationHistory.slice();
+
+    expect(onMessageDeltaSpy).toHaveBeenCalled();
+    expect(onMessageDeltaSpy.mock.calls.length).toBeGreaterThan(1);
+    expect((onMessageDeltaSpy.mock.calls[0][3] as StandardGraph).provider).toBeDefined();
+
+    expect(onRunStepSpy).toHaveBeenCalled();
+    expect(onRunStepSpy.mock.calls.length).toBeGreaterThan(0);
+    expect((onRunStepSpy.mock.calls[0][3] as StandardGraph).provider).toBeDefined();
+
+    const { handleLLMEnd, collected } = createMetadataAggregator();
+    const titleResult = await run.generateTitle({
+      inputText: userMessage,
+      contentParts,
+      chainOptions: {
+        callbacks: [{
+          handleLLMEnd,
+        }],
+      },
+    });
+
+    expect(titleResult).toBeDefined();
+    expect(titleResult.title).toBeDefined();
+    expect(titleResult.language).toBeDefined();
+    expect(collected).toBeDefined();
+  });
+
+  test(`${capitalizeFirstLetter(provider)}: should follow-up`, async () => {
+    console.log('Previous conversation length:', runningHistory.length);
+    console.log('Last message:', runningHistory[runningHistory.length - 1].content);
+    const { userName, location } = await getArgs();
+    const llmConfig = getLLMConfig(provider);
+    const customHandlers = setupCustomHandlers();
+
+    run = await Run.create<t.IState>({
+      runId: 'test-run-id',
+      graphConfig: {
+        type: 'standard',
+        llmConfig,
+        tools: [new Calculator()],
+        instructions: 'You are a friendly AI assistant. Always address the user by their name.',
+        additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
+      },
+      returnContent: true,
+      customHandlers,
+    });
+
+    conversationHistory = runningHistory.slice();
+    conversationHistory.push(new HumanMessage('how are you?'));
+
+    const inputs = {
+      messages: conversationHistory,
+    };
+
+    const finalContentParts = await run.processStream(inputs, config);
+    expect(finalContentParts).toBeDefined();
+    const allTextParts = finalContentParts?.every((part) => part.type === ContentTypes.TEXT);
+    expect(allTextParts).toBe(true);
+    expect(collectedUsage.length).toBeGreaterThan(0);
+    expect(collectedUsage[0].input_tokens).toBeGreaterThan(0);
+    expect(collectedUsage[0].output_tokens).toBeGreaterThan(0);
+
+    const finalMessages = run.getRunMessages();
+    expect(finalMessages).toBeDefined();
+    expect(finalMessages?.length).toBeGreaterThan(0);
+    console.log(`${capitalizeFirstLetter(provider)} follow-up message:`, finalMessages?.[finalMessages.length - 1]?.content);
+
+    expect(onMessageDeltaSpy).toHaveBeenCalled();
+    expect(onMessageDeltaSpy.mock.calls.length).toBeGreaterThan(1);
+
+    expect(onRunStepSpy).toHaveBeenCalled();
+    expect(onRunStepSpy.mock.calls.length).toBeGreaterThan(0);
+  });
+
+  test('should handle errors appropriately', async () => {
+    // Test error scenarios
+    await expect(async () => {
+      await run.processStream({
+        messages: [],
+      }, {} as any);
+    }).rejects.toThrow();
+  });
+});

package/src/specs/openai.simple.test.ts

@@ -0,0 +1,204 @@
+/* eslint-disable no-console */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// src/scripts/cli.test.ts
+import { config } from 'dotenv';
+config();
+import { Calculator } from '@langchain/community/tools/calculator';
+import { HumanMessage, BaseMessage, UsageMetadata } from '@langchain/core/messages';
+import type { StandardGraph } from '@/graphs';
+import type * as t from '@/types';
+import { ToolEndHandler, ModelEndHandler, createMetadataAggregator } from '@/events';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ContentTypes, GraphEvents, Providers } from '@/common';
+import { capitalizeFirstLetter } from './spec.utils';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+
+const provider = Providers.OPENAI;
+describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
+  jest.setTimeout(30000);
+  let run: Run<t.IState>;
+  let runningHistory: BaseMessage[];
+  let collectedUsage: UsageMetadata[];
+  let conversationHistory: BaseMessage[];
+  let aggregateContent: t.ContentAggregator;
+  let contentParts: t.MessageContentComplex[];
+
+  const config = {
+    configurable: {
+      thread_id: 'conversation-num-1',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  beforeEach(async () => {
+    conversationHistory = [];
+    collectedUsage = [];
+    const { contentParts: cp, aggregateContent: ac } = createContentAggregator();
+    contentParts = cp as t.MessageContentComplex[];
+    aggregateContent = ac;
+  });
+
+  const onMessageDeltaSpy = jest.fn();
+  const onRunStepSpy = jest.fn();
+
+  afterAll(() => {
+    onMessageDeltaSpy.mockReset();
+    onRunStepSpy.mockReset();
+  });
+
+  const setupCustomHandlers = (): Record<string | GraphEvents, t.EventHandler> => ({
+    [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 => {
+        aggregateContent({ event, data: data as unknown as { result: t.ToolEndEvent; } });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (event: GraphEvents.ON_RUN_STEP, data: t.StreamEventData, metadata, graph): void => {
+        onRunStepSpy(event, data, metadata, graph);
+        aggregateContent({ event, data: data as t.RunStep });
+      }
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (event: GraphEvents.ON_RUN_STEP_DELTA, data: t.StreamEventData): void => {
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+      }
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (event: GraphEvents.ON_MESSAGE_DELTA, data: t.StreamEventData, metadata, graph): void => {
+        onMessageDeltaSpy(event, data, metadata, graph);
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+      }
+    },
+    [GraphEvents.TOOL_START]: {
+      handle: (_event: string, _data: t.StreamEventData, _metadata?: Record<string, unknown>): void => {
+        // Handle tool start
+      }
+    },
+  });
+
+  test(`${capitalizeFirstLetter(provider)}: should process a simple message, generate title`, async () => {
+    const { userName, location } = await getArgs();
+    const llmConfig = getLLMConfig(provider);
+    const customHandlers = setupCustomHandlers();
+
+    run = await Run.create<t.IState>({
+      runId: 'test-run-id',
+      graphConfig: {
+        type: 'standard',
+        llmConfig,
+        tools: [new Calculator()],
+        instructions: 'You are a friendly AI assistant. Always address the user by their name.',
+        additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
+      },
+      returnContent: true,
+      customHandlers,
+    });
+
+    const userMessage = 'hi';
+    conversationHistory.push(new HumanMessage(userMessage));
+
+    const inputs = {
+      messages: conversationHistory,
+    };
+
+    const finalContentParts = await run.processStream(inputs, config);
+    expect(finalContentParts).toBeDefined();
+    const allTextParts = finalContentParts?.every((part) => part.type === ContentTypes.TEXT);
+    expect(allTextParts).toBe(true);
+    expect(collectedUsage.length).toBeGreaterThan(0);
+    expect(collectedUsage[0].input_tokens).toBeGreaterThan(0);
+    expect(collectedUsage[0].output_tokens).toBeGreaterThan(0);
+
+    const finalMessages = run.getRunMessages();
+    expect(finalMessages).toBeDefined();
+    conversationHistory.push(...finalMessages ?? []);
+    expect(conversationHistory.length).toBeGreaterThan(1);
+    runningHistory = conversationHistory.slice();
+
+    expect(onMessageDeltaSpy).toHaveBeenCalled();
+    expect(onMessageDeltaSpy.mock.calls.length).toBeGreaterThan(1);
+    expect((onMessageDeltaSpy.mock.calls[0][3] as StandardGraph).provider).toBeDefined();
+
+    expect(onRunStepSpy).toHaveBeenCalled();
+    expect(onRunStepSpy.mock.calls.length).toBeGreaterThan(0);
+    expect((onRunStepSpy.mock.calls[0][3] as StandardGraph).provider).toBeDefined();
+
+    const { handleLLMEnd, collected } = createMetadataAggregator();
+    const titleResult = await run.generateTitle({
+      inputText: userMessage,
+      contentParts,
+      chainOptions: {
+        callbacks: [{
+          handleLLMEnd,
+        }],
+      },
+    });
+
+    expect(titleResult).toBeDefined();
+    expect(titleResult.title).toBeDefined();
+    expect(titleResult.language).toBeDefined();
+    expect(collected).toBeDefined();
+  });
+
+  test(`${capitalizeFirstLetter(provider)}: should follow-up`, async () => {
+    console.log('Previous conversation length:', runningHistory.length);
+    console.log('Last message:', runningHistory[runningHistory.length - 1].content);
+    const { userName, location } = await getArgs();
+    const llmConfig = getLLMConfig(provider);
+    const customHandlers = setupCustomHandlers();
+
+    run = await Run.create<t.IState>({
+      runId: 'test-run-id',
+      graphConfig: {
+        type: 'standard',
+        llmConfig,
+        tools: [new Calculator()],
+        instructions: 'You are a friendly AI assistant. Always address the user by their name.',
+        additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
+      },
+      returnContent: true,
+      customHandlers,
+    });
+
+    conversationHistory = runningHistory.slice();
+    conversationHistory.push(new HumanMessage('how are you?'));
+
+    const inputs = {
+      messages: conversationHistory,
+    };
+
+    const finalContentParts = await run.processStream(inputs, config);
+    expect(finalContentParts).toBeDefined();
+    const allTextParts = finalContentParts?.every((part) => part.type === ContentTypes.TEXT);
+    expect(allTextParts).toBe(true);
+    expect(collectedUsage.length).toBeGreaterThan(0);
+    expect(collectedUsage[0].input_tokens).toBeGreaterThan(0);
+    expect(collectedUsage[0].output_tokens).toBeGreaterThan(0);
+
+    const finalMessages = run.getRunMessages();
+    expect(finalMessages).toBeDefined();
+    expect(finalMessages?.length).toBeGreaterThan(0);
+    console.log(`${capitalizeFirstLetter(provider)} follow-up message:`, finalMessages?.[finalMessages.length - 1]?.content);
+
+    expect(onMessageDeltaSpy).toHaveBeenCalled();
+    expect(onMessageDeltaSpy.mock.calls.length).toBeGreaterThan(1);
+
+    expect(onRunStepSpy).toHaveBeenCalled();
+    expect(onRunStepSpy.mock.calls.length).toBeGreaterThan(0);
+  });
+
+  test('should handle errors appropriately', async () => {
+    // Test error scenarios
+    await expect(async () => {
+      await run.processStream({
+        messages: [],
+      }, {} as any);
+    }).rejects.toThrow();
+  });
+});