@illuma-ai/agents 1.1.20 → 1.1.22

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

@@ -1,233 +0,0 @@
-/* eslint-disable no-console */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// src/scripts/cli.test.ts
-import { config } from 'dotenv';
-config();
-import { Calculator } from '@/tools/Calculator';
-import { HumanMessage, } from '@langchain/core/messages';
-import { ToolEndHandler, ModelEndHandler, createMetadataAggregator, } from '@/events';
-import { ContentTypes, GraphEvents, Providers, TitleMethod } from '@/common';
-import { capitalizeFirstLetter } from './spec.utils';
-import { createContentAggregator } from '@/stream';
-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;
-    let runningHistory;
-    let collectedUsage;
-    let conversationHistory;
-    let aggregateContent;
-    let contentParts;
-    const config = {
-        configurable: {
-            thread_id: 'conversation-num-1',
-        },
-        streamMode: 'values',
-        version: 'v2',
-    };
-    beforeEach(async () => {
-        conversationHistory = [];
-        collectedUsage = [];
-        const { contentParts: cp, aggregateContent: ac } = createContentAggregator();
-        contentParts = cp;
-        aggregateContent = ac;
-    });
-    const onMessageDeltaSpy = jest.fn();
-    const onRunStepSpy = jest.fn();
-    afterAll(() => {
-        onMessageDeltaSpy.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.TOOL_START]: {
-            handle: (_event, _data, _metadata) => {
-                // 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({
-            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,
-            skipCleanup: 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]).toBeDefined(); // Graph exists
-        expect(onRunStepSpy).toHaveBeenCalled();
-        expect(onRunStepSpy.mock.calls.length).toBeGreaterThan(0);
-        expect(onRunStepSpy.mock.calls[0][3]).toBeDefined(); // Graph exists
-        const { handleLLMEnd, collected } = createMetadataAggregator();
-        const titleResult = await run.generateTitle({
-            provider,
-            inputText: userMessage,
-            titleMethod: TitleMethod.STRUCTURED,
-            contentParts,
-            chainOptions: {
-                callbacks: [
-                    {
-                        handleLLMEnd,
-                    },
-                ],
-            },
-        });
-        expect(titleResult).toBeDefined();
-        expect(titleResult.title).toBeDefined();
-        expect(titleResult.language).toBeDefined();
-        expect(collected).toBeDefined();
-    });
-    test(`${capitalizeFirstLetter(provider)}: should generate title using completion method`, async () => {
-        const { userName, location } = await getArgs();
-        const llmConfig = getLLMConfig(provider);
-        const customHandlers = setupCustomHandlers();
-        run = await Run.create({
-            runId: 'test-run-id-completion',
-            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,
-            skipCleanup: true,
-            customHandlers,
-        });
-        const userMessage = 'What is the weather like today?';
-        conversationHistory = [];
-        conversationHistory.push(new HumanMessage(userMessage));
-        const inputs = {
-            messages: conversationHistory,
-        };
-        const finalContentParts = await run.processStream(inputs, config);
-        expect(finalContentParts).toBeDefined();
-        const { handleLLMEnd, collected } = createMetadataAggregator();
-        const titleResult = await run.generateTitle({
-            provider,
-            inputText: userMessage,
-            titleMethod: TitleMethod.COMPLETION, // Using completion method
-            contentParts,
-            chainOptions: {
-                callbacks: [
-                    {
-                        handleLLMEnd,
-                    },
-                ],
-            },
-        });
-        expect(titleResult).toBeDefined();
-        expect(titleResult.title).toBeDefined();
-        expect(titleResult.title).not.toBe('');
-        // Completion method doesn't return language
-        expect(titleResult.language).toBeUndefined();
-        expect(collected).toBeDefined();
-        console.log(`Completion method generated title: "${titleResult.title}"`);
-    });
-    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({
-            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,
-            skipCleanup: 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: [],
-            }, {});
-        }).rejects.toThrow();
-    });
-});
-//# sourceMappingURL=openai.simple.test.js.map

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

