@google/gemini-cli-core 0.35.0-preview.2 → 0.36.0-nightly.20260321.fc03891a1

package/dist/src/agents/local-executor.test.js

@@ -4,10 +4,33 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
+const { mockSendMessageStream, mockScheduleAgentTools, mockSetSystemInstruction, mockCompress, mockMaybeDiscoverMcpServer, mockStopMcp, } = vi.hoisted(() => ({
+    mockSendMessageStream: vi.fn().mockResolvedValue({
+        async *[Symbol.asyncIterator]() {
+            yield {
+                type: 'chunk',
+                value: { candidates: [] },
+            };
+        },
+    }),
+    mockScheduleAgentTools: vi.fn(),
+    mockSetSystemInstruction: vi.fn(),
+    mockCompress: vi.fn(),
+    mockMaybeDiscoverMcpServer: vi.fn().mockResolvedValue(undefined),
+    mockStopMcp: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock('../tools/mcp-client-manager.js', () => ({
+    McpClientManager: class {
+        maybeDiscoverMcpServer = mockMaybeDiscoverMcpServer;
+        stop = mockStopMcp;
+    },
+}));
 import { debugLogger } from '../utils/debugLogger.js';
 import { LocalAgentExecutor } from './local-executor.js';
 import { makeFakeConfig } from '../test-utils/config.js';
 import { ToolRegistry } from '../tools/tool-registry.js';
+import { PromptRegistry } from '../prompts/prompt-registry.js';
+import { ResourceRegistry } from '../resources/resource-registry.js';
 import { DiscoveredMCPTool } from '../tools/mcp-tool.js';
 import { LSTool } from '../tools/ls.js';
 import { LS_TOOL_NAME, READ_FILE_TOOL_NAME } from '../tools/tool-names.js';
@@ -20,16 +43,12 @@ import { getErrorMessage } from '../utils/errors.js';
 import { promptIdContext } from '../utils/promptIdContext.js';
 import { logAgentStart, logAgentFinish, logRecoveryAttempt, } from '../telemetry/loggers.js';
 import { LlmRole, AgentStartEvent, AgentFinishEvent, RecoveryAttemptEvent, } from '../telemetry/types.js';
-import { AgentTerminateMode, } from './types.js';
+import { AgentTerminateMode, SubagentActivityErrorType, } from './types.js';
+import { ToolConfirmationOutcome, } from '../tools/tools.js';
+import { CoreToolCallStatus, } from '../scheduler/types.js';
 import { CompressionStatus } from '../core/turn.js';
 import { ChatCompressionService } from '../services/chatCompressionService.js';
 import { getModelConfigAlias } from './registry.js';
-const { mockSendMessageStream, mockScheduleAgentTools, mockSetSystemInstruction, mockCompress, } = vi.hoisted(() => ({
-    mockSendMessageStream: vi.fn(),
-    mockScheduleAgentTools: vi.fn(),
-    mockSetSystemInstruction: vi.fn(),
-    mockCompress: vi.fn(),
-}));
 let mockChatHistory = [];
 const mockSetHistory = vi.fn((newHistory) => {
     mockChatHistory = newHistory;
@@ -233,6 +252,51 @@ describe('LocalAgentExecutor', () => {
         vi.useRealTimers();
     });
     describe('create (Initialization and Validation)', () => {
+        it('should explicitly map execution context properties to prevent unintended propagation', async () => {
+            const definition = createTestDefinition([LS_TOOL_NAME]);
+            const mockGeminiClient = {};
+            const mockSandboxManager = {};
+            const extendedContext = {
+                config: mockConfig,
+                promptId: mockConfig.promptId,
+                toolRegistry: parentToolRegistry,
+                promptRegistry: mockConfig.promptRegistry,
+                resourceRegistry: mockConfig.resourceRegistry,
+                messageBus: mockConfig.messageBus,
+                geminiClient: mockGeminiClient,
+                sandboxManager: mockSandboxManager,
+                unintendedProperty: 'should not be here',
+            };
+            const executor = await LocalAgentExecutor.create(definition, extendedContext, onActivity);
+            mockModelResponse([
+                {
+                    name: TASK_COMPLETE_TOOL_NAME,
+                    args: { finalResult: 'done' },
+                    id: 'call1',
+                },
+            ]);
+            await executor.run({ goal: 'test' }, signal);
+            const chatConstructorArgs = MockedGeminiChat.mock.calls[0];
+            const executionContext = chatConstructorArgs[0];
+            expect(executionContext).toBeDefined();
+            expect(executionContext.config).toBe(extendedContext.config);
+            expect(executionContext.promptId).toBe(extendedContext.promptId);
+            expect(executionContext.geminiClient).toBe(extendedContext.geminiClient);
+            expect(executionContext.sandboxManager).toBe(extendedContext.sandboxManager);
+            const agentToolRegistry = executor['toolRegistry'];
+            const agentPromptRegistry = executor['promptRegistry'];
+            const agentResourceRegistry = executor['resourceRegistry'];
+            expect(executionContext.toolRegistry).toBe(agentToolRegistry);
+            expect(executionContext.promptRegistry).toBe(agentPromptRegistry);
+            expect(executionContext.resourceRegistry).toBe(agentResourceRegistry);
+            expect(executionContext.messageBus).toBe(agentToolRegistry.getMessageBus());
+            // Ensure the unintended property was not spread
+            expect(executionContext
+                .unintendedProperty).toBeUndefined();
+            // Ensure registries and message bus are not the parent's
+            expect(executionContext.toolRegistry).not.toBe(extendedContext.toolRegistry);
+            expect(executionContext.messageBus).not.toBe(extendedContext.messageBus);
+        });
         it('should create successfully with allowed tools', async () => {
             const definition = createTestDefinition([LS_TOOL_NAME]);
             const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
@@ -611,6 +675,7 @@ describe('LocalAgentExecutor', () => {
                 data: expect.objectContaining({
                     context: 'protocol_violation',
                     error: expectedError,
+                    errorType: SubagentActivityErrorType.GENERIC,
                 }),
             }));
         });
@@ -642,6 +707,7 @@ describe('LocalAgentExecutor', () => {
                     context: 'tool_call',
                     name: TASK_COMPLETE_TOOL_NAME,
                     error: expectedError,
+                    errorType: SubagentActivityErrorType.GENERIC,
                 }),
             }));
             const turn2Params = getMockMessageParams(1);
@@ -712,7 +778,7 @@ describe('LocalAgentExecutor', () => {
                         resolveCalls();
                     await vi.advanceTimersByTimeAsync(100);
                     return {
-                        status: 'success',
+                        status: CoreToolCallStatus.Success,
                         request: reqInfo,
                         tool: {},
                         invocation: {},
@@ -730,7 +796,7 @@ describe('LocalAgentExecutor', () => {
                             ],
                             error: undefined,
                             errorType: undefined,
-                            contentLength: undefined,
+                            contentLength: 0,
                         },
                     };
                 }));
@@ -759,10 +825,10 @@ describe('LocalAgentExecutor', () => {
             expect(parts).toHaveLength(2);
             expect(parts).toEqual(expect.arrayContaining([
                 expect.objectContaining({
-                    functionResponse: expect.objectContaining({ id: 'c1' }),
+                    functionResponse: expect.objectContaining({ name: LS_TOOL_NAME }),
                 }),
                 expect.objectContaining({
-                    functionResponse: expect.objectContaining({ id: 'c2' }),
+                    functionResponse: expect.objectContaining({ name: LS_TOOL_NAME }),
                 }),
             ]));
         });
@@ -814,6 +880,7 @@ describe('LocalAgentExecutor', () => {
                 data: expect.objectContaining({
                     context: 'tool_call_unauthorized',
                     name: READ_FILE_TOOL_NAME,
+                    errorType: SubagentActivityErrorType.GENERIC,
                 }),
             }));
         });
