ai-cli-mcp 2.2.0 → 2.3.1

package/dist/__tests__/process-management.test.js

@@ -76,7 +76,7 @@ describe('Process Management Tests', () => {
         const server = new ClaudeCodeServer();
         return { server, module, handlers };
     }
-    describe('claude_code tool with PID return', () => {
+    describe('run tool with PID return', () => {
         it('should return PID immediately when starting a process', async () => {
             const { handlers } = await setupServer();
             // Create a mock process
@@ -89,7 +89,7 @@ describe('Process Management Tests', () => {
             const callToolHandler = handlers.get('callTool');
             const result = await callToolHandler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: 'test prompt',
                         workFolder: '/tmp'
@@ -99,7 +99,7 @@ describe('Process Management Tests', () => {
             const response = JSON.parse(result.content[0].text);
             expect(response.pid).toBe(12345);
             expect(response.status).toBe('started');
-            expect(response.message).toBe('Claude Code process started successfully');
+            expect(response.message).toBe('claude process started successfully');
         });
         it('should handle process with model parameter', async () => {
             const { handlers } = await setupServer();
@@ -112,7 +112,7 @@ describe('Process Management Tests', () => {
             const callToolHandler = handlers.get('callTool');
             await callToolHandler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: 'test prompt',
                         workFolder: '/tmp',
@@ -137,7 +137,7 @@ describe('Process Management Tests', () => {
             const callToolHandler = handlers.get('callTool');
             const result = await callToolHandler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: japanesePrompt,
                         workFolder: '/tmp'
@@ -152,7 +152,7 @@ describe('Process Management Tests', () => {
             // Verify the prompt is stored correctly in process manager
             const getResult = await callToolHandler({
                 params: {
-                    name: 'get_claude_result',
+                    name: 'get_result',
                     arguments: {
                         pid: 12360
                     }
@@ -197,7 +197,7 @@ describe('Process Management Tests', () => {
             const callToolHandler = handlers.get('callTool');
             const result = await callToolHandler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: longJapanesePrompt,
                         workFolder: '/tmp',
@@ -210,18 +210,18 @@ describe('Process Management Tests', () => {
             expect(response.pid).toBe(12361);
             // Verify spawn was called with the complete long prompt
             expect(mockSpawn).toHaveBeenCalledWith(expect.any(String), expect.arrayContaining(['-p', longJapanesePrompt]), expect.any(Object));
-            // Check list_claude_processes truncates long prompts correctly
+            // Verify list_processes returns basic info
             const listResult = await callToolHandler({
                 params: {
-                    name: 'list_claude_processes',
+                    name: 'list_processes',
                     arguments: {}
                 }
             });
             const processes = JSON.parse(listResult.content[0].text);
             const process = processes.find((p) => p.pid === 12361);
-            expect(process.prompt).toHaveLength(103); // 100 chars + '...'
-            expect(process.prompt.endsWith('...')).toBe(true);
-            expect(process.prompt).toContain('タスク：ファイル管理システムの作成');
+            expect(process.pid).toBe(12361);
+            expect(process.agent).toBe('claude');
+            expect(process.status).toBe('running');
         });
         it('should handle prompts with special characters and escape sequences', async () => {
             const { handlers } = await setupServer();
@@ -242,7 +242,7 @@ Unicodeテスト: 🎌 🗾 ✨
             const callToolHandler = handlers.get('callTool');
             const result = await callToolHandler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: specialPrompt,
                         workFolder: '/tmp'
@@ -265,16 +265,16 @@ Unicodeテスト: 🎌 🗾 ✨
             const callToolHandler = handlers.get('callTool');
             await expect(callToolHandler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: 'test prompt',
                         workFolder: '/tmp/test'
                     }
                 }
-            })).rejects.toThrow('Failed to start Claude CLI process');
+            })).rejects.toThrow('Failed to start claude CLI process');
         });
     });
-    describe('list_claude_processes tool', () => {
+    describe('list_processes tool', () => {
         it('should list all processes', async () => {
             const { handlers } = await setupServer();
             // Start a process first
@@ -288,7 +288,7 @@ Unicodeテスト: 🎌 🗾 ✨
             // Start a process
             await callToolHandler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: 'test prompt for listing',
                         workFolder: '/tmp',
@@ -305,7 +305,7 @@ Unicodeテスト: 🎌 🗾 ✨
             // List processes
             const listResult = await callToolHandler({
                 params: {
-                    name: 'list_claude_processes',
+                    name: 'list_processes',
                     arguments: {}
                 }
             });
@@ -313,11 +313,9 @@ Unicodeテスト: 🎌 🗾 ✨
             expect(processes).toHaveLength(1);
             expect(processes[0].pid).toBe(12347);
             expect(processes[0].status).toBe('running');
-            expect(processes[0].prompt).toContain('test prompt for listing');
-            expect(processes[0].model).toBe('sonnet');
-            expect(processes[0].session_id).toBe('list-test-session-789');
+            expect(processes[0].agent).toBe('claude');
         });
-        it('should truncate long prompts in list', async () => {
+        it('should list process with correct agent type', async () => {
             const { handlers } = await setupServer();
             const mockProcess = new EventEmitter();
             mockProcess.pid = 12348;
@@ -326,13 +324,12 @@ Unicodeテスト: 🎌 🗾 ✨
             mockProcess.kill = vi.fn();
             mockSpawn.mockReturnValue(mockProcess);
             const callToolHandler = handlers.get('callTool');
-            // Start a process with a very long prompt
-            const longPrompt = 'a'.repeat(150);
+            // Start a process
             await callToolHandler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
-                        prompt: longPrompt,
+                        prompt: 'test prompt',
                         workFolder: '/tmp'
                     }
                 }
@@ -340,16 +337,17 @@ Unicodeテスト: 🎌 🗾 ✨
             // List processes
             const listResult = await callToolHandler({
                 params: {
-                    name: 'list_claude_processes',
+                    name: 'list_processes',
                     arguments: {}
                 }
             });
             const processes = JSON.parse(listResult.content[0].text);
-            expect(processes[0].prompt).toHaveLength(103); // 100 chars + '...'
-            expect(processes[0].prompt.endsWith('...')).toBe(true);
+            expect(processes[0].pid).toBe(12348);
+            expect(processes[0].agent).toBe('claude');
+            expect(processes[0].status).toBe('running');
         });
     });
-    describe('get_claude_result tool', () => {
+    describe('get_result tool', () => {
         it('should get process output', async () => {
             const { handlers } = await setupServer();
             const mockProcess = new EventEmitter();
@@ -362,7 +360,7 @@ Unicodeテスト: 🎌 🗾 ✨
             // Start a process
             await callToolHandler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: 'test prompt',
                         workFolder: '/tmp'
@@ -380,7 +378,7 @@ Unicodeテスト: 🎌 🗾 ✨
             // Get result
             const result = await callToolHandler({
                 params: {
-                    name: 'get_claude_result',
+                    name: 'get_result',
                     arguments: {
                         pid: 12349
                     }
@@ -389,7 +387,7 @@ Unicodeテスト: 🎌 🗾 ✨
             const processInfo = JSON.parse(result.content[0].text);
             expect(processInfo.pid).toBe(12349);
             expect(processInfo.status).toBe('running');
-            expect(processInfo.claudeOutput).toEqual(claudeJsonOutput);
+            expect(processInfo.agentOutput).toEqual(claudeJsonOutput);
             expect(processInfo.session_id).toBe('test-session-123');
         });
         it('should show completed status when process exits', async () => {
@@ -404,7 +402,7 @@ Unicodeテスト: 🎌 🗾 ✨
             // Start a process
             await callToolHandler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: 'test prompt',
                         workFolder: '/tmp'
@@ -423,7 +421,7 @@ Unicodeテスト: 🎌 🗾 ✨
             // Get result
             const result = await callToolHandler({
                 params: {
-                    name: 'get_claude_result',
+                    name: 'get_result',
                     arguments: {
                         pid: 12350
                     }
@@ -432,7 +430,7 @@ Unicodeテスト: 🎌 🗾 ✨
             const processInfo = JSON.parse(result.content[0].text);
             expect(processInfo.status).toBe('completed');
             expect(processInfo.exitCode).toBe(0);
-            expect(processInfo.claudeOutput).toEqual(completedJsonOutput);
+            expect(processInfo.agentOutput).toEqual(completedJsonOutput);
             expect(processInfo.session_id).toBe('completed-session-456');
         });
         it('should throw error for non-existent PID', async () => {
@@ -440,7 +438,7 @@ Unicodeテスト: 🎌 🗾 ✨
             const callToolHandler = handlers.get('callTool');
             await expect(callToolHandler({
                 params: {
-                    name: 'get_claude_result',
+                    name: 'get_result',
                     arguments: {
                         pid: 99999
                     }
@@ -452,7 +450,7 @@ Unicodeテスト: 🎌 🗾 ✨
             const callToolHandler = handlers.get('callTool');
             await expect(callToolHandler({
                 params: {
-                    name: 'get_claude_result',
+                    name: 'get_result',
                     arguments: {
                         pid: 'not-a-number'
                     }
@@ -471,7 +469,7 @@ Unicodeテスト: 🎌 🗾 ✨
             // Start a process
             await callToolHandler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: 'test prompt',
                         workFolder: '/tmp'
@@ -484,7 +482,7 @@ Unicodeテスト: 🎌 🗾 ✨
             // Get result
             const result = await callToolHandler({
                 params: {
-                    name: 'get_claude_result',
+                    name: 'get_result',
                     arguments: {
                         pid: 12355
                     }
@@ -499,7 +497,7 @@ Unicodeテスト: 🎌 🗾 ✨
             expect(processInfo.session_id).toBeUndefined();
         });
     });
-    describe('kill_claude_process tool', () => {
+    describe('kill_process tool', () => {
         it('should kill a running process', async () => {
             const { handlers } = await setupServer();
             const mockProcess = new EventEmitter();
@@ -512,7 +510,7 @@ Unicodeテスト: 🎌 🗾 ✨
             // Start a process
             await callToolHandler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: 'test prompt',
                         workFolder: '/tmp'
@@ -522,7 +520,7 @@ Unicodeテスト: 🎌 🗾 ✨
             // Kill the process
             const killResult = await callToolHandler({
                 params: {
-                    name: 'kill_claude_process',
+                    name: 'kill_process',
                     arguments: {
                         pid: 12351
                     }
@@ -545,7 +543,7 @@ Unicodeテスト: 🎌 🗾 ✨
             // Start and complete a process
             await callToolHandler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: 'test prompt',
                         workFolder: '/tmp'
@@ -557,7 +555,7 @@ Unicodeテスト: 🎌 🗾 ✨
             // Try to kill the already completed process
             const killResult = await callToolHandler({
                 params: {
-                    name: 'kill_claude_process',
+                    name: 'kill_process',
                     arguments: {
                         pid: 12352
                     }
@@ -573,7 +571,7 @@ Unicodeテスト: 🎌 🗾 ✨
             const callToolHandler = handlers.get('callTool');
             await expect(callToolHandler({
                 params: {
-                    name: 'kill_claude_process',
+                    name: 'kill_process',
                     arguments: {
                         pid: 99999
                     }
@@ -606,7 +604,7 @@ Unicodeテスト: 🎌 🗾 ✨
             // Start a process
             await callToolHandler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: 'test prompt',
                         workFolder: '/tmp'
@@ -618,7 +616,7 @@ Unicodeテスト: 🎌 🗾 ✨
             // Get result to check error was recorded
             const result = await callToolHandler({
                 params: {
-                    name: 'get_claude_result',
+                    name: 'get_result',
                     arguments: {
                         pid: 12353
                     }

package/dist/__tests__/server.test.js

@@ -23,11 +23,13 @@ vi.mock('@modelcontextprotocol/sdk/types.js', () => ({
         MethodNotFound: 'MethodNotFound',
         InvalidParams: 'InvalidParams'
     },
-    McpError: vi.fn().mockImplementation((code, message) => {
-        const error = new Error(message);
-        error.code = code;
-        return error;
-    })
+    McpError: class extends Error {
+        code;
+        constructor(code, message) {
+            super(message);
+            this.code = code;
+        }
+    }
 }));
 vi.mock('@modelcontextprotocol/sdk/server/index.js', () => ({
     Server: vi.fn().mockImplementation(function () {
@@ -350,12 +352,14 @@ describe('ClaudeCodeServer Unit Tests', () => {
             // Test the handler
             const handler = listToolsCall[1];
             const result = await handler();
-            expect(result.tools).toHaveLength(4);
-            expect(result.tools[0].name).toBe('claude_code');
-            expect(result.tools[0].description).toContain('Claude Code Agent');
-            expect(result.tools[1].name).toBe('list_claude_processes');
-            expect(result.tools[2].name).toBe('get_claude_result');
-            expect(result.tools[3].name).toBe('kill_claude_process');
+            expect(result.tools).toHaveLength(6);
+            expect(result.tools[0].name).toBe('run');
+            expect(result.tools[0].description).toContain('AI Agent Runner');
+            expect(result.tools[1].name).toBe('list_processes');
+            expect(result.tools[2].name).toBe('get_result');
+            expect(result.tools[3].name).toBe('wait');
+            expect(result.tools[4].name).toBe('kill_process');
+            expect(result.tools[5].name).toBe('cleanup_processes');
         });
         it('should handle CallToolRequest', async () => {
             mockHomedir.mockReturnValue('/home/user');
@@ -383,14 +387,14 @@ describe('ClaudeCodeServer Unit Tests', () => {
             const handler = callToolCall[1];
             const result = await handler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: 'test prompt',
                         workFolder: '/tmp'
                     }
                 }
             });
-            // claude_code now returns PID immediately
+            // run now returns PID immediately
             expect(result.content[0].type).toBe('text');
             const response = JSON.parse(result.content[0].text);
             expect(response.pid).toBe(12345);
@@ -410,14 +414,20 @@ describe('ClaudeCodeServer Unit Tests', () => {
             const callToolCall = mockServerInstance.setRequestHandler.mock.calls.find((call) => call[0].name === 'callTool');
             const handler = callToolCall[1];
             // Test missing workFolder
-            await expect(handler({
-                params: {
-                    name: 'claude_code',
-                    arguments: {
-                        prompt: 'test'
+            try {
+                await handler({
+                    params: {
+                        name: 'run',
+                        arguments: {
+                            prompt: 'test'
+                        }
                     }
-                }
-            })).rejects.toThrow('Missing or invalid required parameter: workFolder');
+                });
+                expect.fail('Should have thrown');
+            }
+            catch (error) {
+                expect(error.message).toContain('Missing or invalid required parameter: workFolder');
+            }
         });
         it('should handle non-existent workFolder', async () => {
             mockHomedir.mockReturnValue('/home/user');
@@ -440,15 +450,21 @@ describe('ClaudeCodeServer Unit Tests', () => {
             const callToolCall = mockServerInstance.setRequestHandler.mock.calls.find((call) => call[0].name === 'callTool');
             const handler = callToolCall[1];
             // Should throw error for non-existent workFolder
-            await expect(handler({
-                params: {
-                    name: 'claude_code',
-                    arguments: {
-                        prompt: 'test',
-                        workFolder: '/nonexistent'
+            try {
+                await handler({
+                    params: {
+                        name: 'run',
+                        arguments: {
+                            prompt: 'test',
+                            workFolder: '/nonexistent'
+                        }
                     }
-                }
-            })).rejects.toThrow('Working folder does not exist');
+                });
+                expect.fail('Should have thrown');
+            }
+            catch (error) {
+                expect(error.message).toContain('Working folder does not exist');
+            }
         });
         it('should handle session_id parameter', async () => {
             mockHomedir.mockReturnValue('/home/user');
@@ -474,7 +490,7 @@ describe('ClaudeCodeServer Unit Tests', () => {
             mockSpawn.mockReturnValue(mockProcess);
             const result = await handler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: 'test prompt',
                         workFolder: '/tmp',
@@ -523,7 +539,7 @@ describe('ClaudeCodeServer Unit Tests', () => {
             mockSpawn.mockReturnValue(mockProcess);
             const result = await handler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt_file: '/tmp/prompt.txt',
                         workFolder: '/tmp'
@@ -533,7 +549,7 @@ describe('ClaudeCodeServer Unit Tests', () => {
             // Verify file was read and spawn was called with content
             expect(mockSpawn).toHaveBeenCalledWith(expect.any(String), expect.arrayContaining(['-p', 'Content from file']), expect.any(Object));
         });
-        it('should resolve model aliases when calling claude_code tool', async () => {
+        it('should resolve model aliases when calling run tool', async () => {
             mockHomedir.mockReturnValue('/home/user');
             mockExistsSync.mockReturnValue(true);
             // Set up spawn mock to return a process
@@ -555,7 +571,7 @@ describe('ClaudeCodeServer Unit Tests', () => {
             // Test with haiku alias
             const result = await handler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: 'test prompt',
                         workFolder: '/tmp',
@@ -590,7 +606,7 @@ describe('ClaudeCodeServer Unit Tests', () => {
             // Test with non-alias model name
             const result = await handler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: 'test prompt',
                         workFolder: '/tmp',
@@ -618,7 +634,7 @@ describe('ClaudeCodeServer Unit Tests', () => {
             try {
                 await handler({
                     params: {
-                        name: 'claude_code',
+                        name: 'run',
                         arguments: {
                             prompt: 'test prompt',
                             prompt_file: '/tmp/prompt.txt',
@@ -649,7 +665,7 @@ describe('ClaudeCodeServer Unit Tests', () => {
             try {
                 await handler({
                     params: {
-                        name: 'claude_code',
+                        name: 'run',
                         arguments: {
                             workFolder: '/tmp'
                         }

package/dist/__tests__/validation.test.js

@@ -31,11 +31,14 @@ vi.mock('@modelcontextprotocol/sdk/types.js', () => ({
         MethodNotFound: 'MethodNotFound',
         InvalidParams: 'InvalidParams'
     },
-    McpError: vi.fn().mockImplementation((code, message) => {
-        const error = new Error(message);
-        error.code = code;
-        return error;
-    })
+    McpError: class McpError extends Error {
+        code;
+        constructor(code, message) {
+            super(message);
+            this.code = code;
+            this.name = 'McpError';
+        }
+    }
 }));
 const mockExistsSync = vi.mocked(existsSync);
 const mockHomedir = vi.mocked(homedir);
@@ -164,21 +167,49 @@ describe('Argument Validation Tests', () => {
         });
     });
     describe('Runtime Argument Validation', () => {
-        it('should validate workFolder is a string when provided', async () => {
-            mockHomedir.mockReturnValue('/home/user');
-            mockExistsSync.mockReturnValue(true);
-            setupServerMock();
+        let handlers;
+        let mockServerInstance;
+        async function setupServer() {
+            // Reset modules to ensure fresh import
+            vi.resetModules();
+            // Re-setup mocks after reset
+            const { existsSync } = await import('node:fs');
+            const { homedir } = await import('node:os');
+            vi.mocked(existsSync).mockReturnValue(true);
+            vi.mocked(homedir).mockReturnValue('/home/user');
+            const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
+            vi.mocked(Server).mockImplementation(() => {
+                mockServerInstance = {
+                    setRequestHandler: vi.fn((schema, handler) => {
+                        handlers.set(schema.name, handler);
+                    }),
+                    connect: vi.fn(),
+                    close: vi.fn(),
+                    onerror: undefined
+                };
+                return mockServerInstance;
+            });
             const module = await import('../server.js');
             // @ts-ignore
             const { ClaudeCodeServer } = module;
             const server = new ClaudeCodeServer();
-            const mockServerInstance = vi.mocked(Server).mock.results[0].value;
-            const callToolCall = mockServerInstance.setRequestHandler.mock.calls.find((call) => call[0].name === 'callTool');
-            const handler = callToolCall[1];
+            return { server, handlers };
+        }
+        beforeEach(() => {
+            handlers = new Map();
+            // Re-setup mocks after vi.resetModules() in outer beforeEach
+            mockHomedir.mockReturnValue('/home/user');
+            mockExistsSync.mockReturnValue(true);
+        });
+        it('should validate workFolder is a string when provided', async () => {
+            mockHomedir.mockReturnValue('/home/user');
+            mockExistsSync.mockReturnValue(true);
+            await setupServer();
+            const handler = handlers.get('callTool');
             // Test with non-string workFolder
             await expect(handler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: 'test',
                         workFolder: 123 // Invalid type
@@ -187,26 +218,18 @@ describe('Argument Validation Tests', () => {
             })).rejects.toThrow();
         });
         it('should reject empty string prompt', async () => {
-            mockHomedir.mockReturnValue('/home/user');
-            mockExistsSync.mockReturnValue(true);
-            setupServerMock();
-            const module = await import('../server.js');
-            // @ts-ignore
-            const { ClaudeCodeServer } = module;
-            const server = new ClaudeCodeServer();
-            const mockServerInstance = vi.mocked(Server).mock.results[0].value;
-            const callToolCall = mockServerInstance.setRequestHandler.mock.calls.find((call) => call[0].name === 'callTool');
-            const handler = callToolCall[1];
+            await setupServer();
+            const handler = handlers.get('callTool');
             // Empty string prompt should be rejected
             await expect(handler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: '', // Empty prompt
                         workFolder: '/tmp'
                     }
                 }
-            })).rejects.toThrow('Missing or invalid required parameter: prompt');
+            })).rejects.toThrow('Either prompt or prompt_file must be provided');
         });
     });
 });

package/dist/__tests__/version-print.test.js

@@ -32,7 +32,7 @@ describe('Version Print on First Use', () => {
     });
     it('should print version and startup time only on first use', async () => {
         // First tool call
-        await client.callTool('claude_code', {
+        await client.callTool('run', {
             prompt: 'echo "test 1"',
             workFolder: testDir,
         });
@@ -40,17 +40,17 @@ describe('Version Print on First Use', () => {
         const findVersionCall = (calls) => {
             return calls.find(call => {
                 const str = call[1] || call[0]; // message might be first or second param
-                return typeof str === 'string' && str.includes('claude_code v') && str.includes('started at');
+                return typeof str === 'string' && str.includes('ai_cli_mcp v') && str.includes('started at');
             });
         };
         // Check that version was printed on first use
         const versionCall = findVersionCall(consoleErrorSpy.mock.calls);
         expect(versionCall).toBeDefined();
-        expect(versionCall[1]).toMatch(/claude_code v[0-9]+\.[0-9]+\.[0-9]+ started at \d{4}-\d{2}-\d{2}T/);
+        expect(versionCall[1]).toMatch(/ai_cli_mcp v[0-9]+\.[0-9]+\.[0-9]+ started at \d{4}-\d{2}-\d{2}T/);
         // Clear the spy but keep the spy active
         consoleErrorSpy.mockClear();
         // Second tool call
-        await client.callTool('claude_code', {
+        await client.callTool('run', {
             prompt: 'echo "test 2"',
             workFolder: testDir,
         });
@@ -58,7 +58,7 @@ describe('Version Print on First Use', () => {
         const secondVersionCall = findVersionCall(consoleErrorSpy.mock.calls);
         expect(secondVersionCall).toBeUndefined();
         // Third tool call
-        await client.callTool('claude_code', {
+        await client.callTool('run', {
             prompt: 'echo "test 3"',
             workFolder: testDir,
         });