@machina.ai/cell-cli 1.41.1-rc2 → 1.45.1-rc2

package/dist/src/acp/acpClient.test.js

@@ -1,1816 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
-import { GeminiAgent, Session } from './acpClient.js';
-import * as acp from '@agentclientprotocol/sdk';
-import { AuthType, ToolConfirmationOutcome, StreamEventType, ReadManyFilesTool, LlmRole, processSingleFileContent, InvalidStreamError, } from '@google/gemini-cli-core';
-import { SettingScope, loadSettings, } from '../config/settings.js';
-import { loadCliConfig } from '../config/config.js';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { ApprovalMode } from '@google/gemini-cli-core/src/policy/types.js';
-const startMemoryServiceMock = vi.hoisted(() => vi.fn());
-vi.mock('../config/config.js', () => ({
-    loadCliConfig: vi.fn(),
-}));
-vi.mock('../config/settings.js', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        loadSettings: vi.fn(),
-    };
-});
-vi.mock('node:crypto', () => ({
-    randomUUID: () => 'test-session-id',
-}));
-vi.mock('node:fs/promises');
-vi.mock('node:path', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        resolve: vi.fn(),
-    };
-});
-vi.mock('../ui/commands/memoryCommand.js', () => ({
-    memoryCommand: {
-        name: 'memory',
-        action: vi.fn(),
-    },
-}));
-vi.mock('../ui/commands/extensionsCommand.js', () => ({
-    extensionsCommand: vi.fn().mockReturnValue({
-        name: 'extensions',
-        action: vi.fn(),
-    }),
-}));
-vi.mock('../ui/commands/restoreCommand.js', () => ({
-    restoreCommand: vi.fn().mockReturnValue({
-        name: 'restore',
-        action: vi.fn(),
-    }),
-}));
-vi.mock('../ui/commands/initCommand.js', () => ({
-    initCommand: {
-        name: 'init',
-        action: vi.fn(),
-    },
-}));
-vi.mock('@google/gemini-cli-core', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        startMemoryService: startMemoryServiceMock,
-        updatePolicy: vi.fn(),
-        createPolicyUpdater: vi.fn(),
-        ReadManyFilesTool: vi.fn(),
-        logToolCall: vi.fn(),
-        LlmRole: {
-            MAIN: 'main',
-            SUBAGENT: 'subagent',
-            UTILITY_TOOL: 'utility_tool',
-            UTILITY_COMPRESSOR: 'utility_compressor',
-            UTILITY_SUMMARIZER: 'utility_summarizer',
-            UTILITY_ROUTER: 'utility_router',
-            UTILITY_LOOP_DETECTOR: 'utility_loop_detector',
-            UTILITY_NEXT_SPEAKER: 'utility_next_speaker',
-            UTILITY_EDIT_CORRECTOR: 'utility_edit_corrector',
-            UTILITY_AUTOCOMPLETE: 'utility_autocomplete',
-            UTILITY_FAST_ACK_HELPER: 'utility_fast_ack_helper',
-        },
-        CoreToolCallStatus: {
-            Validating: 'validating',
-            Scheduled: 'scheduled',
-            Error: 'error',
-            Success: 'success',
-            Executing: 'executing',
-            Cancelled: 'cancelled',
-            AwaitingApproval: 'awaiting_approval',
-        },
-        processSingleFileContent: vi.fn(),
-    };
-});
-// Helper to create mock streams
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-async function* createMockStream(items) {
-    for (const item of items) {
-        yield item;
-    }
-}
-describe('GeminiAgent', () => {
-    let mockConfig;
-    let mockSettings;
-    let mockArgv;
-    let mockConnection;
-    let agent;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        startMemoryServiceMock.mockResolvedValue(undefined);
-        mockConfig = {
-            refreshAuth: vi.fn(),
-            initialize: vi.fn(),
-            waitForMcpInit: vi.fn(),
-            getFileSystemService: vi.fn(),
-            setFileSystemService: vi.fn(),
-            getContentGeneratorConfig: vi.fn(),
-            isAutoMemoryEnabled: vi.fn().mockReturnValue(false),
-            getActiveModel: vi.fn().mockReturnValue('gemini-pro'),
-            getModel: vi.fn().mockReturnValue('gemini-pro'),
-            getGeminiClient: vi.fn().mockReturnValue({
-                startChat: vi.fn().mockResolvedValue({}),
-            }),
-            getMessageBus: vi.fn().mockReturnValue({
-                publish: vi.fn(),
-                subscribe: vi.fn(),
-                unsubscribe: vi.fn(),
-            }),
-            getApprovalMode: vi.fn().mockReturnValue('default'),
-            isPlanEnabled: vi.fn().mockReturnValue(true),
-            getGemini31LaunchedSync: vi.fn().mockReturnValue(false),
-            getHasAccessToPreviewModel: vi.fn().mockReturnValue(false),
-            getCheckpointingEnabled: vi.fn().mockReturnValue(false),
-            getDisableAlwaysAllow: vi.fn().mockReturnValue(false),
-            validatePathAccess: vi.fn().mockReturnValue(null),
-            getWorkspaceContext: vi.fn().mockReturnValue({
-                addReadOnlyPath: vi.fn(),
-            }),
-            getPolicyEngine: vi.fn().mockReturnValue({
-                addRule: vi.fn(),
-            }),
-            messageBus: {
-                publish: vi.fn(),
-                subscribe: vi.fn(),
-                unsubscribe: vi.fn(),
-            },
-            storage: {
-                getWorkspaceAutoSavedPolicyPath: vi.fn(),
-                getAutoSavedPolicyPath: vi.fn(),
-                setClientName: vi.fn(),
-            },
-            setClientName: vi.fn(),
-            get config() {
-                return this;
-            },
-        };
-        mockSettings = {
-            merged: {
-                security: { auth: { selectedType: 'login_with_google' } },
-                mcpServers: {},
-            },
-            setValue: vi.fn(),
-        };
-        mockArgv = {};
-        mockConnection = {
-            sessionUpdate: vi.fn(),
-            requestPermission: vi.fn(),
-        };
-        loadCliConfig.mockResolvedValue(mockConfig);
-        loadSettings.mockImplementation(() => ({
-            merged: {
-                security: {
-                    auth: { selectedType: AuthType.LOGIN_WITH_GOOGLE },
-                    enablePermanentToolApproval: true,
-                },
-                mcpServers: {},
-            },
-            setValue: vi.fn(),
-        }));
-        agent = new GeminiAgent(mockConfig, mockSettings, mockArgv, mockConnection);
-    });
-    it('should initialize correctly', async () => {
-        const response = await agent.initialize({
-            clientCapabilities: { fs: { readTextFile: true, writeTextFile: true } },
-            protocolVersion: 1,
-        });
-        expect(response.protocolVersion).toBe(acp.PROTOCOL_VERSION);
-        expect(response.authMethods).toHaveLength(5);
-        const keycloakAuth = response.authMethods?.find((m) => m.id === AuthType.KEYCLOAK);
-        expect(keycloakAuth).toBeDefined();
-        const gatewayAuth = response.authMethods?.find((m) => m.id === AuthType.GATEWAY);
-        expect(gatewayAuth?._meta).toEqual({
-            gateway: {
-                protocol: 'google',
-                restartRequired: 'false',
-            },
-        });
-        const geminiAuth = response.authMethods?.find((m) => m.id === AuthType.USE_GEMINI);
-        expect(geminiAuth?._meta).toEqual({
-            'api-key': {
-                provider: 'google',
-            },
-        });
-        expect(response.agentCapabilities?.loadSession).toBe(true);
-    });
-    it('should authenticate correctly', async () => {
-        await agent.authenticate({
-            methodId: AuthType.LOGIN_WITH_GOOGLE,
-        });
-        expect(mockConfig.refreshAuth).toHaveBeenCalledWith(AuthType.LOGIN_WITH_GOOGLE, expect.any(Function), undefined, undefined, undefined);
-        expect(mockSettings.setValue).toHaveBeenCalledWith(SettingScope.User, 'security.auth.selectedType', AuthType.LOGIN_WITH_GOOGLE);
-    });
-    it('should authenticate correctly with api-key in _meta', async () => {
-        await agent.authenticate({
-            methodId: AuthType.USE_GEMINI,
-            _meta: {
-                'api-key': 'test-api-key',
-            },
-        });
-        expect(mockConfig.refreshAuth).toHaveBeenCalledWith(AuthType.USE_GEMINI, expect.any(Function), 'test-api-key', undefined, undefined);
-        expect(mockSettings.setValue).toHaveBeenCalledWith(SettingScope.User, 'security.auth.selectedType', AuthType.USE_GEMINI);
-    });
-    it('should authenticate correctly with gateway method', async () => {
-        await agent.authenticate({
-            methodId: AuthType.GATEWAY,
-            _meta: {
-                gateway: {
-                    baseUrl: 'https://example.com',
-                    headers: { Authorization: 'Bearer token' },
-                },
-            },
-        });
-        expect(mockConfig.refreshAuth).toHaveBeenCalledWith(AuthType.GATEWAY, expect.any(Function), undefined, 'https://example.com', { Authorization: 'Bearer token' });
-        expect(mockSettings.setValue).toHaveBeenCalledWith(SettingScope.User, 'security.auth.selectedType', AuthType.GATEWAY);
-    });
-    it('should throw acp.RequestError when gateway payload is malformed', async () => {
-        await expect(agent.authenticate({
-            methodId: AuthType.GATEWAY,
-            _meta: {
-                gateway: {
-                    // Invalid baseUrl
-                    baseUrl: 123,
-                    headers: { Authorization: 'Bearer token' },
-                },
-            },
-        })).rejects.toThrow(/Malformed gateway payload/);
-    });
-    it('should create a new session', async () => {
-        vi.useFakeTimers();
-        mockConfig.getContentGeneratorConfig = vi.fn().mockReturnValue({
-            apiKey: 'test-key',
-        });
-        const response = await agent.newSession({
-            cwd: '/tmp',
-            mcpServers: [],
-        });
-        expect(response.sessionId).toBe('test-session-id');
-        expect(loadCliConfig).toHaveBeenCalled();
-        expect(mockConfig.initialize).toHaveBeenCalled();
-        expect(mockConfig.getGeminiClient).toHaveBeenCalled();
-        // Verify deferred call
-        await vi.runAllTimersAsync();
-        expect(mockConnection.sessionUpdate).toHaveBeenCalledWith(expect.objectContaining({
-            update: expect.objectContaining({
-                sessionUpdate: 'available_commands_update',
-            }),
-        }));
-        vi.useRealTimers();
-    });
-    it('should start auto memory for new ACP sessions when enabled', async () => {
-        mockConfig.getContentGeneratorConfig = vi.fn().mockReturnValue({
-            apiKey: 'test-key',
-        });
-        mockConfig.isAutoMemoryEnabled = vi.fn().mockReturnValue(true);
-        await agent.newSession({
-            cwd: '/tmp',
-            mcpServers: [],
-        });
-        expect(startMemoryServiceMock).toHaveBeenCalledWith(mockConfig);
-    });
-    it('should not start auto memory for new ACP sessions when disabled', async () => {
-        mockConfig.getContentGeneratorConfig = vi.fn().mockReturnValue({
-            apiKey: 'test-key',
-        });
-        mockConfig.isAutoMemoryEnabled = vi.fn().mockReturnValue(false);
-        await agent.newSession({
-            cwd: '/tmp',
-            mcpServers: [],
-        });
-        expect(startMemoryServiceMock).not.toHaveBeenCalled();
-    });
-    it('should return modes without plan mode when plan is disabled', async () => {
-        mockConfig.getContentGeneratorConfig = vi.fn().mockReturnValue({
-            apiKey: 'test-key',
-        });
-        mockConfig.isPlanEnabled = vi.fn().mockReturnValue(false);
-        mockConfig.getApprovalMode = vi.fn().mockReturnValue('default');
-        const response = await agent.newSession({
-            cwd: '/tmp',
-            mcpServers: [],
-        });
-        expect(response.modes).toEqual({
-            availableModes: [
-                { id: 'default', name: 'Default', description: 'Prompts for approval' },
-                {
-                    id: 'autoEdit',
-                    name: 'Auto Edit',
-                    description: 'Auto-approves edit tools',
-                },
-                { id: 'yolo', name: 'YOLO', description: 'Auto-approves all tools' },
-            ],
-            currentModeId: 'default',
-        });
-        expect(response.models).toEqual({
-            availableModels: expect.arrayContaining([
-                expect.objectContaining({
-                    modelId: 'auto-gemini-2.5',
-                    name: 'Auto (Gemini 2.5)',
-                }),
-            ]),
-            currentModelId: 'gemini-pro',
-        });
-    });
-    it('should include preview models when user has access', async () => {
-        mockConfig.getHasAccessToPreviewModel = vi.fn().mockReturnValue(true);
-        mockConfig.getGemini31LaunchedSync = vi.fn().mockReturnValue(true);
-        const response = await agent.newSession({
-            cwd: '/tmp',
-            mcpServers: [],
-        });
-        expect(response.models?.availableModels).toEqual(expect.arrayContaining([
-            expect.objectContaining({
-                modelId: 'auto-gemini-3',
-                name: expect.stringContaining('Auto'),
-            }),
-            expect.objectContaining({
-                modelId: 'gemini-3.1-pro-preview',
-                name: 'gemini-3.1-pro-preview',
-            }),
-        ]));
-    });
-    it('should include gemini-3.1-flash-lite when useGemini31FlashLite is true', async () => {
-        mockConfig.getHasAccessToPreviewModel = vi.fn().mockReturnValue(true);
-        mockConfig.getGemini31LaunchedSync = vi.fn().mockReturnValue(true);
-        mockConfig.getGemini31FlashLiteLaunchedSync = vi.fn().mockReturnValue(true);
-        const response = await agent.newSession({
-            cwd: '/tmp',
-            mcpServers: [],
-        });
-        expect(response.models?.availableModels).toEqual(expect.arrayContaining([
-            expect.objectContaining({
-                modelId: 'gemini-3.1-flash-lite-preview',
-                name: 'gemini-3.1-flash-lite-preview',
-            }),
-        ]));
-    });
-    it('should return modes with plan mode when plan is enabled', async () => {
-        mockConfig.getContentGeneratorConfig = vi.fn().mockReturnValue({
-            apiKey: 'test-key',
-        });
-        mockConfig.isPlanEnabled = vi.fn().mockReturnValue(true);
-        mockConfig.getApprovalMode = vi.fn().mockReturnValue('plan');
-        const response = await agent.newSession({
-            cwd: '/tmp',
-            mcpServers: [],
-        });
-        expect(response.modes).toEqual({
-            availableModes: [
-                { id: 'default', name: 'Default', description: 'Prompts for approval' },
-                {
-                    id: 'autoEdit',
-                    name: 'Auto Edit',
-                    description: 'Auto-approves edit tools',
-                },
-                { id: 'yolo', name: 'YOLO', description: 'Auto-approves all tools' },
-                { id: 'plan', name: 'Plan', description: 'Read-only mode' },
-            ],
-            currentModeId: 'plan',
-        });
-        expect(response.models).toEqual({
-            availableModels: expect.arrayContaining([
-                expect.objectContaining({
-                    modelId: 'auto-gemini-2.5',
-                    name: 'Auto (Gemini 2.5)',
-                }),
-            ]),
-            currentModelId: 'gemini-pro',
-        });
-    });
-    it('should fail session creation if Gemini API key is missing', async () => {
-        loadSettings.mockImplementation(() => ({
-            merged: {
-                security: { auth: { selectedType: AuthType.USE_GEMINI } },
-                mcpServers: {},
-            },
-            setValue: vi.fn(),
-        }));
-        mockConfig.getContentGeneratorConfig = vi.fn().mockReturnValue({
-            apiKey: undefined,
-        });
-        await expect(agent.newSession({
-            cwd: '/tmp',
-            mcpServers: [],
-        })).rejects.toMatchObject({
-            message: 'Gemini API key is missing or not configured.',
-        });
-    });
-    it('should create a new session with mcp servers', async () => {
-        const mcpServers = [
-            {
-                name: 'test-server',
-                command: 'node',
-                args: ['server.js'],
-                env: [{ name: 'KEY', value: 'VALUE' }],
-            },
-        ];
-        await agent.newSession({
-            cwd: '/tmp',
-            mcpServers,
-        });
-        expect(loadCliConfig).toHaveBeenCalledWith(expect.objectContaining({
-            mcpServers: expect.objectContaining({
-                'test-server': expect.objectContaining({
-                    command: 'node',
-                    args: ['server.js'],
-                    env: { KEY: 'VALUE' },
-                }),
-            }),
-        }), 'test-session-id', mockArgv, { cwd: '/tmp' });
-    });
-    it('should handle authentication failure gracefully', async () => {
-        mockConfig.refreshAuth.mockRejectedValue(new Error('Auth failed'));
-        const debugSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
-        // Should throw RequestError with custom message
-        await expect(agent.newSession({
-            cwd: '/tmp',
-            mcpServers: [],
-        })).rejects.toMatchObject({
-            message: 'Auth failed',
-        });
-        debugSpy.mockRestore();
-    });
-    it('should initialize file system service if client supports it', async () => {
-        agent = new GeminiAgent(mockConfig, mockSettings, mockArgv, mockConnection);
-        await agent.initialize({
-            clientCapabilities: { fs: { readTextFile: true, writeTextFile: true } },
-            protocolVersion: 1,
-        });
-        await agent.newSession({
-            cwd: '/tmp',
-            mcpServers: [],
-        });
-        expect(mockConfig.setFileSystemService).toHaveBeenCalled();
-    });
-    it('should cancel a session', async () => {
-        await agent.newSession({ cwd: '/tmp', mcpServers: [] });
-        // Mock the session's cancelPendingPrompt
-        const session = agent.sessions.get('test-session-id');
-        if (!session)
-            throw new Error('Session not found');
-        session.cancelPendingPrompt = vi.fn();
-        await agent.cancel({ sessionId: 'test-session-id' });
-        expect(session.cancelPendingPrompt).toHaveBeenCalled();
-    });
-    it('should throw error when cancelling non-existent session', async () => {
-        await expect(agent.cancel({ sessionId: 'unknown' })).rejects.toThrow('Session not found');
-    });
-    it('should delegate prompt to session', async () => {
-        await agent.newSession({ cwd: '/tmp', mcpServers: [] });
-        const session = agent.sessions.get('test-session-id');
-        if (!session)
-            throw new Error('Session not found');
-        session.prompt = vi.fn().mockResolvedValue({ stopReason: 'end_turn' });
-        const result = await agent.prompt({
-            sessionId: 'test-session-id',
-            prompt: [],
-        });
-        expect(session.prompt).toHaveBeenCalled();
-        expect(result).toMatchObject({ stopReason: 'end_turn' });
-    });
-    it('should delegate setMode to session', async () => {
-        await agent.newSession({ cwd: '/tmp', mcpServers: [] });
-        const session = agent.sessions.get('test-session-id');
-        if (!session)
-            throw new Error('Session not found');
-        session.setMode = vi.fn().mockReturnValue({});
-        const result = await agent.setSessionMode({
-            sessionId: 'test-session-id',
-            modeId: 'plan',
-        });
-        expect(session.setMode).toHaveBeenCalledWith('plan');
-        expect(result).toEqual({});
-    });
-    it('should throw error when setting mode on non-existent session', async () => {
-        await expect(agent.setSessionMode({
-            sessionId: 'unknown',
-            modeId: 'plan',
-        })).rejects.toThrow('Session not found: unknown');
-    });
-    it('should delegate setModel to session (unstable)', async () => {
-        await agent.newSession({ cwd: '/tmp', mcpServers: [] });
-        const session = agent.sessions.get('test-session-id');
-        if (!session)
-            throw new Error('Session not found');
-        session.setModel = vi.fn().mockReturnValue({});
-        const result = await agent.unstable_setSessionModel({
-            sessionId: 'test-session-id',
-            modelId: 'gemini-2.0-pro-exp',
-        });
-        expect(session.setModel).toHaveBeenCalledWith('gemini-2.0-pro-exp');
-        expect(result).toEqual({});
-    });
-    it('should throw error when setting model on non-existent session (unstable)', async () => {
-        await expect(agent.unstable_setSessionModel({
-            sessionId: 'unknown',
-            modelId: 'gemini-2.0-pro-exp',
-        })).rejects.toThrow('Session not found: unknown');
-    });
-});
-describe('Session', () => {
-    let mockChat;
-    let mockConfig;
-    let mockConnection;
-    let session;
-    let mockToolRegistry;
-    let mockTool;
-    let mockMessageBus;
-    beforeEach(() => {
-        mockChat = {
-            sendMessageStream: vi.fn(),
-            addHistory: vi.fn(),
-            recordCompletedToolCalls: vi.fn(),
-            getHistory: vi.fn().mockReturnValue([]),
-        };
-        mockTool = {
-            kind: 'read',
-            build: vi.fn().mockReturnValue({
-                getDescription: () => 'Test Tool',
-                toolLocations: () => [],
-                shouldConfirmExecute: vi.fn().mockResolvedValue(null),
-                execute: vi.fn().mockResolvedValue({ llmContent: 'Tool Result' }),
-            }),
-        };
-        mockToolRegistry = {
-            getTool: vi.fn().mockReturnValue(mockTool),
-        };
-        mockMessageBus = {
-            publish: vi.fn(),
-            subscribe: vi.fn(),
-            unsubscribe: vi.fn(),
-        };
-        mockConfig = {
-            getModel: vi.fn().mockReturnValue('gemini-pro'),
-            getActiveModel: vi.fn().mockReturnValue('gemini-pro'),
-            getModelRouterService: vi.fn().mockReturnValue({
-                route: vi.fn().mockResolvedValue({ model: 'resolved-model' }),
-            }),
-            getToolRegistry: vi.fn().mockReturnValue(mockToolRegistry),
-            getMcpServers: vi.fn(),
-            getFileService: vi.fn().mockReturnValue({
-                shouldIgnoreFile: vi.fn().mockReturnValue(false),
-            }),
-            getFileFilteringOptions: vi.fn().mockReturnValue({}),
-            getFileSystemService: vi.fn().mockReturnValue({}),
-            getTargetDir: vi.fn().mockReturnValue('/tmp'),
-            getEnableRecursiveFileSearch: vi.fn().mockReturnValue(false),
-            getDebugMode: vi.fn().mockReturnValue(false),
-            getMessageBus: vi.fn().mockReturnValue(mockMessageBus),
-            setApprovalMode: vi.fn(),
-            setModel: vi.fn(),
-            isPlanEnabled: vi.fn().mockReturnValue(true),
-            getCheckpointingEnabled: vi.fn().mockReturnValue(false),
-            getGitService: vi.fn().mockResolvedValue({}),
-            validatePathAccess: vi.fn().mockReturnValue(null),
-            getWorkspaceContext: vi.fn().mockReturnValue({
-                addReadOnlyPath: vi.fn(),
-            }),
-            waitForMcpInit: vi.fn(),
-            getDisableAlwaysAllow: vi.fn().mockReturnValue(false),
-            get config() {
-                return this;
-            },
-            get toolRegistry() {
-                return mockToolRegistry;
-            },
-        };
-        mockConnection = {
-            sessionUpdate: vi.fn(),
-            requestPermission: vi.fn(),
-            sendNotification: vi.fn(),
-        };
-        session = new Session('session-1', mockChat, mockConfig, mockConnection, {
-            system: { settings: {} },
-            systemDefaults: { settings: {} },
-            user: { settings: {} },
-            workspace: { settings: {} },
-            merged: {
-                security: { enablePermanentToolApproval: true },
-                mcpServers: {},
-            },
-            errors: [],
-        });
-        ReadManyFilesTool.mockImplementation(() => ({
-            name: 'read_many_files',
-            kind: 'read',
-            build: vi.fn().mockReturnValue({
-                getDescription: () => 'Read files',
-                toolLocations: () => [],
-                execute: vi.fn().mockResolvedValue({
-                    llmContent: ['--- file.txt ---\n\nFile content\n\n'],
-                }),
-            }),
-        }));
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('should send available commands', async () => {
-        await session.sendAvailableCommands();
-        expect(mockConnection.sessionUpdate).toHaveBeenCalledWith(expect.objectContaining({
-            update: expect.objectContaining({
-                sessionUpdate: 'available_commands_update',
-                availableCommands: expect.arrayContaining([
-                    expect.objectContaining({ name: 'memory' }),
-                    expect.objectContaining({ name: 'extensions' }),
-                    expect.objectContaining({ name: 'restore' }),
-                    expect.objectContaining({ name: 'init' }),
-                ]),
-            }),
-        }));
-    });
-    it('should await MCP initialization before processing a prompt', async () => {
-        const stream = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [{ content: { parts: [{ text: 'Hi' }] } }] },
-            },
-        ]);
-        mockChat.sendMessageStream.mockResolvedValue(stream);
-        await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'test' }],
-        });
-        expect(mockConfig.waitForMcpInit).toHaveBeenCalledOnce();
-        const waitOrder = mockConfig.waitForMcpInit.mock
-            .invocationCallOrder[0];
-        const sendOrder = mockChat.sendMessageStream.mock
-            .invocationCallOrder[0];
-        expect(waitOrder).toBeLessThan(sendOrder);
-    });
-    it('should handle prompt with text response', async () => {
-        const stream = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: {
-                    candidates: [{ content: { parts: [{ text: 'Hello' }] } }],
-                },
-            },
-        ]);
-        mockChat.sendMessageStream.mockResolvedValue(stream);
-        const result = await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'Hi' }],
-        });
-        expect(mockChat.sendMessageStream).toHaveBeenCalled();
-        expect(mockConnection.sessionUpdate).toHaveBeenCalledWith({
-            sessionId: 'session-1',
-            update: {
-                sessionUpdate: 'agent_message_chunk',
-                content: { type: 'text', text: 'Hello' },
-            },
-        });
-        expect(result).toMatchObject({ stopReason: 'end_turn' });
-    });
-    it('should use model router to determine model', async () => {
-        const mockRouter = {
-            route: vi.fn().mockResolvedValue({ model: 'routed-model' }),
-        };
-        mockConfig.getModelRouterService.mockReturnValue(mockRouter);
-        const stream = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: {
-                    candidates: [{ content: { parts: [{ text: 'Hello' }] } }],
-                },
-            },
-        ]);
-        mockChat.sendMessageStream.mockResolvedValue(stream);
-        await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'Hi' }],
-        });
-        expect(mockRouter.route).toHaveBeenCalledWith(expect.objectContaining({
-            requestedModel: 'gemini-pro',
-            request: [{ text: 'Hi' }],
-        }));
-        expect(mockChat.sendMessageStream).toHaveBeenCalledWith(expect.objectContaining({ model: 'routed-model' }), expect.any(Array), expect.any(String), expect.any(Object), expect.any(String));
-    });
-    it('should handle prompt with empty response (InvalidStreamError)', async () => {
-        mockChat.sendMessageStream.mockRejectedValue(new InvalidStreamError('Empty response', 'NO_RESPONSE_TEXT'));
-        const result = await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'Hi' }],
-        });
-        expect(mockChat.sendMessageStream).toHaveBeenCalled();
-        expect(result).toMatchObject({ stopReason: 'end_turn' });
-    });
-    it('should handle prompt with empty response (NO_RESPONSE_TEXT anomaly)', async () => {
-        mockChat.sendMessageStream.mockRejectedValue({ type: 'NO_RESPONSE_TEXT' });
-        const result = await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'Hi' }],
-        });
-        expect(mockChat.sendMessageStream).toHaveBeenCalled();
-        expect(result).toMatchObject({ stopReason: 'end_turn' });
-    });
-    it('should handle prompt with no finish reason (InvalidStreamError)', async () => {
-        mockChat.sendMessageStream.mockRejectedValue(new InvalidStreamError('No finish reason', 'NO_FINISH_REASON'));
-        const result = await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'Hi' }],
-        });
-        expect(mockChat.sendMessageStream).toHaveBeenCalled();
-        expect(result).toMatchObject({ stopReason: 'end_turn' });
-    });
-    it('should handle prompt with no finish reason (NO_FINISH_REASON anomaly)', async () => {
-        mockChat.sendMessageStream.mockRejectedValue({ type: 'NO_FINISH_REASON' });
-        const result = await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'Hi' }],
-        });
-        expect(mockChat.sendMessageStream).toHaveBeenCalled();
-        expect(result).toMatchObject({ stopReason: 'end_turn' });
-    });
-    it('should handle /memory command', async () => {
-        const handleCommandSpy = vi
-            .spyOn(session
-            .commandHandler, 'handleCommand')
-            .mockResolvedValue(true);
-        const result = await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: '/memory view' }],
-        });
-        expect(result).toMatchObject({ stopReason: 'end_turn' });
-        expect(handleCommandSpy).toHaveBeenCalledWith('/memory view', expect.any(Object));
-        expect(mockChat.sendMessageStream).not.toHaveBeenCalled();
-    });
-    it('should handle /extensions command', async () => {
-        const handleCommandSpy = vi
-            .spyOn(session
-            .commandHandler, 'handleCommand')
-            .mockResolvedValue(true);
-        const result = await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: '/extensions list' }],
-        });
-        expect(result).toMatchObject({ stopReason: 'end_turn' });
-        expect(handleCommandSpy).toHaveBeenCalledWith('/extensions list', expect.any(Object));
-        expect(mockChat.sendMessageStream).not.toHaveBeenCalled();
-    });
-    it('should handle /extensions explore command', async () => {
-        const handleCommandSpy = vi
-            .spyOn(session
-            .commandHandler, 'handleCommand')
-            .mockResolvedValue(true);
-        const result = await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: '/extensions explore' }],
-        });
-        expect(result).toMatchObject({ stopReason: 'end_turn' });
-        expect(handleCommandSpy).toHaveBeenCalledWith('/extensions explore', expect.any(Object));
-        expect(mockChat.sendMessageStream).not.toHaveBeenCalled();
-    });
-    it('should handle /restore command', async () => {
-        const handleCommandSpy = vi
-            .spyOn(session
-            .commandHandler, 'handleCommand')
-            .mockResolvedValue(true);
-        const result = await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: '/restore' }],
-        });
-        expect(result).toMatchObject({ stopReason: 'end_turn' });
-        expect(handleCommandSpy).toHaveBeenCalledWith('/restore', expect.any(Object));
-        expect(mockChat.sendMessageStream).not.toHaveBeenCalled();
-    });
-    it('should handle /init command', async () => {
-        const handleCommandSpy = vi
-            .spyOn(session
-            .commandHandler, 'handleCommand')
-            .mockResolvedValue(true);
-        const result = await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: '/init' }],
-        });
-        expect(result).toMatchObject({ stopReason: 'end_turn' });
-        expect(handleCommandSpy).toHaveBeenCalledWith('/init', expect.any(Object));
-        expect(mockChat.sendMessageStream).not.toHaveBeenCalled();
-    });
-    it('should handle tool calls', async () => {
-        const stream1 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: {
-                    functionCalls: [{ name: 'test_tool', args: { foo: 'bar' } }],
-                },
-            },
-        ]);
-        const stream2 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: {
-                    candidates: [{ content: { parts: [{ text: 'Result' }] } }],
-                },
-            },
-        ]);
-        mockChat.sendMessageStream
-            .mockResolvedValueOnce(stream1)
-            .mockResolvedValueOnce(stream2);
-        const result = await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'Call tool' }],
-        });
-        expect(mockToolRegistry.getTool).toHaveBeenCalledWith('test_tool');
-        expect(mockTool.build).toHaveBeenCalledWith({ foo: 'bar' });
-        expect(mockConnection.sessionUpdate).toHaveBeenCalledWith(expect.objectContaining({
-            update: expect.objectContaining({
-                sessionUpdate: 'tool_call',
-                status: 'in_progress',
-                kind: 'read',
-            }),
-        }));
-        expect(mockConnection.sessionUpdate).toHaveBeenCalledWith(expect.objectContaining({
-            update: expect.objectContaining({
-                sessionUpdate: 'tool_call_update',
-                status: 'completed',
-                title: 'Test Tool',
-                locations: [],
-                kind: 'read',
-            }),
-        }));
-        expect(result).toMatchObject({ stopReason: 'end_turn' });
-    });
-    it('should handle tool call permission request', async () => {
-        const confirmationDetails = {
-            type: 'info',
-            onConfirm: vi.fn(),
-        };
-        mockTool.build.mockReturnValue({
-            getDescription: () => 'Test Tool',
-            toolLocations: () => [],
-            shouldConfirmExecute: vi.fn().mockResolvedValue(confirmationDetails),
-            execute: vi.fn().mockResolvedValue({ llmContent: 'Tool Result' }),
-        });
-        mockConnection.requestPermission.mockResolvedValue({
-            outcome: {
-                outcome: 'selected',
-                optionId: ToolConfirmationOutcome.ProceedOnce,
-            },
-        });
-        const stream1 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: {
-                    functionCalls: [{ name: 'test_tool', args: {} }],
-                },
-            },
-        ]);
-        const stream2 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [] },
-            },
-        ]);
-        mockChat.sendMessageStream
-            .mockResolvedValueOnce(stream1)
-            .mockResolvedValueOnce(stream2);
-        await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'Call tool' }],
-        });
-        expect(mockConnection.requestPermission).toHaveBeenCalled();
-        expect(confirmationDetails.onConfirm).toHaveBeenCalledWith(ToolConfirmationOutcome.ProceedOnce);
-    });
-    it('should exclude always allow options when disableAlwaysAllow is true', async () => {
-        mockConfig.getDisableAlwaysAllow = vi.fn().mockReturnValue(true);
-        const confirmationDetails = {
-            type: 'info',
-            onConfirm: vi.fn(),
-        };
-        mockTool.build.mockReturnValue({
-            getDescription: () => 'Test Tool',
-            toolLocations: () => [],
-            shouldConfirmExecute: vi.fn().mockResolvedValue(confirmationDetails),
-            execute: vi.fn().mockResolvedValue({ llmContent: 'Tool Result' }),
-        });
-        mockConnection.requestPermission.mockResolvedValue({
-            outcome: {
-                outcome: 'selected',
-                optionId: ToolConfirmationOutcome.ProceedOnce,
-            },
-        });
-        const stream1 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: {
-                    functionCalls: [{ name: 'test_tool', args: {} }],
-                },
-            },
-        ]);
-        const stream2 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [] },
-            },
-        ]);
-        mockChat.sendMessageStream
-            .mockResolvedValueOnce(stream1)
-            .mockResolvedValueOnce(stream2);
-        await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'Call tool' }],
-        });
-        expect(mockConnection.requestPermission).toHaveBeenCalledWith(expect.objectContaining({
-            options: expect.not.arrayContaining([
-                expect.objectContaining({
-                    optionId: ToolConfirmationOutcome.ProceedAlways,
-                }),
-            ]),
-        }));
-    });
-    it('should exclude always allow and save permanent option when enablePermanentToolApproval is false', async () => {
-        mockConfig.getDisableAlwaysAllow = vi.fn().mockReturnValue(false);
-        const confirmationDetails = {
-            type: 'edit',
-            onConfirm: vi.fn(),
-        };
-        mockTool.build.mockReturnValue({
-            getDescription: () => 'Test Tool',
-            toolLocations: () => [],
-            shouldConfirmExecute: vi.fn().mockResolvedValue(confirmationDetails),
-            execute: vi.fn().mockResolvedValue({ llmContent: 'Tool Result' }),
-        });
-        const customSettings = {
-            system: { settings: {} },
-            systemDefaults: { settings: {} },
-            user: { settings: {} },
-            workspace: { settings: {} },
-            merged: {
-                security: { enablePermanentToolApproval: false },
-                mcpServers: {},
-            },
-            errors: [],
-        };
-        const localSession = new Session('session-2', mockChat, mockConfig, mockConnection, customSettings);
-        mockConnection.requestPermission.mockResolvedValueOnce({
-            outcome: {
-                outcome: 'selected',
-                optionId: ToolConfirmationOutcome.ProceedOnce,
-            },
-        });
-        const stream1 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: {
-                    functionCalls: [{ name: 'test_tool', args: {} }],
-                },
-            },
-        ]);
-        const stream2 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [] },
-            },
-        ]);
-        mockChat.sendMessageStream
-            .mockResolvedValueOnce(stream1)
-            .mockResolvedValueOnce(stream2);
-        await localSession.prompt({
-            sessionId: 'session-2',
-            prompt: [{ type: 'text', text: 'Call tool' }],
-        });
-        expect(mockConnection.requestPermission).toHaveBeenCalledWith(expect.objectContaining({
-            options: expect.not.arrayContaining([
-                expect.objectContaining({
-                    optionId: ToolConfirmationOutcome.ProceedAlwaysAndSave,
-                }),
-            ]),
-        }));
-        expect(mockConnection.requestPermission).toHaveBeenCalledWith(expect.objectContaining({
-            options: expect.arrayContaining([
-                expect.objectContaining({
-                    optionId: ToolConfirmationOutcome.ProceedAlways,
-                }),
-            ]),
-        }));
-    });
-    it('should include always allow and save permanent option when enablePermanentToolApproval is true', async () => {
-        mockConfig.getDisableAlwaysAllow = vi.fn().mockReturnValue(false);
-        const confirmationDetails = {
-            type: 'edit',
-            onConfirm: vi.fn(),
-        };
-        mockTool.build.mockReturnValue({
-            getDescription: () => 'Test Tool',
-            toolLocations: () => [],
-            shouldConfirmExecute: vi.fn().mockResolvedValue(confirmationDetails),
-            execute: vi.fn().mockResolvedValue({ llmContent: 'Tool Result' }),
-        });
-        const customSettings = {
-            system: { settings: {} },
-            systemDefaults: { settings: {} },
-            user: { settings: {} },
-            workspace: { settings: {} },
-            merged: {
-                security: { enablePermanentToolApproval: true },
-                mcpServers: {},
-            },
-            errors: [],
-        };
-        const localSession = new Session('session-2', mockChat, mockConfig, mockConnection, customSettings);
-        mockConnection.requestPermission.mockResolvedValueOnce({
-            outcome: {
-                outcome: 'selected',
-                optionId: ToolConfirmationOutcome.ProceedOnce,
-            },
-        });
-        const stream1 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: {
-                    functionCalls: [{ name: 'test_tool', args: {} }],
-                },
-            },
-        ]);
-        const stream2 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [] },
-            },
-        ]);
-        mockChat.sendMessageStream
-            .mockResolvedValueOnce(stream1)
-            .mockResolvedValueOnce(stream2);
-        await localSession.prompt({
-            sessionId: 'session-2',
-            prompt: [{ type: 'text', text: 'Call tool' }],
-        });
-        expect(mockConnection.requestPermission).toHaveBeenCalledWith(expect.objectContaining({
-            options: expect.arrayContaining([
-                expect.objectContaining({
-                    optionId: ToolConfirmationOutcome.ProceedAlwaysAndSave,
-                    name: 'Allow for this file in all future sessions',
-                }),
-            ]),
-        }));
-    });
-    it('should use filePath for ACP diff content in permission request', async () => {
-        const confirmationDetails = {
-            type: 'edit',
-            title: 'Confirm Write: test.txt',
-            fileName: 'test.txt',
-            filePath: '/tmp/test.txt',
-            originalContent: 'old',
-            newContent: 'new',
-            onConfirm: vi.fn(),
-        };
-        mockTool.build.mockReturnValue({
-            getDescription: () => 'Test Tool',
-            toolLocations: () => [],
-            shouldConfirmExecute: vi.fn().mockResolvedValue(confirmationDetails),
-            execute: vi.fn().mockResolvedValue({ llmContent: 'Tool Result' }),
-        });
-        mockConnection.requestPermission.mockResolvedValue({
-            outcome: {
-                outcome: 'selected',
-                optionId: ToolConfirmationOutcome.ProceedOnce,
-            },
-        });
-        const stream1 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: {
-                    functionCalls: [{ name: 'test_tool', args: {} }],
-                },
-            },
-        ]);
-        const stream2 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [] },
-            },
-        ]);
-        mockChat.sendMessageStream
-            .mockResolvedValueOnce(stream1)
-            .mockResolvedValueOnce(stream2);
-        await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'Call tool' }],
-        });
-        expect(mockConnection.requestPermission).toHaveBeenCalledWith(expect.objectContaining({
-            toolCall: expect.objectContaining({
-                content: expect.arrayContaining([
-                    expect.objectContaining({
-                        type: 'diff',
-                        path: '/tmp/test.txt',
-                        oldText: 'old',
-                        newText: 'new',
-                    }),
-                ]),
-            }),
-        }));
-    });
-    it('should split getDisplayTitle and getExplanation for title and content in permission request', async () => {
-        const confirmationDetails = {
-            type: 'info',
-            onConfirm: vi.fn(),
-        };
-        mockTool.build.mockReturnValue({
-            getDescription: () => 'Original Description',
-            getDisplayTitle: () => 'Display Title Only',
-            getExplanation: () => 'A detailed explanation text',
-            toolLocations: () => [],
-            shouldConfirmExecute: vi.fn().mockResolvedValue(confirmationDetails),
-            execute: vi.fn().mockResolvedValue({ llmContent: 'Tool Result' }),
-        });
-        mockConnection.requestPermission.mockResolvedValue({
-            outcome: {
-                outcome: 'selected',
-                optionId: ToolConfirmationOutcome.ProceedOnce,
-            },
-        });
-        const stream1 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: {
-                    functionCalls: [{ name: 'test_tool', args: {} }],
-                },
-            },
-        ]);
-        const stream2 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [] },
-            },
-        ]);
-        mockChat.sendMessageStream
-            .mockResolvedValueOnce(stream1)
-            .mockResolvedValueOnce(stream2);
-        await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'Call tool' }],
-        });
-        expect(mockConnection.requestPermission).toHaveBeenCalledWith(expect.objectContaining({
-            toolCall: expect.objectContaining({
-                title: 'Display Title Only',
-                content: [],
-            }),
-        }));
-        expect(mockConnection.sessionUpdate).toHaveBeenCalledWith(expect.objectContaining({
-            update: expect.objectContaining({
-                sessionUpdate: 'agent_thought_chunk',
-                content: { type: 'text', text: 'A detailed explanation text' },
-            }),
-        }));
-    });
-    it('should call updatePolicy when tool permission triggers always allow', async () => {
-        const confirmationDetails = {
-            type: 'info',
-            onConfirm: vi.fn(),
-        };
-        mockTool.build.mockReturnValue({
-            getDescription: () => 'Test Tool',
-            toolLocations: () => [],
-            shouldConfirmExecute: vi.fn().mockResolvedValue(confirmationDetails),
-            execute: vi.fn().mockResolvedValue({ llmContent: 'Tool Result' }),
-        });
-        mockConnection.requestPermission.mockResolvedValue({
-            outcome: {
-                outcome: 'selected',
-                optionId: ToolConfirmationOutcome.ProceedAlways,
-            },
-        });
-        const stream1 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: {
-                    functionCalls: [{ name: 'test_tool', args: {} }],
-                },
-            },
-        ]);
-        const stream2 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [] },
-            },
-        ]);
-        mockChat.sendMessageStream
-            .mockResolvedValueOnce(stream1)
-            .mockResolvedValueOnce(stream2);
-        const { updatePolicy } = await import('@google/gemini-cli-core');
-        await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'Call tool' }],
-        });
-        expect(confirmationDetails.onConfirm).toHaveBeenCalled();
-        expect(updatePolicy).toHaveBeenCalled();
-    });
-    it('should use filePath for ACP diff content in tool result', async () => {
-        mockTool.build.mockReturnValue({
-            getDescription: () => 'Test Tool',
-            toolLocations: () => [],
-            shouldConfirmExecute: vi.fn().mockResolvedValue(null),
-            execute: vi.fn().mockResolvedValue({
-                llmContent: 'Tool Result',
-                returnDisplay: {
-                    fileName: 'test.txt',
-                    filePath: '/tmp/test.txt',
-                    originalContent: 'old',
-                    newContent: 'new',
-                },
-            }),
-        });
-        const stream1 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: {
-                    functionCalls: [{ name: 'test_tool', args: {} }],
-                },
-            },
-        ]);
-        const stream2 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [] },
-            },
-        ]);
-        mockChat.sendMessageStream
-            .mockResolvedValueOnce(stream1)
-            .mockResolvedValueOnce(stream2);
-        await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'Call tool' }],
-        });
-        const updateCalls = mockConnection.sessionUpdate.mock.calls.map((call) => call[0]);
-        const toolCallUpdate = updateCalls.find((call) => call.update?.sessionUpdate === 'tool_call_update');
-        expect(toolCallUpdate).toEqual(expect.objectContaining({
-            update: expect.objectContaining({
-                content: expect.arrayContaining([
-                    expect.objectContaining({
-                        type: 'diff',
-                        path: '/tmp/test.txt',
-                        oldText: 'old',
-                        newText: 'new',
-                    }),
-                ]),
-            }),
-        }));
-    });
-    it('should handle tool call cancellation by user', async () => {
-        const confirmationDetails = {
-            type: 'info',
-            onConfirm: vi.fn(),
-        };
-        mockTool.build.mockReturnValue({
-            getDescription: () => 'Test Tool',
-            toolLocations: () => [],
-            shouldConfirmExecute: vi.fn().mockResolvedValue(confirmationDetails),
-            execute: vi.fn().mockResolvedValue({ llmContent: 'Tool Result' }),
-        });
-        mockConnection.requestPermission.mockResolvedValue({
-            outcome: { outcome: 'cancelled' },
-        });
-        const stream1 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: {
-                    functionCalls: [{ name: 'test_tool', args: {} }],
-                },
-            },
-        ]);
-        const stream2 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [] },
-            },
-        ]);
-        mockChat.sendMessageStream
-            .mockResolvedValueOnce(stream1)
-            .mockResolvedValueOnce(stream2);
-        await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'Call tool' }],
-        });
-        // When cancelled, it sends an error response to the model
-        // We can verify that the second call to sendMessageStream contains the error
-        expect(mockChat.sendMessageStream).toHaveBeenCalledTimes(2);
-        const secondCallArgs = mockChat.sendMessageStream.mock.calls[1];
-        const parts = secondCallArgs[1]; // parts
-        expect(parts).toEqual(expect.arrayContaining([
-            expect.objectContaining({
-                functionResponse: expect.objectContaining({
-                    response: {
-                        error: expect.stringContaining('canceled by the user'),
-                    },
-                }),
-            }),
-        ]));
-    });
-    it('should include _meta.kind in diff tool calls', async () => {
-        // Test 'add' (no original content)
-        const addConfirmation = {
-            type: 'edit',
-            fileName: 'new.txt',
-            originalContent: null,
-            newContent: 'New content',
-            onConfirm: vi.fn(),
-        };
-        // Test 'modify' (original and new content)
-        const modifyConfirmation = {
-            type: 'edit',
-            fileName: 'existing.txt',
-            originalContent: 'Old content',
-            newContent: 'New content',
-            onConfirm: vi.fn(),
-        };
-        // Test 'delete' (original content, no new content)
-        const deleteConfirmation = {
-            type: 'edit',
-            fileName: 'deleted.txt',
-            originalContent: 'Old content',
-            newContent: '',
-            onConfirm: vi.fn(),
-        };
-        const mockBuild = vi.fn();
-        mockTool.build = mockBuild;
-        // Helper to simulate tool call and check permission request
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const checkDiffKind = async (confirmation, expectedKind) => {
-            mockBuild.mockReturnValueOnce({
-                getDescription: () => 'Test Tool',
-                toolLocations: () => [],
-                shouldConfirmExecute: vi.fn().mockResolvedValue(confirmation),
-                execute: vi.fn().mockResolvedValue({ llmContent: 'Result' }),
-            });
-            mockConnection.requestPermission.mockResolvedValueOnce({
-                outcome: {
-                    outcome: 'selected',
-                    optionId: ToolConfirmationOutcome.ProceedOnce,
-                },
-            });
-            const stream = createMockStream([
-                {
-                    type: StreamEventType.CHUNK,
-                    value: {
-                        functionCalls: [{ name: 'test_tool', args: {} }],
-                    },
-                },
-            ]);
-            const emptyStream = createMockStream([]);
-            mockChat.sendMessageStream
-                .mockResolvedValueOnce(stream)
-                .mockResolvedValueOnce(emptyStream);
-            await session.prompt({
-                sessionId: 'session-1',
-                prompt: [{ type: 'text', text: 'Call tool' }],
-            });
-            expect(mockConnection.requestPermission).toHaveBeenCalledWith(expect.objectContaining({
-                toolCall: expect.objectContaining({
-                    content: expect.arrayContaining([
-                        expect.objectContaining({
-                            type: 'diff',
-                            _meta: { kind: expectedKind },
-                        }),
-                    ]),
-                }),
-            }));
-        };
-        await checkDiffKind(addConfirmation, 'add');
-        await checkDiffKind(modifyConfirmation, 'modify');
-        await checkDiffKind(deleteConfirmation, 'delete');
-    });
-    it('should handle @path resolution', async () => {
-        path.resolve.mockReturnValue('/tmp/file.txt');
-        fs.stat.mockResolvedValue({
-            isDirectory: () => false,
-        });
-        const stream = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [] },
-            },
-        ]);
-        mockChat.sendMessageStream.mockResolvedValue(stream);
-        await session.prompt({
-            sessionId: 'session-1',
-            prompt: [
-                { type: 'text', text: 'Read' },
-                {
-                    type: 'resource_link',
-                    uri: 'file://file.txt',
-                    mimeType: 'text/plain',
-                    name: 'file.txt',
-                },
-            ],
-        });
-        expect(path.resolve).toHaveBeenCalled();
-        expect(fs.stat).toHaveBeenCalled();
-        expect(mockConnection.sessionUpdate).toHaveBeenCalledWith(expect.objectContaining({
-            update: expect.objectContaining({
-                sessionUpdate: 'tool_call_update',
-                status: 'completed',
-                title: 'Read files',
-                locations: [],
-                kind: 'read',
-            }),
-        }));
-        // Verify ReadManyFilesTool was used (implicitly by checking if sendMessageStream was called with resolved content)
-        // Since we mocked ReadManyFilesTool to return specific content, we can check the args passed to sendMessageStream
-        expect(mockChat.sendMessageStream).toHaveBeenCalledWith(expect.anything(), expect.arrayContaining([
-            expect.objectContaining({
-                text: expect.stringContaining('Content from @file.txt'),
-            }),
-        ]), expect.anything(), expect.any(AbortSignal), LlmRole.MAIN);
-    });
-    it('should handle @path resolution error', async () => {
-        path.resolve.mockReturnValue('/tmp/error.txt');
-        fs.stat.mockResolvedValue({
-            isDirectory: () => false,
-        });
-        const MockReadManyFilesTool = ReadManyFilesTool;
-        MockReadManyFilesTool.mockImplementationOnce(() => ({
-            name: 'read_many_files',
-            kind: 'read',
-            build: vi.fn().mockReturnValue({
-                getDescription: () => 'Read files',
-                toolLocations: () => [],
-                execute: vi.fn().mockRejectedValue(new Error('File read failed')),
-            }),
-        }));
-        const stream = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [] },
-            },
-        ]);
-        mockChat.sendMessageStream.mockResolvedValue(stream);
-        await expect(session.prompt({
-            sessionId: 'session-1',
-            prompt: [
-                { type: 'text', text: 'Read' },
-                {
-                    type: 'resource_link',
-                    uri: 'file://error.txt',
-                    mimeType: 'text/plain',
-                    name: 'error.txt',
-                },
-            ],
-        })).rejects.toThrow('File read failed');
-        expect(mockConnection.sessionUpdate).toHaveBeenCalledWith(expect.objectContaining({
-            update: expect.objectContaining({
-                sessionUpdate: 'tool_call_update',
-                status: 'failed',
-                content: expect.arrayContaining([
-                    expect.objectContaining({
-                        content: expect.objectContaining({
-                            text: expect.stringMatching(/File read failed/),
-                        }),
-                    }),
-                ]),
-                kind: 'read',
-            }),
-        }));
-    });
-    it('should handle @path validation error and bubble it to user', async () => {
-        mockConfig.getTargetDir.mockReturnValue('/workspace');
-        path.resolve.mockReturnValue('/tmp/disallowed.txt');
-        mockConfig.validatePathAccess.mockReturnValue('Path is outside workspace');
-        // Force fs.stat to fail to skip direct reading and triggers the warning
-        fs.stat.mockRejectedValue(new Error('File not found'));
-        const stream = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [] },
-            },
-        ]);
-        mockChat.sendMessageStream.mockResolvedValue(stream);
-        await session.prompt({
-            sessionId: 'session-1',
-            prompt: [
-                {
-                    type: 'resource_link',
-                    uri: 'file://disallowed.txt',
-                    mimeType: 'text/plain',
-                    name: 'disallowed.txt',
-                },
-            ],
-        });
-        // Verify warning sent via sendUpdate
-        expect(mockConnection.sessionUpdate).toHaveBeenCalledWith(expect.objectContaining({
-            update: expect.objectContaining({
-                sessionUpdate: 'agent_thought_chunk',
-                content: expect.objectContaining({
-                    text: expect.stringContaining('Warning: skipping access to `disallowed.txt`. Reason: Path is outside workspace'),
-                }),
-            }),
-        }));
-    });
-    it('should read absolute file directly if outside workspace', async () => {
-        mockConfig.getTargetDir.mockReturnValue('/workspace');
-        const testFilePath = '/tmp/custom.txt';
-        path.resolve.mockReturnValue(testFilePath);
-        mockConfig.validatePathAccess.mockReturnValue('Path is outside workspace');
-        mockConnection.requestPermission.mockResolvedValue({
-            outcome: {
-                outcome: 'selected',
-                optionId: ToolConfirmationOutcome.ProceedOnce,
-            },
-        });
-        const mockStats = {
-            isFile: () => true,
-            isDirectory: () => false,
-        };
-        fs.stat.mockResolvedValue(mockStats);
-        processSingleFileContent.mockResolvedValue({
-            llmContent: 'Absolute File Content',
-        });
-        const stream = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [] },
-            },
-        ]);
-        mockChat.sendMessageStream.mockResolvedValue(stream);
-        await session.prompt({
-            sessionId: 'session-1',
-            prompt: [
-                {
-                    type: 'resource_link',
-                    uri: `file://${testFilePath}`,
-                    mimeType: 'text/plain',
-                    name: 'custom.txt',
-                },
-            ],
-        });
-        expect(processSingleFileContent).toHaveBeenCalledWith(testFilePath, expect.anything(), expect.anything());
-        // Verify content appended to sendMessageStream parts
-        expect(mockChat.sendMessageStream).toHaveBeenCalledWith(expect.anything(), expect.arrayContaining([
-            expect.objectContaining({
-                text: 'Absolute File Content',
-            }),
-        ]), expect.anything(), expect.any(AbortSignal), expect.anything());
-    });
-    it('should read escaping relative file directly if outside workspace', async () => {
-        mockConfig.getTargetDir.mockReturnValue('/workspace');
-        const testFilePath = '../../custom.txt';
-        path.resolve.mockReturnValue('/custom.txt');
-        mockConfig.validatePathAccess.mockReturnValue('Path is outside workspace');
-        mockConnection.requestPermission.mockResolvedValue({
-            outcome: {
-                outcome: 'selected',
-                optionId: ToolConfirmationOutcome.ProceedOnce,
-            },
-        });
-        const mockStats = {
-            isFile: () => true,
-            isDirectory: () => false,
-        };
-        fs.stat.mockResolvedValue(mockStats);
-        processSingleFileContent.mockResolvedValue({
-            llmContent: 'Escaping Relative File Content',
-        });
-        const stream = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [] },
-            },
-        ]);
-        mockChat.sendMessageStream.mockResolvedValue(stream);
-        await session.prompt({
-            sessionId: 'session-1',
-            prompt: [
-                {
-                    type: 'resource_link',
-                    uri: `file://${testFilePath}`,
-                    mimeType: 'text/plain',
-                    name: 'custom.txt',
-                },
-            ],
-        });
-        expect(processSingleFileContent).toHaveBeenCalledWith('/custom.txt', expect.any(String), expect.anything());
-        expect(mockChat.sendMessageStream).toHaveBeenCalledWith(expect.anything(), expect.arrayContaining([
-            expect.objectContaining({
-                text: 'Escaping Relative File Content',
-            }),
-        ]), expect.anything(), expect.any(AbortSignal), expect.anything());
-    });
-    it('should handle cancellation during prompt', async () => {
-        let streamController;
-        const stream = new ReadableStream({
-            start(controller) {
-                streamController = controller;
-            },
-        });
-        let streamStarted;
-        const streamStartedPromise = new Promise((resolve) => {
-            streamStarted = resolve;
-        });
-        // Adapt web stream to async iterable
-        async function* asyncStream() {
-            process.stdout.write('TEST: asyncStream started\n');
-            streamStarted(true);
-            const reader = stream.getReader();
-            try {
-                while (true) {
-                    process.stdout.write('TEST: waiting for read\n');
-                    const { done, value } = await reader.read();
-                    process.stdout.write(`TEST: read returned done=${done}\n`);
-                    if (done)
-                        break;
-                    yield value;
-                }
-            }
-            finally {
-                process.stdout.write('TEST: releasing lock\n');
-                reader.releaseLock();
-            }
-        }
-        mockChat.sendMessageStream.mockResolvedValue(asyncStream());
-        process.stdout.write('TEST: calling prompt\n');
-        const promptPromise = session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'Hi' }],
-        });
-        process.stdout.write('TEST: waiting for streamStarted\n');
-        await streamStartedPromise;
-        process.stdout.write('TEST: streamStarted\n');
-        await session.cancelPendingPrompt();
-        process.stdout.write('TEST: cancelled\n');
-        // Close the stream to allow prompt loop to continue and check aborted signal
-        streamController.close();
-        process.stdout.write('TEST: stream closed\n');
-        const result = await promptPromise;
-        process.stdout.write(`TEST: result received ${JSON.stringify(result)}\n`);
-        expect(result).toEqual({ stopReason: 'cancelled' });
-    });
-    it('should handle rate limit error', async () => {
-        const error = new Error('Rate limit');
-        error.status = 429;
-        mockChat.sendMessageStream.mockRejectedValue(error);
-        await expect(session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'Hi' }],
-        })).rejects.toMatchObject({
-            code: 429,
-            message: 'Rate limit exceeded. Try again later.',
-        });
-    });
-    it('should handle tool execution error', async () => {
-        mockTool.build.mockReturnValue({
-            getDescription: () => 'Test Tool',
-            toolLocations: () => [],
-            shouldConfirmExecute: vi.fn().mockResolvedValue(null),
-            execute: vi.fn().mockRejectedValue(new Error('Tool failed')),
-        });
-        const stream1 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: {
-                    functionCalls: [{ name: 'test_tool', args: {} }],
-                },
-            },
-        ]);
-        const stream2 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [] },
-            },
-        ]);
-        mockChat.sendMessageStream
-            .mockResolvedValueOnce(stream1)
-            .mockResolvedValueOnce(stream2);
-        await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'Call tool' }],
-        });
-        expect(mockConnection.sessionUpdate).toHaveBeenCalledWith(expect.objectContaining({
-            update: expect.objectContaining({
-                sessionUpdate: 'tool_call_update',
-                status: 'failed',
-                content: expect.arrayContaining([
-                    expect.objectContaining({
-                        content: expect.objectContaining({ text: 'Tool failed' }),
-                    }),
-                ]),
-                kind: 'read',
-            }),
-        }));
-    });
-    it('should handle missing tool', async () => {
-        mockToolRegistry.getTool.mockReturnValue(undefined);
-        const stream1 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: {
-                    functionCalls: [{ name: 'unknown_tool', args: {} }],
-                },
-            },
-        ]);
-        const stream2 = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [] },
-            },
-        ]);
-        mockChat.sendMessageStream
-            .mockResolvedValueOnce(stream1)
-            .mockResolvedValueOnce(stream2);
-        await session.prompt({
-            sessionId: 'session-1',
-            prompt: [{ type: 'text', text: 'Call tool' }],
-        });
-        // Should send error response to model
-        expect(mockChat.sendMessageStream).toHaveBeenCalledTimes(2);
-        const secondCallArgs = mockChat.sendMessageStream.mock.calls[1];
-        const parts = secondCallArgs[1];
-        expect(parts).toEqual(expect.arrayContaining([
-            expect.objectContaining({
-                functionResponse: expect.objectContaining({
-                    response: {
-                        error: expect.stringContaining('not found in registry'),
-                    },
-                }),
-            }),
-        ]));
-    });
-    it('should ignore files based on configuration', async () => {
-        mockConfig.getFileService().shouldIgnoreFile.mockReturnValue(true);
-        const stream = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [] },
-            },
-        ]);
-        mockChat.sendMessageStream.mockResolvedValue(stream);
-        await session.prompt({
-            sessionId: 'session-1',
-            prompt: [
-                {
-                    type: 'resource_link',
-                    uri: 'file://ignored.txt',
-                    mimeType: 'text/plain',
-                    name: 'ignored.txt',
-                },
-            ],
-        });
-        // Should not read file
-        expect(mockToolRegistry.getTool).not.toHaveBeenCalledWith('read_many_files');
-    });
-    it('should handle directory resolution with glob', async () => {
-        path.resolve.mockReturnValue('/tmp/dir');
-        fs.stat.mockResolvedValue({
-            isDirectory: () => true,
-        });
-        const stream = createMockStream([
-            {
-                type: StreamEventType.CHUNK,
-                value: { candidates: [] },
-            },
-        ]);
-        mockChat.sendMessageStream.mockResolvedValue(stream);
-        await session.prompt({
-            sessionId: 'session-1',
-            prompt: [
-                {
-                    type: 'resource_link',
-                    uri: 'file://dir',
-                    mimeType: 'text/plain',
-                    name: 'dir',
-                },
-            ],
-        });
-        // Should use glob
-        // ReadManyFilesTool is instantiated directly, so we check if the mock instance's build method was called
-        const MockReadManyFilesTool = ReadManyFilesTool;
-        const mockInstance = MockReadManyFilesTool.mock.results[MockReadManyFilesTool.mock.results.length - 1].value;
-        expect(mockInstance.build).toHaveBeenCalled();
-    });
-    it('should set mode on config', () => {
-        session.setMode(ApprovalMode.AUTO_EDIT);
-        expect(mockConfig.setApprovalMode).toHaveBeenCalledWith(ApprovalMode.AUTO_EDIT);
-    });
-    it('should throw error for invalid mode', () => {
-        expect(() => session.setMode('invalid-mode')).toThrow('Invalid or unavailable mode: invalid-mode');
-    });
-    it('should set model on config', () => {
-        session.setModel('gemini-2.0-flash-exp');
-        expect(mockConfig.setModel).toHaveBeenCalledWith('gemini-2.0-flash-exp');
-    });
-    it('should handle unquoted commands from autocomplete (with empty leading parts)', async () => {
-        // Mock handleCommand to verify it gets called
-        const handleCommandSpy = vi
-            .spyOn(session
-            .commandHandler, 'handleCommand')
-            .mockResolvedValue(true);
-        await session.prompt({
-            sessionId: 'session-1',
-            prompt: [
-                { type: 'text', text: '' },
-                { type: 'text', text: '/memory' },
-            ],
-        });
-        expect(handleCommandSpy).toHaveBeenCalledWith('/memory', expect.anything());
-    });
-});
-//# sourceMappingURL=acpClient.test.js.map