@illuma-ai/agents 1.1.21 → 1.1.23

package/src/specs/emergency-prune.test.js

@@ -1,308 +0,0 @@
-// src/specs/emergency-prune.test.ts
-/**
- * Tests for the emergency pruning feature that handles "input too long" errors
- * by retrying with more aggressive message pruning and adding a context notice.
- */
-import { HumanMessage, AIMessage, SystemMessage, } from '@langchain/core/messages';
-import { createPruneMessages } from '@/messages/prune';
-import { Providers } from '@/common';
-// Simple token counter for testing (1 character = 1 token)
-const createTestTokenCounter = () => {
-    return (message) => {
-        const content = message.content;
-        if (typeof content === 'string') {
-            return content.length;
-        }
-        if (Array.isArray(content)) {
-            return content.reduce((total, item) => {
-                if (typeof item === 'string')
-                    return total + item.length;
-                if (typeof item === 'object' &&
-                    'text' in item &&
-                    typeof item.text === 'string') {
-                    return total + item.text.length;
-                }
-                return total;
-            }, 0);
-        }
-        return 0;
-    };
-};
-// Helper to create test messages
-const createTestMessages = (count, tokensPer) => {
-    const messages = [
-        new SystemMessage('You are a helpful assistant.'),
-    ];
-    for (let i = 0; i < count; i++) {
-        const content = 'x'.repeat(tokensPer);
-        if (i % 2 === 0) {
-            messages.push(new HumanMessage(content));
-        }
-        else {
-            messages.push(new AIMessage(content));
-        }
-    }
-    return messages;
-};
-// Helper to build indexTokenCountMap
-const buildIndexTokenCountMap = (messages, tokenCounter) => {
-    const map = {};
-    messages.forEach((msg, index) => {
-        map[index] = tokenCounter(msg);
-    });
-    return map;
-};
-/**
- * Estimates a human-friendly description of the conversation timeframe based on message count.
- * This mirrors the implementation in Graph.ts
- */
-const getContextTimeframeDescription = (messageCount) => {
-    if (messageCount <= 5) {
-        return 'just the last few exchanges';
-    }
-    else if (messageCount <= 15) {
-        return 'the last several minutes';
-    }
-    else if (messageCount <= 30) {
-        return 'roughly the past hour';
-    }
-    else if (messageCount <= 60) {
-        return 'the past couple of hours';
-    }
-    else if (messageCount <= 150) {
-        return 'the past few hours';
-    }
-    else if (messageCount <= 300) {
-        return 'roughly a day\'s worth';
-    }
-    else if (messageCount <= 700) {
-        return 'the past few days';
-    }
-    else {
-        return 'about a week or more';
-    }
-};
-describe('Emergency Pruning Feature', () => {
-    const tokenCounter = createTestTokenCounter();
-    describe('Normal Pruning vs Emergency Pruning', () => {
-        it('should prune more aggressively with 50% reduced context', () => {
-            // Create 20 messages, each with 100 tokens = 2000 tokens total (excluding system)
-            const messages = createTestMessages(20, 100);
-            const indexTokenCountMap = buildIndexTokenCountMap(messages, tokenCounter);
-            // Normal prune with 1500 token limit
-            const normalMaxTokens = 1500;
-            const normalPrune = createPruneMessages({
-                startIndex: 0,
-                provider: Providers.BEDROCK,
-                tokenCounter,
-                maxTokens: normalMaxTokens,
-                thinkingEnabled: false,
-                indexTokenCountMap,
-            });
-            const { context: normalContext } = normalPrune({ messages });
-            // Emergency prune with 50% (750 tokens)
-            const emergencyMaxTokens = Math.floor(normalMaxTokens * 0.5);
-            const emergencyPrune = createPruneMessages({
-                startIndex: 0,
-                provider: Providers.BEDROCK,
-                tokenCounter,
-                maxTokens: emergencyMaxTokens,
-                thinkingEnabled: false,
-                indexTokenCountMap,
-            });
-            const { context: emergencyContext } = emergencyPrune({ messages });
-            // Emergency should have fewer messages
-            expect(emergencyContext.length).toBeLessThan(normalContext.length);
-            console.log(`Normal prune: ${normalContext.length} messages, Emergency prune: ${emergencyContext.length} messages`);
-        });
-        it('should preserve system message and latest user message after emergency prune', () => {
-            const messages = createTestMessages(10, 200);
-            const indexTokenCountMap = buildIndexTokenCountMap(messages, tokenCounter);
-            // Very aggressive prune - only 300 tokens
-            const emergencyPrune = createPruneMessages({
-                startIndex: 0,
-                provider: Providers.BEDROCK,
-                tokenCounter,
-                maxTokens: 300,
-                thinkingEnabled: false,
-                indexTokenCountMap,
-            });
-            const { context } = emergencyPrune({ messages });
-            // Should still have system message if it fits
-            if (context.length > 0) {
-                // Check that we have at least the most recent messages
-                const lastMessage = context[context.length - 1];
-                expect(lastMessage).toBeDefined();
-            }
-        });
-    });
-    describe('Pruning Notice Message Injection', () => {
-        it('should calculate correct number of pruned messages', () => {
-            const originalCount = 20;
-            const messages = createTestMessages(originalCount, 100);
-            const indexTokenCountMap = buildIndexTokenCountMap(messages, tokenCounter);
-            const emergencyPrune = createPruneMessages({
-                startIndex: 0,
-                provider: Providers.BEDROCK,
-                tokenCounter,
-                maxTokens: 500, // Very small to force aggressive pruning
-                thinkingEnabled: false,
-                indexTokenCountMap,
-            });
-            const { context: reducedMessages } = emergencyPrune({ messages });
-            // Calculate how many were pruned (this is what we inject in the notice)
-            const prunedCount = messages.length - reducedMessages.length;
-            expect(prunedCount).toBeGreaterThan(0);
-            console.log(`Original: ${messages.length}, After prune: ${reducedMessages.length}, Pruned: ${prunedCount}`);
-        });
-        it('should inject personalized notice message after system message', () => {
-            const messages = createTestMessages(10, 100);
-            const indexTokenCountMap = buildIndexTokenCountMap(messages, tokenCounter);
-            const emergencyPrune = createPruneMessages({
-                startIndex: 0,
-                provider: Providers.BEDROCK,
-                tokenCounter,
-                maxTokens: 800,
-                thinkingEnabled: false,
-                indexTokenCountMap,
-            });
-            const { context: reducedMessages } = emergencyPrune({ messages });
-            // Simulate the notice injection logic from Graph.ts
-            const prunedCount = messages.length - reducedMessages.length;
-            const remainingCount = reducedMessages.length;
-            const estimatedContextDescription = getContextTimeframeDescription(remainingCount);
-            const pruneNoticeMessage = new HumanMessage({
-                content: `[CONTEXT NOTICE]
-Our conversation has grown quite long, so I've focused on ${estimatedContextDescription} of our chat (${remainingCount} recent messages). ${prunedCount} earlier messages are no longer in my immediate memory.
-
-If I seem to be missing something we discussed earlier, just give me a quick reminder and I'll pick right back up! I'm still fully engaged and ready to help with whatever you need.`,
-            });
-            // Insert after system message
-            const hasSystemMessage = reducedMessages[0]?.getType() === 'system';
-            const insertIndex = hasSystemMessage ? 1 : 0;
-            const messagesWithNotice = [
-                ...reducedMessages.slice(0, insertIndex),
-                pruneNoticeMessage,
-                ...reducedMessages.slice(insertIndex),
-            ];
-            // Verify notice is in correct position
-            if (hasSystemMessage) {
-                expect(messagesWithNotice[0].getType()).toBe('system');
-                expect(messagesWithNotice[1].getType()).toBe('human');
-                expect(messagesWithNotice[1].content).toContain('[CONTEXT NOTICE]');
-                expect(messagesWithNotice[1].content).toContain('recent messages');
-                expect(messagesWithNotice[1].content).toContain('quick reminder');
-            }
-            else {
-                expect(messagesWithNotice[0].getType()).toBe('human');
-                expect(messagesWithNotice[0].content).toContain('[CONTEXT NOTICE]');
-            }
-            // Total messages should be reduced + 1 notice
-            expect(messagesWithNotice.length).toBe(reducedMessages.length + 1);
-            console.log(`Notice preview:\n${pruneNoticeMessage.content.substring(0, 200)}...`);
-        });
-    });
-    describe('Context Timeframe Description', () => {
-        it('should return appropriate descriptions for different message counts', () => {
-            expect(getContextTimeframeDescription(3)).toBe('just the last few exchanges');
-            expect(getContextTimeframeDescription(10)).toBe('the last several minutes');
-            expect(getContextTimeframeDescription(25)).toBe('roughly the past hour');
-            expect(getContextTimeframeDescription(45)).toBe('the past couple of hours');
-            expect(getContextTimeframeDescription(100)).toBe('the past few hours');
-            expect(getContextTimeframeDescription(200)).toBe('roughly a day\'s worth');
-            expect(getContextTimeframeDescription(500)).toBe('the past few days');
-            expect(getContextTimeframeDescription(1000)).toBe('about a week or more');
-        });
-    });
-    describe('Error Detection Patterns', () => {
-        const errorPatterns = [
-            'Input is too long for the model',
-            'context length exceeded',
-            'maximum context length',
-            'ValidationException: Input is too long',
-            'prompt is too long for this model',
-            'The input is too long',
-        ];
-        it('should detect various "input too long" error patterns', () => {
-            const isInputTooLongError = (errorMessage) => {
-                const lowerMessage = errorMessage.toLowerCase();
-                return (lowerMessage.includes('too long') ||
-                    lowerMessage.includes('input is too long') ||
-                    lowerMessage.includes('context length') ||
-                    lowerMessage.includes('maximum context') ||
-                    lowerMessage.includes('validationexception') ||
-                    lowerMessage.includes('prompt is too long'));
-            };
-            for (const pattern of errorPatterns) {
-                expect(isInputTooLongError(pattern)).toBe(true);
-                console.log(`✓ Detected: "${pattern}"`);
-            }
-            // Should not match unrelated errors
-            expect(isInputTooLongError('Network timeout')).toBe(false);
-            expect(isInputTooLongError('Invalid API key')).toBe(false);
-            expect(isInputTooLongError('Rate limit exceeded')).toBe(false);
-        });
-    });
-    describe('Edge Cases', () => {
-        it('should handle empty messages after pruning', () => {
-            // Single very long message that exceeds the limit
-            const messages = [
-                new SystemMessage('System prompt'),
-                new HumanMessage('x'.repeat(10000)), // Way too long
-            ];
-            const indexTokenCountMap = buildIndexTokenCountMap(messages, tokenCounter);
-            const emergencyPrune = createPruneMessages({
-                startIndex: 0,
-                provider: Providers.BEDROCK,
-                tokenCounter,
-                maxTokens: 100, // Very small limit
-                thinkingEnabled: false,
-                indexTokenCountMap,
-            });
-            const { context } = emergencyPrune({ messages });
-            // Should have at least tried to keep something or be empty
-            // The key is it shouldn't throw
-            expect(Array.isArray(context)).toBe(true);
-        });
-        it('should work with only system message and one user message', () => {
-            const messages = [
-                new SystemMessage('You are helpful.'),
-                new HumanMessage('Hello'),
-            ];
-            const indexTokenCountMap = buildIndexTokenCountMap(messages, tokenCounter);
-            const emergencyPrune = createPruneMessages({
-                startIndex: 0,
-                provider: Providers.BEDROCK,
-                tokenCounter,
-                maxTokens: 500,
-                thinkingEnabled: false,
-                indexTokenCountMap,
-            });
-            const { context } = emergencyPrune({ messages });
-            expect(context.length).toBe(2);
-            expect(context[0].getType()).toBe('system');
-            expect(context[1].getType()).toBe('human');
-        });
-        it('should handle conversation without system message', () => {
-            const messages = [
-                new HumanMessage('Hello'),
-                new AIMessage('Hi there!'),
-                new HumanMessage('How are you?'),
-            ];
-            const indexTokenCountMap = buildIndexTokenCountMap(messages, tokenCounter);
-            const emergencyPrune = createPruneMessages({
-                startIndex: 0,
-                provider: Providers.BEDROCK,
-                tokenCounter,
-                maxTokens: 100,
-                thinkingEnabled: false,
-                indexTokenCountMap,
-            });
-            const { context } = emergencyPrune({ messages });
-            // Should keep the most recent messages that fit
-            expect(context.length).toBeGreaterThan(0);
-            expect(context[0].getType()).not.toBe('system');
-        });
-    });
-});
-//# sourceMappingURL=emergency-prune.test.js.map

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

