@illuma-ai/agents 1.1.20 → 1.1.22

package/src/specs/reasoning.test.js

@@ -1,144 +0,0 @@
-/* eslint-disable no-console */
-// src/scripts/cli.test.ts
-import { config } from 'dotenv';
-config();
-import { HumanMessage, } from '@langchain/core/messages';
-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';
-const reasoningText = `<think>
-Okay, the user is Jo from New York. I should start by greeting them by name. Let's keep it friendly and open-ended. Maybe mention the weather in New York to make it personal. Then offer help with something specific like plans or questions. Need to keep it concise and welcoming. Check for any typos. Alright, that should work.
-</think>
-Hi Jo! 🌆 How's everything in New York today? Whether you need recommendations for the city, help with a task, or just want to chat, I'm here for it. What's on your mind? 😊`;
-const provider = 'Reasoning LLM';
-describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
-    jest.setTimeout(30000);
-    let run;
-    let contentParts;
-    let conversationHistory;
-    let aggregateContent;
-    let runSteps;
-    const config = {
-        configurable: {
-            thread_id: 'conversation-num-1',
-        },
-        streamMode: 'values',
-        version: 'v2',
-        callbacks: [
-            {
-                async handleCustomEvent(event, data, metadata) {
-                    if (event !== GraphEvents.ON_MESSAGE_DELTA) {
-                        return;
-                    }
-                    const messageDeltaData = data;
-                    // Wait until we see the run step (with timeout for safety)
-                    const maxAttempts = 50; // 5 seconds total
-                    let attempts = 0;
-                    while (!runSteps.has(messageDeltaData.id) && attempts < maxAttempts) {
-                        await new Promise((resolve) => setTimeout(resolve, 100));
-                        attempts++;
-                    }
-                    if (!runSteps.has(messageDeltaData.id)) {
-                        console.warn(`Timeout waiting for run step: ${messageDeltaData.id}`);
-                    }
-                    onMessageDeltaSpy(event, data, metadata, run.Graph);
-                    aggregateContent({ event, data: messageDeltaData });
-                },
-            },
-        ],
-    };
-    beforeEach(async () => {
-        conversationHistory = [];
-        const { contentParts: parts, aggregateContent: ac } = createContentAggregator();
-        aggregateContent = ac;
-        runSteps = new Set();
-        contentParts = parts;
-    });
-    afterEach(() => {
-        runSteps.clear();
-    });
-    const onReasoningDeltaSpy = jest.fn();
-    const onMessageDeltaSpy = jest.fn();
-    const onRunStepSpy = jest.fn();
-    afterAll(() => {
-        onReasoningDeltaSpy.mockReset();
-        onMessageDeltaSpy.mockReset();
-        onRunStepSpy.mockReset();
-    });
-    const setupCustomHandlers = () => ({
-        [GraphEvents.ON_RUN_STEP_COMPLETED]: {
-            handle: (event, data) => {
-                aggregateContent({
-                    event,
-                    data: data,
-                });
-            },
-        },
-        [GraphEvents.ON_RUN_STEP]: {
-            handle: (event, data, metadata, graph) => {
-                const runStepData = data;
-                runSteps.add(runStepData.id);
-                onRunStepSpy(event, runStepData, metadata, graph);
-                aggregateContent({ event, data: runStepData });
-            },
-        },
-        [GraphEvents.ON_RUN_STEP_DELTA]: {
-            handle: (event, data) => {
-                aggregateContent({ event, data: data });
-            },
-        },
-        [GraphEvents.ON_REASONING_DELTA]: {
-            handle: (event, data, metadata, graph) => {
-                onReasoningDeltaSpy(event, data, metadata, graph);
-                aggregateContent({ event, data: data });
-            },
-        },
-    });
-    test(`${capitalizeFirstLetter(provider)}: should process a simple reasoning message`, async () => {
-        const { userName, location } = await getArgs();
-        const llmConfig = getLLMConfig(Providers.OPENAI);
-        const customHandlers = setupCustomHandlers();
-        run = await Run.create({
-            runId: 'test-run-id',
-            graphConfig: {
-                type: 'standard',
-                llmConfig,
-                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,
-        });
-        run.Graph?.overrideTestModel([reasoningText], 2);
-        const userMessage = 'hi';
-        conversationHistory.push(new HumanMessage(userMessage));
-        const inputs = {
-            messages: conversationHistory,
-        };
-        await run.processStream(inputs, config);
-        expect(contentParts).toBeDefined();
-        expect(contentParts.length).toBe(2);
-        const reasoningContent = reasoningText.match(/<think>(.*)<\/think>/s)?.[0];
-        const content = reasoningText.split(/<\/think>/)[1];
-        expect(contentParts[0].think).toBe(reasoningContent);
-        expect(contentParts[1].text).toBe(content);
-        const finalMessages = run.getRunMessages();
-        expect(finalMessages).toBeDefined();
-        conversationHistory.push(...(finalMessages ?? []));
-        expect(conversationHistory.length).toBeGreaterThan(1);
-        expect(onMessageDeltaSpy).toHaveBeenCalled();
-        expect(onMessageDeltaSpy.mock.calls.length).toBeGreaterThan(1);
-        expect(onMessageDeltaSpy.mock.calls[0][3]).toBeDefined(); // Graph exists
-        expect(onReasoningDeltaSpy).toHaveBeenCalled();
-        expect(onReasoningDeltaSpy.mock.calls.length).toBeGreaterThan(1);
-        expect(onReasoningDeltaSpy.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
-    });
-});
-//# sourceMappingURL=reasoning.test.js.map

