@machina.ai/cell-cli 1.33.0-rc1 → 1.38.1-rc1

package/dist/src/{zed-integration/zedIntegration.js → acp/acpClient.js}

@@ -3,20 +3,35 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { AuthType, logToolCall, convertToFunctionResponse, ToolConfirmationOutcome, clearCachedCredentialFile, isNodeError, getErrorMessage, isWithinRoot, getErrorStatus, MCPServerConfig, DiscoveredMCPTool, StreamEventType, ToolCallEvent, debugLogger, ReadManyFilesTool, REFERENCE_CONTENT_START, resolveModel, createWorkingStdio, startupProfiler, Kind, partListUnionToString, } from '@google/gemini-cli-core';
+import { CoreToolCallStatus, AuthType, logToolCall, convertToFunctionResponse, ToolConfirmationOutcome, clearCachedCredentialFile, isNodeError, getErrorMessage, isWithinRoot, getErrorStatus, MCPServerConfig, DiscoveredMCPTool, StreamEventType, ToolCallEvent, debugLogger, ReadManyFilesTool, REFERENCE_CONTENT_START, createWorkingStdio, startupProfiler, Kind, partListUnionToString, LlmRole, ApprovalMode, getVersion, convertSessionToClientHistory, DEFAULT_GEMINI_MODEL, DEFAULT_GEMINI_FLASH_MODEL, DEFAULT_GEMINI_FLASH_LITE_MODEL, PREVIEW_GEMINI_MODEL, PREVIEW_GEMINI_3_1_MODEL, PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL, PREVIEW_GEMINI_3_1_CUSTOM_TOOLS_MODEL, PREVIEW_GEMINI_FLASH_MODEL, DEFAULT_GEMINI_MODEL_AUTO, PREVIEW_GEMINI_MODEL_AUTO, getDisplayString, processSingleFileContent, InvalidStreamError, updatePolicy, } from '@google/gemini-cli-core';
 import * as acp from '@agentclientprotocol/sdk';
 import { AcpFileSystemService } from './fileSystemService.js';
 import { getAcpErrorMessage } from './acpErrors.js';
 import { Readable, Writable } from 'node:stream';
-import { SettingScope, loadSettings } from '../config/settings.js';
+function hasMeta(obj) {
+    return typeof obj === 'object' && obj !== null && '_meta' in obj;
+}
+import { SettingScope, loadSettings, } from '../config/settings.js';
+import { createPolicyUpdater } from '../config/policy.js';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { z } from 'zod';
 import { randomUUID } from 'node:crypto';
 import { loadCliConfig } from '../config/config.js';
 import { runExitCleanup } from '../utils/cleanup.js';
