@machina.ai/cell-cli-core 1.19.4-rc3 → 1.22.5-rc1

package/dist/src/core/coreToolScheduler.test.js

@@ -5,12 +5,14 @@
  */
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { CoreToolScheduler, convertToFunctionResponse, truncateAndSaveToFile, } from './coreToolScheduler.js';
-import { DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES, DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD, BaseDeclarativeTool, BaseToolInvocation, ToolConfirmationOutcome, Kind, ApprovalMode, } from '../index.js';
+import { DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES, DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD, BaseDeclarativeTool, BaseToolInvocation, ToolConfirmationOutcome, Kind, ApprovalMode, HookSystem, } from '../index.js';
+import { createMockMessageBus } from '../test-utils/mock-message-bus.js';
 import { MockModifiableTool, MockTool, MOCK_TOOL_SHOULD_CONFIRM_EXECUTE, } from '../test-utils/mock-tool.js';
 import * as modifiableToolModule from '../tools/modifiable-tool.js';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { isShellInvocationAllowlisted } from '../utils/shell-utils.js';
+import { isShellInvocationAllowlisted } from '../utils/shell-permissions.js';
+import { DEFAULT_GEMINI_MODEL, PREVIEW_GEMINI_MODEL, } from '../config/models.js';
 vi.mock('fs/promises', () => ({
     writeFile: vi.fn(),
 }));
