@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/acp/acpSessionManager.js

@@ -0,0 +1,200 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AuthType, MCPServerConfig, debugLogger, startupProfiler, convertSessionToClientHistory, createPolicyUpdater, } from '@google/gemini-cli-core';
+import * as acp from '@agentclientprotocol/sdk';
+import { randomUUID } from 'node:crypto';
+import { loadSettings } from '../config/settings.js';
+import { SessionSelector } from '../utils/sessionUtils.js';
+import { Session } from './acpSession.js';
+import { AcpFileSystemService } from './acpFileSystemService.js';
+import { getAcpErrorMessage } from './acpErrors.js';
+import { buildAvailableModels, buildAvailableModes } from './acpUtils.js';
+import { loadCliConfig } from '../config/config.js';
+import { startAutoMemoryIfEnabled } from '../utils/autoMemory.js';
+export class AcpSessionManager {
+    settings;
+    argv;
+    connection;
+    sessions = new Map();
+    clientCapabilities;
+    constructor(settings, argv, connection) {
+        this.settings = settings;
+        this.argv = argv;
+        this.connection = connection;
+    }
+    setClientCapabilities(capabilities) {
+        this.clientCapabilities = capabilities;
+    }
+    getSession(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    dispose() {
+        for (const session of this.sessions.values()) {
+            session.dispose();
+        }
+        this.sessions.clear();
+    }
+    async newSession({ cwd, mcpServers }, authDetails) {
+        const sessionId = randomUUID();
+        const loadedSettings = loadSettings(cwd);
+        const config = await this.newSessionConfig(sessionId, cwd, mcpServers, loadedSettings);
+        const authType = loadedSettings.merged.security.auth.selectedType ||
+            (authDetails.baseUrl || process.env['GOOGLE_GEMINI_BASE_URL']
+                ? AuthType.GATEWAY
+                : AuthType.USE_GEMINI);
+        let isAuthenticated = false;
+        let authErrorMessage = '';
+        try {
+            await config.refreshAuth(authType, authDetails.apiKey, authDetails.baseUrl, authDetails.customHeaders);
+            isAuthenticated = true;
+            // Extra validation for Gemini API key
+            const contentGeneratorConfig = config.getContentGeneratorConfig();
+            if (authType === AuthType.USE_GEMINI &&
+                (!contentGeneratorConfig || !contentGeneratorConfig.apiKey)) {
+                isAuthenticated = false;
+                authErrorMessage = 'Gemini API key is missing or not configured.';
+            }
+        }
+        catch (e) {
+            isAuthenticated = false;
+            authErrorMessage = getAcpErrorMessage(e);
+            debugLogger.error(`Authentication failed: ${e instanceof Error ? e.stack : e}`);
+        }
+        if (!isAuthenticated) {
+            throw new acp.RequestError(-32000, authErrorMessage || 'Authentication required.');
+        }
+        if (this.clientCapabilities?.fs) {
+            const acpFileSystemService = new AcpFileSystemService(this.connection, sessionId, this.clientCapabilities.fs, config.getFileSystemService(), cwd);
+            config.setFileSystemService(acpFileSystemService);
+        }
+        await config.initialize();
+        startupProfiler.flush(config);
+        startAutoMemoryIfEnabled(config);
+        const geminiClient = config.getGeminiClient();
+        const chat = await geminiClient.startChat();
+        const session = new Session(sessionId, chat, config, this.connection, this.settings);
+        this.sessions.set(sessionId, session);
+        setTimeout(() => {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            session.sendAvailableCommands();
+        }, 0);
+        const { availableModels, currentModelId } = buildAvailableModels(config, loadedSettings);
+        const response = {
+            sessionId,
+            modes: {
+                availableModes: buildAvailableModes(config.isPlanEnabled()),
+                currentModeId: config.getApprovalMode(),
+            },
+            models: {
+                availableModels,
+                currentModelId,
+            },
+        };
+        return response;
+    }
+    async loadSession({ sessionId, cwd, mcpServers }, authDetails) {
+        const config = await this.initializeSessionConfig(sessionId, cwd, mcpServers, authDetails);
+        const sessionSelector = new SessionSelector(config.storage);
+        const { sessionData, sessionPath } = await sessionSelector.resolveSession(sessionId);
+        const clientHistory = convertSessionToClientHistory(sessionData.messages);
+        const geminiClient = config.getGeminiClient();
+        await geminiClient.initialize();
+        await geminiClient.resumeChat(clientHistory, {
+            conversation: sessionData,
+            filePath: sessionPath,
+        });
+        const session = new Session(sessionId, geminiClient.getChat(), config, this.connection, this.settings);
+        const existingSession = this.sessions.get(sessionId);
+        if (existingSession) {
+            existingSession.dispose();
+        }
+        this.sessions.set(sessionId, session);
+        // Stream history back to client
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        session.streamHistory(sessionData.messages);
+        setTimeout(() => {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            session.sendAvailableCommands();
+        }, 0);
+        const { availableModels, currentModelId } = buildAvailableModels(config, this.settings);
+        const response = {
+            modes: {
+                availableModes: buildAvailableModes(config.isPlanEnabled()),
+                currentModeId: config.getApprovalMode(),
+            },
+            models: {
+                availableModels,
+                currentModelId,
+            },
+        };
+        return response;
+    }
+    async initializeSessionConfig(sessionId, cwd, mcpServers, authDetails) {
+        const selectedAuthType = this.settings.merged.security.auth.selectedType ||
+            (authDetails.baseUrl || process.env['GOOGLE_GEMINI_BASE_URL']
+                ? AuthType.GATEWAY
+                : undefined);
+        if (!selectedAuthType) {
+            throw acp.RequestError.authRequired();
+        }
+        // 1. Create config WITHOUT initializing it (no MCP servers started yet)
+        const config = await this.newSessionConfig(sessionId, cwd, mcpServers);
+        // 2. Authenticate BEFORE initializing configuration or starting MCP servers.
+        // This satisfies the security requirement to verify the user before executing
+        // potentially unsafe server definitions.
+        try {
+            await config.refreshAuth(selectedAuthType, authDetails.apiKey, authDetails.baseUrl, authDetails.customHeaders);
+        }
+        catch (e) {
+            debugLogger.error(`Authentication failed: ${e}`);
+            throw acp.RequestError.authRequired();
+        }
+        // 3. Set the ACP FileSystemService (if supported) before config initialization
+        if (this.clientCapabilities?.fs) {
+            const acpFileSystemService = new AcpFileSystemService(this.connection, sessionId, this.clientCapabilities.fs, config.getFileSystemService(), cwd);
+            config.setFileSystemService(acpFileSystemService);
+        }
+        // 4. Now that we are authenticated, it is safe to initialize the config
+        // which starts the MCP servers and other heavy resources.
+        await config.initialize();
+        startupProfiler.flush(config);
+        startAutoMemoryIfEnabled(config);
+        return config;
+    }
+    async newSessionConfig(sessionId, cwd, mcpServers, loadedSettings) {
+        const currentSettings = loadedSettings || this.settings;
+        const mergedMcpServers = { ...currentSettings.merged.mcpServers };
+        for (const server of mcpServers) {
+            if ('type' in server &&
+                (server.type === 'sse' || server.type === 'http')) {
+                // HTTP or SSE MCP server
+                const headers = Object.fromEntries(server.headers.map(({ name, value }) => [name, value]));
+                mergedMcpServers[server.name] = new MCPServerConfig(undefined, // command
+                undefined, // args
+                undefined, // env
+                undefined, // cwd
+                server.type === 'sse' ? server.url : undefined, // url (sse)
+                server.type === 'http' ? server.url : undefined, // httpUrl
+                headers);
+            }
+            else if ('command' in server) {
+                // Stdio MCP server
+                const env = {};
+                for (const { name: envName, value } of server.env) {
+                    env[envName] = value;
+                }
+                mergedMcpServers[server.name] = new MCPServerConfig(server.command, server.args, env, cwd);
+            }
+        }
+        const settings = {
+            ...currentSettings.merged,
+            mcpServers: mergedMcpServers,
+        };
+        const config = await loadCliConfig(settings, sessionId, this.argv, { cwd });
+        createPolicyUpdater(config.getPolicyEngine(), config.messageBus, config.storage);
+        return config;
+    }
+}

package/dist/acp/acpStdioTransport.js

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createWorkingStdio } from '@google/gemini-cli-core';
+import { runExitCleanup } from '../utils/cleanup.js';
+import * as acp from '@agentclientprotocol/sdk';
+import { Readable, Writable } from 'node:stream';
+import { GeminiAgent } from './acpRpcDispatcher.js';
+export async function runAcpClient(config, settings, argv) {
+    const { stdout: workingStdout } = createWorkingStdio();
+    const stdout = Writable.toWeb(workingStdout);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const stdin = Readable.toWeb(process.stdin);
+    const stream = acp.ndJsonStream(stdout, stdin);
+    const connection = new acp.AgentSideConnection((connection) => new GeminiAgent(config, settings, argv, connection), stream);
+    // SIGTERM/SIGINT handlers (in sdk.ts) don't fire when stdin closes.
+    // We must explicitly await the connection close to flush telemetry.
+    // Use finally() to ensure cleanup runs even on stream errors.
+    await connection.closed.finally(runExitCleanup);
+}