@@ -848,6 +915,7 @@ describe('LocalAgentExecutor', () => {
                     context: 'tool_call',
                     name: TASK_COMPLETE_TOOL_NAME,
                     error: expect.stringContaining('Output validation failed'),
+                    errorType: SubagentActivityErrorType.GENERIC,
                 }),
             }));
             // Check that the error was sent back to the model for the next turn
@@ -880,6 +948,7 @@ describe('LocalAgentExecutor', () => {
                 type: 'ERROR',
                 data: expect.objectContaining({
                     error: `Error: Failed to create chat object: ${getErrorMessage(initError)}`,
+                    errorType: SubagentActivityErrorType.GENERIC,
                 }),
             }));
             // Ensure the agent run was logged as a failure
@@ -897,7 +966,7 @@ describe('LocalAgentExecutor', () => {
             ]);
             mockScheduleAgentTools.mockResolvedValueOnce([
                 {
-                    status: 'error',
+                    status: CoreToolCallStatus.Error,
                     request: {
                         callId: 'call1',
                         name: LS_TOOL_NAME,
@@ -943,6 +1012,7 @@ describe('LocalAgentExecutor', () => {
                     context: 'tool_call',
                     name: LS_TOOL_NAME,
                     error: toolErrorMessage,
+                    errorType: SubagentActivityErrorType.GENERIC,
                 }),
             }));
             // Verify the error was sent back to the model
@@ -962,6 +1032,129 @@ describe('LocalAgentExecutor', () => {
             expect(output.terminate_reason).toBe(AgentTerminateMode.GOAL);
             expect(output.result).toBe('Aborted due to tool failure.');
         });
+        it('should handle a soft tool rejection (outcome: Cancel) and provide direct instructions to the model', async () => {
+            const definition = createTestDefinition([LS_TOOL_NAME]);
+            const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+            // Turn 1: Model calls a tool that will be rejected
+            mockModelResponse([
+                { name: LS_TOOL_NAME, args: { path: '/secret' }, id: 'call1' },
+            ]);
+            mockScheduleAgentTools.mockResolvedValueOnce([
+                {
+                    status: 'cancelled',
+                    request: {
+                        callId: 'call1',
+                        name: LS_TOOL_NAME,
+                        args: { path: '/secret' },
+                        isClientInitiated: false,
+                        prompt_id: 'test-prompt',
+                    },
+                    tool: {},
+                    invocation: {},
+                    outcome: ToolConfirmationOutcome.Cancel, // Soft rejection
+                    response: {
+                        callId: 'call1',
+                        resultDisplay: '',
+                        responseParts: [
+                            {
+                                functionResponse: {
+                                    name: LS_TOOL_NAME,
+                                    response: {
+                                        error: '[Operation Cancelled] Reason: User denied execution.',
+                                    },
+                                    id: 'call1',
+                                },
+                            },
+                        ],
+                        error: undefined,
+                        errorType: undefined,
+                        contentLength: 0,
+                    },
+                },
+            ]);
+            // Turn 2: Model sees the rejection + consolidated instructions and completes
+            mockModelResponse([
+                {
+                    name: TASK_COMPLETE_TOOL_NAME,
+                    args: { finalResult: 'User rejected access to /secret.' },
+                    id: 'call2',
+                },
+            ]);
+            const output = await executor.run({ goal: 'Soft rejection test' }, signal);
+            // Verify the activity stream reported the consolidated instruction
+            expect(activities).toContainEqual(expect.objectContaining({
+                type: 'ERROR',
+                data: expect.objectContaining({
+                    context: 'tool_call',
+                    name: LS_TOOL_NAME,
+                    error: expect.stringContaining('User rejected this operation'),
+                    errorType: SubagentActivityErrorType.REJECTED,
+                }),
+            }));
+            // Verify the instruction was sent back to the model as the tool error
+            const turn2Params = getMockMessageParams(1);
+            const parts = turn2Params.message;
+            const errorMsg = parts[0].functionResponse?.response?.['error'];
+            expect(typeof errorMsg).toBe('string');
+            if (typeof errorMsg === 'string') {
+                expect(errorMsg).toContain('User rejected this operation');
+                expect(errorMsg).toContain('acknowledge this, rethink your strategy');
+            }
+            expect(output.terminate_reason).toBe(AgentTerminateMode.GOAL);
+            expect(output.result).toBe('User rejected access to /secret.');
+        });
+        it('should handle a hard tool abort (cancelled with no outcome) and terminate the agent', async () => {
+            const definition = createTestDefinition([LS_TOOL_NAME]);
+            const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+            // Turn 1: Model calls a tool that will be aborted (e.g. Ctrl+C)
+            mockModelResponse([
+                { name: LS_TOOL_NAME, args: { path: '/secret' }, id: 'call1' },
+            ]);
+            mockScheduleAgentTools.mockResolvedValueOnce([
+                {
+                    status: 'cancelled',
+                    request: {
+                        callId: 'call1',
+                        name: LS_TOOL_NAME,
+                        args: { path: '/secret' },
+                        isClientInitiated: false,
+                        prompt_id: 'test-prompt',
+                    },
+                    tool: {},
+                    invocation: {},
+                    outcome: undefined, // Hard abort
+                    response: {
+                        callId: 'call1',
+                        resultDisplay: '',
+                        responseParts: [
+                            {
+                                functionResponse: {
+                                    name: LS_TOOL_NAME,
+                                    response: { error: 'Request cancelled.' },
+                                    id: 'call1',
+                                },
+                            },
+                        ],
+                        error: undefined,
+                        errorType: undefined,
+                        contentLength: 0,
+                    },
+                },
+            ]);
+            const output = await executor.run({ goal: 'Hard abort test' }, signal);
+            // Verify the activity stream reported the cancellation
+            expect(activities).toContainEqual(expect.objectContaining({
+                type: 'ERROR',
+                data: expect.objectContaining({
+                    context: 'tool_call',
+                    name: LS_TOOL_NAME,
+                    error: 'Request cancelled.',
+                    errorType: SubagentActivityErrorType.CANCELLED,
+                }),
+            }));
+            // Agent should terminate with ABORTED status
+            expect(output.terminate_reason).toBe(AgentTerminateMode.ABORTED);
+        });
     });
     describe('Model Routing', () => {
         it('should use model routing when the agent model is "auto"', async () => {
@@ -1089,6 +1282,7 @@ describe('LocalAgentExecutor', () => {
                 data: expect.objectContaining({
                     context: 'timeout',
                     error: 'Agent timed out after 0.5 minutes.',
+                    errorType: SubagentActivityErrorType.GENERIC,
                 }),
             }));
             // Verify telemetry
@@ -1226,6 +1420,7 @@ describe('LocalAgentExecutor', () => {
                 data: expect.objectContaining({
                     context: 'recovery_turn',
                     error: 'Graceful recovery attempt failed. Reason: stop',
+                    errorType: SubagentActivityErrorType.GENERIC,
                 }),
             }));
         });