@@ -142,6 +144,7 @@ function createMockConfig(overrides = {}) {
         getSessionId: () => 'test-session-id',
         getUsageStatisticsEnabled: () => true,
         getDebugMode: () => false,
+        isInteractive: () => true,
         getApprovalMode: () => ApprovalMode.DEFAULT,
         setApprovalMode: () => { },
         getAllowedTools: () => [],
@@ -159,10 +162,12 @@ function createMockConfig(overrides = {}) {
         getTruncateToolOutputThreshold: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD,
         getTruncateToolOutputLines: () => DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
         getToolRegistry: () => defaultToolRegistry,
+        getActiveModel: () => DEFAULT_GEMINI_MODEL,
         getUseSmartEdit: () => false,
         getGeminiClient: () => null,
         getEnableMessageBusIntegration: () => false,
         getMessageBus: () => null,
+        getEnableHooks: () => false,
         getPolicyEngine: () => null,
         getExperiments: () => { },
     };
@@ -255,7 +260,7 @@ describe('CoreToolScheduler', () => {
         const onToolCallsUpdate = vi.fn();
         const mockConfig = createMockConfig({
             getToolRegistry: () => mockToolRegistry,
-            isInteractive: () => false,
+            getHookSystem: () => undefined,
         });
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
@@ -344,7 +349,7 @@ describe('CoreToolScheduler', () => {
         const onToolCallsUpdate = vi.fn();
         const mockConfig = createMockConfig({
             getToolRegistry: () => mockToolRegistry,
-            isInteractive: () => false,
+            getHookSystem: () => undefined,
         });
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
@@ -437,6 +442,57 @@ describe('CoreToolScheduler', () => {
         const statuses = onToolCallsUpdate.mock.calls.flatMap((call) => call[0].map((toolCall) => toolCall.status));
         expect(statuses).not.toContain('error');
     });
+    it('should error when tool requires confirmation in non-interactive mode', async () => {
+        const mockTool = new MockTool({
+            name: 'mockTool',
+            shouldConfirmExecute: MOCK_TOOL_SHOULD_CONFIRM_EXECUTE,
+        });
+        const declarativeTool = mockTool;
+        const mockToolRegistry = {
+            getTool: () => declarativeTool,
+            getFunctionDeclarations: () => [],
+            tools: new Map(),
+            discovery: {},
+            registerTool: () => { },
+            getToolByName: () => declarativeTool,
+            getToolByDisplayName: () => declarativeTool,
+            getTools: () => [],
+            discoverTools: async () => { },
+            getAllTools: () => [],
+            getToolsByServer: () => [],
+        };
+        const onAllToolCallsComplete = vi.fn();
+        const onToolCallsUpdate = vi.fn();
+        const mockConfig = createMockConfig({
+            getToolRegistry: () => mockToolRegistry,
+            isInteractive: () => false,
+        });
+        const scheduler = new CoreToolScheduler({
+            config: mockConfig,
+            onAllToolCallsComplete,
+            onToolCallsUpdate,
+            getPreferredEditor: () => 'vscode',
+        });
+        const abortController = new AbortController();
+        const request = {
+            callId: '1',
+            name: 'mockTool',
+            args: {},
+            isClientInitiated: false,
+            prompt_id: 'prompt-id-1',
+        };
+        await scheduler.schedule([request], abortController.signal);
+        expect(onAllToolCallsComplete).toHaveBeenCalled();
+        const completedCalls = onAllToolCallsComplete.mock
+            .calls[0][0];
+        expect(completedCalls[0].status).toBe('error');
+        const erroredCall = completedCalls[0];
+        const errorResponse = erroredCall.response;
+        const errorParts = errorResponse.responseParts;
+        // @ts-expect-error - accessing internal structure of FunctionResponsePart
+        const errorMessage = errorParts[0].functionResponse.response.error;
+        expect(errorMessage).toContain('Tool execution for "mockTool" requires user confirmation, which is not supported in non-interactive mode.');
+    });
     describe('getToolSuggestion', () => {
         it('should suggest the top N closest tool names for a typo', () => {
             // Create mocked tool registry
@@ -489,8 +545,13 @@ describe('CoreToolScheduler with payload', () => {
         const onToolCallsUpdate = vi.fn();
         const mockConfig = createMockConfig({
             getToolRegistry: () => mockToolRegistry,
-            isInteractive: () => false,
         });
+        const mockMessageBus = createMockMessageBus();
+        mockConfig.getMessageBus = vi.fn().mockReturnValue(mockMessageBus);
+        mockConfig.getEnableHooks = vi.fn().mockReturnValue(false);
+        mockConfig.getHookSystem = vi
+            .fn()
+            .mockReturnValue(new HookSystem(mockConfig));
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
             onAllToolCallsComplete,
@@ -529,7 +590,7 @@ describe('convertToFunctionResponse', () => {
     const callId = 'call1';
     it('should handle simple string llmContent', () => {
         const llmContent = 'Simple text output';
-        const result = convertToFunctionResponse(toolName, callId, llmContent);
+        const result = convertToFunctionResponse(toolName, callId, llmContent, DEFAULT_GEMINI_MODEL);
         expect(result).toEqual([
             {
                 functionResponse: {
@@ -542,7 +603,7 @@ describe('convertToFunctionResponse', () => {
     });
     it('should handle llmContent as a single Part with text', () => {
         const llmContent = { text: 'Text from Part object' };
-        const result = convertToFunctionResponse(toolName, callId, llmContent);
+        const result = convertToFunctionResponse(toolName, callId, llmContent, DEFAULT_GEMINI_MODEL);
         expect(result).toEqual([
             {
                 functionResponse: {
@@ -555,7 +616,7 @@ describe('convertToFunctionResponse', () => {
     });
     it('should handle llmContent as a PartListUnion array with a single text Part', () => {
         const llmContent = [{ text: 'Text from array' }];
-        const result = convertToFunctionResponse(toolName, callId, llmContent);
+        const result = convertToFunctionResponse(toolName, callId, llmContent, DEFAULT_GEMINI_MODEL);
         expect(result).toEqual([
             {
                 functionResponse: {
@@ -566,94 +627,144 @@ describe('convertToFunctionResponse', () => {
             },
         ]);
     });
-    it('should handle llmContent with inlineData', () => {
+    it('should handle llmContent as a PartListUnion array with multiple Parts', () => {
+        const llmContent = [{ text: 'part1' }, { text: 'part2' }];
+        const result = convertToFunctionResponse(toolName, callId, llmContent, DEFAULT_GEMINI_MODEL);
+        expect(result).toEqual([
+            {
+                functionResponse: {
+                    name: toolName,
+                    id: callId,
+                    response: { output: 'part1\npart2' },
+                },
+            },
+        ]);
+    });
+    it('should handle llmContent with fileData for Gemini 3 model (should be siblings)', () => {
         const llmContent = {
-            inlineData: { mimeType: 'image/png', data: 'base64...' },
+            fileData: { mimeType: 'application/pdf', fileUri: 'gs://...' },
         };
-        const result = convertToFunctionResponse(toolName, callId, llmContent);
+        const result = convertToFunctionResponse(toolName, callId, llmContent, PREVIEW_GEMINI_MODEL);
         expect(result).toEqual([
             {
                 functionResponse: {
                     name: toolName,
                     id: callId,
-                    response: {
-                        output: 'Binary content of type image/png was processed.',
-                    },
+                    response: { output: 'Binary content provided (1 item(s)).' },
                 },
             },
             llmContent,
         ]);
     });
-    it('should handle llmContent with fileData', () => {
+    it('should handle llmContent with inlineData for Gemini 3 model (should be nested)', () => {
+        const llmContent = {
+            inlineData: { mimeType: 'image/png', data: 'base64...' },
+        };
+        const result = convertToFunctionResponse(toolName, callId, llmContent, PREVIEW_GEMINI_MODEL);
+        expect(result).toEqual([
+            {
+                functionResponse: {
+                    name: toolName,
+                    id: callId,
+                    response: { output: 'Binary content provided (1 item(s)).' },
+                    parts: [llmContent],
+                },
+            },
+        ]);
+    });
+    it('should handle llmContent with fileData for non-Gemini 3 models', () => {
         const llmContent = {
             fileData: { mimeType: 'application/pdf', fileUri: 'gs://...' },
         };
-        const result = convertToFunctionResponse(toolName, callId, llmContent);
+        const result = convertToFunctionResponse(toolName, callId, llmContent, DEFAULT_GEMINI_MODEL);
         expect(result).toEqual([
             {
                 functionResponse: {
                     name: toolName,
                     id: callId,
-                    response: {
-                        output: 'Binary content of type application/pdf was processed.',
-                    },
+                    response: { output: 'Binary content provided (1 item(s)).' },
                 },
             },
             llmContent,
         ]);
     });
+    it('should preserve existing functionResponse metadata', () => {
+        const innerId = 'inner-call-id';
+        const innerName = 'inner-tool-name';
+        const responseMetadata = {
+            flags: ['flag1'],
+            isError: false,
+            customData: { key: 'value' },
+        };
+        const input = {
+            functionResponse: {
+                id: innerId,
+                name: innerName,
+                response: responseMetadata,
+            },
+        };
+        const result = convertToFunctionResponse(toolName, callId, input, DEFAULT_GEMINI_MODEL);
+        expect(result).toHaveLength(1);
+        expect(result[0].functionResponse).toEqual({
+            id: callId,
+            name: toolName,
+            response: responseMetadata,
+        });
+    });
     it('should handle llmContent as an array of multiple Parts (text and inlineData)', () => {
         const llmContent = [
             { text: 'Some textual description' },
             { inlineData: { mimeType: 'image/jpeg', data: 'base64data...' } },
             { text: 'Another text part' },
         ];
-        const result = convertToFunctionResponse(toolName, callId, llmContent);
+        const result = convertToFunctionResponse(toolName, callId, llmContent, PREVIEW_GEMINI_MODEL);
         expect(result).toEqual([
             {
                 functionResponse: {
                     name: toolName,
                     id: callId,
-                    response: { output: 'Tool execution succeeded.' },
+                    response: {
+                        output: 'Some textual description\nAnother text part',
+                    },
+                    parts: [
+                        { inlineData: { mimeType: 'image/jpeg', data: 'base64data...' } },
+                    ],
                 },
             },
-            ...llmContent,
         ]);
     });
     it('should handle llmContent as an array with a single inlineData Part', () => {
         const llmContent = [
             { inlineData: { mimeType: 'image/gif', data: 'gifdata...' } },
         ];
-        const result = convertToFunctionResponse(toolName, callId, llmContent);
+        const result = convertToFunctionResponse(toolName, callId, llmContent, PREVIEW_GEMINI_MODEL);
         expect(result).toEqual([
             {
                 functionResponse: {
                     name: toolName,
                     id: callId,
-                    response: {
-                        output: 'Binary content of type image/gif was processed.',
-                    },
+                    response: { output: 'Binary content provided (1 item(s)).' },
+                    parts: llmContent,
                 },
             },
-            ...llmContent,
         ]);
     });
     it('should handle llmContent as a generic Part (not text, inlineData, or fileData)', () => {
         const llmContent = { functionCall: { name: 'test', args: {} } };
-        const result = convertToFunctionResponse(toolName, callId, llmContent);
+        const result = convertToFunctionResponse(toolName, callId, llmContent, PREVIEW_GEMINI_MODEL);
         expect(result).toEqual([
             {
                 functionResponse: {
                     name: toolName,
                     id: callId,
-                    response: { output: 'Tool execution succeeded.' },
+                    response: {},
                 },
             },
         ]);
     });
     it('should handle empty string llmContent', () => {
         const llmContent = '';
-        const result = convertToFunctionResponse(toolName, callId, llmContent);
+        const result = convertToFunctionResponse(toolName, callId, llmContent, PREVIEW_GEMINI_MODEL);
         expect(result).toEqual([
             {
                 functionResponse: {
@@ -666,26 +777,26 @@ describe('convertToFunctionResponse', () => {
     });
     it('should handle llmContent as an empty array', () => {
         const llmContent = [];
-        const result = convertToFunctionResponse(toolName, callId, llmContent);
+        const result = convertToFunctionResponse(toolName, callId, llmContent, PREVIEW_GEMINI_MODEL);
         expect(result).toEqual([
             {
                 functionResponse: {
                     name: toolName,
                     id: callId,
-                    response: { output: 'Tool execution succeeded.' },
+                    response: {},
                 },
             },
         ]);
     });
     it('should handle llmContent as a Part with undefined inlineData/fileData/text', () => {
         const llmContent = {}; // An empty part object
-        const result = convertToFunctionResponse(toolName, callId, llmContent);
+        const result = convertToFunctionResponse(toolName, callId, llmContent, PREVIEW_GEMINI_MODEL);
         expect(result).toEqual([
             {
                 functionResponse: {
                     name: toolName,
                     id: callId,
-                    response: { output: 'Tool execution succeeded.' },
+                    response: {},
                 },
             },
         ]);
@@ -745,8 +856,13 @@ describe('CoreToolScheduler edit cancellation', () => {
         const onToolCallsUpdate = vi.fn();
         const mockConfig = createMockConfig({
             getToolRegistry: () => mockToolRegistry,
-            isInteractive: () => false,
         });
+        const mockMessageBus = createMockMessageBus();
+        mockConfig.getMessageBus = vi.fn().mockReturnValue(mockMessageBus);
+        mockConfig.getEnableHooks = vi.fn().mockReturnValue(false);
+        mockConfig.getHookSystem = vi
+            .fn()
+            .mockReturnValue(new HookSystem(mockConfig));
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
             onAllToolCallsComplete,
@@ -815,6 +931,12 @@ describe('CoreToolScheduler YOLO mode', () => {
             getApprovalMode: () => ApprovalMode.YOLO,
             isInteractive: () => false,
         });
+        const mockMessageBus = createMockMessageBus();
+        mockConfig.getMessageBus = vi.fn().mockReturnValue(mockMessageBus);
+        mockConfig.getEnableHooks = vi.fn().mockReturnValue(false);
+        mockConfig.getHookSystem = vi
+            .fn()
+            .mockReturnValue(new HookSystem(mockConfig));
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
             onAllToolCallsComplete,
@@ -889,6 +1011,12 @@ describe('CoreToolScheduler request queueing', () => {
             getApprovalMode: () => ApprovalMode.YOLO, // Use YOLO to avoid confirmation prompts
             isInteractive: () => false,
         });
+        const mockMessageBus = createMockMessageBus();
+        mockConfig.getMessageBus = vi.fn().mockReturnValue(mockMessageBus);
+        mockConfig.getEnableHooks = vi.fn().mockReturnValue(false);
+        mockConfig.getHookSystem = vi
+            .fn()
+            .mockReturnValue(new HookSystem(mockConfig));
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
             onAllToolCallsComplete,
@@ -911,6 +1039,7 @@ describe('CoreToolScheduler request queueing', () => {
             prompt_id: 'prompt-2',
         };
         // Schedule the first call, which will pause execution.
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
         scheduler.schedule([request1], abortController.signal);
         // Wait for the first call to be in the 'executing' state.
         await waitForStatus(onToolCallsUpdate, 'executing');
@@ -983,6 +1112,12 @@ describe('CoreToolScheduler request queueing', () => {
             }),
             isInteractive: () => false,
         });
+        const mockMessageBus = createMockMessageBus();
+        mockConfig.getMessageBus = vi.fn().mockReturnValue(mockMessageBus);
+        mockConfig.getEnableHooks = vi.fn().mockReturnValue(false);
+        mockConfig.getHookSystem = vi
+            .fn()
+            .mockReturnValue(new HookSystem(mockConfig));
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
             onAllToolCallsComplete,
@@ -1069,7 +1204,7 @@ describe('CoreToolScheduler request queueing', () => {
                 terminalHeight: 24,
             }),
             getToolRegistry: () => toolRegistry,
-            isInteractive: () => false,
+            getHookSystem: () => undefined,
         });
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
@@ -1118,8 +1253,13 @@ describe('CoreToolScheduler request queueing', () => {
         const mockConfig = createMockConfig({
             getToolRegistry: () => mockToolRegistry,
             getApprovalMode: () => ApprovalMode.YOLO,
-            isInteractive: () => false,
         });
+        const mockMessageBus = createMockMessageBus();
+        mockConfig.getMessageBus = vi.fn().mockReturnValue(mockMessageBus);
+        mockConfig.getEnableHooks = vi.fn().mockReturnValue(false);
+        mockConfig.getHookSystem = vi
+            .fn()
+            .mockReturnValue(new HookSystem(mockConfig));
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
             onAllToolCallsComplete,
@@ -1160,8 +1300,13 @@ describe('CoreToolScheduler request queueing', () => {
             setApprovalMode: (mode) => {
                 approvalMode = mode;
             },
-            isInteractive: () => false,
         });
+        const mockMessageBus = createMockMessageBus();
+        mockConfig.getMessageBus = vi.fn().mockReturnValue(mockMessageBus);
+        mockConfig.getEnableHooks = vi.fn().mockReturnValue(false);
+        mockConfig.getHookSystem = vi
+            .fn()
+            .mockReturnValue(new HookSystem(mockConfig));
         const testTool = new TestApprovalTool(mockConfig);
         const toolRegistry = {
             getTool: () => testTool,
@@ -1303,6 +1448,12 @@ describe('CoreToolScheduler Sequential Execution', () => {
             getApprovalMode: () => ApprovalMode.YOLO, // Use YOLO to avoid confirmation prompts
             isInteractive: () => false,
         });
+        const mockMessageBus = createMockMessageBus();
+        mockConfig.getMessageBus = vi.fn().mockReturnValue(mockMessageBus);
+        mockConfig.getEnableHooks = vi.fn().mockReturnValue(false);
+        mockConfig.getHookSystem = vi
+            .fn()
+            .mockReturnValue(new HookSystem(mockConfig));
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
             onAllToolCallsComplete,
@@ -1389,6 +1540,12 @@ describe('CoreToolScheduler Sequential Execution', () => {
             getApprovalMode: () => ApprovalMode.YOLO,
             isInteractive: () => false,
         });
+        const mockMessageBus = createMockMessageBus();
+        mockConfig.getMessageBus = vi.fn().mockReturnValue(mockMessageBus);
+        mockConfig.getEnableHooks = vi.fn().mockReturnValue(false);
+        mockConfig.getHookSystem = vi
+            .fn()
+            .mockReturnValue(new HookSystem(mockConfig));
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
             onAllToolCallsComplete,
@@ -1470,6 +1627,12 @@ describe('CoreToolScheduler Sequential Execution', () => {
         const mockConfig = createMockConfig({
             getToolRegistry: () => mockToolRegistry,
         });
+        const mockMessageBus = createMockMessageBus();
+        mockConfig.getMessageBus = vi.fn().mockReturnValue(mockMessageBus);
+        mockConfig.getEnableHooks = vi.fn().mockReturnValue(false);
+        mockConfig.getHookSystem = vi
+            .fn()
+            .mockReturnValue(new HookSystem(mockConfig));
         const scheduler = new CoreToolScheduler({
             config: mockConfig,
             onAllToolCallsComplete,