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

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

@@ -3,13 +3,16 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { AuthType, logToolCall, convertToFunctionResponse, ToolConfirmationOutcome, clearCachedCredentialFile, isNodeError, getErrorMessage, isWithinRoot, getErrorStatus, } from '@google/gemini-cli-core';
+import { AuthType, logToolCall, convertToFunctionResponse, ToolConfirmationOutcome, clearCachedCredentialFile, isNodeError, getErrorMessage, isWithinRoot, getErrorStatus, MCPServerConfig, } 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';
-export async function runAcpPeer(config, settings) {
+import { z } from 'zod';
+import { randomUUID } from 'crypto';
+import { loadCliConfig } from '../config/config.js';
+export async function runZedIntegration(config, settings, extensions, argv) {
     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
@@ -17,61 +20,138 @@ export async function runAcpPeer(config, settings) {
     console.log = console.error;
     console.info = console.error;
     console.debug = console.error;
-    new acp.ClientConnection((client) => new GeminiAgent(config, settings, client), stdout, stdin);
+    new acp.AgentSideConnection((client) => new GeminiAgent(config, settings, extensions, argv, client), stdout, stdin);
 }
 class GeminiAgent {
     config;
     settings;
+    extensions;
+    argv;
     client;
-    chat;
-    pendingSend;
-    constructor(config, settings, client) {
+    sessions = new Map();
+    constructor(config, settings, extensions, argv, client) {
         this.config = config;
         this.settings = settings;
+        this.extensions = extensions;
+        this.argv = argv;
         this.client = client;
     }
-    async initialize(_) {
+    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);
         let isAuthenticated = false;
         if (this.settings.merged.selectedAuthType) {
             try {
-                await this.config.refreshAuth(this.settings.merged.selectedAuthType);
+                await config.refreshAuth(this.settings.merged.selectedAuthType);
                 isAuthenticated = true;
             }
-            catch (error) {
-                console.error('Failed to refresh auth:', error);
+            catch (e) {
+                console.error(`Authentication failed: ${e}`);
             }
         }
-        return { protocolVersion: acp.LATEST_PROTOCOL_VERSION, isAuthenticated };
+        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 authenticate() {
-        await clearCachedCredentialFile();
-        await this.config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
-        this.settings.setValue(SettingScope.User, 'selectedAuthType', AuthType.LOGIN_WITH_GOOGLE);
+    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;
+            }
+            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;
+    }
+    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);
     }
-    async cancelSendMessage() {
-        if (!this.pendingSend) {
+}
+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 cancelPendingPrompt() {
+        if (!this.pendingPrompt) {
             throw new Error('Not currently generating');
         }
-        this.pendingSend.abort();
-        delete this.pendingSend;
+        this.pendingPrompt.abort();
+        this.pendingPrompt = null;
     }
-    async sendUserMessage(params) {
-        this.pendingSend?.abort();
+    async prompt(params) {
+        this.pendingPrompt?.abort();
         const pendingSend = new AbortController();
-        this.pendingSend = pendingSend;
-        if (!this.chat) {
-            const geminiClient = this.config.getGeminiClient();
-            this.chat = await geminiClient.startChat();
-        }
+        this.pendingPrompt = pendingSend;
         const promptId = Math.random().toString(16).slice(2);
         const chat = this.chat;
-        const toolRegistry = await this.config.getToolRegistry();
-        const parts = await this.#resolveUserMessage(params, pendingSend.signal);
+        const parts = await this.#resolvePrompt(params.prompt, pendingSend.signal);
         let nextMessage = { role: 'user', parts };
         while (nextMessage !== null) {
             if (pendingSend.signal.aborted) {
                 chat.addHistory(nextMessage);
-                return;
+                return { stopReason: 'cancelled' };
             }
             const functionCalls = [];
             try {
@@ -79,17 +159,12 @@ class GeminiAgent {
                     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;
+                        return { stopReason: 'cancelled' };
                     }
                     if (resp.candidates && resp.candidates.length > 0) {
                         const candidate = resp.candidates[0];
@@ -97,10 +172,15 @@ class GeminiAgent {
                             if (!part.text) {
                                 continue;
                             }
-                            this.client.streamAssistantMessageChunk({
-                                chunk: part.thought
-                                    ? { thought: part.text }
-                                    : { text: part.text },
+                            const content = {
+                                type: 'text',
+                                text: part.text,
+                            };
+                            this.sendUpdate({
+                                sessionUpdate: part.thought
+                                    ? 'agent_thought_chunk'
+                                    : 'agent_message_chunk',
+                                content,
                             });
                         }
                     }
@@ -118,7 +198,7 @@ class GeminiAgent {
             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') {
@@ -132,8 +212,16 @@ class GeminiAgent {
                 nextMessage = { role: 'user', parts: toolResponseParts };
             }
         }
+        return { stopReason: 'end_turn' };
     }
-    async #runTool(abortSignal, promptId, fc) {
+    async sendUpdate(update) {
+        const params = {
+            sessionId: this.id,
+            update,
+        };
+        await this.client.sessionUpdate(params);
+    }
+    async runTool(abortSignal, promptId, fc) {
         const callId = fc.id ?? `${fc.name}-${Date.now()}`;
         const args = (fc.args ?? {});
         const startTime = Date.now();
@@ -167,58 +255,71 @@ class GeminiAgent {
         if (!tool) {
             return errorResponse(new Error(`Tool "${fc.name}" not found in registry.`));
         }
-        let toolCallId;
-        const confirmationDetails = await tool.shouldConfirmExecute(args, abortSignal);
+        const invocation = tool.build(args);
+        const confirmationDetails = await invocation.shouldConfirmExecute(abortSignal);
         if (confirmationDetails) {
-            let content = null;
+            const content = [];
             if (confirmationDetails.type === 'edit') {
-                content = {
+                content.push({
                     type: 'diff',
                     path: confirmationDetails.fileName,
                     oldText: confirmationDetails.originalContent,
                     newText: confirmationDetails.newContent,
-                };
+                });
             }
-            const result = await this.client.requestToolCallConfirmation({
-                label: tool.getDescription(args),
-                icon: tool.icon,
-                content,
-                confirmation: toAcpToolCallConfirmation(confirmationDetails),
-                locations: tool.toolLocations(args),
-            });
-            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':
+            const params = {
+                sessionId: this.id,
+                options: toPermissionOptions(confirmationDetails),
+                toolCall: {
+                    toolCallId: callId,
+                    status: 'pending',
+                    title: invocation.getDescription(),
+                    content,
+                    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 'allow':
-                case 'alwaysAllow':
-                case 'alwaysAllowMcpServer':
-                case 'alwaysAllowTool':
+                case ToolConfirmationOutcome.ProceedOnce:
+                case ToolConfirmationOutcome.ProceedAlways:
+                case ToolConfirmationOutcome.ProceedAlwaysServer:
+                case ToolConfirmationOutcome.ProceedAlwaysTool:
+                case ToolConfirmationOutcome.ModifyWithEditor:
                     break;
                 default: {
-                    const resultOutcome = result.outcome;
+                    const resultOutcome = outcome;
                     throw new Error(`Unexpected: ${resultOutcome}`);
                 }
             }
-            toolCallId = result.id;
         }
         else {
-            const result = await this.client.pushToolCall({
-                icon: tool.icon,
-                label: tool.getDescription(args),
-                locations: tool.toolLocations(args),
+            await this.sendUpdate({
+                sessionUpdate: 'tool_call',
+                toolCallId: callId,
+                status: 'in_progress',
+                title: invocation.getDescription(),
+                content: [],
+                locations: invocation.toolLocations(),
+                kind: tool.kind,
             });
-            toolCallId = result.id;
         }
         try {
-            const toolResult = await tool.execute(args, abortSignal);
-            const toolCallContent = toToolCallContent(toolResult);
-            await this.client.updateToolCall({
-                toolCallId,
-                status: 'finished',
-                content: toolCallContent,
+            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 durationMs = Date.now() - startTime;
             logToolCall(this.config, {
@@ -234,25 +335,47 @@ class GeminiAgent {
         }
         catch (e) {
             const error = e instanceof Error ? e : new Error(String(e));
-            await this.client.updateToolCall({
-                toolCallId,
-                status: 'error',
-                content: { type: 'markdown', markdown: error.message },
+            await this.sendUpdate({
+                sessionUpdate: 'tool_call_update',
+                toolCallId: callId,
+                status: 'failed',
+                content: [
+                    { type: 'content', content: { type: 'text', text: error.message } },
+                ],
             });
             return errorResponse(error);
         }
     }
-    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 };
+    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,
+                        },
+                    };
                 }
-                else {
-                    throw new Error('Unexpected chunk type');
+                default: {
+                    throw new Error(`Unexpected chunk type: '${part.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();
@@ -268,7 +391,7 @@ class GeminiAgent {
             throw new Error('Error: read_many_files tool not found.');
         }
         for (const atPathPart of atPathCommandParts) {
-            const pathName = atPathPart.path;
+            const pathName = atPathPart.fileData.fileUri;
             // Check if path should be ignored by git
             if (fileDiscovery.shouldGitIgnoreFile(pathName)) {
                 ignoredPaths.push(pathName);
@@ -288,23 +411,23 @@ class GeminiAgent {
                         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.execute({
+                            const globResult = await globTool.buildAndExecute({
                                 pattern: `**/*${pathName}*`,
                                 path: this.config.getTargetDir(),
                             }, abortSignal);
@@ -316,15 +439,15 @@ class GeminiAgent {
                                 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) {
@@ -332,7 +455,7 @@ class GeminiAgent {
                         }
                     }
                     else {
-                        this.#debug(`Glob tool not found. Path ${pathName} will be skipped.`);
+                        this.debug(`Glob tool not found. Path ${pathName} will be skipped.`);
                     }
                 }
                 else {
@@ -347,22 +470,23 @@ class GeminiAgent {
         }
         // Construct the initial part of the query for the LLM
         let initialQueryText = '';
-        for (let i = 0; i < message.chunks.length; i++) {
-            const chunk = message.chunks[i];
+        for (let i = 0; i < parts.length; i++) {
+            const chunk = parts[i];
             if ('text' in chunk) {
                 initialQueryText += chunk.text;
             }
             else {
                 // type === 'atPath'
-                const resolvedSpec = atPathToResolvedSpecMap.get(chunk.path);
+                const resolvedSpec = chunk.fileData && atPathToResolvedSpecMap.get(chunk.fileData.fileUri);
                 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 = message.chunks[i - 1];
+                    const prevPart = parts[i - 1];
                     if ('text' in prevPart ||
-                        ('path' in prevPart && atPathToResolvedSpecMap.has(prevPart.path))) {
+                        ('fileData' in prevPart &&
+                            atPathToResolvedSpecMap.has(prevPart.fileData.fileUri))) {
                         initialQueryText += ' ';
                     }
                 }
@@ -375,10 +499,12 @@ class GeminiAgent {
                     if (i > 0 &&
                         initialQueryText.length > 0 &&
                         !initialQueryText.endsWith(' ') &&
-                        !chunk.path.startsWith(' ')) {
+                        !chunk.fileData?.fileUri.startsWith(' ')) {
                         initialQueryText += ' ';
                     }
-                    initialQueryText += `@${chunk.path}`;
+                    if (chunk.fileData?.fileUri) {
+                        initialQueryText += `@${chunk.fileData.fileUri}`;
+                    }
                 }
             }
         }
@@ -386,7 +512,7 @@ class GeminiAgent {
         // 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) {
@@ -398,20 +524,31 @@ class GeminiAgent {
             paths: pathSpecsToRead,
             respectGitIgnore, // Use configuration setting
         };
-        const toolCall = await this.client.pushToolCall({
-            icon: readManyFilesTool.icon,
-            label: readManyFilesTool.getDescription(toolArgs),
-        });
+        const callId = `${readManyFilesTool.name}-${Date.now()}`;
         try {
-            const result = await readManyFilesTool.execute(toolArgs, abortSignal);
+            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 result = await invocation.execute(abortSignal);
             const content = toToolCallContent(result) || {
-                type: 'markdown',
-                markdown: `Successfully read: ${contentLabelsForDisplay.join(', ')}`,
+                type: 'content',
+                content: {
+                    type: 'text',
+                    text: `Successfully read: ${contentLabelsForDisplay.join(', ')}`,
+                },
             };
-            await this.client.updateToolCall({
-                toolCallId: toolCall.id,
-                status: 'finished',
-                content,
+            await this.sendUpdate({
+                sessionUpdate: 'tool_call_update',
+                toolCallId: callId,
+                status: 'completed',
+                content: content ? [content] : [],
             });
             if (Array.isArray(result.llmContent)) {
                 const fileContentRegex = /^--- (.*?) ---\n\n([\s\S]*?)\n\n$/;
@@ -446,18 +583,24 @@ class GeminiAgent {
             return processedQueryParts;
         }
         catch (error) {
-            await this.client.updateToolCall({
-                toolCallId: toolCall.id,
-                status: 'error',
-                content: {
-                    type: 'markdown',
-                    markdown: `Error reading files (${contentLabelsForDisplay.join(', ')}): ${getErrorMessage(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)}`,
+                        },
+                    },
+                ],
             });
             throw error;
         }
     }
-    #debug(msg) {
+    debug(msg) {
         if (this.config.getDebugMode()) {
             console.warn(msg);
         }
@@ -467,8 +610,8 @@ function toToolCallContent(toolResult) {
     if (toolResult.returnDisplay) {
         if (typeof toolResult.returnDisplay === 'string') {
             return {
-                type: 'markdown',
-                markdown: toolResult.returnDisplay,
+                type: 'content',
+                content: { type: 'text', text: toolResult.returnDisplay },
             };
         }
         else {
@@ -484,54 +627,65 @@ function toToolCallContent(toolResult) {
         return null;
     }
 }
-function toAcpToolCallConfirmation(confirmationDetails) {
-    switch (confirmationDetails.type) {
+const basicPermissionOptions = [
+    {
+        optionId: ToolConfirmationOutcome.ProceedOnce,
+        name: 'Allow',
+        kind: 'allow_once',
+    },
+    {
+        optionId: ToolConfirmationOutcome.Cancel,
+        name: 'Reject',
+        kind: 'reject_once',
+    },
+];
+function toPermissionOptions(confirmation) {
+    switch (confirmation.type) {
         case 'edit':
-            return { type: 'edit' };
+            return [
+                {
+                    optionId: ToolConfirmationOutcome.ProceedAlways,
+                    name: 'Allow All Edits',
+                    kind: 'allow_always',
+                },
+                ...basicPermissionOptions,
+            ];
         case 'exec':
-            return {
-                type: 'execute',
-                rootCommand: confirmationDetails.rootCommand,
-                command: confirmationDetails.command,
-            };
+            return [
+                {
+                    optionId: ToolConfirmationOutcome.ProceedAlways,
+                    name: `Always Allow ${confirmation.rootCommand}`,
+                    kind: 'allow_always',
+                },
+                ...basicPermissionOptions,
+            ];
         case 'mcp':
-            return {
-                type: 'mcp',
-                serverName: confirmationDetails.serverName,
-                toolName: confirmationDetails.toolName,
-                toolDisplayName: confirmationDetails.toolDisplayName,
-            };
+            return [
+                {
+                    optionId: ToolConfirmationOutcome.ProceedAlwaysServer,
+                    name: `Always Allow ${confirmation.serverName}`,
+                    kind: 'allow_always',
+                },
+                {
+                    optionId: ToolConfirmationOutcome.ProceedAlwaysTool,
+                    name: `Always Allow ${confirmation.toolName}`,
+                    kind: 'allow_always',
+                },
+                ...basicPermissionOptions,
+            ];
         case 'info':
-            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;
+            return [
+                {
+                    optionId: ToolConfirmationOutcome.ProceedAlways,
+                    name: `Always Allow`,
+                    kind: 'allow_always',
+                },
+                ...basicPermissionOptions,
+            ];
         default: {
-            const unreachable = outcome;
+            const unreachable = confirmation;
             throw new Error(`Unexpected: ${unreachable}`);
         }
     }
 }
-//# sourceMappingURL=acpPeer.js.map
+//# sourceMappingURL=zedIntegration.js.map