@illuma-ai/agents 1.1.21 → 1.1.23

package/src/stream.test.js

@@ -1,225 +0,0 @@
-import { getChunkContent, createContentAggregator } from './stream';
-import { Providers, GraphEvents, StepTypes } from '@/common';
-describe('getChunkContent', () => {
-    it('should handle reasoning content for OpenAI/Azure providers', () => {
-        const chunk = {
-            content: 'Regular content',
-            additional_kwargs: {
-                reasoning: {
-                    summary: [{ text: 'Reasoning summary text' }],
-                },
-            },
-        };
-        const result = getChunkContent({
-            chunk,
-            provider: Providers.OPENAI,
-            reasoningKey: 'reasoning',
-        });
-        expect(result).toBe('Reasoning summary text');
-    });
-    it('should fallback to reasoningKey when no OpenAI reasoning summary', () => {
-        const chunk = {
-            content: 'Regular content',
-            additional_kwargs: {
-                reasoning_content: 'Reasoning from key',
-            },
-        };
-        const result = getChunkContent({
-            chunk,
-            reasoningKey: 'reasoning_content',
-        });
-        expect(result).toBe('Reasoning from key');
-    });
-    it('should fallback to chunk.content when reasoningKey value is null or undefined', () => {
-        const chunk = {
-            content: 'Fallback content',
-            additional_kwargs: {
-                reasoning_content: null,
-            },
-        };
-        const result = getChunkContent({
-            chunk,
-            reasoningKey: 'reasoning_content',
-        });
-        expect(result).toBe('Fallback content');
-    });
-    it('should fallback to chunk.content when reasoningKey value is empty string', () => {
-        const chunk = {
-            content: ' can',
-            additional_kwargs: {
-                reasoning_content: '',
-            },
-        };
-        const result = getChunkContent({
-            chunk,
-            reasoningKey: 'reasoning_content',
-        });
-        expect(result).toBe(' can');
-    });
-    it('should return undefined when no content is available', () => {
-        const chunk = {
-            additional_kwargs: {},
-        };
-        const result = getChunkContent({
-            chunk,
-            reasoningKey: 'reasoning',
-        });
-        expect(result).toBeUndefined();
-    });
-    it('should handle missing chunk gracefully', () => {
-        const result = getChunkContent({
-            reasoningKey: 'reasoning',
-        });
-        expect(result).toBeUndefined();
-    });
-});
-describe('createContentAggregator — tool call delta streaming', () => {
-    it('should allow delta updates when content part already has a name', () => {
-        const { contentParts, aggregateContent } = createContentAggregator();
-        // Step 1: ON_RUN_STEP creates the initial tool call with name
-        aggregateContent({
-            event: GraphEvents.ON_RUN_STEP,
-            data: {
-                id: 'step-1',
-                index: 0,
-                type: StepTypes.TOOL_CALLS,
-                stepDetails: {
-                    type: StepTypes.TOOL_CALLS,
-                    tool_calls: [
-                        { id: 'tc-1', name: 'content_tool', args: '{"action":"write"' },
-                    ],
-                },
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            },
-        });
-        // Verify initial content part was created with tool name
-        expect(contentParts[0]).toBeDefined();
-        expect(contentParts[0].tool_call?.name).toBe('content_tool');
-        const initialArgs = contentParts[0].tool_call?.args;
-        // Step 2: ON_RUN_STEP_DELTA — should UPDATE args (not be dropped)
-        aggregateContent({
-            event: GraphEvents.ON_RUN_STEP_DELTA,
-            data: {
-                id: 'step-1',
-                delta: {
-                    type: StepTypes.TOOL_CALLS,
-                    tool_calls: [{ args: ',"content":"hello world"', name: undefined }],
-                },
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            },
-        });
-        // Verify args were UPDATED (delta was not dropped)
-        const updatedArgs = contentParts[0].tool_call?.args;
-        expect(updatedArgs).not.toBe(initialArgs);
-        expect(updatedArgs).toContain('content');
-        expect(updatedArgs).toContain('hello world');
-    });
-    it('should still drop delta updates when no content part exists yet', () => {
-        const { contentParts, aggregateContent } = createContentAggregator();
-        // Simulate a delta arriving BEFORE the initial ON_RUN_STEP
-        // This creates an entry at index 0 via the delta but with no name
-        aggregateContent({
-            event: GraphEvents.ON_RUN_STEP,
-            data: {
-                id: 'step-orphan',
-                index: 5,
-                type: StepTypes.TOOL_CALLS,
-                stepDetails: {
-                    type: StepTypes.TOOL_CALLS,
-                    tool_calls: [],
-                },
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            },
-        });
-        // Delta for an index that has no content part (index 5 has no tool call)
-        aggregateContent({
-            event: GraphEvents.ON_RUN_STEP_DELTA,
-            data: {
-                id: 'step-orphan',
-                delta: {
-                    type: StepTypes.TOOL_CALLS,
-                    tool_calls: [{ args: '{"some":"data"}', name: undefined }],
-                },
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            },
-        });
-        // contentParts[5] should remain undefined or have no valid tool call name
-        const part = contentParts[5];
-        // The part either doesn't exist or has empty name — delta should have been dropped
-        if (part?.tool_call != null) {
-            expect(part.tool_call.name).toBe('');
-        }
-    });
-    it('should handle the full lifecycle: ON_RUN_STEP → deltas → ON_RUN_STEP_COMPLETED', () => {
-        const { contentParts, aggregateContent } = createContentAggregator();
-        // Step 1: Initial tool call
-        aggregateContent({
-            event: GraphEvents.ON_RUN_STEP,
-            data: {
-                id: 'step-write',
-                index: 0,
-                type: StepTypes.TOOL_CALLS,
-                stepDetails: {
-                    type: StepTypes.TOOL_CALLS,
-                    tool_calls: [
-                        { id: 'tc-write', name: 'content_tool', args: '{"action":"write"' },
-                    ],
-                },
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            },
-        });
-        // Step 2: Multiple delta updates growing the args
-        aggregateContent({
-            event: GraphEvents.ON_RUN_STEP_DELTA,
-            data: {
-                id: 'step-write',
-                delta: {
-                    type: StepTypes.TOOL_CALLS,
-                    tool_calls: [{ args: ',"name":"Dashboard.tsx"', name: undefined }],
-                },
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            },
-        });
-        aggregateContent({
-            event: GraphEvents.ON_RUN_STEP_DELTA,
-            data: {
-                id: 'step-write',
-                delta: {
-                    type: StepTypes.TOOL_CALLS,
-                    tool_calls: [{ args: ',"content":"import React', name: undefined }],
-                },
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            },
-        });
-        // Verify args accumulated progressively
-        const midArgs = contentParts[0].tool_call?.args;
-        expect(midArgs).toContain('Dashboard.tsx');
-        expect(midArgs).toContain('import React');
-        // Step 3: Completion with full output
-        aggregateContent({
-            event: GraphEvents.ON_RUN_STEP_COMPLETED,
-            data: {
-                result: {
-                    id: 'step-write',
-                    index: 0,
-                    type: 'tool_call',
-                    tool_call: {
-                        id: 'tc-write',
-                        name: 'content_tool',
-                        args: '{"action":"write","name":"Dashboard.tsx","content":"import React..."}',
-                        output: 'Stored "Dashboard.tsx" (content_id: abc). 176 lines, 5000 chars.',
-                        progress: 1,
-                    },
-                },
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            },
-        });
-        // Final content part should have output and progress=1
-        const final = contentParts[0]
-            .tool_call;
-        expect(final.output).toContain('Stored');
-        expect(final.progress).toBe(1);
-        expect(final.name).toBe('content_tool');
-    });
-});
-//# sourceMappingURL=stream.test.js.map

