@umsai/ums-code 0.0.11-post1

package/dist/src/zed-integration/zedIntegration.js

@@ -0,0 +1,765 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AuthType, clearCachedCredentialFile, logToolCall, convertToFunctionResponse, getErrorMessage, getErrorStatus, isNodeError, isWithinRoot, MCPServerConfig, ToolConfirmationOutcome, DiscoveredMCPTool, } from '@umsai/ums-code-core';
+import { AcpFileSystemService } from './fileSystemService.js';
+import * as fs from 'fs/promises';
+import { Readable, Writable } from 'node:stream';
+import * as path from 'path';
+import { z } from 'zod';
+import { SettingScope } from '../config/settings.js';
+import * as acp from './acp.js';
+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
+    // messages to stderr so that they don't interfere with ACP.
+    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);
+}
+class GeminiAgent {
+    config;
+    settings;
+    extensions;
+    argv;
+    client;
+    sessions = new Map();
+    clientCapabilities;
+    constructor(config, settings, extensions, argv, client) {
+        this.config = config;
+        this.settings = settings;
+        this.extensions = extensions;
+        this.argv = argv;
+        this.client = client;
+    }
+    async initialize(args) {
+        this.clientCapabilities = args.clientCapabilities;
+        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,
+                promptCapabilities: {
+                    image: true,
+                    audio: true,
+                    embeddedContext: true,
+                },
+            },
+        };
+    }
+    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 config.refreshAuth(this.settings.merged.selectedAuthType);
+                isAuthenticated = true;
+            }
+            catch (e) {
+                console.error(`Authentication failed: ${e}`);
+            }
+        }
+        if (!isAuthenticated) {
+            throw acp.RequestError.authRequired();
+        }
+        if (this.clientCapabilities?.fs) {
+            const acpFileSystemService = new AcpFileSystemService(this.client, sessionId, this.clientCapabilities.fs, config.getFileSystemService());
+            config.setFileSystemService(acpFileSystemService);
+        }
+        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;
+            }
+            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);
+    }
+}
+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.pendingPrompt.abort();
+        this.pendingPrompt = null;
+    }
+    async prompt(params) {
+        this.pendingPrompt?.abort();
+        const pendingSend = new AbortController();
+        this.pendingPrompt = pendingSend;
+        const promptId = Math.random().toString(16).slice(2);
+        const chat = this.chat;
+        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 { stopReason: 'cancelled' };
+            }
+            const functionCalls = [];
+            try {
+                const responseStream = await chat.sendMessageStream({
+                    message: nextMessage?.parts ?? [],
+                    config: {
+                        abortSignal: pendingSend.signal,
+                    },
+                }, promptId);
+                nextMessage = null;
+                for await (const resp of responseStream) {
+                    if (pendingSend.signal.aborted) {
+                        return { stopReason: 'cancelled' };
+                    }
+                    if (resp.candidates && resp.candidates.length > 0) {
+                        const candidate = resp.candidates[0];
+                        for (const part of candidate.content?.parts ?? []) {
+                            if (!part.text) {
+                                continue;
+                            }
+                            const content = {
+                                type: 'text',
+                                text: part.text,
+                            };
+                            this.sendUpdate({
+                                sessionUpdate: part.thought
+                                    ? 'agent_thought_chunk'
+                                    : 'agent_message_chunk',
+                                content,
+                            });
+                        }
+                    }
+                    if (resp.functionCalls) {
+                        functionCalls.push(...resp.functionCalls);
+                    }
+                }
+            }
+            catch (error) {
+                if (getErrorStatus(error) === 429) {
+                    throw new acp.RequestError(429, 'Rate limit exceeded. Try again later.');
+                }
+                throw error;
+            }
+            if (functionCalls.length > 0) {
+                const toolResponseParts = [];
+                for (const fc of functionCalls) {
+                    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') {
+                            toolResponseParts.push({ text: part });
+                        }
+                        else if (part) {
+                            toolResponseParts.push(part);
+                        }
+                    }
+                }
+                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) {
+        const callId = fc.id ?? `${fc.name}-${Date.now()}`;
+        const args = (fc.args ?? {});
+        const startTime = Date.now();
+        const errorResponse = (error) => {
+            const durationMs = Date.now() - startTime;
+            logToolCall(this.config, {
+                'event.name': 'tool_call',
+                'event.timestamp': new Date().toISOString(),
+                prompt_id: promptId,
+                function_name: fc.name ?? '',
+                function_args: args,
+                duration_ms: durationMs,
+                success: false,
+                error: error.message,
+                tool_type: typeof tool !== 'undefined' && tool instanceof DiscoveredMCPTool
+                    ? 'mcp'
+                    : 'native',
+            });
+            return [
+                {
+                    functionResponse: {
+                        id: callId,
+                        name: fc.name ?? '',
+                        response: { error: error.message },
+                    },
+                },
+            ];
+        };
+        if (!fc.name) {
+            return errorResponse(new Error('Missing function name'));
+        }
+        const toolRegistry = this.config.getToolRegistry();
+        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 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(),
+                        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 ToolConfirmationOutcome.ProceedOnce:
+                    case ToolConfirmationOutcome.ProceedAlways:
+                    case ToolConfirmationOutcome.ProceedAlwaysServer:
+                    case ToolConfirmationOutcome.ProceedAlwaysTool:
+                    case ToolConfirmationOutcome.ModifyWithEditor:
+                        break;
+                    default: {
+                        const resultOutcome = outcome;
+                        throw new Error(`Unexpected: ${resultOutcome}`);
+                    }
+                }
+            }
+            else {
+                await this.sendUpdate({
+                    sessionUpdate: 'tool_call',
+                    toolCallId: callId,
+                    status: 'in_progress',
+                    title: invocation.getDescription(),
+                    content: [],
+                    locations: invocation.toolLocations(),
+                    kind: tool.kind,
+                });
+            }
+            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, {
+                'event.name': 'tool_call',
+                'event.timestamp': new Date().toISOString(),
+                function_name: fc.name,
+                function_args: args,
+                duration_ms: durationMs,
+                success: true,
+                prompt_id: promptId,
+                tool_type: typeof tool !== 'undefined' && tool instanceof DiscoveredMCPTool
+                    ? 'mcp'
+                    : 'native',
+            });
+            return convertToFunctionResponse(fc.name, callId, toolResult.llmContent);
+        }
+        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 } },
+                ],
+            });
+            return errorResponse(error);
+        }
+    }
+    async #resolvePrompt(message, abortSignal) {
+        const FILE_URI_SCHEME = 'file://';
+        const embeddedContext = [];
+        const parts = message.map((part) => {
+            switch (part.type) {
+                case 'text':
+                    return { text: part.text };
+                case 'image':
+                case 'audio':
+                    return {
+                        inlineData: {
+                            mimeType: part.mimeType,
+                            data: part.data,
+                        },
+                    };
+                case 'resource_link': {
+                    if (part.uri.startsWith(FILE_URI_SCHEME)) {
+                        return {
+                            fileData: {
+                                mimeData: part.mimeType,
+                                name: part.name,
+                                fileUri: part.uri.slice(FILE_URI_SCHEME.length),
+                            },
+                        };
+                    }
+                    else {
+                        return { text: `@${part.uri}` };
+                    }
+                }
+                case 'resource': {
+                    embeddedContext.push(part.resource);
+                    return { text: `@${part.resource.uri}` };
+                }
+                default: {
+                    const unreachable = part;
+                    throw new Error(`Unexpected chunk type: '${unreachable}'`);
+                }
+            }
+        });
+        const atPathCommandParts = parts.filter((part) => 'fileData' in part);
+        if (atPathCommandParts.length === 0 && embeddedContext.length === 0) {
+            return parts;
+        }
+        const atPathToResolvedSpecMap = new Map();
+        // Get centralized file discovery service
+        const fileDiscovery = this.config.getFileService();
+        const respectGitIgnore = this.config.getFileFilteringRespectGitIgnore();
+        const pathSpecsToRead = [];
+        const contentLabelsForDisplay = [];
+        const ignoredPaths = [];
+        const toolRegistry = this.config.getToolRegistry();
+        const readManyFilesTool = toolRegistry.getTool('read_many_files');
+        const globTool = toolRegistry.getTool('glob');
+        if (!readManyFilesTool) {
+            throw new Error('Error: read_many_files tool not found.');
+        }
+        for (const atPathPart of atPathCommandParts) {
+            const pathName = atPathPart.fileData.fileUri;
+            // Check if path should be ignored by git
+            if (fileDiscovery.shouldGitIgnoreFile(pathName)) {
+                ignoredPaths.push(pathName);
+                const reason = respectGitIgnore
+                    ? 'git-ignored and will be skipped'
+                    : 'ignored by custom patterns';
+                console.warn(`Path ${pathName} is ${reason}.`);
+                continue;
+            }
+            let currentPathSpec = pathName;
+            let resolvedSuccessfully = 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}`);
+                    }
+                    else {
+                        this.debug(`Path ${pathName} resolved to file: ${currentPathSpec}`);
+                    }
+                    resolvedSuccessfully = true;
+                }
+                else {
+                    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.`);
+                        try {
+                            const globResult = await globTool.buildAndExecute({
+                                pattern: `**/*${pathName}*`,
+                                path: this.config.getTargetDir(),
+                            }, abortSignal);
+                            if (globResult.llmContent &&
+                                typeof globResult.llmContent === 'string' &&
+                                !globResult.llmContent.startsWith('No files found') &&
+                                !globResult.llmContent.startsWith('Error:')) {
+                                const lines = globResult.llmContent.split('\n');
+                                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}`);
+                                    resolvedSuccessfully = true;
+                                }
+                                else {
+                                    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.`);
+                            }
+                        }
+                        catch (globError) {
+                            console.error(`Error during glob search for ${pathName}: ${getErrorMessage(globError)}`);
+                        }
+                    }
+                    else {
+                        this.debug(`Glob tool not found. Path ${pathName} will be skipped.`);
+                    }
+                }
+                else {
+                    console.error(`Error stating path ${pathName}. Path ${pathName} will be skipped.`);
+                }
+            }
+            if (resolvedSuccessfully) {
+                pathSpecsToRead.push(currentPathSpec);
+                atPathToResolvedSpecMap.set(pathName, currentPathSpec);
+                contentLabelsForDisplay.push(pathName);
+            }
+        }
+        // Construct the initial part of the query for the LLM
+        let initialQueryText = '';
+        for (let i = 0; i < parts.length; i++) {
+            const chunk = parts[i];
+            if ('text' in chunk) {
+                initialQueryText += chunk.text;
+            }
+            else {
+                // type === 'atPath'
+                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 = parts[i - 1];
+                    if ('text' in prevPart ||
+                        ('fileData' in prevPart &&
+                            atPathToResolvedSpecMap.has(prevPart.fileData.fileUri))) {
+                        initialQueryText += ' ';
+                    }
+                }
+                if (resolvedSpec) {
+                    initialQueryText += `@${resolvedSpec}`;
+                }
+                else {
+                    // If not resolved for reading (e.g. lone @ or invalid path that was skipped),
+                    // add the original @-string back, ensuring spacing if it's not the first element.
+                    if (i > 0 &&
+                        initialQueryText.length > 0 &&
+                        !initialQueryText.endsWith(' ') &&
+                        !chunk.fileData?.fileUri.startsWith(' ')) {
+                        initialQueryText += ' ';
+                    }
+                    if (chunk.fileData?.fileUri) {
+                        initialQueryText += `@${chunk.fileData.fileUri}`;
+                    }
+                }
+            }
+        }
+        initialQueryText = initialQueryText.trim();
+        // 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(', ')}`);
+        }
+        const processedQueryParts = [{ text: initialQueryText }];
+        if (pathSpecsToRead.length === 0 && embeddedContext.length === 0) {
+            // Fallback for lone "@" or completely invalid @-commands resulting in empty initialQueryText
+            console.warn('No valid file paths found in @ commands to read.');
+            return [{ text: initialQueryText }];
+        }
+        if (pathSpecsToRead.length > 0) {
+            const toolArgs = {
+                paths: pathSpecsToRead,
+                respectGitIgnore, // Use configuration setting
+            };
+            const callId = `${readManyFilesTool.name}-${Date.now()}`;
+            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 result = await invocation.execute(abortSignal);
+                const content = toToolCallContent(result) || {
+                    type: 'content',
+                    content: {
+                        type: 'text',
+                        text: `Successfully read: ${contentLabelsForDisplay.join(', ')}`,
+                    },
+                };
+                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$/;
+                    processedQueryParts.push({
+                        text: '\n--- Content from referenced files ---',
+                    });
+                    for (const part of result.llmContent) {
+                        if (typeof part === 'string') {
+                            const match = fileContentRegex.exec(part);
+                            if (match) {
+                                const filePathSpecInContent = match[1]; // This is a resolved pathSpec
+                                const fileActualContent = match[2].trim();
+                                processedQueryParts.push({
+                                    text: `\nContent from @${filePathSpecInContent}:\n`,
+                                });
+                                processedQueryParts.push({ text: fileActualContent });
+                            }
+                            else {
+                                processedQueryParts.push({ text: part });
+                            }
+                        }
+                        else {
+                            // part is a Part object.
+                            processedQueryParts.push(part);
+                        }
+                    }
+                }
+                else {
+                    console.warn('read_many_files tool returned no content or empty content.');
+                }
+            }
+            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)}`,
+                            },
+                        },
+                    ],
+                });
+                throw error;
+            }
+        }
+        if (embeddedContext.length > 0) {
+            processedQueryParts.push({
+                text: '\n--- Content from referenced context ---',
+            });
+            for (const contextPart of embeddedContext) {
+                processedQueryParts.push({
+                    text: `\nContent from @${contextPart.uri}:\n`,
+                });
+                if ('text' in contextPart) {
+                    processedQueryParts.push({
+                        text: contextPart.text,
+                    });
+                }
+                else {
+                    processedQueryParts.push({
+                        inlineData: {
+                            mimeType: contextPart.mimeType ?? 'application/octet-stream',
+                            data: contextPart.blob,
+                        },
+                    });
+                }
+            }
+        }
+        return processedQueryParts;
+    }
+    debug(msg) {
+        if (this.config.getDebugMode()) {
+            console.warn(msg);
+        }
+    }
+}
+function toToolCallContent(toolResult) {
+    if (toolResult.error?.message) {
+        throw new Error(toolResult.error.message);
+    }
+    if (toolResult.returnDisplay) {
+        if (typeof toolResult.returnDisplay === 'string') {
+            return {
+                type: 'content',
+                content: { type: 'text', text: toolResult.returnDisplay },
+            };
+        }
+        else if ('type' in toolResult.returnDisplay &&
+            toolResult.returnDisplay.type === 'todo_list') {
+            // Handle TodoResultDisplay - convert to text representation
+            const todoText = toolResult.returnDisplay.todos
+                .map((todo) => {
+                const statusIcon = {
+                    pending: '○',
+                    in_progress: '◐',
+                    completed: '●',
+                }[todo.status];
+                return `${statusIcon} ${todo.content}`;
+            })
+                .join('\n');
+            return {
+                type: 'content',
+                content: { type: 'text', text: todoText },
+            };
+        }
+        else if ('fileDiff' in toolResult.returnDisplay) {
+            // Handle FileDiff
+            return {
+                type: 'diff',
+                path: toolResult.returnDisplay.fileName,
+                oldText: toolResult.returnDisplay.originalContent,
+                newText: toolResult.returnDisplay.newContent,
+            };
+        }
+    }
+    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) {
+        case 'edit':
+            return [
+                {
+                    optionId: ToolConfirmationOutcome.ProceedAlways,
+                    name: 'Allow All Edits',
+                    kind: 'allow_always',
+                },
+                ...basicPermissionOptions,
+            ];
+        case 'exec':
+            return [
+                {
+                    optionId: ToolConfirmationOutcome.ProceedAlways,
+                    name: `Always Allow ${confirmation.rootCommand}`,
+                    kind: 'allow_always',
+                },
+                ...basicPermissionOptions,
+            ];
+        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,
+            ];
+        case 'info':
+            return [
+                {
+                    optionId: ToolConfirmationOutcome.ProceedAlways,
+                    name: `Always Allow`,
+                    kind: 'allow_always',
+                },
+                ...basicPermissionOptions,
+            ];
+        default: {
+            const unreachable = confirmation;
+            throw new Error(`Unexpected: ${unreachable}`);
+        }
+    }
+}
+//# sourceMappingURL=zedIntegration.js.map