@illuma-ai/agents 1.1.20 → 1.1.22

package/src/tools/__tests__/ToolNode.recovery.test.js

@@ -1,200 +0,0 @@
-import { z } from 'zod';
-import { tool } from '@langchain/core/tools';
-import { AIMessage } from '@langchain/core/messages';
-import { describe, it, expect } from '@jest/globals';
-import { ToolNode } from '../ToolNode';
-import { StreamingToolCallBuffer } from '../StreamingToolCallBuffer';
-/**
- * Creates a mock content_tool that captures the args it receives.
- * Used to verify that truncated args are recovered from the streaming buffer.
- */
-function createMockContentTool(capturedArgs) {
-    return tool(async (input) => {
-        capturedArgs.push({ ...input });
-        return `Wrote ${input.filename ?? 'file'}`;
-    }, {
-        name: 'content_tool',
-        description: 'Read, write, and manage files',
-        schema: z.object({
-            action: z.string(),
-            filename: z.string().optional(),
-            content: z.string().optional(),
-        }),
-    });
-}
-function createAIMessageWithContentTool(callId, args) {
-    return new AIMessage({
-        content: '',
-        tool_calls: [
-            {
-                id: callId,
-                name: 'content_tool',
-                args,
-            },
-        ],
-    });
-}
-describe('ToolNode truncated arg recovery', () => {
-    it('recovers missing content field from streaming buffer', async () => {
-        const capturedArgs = [];
-        const buffer = new StreamingToolCallBuffer();
-        // Simulate streaming: buffer accumulated the full raw args
-        buffer.append('tc_1', '{"action":"write","filename":"app.tsx","content":"function App() {\\n  return <div>Hello</div>;\\n}"}');
-        buffer.setToolName('tc_1', 'content_tool');
-        const contentTool = createMockContentTool(capturedArgs);
-        const toolNode = new ToolNode({
-            tools: [contentTool],
-            streamingToolCallBuffer: buffer,
-        });
-        // Simulate truncated args: parsePartialJson lost the content field
-        const aiMsg = createAIMessageWithContentTool('tc_1', {
-            action: 'write',
-            filename: 'app.tsx',
-            // content is MISSING — truncated by max_tokens
-        });
-        await toolNode.invoke({ messages: [aiMsg] });
-        expect(capturedArgs).toHaveLength(1);
-        expect(capturedArgs[0].action).toBe('write');
-        expect(capturedArgs[0].filename).toBe('app.tsx');
-        expect(capturedArgs[0].content).toBe('function App() {\n  return <div>Hello</div>;\n}');
-    });
-    it('recovers completely empty args from streaming buffer', async () => {
-        const capturedArgs = [];
-        const buffer = new StreamingToolCallBuffer();
-        // Buffer has full args, but parsePartialJson returned empty object
-        buffer.append('tc_1', '{"action":"write","filename":"test.js","content":"const x = 1;"}');
-        buffer.setToolName('tc_1', 'content_tool');
-        const contentTool = createMockContentTool(capturedArgs);
-        const toolNode = new ToolNode({
-            tools: [contentTool],
-            streamingToolCallBuffer: buffer,
-        });
-        // Empty args — JSON parsing aborted completely
-        const aiMsg = createAIMessageWithContentTool('tc_1', {});
-        await toolNode.invoke({ messages: [aiMsg] });
-        expect(capturedArgs).toHaveLength(1);
-        expect(capturedArgs[0].action).toBe('write');
-        expect(capturedArgs[0].filename).toBe('test.js');
-        expect(capturedArgs[0].content).toBe('const x = 1;');
-    });
-    it('does not modify args when buffer has no entry', async () => {
-        const capturedArgs = [];
-        const buffer = new StreamingToolCallBuffer();
-        // No buffer entry for tc_1
-        const contentTool = createMockContentTool(capturedArgs);
-        const toolNode = new ToolNode({
-            tools: [contentTool],
-            streamingToolCallBuffer: buffer,
-        });
-        const aiMsg = createAIMessageWithContentTool('tc_1', {
-            action: 'read',
-            filename: 'test.js',
-        });
-        await toolNode.invoke({ messages: [aiMsg] });
-        expect(capturedArgs).toHaveLength(1);
-        expect(capturedArgs[0].action).toBe('read');
-        expect(capturedArgs[0].filename).toBe('test.js');
-        expect(capturedArgs[0].content).toBeUndefined();
-    });
-    it('does not overwrite existing parsed values', async () => {
-        const capturedArgs = [];
-        const buffer = new StreamingToolCallBuffer();
-        // Buffer has different values than parsed
-        buffer.append('tc_1', '{"action":"write","filename":"old.tsx","content":"old content"}');
-        const contentTool = createMockContentTool(capturedArgs);
-        const toolNode = new ToolNode({
-            tools: [contentTool],
-            streamingToolCallBuffer: buffer,
-        });
-        // Parsed args have action and filename already
-        const aiMsg = createAIMessageWithContentTool('tc_1', {
-            action: 'write',
-            filename: 'new.tsx',
-            // content is missing — should be recovered
-        });
-        await toolNode.invoke({ messages: [aiMsg] });
-        expect(capturedArgs).toHaveLength(1);
-        expect(capturedArgs[0].action).toBe('write');
-        expect(capturedArgs[0].filename).toBe('new.tsx'); // Keeps parsed value, not buffer value
-        expect(capturedArgs[0].content).toBe('old content'); // Recovered from buffer
-    });
-    it('clears buffer after recovery', async () => {
-        const capturedArgs = [];
-        const buffer = new StreamingToolCallBuffer();
-        buffer.append('tc_1', '{"action":"write","content":"test"}');
-        const contentTool = createMockContentTool(capturedArgs);
-        const toolNode = new ToolNode({
-            tools: [contentTool],
-            streamingToolCallBuffer: buffer,
-        });
-        const aiMsg = createAIMessageWithContentTool('tc_1', { action: 'write' });
-        await toolNode.invoke({ messages: [aiMsg] });
-        // Buffer should be cleared after processing
-        expect(buffer.has('tc_1')).toBe(false);
-    });
-    it('works with tools other than content_tool', async () => {
-        const capturedArgs = [];
-        const buffer = new StreamingToolCallBuffer();
-        buffer.append('tc_1', '{"query":"SELECT * FROM users","database":"prod"}');
-        buffer.setToolName('tc_1', 'sql_query');
-        const sqlTool = tool(async (input) => {
-            capturedArgs.push({ ...input });
-            return 'Results: 42 rows';
-        }, {
-            name: 'sql_query',
-            description: 'Execute SQL query',
-            schema: z.object({
-                query: z.string(),
-                database: z.string().optional(),
-            }),
-        });
-        const toolNode = new ToolNode({
-            tools: [sqlTool],
-            streamingToolCallBuffer: buffer,
-        });
-        // Truncated: only has query, missing database
-        const aiMsg = new AIMessage({
-            content: '',
-            tool_calls: [
-                { id: 'tc_1', name: 'sql_query', args: { query: 'SELECT * FROM users' } },
-            ],
-        });
-        await toolNode.invoke({ messages: [aiMsg] });
-        expect(capturedArgs).toHaveLength(1);
-        expect(capturedArgs[0].query).toBe('SELECT * FROM users');
-        expect(capturedArgs[0].database).toBe('prod');
-    });
-    it('recovers truncated content with newlines and special chars', async () => {
-        const capturedArgs = [];
-        const buffer = new StreamingToolCallBuffer();
-        const largeContent = 'import React from \\"react\\";\\n\\n' +
-            'export default function Dashboard() {\\n' +
-            '  const [count, setCount] = React.useState(0);\\n' +
-            '  return (\\n' +
-            '    <div className=\\"dashboard\\">\\n' +
-            '      <h1>Dashboard</h1>\\n' +
-            '      <button onClick={() => setCount(c => c + 1)}>\\n' +
-            '        Count: {count}\\n' +
-            '      </button>\\n' +
-            '    </div>\\n' +
-            '  );\\n' +
-            '}';
-        buffer.append('tc_1', `{"action":"write","filename":"Dashboard.tsx","content":"${largeContent}"}`);
-        const contentTool = createMockContentTool(capturedArgs);
-        const toolNode = new ToolNode({
-            tools: [contentTool],
-            streamingToolCallBuffer: buffer,
-        });
-        // content_tool with missing content
-        const aiMsg = createAIMessageWithContentTool('tc_1', {
-            action: 'write',
-            filename: 'Dashboard.tsx',
-        });
-        await toolNode.invoke({ messages: [aiMsg] });
-        expect(capturedArgs).toHaveLength(1);
-        expect(capturedArgs[0].content).toContain('import React from "react"');
-        expect(capturedArgs[0].content).toContain('export default function Dashboard()');
-        expect(capturedArgs[0].content).toContain('Count: {count}');
-    });
-});
-//# sourceMappingURL=ToolNode.recovery.test.js.map

