@google/gemini-cli 0.1.19-nightly.250814.514e883a → 0.1.20

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

@@ -3,16 +3,13 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { AuthType, logToolCall, convertToFunctionResponse, ToolConfirmationOutcome, clearCachedCredentialFile, isNodeError, getErrorMessage, isWithinRoot, getErrorStatus, MCPServerConfig, } from '@google/gemini-cli-core';
+import { AuthType, logToolCall, convertToFunctionResponse, ToolConfirmationOutcome, clearCachedCredentialFile, isNodeError, getErrorMessage, isWithinRoot, getErrorStatus, } from '@google/gemini-cli-core';
 import * as acp from './acp.js';
 import { Readable, Writable } from 'node:stream';
 import { SettingScope } from '../config/settings.js';
 import * as fs from 'fs/promises';
 import * as path from 'path';
-import { z } from 'zod';
-import { randomUUID } from 'crypto';
-import { loadCliConfig } from '../config/config.js';
-export async function runZedIntegration(config, settings, extensions, argv) {
+export async function runAcpPeer(config, settings) {
     const stdout = Writable.toWeb(process.stdout);
     const stdin = Readable.toWeb(process.stdin);
     // Stdout is used to send messages to the client, so console.log/console.info
@@ -20,138 +17,61 @@ export async function runZedIntegration(config, settings, extensions, argv) {
     console.log = console.error;
     console.info = console.error;
     console.debug = console.error;
-    new acp.AgentSideConnection((client) => new GeminiAgent(config, settings, extensions, argv, client), stdout, stdin);
+    new acp.ClientConnection((client) => new GeminiAgent(config, settings, client), stdout, stdin);
 }
 class GeminiAgent {
     config;
     settings;
-    extensions;
-    argv;
     client;
-    sessions = new Map();
-    constructor(config, settings, extensions, argv, client) {
+    chat;
+    pendingSend;
+    constructor(config, settings, client) {
         this.config = config;
         this.settings = settings;
-        this.extensions = extensions;
-        this.argv = argv;
         this.client = client;
     }
-    async initialize(_args) {
-        const authMethods = [
-            {
-                id: AuthType.LOGIN_WITH_GOOGLE,
-                name: 'Log in with Google',
-                description: null,
-            },
-            {
-                id: AuthType.USE_GEMINI,
-                name: 'Use Gemini API key',
-                description: 'Requires setting the `GEMINI_API_KEY` environment variable',
-            },
-            {
-                id: AuthType.USE_VERTEX_AI,
-                name: 'Vertex AI',
-                description: null,
-            },
-        ];
-        return {
-            protocolVersion: acp.PROTOCOL_VERSION,
-            authMethods,
-            agentCapabilities: {
-                loadSession: false,
-            },
-        };
-    }
-    async authenticate({ methodId }) {
-        const method = z.nativeEnum(AuthType).parse(methodId);
-        await clearCachedCredentialFile();
-        await this.config.refreshAuth(method);
-        this.settings.setValue(SettingScope.User, 'selectedAuthType', method);
-    }
-    async newSession({ cwd, mcpServers, }) {
-        const sessionId = randomUUID();
-        const config = await this.newSessionConfig(sessionId, cwd, mcpServers);
+    async initialize(_) {
         let isAuthenticated = false;
         if (this.settings.merged.selectedAuthType) {
             try {
-                await config.refreshAuth(this.settings.merged.selectedAuthType);
+                await this.config.refreshAuth(this.settings.merged.selectedAuthType);
                 isAuthenticated = true;
             }
-            catch (e) {
-                console.error(`Authentication failed: ${e}`);
-            }
-        }
-        if (!isAuthenticated) {
-            throw acp.RequestError.authRequired();
-        }
-        const geminiClient = config.getGeminiClient();
-        const chat = await geminiClient.startChat();
-        const session = new Session(sessionId, chat, config, this.client);
-        this.sessions.set(sessionId, session);
-        return {
-            sessionId,
-        };
-    }
-    async newSessionConfig(sessionId, cwd, mcpServers) {
-        const mergedMcpServers = { ...this.settings.merged.mcpServers };
-        for (const { command, args, env: rawEnv, name } of mcpServers) {
-            const env = {};
-            for (const { name: envName, value } of rawEnv) {
-                env[envName] = value;
+            catch (error) {
+                console.error('Failed to refresh auth:', error);
             }
-            mergedMcpServers[name] = new MCPServerConfig(command, args, env, cwd);
         }
-        const settings = { ...this.settings.merged, mcpServers: mergedMcpServers };
-        const config = await loadCliConfig(settings, this.extensions, sessionId, this.argv, cwd);
-        await config.initialize();
-        return config;
+        return { protocolVersion: acp.LATEST_PROTOCOL_VERSION, isAuthenticated };
     }
-    async cancel(params) {
-        const session = this.sessions.get(params.sessionId);
-        if (!session) {
-            throw new Error(`Session not found: ${params.sessionId}`);
-        }
-        await session.cancelPendingPrompt();
-    }
-    async prompt(params) {
-        const session = this.sessions.get(params.sessionId);
-        if (!session) {
-            throw new Error(`Session not found: ${params.sessionId}`);
-        }
-        return session.prompt(params);
-    }
-}
-class Session {
-    id;
-    chat;
-    config;
-    client;
-    pendingPrompt = null;
-    constructor(id, chat, config, client) {
-        this.id = id;
-        this.chat = chat;
-        this.config = config;
-        this.client = client;
+    async authenticate() {
+        await clearCachedCredentialFile();
+        await this.config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
+        this.settings.setValue(SettingScope.User, 'selectedAuthType', AuthType.LOGIN_WITH_GOOGLE);
     }
-    async cancelPendingPrompt() {
-        if (!this.pendingPrompt) {
+    async cancelSendMessage() {
+        if (!this.pendingSend) {
             throw new Error('Not currently generating');
         }
-        this.pendingPrompt.abort();
-        this.pendingPrompt = null;
+        this.pendingSend.abort();
+        delete this.pendingSend;
     }
-    async prompt(params) {
-        this.pendingPrompt?.abort();
+    async sendUserMessage(params) {
+        this.pendingSend?.abort();
         const pendingSend = new AbortController();
-        this.pendingPrompt = pendingSend;
+        this.pendingSend = pendingSend;
+        if (!this.chat) {
+            const geminiClient = this.config.getGeminiClient();
+            this.chat = await geminiClient.startChat();
+        }
         const promptId = Math.random().toString(16).slice(2);
         const chat = this.chat;
-        const parts = await this.#resolvePrompt(params.prompt, pendingSend.signal);
+        const toolRegistry = await this.config.getToolRegistry();
+        const parts = await this.#resolveUserMessage(params, pendingSend.signal);
         let nextMessage = { role: 'user', parts };
         while (nextMessage !== null) {
             if (pendingSend.signal.aborted) {
                 chat.addHistory(nextMessage);
-                return { stopReason: 'cancelled' };
+                return;
             }
             const functionCalls = [];
             try {
@@ -159,12 +79,17 @@ class Session {
                     message: nextMessage?.parts ?? [],
                     config: {
                         abortSignal: pendingSend.signal,
+                        tools: [
+                            {
+                                functionDeclarations: toolRegistry.getFunctionDeclarations(),
+                            },
+                        ],
                     },
                 }, promptId);
                 nextMessage = null;
                 for await (const resp of responseStream) {
                     if (pendingSend.signal.aborted) {
-                        return { stopReason: 'cancelled' };
+                        return;
                     }
                     if (resp.candidates && resp.candidates.length > 0) {
                         const candidate = resp.candidates[0];
@@ -172,15 +97,10 @@ class Session {
                             if (!part.text) {
                                 continue;
                             }
-                            const content = {
-                                type: 'text',
-                                text: part.text,
-                            };
-                            this.sendUpdate({
-                                sessionUpdate: part.thought
-                                    ? 'agent_thought_chunk'
-                                    : 'agent_message_chunk',
-                                content,
+                            this.client.streamAssistantMessageChunk({
+                                chunk: part.thought
+                                    ? { thought: part.text }
+                                    : { text: part.text },
                             });
                         }
                     }
@@ -198,7 +118,7 @@ class Session {
             if (functionCalls.length > 0) {
                 const toolResponseParts = [];
                 for (const fc of functionCalls) {
-                    const response = await this.runTool(pendingSend.signal, promptId, fc);
+                    const response = await this.#runTool(pendingSend.signal, promptId, fc);
                     const parts = Array.isArray(response) ? response : [response];
                     for (const part of parts) {
                         if (typeof part === 'string') {
@@ -212,16 +132,8 @@ class Session {
                 nextMessage = { role: 'user', parts: toolResponseParts };
             }
         }
-        return { stopReason: 'end_turn' };
-    }
-    async sendUpdate(update) {
-        const params = {
-            sessionId: this.id,
-            update,
-        };
-        await this.client.sessionUpdate(params);
     }
-    async runTool(abortSignal, promptId, fc) {
+    async #runTool(abortSignal, promptId, fc) {
         const callId = fc.id ?? `${fc.name}-${Date.now()}`;
         const args = (fc.args ?? {});
         const startTime = Date.now();
@@ -255,71 +167,59 @@ class Session {
         if (!tool) {
             return errorResponse(new Error(`Tool "${fc.name}" not found in registry.`));
         }
-        const invocation = tool.build(args);
-        const confirmationDetails = await invocation.shouldConfirmExecute(abortSignal);
-        if (confirmationDetails) {
-            const content = [];
-            if (confirmationDetails.type === 'edit') {
-                content.push({
-                    type: 'diff',
-                    path: confirmationDetails.fileName,
-                    oldText: confirmationDetails.originalContent,
-                    newText: confirmationDetails.newContent,
-                });
-            }
-            const params = {
-                sessionId: this.id,
-                options: toPermissionOptions(confirmationDetails),
-                toolCall: {
-                    toolCallId: callId,
-                    status: 'pending',
-                    title: invocation.getDescription(),
+        let toolCallId = undefined;
+        try {
+            const invocation = tool.build(args);
+            const confirmationDetails = await invocation.shouldConfirmExecute(abortSignal);
+            if (confirmationDetails) {
+                let content = null;
+                if (confirmationDetails.type === 'edit') {
+                    content = {
+                        type: 'diff',
+                        path: confirmationDetails.fileName,
+                        oldText: confirmationDetails.originalContent,
+                        newText: confirmationDetails.newContent,
+                    };
+                }
+                const result = await this.client.requestToolCallConfirmation({
+                    label: invocation.getDescription(),
+                    icon: tool.icon,
                     content,
+                    confirmation: toAcpToolCallConfirmation(confirmationDetails),
                     locations: invocation.toolLocations(),
-                    kind: tool.kind,
-                },
-            };
-            const output = await this.client.requestPermission(params);
-            const outcome = output.outcome.outcome === 'cancelled'
-                ? ToolConfirmationOutcome.Cancel
-                : z
-                    .nativeEnum(ToolConfirmationOutcome)
-                    .parse(output.outcome.optionId);
-            await confirmationDetails.onConfirm(outcome);
-            switch (outcome) {
-                case ToolConfirmationOutcome.Cancel:
-                    return errorResponse(new Error(`Tool "${fc.name}" was canceled by the user.`));
-                case ToolConfirmationOutcome.ProceedOnce:
-                case ToolConfirmationOutcome.ProceedAlways:
-                case ToolConfirmationOutcome.ProceedAlwaysServer:
-                case ToolConfirmationOutcome.ProceedAlwaysTool:
-                case ToolConfirmationOutcome.ModifyWithEditor:
-                    break;
-                default: {
-                    const resultOutcome = outcome;
-                    throw new Error(`Unexpected: ${resultOutcome}`);
+                });
+                await confirmationDetails.onConfirm(toToolCallOutcome(result.outcome));
+                switch (result.outcome) {
+                    case 'reject':
+                        return errorResponse(new Error(`Tool "${fc.name}" not allowed to run by the user.`));
+                    case 'cancel':
+                        return errorResponse(new Error(`Tool "${fc.name}" was canceled by the user.`));
+                    case 'allow':
+                    case 'alwaysAllow':
+                    case 'alwaysAllowMcpServer':
+                    case 'alwaysAllowTool':
+                        break;
+                    default: {
+                        const resultOutcome = result.outcome;
+                        throw new Error(`Unexpected: ${resultOutcome}`);
+                    }
                 }
+                toolCallId = result.id;
+            }
+            else {
+                const result = await this.client.pushToolCall({
+                    icon: tool.icon,
+                    label: invocation.getDescription(),
+                    locations: invocation.toolLocations(),
+                });
+                toolCallId = result.id;
             }
-        }
-        else {
-            await this.sendUpdate({
-                sessionUpdate: 'tool_call',
-                toolCallId: callId,
-                status: 'in_progress',
-                title: invocation.getDescription(),
-                content: [],
-                locations: invocation.toolLocations(),
-                kind: tool.kind,
-            });
-        }
-        try {
             const toolResult = await invocation.execute(abortSignal);
-            const content = toToolCallContent(toolResult);
-            await this.sendUpdate({
-                sessionUpdate: 'tool_call_update',
-                toolCallId: callId,
-                status: 'completed',
-                content: content ? [content] : [],
+            const toolCallContent = toToolCallContent(toolResult);
+            await this.client.updateToolCall({
+                toolCallId,
+                status: 'finished',
+                content: toolCallContent,
             });
             const durationMs = Date.now() - startTime;
             logToolCall(this.config, {
@@ -335,47 +235,27 @@ class Session {
         }
         catch (e) {
             const error = e instanceof Error ? e : new Error(String(e));
-            await this.sendUpdate({
-                sessionUpdate: 'tool_call_update',
-                toolCallId: callId,
-                status: 'failed',
-                content: [
-                    { type: 'content', content: { type: 'text', text: error.message } },
-                ],
-            });
+            if (toolCallId) {
+                await this.client.updateToolCall({
+                    toolCallId,
+                    status: 'error',
+                    content: { type: 'markdown', markdown: error.message },
+                });
+            }
             return errorResponse(error);
         }
     }
-    async #resolvePrompt(message, abortSignal) {
-        const parts = message.map((part) => {
-            switch (part.type) {
-                case 'text':
-                    return { text: part.text };
-                case 'resource_link':
-                    return {
-                        fileData: {
-                            mimeData: part.mimeType,
-                            name: part.name,
-                            fileUri: part.uri,
-                        },
-                    };
-                case 'resource': {
-                    return {
-                        fileData: {
-                            mimeData: part.resource.mimeType,
-                            name: part.resource.uri,
-                            fileUri: part.resource.uri,
-                        },
-                    };
+    async #resolveUserMessage(message, abortSignal) {
+        const atPathCommandParts = message.chunks.filter((part) => 'path' in part);
+        if (atPathCommandParts.length === 0) {
+            return message.chunks.map((chunk) => {
+                if ('text' in chunk) {
+                    return { text: chunk.text };
                 }
-                default: {
-                    throw new Error(`Unexpected chunk type: '${part.type}'`);
+                else {
+                    throw new Error('Unexpected chunk type');
                 }
-            }
-        });
-        const atPathCommandParts = parts.filter((part) => 'fileData' in part);
-        if (atPathCommandParts.length === 0) {
-            return parts;
+            });
         }
         // Get centralized file discovery service
         const fileDiscovery = this.config.getFileService();
@@ -391,7 +271,7 @@ class Session {
             throw new Error('Error: read_many_files tool not found.');
         }
         for (const atPathPart of atPathCommandParts) {
-            const pathName = atPathPart.fileData.fileUri;
+            const pathName = atPathPart.path;
             // Check if path should be ignored by git
             if (fileDiscovery.shouldGitIgnoreFile(pathName)) {
                 ignoredPaths.push(pathName);
@@ -411,21 +291,21 @@ class Session {
                         currentPathSpec = pathName.endsWith('/')
                             ? `${pathName}**`
                             : `${pathName}/**`;
-                        this.debug(`Path ${pathName} resolved to directory, using glob: ${currentPathSpec}`);
+                        this.#debug(`Path ${pathName} resolved to directory, using glob: ${currentPathSpec}`);
                     }
                     else {
-                        this.debug(`Path ${pathName} resolved to file: ${currentPathSpec}`);
+                        this.#debug(`Path ${pathName} resolved to file: ${currentPathSpec}`);
                     }
                     resolvedSuccessfully = true;
                 }
                 else {
-                    this.debug(`Path ${pathName} is outside the project directory. Skipping.`);
+                    this.#debug(`Path ${pathName} is outside the project directory. Skipping.`);
                 }
             }
             catch (error) {
                 if (isNodeError(error) && error.code === 'ENOENT') {
                     if (this.config.getEnableRecursiveFileSearch() && globTool) {
-                        this.debug(`Path ${pathName} not found directly, attempting glob search.`);
+                        this.#debug(`Path ${pathName} not found directly, attempting glob search.`);
                         try {
                             const globResult = await globTool.buildAndExecute({
                                 pattern: `**/*${pathName}*`,
@@ -439,15 +319,15 @@ class Session {
                                 if (lines.length > 1 && lines[1]) {
                                     const firstMatchAbsolute = lines[1].trim();
                                     currentPathSpec = path.relative(this.config.getTargetDir(), firstMatchAbsolute);
-                                    this.debug(`Glob search for ${pathName} found ${firstMatchAbsolute}, using relative path: ${currentPathSpec}`);
+                                    this.#debug(`Glob search for ${pathName} found ${firstMatchAbsolute}, using relative path: ${currentPathSpec}`);
                                     resolvedSuccessfully = true;
                                 }
                                 else {
-                                    this.debug(`Glob search for '**/*${pathName}*' did not return a usable path. Path ${pathName} will be skipped.`);
+                                    this.#debug(`Glob search for '**/*${pathName}*' did not return a usable path. Path ${pathName} will be skipped.`);
                                 }
                             }
                             else {
-                                this.debug(`Glob search for '**/*${pathName}*' found no files or an error. Path ${pathName} will be skipped.`);
+                                this.#debug(`Glob search for '**/*${pathName}*' found no files or an error. Path ${pathName} will be skipped.`);
                             }
                         }
                         catch (globError) {
@@ -455,7 +335,7 @@ class Session {
                         }
                     }
                     else {
-                        this.debug(`Glob tool not found. Path ${pathName} will be skipped.`);
+                        this.#debug(`Glob tool not found. Path ${pathName} will be skipped.`);
                     }
                 }
                 else {
@@ -470,23 +350,22 @@ class Session {
         }
         // Construct the initial part of the query for the LLM
         let initialQueryText = '';
-        for (let i = 0; i < parts.length; i++) {
-            const chunk = parts[i];
+        for (let i = 0; i < message.chunks.length; i++) {
+            const chunk = message.chunks[i];
             if ('text' in chunk) {
                 initialQueryText += chunk.text;
             }
             else {
                 // type === 'atPath'
-                const resolvedSpec = chunk.fileData && atPathToResolvedSpecMap.get(chunk.fileData.fileUri);
+                const resolvedSpec = atPathToResolvedSpecMap.get(chunk.path);
                 if (i > 0 &&
                     initialQueryText.length > 0 &&
                     !initialQueryText.endsWith(' ') &&
                     resolvedSpec) {
                     // Add space if previous part was text and didn't end with space, or if previous was @path
-                    const prevPart = parts[i - 1];
+                    const prevPart = message.chunks[i - 1];
                     if ('text' in prevPart ||
-                        ('fileData' in prevPart &&
-                            atPathToResolvedSpecMap.has(prevPart.fileData.fileUri))) {
+                        ('path' in prevPart && atPathToResolvedSpecMap.has(prevPart.path))) {
                         initialQueryText += ' ';
                     }
                 }
@@ -499,12 +378,10 @@ class Session {
                     if (i > 0 &&
                         initialQueryText.length > 0 &&
                         !initialQueryText.endsWith(' ') &&
-                        !chunk.fileData?.fileUri.startsWith(' ')) {
+                        !chunk.path.startsWith(' ')) {
                         initialQueryText += ' ';
                     }
-                    if (chunk.fileData?.fileUri) {
-                        initialQueryText += `@${chunk.fileData.fileUri}`;
-                    }
+                    initialQueryText += `@${chunk.path}`;
                 }
             }
         }
@@ -512,7 +389,7 @@ class Session {
         // Inform user about ignored paths
         if (ignoredPaths.length > 0) {
             const ignoreType = respectGitIgnore ? 'git-ignored' : 'custom-ignored';
-            this.debug(`Ignored ${ignoredPaths.length} ${ignoreType} files: ${ignoredPaths.join(', ')}`);
+            this.#debug(`Ignored ${ignoredPaths.length} ${ignoreType} files: ${ignoredPaths.join(', ')}`);
         }
         // Fallback for lone "@" or completely invalid @-commands resulting in empty initialQueryText
         if (pathSpecsToRead.length === 0) {
@@ -524,31 +401,23 @@ class Session {
             paths: pathSpecsToRead,
             respectGitIgnore, // Use configuration setting
         };
-        const callId = `${readManyFilesTool.name}-${Date.now()}`;
+        let toolCallId = undefined;
         try {
             const invocation = readManyFilesTool.build(toolArgs);
-            await this.sendUpdate({
-                sessionUpdate: 'tool_call',
-                toolCallId: callId,
-                status: 'in_progress',
-                title: invocation.getDescription(),
-                content: [],
-                locations: invocation.toolLocations(),
-                kind: readManyFilesTool.kind,
+            const toolCall = await this.client.pushToolCall({
+                icon: readManyFilesTool.icon,
+                label: invocation.getDescription(),
             });
+            toolCallId = toolCall.id;
             const result = await invocation.execute(abortSignal);
             const content = toToolCallContent(result) || {
-                type: 'content',
-                content: {
-                    type: 'text',
-                    text: `Successfully read: ${contentLabelsForDisplay.join(', ')}`,
-                },
+                type: 'markdown',
+                markdown: `Successfully read: ${contentLabelsForDisplay.join(', ')}`,
             };
-            await this.sendUpdate({
-                sessionUpdate: 'tool_call_update',
-                toolCallId: callId,
-                status: 'completed',
-                content: content ? [content] : [],
+            await this.client.updateToolCall({
+                toolCallId: toolCall.id,
+                status: 'finished',
+                content,
             });
             if (Array.isArray(result.llmContent)) {
                 const fileContentRegex = /^--- (.*?) ---\n\n([\s\S]*?)\n\n$/;
@@ -583,24 +452,20 @@ class Session {
             return processedQueryParts;
         }
         catch (error) {
-            await this.sendUpdate({
-                sessionUpdate: 'tool_call_update',
-                toolCallId: callId,
-                status: 'failed',
-                content: [
-                    {
-                        type: 'content',
-                        content: {
-                            type: 'text',
-                            text: `Error reading files (${contentLabelsForDisplay.join(', ')}): ${getErrorMessage(error)}`,
-                        },
+            if (toolCallId) {
+                await this.client.updateToolCall({
+                    toolCallId,
+                    status: 'error',
+                    content: {
+                        type: 'markdown',
+                        markdown: `Error reading files (${contentLabelsForDisplay.join(', ')}): ${getErrorMessage(error)}`,
                     },
-                ],
-            });
+                });
+            }
             throw error;
         }
     }
-    debug(msg) {
+    #debug(msg) {
         if (this.config.getDebugMode()) {
             console.warn(msg);
         }
@@ -610,8 +475,8 @@ function toToolCallContent(toolResult) {
     if (toolResult.returnDisplay) {
         if (typeof toolResult.returnDisplay === 'string') {
             return {
-                type: 'content',
-                content: { type: 'text', text: toolResult.returnDisplay },
+                type: 'markdown',
+                markdown: toolResult.returnDisplay,
             };
         }
         else {
@@ -627,65 +492,54 @@ function toToolCallContent(toolResult) {
         return null;
     }
 }
-const basicPermissionOptions = [
-    {
-        optionId: ToolConfirmationOutcome.ProceedOnce,
-        name: 'Allow',
-        kind: 'allow_once',
-    },
-    {
-        optionId: ToolConfirmationOutcome.Cancel,
-        name: 'Reject',
-        kind: 'reject_once',
-    },
-];
-function toPermissionOptions(confirmation) {
-    switch (confirmation.type) {
+function toAcpToolCallConfirmation(confirmationDetails) {
+    switch (confirmationDetails.type) {
         case 'edit':
-            return [
-                {
-                    optionId: ToolConfirmationOutcome.ProceedAlways,
-                    name: 'Allow All Edits',
-                    kind: 'allow_always',
-                },
-                ...basicPermissionOptions,
-            ];
+            return { type: 'edit' };
         case 'exec':
-            return [
-                {
-                    optionId: ToolConfirmationOutcome.ProceedAlways,
-                    name: `Always Allow ${confirmation.rootCommand}`,
-                    kind: 'allow_always',
-                },
-                ...basicPermissionOptions,
-            ];
+            return {
+                type: 'execute',
+                rootCommand: confirmationDetails.rootCommand,
+                command: confirmationDetails.command,
+            };
         case 'mcp':
-            return [
-                {
-                    optionId: ToolConfirmationOutcome.ProceedAlwaysServer,
-                    name: `Always Allow ${confirmation.serverName}`,
-                    kind: 'allow_always',
-                },
-                {
-                    optionId: ToolConfirmationOutcome.ProceedAlwaysTool,
-                    name: `Always Allow ${confirmation.toolName}`,
-                    kind: 'allow_always',
-                },
-                ...basicPermissionOptions,
-            ];
+            return {
+                type: 'mcp',
+                serverName: confirmationDetails.serverName,
+                toolName: confirmationDetails.toolName,
+                toolDisplayName: confirmationDetails.toolDisplayName,
+            };
         case 'info':
-            return [
-                {
-                    optionId: ToolConfirmationOutcome.ProceedAlways,
-                    name: `Always Allow`,
-                    kind: 'allow_always',
-                },
-                ...basicPermissionOptions,
-            ];
+            return {
+                type: 'fetch',
+                urls: confirmationDetails.urls || [],
+                description: confirmationDetails.urls?.length
+                    ? null
+                    : confirmationDetails.prompt,
+            };
+        default: {
+            const unreachable = confirmationDetails;
+            throw new Error(`Unexpected: ${unreachable}`);
+        }
+    }
+}
+function toToolCallOutcome(outcome) {
+    switch (outcome) {
+        case 'allow':
+            return ToolConfirmationOutcome.ProceedOnce;
+        case 'alwaysAllow':
+            return ToolConfirmationOutcome.ProceedAlways;
+        case 'alwaysAllowMcpServer':
+            return ToolConfirmationOutcome.ProceedAlwaysServer;
+        case 'alwaysAllowTool':
+            return ToolConfirmationOutcome.ProceedAlwaysTool;
+        case 'reject':
+        case 'cancel':
+            return ToolConfirmationOutcome.Cancel;
         default: {
-            const unreachable = confirmation;
+            const unreachable = outcome;
             throw new Error(`Unexpected: ${unreachable}`);
         }
     }
 }
-//# sourceMappingURL=zedIntegration.js.map
+//# sourceMappingURL=acpPeer.js.map