package/src/specs/spec.utils.js

@@ -1,4 +0,0 @@
-export function capitalizeFirstLetter(string) {
-    return string.charAt(0).toUpperCase() + string.slice(1);
-}
-//# sourceMappingURL=spec.utils.js.map

package/src/specs/thinking-handoff.test.js

@@ -1,486 +0,0 @@
-// src/specs/thinking-handoff.test.ts
-import { HumanMessage } from '@langchain/core/messages';
-import { Providers, Constants } from '@/common';
-import { Run } from '@/run';
-/**
- * Test suite for Thinking-Enabled Agent Handoff Edge Case
- *
- * Tests the specific edge case where:
- * - An agent without thinking blocks (e.g., OpenAI) makes a tool call
- * - Control is handed off to an agent with thinking enabled (e.g., Anthropic/Bedrock)
- * - The system should handle the transition without errors
- *
- * Background:
- * When Anthropic's extended thinking is enabled, the API requires that any assistant
- * message with tool_use content must start with a thinking or redacted_thinking block.
- * When switching from a non-thinking agent to a thinking-enabled agent, previous
- * messages may not have these blocks, causing API errors.
- *
- * Solution:
- * The ensureThinkingBlockInMessages() function converts AI messages with tool calls
- * (that lack thinking blocks) into HumanMessages with buffer strings, avoiding the
- * thinking block requirement while preserving context.
- */
-describe('Thinking-Enabled Agent Handoff Tests', () => {
-    jest.setTimeout(30000);
-    const createTestConfig = (agents, edges) => ({
-        runId: `thinking-handoff-test-${Date.now()}-${Math.random()}`,
-        graphConfig: {
-            type: 'multi-agent',
-            agents,
-            edges,
-        },
-        returnContent: true,
-        skipCleanup: true,
-    });
-    describe('OpenAI to Anthropic with Thinking', () => {
-        it('should successfully handoff from OpenAI to Anthropic with thinking enabled', async () => {
-            const agents = [
-                {
-                    agentId: 'supervisor',
-                    provider: Providers.OPENAI,
-                    clientOptions: {
-                        modelName: 'gpt-4o-mini',
-                        apiKey: 'test-key',
-                    },
-                    instructions: 'You are a supervisor. Use transfer_to_specialist when asked.',
-                    maxContextTokens: 8000,
-                },
-                {
-                    agentId: 'specialist',
-                    provider: Providers.ANTHROPIC,
-                    clientOptions: {
-                        modelName: 'claude-3-7-sonnet-20250219',
-                        apiKey: 'test-key',
-                        thinking: {
-                            type: 'enabled',
-                            budget_tokens: 2000,
-                        },
-                    },
-                    instructions: 'You are a specialist. Provide detailed answers.',
-                    maxContextTokens: 8000,
-                },
-            ];
-            const edges = [
-                {
-                    from: 'supervisor',
-                    to: 'specialist',
-                    edgeType: 'handoff',
-                    description: 'Transfer to specialist for detailed analysis',
-                },
-            ];
-            const run = await Run.create(createTestConfig(agents, edges));
-            // Simulate supervisor using handoff tool
-            run.Graph?.overrideTestModel([
-                'Let me transfer you to our specialist',
-                'As a specialist, let me analyze this carefully...',
-            ], 10, [
-                {
-                    id: 'tool_call_1',
-                    name: `${Constants.LC_TRANSFER_TO_}specialist`,
-                    args: {},
-                },
-            ]);
-            const messages = [new HumanMessage('I need expert analysis')];
-            const config = {
-                configurable: {
-                    thread_id: 'test-thinking-handoff-thread',
-                },
-                streamMode: 'values',
-                version: 'v2',
-            };
-            // Should not throw despite thinking requirement
-            await expect(run.processStream({ messages }, config)).resolves.not.toThrow();
-            const finalMessages = run.getRunMessages();
-            expect(finalMessages).toBeDefined();
-            expect(finalMessages.length).toBeGreaterThan(1);
-            // Should have successful handoff
-            const toolMessages = finalMessages.filter((msg) => msg.getType() === 'tool');
-            const handoffMessage = toolMessages.find((msg) => msg.name === `${Constants.LC_TRANSFER_TO_}specialist`);
-            expect(handoffMessage).toBeDefined();
-            expect(handoffMessage?.content).toContain('transferred to specialist');
-        });
-        it('should convert tool sequence to HumanMessage for thinking-enabled agent', async () => {
-            const agents = [
-                {
-                    agentId: 'agent_a',
-                    provider: Providers.OPENAI,
-                    clientOptions: {
-                        modelName: 'gpt-4o-mini',
-                        apiKey: 'test-key',
-                    },
-                    instructions: 'You are agent A',
-                    maxContextTokens: 8000,
-                },
-                {
-                    agentId: 'agent_b',
-                    provider: Providers.ANTHROPIC,
-                    clientOptions: {
-                        modelName: 'claude-3-7-sonnet-20250219',
-                        apiKey: 'test-key',
-                        thinking: {
-                            type: 'enabled',
-                            budget_tokens: 2000,
-                        },
-                    },
-                    instructions: 'You are agent B with thinking enabled',
-                    maxContextTokens: 8000,
-                },
-            ];
-            const edges = [
-                {
-                    from: 'agent_a',
-                    to: 'agent_b',
-                    edgeType: 'handoff',
-                },
-            ];
-            const run = await Run.create(createTestConfig(agents, edges));
-            // Check that agent B's context is set up correctly
-            const agentBContext = run.Graph.agentContexts.get('agent_b');
-            expect(agentBContext).toBeDefined();
-            // Verify thinking is enabled
-            const thinkingConfig = (agentBContext?.clientOptions).thinking;
-            expect(thinkingConfig).toBeDefined();
-            expect(thinkingConfig?.type).toBe('enabled');
-        });
-    });
-    describe('Bedrock with Thinking', () => {
-        it('should handle handoff from Bedrock without thinking to Bedrock with thinking', async () => {
-            const agents = [
-                {
-                    agentId: 'coordinator',
-                    provider: Providers.BEDROCK,
-                    clientOptions: {
-                        region: 'us-east-1',
-                        model: 'anthropic.claude-3-5-haiku-20241022-v1:0',
-                        // No thinking config
-                    },
-                    instructions: 'You are a coordinator',
-                    maxContextTokens: 8000,
-                },
-                {
-                    agentId: 'analyst',
-                    provider: Providers.BEDROCK,
-                    clientOptions: {
-                        region: 'us-east-1',
-                        model: 'us.anthropic.claude-3-7-sonnet-20250219-v1:0',
-                        additionalModelRequestFields: {
-                            thinking: {
-                                type: 'enabled',
-                                budget_tokens: 2000,
-                            },
-                        },
-                    },
-                    instructions: 'You are an analyst with extended thinking',
-                    maxContextTokens: 8000,
-                },
-            ];
-            const edges = [
-                {
-                    from: 'coordinator',
-                    to: 'analyst',
-                    edgeType: 'handoff',
-                    description: 'Transfer to analyst for deep analysis',
-                },
-            ];
-            const run = await Run.create(createTestConfig(agents, edges));
-            run.Graph?.overrideTestModel(['Transferring to analyst', 'Deep analysis results...'], 10, [
-                {
-                    id: 'tool_call_1',
-                    name: `${Constants.LC_TRANSFER_TO_}analyst`,
-                    args: {},
-                },
-            ]);
-            const messages = [new HumanMessage('Analyze this data')];
-            const config = {
-                configurable: {
-                    thread_id: 'test-bedrock-thinking-thread',
-                },
-                streamMode: 'values',
-                version: 'v2',
-            };
-            await expect(run.processStream({ messages }, config)).resolves.not.toThrow();
-            const finalMessages = run.getRunMessages();
-            expect(finalMessages).toBeDefined();
-        });
-        it('should verify Bedrock thinking configuration is properly detected', async () => {
-            const agents = [
-                {
-                    agentId: 'agent_a',
-                    provider: Providers.OPENAI,
-                    clientOptions: {
-                        modelName: 'gpt-4o-mini',
-                        apiKey: 'test-key',
-                    },
-                    instructions: 'You are agent A',
-                    maxContextTokens: 8000,
-                },
-                {
-                    agentId: 'agent_b',
-                    provider: Providers.BEDROCK,
-                    clientOptions: {
-                        region: 'us-east-1',
-                        model: 'us.anthropic.claude-3-7-sonnet-20250219-v1:0',
-                        additionalModelRequestFields: {
-                            thinking: {
-                                type: 'enabled',
-                                budget_tokens: 3000,
-                            },
-                        },
-                    },
-                    instructions: 'You are agent B with Bedrock thinking',
-                    maxContextTokens: 8000,
-                },
-            ];
-            const edges = [
-                {
-                    from: 'agent_a',
-                    to: 'agent_b',
-                    edgeType: 'handoff',
-                },
-            ];
-            const run = await Run.create(createTestConfig(agents, edges));
-            const agentBContext = run.Graph.agentContexts.get('agent_b');
-            expect(agentBContext).toBeDefined();
-            expect(agentBContext?.provider).toBe(Providers.BEDROCK);
-            // Verify thinking configuration in additionalModelRequestFields
-            const bedrockOptions = agentBContext?.clientOptions;
-            expect(bedrockOptions.additionalModelRequestFields).toBeDefined();
-            expect(bedrockOptions.additionalModelRequestFields?.thinking).toBeDefined();
-            const thinkingConfig = bedrockOptions.additionalModelRequestFields
-                ?.thinking;
-            expect(thinkingConfig.type).toBe('enabled');
-            expect(thinkingConfig.budget_tokens).toBe(3000);
-        });
-        it('should handle OpenAI to Bedrock with thinking handoff', async () => {
-            const agents = [
-                {
-                    agentId: 'supervisor',
-                    provider: Providers.OPENAI,
-                    clientOptions: {
-                        modelName: 'gpt-4o-mini',
-                        apiKey: 'test-key',
-                    },
-                    instructions: 'You are a supervisor',
-                    maxContextTokens: 8000,
-                },
-                {
-                    agentId: 'bedrock_specialist',
-                    provider: Providers.BEDROCK,
-                    clientOptions: {
-                        region: 'us-east-1',
-                        model: 'us.anthropic.claude-3-7-sonnet-20250219-v1:0',
-                        additionalModelRequestFields: {
-                            thinking: {
-                                type: 'enabled',
-                                budget_tokens: 2000,
-                            },
-                        },
-                    },
-                    instructions: 'You are a Bedrock specialist with thinking',
-                    maxContextTokens: 8000,
-                },
-            ];
-            const edges = [
-                {
-                    from: 'supervisor',
-                    to: 'bedrock_specialist',
-                    edgeType: 'handoff',
-                    description: 'Transfer to Bedrock specialist',
-                },
-            ];
-            const run = await Run.create(createTestConfig(agents, edges));
-            run.Graph?.overrideTestModel(['Transferring', 'Analysis complete'], 10, [
-                {
-                    id: 'tool_call_1',
-                    name: `${Constants.LC_TRANSFER_TO_}bedrock_specialist`,
-                    args: {},
-                },
-            ]);
-            const messages = [new HumanMessage('Analyze this')];
-            const config = {
-                configurable: {
-                    thread_id: 'test-openai-bedrock-thread',
-                },
-                streamMode: 'values',
-                version: 'v2',
-            };
-            await expect(run.processStream({ messages }, config)).resolves.not.toThrow();
-            const finalMessages = run.getRunMessages();
-            expect(finalMessages).toBeDefined();
-            const toolMessages = finalMessages.filter((msg) => msg.getType() === 'tool');
-            const handoffMessage = toolMessages.find((msg) => msg.name === `${Constants.LC_TRANSFER_TO_}bedrock_specialist`);
-            expect(handoffMessage).toBeDefined();
-        });
-    });
-    describe('Multiple Handoffs with Mixed Thinking Configurations', () => {
-        it('should handle chain of handoffs with varying thinking configurations', async () => {
-            const agents = [
-                {
-                    agentId: 'router',
-                    provider: Providers.OPENAI,
-                    clientOptions: {
-                        modelName: 'gpt-4o-mini',
-                        apiKey: 'test-key',
-                    },
-                    instructions: 'You route requests',
-                    maxContextTokens: 8000,
-                },
-                {
-                    agentId: 'processor',
-                    provider: Providers.ANTHROPIC,
-                    clientOptions: {
-                        modelName: 'claude-haiku-4-5',
-                        apiKey: 'test-key',
-                        // No thinking
-                    },
-                    instructions: 'You process requests',
-                    maxContextTokens: 8000,
-                },
-                {
-                    agentId: 'reviewer',
-                    provider: Providers.ANTHROPIC,
-                    clientOptions: {
-                        modelName: 'claude-3-7-sonnet-20250219',
-                        apiKey: 'test-key',
-                        thinking: {
-                            type: 'enabled',
-                            budget_tokens: 2000,
-                        },
-                    },
-                    instructions: 'You review with deep thinking',
-                    maxContextTokens: 8000,
-                },
-            ];
-            const edges = [
-                {
-                    from: 'router',
-                    to: 'processor',
-                    edgeType: 'handoff',
-                },
-                {
-                    from: 'processor',
-                    to: 'reviewer',
-                    edgeType: 'handoff',
-                },
-            ];
-            const run = await Run.create(createTestConfig(agents, edges));
-            // Verify all agents are created with correct configurations
-            const routerContext = run.Graph.agentContexts.get('router');
-            const processorContext = run.Graph.agentContexts.get('processor');
-            const reviewerContext = run.Graph.agentContexts.get('reviewer');
-            expect(routerContext).toBeDefined();
-            expect(processorContext).toBeDefined();
-            expect(reviewerContext).toBeDefined();
-            // Verify thinking configuration on reviewer
-            const reviewerThinking = (reviewerContext?.clientOptions).thinking;
-            expect(reviewerThinking).toBeDefined();
-            expect(reviewerThinking?.type).toBe('enabled');
-            // Verify handoff tools exist
-            expect(routerContext?.graphTools?.find((tool) => tool.name ===
-                `${Constants.LC_TRANSFER_TO_}processor`)).toBeDefined();
-            expect(processorContext?.graphTools?.find((tool) => tool.name ===
-                `${Constants.LC_TRANSFER_TO_}reviewer`)).toBeDefined();
-        });
-    });
-    describe('Edge Cases', () => {
-        it('should not modify messages when agent already uses thinking', async () => {
-            const agents = [
-                {
-                    agentId: 'agent_a',
-                    provider: Providers.ANTHROPIC,
-                    clientOptions: {
-                        modelName: 'claude-3-7-sonnet-20250219',
-                        apiKey: 'test-key',
-                        thinking: {
-                            type: 'enabled',
-                            budget_tokens: 2000,
-                        },
-                    },
-                    instructions: 'You are agent A with thinking',
-                    maxContextTokens: 8000,
-                },
-                {
-                    agentId: 'agent_b',
-                    provider: Providers.ANTHROPIC,
-                    clientOptions: {
-                        modelName: 'claude-3-7-sonnet-20250219',
-                        apiKey: 'test-key',
-                        thinking: {
-                            type: 'enabled',
-                            budget_tokens: 2000,
-                        },
-                    },
-                    instructions: 'You are agent B with thinking',
-                    maxContextTokens: 8000,
-                },
-            ];
-            const edges = [
-                {
-                    from: 'agent_a',
-                    to: 'agent_b',
-                    edgeType: 'handoff',
-                },
-            ];
-            const run = await Run.create(createTestConfig(agents, edges));
-            run.Graph?.overrideTestModel(['Transferring', 'Received handoff'], 10, [
-                {
-                    id: 'tool_call_1',
-                    name: `${Constants.LC_TRANSFER_TO_}agent_b`,
-                    args: {},
-                },
-            ]);
-            const messages = [new HumanMessage('Test message')];
-            const config = {
-                configurable: {
-                    thread_id: 'test-both-thinking-thread',
-                },
-                streamMode: 'values',
-                version: 'v2',
-            };
-            // Should work fine when both agents use thinking
-            await expect(run.processStream({ messages }, config)).resolves.not.toThrow();
-        });
-        it('should handle empty conversation history', async () => {
-            const agents = [
-                {
-                    agentId: 'agent_a',
-                    provider: Providers.OPENAI,
-                    clientOptions: {
-                        modelName: 'gpt-4o-mini',
-                        apiKey: 'test-key',
-                    },
-                    instructions: 'You are agent A',
-                    maxContextTokens: 8000,
-                },
-                {
-                    agentId: 'agent_b',
-                    provider: Providers.ANTHROPIC,
-                    clientOptions: {
-                        modelName: 'claude-3-7-sonnet-20250219',
-                        apiKey: 'test-key',
-                        thinking: {
-                            type: 'enabled',
-                            budget_tokens: 2000,
-                        },
-                    },
-                    instructions: 'You are agent B',
-                    maxContextTokens: 8000,
-                },
-            ];
-            const edges = [
-                {
-                    from: 'agent_a',
-                    to: 'agent_b',
-                    edgeType: 'handoff',
-                },
-            ];
-            const run = await Run.create(createTestConfig(agents, edges));
-            expect(run.Graph).toBeDefined();
-            // Just verify the graph was created correctly
-            const agentBContext = run.Graph.agentContexts.get('agent_b');
-            expect(agentBContext).toBeDefined();
-        });
-    });
-});
-//# sourceMappingURL=thinking-handoff.test.js.map