package/src/tools/__tests__/ToolNode.session.test.js

@@ -1,319 +0,0 @@
-import { z } from 'zod';
-import { tool } from '@langchain/core/tools';
-import { AIMessage } from '@langchain/core/messages';
-import { describe, it, expect } from '@jest/globals';
-import { ToolNode } from '../ToolNode';
-import { Constants } from '@/common';
-/**
- * Creates a mock execute_code tool that captures the toolCall config it receives.
- * Returns a content_and_artifact response with configurable session/files.
- */
-function createMockCodeTool(options) {
-    const { capturedConfigs, artifact } = options;
-    const defaultArtifact = {
-        session_id: 'new-session-123',
-        files: [],
-    };
-    return tool(async (_input, config) => {
-        capturedConfigs.push({ ...(config.toolCall ?? {}) });
-        return ['stdout:\nhello world\n', artifact ?? defaultArtifact];
-    }, {
-        name: Constants.EXECUTE_CODE,
-        description: 'Execute code in a sandbox',
-        schema: z.object({ lang: z.string(), code: z.string() }),
-        responseFormat: Constants.CONTENT_AND_ARTIFACT,
-    });
-}
-function createAIMessageWithCodeCall(callId) {
-    return new AIMessage({
-        content: '',
-        tool_calls: [
-            {
-                id: callId,
-                name: Constants.EXECUTE_CODE,
-                args: { lang: 'python', code: 'print("hello")' },
-            },
-        ],
-    });
-}
-describe('ToolNode code execution session management', () => {
-    describe('session injection via runTool (direct execution)', () => {
-        it('injects session_id and _injected_files when session has files', async () => {
-            const capturedConfigs = [];
-            const sessions = new Map();
-            sessions.set(Constants.EXECUTE_CODE, {
-                session_id: 'prev-session-abc',
-                files: [
-                    { id: 'file1', name: 'data.csv', session_id: 'prev-session-abc' },
-                    { id: 'file2', name: 'chart.png', session_id: 'prev-session-abc' },
-                ],
-                lastUpdated: Date.now(),
-            });
-            const mockTool = createMockCodeTool({ capturedConfigs });
-            const toolNode = new ToolNode({ tools: [mockTool], sessions });
-            const aiMsg = createAIMessageWithCodeCall('call_1');
-            await toolNode.invoke({ messages: [aiMsg] });
-            expect(capturedConfigs).toHaveLength(1);
-            expect(capturedConfigs[0].session_id).toBe('prev-session-abc');
-            expect(capturedConfigs[0]._injected_files).toEqual([
-                { session_id: 'prev-session-abc', id: 'file1', name: 'data.csv' },
-                { session_id: 'prev-session-abc', id: 'file2', name: 'chart.png' },
-            ]);
-        });
-        it('injects session_id even when session has no tracked files', async () => {
-            const capturedConfigs = [];
-            const sessions = new Map();
-            sessions.set(Constants.EXECUTE_CODE, {
-                session_id: 'prev-session-no-files',
-                files: [],
-                lastUpdated: Date.now(),
-            });
-            const mockTool = createMockCodeTool({ capturedConfigs });
-            const toolNode = new ToolNode({ tools: [mockTool], sessions });
-            const aiMsg = createAIMessageWithCodeCall('call_2');
-            await toolNode.invoke({ messages: [aiMsg] });
-            expect(capturedConfigs).toHaveLength(1);
-            expect(capturedConfigs[0].session_id).toBe('prev-session-no-files');
-            expect(capturedConfigs[0]._injected_files).toBeUndefined();
-        });
-        it('does not inject session context when no session exists', async () => {
-            const capturedConfigs = [];
-            const sessions = new Map();
-            const mockTool = createMockCodeTool({ capturedConfigs });
-            const toolNode = new ToolNode({ tools: [mockTool], sessions });
-            const aiMsg = createAIMessageWithCodeCall('call_3');
-            await toolNode.invoke({ messages: [aiMsg] });
-            expect(capturedConfigs).toHaveLength(1);
-            expect(capturedConfigs[0].session_id).toBeUndefined();
-            expect(capturedConfigs[0]._injected_files).toBeUndefined();
-        });
-        it('preserves per-file session_id for multi-session files', async () => {
-            const capturedConfigs = [];
-            const sessions = new Map();
-            sessions.set(Constants.EXECUTE_CODE, {
-                session_id: 'session-B',
-                files: [
-                    { id: 'f1', name: 'old.csv', session_id: 'session-A' },
-                    { id: 'f2', name: 'new.png', session_id: 'session-B' },
-                ],
-                lastUpdated: Date.now(),
-            });
-            const mockTool = createMockCodeTool({ capturedConfigs });
-            const toolNode = new ToolNode({ tools: [mockTool], sessions });
-            const aiMsg = createAIMessageWithCodeCall('call_4');
-            await toolNode.invoke({ messages: [aiMsg] });
-            const files = capturedConfigs[0]._injected_files;
-            expect(files[0].session_id).toBe('session-A');
-            expect(files[1].session_id).toBe('session-B');
-        });
-    });
-    describe('getCodeSessionContext (via dispatchToolEvents request building)', () => {
-        it('builds session context with files for event-driven requests', () => {
-            const sessions = new Map();
-            sessions.set(Constants.EXECUTE_CODE, {
-                session_id: 'evt-session',
-                files: [{ id: 'ef1', name: 'out.parquet', session_id: 'evt-session' }],
-                lastUpdated: Date.now(),
-            });
-            const mockTool = createMockCodeTool({ capturedConfigs: [] });
-            const toolNode = new ToolNode({
-                tools: [mockTool],
-                sessions,
-                eventDrivenMode: true,
-            });
-            const context = toolNode.getCodeSessionContext();
-            expect(context).toEqual({
-                session_id: 'evt-session',
-                files: [{ session_id: 'evt-session', id: 'ef1', name: 'out.parquet' }],
-            });
-        });
-        it('builds session context without files when session has no tracked files', () => {
-            const sessions = new Map();
-            sessions.set(Constants.EXECUTE_CODE, {
-                session_id: 'evt-session-empty',
-                files: [],
-                lastUpdated: Date.now(),
-            });
-            const mockTool = createMockCodeTool({ capturedConfigs: [] });
-            const toolNode = new ToolNode({
-                tools: [mockTool],
-                sessions,
-                eventDrivenMode: true,
-            });
-            const context = toolNode.getCodeSessionContext();
-            expect(context).toEqual({ session_id: 'evt-session-empty' });
-        });
-        it('returns undefined when no session exists', () => {
-            const sessions = new Map();
-            const mockTool = createMockCodeTool({ capturedConfigs: [] });
-            const toolNode = new ToolNode({
-                tools: [mockTool],
-                sessions,
-                eventDrivenMode: true,
-            });
-            const context = toolNode.getCodeSessionContext();
-            expect(context).toBeUndefined();
-        });
-    });
-    describe('storeCodeSessionFromResults (session storage from artifacts)', () => {
-        it('stores session with files from code execution results', () => {
-            const sessions = new Map();
-            const mockTool = createMockCodeTool({ capturedConfigs: [] });
-            const toolNode = new ToolNode({
-                tools: [mockTool],
-                sessions,
-                eventDrivenMode: true,
-            });
-            const storeMethod = toolNode.storeCodeSessionFromResults.bind(toolNode);
-            storeMethod([
-                {
-                    toolCallId: 'tc1',
-                    content: 'output',
-                    artifact: {
-                        session_id: 'new-sess',
-                        files: [{ id: 'f1', name: 'result.csv' }],
-                    },
-                    status: 'success',
-                },
-            ], [{ id: 'tc1', name: Constants.EXECUTE_CODE, args: {} }]);
-            const stored = sessions.get(Constants.EXECUTE_CODE);
-            expect(stored).toBeDefined();
-            expect(stored.session_id).toBe('new-sess');
-            expect(stored.files).toHaveLength(1);
-            expect(stored.files[0]).toEqual(expect.objectContaining({
-                id: 'f1',
-                name: 'result.csv',
-                session_id: 'new-sess',
-            }));
-        });
-        it('stores session_id even when Code API returns no files', () => {
-            const sessions = new Map();
-            const mockTool = createMockCodeTool({ capturedConfigs: [] });
-            const toolNode = new ToolNode({
-                tools: [mockTool],
-                sessions,
-                eventDrivenMode: true,
-            });
-            const storeMethod = toolNode.storeCodeSessionFromResults.bind(toolNode);
-            storeMethod([
-                {
-                    toolCallId: 'tc2',
-                    content: 'stdout:\nSaved parquet\n',
-                    artifact: { session_id: 'parquet-session', files: [] },
-                    status: 'success',
-                },
-            ], [{ id: 'tc2', name: Constants.EXECUTE_CODE, args: {} }]);
-            const stored = sessions.get(Constants.EXECUTE_CODE);
-            expect(stored).toBeDefined();
-            expect(stored.session_id).toBe('parquet-session');
-            expect(stored.files).toEqual([]);
-        });
-        it('merges new files with existing session, replacing same-name files', () => {
-            const sessions = new Map();
-            sessions.set(Constants.EXECUTE_CODE, {
-                session_id: 'old-sess',
-                files: [
-                    { id: 'f1', name: 'data.csv', session_id: 'old-sess' },
-                    { id: 'f2', name: 'chart.png', session_id: 'old-sess' },
-                ],
-                lastUpdated: Date.now(),
-            });
-            const mockTool = createMockCodeTool({ capturedConfigs: [] });
-            const toolNode = new ToolNode({
-                tools: [mockTool],
-                sessions,
-                eventDrivenMode: true,
-            });
-            const storeMethod = toolNode.storeCodeSessionFromResults.bind(toolNode);
-            storeMethod([
-                {
-                    toolCallId: 'tc3',
-                    content: 'output',
-                    artifact: {
-                        session_id: 'new-sess',
-                        files: [{ id: 'f3', name: 'chart.png' }],
-                    },
-                    status: 'success',
-                },
-            ], [{ id: 'tc3', name: Constants.EXECUTE_CODE, args: {} }]);
-            const stored = sessions.get(Constants.EXECUTE_CODE);
-            expect(stored.session_id).toBe('new-sess');
-            expect(stored.files).toHaveLength(2);
-            const csvFile = stored.files.find((f) => f.name === 'data.csv');
-            expect(csvFile.session_id).toBe('old-sess');
-            const chartFile = stored.files.find((f) => f.name === 'chart.png');
-            expect(chartFile.id).toBe('f3');
-            expect(chartFile.session_id).toBe('new-sess');
-        });
-        it('preserves existing files when new execution has no files', () => {
-            const sessions = new Map();
-            sessions.set(Constants.EXECUTE_CODE, {
-                session_id: 'old-sess',
-                files: [{ id: 'f1', name: 'data.csv', session_id: 'old-sess' }],
-                lastUpdated: Date.now(),
-            });
-            const mockTool = createMockCodeTool({ capturedConfigs: [] });
-            const toolNode = new ToolNode({
-                tools: [mockTool],
-                sessions,
-                eventDrivenMode: true,
-            });
-            const storeMethod = toolNode.storeCodeSessionFromResults.bind(toolNode);
-            storeMethod([
-                {
-                    toolCallId: 'tc4',
-                    content: 'stdout:\nno files generated\n',
-                    artifact: { session_id: 'new-sess', files: [] },
-                    status: 'success',
-                },
-            ], [{ id: 'tc4', name: Constants.EXECUTE_CODE, args: {} }]);
-            const stored = sessions.get(Constants.EXECUTE_CODE);
-            expect(stored.session_id).toBe('new-sess');
-            expect(stored.files).toHaveLength(1);
-            expect(stored.files[0].name).toBe('data.csv');
-        });
-        it('ignores non-code-execution tool results', () => {
-            const sessions = new Map();
-            const mockTool = createMockCodeTool({ capturedConfigs: [] });
-            const toolNode = new ToolNode({
-                tools: [mockTool],
-                sessions,
-                eventDrivenMode: true,
-            });
-            const storeMethod = toolNode.storeCodeSessionFromResults.bind(toolNode);
-            storeMethod([
-                {
-                    toolCallId: 'tc5',
-                    content: 'search results',
-                    artifact: { session_id: 'should-not-store' },
-                    status: 'success',
-                },
-            ], [{ id: 'tc5', name: 'web_search', args: {} }]);
-            expect(sessions.has(Constants.EXECUTE_CODE)).toBe(false);
-        });
-        it('ignores error results', () => {
-            const sessions = new Map();
-            const mockTool = createMockCodeTool({ capturedConfigs: [] });
-            const toolNode = new ToolNode({
-                tools: [mockTool],
-                sessions,
-                eventDrivenMode: true,
-            });
-            const storeMethod = toolNode.storeCodeSessionFromResults.bind(toolNode);
-            storeMethod([
-                {
-                    toolCallId: 'tc6',
-                    content: '',
-                    artifact: {
-                        session_id: 'error-session',
-                        files: [{ id: 'f1', name: 'x' }],
-                    },
-                    status: 'error',
-                    errorMessage: 'execution failed',
-                },
-            ], [{ id: 'tc6', name: Constants.EXECUTE_CODE, args: {} }]);
-            expect(sessions.has(Constants.EXECUTE_CODE)).toBe(false);
-        });
-    });
-});
-//# sourceMappingURL=ToolNode.session.test.js.map