package/dist/acp/acpUtils.js

@@ -0,0 +1,287 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Kind, ApprovalMode, GEMINI_MODEL_ALIAS_AUTO, DEFAULT_GEMINI_MODEL, DEFAULT_GEMINI_FLASH_MODEL, DEFAULT_GEMINI_FLASH_LITE_MODEL, PREVIEW_GEMINI_3_1_MODEL, PREVIEW_GEMINI_MODEL, PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL, PREVIEW_GEMINI_FLASH_MODEL, PREVIEW_GEMINI_FLASH_LITE_MODEL, getDisplayString, AuthType, ToolConfirmationOutcome, getAutoModelDescription, } from '@google/gemini-cli-core';
+import { z } from 'zod';
+export function hasMeta(obj) {
+    return typeof obj === 'object' && obj !== null && '_meta' in obj;
+}
+export const RequestPermissionResponseSchema = z.object({
+    outcome: z.discriminatedUnion('outcome', [
+        z.object({ outcome: z.literal('cancelled') }),
+        z.object({
+            outcome: z.literal('selected'),
+            optionId: z.string(),
+        }),
+    ]),
+});
+export function toToolCallContent(toolResult) {
+    if (toolResult.error?.message) {
+        throw new Error(toolResult.error.message);
+    }
+    if (toolResult.returnDisplay) {
+        if (typeof toolResult.returnDisplay === 'string') {
+            return {
+                type: 'content',
+                content: { type: 'text', text: toolResult.returnDisplay },
+            };
+        }
+        else {
+            if ('fileName' in toolResult.returnDisplay) {
+                return {
+                    type: 'diff',
+                    path: toolResult.returnDisplay.filePath ??
+                        toolResult.returnDisplay.fileName,
+                    oldText: toolResult.returnDisplay.originalContent,
+                    newText: toolResult.returnDisplay.newContent,
+                    _meta: {
+                        kind: !toolResult.returnDisplay.originalContent
+                            ? 'add'
+                            : toolResult.returnDisplay.newContent === ''
+                                ? 'delete'
+                                : 'modify',
+                    },
+                };
+            }
+            return null;
+        }
+    }
+    else {
+        return null;
+    }
+}
+const basicPermissionOptions = [
+    {
+        optionId: ToolConfirmationOutcome.ProceedOnce,
+        name: 'Allow',
+        kind: 'allow_once',
+    },
+    {
+        optionId: ToolConfirmationOutcome.Cancel,
+        name: 'Reject',
+        kind: 'reject_once',
+    },
+];
+export function toPermissionOptions(confirmation, config, enablePermanentToolApproval = false) {
+    const disableAlwaysAllow = config.getDisableAlwaysAllow();
+    const options = [];
+    if (!disableAlwaysAllow) {
+        switch (confirmation.type) {
+            case 'edit':
+                options.push({
+                    optionId: ToolConfirmationOutcome.ProceedAlways,
+                    name: 'Allow for this session',
+                    kind: 'allow_always',
+                });
+                if (enablePermanentToolApproval) {
+                    options.push({
+                        optionId: ToolConfirmationOutcome.ProceedAlwaysAndSave,
+                        name: 'Allow for this file in all future sessions',
+                        kind: 'allow_always',
+                    });
+                }
+                break;
+            case 'exec':
+                options.push({
+                    optionId: ToolConfirmationOutcome.ProceedAlways,
+                    name: 'Allow for this session',
+                    kind: 'allow_always',
+                });
+                if (enablePermanentToolApproval) {
+                    options.push({
+                        optionId: ToolConfirmationOutcome.ProceedAlwaysAndSave,
+                        name: 'Allow this command for all future sessions',
+                        kind: 'allow_always',
+                    });
+                }
+                break;
+            case 'mcp':
+                options.push({
+                    optionId: ToolConfirmationOutcome.ProceedAlwaysServer,
+                    name: 'Allow all server tools for this session',
+                    kind: 'allow_always',
+                }, {
+                    optionId: ToolConfirmationOutcome.ProceedAlwaysTool,
+                    name: 'Allow tool for this session',
+                    kind: 'allow_always',
+                });
+                if (enablePermanentToolApproval) {
+                    options.push({
+                        optionId: ToolConfirmationOutcome.ProceedAlwaysAndSave,
+                        name: 'Allow tool for all future sessions',
+                        kind: 'allow_always',
+                    });
+                }
+                break;
+            case 'info':
+                options.push({
+                    optionId: ToolConfirmationOutcome.ProceedAlways,
+                    name: 'Allow for this session',
+                    kind: 'allow_always',
+                });
+                if (enablePermanentToolApproval) {
+                    options.push({
+                        optionId: ToolConfirmationOutcome.ProceedAlwaysAndSave,
+                        name: 'Allow for all future sessions',
+                        kind: 'allow_always',
+                    });
+                }
+                break;
+            case 'ask_user':
+            case 'exit_plan_mode':
+                // askuser and exit_plan_mode don't need "always allow" options
+                break;
+            default:
+                // No "always allow" options for other types
+                break;
+        }
+    }
+    options.push(...basicPermissionOptions);
+    // Exhaustive check
+    switch (confirmation.type) {
+        case 'edit':
+        case 'exec':
+        case 'mcp':
+        case 'info':
+        case 'ask_user':
+        case 'exit_plan_mode':
+        case 'sandbox_expansion':
+            break;
+        default: {
+            const unreachable = confirmation;
+            throw new Error(`Unexpected: ${unreachable}`);
+        }
+    }
+    return options;
+}
+export function toAcpToolKind(kind) {
+    switch (kind) {
+        case Kind.Read:
+        case Kind.Edit:
+        case Kind.Execute:
+        case Kind.Search:
+        case Kind.Delete:
+        case Kind.Move:
+        case Kind.Think:
+        case Kind.Fetch:
+        case Kind.SwitchMode:
+        case Kind.Other:
+            return kind;
+        case Kind.Agent:
+            return 'think';
+        case Kind.Plan:
+        case Kind.Communicate:
+        default:
+            return 'other';
+    }
+}
+export function buildAvailableModes(isPlanEnabled) {
+    const modes = [
+        {
+            id: ApprovalMode.DEFAULT,
+            name: 'Default',
+            description: 'Prompts for approval',
+        },
+        {
+            id: ApprovalMode.AUTO_EDIT,
+            name: 'Auto Edit',
+            description: 'Auto-approves edit tools',
+        },
+        {
+            id: ApprovalMode.YOLO,
+            name: 'YOLO',
+            description: 'Auto-approves all tools',
+        },
+    ];
+    if (isPlanEnabled) {
+        modes.push({
+            id: ApprovalMode.PLAN,
+            name: 'Plan',
+            description: 'Read-only mode',
+        });
+    }
+    return modes;
+}
+export function buildAvailableModels(config, settings) {
+    const preferredModel = config.getModel() || GEMINI_MODEL_ALIAS_AUTO;
+    const shouldShowPreviewModels = config.getHasAccessToPreviewModel();
+    const useGemini31 = config.getGemini31LaunchedSync?.() ?? false;
+    const useGemini3_5Flash = config.hasGemini35FlashGAAccess?.() ?? false;
+    const selectedAuthType = settings.merged.security.auth.selectedType;
+    const useCustomToolModel = useGemini31 && selectedAuthType === AuthType.USE_GEMINI;
+    // --- DYNAMIC PATH ---
+    if (config.getExperimentalDynamicModelConfiguration?.() === true &&
+        config.getModelConfigService) {
+        const options = config.getModelConfigService().getAvailableModelOptions({
+            useGemini3_1: useGemini31,
+            useGemini3_5Flash,
+            useCustomTools: useCustomToolModel,
+            hasAccessToPreview: shouldShowPreviewModels,
+        });
+        return {
+            availableModels: options,
+            currentModelId: preferredModel,
+        };
+    }
+    // --- LEGACY PATH ---
+    const mainOptions = [
+        {
+            value: GEMINI_MODEL_ALIAS_AUTO,
+            title: getDisplayString(GEMINI_MODEL_ALIAS_AUTO),
+            description: getAutoModelDescription(shouldShowPreviewModels, useGemini31, useGemini3_5Flash),
+        },
+    ];
+    const manualOptions = [
+        {
+            value: DEFAULT_GEMINI_MODEL,
+            title: getDisplayString(DEFAULT_GEMINI_MODEL),
+        },
+        {
+            value: DEFAULT_GEMINI_FLASH_MODEL,
+            title: getDisplayString(DEFAULT_GEMINI_FLASH_MODEL),
+        },
+        {
+            value: DEFAULT_GEMINI_FLASH_LITE_MODEL,
+            title: getDisplayString(DEFAULT_GEMINI_FLASH_LITE_MODEL),
+        },
+    ];
+    if (shouldShowPreviewModels) {
+        const previewProModel = useGemini31
+            ? PREVIEW_GEMINI_3_1_MODEL
+            : PREVIEW_GEMINI_MODEL;
+        const previewProValue = useCustomToolModel
+            ? PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL
+            : previewProModel;
+        const previewOptions = [
+            {
+                value: previewProValue,
+                title: getDisplayString(previewProModel),
+            },
+            {
+                value: PREVIEW_GEMINI_FLASH_MODEL,
+                title: getDisplayString(PREVIEW_GEMINI_FLASH_MODEL),
+            },
+        ];
+        if (PREVIEW_GEMINI_FLASH_LITE_MODEL !== 'none') {
+            previewOptions.push({
+                value: PREVIEW_GEMINI_FLASH_LITE_MODEL,
+                title: getDisplayString(PREVIEW_GEMINI_FLASH_LITE_MODEL),
+            });
+        }
+        manualOptions.unshift(...previewOptions);
+    }
+    const scaleOptions = (options) => options.map((o) => ({
+        modelId: o.value,
+        name: o.title,
+        description: o.description,
+    }));
+    return {
+        availableModels: [
+            ...scaleOptions(mainOptions),
+            ...scaleOptions(manualOptions),
+        ],
+        currentModelId: preferredModel,
+    };
+}