@@ -1273,6 +1468,7 @@ describe('LocalAgentExecutor', () => {
                 data: expect.objectContaining({
                     context: 'recovery_turn',
                     error: 'Graceful recovery attempt failed. Reason: stop',
+                    errorType: SubagentActivityErrorType.GENERIC,
                 }),
             }));
         });
@@ -1350,6 +1546,7 @@ describe('LocalAgentExecutor', () => {
                 data: expect.objectContaining({
                     context: 'recovery_turn',
                     error: 'Graceful recovery attempt failed. Reason: stop',
+                    errorType: SubagentActivityErrorType.GENERIC,
                 }),
             }));
         });
@@ -1876,6 +2073,40 @@ describe('LocalAgentExecutor', () => {
             expect(mockSetHistory).toHaveBeenCalledWith(compressedHistory);
         });
     });
+    describe('MCP Isolation', () => {
+        it('should initialize McpClientManager when mcpServers are defined', async () => {
+            const { MCPServerConfig } = await import('../config/config.js');
+            const mcpServers = {
+                'test-server': new MCPServerConfig('node', ['server.js']),
+            };
+            const definition = {
+                ...createTestDefinition(),
+                mcpServers,
+            };
+            vi.spyOn(mockConfig, 'getMcpClientManager').mockReturnValue({
+                maybeDiscoverMcpServer: mockMaybeDiscoverMcpServer,
+            });
+            await LocalAgentExecutor.create(definition, mockConfig);
+            const mcpManager = mockConfig.getMcpClientManager();
+            expect(mcpManager?.maybeDiscoverMcpServer).toHaveBeenCalledWith('test-server', mcpServers['test-server'], expect.objectContaining({
+                toolRegistry: expect.any(ToolRegistry),
+                promptRegistry: expect.any(PromptRegistry),
+                resourceRegistry: expect.any(ResourceRegistry),
+            }));
+        });
+        it('should inherit main registry tools', async () => {
+            const parentMcpTool = new DiscoveredMCPTool({}, 'main-server', 'tool1', 'desc1', {}, mockConfig.getMessageBus());
+            parentToolRegistry.registerTool(parentMcpTool);
+            const definition = createTestDefinition();
+            definition.toolConfig = undefined; // trigger inheritance
+            vi.spyOn(mockConfig, 'getMcpClientManager').mockReturnValue({
+                maybeDiscoverMcpServer: vi.fn(),
+            });
+            const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+            const agentTools = executor.toolRegistry.getAllToolNames();
+            expect(agentTools).toContain(parentMcpTool.name);
+        });
+    });
     describe('DeclarativeTool instance tools (browser agent pattern)', () => {
         /**
          * The browser agent passes DeclarativeTool instances (not string names) in
@@ -2133,6 +2364,68 @@ describe('LocalAgentExecutor', () => {
             const uniqueNames = new Set(names);
             expect(uniqueNames.size).toBe(names.length);
         });
+        describe('Memory Injection', () => {
+            it('should inject system instruction memory into system prompt', async () => {
+                const definition = createTestDefinition();
+                const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+                const mockMemory = 'Global memory constraint';
+                vi.spyOn(mockConfig, 'getSystemInstructionMemory').mockReturnValue(mockMemory);
+                mockModelResponse([
+                    {
+                        name: TASK_COMPLETE_TOOL_NAME,
+                        args: { finalResult: 'done' },
+                        id: 'call1',
+                    },
+                ]);
+                await executor.run({ goal: 'test' }, signal);
+                const chatConstructorArgs = MockedGeminiChat.mock.calls[0];
+                const systemInstruction = chatConstructorArgs[1];
+                expect(systemInstruction).toContain(mockMemory);
+                expect(systemInstruction).toContain('<loaded_context>');
+            });
+            it('should inject environment memory into the first message when JIT is disabled', async () => {
+                const definition = createTestDefinition();
+                const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+                const mockMemory = 'Project memory rule';
+                vi.spyOn(mockConfig, 'getEnvironmentMemory').mockReturnValue(mockMemory);
+                vi.spyOn(mockConfig, 'isJitContextEnabled').mockReturnValue(false);
+                mockModelResponse([
+                    {
+                        name: TASK_COMPLETE_TOOL_NAME,
+                        args: { finalResult: 'done' },
+                        id: 'call1',
+                    },
+                ]);
+                await executor.run({ goal: 'test' }, signal);
+                const { message } = getMockMessageParams(0);
+                const parts = message;
+                expect(parts).toBeDefined();
+                const memoryPart = parts.find((p) => p.text?.includes(mockMemory));
+                expect(memoryPart).toBeDefined();
+                expect(memoryPart?.text).toBe(mockMemory);
+            });
+            it('should inject session memory into the first message when JIT is enabled', async () => {
+                const definition = createTestDefinition();
+                const executor = await LocalAgentExecutor.create(definition, mockConfig, onActivity);
+                const mockMemory = '<loaded_context>\nExtension memory rule\n</loaded_context>';
+                vi.spyOn(mockConfig, 'getSessionMemory').mockReturnValue(mockMemory);
+                vi.spyOn(mockConfig, 'isJitContextEnabled').mockReturnValue(true);
+                mockModelResponse([
+                    {
+                        name: TASK_COMPLETE_TOOL_NAME,
+                        args: { finalResult: 'done' },
+                        id: 'call1',
+                    },
+                ]);
+                await executor.run({ goal: 'test' }, signal);
+                const { message } = getMockMessageParams(0);
+                const parts = message;
+                expect(parts).toBeDefined();
+                const memoryPart = parts.find((p) => p.text?.includes('Extension memory rule'));
+                expect(memoryPart).toBeDefined();
+                expect(memoryPart?.text).toContain(mockMemory);
+            });
+        });
     });
 });
 //# sourceMappingURL=local-executor.test.js.map