@@ -1,202 +0,0 @@
-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, TitleMethod } from '@/common';
-import { capitalizeFirstLetter } from './spec.utils';
-import { createContentAggregator } from '@/stream';
-import { getLLMConfig } from '@/utils/llmConfig';
-import { getArgs } from '@/scripts/args';
-import { Run } from '@/run';
-// Auto-skip if OpenRouter env is missing
-const hasOpenRouter = (process.env.OPENROUTER_API_KEY ?? '').trim() !== '';
-const describeIf = hasOpenRouter ? describe : describe.skip;
-const provider = Providers.OPENROUTER;
-describeIf(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
-    jest.setTimeout(60000);
-    let run;
-    let collectedUsage;
-    let conversationHistory;
-    let contentParts;
-    const configV2 = {
-        configurable: { thread_id: 'or-convo-1' },
-        streamMode: 'values',
-        version: 'v2',
-    };
-    const baseLLMConfig = getLLMConfig(provider);
-    beforeEach(async () => {
-        conversationHistory = [];
-        collectedUsage = [];
-        const { contentParts: cp } = createContentAggregator();
-        contentParts = cp;
-    });
-    const onMessageDeltaSpy = jest.fn();
-    const onRunStepSpy = jest.fn();
-    afterAll(() => {
-        onMessageDeltaSpy.mockReset();
-        onRunStepSpy.mockReset();
-    });
-    const setupCustomHandlers = () => ({
-        [GraphEvents.TOOL_END]: new ToolEndHandler(),
-        [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
-    });
-    /**
-     * Helper: run a reasoning test against a specific model with the given reasoning config.
-     * Asserts that reasoning tokens are reported and content is produced.
-     */
-    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-    async function runReasoningTest(opts) {
-        const { reasoning: _baseReasoning, ...baseWithoutReasoning } = baseLLMConfig;
-        const llmConfig = {
-            ...baseWithoutReasoning,
-            model: opts.model,
-            ...(opts.reasoning != null ? { reasoning: opts.reasoning } : {}),
-        };
-        const customHandlers = setupCustomHandlers();
-        run = await Run.create({
-            runId: opts.runId,
-            graphConfig: {
-                type: 'standard',
-                llmConfig,
-                instructions: 'You are a helpful AI assistant. Think step by step.',
-            },
-            returnContent: true,
-            skipCleanup: true,
-            customHandlers,
-        });
-        const userMessage = 'What is 15 * 37 + 128 / 4? Show your work.';
-        conversationHistory.push(new HumanMessage(userMessage));
-        const finalContentParts = await run.processStream({ messages: conversationHistory }, { ...configV2, configurable: { thread_id: opts.threadId } });
-        expect(finalContentParts).toBeDefined();
-        expect(finalContentParts?.length).toBeGreaterThan(0);
-        // Verify usage metadata was collected
-        expect(collectedUsage.length).toBeGreaterThan(0);
-        const usage = collectedUsage[0];
-        expect(usage.input_tokens).toBeGreaterThan(0);
-        expect(usage.output_tokens).toBeGreaterThan(0);
-        // Verify reasoning tokens are reported in output_token_details
-        const reasoningTokens = usage.output_token_details
-            ?.reasoning ?? 0;
-        expect(reasoningTokens).toBeGreaterThan(0);
-        // Verify the final message has content
-        const finalMessages = run.getRunMessages();
-        expect(finalMessages).toBeDefined();
-        expect(finalMessages?.length).toBeGreaterThan(0);
-        const assistantMsg = finalMessages?.[0];
-        expect(typeof assistantMsg?.content).toBe('string');
-        expect((assistantMsg?.content).length).toBeGreaterThan(0);
-        return { usage, reasoningTokens, finalMessages };
-    }
-    test(`${capitalizeFirstLetter(provider)}: simple stream + title`, async () => {
-        const { userName, location } = await getArgs();
-        const customHandlers = setupCustomHandlers();
-        run = await Run.create({
-            runId: 'or-run-1',
-            graphConfig: {
-                type: 'standard',
-                llmConfig: baseLLMConfig,
-                tools: [new Calculator()],
-                instructions: 'You are a friendly AI assistant.',
-                additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
-            },
-            returnContent: true,
-            skipCleanup: true,
-            customHandlers,
-        });
-        const userMessage = 'hi';
-        conversationHistory.push(new HumanMessage(userMessage));
-        const finalContentParts = await run.processStream({ messages: conversationHistory }, configV2);
-        expect(finalContentParts).toBeDefined();
-        const allTextParts = finalContentParts?.every((part) => part.type === ContentTypes.TEXT);
-        expect(allTextParts).toBe(true);
-        expect((collectedUsage[0]?.input_tokens ?? 0) +
-            (collectedUsage[0]?.output_tokens ?? 0)).toBeGreaterThan(0);
-        const finalMessages = run.getRunMessages();
-        expect(finalMessages).toBeDefined();
-        conversationHistory.push(...(finalMessages ?? []));
-        const titleRes = await run.generateTitle({
-            provider,
-            inputText: userMessage,
-            titleMethod: TitleMethod.COMPLETION,
-            contentParts,
-        });
-        expect(titleRes.title).toBeDefined();
-    });
-    test(`${capitalizeFirstLetter(provider)}: Anthropic does NOT reason by default (no config)`, async () => {
-        const { reasoning: _baseReasoning, ...baseWithoutReasoning } = baseLLMConfig;
-        const llmConfig = {
-            ...baseWithoutReasoning,
-            model: 'anthropic/claude-sonnet-4',
-        };
-        const customHandlers = setupCustomHandlers();
-        run = await Run.create({
-            runId: 'or-anthropic-default-1',
-            graphConfig: {
-                type: 'standard',
-                llmConfig,
-                instructions: 'You are a helpful AI assistant.',
-            },
-            returnContent: true,
-            skipCleanup: true,
-            customHandlers,
-        });
-        conversationHistory.push(new HumanMessage('What is 15 * 37 + 128 / 4? Show your work.'));
-        await run.processStream({ messages: conversationHistory }, { ...configV2, configurable: { thread_id: 'or-anthropic-default-1' } });
-        expect(collectedUsage.length).toBeGreaterThan(0);
-        const usage = collectedUsage[0];
-        // Anthropic requires explicit reasoning config — no reasoning tokens by default
-        const reasoningTokens = usage.output_token_details
-            ?.reasoning ?? 0;
-        expect(reasoningTokens).toBe(0);
-    });
-    test(`${capitalizeFirstLetter(provider)}: Gemini 3 reasons by default (no config)`, async () => {
-        await runReasoningTest({
-            model: 'google/gemini-3-pro-preview',
-            reasoning: undefined,
-            threadId: 'or-gemini-default-1',
-            runId: 'or-gemini-default-1',
-        });
-    });
-    test(`${capitalizeFirstLetter(provider)}: Gemini reasoning with max_tokens`, async () => {
-        await runReasoningTest({
-            model: 'google/gemini-3-pro-preview',
-            reasoning: { max_tokens: 4000 },
-            threadId: 'or-gemini-reasoning-1',
-            runId: 'or-gemini-reasoning-1',
-        });
-    });
-    test(`${capitalizeFirstLetter(provider)}: Gemini reasoning with effort`, async () => {
-        await runReasoningTest({
-            model: 'google/gemini-3-flash-preview',
-            reasoning: { effort: 'low' },
-            threadId: 'or-gemini-effort-1',
-            runId: 'or-gemini-effort-1',
-        });
-    });
-    test(`${capitalizeFirstLetter(provider)}: Anthropic reasoning with max_tokens`, async () => {
-        await runReasoningTest({
-            model: 'anthropic/claude-sonnet-4',
-            reasoning: { max_tokens: 4000 },
-            threadId: 'or-anthropic-reasoning-1',
-            runId: 'or-anthropic-reasoning-1',
-        });
-    });
-    test(`${capitalizeFirstLetter(provider)}: Anthropic sonnet-4 reasoning with effort`, async () => {
-        await runReasoningTest({
-            model: 'anthropic/claude-sonnet-4',
-            reasoning: { effort: 'medium' },
-            threadId: 'or-anthropic-effort-s4-1',
-            runId: 'or-anthropic-effort-s4-1',
-        });
-    });
-    test(`${capitalizeFirstLetter(provider)}: Anthropic sonnet-4-6 reasoning with effort`, async () => {
-        await runReasoningTest({
-            model: 'anthropic/claude-sonnet-4-6',
-            reasoning: { effort: 'medium' },
-            threadId: 'or-anthropic-effort-s46-1',
-            runId: 'or-anthropic-effort-s46-1',
-        });
-    });
-});
-//# sourceMappingURL=openrouter.simple.test.js.map