@illuma-ai/agents 1.1.20 → 1.1.22

package/src/tools/__tests__/ProgrammaticToolCalling.test.js

@@ -1,807 +0,0 @@
-// src/tools/__tests__/ProgrammaticToolCalling.test.ts
-/**
- * Unit tests for Programmatic Tool Calling.
- * Tests manual invocation with mock tools and Code API responses.
- */
-import { describe, it, expect, beforeEach } from '@jest/globals';
-import { createProgrammaticToolCallingTool, formatCompletedResponse, extractUsedToolNames, filterToolsByUsage, executeTools, normalizeToPythonIdentifier, unwrapToolResponse, } from '../ProgrammaticToolCalling';
-import { createProgrammaticToolRegistry, createGetTeamMembersTool, createGetExpensesTool, createGetWeatherTool, createCalculatorTool, } from '@/test/mockTools';
-describe('ProgrammaticToolCalling', () => {
-    describe('executeTools', () => {
-        let toolMap;
-        beforeEach(() => {
-            const tools = [
-                createGetTeamMembersTool(),
-                createGetExpensesTool(),
-                createGetWeatherTool(),
-                createCalculatorTool(),
-            ];
-            toolMap = new Map(tools.map((t) => [t.name, t]));
-        });
-        it('executes a single tool successfully', async () => {
-            const toolCalls = [
-                {
-                    id: 'call_001',
-                    name: 'get_weather',
-                    input: { city: 'San Francisco' },
-                },
-            ];
-            const results = await executeTools(toolCalls, toolMap);
-            expect(results).toHaveLength(1);
-            expect(results[0].call_id).toBe('call_001');
-            expect(results[0].is_error).toBe(false);
-            expect(results[0].result).toEqual({
-                temperature: 65,
-                condition: 'Foggy',
-            });
-        });
-        it('executes multiple tools in parallel', async () => {
-            const toolCalls = [
-                {
-                    id: 'call_001',
-                    name: 'get_weather',
-                    input: { city: 'San Francisco' },
-                },
-                {
-                    id: 'call_002',
-                    name: 'get_weather',
-                    input: { city: 'New York' },
-                },
-                {
-                    id: 'call_003',
-                    name: 'get_weather',
-                    input: { city: 'London' },
-                },
-            ];
-            const startTime = Date.now();
-            const results = await executeTools(toolCalls, toolMap);
-            const duration = Date.now() - startTime;
-            // Should execute in parallel (< 150ms total, not 120ms sequential)
-            expect(duration).toBeLessThan(150);
-            expect(results).toHaveLength(3);
-            expect(results[0].is_error).toBe(false);
-            expect(results[1].is_error).toBe(false);
-            expect(results[2].is_error).toBe(false);
-            expect(results[0].result.temperature).toBe(65);
-            expect(results[1].result.temperature).toBe(75);
-            expect(results[2].result.temperature).toBe(55);
-        });
-        it('handles tool not found error', async () => {
-            const toolCalls = [
-                {
-                    id: 'call_001',
-                    name: 'nonexistent_tool',
-                    input: {},
-                },
-            ];
-            const results = await executeTools(toolCalls, toolMap);
-            expect(results).toHaveLength(1);
-            expect(results[0].call_id).toBe('call_001');
-            expect(results[0].is_error).toBe(true);
-            expect(results[0].error_message).toContain('nonexistent_tool');
-            expect(results[0].error_message).toContain('Available tools:');
-        });
-        it('handles tool execution error', async () => {
-            const toolCalls = [
-                {
-                    id: 'call_001',
-                    name: 'get_weather',
-                    input: { city: 'InvalidCity' },
-                },
-            ];
-            const results = await executeTools(toolCalls, toolMap);
-            expect(results).toHaveLength(1);
-            expect(results[0].call_id).toBe('call_001');
-            expect(results[0].is_error).toBe(true);
-            expect(results[0].error_message).toContain('Weather data not available');
-        });
-        it('handles mix of successful and failed tool calls', async () => {
-            const toolCalls = [
-                {
-                    id: 'call_001',
-                    name: 'get_weather',
-                    input: { city: 'San Francisco' },
-                },
-                {
-                    id: 'call_002',
-                    name: 'get_weather',
-                    input: { city: 'InvalidCity' },
-                },
-                {
-                    id: 'call_003',
-                    name: 'get_weather',
-                    input: { city: 'New York' },
-                },
-            ];
-            const results = await executeTools(toolCalls, toolMap);
-            expect(results).toHaveLength(3);
-            expect(results[0].is_error).toBe(false);
-            expect(results[1].is_error).toBe(true);
-            expect(results[2].is_error).toBe(false);
-        });
-        it('executes tools with different parameters', async () => {
-            const toolCalls = [
-                {
-                    id: 'call_001',
-                    name: 'get_team_members',
-                    input: {},
-                },
-                {
-                    id: 'call_002',
-                    name: 'get_expenses',
-                    input: { user_id: 'u1' },
-                },
-                {
-                    id: 'call_003',
-                    name: 'calculator',
-                    input: { expression: '2 + 2 * 3' },
-                },
-            ];
-            const results = await executeTools(toolCalls, toolMap);
-            expect(results).toHaveLength(3);
-            expect(results[0].is_error).toBe(false);
-            expect(results[1].is_error).toBe(false);
-            expect(results[2].is_error).toBe(false);
-            expect(Array.isArray(results[0].result)).toBe(true);
-            expect(results[0].result).toHaveLength(3);
-            expect(Array.isArray(results[1].result)).toBe(true);
-            expect(results[2].result.result).toBe(8);
-        });
-    });
-    describe('normalizeToPythonIdentifier', () => {
-        it('converts hyphens to underscores', () => {
-            expect(normalizeToPythonIdentifier('my-tool-name')).toBe('my_tool_name');
-        });
-        it('converts spaces to underscores', () => {
-            expect(normalizeToPythonIdentifier('my tool name')).toBe('my_tool_name');
-        });
-        it('leaves underscores unchanged', () => {
-            expect(normalizeToPythonIdentifier('my_tool_name')).toBe('my_tool_name');
-        });
-        it('handles mixed hyphens and underscores', () => {
-            expect(normalizeToPythonIdentifier('my-tool_name-v2')).toBe('my_tool_name_v2');
-        });
-        it('handles MCP-style names with hyphens', () => {
-            expect(normalizeToPythonIdentifier('create_spreadsheet_mcp_Google-Workspace')).toBe('create_spreadsheet_mcp_Google_Workspace');
-        });
-        it('removes invalid characters', () => {
-            expect(normalizeToPythonIdentifier('tool@name!v2')).toBe('toolnamev2');
-            expect(normalizeToPythonIdentifier('get.data.v2')).toBe('getdatav2');
-        });
-        it('prefixes with underscore if starts with number', () => {
-            expect(normalizeToPythonIdentifier('123tool')).toBe('_123tool');
-            expect(normalizeToPythonIdentifier('1-tool')).toBe('_1_tool');
-        });
-        it('appends _tool suffix for Python keywords', () => {
-            expect(normalizeToPythonIdentifier('return')).toBe('return_tool');
-            expect(normalizeToPythonIdentifier('async')).toBe('async_tool');
-            expect(normalizeToPythonIdentifier('import')).toBe('import_tool');
-        });
-    });
-    describe('unwrapToolResponse', () => {
-        describe('non-MCP tools', () => {
-            it('returns result as-is for non-MCP tools', () => {
-                const result = { temperature: 65, condition: 'Foggy' };
-                expect(unwrapToolResponse(result, false)).toEqual(result);
-            });
-            it('returns string as-is for non-MCP tools', () => {
-                expect(unwrapToolResponse('plain string', false)).toBe('plain string');
-            });
-            it('returns array as-is for non-MCP tools', () => {
-                const result = [1, 2, 3];
-                expect(unwrapToolResponse(result, false)).toEqual(result);
-            });
-        });
-        describe('MCP tools - tuple format [content, artifacts]', () => {
-            it('extracts string content from tuple', () => {
-                const result = ['Hello world', { artifacts: [] }];
-                expect(unwrapToolResponse(result, true)).toBe('Hello world');
-            });
-            it('parses JSON string content from tuple', () => {
-                const result = ['{"temperature": 65}', { artifacts: [] }];
-                expect(unwrapToolResponse(result, true)).toEqual({ temperature: 65 });
-            });
-            it('parses JSON array string content from tuple', () => {
-                const result = ['[1, 2, 3]', { artifacts: [] }];
-                expect(unwrapToolResponse(result, true)).toEqual([1, 2, 3]);
-            });
-            it('extracts text from single content block in tuple', () => {
-                const result = [{ type: 'text', text: 'Spreadsheet info here' }, {}];
-                expect(unwrapToolResponse(result, true)).toBe('Spreadsheet info here');
-            });
-            it('extracts and parses JSON from single content block in tuple', () => {
-                const result = [
-                    { type: 'text', text: '{"id": "123", "name": "Test"}' },
-                    {},
-                ];
-                expect(unwrapToolResponse(result, true)).toEqual({
-                    id: '123',
-                    name: 'Test',
-                });
-            });
-            it('extracts text from array of content blocks in tuple', () => {
-                const result = [
-                    [
-                        { type: 'text', text: 'Line 1' },
-                        { type: 'text', text: 'Line 2' },
-                    ],
-                    {},
-                ];
-                expect(unwrapToolResponse(result, true)).toBe('Line 1\nLine 2');
-            });
-            it('returns object content as-is when not a text block', () => {
-                const result = [{ temperature: 65, condition: 'Foggy' }, {}];
-                expect(unwrapToolResponse(result, true)).toEqual({
-                    temperature: 65,
-                    condition: 'Foggy',
-                });
-            });
-        });
-        describe('MCP tools - single content block (not in tuple)', () => {
-            it('extracts text from single content block object', () => {
-                const result = { type: 'text', text: 'No data found in range' };
-                expect(unwrapToolResponse(result, true)).toBe('No data found in range');
-            });
-            it('extracts and parses JSON from single content block object', () => {
-                const result = {
-                    type: 'text',
-                    text: '{"sheets": [{"name": "raw_data"}]}',
-                };
-                expect(unwrapToolResponse(result, true)).toEqual({
-                    sheets: [{ name: 'raw_data' }],
-                });
-            });
-            it('handles real-world MCP spreadsheet response', () => {
-                const result = {
-                    type: 'text',
-                    text: 'Spreadsheet: "NYC Taxi - Top Pickup Neighborhoods" (ID: abc123)\nSheets (2):\n  - "raw_data" (ID: 123) | Size: 1000x26',
-                };
-                expect(unwrapToolResponse(result, true)).toBe('Spreadsheet: "NYC Taxi - Top Pickup Neighborhoods" (ID: abc123)\nSheets (2):\n  - "raw_data" (ID: 123) | Size: 1000x26');
-            });
-            it('handles real-world MCP no data response', () => {
-                const result = {
-                    type: 'text',
-                    text: 'No data found in range \'raw_data!A1:D25\' for user@example.com.',
-                };
-                expect(unwrapToolResponse(result, true)).toBe('No data found in range \'raw_data!A1:D25\' for user@example.com.');
-            });
-        });
-        describe('MCP tools - array of content blocks (not in tuple)', () => {
-            it('extracts text from array of content blocks', () => {
-                const result = [
-                    { type: 'text', text: 'First block' },
-                    { type: 'text', text: 'Second block' },
-                ];
-                expect(unwrapToolResponse(result, true)).toBe('First block\nSecond block');
-            });
-            it('filters out non-text blocks', () => {
-                const result = [
-                    { type: 'text', text: 'Text content' },
-                    { type: 'image', data: 'base64...' },
-                    { type: 'text', text: 'More text' },
-                ];
-                expect(unwrapToolResponse(result, true)).toBe('Text content\nMore text');
-            });
-        });
-        describe('edge cases', () => {
-            it('returns non-text block object as-is', () => {
-                const result = { type: 'image', data: 'base64...' };
-                expect(unwrapToolResponse(result, true)).toEqual(result);
-            });
-            it('handles empty array', () => {
-                expect(unwrapToolResponse([], true)).toEqual([]);
-            });
-            it('handles malformed JSON in text block gracefully', () => {
-                const result = { type: 'text', text: '{ invalid json }' };
-                expect(unwrapToolResponse(result, true)).toBe('{ invalid json }');
-            });
-            it('handles null', () => {
-                expect(unwrapToolResponse(null, true)).toBe(null);
-            });
-            it('handles undefined', () => {
-                expect(unwrapToolResponse(undefined, true)).toBe(undefined);
-            });
-        });
-    });
-    describe('extractUsedToolNames', () => {
-        const createToolMap = (names) => {
-            const map = new Map();
-            for (const name of names) {
-                map.set(normalizeToPythonIdentifier(name), name);
-            }
-            return map;
-        };
-        const availableTools = createToolMap([
-            'get_weather',
-            'get_team_members',
-            'get_expenses',
-            'calculator',
-            'search_docs',
-        ]);
-        it('extracts single tool name from simple code', () => {
-            const code = `result = await get_weather(city="SF")
-print(result)`;
-            const used = extractUsedToolNames(code, availableTools);
-            expect(used.size).toBe(1);
-            expect(used.has('get_weather')).toBe(true);
-        });
-        it('extracts multiple tool names from code', () => {
-            const code = `team = await get_team_members()
-for member in team:
-    expenses = await get_expenses(user_id=member['id'])
-    print(f"{member['name']}: {sum(e['amount'] for e in expenses)}")`;
-            const used = extractUsedToolNames(code, availableTools);
-            expect(used.size).toBe(2);
-            expect(used.has('get_team_members')).toBe(true);
-            expect(used.has('get_expenses')).toBe(true);
-        });
-        it('extracts tools from asyncio.gather calls', () => {
-            const code = `results = await asyncio.gather(
-    get_weather(city="SF"),
-    get_weather(city="NYC"),
-    get_expenses(user_id="u1")
-)`;
-            const used = extractUsedToolNames(code, availableTools);
-            expect(used.size).toBe(2);
-            expect(used.has('get_weather')).toBe(true);
-            expect(used.has('get_expenses')).toBe(true);
-        });
-        it('does not match partial tool names', () => {
-            const code = `# Using get_weather_data instead
-result = await get_weather_data(city="SF")`;
-            const used = extractUsedToolNames(code, availableTools);
-            expect(used.has('get_weather')).toBe(false);
-        });
-        it('matches tool names in different contexts', () => {
-            const code = `# direct call
-x = await calculator(expression="1+1")
-# in list comprehension
-results = [await get_weather(city=c) for c in cities]
-# conditional
-if condition:
-    await get_team_members()`;
-            const used = extractUsedToolNames(code, availableTools);
-            expect(used.size).toBe(3);
-            expect(used.has('calculator')).toBe(true);
-            expect(used.has('get_weather')).toBe(true);
-            expect(used.has('get_team_members')).toBe(true);
-        });
-        it('returns empty set when no tools are used', () => {
-            const code = `print("Hello, World!")
-x = 1 + 2`;
-            const used = extractUsedToolNames(code, availableTools);
-            expect(used.size).toBe(0);
-        });
-        it('handles tool names with special characters via normalization', () => {
-            const specialTools = createToolMap(['get_data.v2', 'calc+plus']);
-            const code = `await get_datav2()
-await calcplus()`;
-            const used = extractUsedToolNames(code, specialTools);
-            expect(used.has('get_data.v2')).toBe(true);
-            expect(used.has('calc+plus')).toBe(true);
-        });
-        it('matches hyphenated tool names using underscore in code', () => {
-            const mcpTools = createToolMap([
-                'create_spreadsheet_mcp_Google-Workspace',
-                'search_gmail_mcp_Google-Workspace',
-            ]);
-            const code = `result = await create_spreadsheet_mcp_Google_Workspace(title="Test")
-print(result)`;
-            const used = extractUsedToolNames(code, mcpTools);
-            expect(used.size).toBe(1);
-            expect(used.has('create_spreadsheet_mcp_Google-Workspace')).toBe(true);
-        });
-    });
-    describe('filterToolsByUsage', () => {
-        const allToolDefs = [
-            {
-                name: 'get_weather',
-                description: 'Get weather for a city',
-                parameters: {
-                    type: 'object',
-                    properties: { city: { type: 'string' } },
-                },
-            },
-            {
-                name: 'get_team_members',
-                description: 'Get team members',
-                parameters: { type: 'object', properties: {} },
-            },
-            {
-                name: 'get_expenses',
-                description: 'Get expenses for a user',
-                parameters: {
-                    type: 'object',
-                    properties: { user_id: { type: 'string' } },
-                },
-            },
-            {
-                name: 'calculator',
-                description: 'Evaluate an expression',
-                parameters: {
-                    type: 'object',
-                    properties: { expression: { type: 'string' } },
-                },
-            },
-        ];
-        it('filters to only used tools', () => {
-            const code = `result = await get_weather(city="SF")
-print(result)`;
-            const filtered = filterToolsByUsage(allToolDefs, code);
-            expect(filtered).toHaveLength(1);
-            expect(filtered[0].name).toBe('get_weather');
-        });
-        it('filters to multiple used tools', () => {
-            const code = `team = await get_team_members()
-for member in team:
-    expenses = await get_expenses(user_id=member['id'])`;
-            const filtered = filterToolsByUsage(allToolDefs, code);
-            expect(filtered).toHaveLength(2);
-            expect(filtered.map((t) => t.name).sort()).toEqual([
-                'get_expenses',
-                'get_team_members',
-            ]);
-        });
-        it('returns all tools when no tools are detected', () => {
-            const code = 'print("Hello, World!")';
-            const filtered = filterToolsByUsage(allToolDefs, code);
-            expect(filtered).toHaveLength(4);
-        });
-        it('preserves tool definition structure', () => {
-            const code = 'await calculator(expression="2+2")';
-            const filtered = filterToolsByUsage(allToolDefs, code);
-            expect(filtered).toHaveLength(1);
-            expect(filtered[0]).toEqual(allToolDefs[3]);
-            expect(filtered[0].parameters).toBeDefined();
-            expect(filtered[0].description).toBe('Evaluate an expression');
-        });
-        it('handles empty tool definitions', () => {
-            const code = 'await get_weather(city="SF")';
-            const filtered = filterToolsByUsage([], code);
-            expect(filtered).toHaveLength(0);
-        });
-    });
-    describe('formatCompletedResponse', () => {
-        it('formats response with stdout', () => {
-            const response = {
-                status: 'completed',
-                stdout: 'Hello, World!\n',
-                stderr: '',
-                files: [],
-                session_id: 'sess_abc123',
-            };
-            const [output, artifact] = formatCompletedResponse(response);
-            expect(output).toContain('stdout:\nHello, World!');
-            expect(artifact.session_id).toBe('sess_abc123');
-            expect(artifact.files).toEqual([]);
-        });
-        it('shows empty output message when no stdout', () => {
-            const response = {
-                status: 'completed',
-                stdout: '',
-                stderr: '',
-                files: [],
-                session_id: 'sess_abc123',
-            };
-            const [output] = formatCompletedResponse(response);
-            expect(output).toContain('stdout: Empty. Ensure you\'re writing output explicitly');
-        });
-        it('includes stderr when present', () => {
-            const response = {
-                status: 'completed',
-                stdout: 'Output\n',
-                stderr: 'Warning: deprecated function\n',
-                files: [],
-                session_id: 'sess_abc123',
-            };
-            const [output] = formatCompletedResponse(response);
-            expect(output).toContain('stdout:\nOutput');
-            expect(output).toContain('stderr:\nWarning: deprecated function');
-        });
-        it('formats file information correctly', () => {
-            const response = {
-                status: 'completed',
-                stdout: 'Generated report\n',
-                stderr: '',
-                files: [
-                    { id: '1', name: 'report.pdf' },
-                    { id: '2', name: 'data.csv' },
-                ],
-                session_id: 'sess_abc123',
-            };
-            const [output, artifact] = formatCompletedResponse(response);
-            expect(output).toContain('Generated files:');
-            expect(output).toContain('report.pdf');
-            expect(output).toContain('data.csv');
-            expect(artifact.files).toHaveLength(2);
-            expect(artifact.files).toEqual(response.files);
-        });
-        it('handles image files with special message', () => {
-            const response = {
-                status: 'completed',
-                stdout: '',
-                stderr: '',
-                files: [
-                    { id: '1', name: 'chart.png' },
-                    { id: '2', name: 'photo.jpg' },
-                ],
-                session_id: 'sess_abc123',
-            };
-            const [output] = formatCompletedResponse(response);
-            expect(output).toContain('chart.png');
-            expect(output).toContain('Image is already displayed to the user');
-        });
-    });
-    describe('createProgrammaticToolCallingTool - Manual Invocation', () => {
-        let ptcTool;
-        let toolMap;
-        let toolDefinitions;
-        beforeEach(() => {
-            const tools = [
-                createGetTeamMembersTool(),
-                createGetExpensesTool(),
-                createGetWeatherTool(),
-            ];
-            toolMap = new Map(tools.map((t) => [t.name, t]));
-            toolDefinitions = Array.from(createProgrammaticToolRegistry().values()).filter((t) => ['get_team_members', 'get_expenses', 'get_weather'].includes(t.name));
-            ptcTool = createProgrammaticToolCallingTool({
-                apiKey: 'test-key',
-                baseUrl: 'http://mock-api',
-            });
-        });
-        it('throws error when no toolMap provided', async () => {
-            await expect(ptcTool.invoke({
-                code: 'result = await get_weather(city="SF")\nprint(result)',
-                tools: toolDefinitions,
-                toolMap,
-            })).rejects.toThrow('No toolMap provided');
-        });
-        it('throws error when toolMap is empty', async () => {
-            const args = {
-                code: 'result = await get_weather(city="SF")\nprint(result)',
-                tools: toolDefinitions,
-                toolMap: new Map(),
-            };
-            const toolCall = {
-                name: 'programmatic_tool_calling',
-                args,
-            };
-            await expect(ptcTool.invoke(args, {
-                toolCall,
-            })).rejects.toThrow('No toolMap provided');
-        });
-        it('throws error when no tool definitions provided', async () => {
-            const args = {
-                code: 'result = await get_weather(city="SF")\nprint(result)',
-                // No tools
-            };
-            const toolCall = {
-                name: 'programmatic_code_execution',
-                args,
-                toolMap,
-                // No `toolDefs`
-            };
-            await expect(ptcTool.invoke(args, { toolCall })).rejects.toThrow('No tool definitions provided');
-        });
-        it('uses toolDefs from config when tools not provided', async () => {
-            // Skip this test - requires mocking fetch which has complex typing
-            // This functionality is tested in the live script tests instead
-        });
-    });
-    describe('Tool Classification', () => {
-        it('filters tools by allowed_callers', () => {
-            const registry = createProgrammaticToolRegistry();
-            const codeExecutionTools = Array.from(registry.values()).filter((t) => (t.allowed_callers ?? ['direct']).includes('code_execution'));
-            // get_team_members, get_expenses, calculator: code_execution only
-            const codeOnlyTools = codeExecutionTools.filter((t) => !(t.allowed_callers?.includes('direct') === true));
-            expect(codeOnlyTools.length).toBeGreaterThanOrEqual(3);
-            // get_weather: both direct and code_execution
-            const bothTools = Array.from(registry.values()).filter((t) => t.allowed_callers?.includes('direct') === true &&
-                t.allowed_callers.includes('code_execution'));
-            expect(bothTools.length).toBeGreaterThanOrEqual(1);
-            expect(bothTools.some((t) => t.name === 'get_weather')).toBe(true);
-        });
-    });
-    describe('Error Handling', () => {
-        let toolMap;
-        beforeEach(() => {
-            const tools = [createGetWeatherTool()];
-            toolMap = new Map(tools.map((t) => [t.name, t]));
-        });
-        it('returns error for invalid city without throwing', async () => {
-            const toolCalls = [
-                {
-                    id: 'call_001',
-                    name: 'get_weather',
-                    input: { city: 'InvalidCity' },
-                },
-            ];
-            const results = await executeTools(toolCalls, toolMap);
-            expect(results).toHaveLength(1);
-            expect(results[0].is_error).toBe(true);
-            expect(results[0].result).toBeNull();
-            expect(results[0].error_message).toContain('Weather data not available');
-        });
-        it('continues execution when one tool fails', async () => {
-            const toolCalls = [
-                {
-                    id: 'call_001',
-                    name: 'get_weather',
-                    input: { city: 'San Francisco' },
-                },
-                {
-                    id: 'call_002',
-                    name: 'get_weather',
-                    input: { city: 'InvalidCity' },
-                },
-                {
-                    id: 'call_003',
-                    name: 'get_weather',
-                    input: { city: 'London' },
-                },
-            ];
-            const results = await executeTools(toolCalls, toolMap);
-            expect(results).toHaveLength(3);
-            expect(results[0].is_error).toBe(false);
-            expect(results[1].is_error).toBe(true);
-            expect(results[2].is_error).toBe(false);
-        });
-    });
-    describe('Parallel Execution Performance', () => {
-        let toolMap;
-        beforeEach(() => {
-            const tools = [createGetExpensesTool()];
-            toolMap = new Map(tools.map((t) => [t.name, t]));
-        });
-        it('executes tools in parallel, not sequentially', async () => {
-            const toolCalls = [
-                { id: 'call_001', name: 'get_expenses', input: { user_id: 'u1' } },
-                { id: 'call_002', name: 'get_expenses', input: { user_id: 'u2' } },
-                { id: 'call_003', name: 'get_expenses', input: { user_id: 'u3' } },
-            ];
-            const startTime = Date.now();
-            const results = await executeTools(toolCalls, toolMap);
-            const duration = Date.now() - startTime;
-            // Each tool has 30ms delay
-            // Sequential would be ~90ms, parallel should be ~30-50ms
-            expect(duration).toBeLessThan(80);
-            expect(results).toHaveLength(3);
-            expect(results.every((r) => r.is_error === false)).toBe(true);
-        });
-    });
-    describe('Response Formatting', () => {
-        it('formats stdout-only response', () => {
-            const response = {
-                status: 'completed',
-                stdout: 'Team size: 3\n- Alice\n- Bob\n- Charlie\n',
-                stderr: '',
-                files: [],
-                session_id: 'sess_xyz',
-            };
-            const [output, artifact] = formatCompletedResponse(response);
-            expect(output).toBe('stdout:\nTeam size: 3\n- Alice\n- Bob\n- Charlie');
-            expect(artifact).toEqual({
-                session_id: 'sess_xyz',
-                files: [],
-            });
-        });
-        it('formats response with files', () => {
-            const response = {
-                status: 'completed',
-                stdout: 'Report generated\n',
-                stderr: '',
-                files: [
-                    { id: '1', name: 'report.csv' },
-                    { id: '2', name: 'chart.png' },
-                ],
-                session_id: 'sess_xyz',
-            };
-            const [output, artifact] = formatCompletedResponse(response);
-            expect(output).toContain('Generated files:');
-            expect(output).toContain('report.csv');
-            expect(output).toContain('chart.png');
-            expect(output).toContain('File is already downloaded');
-            expect(output).toContain('Image is already displayed');
-            expect(artifact.files).toHaveLength(2);
-        });
-        it('handles multiple files with correct separators', () => {
-            const response = {
-                status: 'completed',
-                stdout: 'Done\n',
-                stderr: '',
-                files: [
-                    { id: '1', name: 'file1.txt' },
-                    { id: '2', name: 'file2.txt' },
-                ],
-                session_id: 'sess_xyz',
-            };
-            const [output] = formatCompletedResponse(response);
-            // 2 files format: "- /mnt/data/file1.txt | ..., - /mnt/data/file2.txt | ..."
-            expect(output).toContain('file1.txt');
-            expect(output).toContain('file2.txt');
-            expect(output).toContain('- /mnt/data/file1.txt');
-            expect(output).toContain('- /mnt/data/file2.txt');
-        });
-        it('handles many files with newline separators', () => {
-            const response = {
-                status: 'completed',
-                stdout: 'Done\n',
-                stderr: '',
-                files: [
-                    { id: '1', name: 'file1.txt' },
-                    { id: '2', name: 'file2.txt' },
-                    { id: '3', name: 'file3.txt' },
-                    { id: '4', name: 'file4.txt' },
-                ],
-                session_id: 'sess_xyz',
-            };
-            const [output] = formatCompletedResponse(response);
-            // More than 3 files should use newline separators
-            expect(output).toContain('file1.txt');
-            expect(output).toContain('file4.txt');
-            expect(output.match(/,\n/g)?.length).toBeGreaterThanOrEqual(2);
-        });
-    });
-    describe('Tool Data Extraction', () => {
-        let toolMap;
-        beforeEach(() => {
-            const tools = [
-                createGetTeamMembersTool(),
-                createGetExpensesTool(),
-                createCalculatorTool(),
-            ];
-            toolMap = new Map(tools.map((t) => [t.name, t]));
-        });
-        it('extracts correct data from team members tool', async () => {
-            const toolCalls = [
-                { id: 'call_001', name: 'get_team_members', input: {} },
-            ];
-            const results = await executeTools(toolCalls, toolMap);
-            expect(results[0].result).toEqual([
-                { id: 'u1', name: 'Alice', department: 'Engineering' },
-                { id: 'u2', name: 'Bob', department: 'Marketing' },
-                { id: 'u3', name: 'Charlie', department: 'Engineering' },
-            ]);
-        });
-        it('extracts correct data from expenses tool', async () => {
-            const toolCalls = [
-                { id: 'call_001', name: 'get_expenses', input: { user_id: 'u1' } },
-            ];
-            const results = await executeTools(toolCalls, toolMap);
-            expect(results[0].result).toEqual([
-                { amount: 150.0, category: 'travel' },
-                { amount: 75.5, category: 'meals' },
-            ]);
-        });
-        it('handles empty expense data', async () => {
-            const toolCalls = [
-                {
-                    id: 'call_001',
-                    name: 'get_expenses',
-                    input: { user_id: 'nonexistent' },
-                },
-            ];
-            const results = await executeTools(toolCalls, toolMap);
-            expect(results[0].is_error).toBe(false);
-            expect(results[0].result).toEqual([]);
-        });
-        it('calculates correct result', async () => {
-            const toolCalls = [
-                {
-                    id: 'call_001',
-                    name: 'calculator',
-                    input: { expression: '2 + 2 * 3' },
-                },
-                {
-                    id: 'call_002',
-                    name: 'calculator',
-                    input: { expression: '(10 + 5) / 3' },
-                },
-            ];
-            const results = await executeTools(toolCalls, toolMap);
-            expect(results[0].result.result).toBe(8);
-            expect(results[1].result.result).toBe(5);
-        });
-    });
-});
-//# sourceMappingURL=ProgrammaticToolCalling.test.js.map