@@ -1,237 +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 { Run } from '@/run';
-const provider = Providers.MOONSHOT;
-const llmConfig = {
-    provider,
-    model: 'kimi-k2.5',
-    configuration: {
-        apiKey: process.env.MOONSHOT_API_KEY,
-        baseURL: 'https://api.moonshot.ai/v1',
-    },
-};
-const skipTests = process.env.MOONSHOT_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: 'moonshot-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`, async () => {
-        const customHandlers = setupCustomHandlers();
-        run = await Run.create({
-            runId: 'moonshot-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 Moonshot 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('Tool call test passed - reasoning_content was preserved');
-        console.log('Final response:', finalMessages?.[finalMessages.length - 1]?.content);
-    });
-    test(`${capitalizeFirstLetter(provider)}: should handle multi-turn conversation with tools`, async () => {
-        const customHandlers = setupCustomHandlers();
-        run = await Run.create({
-            runId: 'moonshot-multi-turn-test',
-            graphConfig: {
-                type: 'standard',
-                llmConfig,
-                tools: [new Calculator()],
-                instructions: 'You are a helpful math assistant. Use the calculator tool when needed.',
-            },
-            returnContent: true,
-            skipCleanup: true,
-            customHandlers,
-        });
-        conversationHistory.push(new HumanMessage('What is 15 + 27?'));
-        let finalContentParts = await run.processStream({ messages: conversationHistory }, testConfig);
-        expect(finalContentParts).toBeDefined();
-        let runMessages = run.getRunMessages();
-        conversationHistory.push(...(runMessages ?? []));
-        console.log('Turn 1 completed, conversation length:', conversationHistory.length);
-        conversationHistory.push(new HumanMessage('Now multiply that result by 3'));
-        run = await Run.create({
-            runId: 'moonshot-multi-turn-test-2',
-            graphConfig: {
-                type: 'standard',
-                llmConfig,
-                tools: [new Calculator()],
-                instructions: 'You are a helpful math assistant. Use the calculator tool when needed.',
-            },
-            returnContent: true,
-            skipCleanup: true,
-            customHandlers,
-        });
-        finalContentParts = await run.processStream({ messages: conversationHistory }, { ...testConfig, configurable: { thread_id: 'moonshot-test-2' } });
-        expect(finalContentParts).toBeDefined();
-        runMessages = run.getRunMessages();
-        expect(runMessages).toBeDefined();
-        console.log('Turn 2 completed');
-        console.log('Final response:', runMessages?.[runMessages.length - 1]?.content);
-        const textParts = finalContentParts?.filter((part) => part.type === ContentTypes.TEXT);
-        expect(textParts?.length).toBeGreaterThan(0);
-    });
-    test(`${capitalizeFirstLetter(provider)}: should process simple message without tools`, async () => {
-        const customHandlers = setupCustomHandlers();
-        run = await Run.create({
-            runId: 'moonshot-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);
-    });
-    test(`${capitalizeFirstLetter(provider)}: should handle tool calls with disableStreaming`, async () => {
-        const customHandlers = setupCustomHandlers();
-        const nonStreamingLlmConfig = {
-            ...llmConfig,
-            disableStreaming: true,
-        };
-        run = await Run.create({
-            runId: 'moonshot-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 Moonshot 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);
-    });
-});
-//# sourceMappingURL=moonshot.simple.test.js.map