-import { SessionSelector, convertSessionToHistoryFormats, } from '../utils/sessionUtils.js';
-export async function runZedIntegration(config, settings, argv) {
+import { SessionSelector } from '../utils/sessionUtils.js';
+import { CommandHandler } from './commandHandler.js';
+const RequestPermissionResponseSchema = z.object({
+    outcome: z.discriminatedUnion('outcome', [
+        z.object({ outcome: z.literal('cancelled') }),
+        z.object({
+            outcome: z.literal('selected'),
+            optionId: z.string(),
+        }),
+    ]),
+});
+export async function runAcpClient(config, settings, argv) {
+    // ... (skip unchanged lines) ...
     const { stdout: workingStdout } = createWorkingStdio();
     const stdout = Writable.toWeb(workingStdout);
     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
@@ -29,14 +44,21 @@ export async function runZedIntegration(config, settings, argv) {
     await connection.closed.finally(runExitCleanup);
 }
 export class GeminiAgent {
-    config;
+    context;
     settings;
     argv;
     connection;
+    static callIdCounter = 0;
+    static generateCallId(name) {
+        return `${name}-${Date.now()}-${++GeminiAgent.callIdCounter}`;
+    }
     sessions = new Map();
     clientCapabilities;
-    constructor(config, settings, argv, connection) {
-        this.config = config;
+    apiKey;
+    baseUrl;
+    customHeaders;
+    constructor(context, settings, argv, connection) {
+        this.context = context;
         this.settings = settings;
         this.argv = argv;
         this.connection = connection;
@@ -47,22 +69,45 @@ export class GeminiAgent {
             {
                 id: AuthType.LOGIN_WITH_GOOGLE,
                 name: 'Log in with Google',
-                description: null,
+                description: 'Log in with your Google account',
             },
             {
                 id: AuthType.USE_GEMINI,
-                name: 'Use Gemini API key',
-                description: 'Requires setting the `GEMINI_API_KEY` environment variable',
+                name: 'Gemini API key',
+                description: 'Use an API key with Gemini Developer API',
+                _meta: {
+                    'api-key': {
+                        provider: 'google',
+                    },
+                },
             },
             {
                 id: AuthType.USE_VERTEX_AI,
                 name: 'Vertex AI',
-                description: null,
+                description: 'Use an API key with Vertex AI GenAI API',
+            },
+            {
+                id: AuthType.GATEWAY,
+                name: 'AI API Gateway',
+                description: 'Use a custom AI API Gateway',
+                _meta: {
+                    gateway: {
+                        protocol: 'google',
+                        restartRequired: 'false',
+                    },
+                },
             },
         ];
+        await this.context.config.initialize();
+        const version = await getVersion();
         return {
             protocolVersion: acp.PROTOCOL_VERSION,
             authMethods,
+            agentInfo: {
+                name: 'gemini-cli',
+                title: 'Cell CLI',
+                version,
+            },
             agentCapabilities: {
                 loadSession: true,
                 promptCapabilities: {
@@ -77,21 +122,47 @@ export class GeminiAgent {
             },
         };
     }
-    async authenticate({ methodId }) {
+    async authenticate(req) {
+        const { methodId } = req;
         const method = z.nativeEnum(AuthType).parse(methodId);
         const selectedAuthType = this.settings.merged.security.auth.selectedType;
         // Only clear credentials when switching to a different auth method
         if (selectedAuthType && selectedAuthType !== method) {
             await clearCachedCredentialFile();
         }
+        // Check for api-key in _meta
+        const meta = hasMeta(req) ? req._meta : undefined;
+        const apiKey = typeof meta?.['api-key'] === 'string' ? meta['api-key'] : undefined;
         // Refresh auth with the requested method
         // This will reuse existing credentials if they're valid,
         // or perform new authentication if needed
         try {
-            await this.config.refreshAuth(method);
+            if (apiKey) {
+                this.apiKey = apiKey;
+            }
+            // Extract gateway details if present
+            const gatewaySchema = z.object({
+                baseUrl: z.string().optional(),
+                headers: z.record(z.string()).optional(),
+            });
+            let baseUrl;
+            let headers;
+            if (meta?.['gateway']) {
+                const result = gatewaySchema.safeParse(meta['gateway']);
+                if (result.success) {
+                    baseUrl = result.data.baseUrl;
+                    headers = result.data.headers;
+                }
+                else {
+                    throw new acp.RequestError(-32602, `Malformed gateway payload: ${result.error.message}`);
+                }
+            }
+            this.baseUrl = baseUrl;
+            this.customHeaders = headers;
+            await this.context.config.refreshAuth(method, undefined, apiKey ?? this.apiKey, baseUrl, headers);
         }
         catch (e) {
-            throw new acp.RequestError(getErrorStatus(e) || 401, getAcpErrorMessage(e));
+            throw new acp.RequestError(-32000, getAcpErrorMessage(e));
         }
         this.settings.setValue(SettingScope.User, 'security.auth.selectedType', method);
     }
@@ -103,7 +174,7 @@ export class GeminiAgent {
         let isAuthenticated = false;
         let authErrorMessage = '';
         try {
-            await config.refreshAuth(authType);
+            await config.refreshAuth(authType, undefined, this.apiKey, this.baseUrl, this.customHeaders);
             isAuthenticated = true;
             // Extra validation for Gemini API key
             const contentGeneratorConfig = config.getContentGeneratorConfig();
@@ -119,43 +190,68 @@ export class GeminiAgent {
             debugLogger.error(`Authentication failed: ${e instanceof Error ? e.stack : e}`);
         }
         if (!isAuthenticated) {
-            throw new acp.RequestError(401, authErrorMessage || 'Authentication required.');
+            throw new acp.RequestError(-32000, authErrorMessage || 'Authentication required.');
         }
         if (this.clientCapabilities?.fs) {
-            const acpFileSystemService = new AcpFileSystemService(this.connection, sessionId, this.clientCapabilities.fs, config.getFileSystemService());
+            const acpFileSystemService = new AcpFileSystemService(this.connection, sessionId, this.clientCapabilities.fs, config.getFileSystemService(), cwd);
             config.setFileSystemService(acpFileSystemService);
         }
         await config.initialize();
         startupProfiler.flush(config);
         const geminiClient = config.getGeminiClient();
         const chat = await geminiClient.startChat();
-        const session = new Session(sessionId, chat, config, this.connection);
+        const session = new Session(sessionId, chat, config, this.connection, this.settings);
         this.sessions.set(sessionId, session);
-        return {
+        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, }) {
         const config = await this.initializeSessionConfig(sessionId, cwd, mcpServers);
         const sessionSelector = new SessionSelector(config);
         const { sessionData, sessionPath } = await sessionSelector.resolveSession(sessionId);
-        if (this.clientCapabilities?.fs) {
-            const acpFileSystemService = new AcpFileSystemService(this.connection, sessionId, this.clientCapabilities.fs, config.getFileSystemService());
-            config.setFileSystemService(acpFileSystemService);
-        }
-        const { clientHistory } = convertSessionToHistoryFormats(sessionData.messages);
+        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);
+        const session = new Session(sessionId, geminiClient.getChat(), config, this.connection, this.settings);
         this.sessions.set(sessionId, session);
         // Stream history back to client
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         session.streamHistory(sessionData.messages);
-        return {};
+        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) {
         const selectedAuthType = this.settings.merged.security.auth.selectedType;
@@ -168,13 +264,18 @@ export class GeminiAgent {
         // This satisfies the security requirement to verify the user before executing
         // potentially unsafe server definitions.
         try {
-            await config.refreshAuth(selectedAuthType);
+            await config.refreshAuth(selectedAuthType, undefined, this.apiKey, this.baseUrl, this.customHeaders);
         }
         catch (e) {
             debugLogger.error(`Authentication failed: ${e}`);
             throw acp.RequestError.authRequired();
         }
-        // 3. Now that we are authenticated, it is safe to initialize the config
+        // 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);
@@ -211,6 +312,7 @@ export class GeminiAgent {
             mcpServers: mergedMcpServers,
         };
         const config = await loadCliConfig(settings, sessionId, this.argv, { cwd });
+        createPolicyUpdater(config.getPolicyEngine(), config.messageBus, config.storage);
         return config;
     }
     async cancel(params) {
@@ -227,18 +329,35 @@ export class GeminiAgent {
         }
         return session.prompt(params);
     }
+    async setSessionMode(params) {
+        const session = this.sessions.get(params.sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${params.sessionId}`);
+        }
+        return session.setMode(params.modeId);
+    }
+    async unstable_setSessionModel(params) {
+        const session = this.sessions.get(params.sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${params.sessionId}`);
+        }
+        return session.setModel(params.modelId);
+    }
 }
 export class Session {
     id;
     chat;
-    config;
+    context;
     connection;
+    settings;
     pendingPrompt = null;
-    constructor(id, chat, config, connection) {
+    commandHandler = new CommandHandler();
+    constructor(id, chat, context, connection, settings) {
         this.id = id;
         this.chat = chat;
-        this.config = config;
+        this.context = context;
         this.connection = connection;
+        this.settings = settings;
     }
     async cancelPendingPrompt() {
         if (!this.pendingPrompt) {
@@ -247,6 +366,33 @@ export class Session {
         this.pendingPrompt.abort();
         this.pendingPrompt = null;
     }
+    setMode(modeId) {
+        const availableModes = buildAvailableModes(this.context.config.isPlanEnabled());
+        const mode = availableModes.find((m) => m.id === modeId);
+        if (!mode) {
+            throw new Error(`Invalid or unavailable mode: ${modeId}`);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        this.context.config.setApprovalMode(mode.id);
+        return {};
+    }
+    getAvailableCommands() {
+        return this.commandHandler.getAvailableCommands();
+    }
+    async sendAvailableCommands() {
+        const availableCommands = this.getAvailableCommands().map((command) => ({
+            name: command.name,
+            description: command.description,
+        }));
+        await this.sendUpdate({
+            sessionUpdate: 'available_commands_update',
+            availableCommands,
+        });
+    }
+    setModel(modelId) {
+        this.context.config.setModel(modelId);
+        return {};
+    }
     async streamHistory(messages) {
         for (const msg of messages) {
             const contentString = partListUnionToString(msg.content);
@@ -296,11 +442,13 @@ export class Session {
                                 });
                             }
                         }
-                        const tool = this.config.getToolRegistry().getTool(toolCall.name);
+                        const tool = this.context.toolRegistry.getTool(toolCall.name);
                         await this.sendUpdate({
                             sessionUpdate: 'tool_call',
                             toolCallId: toolCall.id,
-                            status: toolCall.status === 'success' ? 'completed' : 'failed',
+                            status: toolCall.status === CoreToolCallStatus.Success
+                                ? 'completed'
+                                : 'failed',
                             title: toolCall.displayName || toolCall.name,
                             content: toolCallContent,
                             kind: tool ? toAcpToolKind(tool.kind) : 'other',
@@ -314,23 +462,84 @@ export class Session {
         this.pendingPrompt?.abort();
         const pendingSend = new AbortController();
         this.pendingPrompt = pendingSend;
+        await this.context.config.waitForMcpInit();
         const promptId = Math.random().toString(16).slice(2);
         const chat = this.chat;
         const parts = await this.#resolvePrompt(params.prompt, pendingSend.signal);
+        // Command interception
+        let commandText = '';
+        for (const part of parts) {
+            if (typeof part === 'object' && part !== null) {
+                if ('text' in part) {
+                    // It is a text part
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-type-assertion
+                    const text = part.text;
+                    if (typeof text === 'string') {
+                        commandText += text;
+                    }
+                }
+                else {
+                    // Non-text part (image, embedded resource)
+                    // Stop looking for command
+                    break;
+                }
+            }
+        }
+        commandText = commandText.trim();
+        if (commandText &&
+            (commandText.startsWith('/') || commandText.startsWith('$'))) {
+            // If we found a command, pass it to handleCommand
+            // Note: handleCommand currently expects `commandText` to be the command string
+            // It uses `parts` argument but effectively ignores it in current implementation
+            const handled = await this.handleCommand(commandText, parts);
+            if (handled) {
+                return {
+                    stopReason: 'end_turn',
+                    _meta: {
+                        quota: {
+                            token_count: { input_tokens: 0, output_tokens: 0 },
+                            model_usage: [],
+                        },
+                    },
+                };
+            }
+        }
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        const modelUsageMap = new Map();
         let nextMessage = { role: 'user', parts };
         while (nextMessage !== null) {
             if (pendingSend.signal.aborted) {
                 chat.addHistory(nextMessage);
-                return { stopReason: 'cancelled' };
+                return { stopReason: CoreToolCallStatus.Cancelled };
             }
             const functionCalls = [];
             try {
-                const model = resolveModel(this.config.getModel(), (await this.config.getGemini31Launched?.()) ?? false);
-                const responseStream = await chat.sendMessageStream({ model }, nextMessage?.parts ?? [], promptId, pendingSend.signal);
+                const routingContext = {
+                    history: chat.getHistory(/*curated=*/ true),
+                    request: nextMessage?.parts ?? [],
+                    signal: pendingSend.signal,
+                    requestedModel: this.context.config.getModel(),
+                };
+                const router = this.context.config.getModelRouterService();
+                const { model } = await router.route(routingContext);
+                const responseStream = await chat.sendMessageStream({ model }, nextMessage?.parts ?? [], promptId, pendingSend.signal, LlmRole.MAIN);
                 nextMessage = null;
+                let turnInputTokens = 0;
+                let turnOutputTokens = 0;
+                let turnModelId = model;
                 for await (const resp of responseStream) {
                     if (pendingSend.signal.aborted) {
-                        return { stopReason: 'cancelled' };
+                        return { stopReason: CoreToolCallStatus.Cancelled };
+                    }
+                    if (resp.type === StreamEventType.CHUNK && resp.value.usageMetadata) {
+                        turnInputTokens =
+                            resp.value.usageMetadata.promptTokenCount ?? turnInputTokens;
+                        turnOutputTokens =
+                            resp.value.usageMetadata.candidatesTokenCount ?? turnOutputTokens;
+                        if (resp.value.modelVersion) {
+                            turnModelId = resp.value.modelVersion;
+                        }
                     }
                     if (resp.type === StreamEventType.CHUNK &&
                         resp.value.candidates &&
@@ -357,8 +566,19 @@ export class Session {
                         functionCalls.push(...resp.value.functionCalls);
                     }
                 }
+                totalInputTokens += turnInputTokens;
+                totalOutputTokens += turnOutputTokens;
+                if (turnInputTokens > 0 || turnOutputTokens > 0) {
+                    const existing = modelUsageMap.get(turnModelId) ?? {
+                        input: 0,
+                        output: 0,
+                    };
+                    existing.input += turnInputTokens;
+                    existing.output += turnOutputTokens;
+                    modelUsageMap.set(turnModelId, existing);
+                }
                 if (pendingSend.signal.aborted) {
-                    return { stopReason: 'cancelled' };
+                    return { stopReason: CoreToolCallStatus.Cancelled };
                 }
             }
             catch (error) {
@@ -367,7 +587,36 @@ export class Session {
                 }
                 if (pendingSend.signal.aborted ||
                     (error instanceof Error && error.name === 'AbortError')) {
-                    return { stopReason: 'cancelled' };
+                    return { stopReason: CoreToolCallStatus.Cancelled };
+                }
+                if (error instanceof InvalidStreamError ||
+                    (error &&
+                        typeof error === 'object' &&
+                        'type' in error &&
+                        (error.type === 'NO_RESPONSE_TEXT' ||
+                            error.type === 'NO_FINISH_REASON' ||
+                            error.type === 'MALFORMED_FUNCTION_CALL' ||
+                            error.type === 'UNEXPECTED_TOOL_CALL'))) {
+                    // The stream ended with an empty response or malformed tool call.
+                    // Treat this as a graceful end to the model's turn rather than a crash.
+                    return {
+                        stopReason: 'end_turn',
+                        _meta: {
+                            quota: {
+                                token_count: {
+                                    input_tokens: totalInputTokens,
+                                    output_tokens: totalOutputTokens,
+                                },
+                                model_usage: Array.from(modelUsageMap.entries()).map(([modelName, counts]) => ({
+                                    model: modelName,
+                                    token_count: {
+                                        input_tokens: counts.input,
+                                        output_tokens: counts.output,
+                                    },
+                                })),
+                            },
+                        },
+                    };
                 }
                 throw new acp.RequestError(getErrorStatus(error) || 500, getAcpErrorMessage(error));
             }
@@ -380,7 +629,42 @@ export class Session {
                 nextMessage = { role: 'user', parts: toolResponseParts };
             }
         }
-        return { stopReason: 'end_turn' };
+        const modelUsageArray = Array.from(modelUsageMap.entries()).map(([modelName, counts]) => ({
+            model: modelName,
+            token_count: {
+                input_tokens: counts.input,
+                output_tokens: counts.output,
+            },
+        }));
+        return {
+            stopReason: 'end_turn',
+            _meta: {
+                quota: {
+                    token_count: {
+                        input_tokens: totalInputTokens,
+                        output_tokens: totalOutputTokens,
+                    },
+                    model_usage: modelUsageArray,
+                },
+            },
+        };
+    }
+    async handleCommand(commandText, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    parts) {
+        const gitService = await this.context.config.getGitService();
+        const commandContext = {
+            agentContext: this.context,
+            settings: this.settings,
+            git: gitService,
+            sendMessage: async (text) => {
+                await this.sendUpdate({
+                    sessionUpdate: 'agent_message_chunk',
+                    content: { type: 'text', text },
+                });
+            },
+        };
+        return this.commandHandler.handleCommand(commandText, commandContext);
     }
     async sendUpdate(update) {
         const params = {
@@ -390,12 +674,12 @@ export class Session {
         await this.connection.sessionUpdate(params);
     }
     async runTool(abortSignal, promptId, fc) {
-        const callId = fc.id ?? `${fc.name}-${Date.now()}`;
+        const callId = fc.id ?? GeminiAgent.generateCallId(fc.name || 'unknown');
         const args = fc.args ?? {};
         const startTime = Date.now();
         const errorResponse = (error) => {
             const durationMs = Date.now() - startTime;
-            logToolCall(this.config, new ToolCallEvent(undefined, fc.name ?? '', args, durationMs, false, promptId, typeof tool !== 'undefined' && tool instanceof DiscoveredMCPTool
+            logToolCall(this.context.config, new ToolCallEvent(undefined, fc.name ?? '', args, durationMs, false, promptId, typeof tool !== 'undefined' && tool instanceof DiscoveredMCPTool
                 ? 'mcp'
                 : 'native', error.message));
             return [
@@ -411,43 +695,64 @@ export class Session {
         if (!fc.name) {
             return errorResponse(new Error('Missing function name'));
         }
-        const toolRegistry = this.config.getToolRegistry();
+        const toolRegistry = this.context.toolRegistry;
         const tool = toolRegistry.getTool(fc.name);
         if (!tool) {
             return errorResponse(new Error(`Tool "${fc.name}" not found in registry.`));
         }
         try {
             const invocation = tool.build(args);
+            const displayTitle = typeof invocation.getDisplayTitle === 'function'
+                ? invocation.getDisplayTitle()
+                : invocation.getDescription();
+            const explanation = typeof invocation.getExplanation === 'function'
+                ? invocation.getExplanation()
+                : '';
+            if (explanation) {
+                await this.sendUpdate({
+                    sessionUpdate: 'agent_thought_chunk',
+                    content: { type: 'text', text: explanation },
+                });
+            }
             const confirmationDetails = await invocation.shouldConfirmExecute(abortSignal);
             if (confirmationDetails) {
                 const content = [];
                 if (confirmationDetails.type === 'edit') {
                     content.push({
                         type: 'diff',
-                        path: confirmationDetails.fileName,
+                        path: confirmationDetails.filePath,
                         oldText: confirmationDetails.originalContent,
                         newText: confirmationDetails.newContent,
+                        _meta: {
+                            kind: !confirmationDetails.originalContent
+                                ? 'add'
+                                : confirmationDetails.newContent === ''
+                                    ? 'delete'
+                                    : 'modify',
+                        },
                     });
                 }
                 const params = {
                     sessionId: this.id,
-                    options: toPermissionOptions(confirmationDetails),
+                    options: toPermissionOptions(confirmationDetails, this.context.config, this.settings.merged.security.enablePermanentToolApproval),
                     toolCall: {
                         toolCallId: callId,
                         status: 'pending',
-                        title: invocation.getDescription(),
+                        title: displayTitle,
                         content,
                         locations: invocation.toolLocations(),
                         kind: toAcpToolKind(tool.kind),
                     },
                 };
-                const output = await this.connection.requestPermission(params);
+                const output = RequestPermissionResponseSchema.parse(await this.connection.requestPermission(params));
                 const outcome = output.outcome.outcome === 'cancelled'
                     ? ToolConfirmationOutcome.Cancel
                     : z
                         .nativeEnum(ToolConfirmationOutcome)
                         .parse(output.outcome.optionId);
                 await confirmationDetails.onConfirm(outcome);
+                // Update policy to enable Always Allow persistence
+                await updatePolicy(tool, outcome, confirmationDetails, this.context, this.context.messageBus, invocation);
                 switch (outcome) {
                     case ToolConfirmationOutcome.Cancel:
                         return errorResponse(new Error(`Tool "${fc.name}" was canceled by the user.`));
@@ -465,31 +770,36 @@ export class Session {
                 }
             }
             else {
+                const content = [];
                 await this.sendUpdate({
                     sessionUpdate: 'tool_call',
                     toolCallId: callId,
                     status: 'in_progress',
-                    title: invocation.getDescription(),
-                    content: [],
+                    title: displayTitle,
+                    content,
                     locations: invocation.toolLocations(),
                     kind: toAcpToolKind(tool.kind),
                 });
             }
             const toolResult = await invocation.execute(abortSignal);
             const content = toToolCallContent(toolResult);
+            const updateContent = content ? [content] : [];
             await this.sendUpdate({
                 sessionUpdate: 'tool_call_update',
                 toolCallId: callId,
                 status: 'completed',
-                content: content ? [content] : [],
+                title: displayTitle,
+                content: updateContent,
+                locations: invocation.toolLocations(),
+                kind: toAcpToolKind(tool.kind),
             });
             const durationMs = Date.now() - startTime;
-            logToolCall(this.config, new ToolCallEvent(undefined, fc.name ?? '', args, durationMs, true, promptId, typeof tool !== 'undefined' && tool instanceof DiscoveredMCPTool
+            logToolCall(this.context.config, new ToolCallEvent(undefined, fc.name ?? '', args, durationMs, true, promptId, typeof tool !== 'undefined' && tool instanceof DiscoveredMCPTool
                 ? 'mcp'
                 : 'native'));
-            this.chat.recordCompletedToolCalls(this.config.getActiveModel(), [
+            this.chat.recordCompletedToolCalls(this.context.config.getActiveModel(), [
                 {
-                    status: 'success',
+                    status: CoreToolCallStatus.Success,
                     request: {
                         callId,
                         name: fc.name,
@@ -501,14 +811,14 @@ export class Session {
                     invocation,
                     response: {
                         callId,
-                        responseParts: convertToFunctionResponse(fc.name, callId, toolResult.llmContent, this.config.getActiveModel()),
+                        responseParts: convertToFunctionResponse(fc.name, callId, toolResult.llmContent, this.context.config.getActiveModel(), this.context.config),
                         resultDisplay: toolResult.returnDisplay,
                         error: undefined,
                         errorType: undefined,
                     },
                 },
             ]);
-            return convertToFunctionResponse(fc.name, callId, toolResult.llmContent, this.config.getActiveModel());
+            return convertToFunctionResponse(fc.name, callId, toolResult.llmContent, this.context.config.getActiveModel(), this.context.config);
         }
         catch (e) {
             const error = e instanceof Error ? e : new Error(String(e));
@@ -519,10 +829,11 @@ export class Session {
                 content: [
                     { type: 'content', content: { type: 'text', text: error.message } },
                 ],
+                kind: toAcpToolKind(tool.kind),
             });
-            this.chat.recordCompletedToolCalls(this.config.getActiveModel(), [
+            this.chat.recordCompletedToolCalls(this.context.config.getActiveModel(), [
                 {
-                    status: 'error',
+                    status: CoreToolCallStatus.Error,
                     request: {
                         callId,
                         name: fc.name,
@@ -596,13 +907,14 @@ export class Session {
         }
         const atPathToResolvedSpecMap = new Map();
         // Get centralized file discovery service
-        const fileDiscovery = this.config.getFileService();
-        const fileFilteringOptions = this.config.getFileFilteringOptions();
+        const fileDiscovery = this.context.config.getFileService();
+        const fileFilteringOptions = this.context.config.getFileFilteringOptions();
         const pathSpecsToRead = [];
         const contentLabelsForDisplay = [];
         const ignoredPaths = [];
-        const toolRegistry = this.config.getToolRegistry();
-        const readManyFilesTool = new ReadManyFilesTool(this.config, this.config.getMessageBus());
+        const directContents = [];
+        const toolRegistry = this.context.toolRegistry;
+        const readManyFilesTool = new ReadManyFilesTool(this.context.config, this.context.messageBus);
         const globTool = toolRegistry.getTool('glob');
         if (!readManyFilesTool) {
             throw new Error('Error: read_many_files tool not found.');
@@ -617,33 +929,170 @@ export class Session {
             }
             let currentPathSpec = pathName;
             let resolvedSuccessfully = false;
+            let readDirectly = false;
             try {
-                const absolutePath = path.resolve(this.config.getTargetDir(), pathName);
-                if (isWithinRoot(absolutePath, this.config.getTargetDir())) {
-                    const stats = await fs.stat(absolutePath);
-                    if (stats.isDirectory()) {
-                        currentPathSpec = pathName.endsWith('/')
-                            ? `${pathName}**`
-                            : `${pathName}/**`;
-                        this.debug(`Path ${pathName} resolved to directory, using glob: ${currentPathSpec}`);
+                const absolutePath = path.resolve(this.context.config.getTargetDir(), pathName);
+                let validationError = this.context.config.validatePathAccess(absolutePath, 'read');
+                // We ask the user for explicit permission to read them if outside sandboxed workspace boundaries (and not already authorized).
+                if (validationError &&
+                    !isWithinRoot(absolutePath, this.context.config.getTargetDir())) {
+                    try {
+                        const stats = await fs.stat(absolutePath);
+                        if (stats.isFile()) {
+                            const syntheticCallId = `resolve-prompt-${pathName}-${randomUUID()}`;
+                            const params = {
+                                sessionId: this.id,
+                                options: [
+                                    {
+                                        optionId: ToolConfirmationOutcome.ProceedOnce,
+                                        name: 'Allow once',
+                                        kind: 'allow_once',
+                                    },
+                                    {
+                                        optionId: ToolConfirmationOutcome.Cancel,
+                                        name: 'Deny',
+                                        kind: 'reject_once',
+                                    },
+                                ],
+                                toolCall: {
+                                    toolCallId: syntheticCallId,
+                                    status: 'pending',
+                                    title: `Allow access to absolute path: ${pathName}`,
+                                    content: [
+                                        {
+                                            type: 'content',
+                                            content: {
+                                                type: 'text',
+                                                text: `The Agent needs access to read an attached file outside your workspace: ${pathName}`,
+                                            },
+                                        },
+                                    ],
+                                    locations: [],
+                                    kind: 'read',
+                                },
+                            };
+                            const output = RequestPermissionResponseSchema.parse(await this.connection.requestPermission(params));
+                            const outcome = output.outcome.outcome === 'cancelled'
+                                ? ToolConfirmationOutcome.Cancel
+                                : z
+                                    .nativeEnum(ToolConfirmationOutcome)
+                                    .parse(output.outcome.optionId);
+                            if (outcome === ToolConfirmationOutcome.ProceedOnce) {
+                                this.context.config
+                                    .getWorkspaceContext()
+                                    .addReadOnlyPath(absolutePath);
+                                validationError = null;
+                            }
+                            else {
+                                this.debug(`Direct read authorization denied for absolute path ${pathName}`);
+                                directContents.push({
+                                    spec: pathName,
+                                    content: `[Warning: Access to absolute path \`${pathName}\` denied by user.]`,
+                                });
+                                continue;
+                            }
+                        }
                     }
-                    else {
-                        this.debug(`Path ${pathName} resolved to file: ${currentPathSpec}`);
+                    catch (error) {
+                        this.debug(`Failed to request permission for absolute attachment ${pathName}: ${getErrorMessage(error)}`);
+                        await this.sendUpdate({
+                            sessionUpdate: 'agent_thought_chunk',
+                            content: {
+                                type: 'text',
+                                text: `Warning: Failed to display permission dialog for \`${absolutePath}\`. Error: ${getErrorMessage(error)}`,
+                            },
+                        });
+                    }
+                }
+                if (!validationError) {
+                    // If it's an absolute path that is authorized (e.g. added via readOnlyPaths),
+                    // read it directly to avoid ReadManyFilesTool absolute path resolution issues.
+                    if ((path.isAbsolute(pathName) ||
+                        !isWithinRoot(absolutePath, this.context.config.getTargetDir())) &&
+                        !readDirectly) {
+                        try {
+                            const stats = await fs.stat(absolutePath);
+                            if (stats.isFile()) {
+                                const fileReadResult = await processSingleFileContent(absolutePath, this.context.config.getTargetDir(), this.context.config.getFileSystemService());
+                                if (!fileReadResult.error) {
+                                    if (typeof fileReadResult.llmContent === 'object' &&
+                                        'inlineData' in fileReadResult.llmContent) {
+                                        directContents.push({
+                                            spec: pathName,
+                                            part: fileReadResult.llmContent,
+                                        });
+                                    }
+                                    else if (typeof fileReadResult.llmContent === 'string') {
+                                        let contentToPush = fileReadResult.llmContent;
+                                        if (fileReadResult.isTruncated) {
+                                            contentToPush = `[WARNING: This file was truncated]\n\n${contentToPush}`;
+                                        }
+                                        directContents.push({
+                                            spec: pathName,
+                                            content: contentToPush,
+                                        });
+                                    }
+                                    readDirectly = true;
+                                    resolvedSuccessfully = true;
+                                }
+                                else {
+                                    this.debug(`Direct read failed for absolute path ${pathName}: ${fileReadResult.error}`);
+                                    await this.sendUpdate({
+                                        sessionUpdate: 'agent_thought_chunk',
+                                        content: {
+                                            type: 'text',
+                                            text: `Warning: file read failed for \`${pathName}\`. Reason: ${fileReadResult.error}`,
+                                        },
+                                    });
+                                    continue;
+                                }
+                            }
+                        }
+                        catch (error) {
+                            this.debug(`File stat/access error for absolute path ${pathName}: ${getErrorMessage(error)}`);
+                            await this.sendUpdate({
+                                sessionUpdate: 'agent_thought_chunk',
+                                content: {
+                                    type: 'text',
+                                    text: `Warning: file access failed for \`${pathName}\`. Reason: ${getErrorMessage(error)}`,
+                                },
+                            });
+                            continue;
+                        }
+                    }
+                    if (!readDirectly) {
+                        const stats = await fs.stat(absolutePath);
+                        if (stats.isDirectory()) {
+                            currentPathSpec = pathName.endsWith('/')
+                                ? `${pathName}**`
+                                : `${pathName}/**`;
+                            this.debug(`Path ${pathName} resolved to directory, using glob: ${currentPathSpec}`);
+                        }
+                        else {
+                            this.debug(`Path ${pathName} resolved to file: ${currentPathSpec}`);
+                        }
+                        resolvedSuccessfully = true;
                     }
-                    resolvedSuccessfully = true;
                 }
                 else {
-                    this.debug(`Path ${pathName} is outside the project directory. Skipping.`);
+                    this.debug(`Path ${pathName} access disallowed: ${validationError}. Skipping.`);
+                    await this.sendUpdate({
+                        sessionUpdate: 'agent_thought_chunk',
+                        content: {
+                            type: 'text',
+                            text: `Warning: skipping access to \`${pathName}\`. Reason: ${validationError}`,
+                        },
+                    });
                 }
             }
             catch (error) {
                 if (isNodeError(error) && error.code === 'ENOENT') {
-                    if (this.config.getEnableRecursiveFileSearch() && globTool) {
+                    if (this.context.config.getEnableRecursiveFileSearch() && globTool) {
                         this.debug(`Path ${pathName} not found directly, attempting glob search.`);
                         try {
                             const globResult = await globTool.buildAndExecute({
                                 pattern: `**/*${pathName}*`,
-                                path: this.config.getTargetDir(),
+                                path: this.context.config.getTargetDir(),
                             }, abortSignal);
                             if (globResult.llmContent &&
                                 typeof globResult.llmContent === 'string' &&
@@ -652,7 +1101,7 @@ export class Session {
                                 const lines = globResult.llmContent.split('\n');
                                 if (lines.length > 1 && lines[1]) {
                                     const firstMatchAbsolute = lines[1].trim();
-                                    currentPathSpec = path.relative(this.config.getTargetDir(), firstMatchAbsolute);
+                                    currentPathSpec = path.relative(this.context.config.getTargetDir(), firstMatchAbsolute);
                                     this.debug(`Glob search for ${pathName} found ${firstMatchAbsolute}, using relative path: ${currentPathSpec}`);
                                     resolvedSuccessfully = true;
                                 }
@@ -677,7 +1126,9 @@ export class Session {
                 }
             }
             if (resolvedSuccessfully) {
-                pathSpecsToRead.push(currentPathSpec);
+                if (!readDirectly) {
+                    pathSpecsToRead.push(currentPathSpec);
+                }
                 atPathToResolvedSpecMap.set(pathName, currentPathSpec);
                 contentLabelsForDisplay.push(pathName);
             }
@@ -728,7 +1179,9 @@ export class Session {
             this.debug(`Ignored ${ignoredPaths.length} files: ${ignoredPaths.join(', ')}`);
         }
         const processedQueryParts = [{ text: initialQueryText }];
-        if (pathSpecsToRead.length === 0 && embeddedContext.length === 0) {
+        if (pathSpecsToRead.length === 0 &&
+            embeddedContext.length === 0 &&
+            directContents.length === 0) {
             // Fallback for lone "@" or completely invalid @-commands resulting in empty initialQueryText
             debugLogger.warn('No valid file paths found in @ commands to read.');
             return [{ text: initialQueryText }];
@@ -737,7 +1190,7 @@ export class Session {
             const toolArgs = {
                 include: pathSpecsToRead,
             };
-            const callId = `${readManyFilesTool.name}-${Date.now()}`;
+            const callId = GeminiAgent.generateCallId(readManyFilesTool.name);
             try {
                 const invocation = readManyFilesTool.build(toolArgs);
                 await this.sendUpdate({
@@ -761,7 +1214,10 @@ export class Session {
                     sessionUpdate: 'tool_call_update',
                     toolCallId: callId,
                     status: 'completed',
+                    title: invocation.getDescription(),
                     content: content ? [content] : [],
+                    locations: invocation.toolLocations(),
+                    kind: toAcpToolKind(readManyFilesTool.kind),
                 });
                 if (Array.isArray(result.llmContent)) {
                     const fileContentRegex = /^--- (.*?) ---\n\n([\s\S]*?)\n\n$/;
@@ -807,10 +1263,32 @@ export class Session {
                             },
                         },
                     ],
+                    kind: toAcpToolKind(readManyFilesTool.kind),
                 });
                 throw error;
             }
         }
+        if (directContents.length > 0) {
+            const hasReferenceStart = processedQueryParts.some((p) => 'text' in p &&
+                typeof p.text === 'string' &&
+                p.text.includes(REFERENCE_CONTENT_START));
+            if (!hasReferenceStart) {
+                processedQueryParts.push({
+                    text: `\n${REFERENCE_CONTENT_START}`,
+                });
+            }
+            for (const item of directContents) {
+                processedQueryParts.push({
+                    text: `\nContent from @${item.spec}:\n`,
+                });
+                if (item.content) {
+                    processedQueryParts.push({ text: item.content });
+                }
+                else if (item.part) {
+                    processedQueryParts.push(item.part);
+                }
+            }
+        }
         if (embeddedContext.length > 0) {
             processedQueryParts.push({
                 text: '\n--- Content from referenced context ---',
@@ -837,7 +1315,7 @@ export class Session {
         return processedQueryParts;
     }
     debug(msg) {
-        if (this.config.getDebugMode()) {
+        if (this.context.config.getDebugMode()) {
             debugLogger.warn(msg);
         }
     }
@@ -857,9 +1335,17 @@ function toToolCallContent(toolResult) {
             if ('fileName' in toolResult.returnDisplay) {
                 return {
                     type: 'diff',
-                    path: toolResult.returnDisplay.fileName,
+                    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;
@@ -881,60 +1367,97 @@ const basicPermissionOptions = [
         kind: 'reject_once',
     },
 ];
-function toPermissionOptions(confirmation) {
-    switch (confirmation.type) {
-        case 'edit':
-            return [
-                {
+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 All Edits',
+                    name: 'Allow for this session',
                     kind: 'allow_always',
-                },
-                ...basicPermissionOptions,
-            ];
-        case 'exec':
-            return [
-                {
+                });
+                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: `Always Allow ${confirmation.rootCommand}`,
+                    name: 'Allow for this session',
                     kind: 'allow_always',
-                },
-                ...basicPermissionOptions,
-            ];
-        case 'mcp':
-            return [
-                {
+                });
+                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: `Always Allow ${confirmation.serverName}`,
+                    name: 'Allow all server tools for this session',
                     kind: 'allow_always',
-                },
-                {
+                }, {
                     optionId: ToolConfirmationOutcome.ProceedAlwaysTool,
-                    name: `Always Allow ${confirmation.toolName}`,
+                    name: 'Allow tool for this session',
                     kind: 'allow_always',
-                },
-                ...basicPermissionOptions,
-            ];
-        case 'info':
-            return [
-                {
+                });
+                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: `Always Allow`,
+                    name: 'Allow for this session',
                     kind: 'allow_always',
-                },
-                ...basicPermissionOptions,
-            ];
+                });
+                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':
-            // askuser doesn't need "always allow" options since it's asking questions
-            return [...basicPermissionOptions];
         case 'exit_plan_mode':
-            // exit_plan_mode doesn't need "always allow" options since it's a plan approval flow
-            return [...basicPermissionOptions];
+        case 'sandbox_expansion':
+            break;
         default: {
             const unreachable = confirmation;
             throw new Error(`Unexpected: ${unreachable}`);
         }
     }
+    return options;
 }
 /**
  * Maps our internal tool kind to the ACP ToolKind.
@@ -944,17 +1467,138 @@ 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.Search:
-        case Kind.Execute:
         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';
     }
 }
-//# sourceMappingURL=zedIntegration.js.map
+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;
+}
+function buildAvailableModels(config, settings) {
+    const preferredModel = config.getModel() || DEFAULT_GEMINI_MODEL_AUTO;
+    const shouldShowPreviewModels = config.getHasAccessToPreviewModel();
+    const useGemini31 = config.getGemini31LaunchedSync?.() ?? false;
+    const useGemini31FlashLite = config.getGemini31FlashLiteLaunchedSync?.() ?? 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_1FlashLite: useGemini31FlashLite,
+            useCustomTools: useCustomToolModel,
+            hasAccessToPreview: shouldShowPreviewModels,
+        });
+        return {
+            availableModels: options,
+            currentModelId: preferredModel,
+        };
+    }
+    // --- LEGACY PATH ---
+    const mainOptions = [
+        {
+            value: DEFAULT_GEMINI_MODEL_AUTO,
+            title: getDisplayString(DEFAULT_GEMINI_MODEL_AUTO),
+            description: 'Let Cell CLI decide the best model for the task: gemini-2.5-pro, gemini-2.5-flash',
+        },
+    ];
+    if (shouldShowPreviewModels) {
+        mainOptions.unshift({
+            value: PREVIEW_GEMINI_MODEL_AUTO,
+            title: getDisplayString(PREVIEW_GEMINI_MODEL_AUTO),
+            description: useGemini31
+                ? 'Let Cell CLI decide the best model for the task: gemini-3.1-pro, gemini-3-flash'
+                : 'Let Cell CLI decide the best model for the task: gemini-3-pro, gemini-3-flash',
+        });
+    }
+    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 (useGemini31FlashLite) {
+            previewOptions.push({
+                value: PREVIEW_GEMINI_3_1_FLASH_LITE_MODEL,
+                title: getDisplayString(PREVIEW_GEMINI_3_1_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,
+    };
+}
+//# sourceMappingURL=acpClient.js.map