package/src/tools/__tests__/ToolSearch.integration.test.js

@@ -1,125 +0,0 @@
-// src/tools/__tests__/ToolSearch.integration.test.ts
-/**
- * Integration tests for Tool Search Regex.
- * These tests hit the LIVE Code API and verify end-to-end search functionality.
- *
- * Run with: npm test -- ToolSearch.integration.test.ts
- *
- * Requires CODE_EXECUTOR_API_KEY environment variable.
- * Tests are skipped when the API key is not available.
- */
-import { config as dotenvConfig } from 'dotenv';
-dotenvConfig();
-import { describe, it, expect, beforeAll } from '@jest/globals';
-import { createToolSearch } from '../ToolSearch';
-import { createToolSearchToolRegistry } from '@/test/mockTools';
-const apiKey = process.env.CODE_EXECUTOR_API_KEY;
-const shouldSkip = apiKey == null || apiKey === '';
-const describeIfApiKey = shouldSkip ? describe.skip : describe;
-describeIfApiKey('ToolSearch - Live API Integration', () => {
-    let searchTool;
-    const toolRegistry = createToolSearchToolRegistry();
-    beforeAll(() => {
-        searchTool = createToolSearch({ apiKey: apiKey, toolRegistry });
-    });
-    it('searches for expense-related tools', async () => {
-        const output = await searchTool.invoke({ query: 'expense' });
-        expect(typeof output).toBe('string');
-        expect(output).toContain('Found');
-        expect(output).toContain('matching tools');
-        expect(output).toContain('get_expenses');
-        expect(output).toContain('calculate_expense_totals');
-        expect(output).toContain('score: 0.95');
-    }, 10000);
-    it('searches for weather tools with OR pattern', async () => {
-        const output = await searchTool.invoke({ query: 'weather|forecast' });
-        expect(output).toContain('Found');
-        expect(output).toContain('get_weather');
-        expect(output).toContain('get_forecast');
-    }, 10000);
-    it('performs case-insensitive search', async () => {
-        const output = await searchTool.invoke({ query: 'EMAIL' });
-        expect(output).toContain('send_email');
-    }, 10000);
-    it('searches descriptions only', async () => {
-        const output = await searchTool.invoke({
-            query: 'database',
-            fields: ['description'],
-        });
-        expect(output).toContain('Found');
-        expect(output).toContain('Matched in: description');
-        expect(output).toContain('run_database_query');
-    }, 10000);
-    it('searches parameter names', async () => {
-        const output = await searchTool.invoke({
-            query: 'query',
-            fields: ['parameters'],
-        });
-        expect(output).toContain('Found');
-        expect(output).toContain('Matched in: parameters');
-    }, 10000);
-    it('limits results to specified count', async () => {
-        const output = await searchTool.invoke({
-            query: 'get',
-            max_results: 2,
-        });
-        expect(output).toContain('Found 2 matching tools');
-        const toolMatches = output.match(/- \w+ \(score:/g);
-        expect(toolMatches?.length).toBe(2);
-    }, 10000);
-    it('returns no matches for nonsense pattern', async () => {
-        const output = await searchTool.invoke({
-            query: 'xyznonexistent999',
-        });
-        expect(output).toContain('No tools matched');
-        expect(output).toContain('Total tools searched:');
-    }, 10000);
-    it('uses regex character classes', async () => {
-        const output = await searchTool.invoke({ query: 'get_[a-z]+' });
-        expect(output).toContain('Found');
-        expect(output).toContain('matching tools');
-    }, 10000);
-    it('sanitizes dangerous patterns with warning', async () => {
-        const output = await searchTool.invoke({ query: '(a+)+' });
-        expect(output).toContain('Note: The provided pattern was converted to a literal search for safety');
-        // After sanitization, pattern is shown in the output
-        expect(output).toContain('Total tools searched:');
-        expect(output).toContain('No tools matched');
-    }, 10000);
-    it('searches across all fields', async () => {
-        const output = await searchTool.invoke({
-            query: 'text',
-            fields: ['name', 'description', 'parameters'],
-        });
-        expect(output).toContain('Found');
-        expect(output).toContain('translate_text');
-    }, 10000);
-    it('handles complex regex patterns', async () => {
-        const output = await searchTool.invoke({
-            query: '^(get|create)_.*',
-        });
-        expect(output).toContain('Found');
-        expect(output).toContain('matching tools');
-    }, 10000);
-    it('prioritizes name matches over description matches', async () => {
-        const output = await searchTool.invoke({ query: 'generate' });
-        expect(output).toContain('generate_report');
-        expect(output).toContain('score:');
-        const lines = output.split('\n');
-        const generateLine = lines.find((l) => l.includes('generate_report'));
-        expect(generateLine).toContain('score: 0.95'); // Name match = 0.95
-    }, 10000);
-    it('finds tools by partial name match', async () => {
-        const output = await searchTool.invoke({ query: 'budget' });
-        expect(output).toContain('create_budget');
-    }, 10000);
-    it('handles very specific patterns', async () => {
-        const output = await searchTool.invoke({
-            query: 'send_email',
-        });
-        expect(output).toContain('Found');
-        expect(output).toContain('send_email');
-        expect(output).toContain('score: 0.95');
-    }, 10000);
-});
-//# sourceMappingURL=ToolSearch.integration.test.js.map