package/dist/acp/commands/about.js

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { IdeClient, UserAccountManager, getVersion, } from '@google/gemini-cli-core';
+import process from 'node:process';
+export class AboutCommand {
+    name = 'about';
+    description = 'Show version and environment info';
+    async execute(context, _args = []) {
+        const osVersion = process.platform;
+        let sandboxEnv = 'no sandbox';
+        if (process.env['SANDBOX'] && process.env['SANDBOX'] !== 'sandbox-exec') {
+            sandboxEnv = process.env['SANDBOX'];
+        }
+        else if (process.env['SANDBOX'] === 'sandbox-exec') {
+            sandboxEnv = `sandbox-exec (${process.env['SEATBELT_PROFILE'] || 'unknown'})`;
+        }
+        const modelVersion = context.agentContext.config.getModel() || 'Unknown';
+        const cliVersion = await getVersion();
+        const selectedAuthType = context.settings.merged?.security?.auth?.selectedType ?? '';
+        const gcpProject = process.env['GOOGLE_CLOUD_PROJECT'] || '';
+        const ideClient = await getIdeClientName(context);
+        const userAccountManager = new UserAccountManager();
+        const cachedAccount = userAccountManager.getCachedGoogleAccount();
+        const userEmail = cachedAccount ?? 'Unknown';
+        const tier = context.agentContext.config.getUserTierName() || 'Unknown';
+        const info = [
+            `- Version: ${cliVersion}`,
+            `- OS: ${osVersion}`,
+            `- Sandbox: ${sandboxEnv}`,
+            `- Model: ${modelVersion}`,
+            `- Auth Type: ${selectedAuthType}`,
+            `- GCP Project: ${gcpProject}`,
+            `- IDE Client: ${ideClient}`,
+            `- User Email: ${userEmail}`,
+            `- Tier: ${tier}`,
+        ].join('\n');
+        return {
+            name: this.name,
+            data: `Gemini CLI Info:\n${info}`,
+        };
+    }
+}
+async function getIdeClientName(context) {
+    if (!context.agentContext.config.getIdeMode()) {
+        return '';
+    }
+    const ideClient = await IdeClient.getInstance();
+    return ideClient?.getDetectedIdeDisplayName() ?? '';
+}

package/dist/acp/commands/commandRegistry.js

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { debugLogger } from '@google/gemini-cli-core';
+export class CommandRegistry {
+    commands = new Map();
+    register(command) {
+        if (this.commands.has(command.name)) {
+            debugLogger.warn(`Command ${command.name} already registered. Skipping.`);
+            return;
+        }
+        this.commands.set(command.name, command);
+        for (const subCommand of command.subCommands ?? []) {
+            this.register(subCommand);
+        }
+    }
+    get(commandName) {
+        return this.commands.get(commandName);
+    }
+    getAllCommands() {
+        return [...this.commands.values()];
+    }
+}