package/src/test/mockTools.js

@@ -1,340 +0,0 @@
-// src/test/mockTools.ts
-/**
- * Shared mock tools for testing across all test scripts.
- * Centralizes tool definitions to follow DRY principles.
- */
-import { tool } from '@langchain/core/tools';
-// ============================================================================
-// Mock Tool Implementations
-// ============================================================================
-/**
- * Mock get_team_members tool - returns list of team members
- */
-export function createGetTeamMembersTool() {
-    return tool(async () => {
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        return [
-            { id: 'u1', name: 'Alice', department: 'Engineering' },
-            { id: 'u2', name: 'Bob', department: 'Marketing' },
-            { id: 'u3', name: 'Charlie', department: 'Engineering' },
-        ];
-    }, {
-        name: 'get_team_members',
-        description: 'Get list of team members. Returns array of objects with id, name, and department fields.',
-        schema: { type: 'object', properties: {}, required: [] },
-    });
-}
-/**
- * Mock get_expenses tool - returns expense records for a user
- */
-export function createGetExpensesTool() {
-    const expenseData = {
-        u1: [
-            { amount: 150.0, category: 'travel' },
-            { amount: 75.5, category: 'meals' },
-        ],
-        u2: [
-            { amount: 200.0, category: 'marketing' },
-            { amount: 50.0, category: 'meals' },
-            { amount: 300.0, category: 'events' },
-        ],
-        u3: [
-            { amount: 500.0, category: 'equipment' },
-            { amount: 120.0, category: 'travel' },
-            { amount: 80.0, category: 'meals' },
-        ],
-    };
-    return tool(async (input) => {
-        const { user_id } = input;
-        await new Promise((resolve) => setTimeout(resolve, 30));
-        return expenseData[user_id] ?? [];
-    }, {
-        name: 'get_expenses',
-        description: 'Get expense records for a user. Returns array of objects with amount and category fields.',
-        schema: {
-            type: 'object',
-            properties: {
-                user_id: {
-                    type: 'string',
-                    description: 'The user ID to fetch expenses for',
-                },
-            },
-            required: ['user_id'],
-        },
-    });
-}
-/**
- * Mock get_weather tool - returns weather data for a city
- */
-export function createGetWeatherTool() {
-    const weatherData = {
-        'San Francisco': { temperature: 65, condition: 'Foggy' },
-        'New York': { temperature: 75, condition: 'Sunny' },
-        London: { temperature: 55, condition: 'Rainy' },
-        Tokyo: { temperature: 80, condition: 'Humid' },
-        SF: { temperature: 65, condition: 'Foggy' },
-        NYC: { temperature: 75, condition: 'Sunny' },
-    };
-    return tool(async (input) => {
-        const { city } = input;
-        await new Promise((resolve) => setTimeout(resolve, 40));
-        const weather = weatherData[city];
-        if (!weather) {
-            throw new Error(`Weather data not available for city: ${city}`);
-        }
-        return weather;
-    }, {
-        name: 'get_weather',
-        description: 'Get current weather for a city. Returns object with temperature (number) and condition (string) fields.',
-        schema: {
-            type: 'object',
-            properties: {
-                city: { type: 'string', description: 'City name' },
-            },
-            required: ['city'],
-        },
-    });
-}
-/**
- * Mock calculator tool - evaluates mathematical expressions
- */
-export function createCalculatorTool() {
-    return tool(async (input) => {
-        const { expression } = input;
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        // Simple eval for demo (in production, use a proper math parser)
-        const result = eval(expression);
-        return { expression, result };
-    }, {
-        name: 'calculator',
-        description: 'Evaluate a mathematical expression',
-        schema: {
-            type: 'object',
-            properties: {
-                expression: {
-                    type: 'string',
-                    description: 'Mathematical expression to evaluate',
-                },
-            },
-            required: ['expression'],
-        },
-    });
-}
-// ============================================================================
-// Tool Registry Definitions
-// ============================================================================
-/**
- * Creates a tool registry for programmatic tool calling tests.
- * Tools are configured with allowed_callers to demonstrate classification.
- */
-export function createProgrammaticToolRegistry() {
-    const toolDefs = [
-        {
-            name: 'get_team_members',
-            description: 'Get list of team members. Returns array of objects with id, name, and department fields.',
-            parameters: {
-                type: 'object',
-                properties: {},
-                required: [],
-            },
-            allowed_callers: ['code_execution'], // Programmatic-only
-            defer_loading: false,
-        },
-        {
-            name: 'get_expenses',
-            description: 'Get expense records for a user. Returns array of objects with amount and category fields.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    user_id: {
-                        type: 'string',
-                        description: 'The user ID to fetch expenses for',
-                    },
-                },
-                required: ['user_id'],
-            },
-            allowed_callers: ['code_execution'], // Programmatic-only
-            defer_loading: false,
-        },
-        {
-            name: 'get_weather',
-            description: 'Get current weather for a city. Returns object with temperature (number) and condition (string) fields.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    city: {
-                        type: 'string',
-                        description: 'City name',
-                    },
-                },
-                required: ['city'],
-            },
-            allowed_callers: ['direct', 'code_execution'], // Both contexts
-            defer_loading: false,
-        },
-        {
-            name: 'calculator',
-            description: 'Evaluate a mathematical expression',
-            parameters: {
-                type: 'object',
-                properties: {
-                    expression: {
-                        type: 'string',
-                        description: 'Mathematical expression to evaluate',
-                    },
-                },
-                required: ['expression'],
-            },
-            allowed_callers: ['code_execution'], // Programmatic-only
-            defer_loading: false,
-        },
-    ];
-    return new Map(toolDefs.map((t) => [t.name, t]));
-}
-/**
- * Creates a sample tool registry for tool search tests.
- * Includes mix of deferred and non-deferred tools.
- */
-export function createToolSearchToolRegistry() {
-    const tools = [
-        {
-            name: 'get_expenses',
-            description: 'Retrieve expense records from the database. Supports filtering by date range, category, and amount.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    start_date: {
-                        type: 'string',
-                        description: 'Start date for filtering',
-                    },
-                    end_date: { type: 'string', description: 'End date for filtering' },
-                    category: { type: 'string', description: 'Expense category' },
-                },
-            },
-            defer_loading: true,
-        },
-        {
-            name: 'calculate_expense_totals',
-            description: 'Calculate total expenses by category or time period. Returns aggregated financial data.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    group_by: {
-                        type: 'string',
-                        description: 'Group by category or month',
-                    },
-                },
-            },
-            defer_loading: true,
-        },
-        {
-            name: 'create_budget',
-            description: 'Create a new budget plan with spending limits for different categories.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    name: { type: 'string', description: 'Budget name' },
-                    limits: { type: 'object', description: 'Category spending limits' },
-                },
-            },
-            defer_loading: true,
-        },
-        {
-            name: 'get_weather',
-            description: 'Get current weather conditions for a specified location.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    location: { type: 'string', description: 'City or coordinates' },
-                },
-            },
-            defer_loading: true,
-        },
-        {
-            name: 'get_forecast',
-            description: 'Get weather forecast for the next 7 days for a location.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    location: { type: 'string', description: 'City or coordinates' },
-                    days: { type: 'number', description: 'Number of days to forecast' },
-                },
-            },
-            defer_loading: true,
-        },
-        {
-            name: 'send_email',
-            description: 'Send an email to one or more recipients with attachments support.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    to: {
-                        type: 'array',
-                        items: { type: 'string' },
-                        description: 'Recipients',
-                    },
-                    subject: { type: 'string', description: 'Email subject' },
-                    body: { type: 'string', description: 'Email body' },
-                },
-            },
-            defer_loading: true,
-        },
-        {
-            name: 'search_files',
-            description: 'Search for files in the file system by name or content.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    query: { type: 'string', description: 'Search query' },
-                    path: { type: 'string', description: 'Directory to search in' },
-                },
-            },
-            defer_loading: true,
-        },
-        {
-            name: 'run_database_query',
-            description: 'Execute a SQL query against the database and return results.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    query: { type: 'string', description: 'SQL query to execute' },
-                    database: { type: 'string', description: 'Target database' },
-                },
-            },
-            defer_loading: true,
-        },
-        {
-            name: 'generate_report',
-            description: 'Generate a PDF or Excel report from data with customizable templates.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    template: { type: 'string', description: 'Report template name' },
-                    format: { type: 'string', description: 'Output format: pdf or xlsx' },
-                    data: { type: 'object', description: 'Data to include in report' },
-                },
-            },
-            defer_loading: true,
-        },
-        {
-            name: 'translate_text',
-            description: 'Translate text between languages using machine translation.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    text: { type: 'string', description: 'Text to translate' },
-                    source_lang: { type: 'string', description: 'Source language code' },
-                    target_lang: { type: 'string', description: 'Target language code' },
-                },
-            },
-            defer_loading: true,
-        },
-        {
-            name: 'calculator',
-            description: 'Perform mathematical calculations. Supports basic arithmetic and scientific functions.',
-            defer_loading: false, // Not deferred - should be excluded by default
-        },
-    ];
-    return new Map(tools.map((t) => [t.name, t]));
-}
-//# sourceMappingURL=mockTools.js.map