@illuma-ai/agents 1.1.21 → 1.1.23

package/src/specs/cache.simple.test.js

@@ -1,282 +0,0 @@
-/* eslint-disable no-console */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { config } from 'dotenv';
-config();
-import { Calculator } from '@/tools/Calculator';
-import { HumanMessage, } from '@langchain/core/messages';
-import { ModelEndHandler, ToolEndHandler } from '@/events';
-import { capitalizeFirstLetter } from './spec.utils';
-import { createContentAggregator } from '@/stream';
-import { GraphEvents, Providers } from '@/common';
-import { getLLMConfig } from '@/utils/llmConfig';
-import { getArgs } from '@/scripts/args';
-import { Run } from '@/run';
-/**
- * These tests verify that prompt caching works correctly across multi-turn
- * conversations and that messages are not mutated in place.
- */
-describe('Prompt Caching Integration Tests', () => {
-    jest.setTimeout(120000);
-    const setupTest = () => {
-        const collectedUsage = [];
-        const { contentParts, aggregateContent } = createContentAggregator();
-        const customHandlers = {
-            [GraphEvents.TOOL_END]: new ToolEndHandler(),
-            [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
-            [GraphEvents.ON_RUN_STEP_COMPLETED]: {
-                handle: (event, data) => {
-                    aggregateContent({
-                        event,
-                        data: data,
-                    });
-                },
-            },
-            [GraphEvents.ON_RUN_STEP]: {
-                handle: (event, data) => {
-                    aggregateContent({ event, data: data });
-                },
-            },
-            [GraphEvents.ON_RUN_STEP_DELTA]: {
-                handle: (event, data) => {
-                    aggregateContent({ event, data: data });
-                },
-            },
-            [GraphEvents.ON_MESSAGE_DELTA]: {
-                handle: (event, data) => {
-                    aggregateContent({ event, data: data });
-                },
-            },
-        };
-        return { collectedUsage, contentParts, customHandlers };
-    };
-    const streamConfig = {
-        configurable: { thread_id: 'cache-test-thread' },
-        streamMode: 'values',
-        version: 'v2',
-    };
-    describe('Anthropic Prompt Caching', () => {
-        const provider = Providers.ANTHROPIC;
-        test(`${capitalizeFirstLetter(provider)}: multi-turn conversation with caching should not corrupt messages`, async () => {
-            const { userName, location } = await getArgs();
-            const llmConfig = getLLMConfig(provider);
-            const { collectedUsage, customHandlers } = setupTest();
-            const run = await Run.create({
-                runId: 'cache-test-anthropic',
-                graphConfig: {
-                    type: 'standard',
-                    llmConfig: { ...llmConfig, promptCache: true },
-                    tools: [new Calculator()],
-                    instructions: 'You are a helpful assistant.',
-                    additional_instructions: `User: ${userName}, Location: ${location}`,
-                },
-                returnContent: true,
-                skipCleanup: true,
-                customHandlers,
-            });
-            // Turn 1
-            const turn1Messages = [
-                new HumanMessage('Hello, what is 2+2?'),
-            ];
-            const turn1ContentSnapshot = JSON.stringify(turn1Messages[0].content);
-            const turn1Result = await run.processStream({ messages: turn1Messages }, streamConfig);
-            expect(turn1Result).toBeDefined();
-            // Verify original message was NOT mutated
-            expect(JSON.stringify(turn1Messages[0].content)).toBe(turn1ContentSnapshot);
-            expect(turn1Messages[0].content).not.toContain('cache_control');
-            const turn1RunMessages = run.getRunMessages();
-            expect(turn1RunMessages).toBeDefined();
-            expect(turn1RunMessages.length).toBeGreaterThan(0);
-            // Turn 2 - build on conversation
-            const turn2Messages = [
-                ...turn1Messages,
-                ...turn1RunMessages,
-                new HumanMessage('Now multiply that by 10'),
-            ];
-            const turn2HumanContentSnapshot = JSON.stringify(turn2Messages[turn2Messages.length - 1].content);
-            const run2 = await Run.create({
-                runId: 'cache-test-anthropic-2',
-                graphConfig: {
-                    type: 'standard',
-                    llmConfig: { ...llmConfig, promptCache: true },
-                    tools: [new Calculator()],
-                    instructions: 'You are a helpful assistant.',
-                    additional_instructions: `User: ${userName}, Location: ${location}`,
-                },
-                returnContent: true,
-                skipCleanup: true,
-                customHandlers,
-            });
-            const turn2Result = await run2.processStream({ messages: turn2Messages }, streamConfig);
-            expect(turn2Result).toBeDefined();
-            // Verify messages were NOT mutated
-            expect(JSON.stringify(turn2Messages[turn2Messages.length - 1].content)).toBe(turn2HumanContentSnapshot);
-            // Check that we got cache read tokens (indicating caching worked)
-            console.log(`${provider} Usage:`, collectedUsage);
-            expect(collectedUsage.length).toBeGreaterThan(0);
-            console.log(`${capitalizeFirstLetter(provider)} multi-turn caching test passed - messages not mutated`);
-        });
-        test(`${capitalizeFirstLetter(provider)}: tool calls should work with caching enabled`, async () => {
-            const llmConfig = getLLMConfig(provider);
-            const { customHandlers } = setupTest();
-            const run = await Run.create({
-                runId: 'cache-test-anthropic-tools',
-                graphConfig: {
-                    type: 'standard',
-                    llmConfig: { ...llmConfig, promptCache: true },
-                    tools: [new Calculator()],
-                    instructions: 'You are a math assistant. Use the calculator tool for all calculations.',
-                },
-                returnContent: true,
-                skipCleanup: true,
-                customHandlers,
-            });
-            const messages = [
-                new HumanMessage('Calculate 123 * 456 using the calculator'),
-            ];
-            const result = await run.processStream({ messages }, streamConfig);
-            expect(result).toBeDefined();
-            const runMessages = run.getRunMessages();
-            expect(runMessages).toBeDefined();
-            // Should have used the calculator tool
-            const hasToolUse = runMessages?.some((msg) => msg._getType() === 'ai' &&
-                (msg.tool_calls?.length ?? 0) > 0);
-            expect(hasToolUse).toBe(true);
-            console.log(`${capitalizeFirstLetter(provider)} tool call with caching test passed`);
-        });
-    });
-    describe('Bedrock Prompt Caching', () => {
-        const provider = Providers.BEDROCK;
-        test(`${capitalizeFirstLetter(provider)}: multi-turn conversation with caching should not corrupt messages`, async () => {
-            const { userName, location } = await getArgs();
-            const llmConfig = getLLMConfig(provider);
-            const { collectedUsage, customHandlers } = setupTest();
-            const run = await Run.create({
-                runId: 'cache-test-bedrock',
-                graphConfig: {
-                    type: 'standard',
-                    llmConfig: { ...llmConfig, promptCache: true },
-                    tools: [new Calculator()],
-                    instructions: 'You are a helpful assistant.',
-                    additional_instructions: `User: ${userName}, Location: ${location}`,
-                },
-                returnContent: true,
-                skipCleanup: true,
-                customHandlers,
-            });
-            // Turn 1
-            const turn1Messages = [
-                new HumanMessage('Hello, what is 5+5?'),
-            ];
-            const turn1ContentSnapshot = JSON.stringify(turn1Messages[0].content);
-            const turn1Result = await run.processStream({ messages: turn1Messages }, streamConfig);
-            expect(turn1Result).toBeDefined();
-            // Verify original message was NOT mutated
-            expect(JSON.stringify(turn1Messages[0].content)).toBe(turn1ContentSnapshot);
-            const turn1RunMessages = run.getRunMessages();
-            expect(turn1RunMessages).toBeDefined();
-            expect(turn1RunMessages.length).toBeGreaterThan(0);
-            // Turn 2
-            const turn2Messages = [
-                ...turn1Messages,
-                ...turn1RunMessages,
-                new HumanMessage('Multiply that by 3'),
-            ];
-            const turn2HumanContentSnapshot = JSON.stringify(turn2Messages[turn2Messages.length - 1].content);
-            const run2 = await Run.create({
-                runId: 'cache-test-bedrock-2',
-                graphConfig: {
-                    type: 'standard',
-                    llmConfig: { ...llmConfig, promptCache: true },
-                    tools: [new Calculator()],
-                    instructions: 'You are a helpful assistant.',
-                    additional_instructions: `User: ${userName}, Location: ${location}`,
-                },
-                returnContent: true,
-                skipCleanup: true,
-                customHandlers,
-            });
-            const turn2Result = await run2.processStream({ messages: turn2Messages }, streamConfig);
-            expect(turn2Result).toBeDefined();
-            // Verify messages were NOT mutated
-            expect(JSON.stringify(turn2Messages[turn2Messages.length - 1].content)).toBe(turn2HumanContentSnapshot);
-            console.log(`${provider} Usage:`, collectedUsage);
-            expect(collectedUsage.length).toBeGreaterThan(0);
-            console.log(`${capitalizeFirstLetter(provider)} multi-turn caching test passed - messages not mutated`);
-        });
-        test(`${capitalizeFirstLetter(provider)}: tool calls should work with caching enabled`, async () => {
-            const llmConfig = getLLMConfig(provider);
-            const { customHandlers } = setupTest();
-            const run = await Run.create({
-                runId: 'cache-test-bedrock-tools',
-                graphConfig: {
-                    type: 'standard',
-                    llmConfig: { ...llmConfig, promptCache: true },
-                    tools: [new Calculator()],
-                    instructions: 'You are a math assistant. Use the calculator tool for all calculations.',
-                },
-                returnContent: true,
-                skipCleanup: true,
-                customHandlers,
-            });
-            const messages = [
-                new HumanMessage('Calculate 789 * 123 using the calculator'),
-            ];
-            const result = await run.processStream({ messages }, streamConfig);
-            expect(result).toBeDefined();
-            const runMessages = run.getRunMessages();
-            expect(runMessages).toBeDefined();
-            // Should have used the calculator tool
-            const hasToolUse = runMessages?.some((msg) => msg._getType() === 'ai' &&
-                (msg.tool_calls?.length ?? 0) > 0);
-            expect(hasToolUse).toBe(true);
-            console.log(`${capitalizeFirstLetter(provider)} tool call with caching test passed`);
-        });
-    });
-    describe('Cross-provider message isolation', () => {
-        test('Messages processed by Anthropic should not affect Bedrock processing', async () => {
-            const anthropicConfig = getLLMConfig(Providers.ANTHROPIC);
-            const bedrockConfig = getLLMConfig(Providers.BEDROCK);
-            const { customHandlers: handlers1 } = setupTest();
-            const { customHandlers: handlers2 } = setupTest();
-            // Create a shared message array
-            const sharedMessages = [
-                new HumanMessage('Hello, what is the capital of France?'),
-            ];
-            const originalContent = JSON.stringify(sharedMessages[0].content);
-            // Process with Anthropic first
-            const anthropicRun = await Run.create({
-                runId: 'cross-provider-anthropic',
-                graphConfig: {
-                    type: 'standard',
-                    llmConfig: { ...anthropicConfig, promptCache: true },
-                    instructions: 'You are a helpful assistant.',
-                },
-                returnContent: true,
-                skipCleanup: true,
-                customHandlers: handlers1,
-            });
-            const anthropicResult = await anthropicRun.processStream({ messages: sharedMessages }, streamConfig);
-            expect(anthropicResult).toBeDefined();
-            // Verify message not mutated
-            expect(JSON.stringify(sharedMessages[0].content)).toBe(originalContent);
-            // Now process with Bedrock using the SAME messages
-            const bedrockRun = await Run.create({
-                runId: 'cross-provider-bedrock',
-                graphConfig: {
-                    type: 'standard',
-                    llmConfig: { ...bedrockConfig, promptCache: true },
-                    instructions: 'You are a helpful assistant.',
-                },
-                returnContent: true,
-                skipCleanup: true,
-                customHandlers: handlers2,
-            });
-            const bedrockResult = await bedrockRun.processStream({ messages: sharedMessages }, streamConfig);
-            expect(bedrockResult).toBeDefined();
-            // Verify message STILL not mutated after both providers processed
-            expect(JSON.stringify(sharedMessages[0].content)).toBe(originalContent);
-            console.log('Cross-provider message isolation test passed');
-        });
-    });
-});
-//# sourceMappingURL=cache.simple.test.js.map

package/src/specs/custom-event-await.test.js

@@ -1,148 +0,0 @@
-import { HumanMessage } from '@langchain/core/messages';
-import { ContentTypes, GraphEvents, Providers } from '@/common';
-import { ToolEndHandler, ModelEndHandler } from '@/events';
-import { createContentAggregator } from '@/stream';
-import { Run } from '@/run';
-describe('Custom event handler awaitHandlers behavior', () => {
-    jest.setTimeout(15000);
-    const llmConfig = {
-        provider: Providers.OPENAI,
-        streaming: true,
-        streamUsage: false,
-    };
-    const config = {
-        configurable: {
-            thread_id: 'test-thread',
-        },
-        streamMode: 'values',
-        version: 'v2',
-    };
-    it('should fully aggregate all content before processStream returns', async () => {
-        const longResponse = 'The quick brown fox jumps over the lazy dog and then runs across the field to find shelter from the rain';
-        let aggregateCallCount = 0;
-        const { contentParts, aggregateContent } = createContentAggregator();
-        const wrappedAggregate = (params) => {
-            aggregateCallCount++;
-            aggregateContent(params);
-        };
-        let messageDeltaCount = 0;
-        const customHandlers = {
-            [GraphEvents.TOOL_END]: new ToolEndHandler(),
-            [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
-            [GraphEvents.ON_RUN_STEP_COMPLETED]: {
-                handle: (event, data) => {
-                    wrappedAggregate({
-                        event,
-                        data: data,
-                    });
-                },
-            },
-            [GraphEvents.ON_RUN_STEP]: {
-                handle: (event, data) => {
-                    wrappedAggregate({ event, data: data });
-                },
-            },
-            [GraphEvents.ON_RUN_STEP_DELTA]: {
-                handle: (event, data) => {
-                    wrappedAggregate({ event, data: data });
-                },
-            },
-            [GraphEvents.ON_MESSAGE_DELTA]: {
-                handle: async (event, data) => {
-                    messageDeltaCount++;
-                    wrappedAggregate({ event, data: data });
-                },
-            },
-            [GraphEvents.ON_REASONING_DELTA]: {
-                handle: (event, data) => {
-                    wrappedAggregate({ event, data: data });
-                },
-            },
-        };
-        const run = await Run.create({
-            runId: 'test-await-handlers',
-            graphConfig: {
-                type: 'standard',
-                llmConfig,
-            },
-            returnContent: true,
-            skipCleanup: true,
-            customHandlers,
-        });
-        run.Graph.overrideTestModel([longResponse]);
-        const inputs = { messages: [new HumanMessage('hello')] };
-        const finalContentParts = await run.processStream(inputs, config);
-        expect(finalContentParts).toBeDefined();
-        expect(finalContentParts.length).toBeGreaterThan(0);
-        expect(messageDeltaCount).toBeGreaterThan(0);
-        expect(aggregateCallCount).toBeGreaterThan(0);
-        const typedParts = contentParts;
-        const textParts = typedParts.filter((p) => p !== undefined && p.type === ContentTypes.TEXT);
-        expect(textParts.length).toBeGreaterThan(0);
-        const aggregatedText = textParts
-            .map((p) => p[ContentTypes.TEXT])
-            .join('');
-        expect(aggregatedText).toBe(longResponse);
-    });
-    it('should aggregate content from async handlers before processStream returns', async () => {
-        const response = 'This is a test of async handler aggregation with multiple tokens';
-        const { contentParts, aggregateContent } = createContentAggregator();
-        let asyncHandlerCompletions = 0;
-        const customHandlers = {
-            [GraphEvents.TOOL_END]: new ToolEndHandler(),
-            [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
-            [GraphEvents.ON_RUN_STEP_COMPLETED]: {
-                handle: (event, data) => {
-                    aggregateContent({
-                        event,
-                        data: data,
-                    });
-                },
-            },
-            [GraphEvents.ON_RUN_STEP]: {
-                handle: (event, data) => {
-                    aggregateContent({ event, data: data });
-                },
-            },
-            [GraphEvents.ON_RUN_STEP_DELTA]: {
-                handle: (event, data) => {
-                    aggregateContent({ event, data: data });
-                },
-            },
-            [GraphEvents.ON_MESSAGE_DELTA]: {
-                handle: async (event, data) => {
-                    await new Promise((resolve) => setTimeout(resolve, 5));
-                    aggregateContent({ event, data: data });
-                    asyncHandlerCompletions++;
-                },
-            },
-            [GraphEvents.ON_REASONING_DELTA]: {
-                handle: (event, data) => {
-                    aggregateContent({ event, data: data });
-                },
-            },
-        };
-        const run = await Run.create({
-            runId: 'test-async-handlers',
-            graphConfig: {
-                type: 'standard',
-                llmConfig,
-            },
-            returnContent: true,
-            skipCleanup: true,
-            customHandlers,
-        });
-        run.Graph.overrideTestModel([response]);
-        const inputs = { messages: [new HumanMessage('hello')] };
-        await run.processStream(inputs, config);
-        expect(asyncHandlerCompletions).toBeGreaterThan(0);
-        const typedParts = contentParts;
-        const textParts = typedParts.filter((p) => p !== undefined && p.type === ContentTypes.TEXT);
-        expect(textParts.length).toBeGreaterThan(0);
-        const aggregatedText = textParts
-            .map((p) => p[ContentTypes.TEXT])
-            .join('');
-        expect(aggregatedText).toBe(response);
-    });
-});
-//# sourceMappingURL=custom-event-await.test.js.map

package/src/specs/deepseek.simple.test.js

@@ -1,189 +0,0 @@
-/* eslint-disable no-console */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { config } from 'dotenv';
-config();
-import { Calculator } from '@/tools/Calculator';
-import { HumanMessage, } from '@langchain/core/messages';
-import { ToolEndHandler, ModelEndHandler } from '@/events';
-import { ContentTypes, GraphEvents, Providers } from '@/common';
-import { capitalizeFirstLetter } from './spec.utils';
-import { createContentAggregator } from '@/stream';
-import { getLLMConfig } from '@/utils/llmConfig';
-import { Run } from '@/run';
-const provider = Providers.DEEPSEEK;
-const llmConfig = getLLMConfig(provider);
-const skipTests = process.env.DEEPSEEK_API_KEY == null;
-(skipTests ? describe.skip : describe)(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
-    jest.setTimeout(120000);
-    let run;
-    let collectedUsage;
-    let conversationHistory;
-    let aggregateContent;
-    let _contentParts;
-    const testConfig = {
-        configurable: {
-            thread_id: 'deepseek-test-1',
-        },
-        streamMode: 'values',
-        version: 'v2',
-    };
-    beforeEach(async () => {
-        conversationHistory = [];
-        collectedUsage = [];
-        const { contentParts: cp, aggregateContent: ac } = createContentAggregator();
-        _contentParts = cp;
-        aggregateContent = ac;
-    });
-    const onMessageDeltaSpy = jest.fn();
-    const onReasoningDeltaSpy = jest.fn();
-    const onRunStepSpy = jest.fn();
-    afterAll(() => {
-        onMessageDeltaSpy.mockReset();
-        onReasoningDeltaSpy.mockReset();
-        onRunStepSpy.mockReset();
-    });
-    const setupCustomHandlers = () => ({
-        [GraphEvents.TOOL_END]: new ToolEndHandler(),
-        [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
-        [GraphEvents.ON_RUN_STEP_COMPLETED]: {
-            handle: (event, data) => {
-                aggregateContent({
-                    event,
-                    data: data,
-                });
-            },
-        },
-        [GraphEvents.ON_RUN_STEP]: {
-            handle: (event, data, metadata, graph) => {
-                onRunStepSpy(event, data, metadata, graph);
-                aggregateContent({ event, data: data });
-            },
-        },
-        [GraphEvents.ON_RUN_STEP_DELTA]: {
-            handle: (event, data) => {
-                aggregateContent({ event, data: data });
-            },
-        },
-        [GraphEvents.ON_MESSAGE_DELTA]: {
-            handle: (event, data, metadata, graph) => {
-                onMessageDeltaSpy(event, data, metadata, graph);
-                aggregateContent({ event, data: data });
-            },
-        },
-        [GraphEvents.ON_REASONING_DELTA]: {
-            handle: (event, data) => {
-                onReasoningDeltaSpy(event, data);
-            },
-        },
-        [GraphEvents.TOOL_START]: {
-            handle: (_event, _data, _metadata) => {
-                // Handle tool start
-            },
-        },
-    });
-    test(`${capitalizeFirstLetter(provider)}: should handle tool calls with reasoning_content preservation (streaming)`, async () => {
-        const customHandlers = setupCustomHandlers();
-        run = await Run.create({
-            runId: 'deepseek-tool-test',
-            graphConfig: {
-                type: 'standard',
-                llmConfig,
-                tools: [new Calculator()],
-                instructions: 'You are a helpful math assistant. Use the calculator tool to solve math problems.',
-            },
-            returnContent: true,
-            skipCleanup: true,
-            customHandlers,
-        });
-        const userMessage = 'What is 127 * 453?';
-        conversationHistory.push(new HumanMessage(userMessage));
-        const inputs = {
-            messages: conversationHistory,
-        };
-        console.log('Starting DeepSeek streaming tool call test...');
-        const finalContentParts = await run.processStream(inputs, testConfig);
-        expect(finalContentParts).toBeDefined();
-        console.log('Final content parts:', finalContentParts);
-        const finalMessages = run.getRunMessages();
-        expect(finalMessages).toBeDefined();
-        expect(finalMessages?.length).toBeGreaterThan(0);
-        const hasToolCall = finalMessages?.some((msg) => msg.getType() === 'ai' &&
-            Array.isArray(msg.tool_calls) &&
-            msg.tool_calls.length > 0);
-        expect(hasToolCall).toBe(true);
-        const hasToolResult = finalMessages?.some((msg) => msg.getType() === 'tool');
-        expect(hasToolResult).toBe(true);
-        console.log('Streaming tool call test passed - reasoning_content was preserved');
-        console.log('Final response:', finalMessages?.[finalMessages.length - 1]?.content);
-    });
-    test(`${capitalizeFirstLetter(provider)}: should handle tool calls with disableStreaming`, async () => {
-        const customHandlers = setupCustomHandlers();
-        const nonStreamingLlmConfig = {
-            ...llmConfig,
-            disableStreaming: true,
-        };
-        run = await Run.create({
-            runId: 'deepseek-non-streaming-tool-test',
-            graphConfig: {
-                type: 'standard',
-                llmConfig: nonStreamingLlmConfig,
-                tools: [new Calculator()],
-                instructions: 'You are a helpful math assistant. Use the calculator tool to solve math problems.',
-            },
-            returnContent: true,
-            skipCleanup: true,
-            customHandlers,
-        });
-        const userMessage = 'What is 99 * 77?';
-        conversationHistory.push(new HumanMessage(userMessage));
-        const inputs = {
-            messages: conversationHistory,
-        };
-        console.log('Starting DeepSeek non-streaming tool call test...');
-        const finalContentParts = await run.processStream(inputs, testConfig);
-        expect(finalContentParts).toBeDefined();
-        console.log('Final content parts (non-streaming):', finalContentParts);
-        const finalMessages = run.getRunMessages();
-        expect(finalMessages).toBeDefined();
-        expect(finalMessages?.length).toBeGreaterThan(0);
-        const hasToolCall = finalMessages?.some((msg) => msg.getType() === 'ai' &&
-            Array.isArray(msg.tool_calls) &&
-            msg.tool_calls.length > 0);
-        expect(hasToolCall).toBe(true);
-        const hasToolResult = finalMessages?.some((msg) => msg.getType() === 'tool');
-        expect(hasToolResult).toBe(true);
-        console.log('Non-streaming tool call test passed');
-        console.log('Final response:', finalMessages?.[finalMessages.length - 1]?.content);
-    });
-    test(`${capitalizeFirstLetter(provider)}: should process simple message without tools`, async () => {
-        const customHandlers = setupCustomHandlers();
-        run = await Run.create({
-            runId: 'deepseek-simple-test',
-            graphConfig: {
-                type: 'standard',
-                llmConfig,
-                tools: [],
-                instructions: 'You are a friendly AI assistant.',
-            },
-            returnContent: true,
-            skipCleanup: true,
-            customHandlers,
-        });
-        const userMessage = 'Hello! How are you today?';
-        conversationHistory.push(new HumanMessage(userMessage));
-        const inputs = {
-            messages: conversationHistory,
-        };
-        const finalContentParts = await run.processStream(inputs, testConfig);
-        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();
-        console.log(`${capitalizeFirstLetter(provider)} response:`, finalMessages?.[finalMessages.length - 1]?.content);
-    });
-});
-//# sourceMappingURL=deepseek.simple.test.js.map