@umsai/ums-code 0.3.0-v2 → 0.6.0-v1

package/dist/src/acp-integration/session/Session.js

@@ -0,0 +1,839 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ApprovalMode, convertToFunctionResponse, DiscoveredMCPTool, StreamEventType, ToolConfirmationOutcome, logToolCall, logUserPrompt, getErrorStatus, isWithinRoot, isNodeError, TaskTool, UserPromptEvent, TodoWriteTool, ExitPlanModeTool, } from '@umsai/ums-code-core';
+import * as acp from '../acp.js';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { z } from 'zod';
+import { getErrorMessage } from '../../utils/errors.js';
+import { normalizePartList } from '../../utils/nonInteractiveHelpers.js';
+import { handleSlashCommand, getAvailableCommands, } from '../../nonInteractiveCliCommands.js';
+import { isSlashCommand } from '../../ui/utils/commandUtils.js';
+import { HistoryReplayer } from './HistoryReplayer.js';
+import { ToolCallEmitter } from './emitters/ToolCallEmitter.js';
+import { PlanEmitter } from './emitters/PlanEmitter.js';
+import { MessageEmitter } from './emitters/MessageEmitter.js';
+import { SubAgentTracker } from './SubAgentTracker.js';
+/**
+ * Session represents an active conversation session with the AI model.
+ * It uses modular components for consistent event emission:
+ * - HistoryReplayer for replaying past conversations
+ * - ToolCallEmitter for tool-related session updates
+ * - PlanEmitter for todo/plan updates
+ * - SubAgentTracker for tracking sub-agent tool calls
+ */
+export class Session {
+    chat;
+    config;
+    client;
+    settings;
+    pendingPrompt = null;
+    turn = 0;
+    // Modular components
+    historyReplayer;
+    toolCallEmitter;
+    planEmitter;
+    messageEmitter;
+    // Implement SessionContext interface
+    sessionId;
+    constructor(id, chat, config, client, settings) {
+        this.chat = chat;
+        this.config = config;
+        this.client = client;
+        this.settings = settings;
+        this.sessionId = id;
+        // Initialize modular components with this session as context
+        this.toolCallEmitter = new ToolCallEmitter(this);
+        this.planEmitter = new PlanEmitter(this);
+        this.historyReplayer = new HistoryReplayer(this);
+        this.messageEmitter = new MessageEmitter(this);
+    }
+    getId() {
+        return this.sessionId;
+    }
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Replays conversation history to the client using modular components.
+     * Delegates to HistoryReplayer for consistent event emission.
+     */
+    async replayHistory(records) {
+        await this.historyReplayer.replay(records);
+    }
+    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;
+        // Increment turn counter for each user prompt
+        this.turn += 1;
+        const chat = this.chat;
+        const promptId = this.config.getSessionId() + '########' + this.turn;
+        // Extract text from all text blocks to construct the full prompt text for logging
+        const promptText = params.prompt
+            .filter((block) => block.type === 'text')
+            .map((block) => (block.type === 'text' ? block.text : ''))
+            .join(' ');
+        // Log user prompt
+        logUserPrompt(this.config, new UserPromptEvent(promptText.length, promptId, this.config.getContentGeneratorConfig()?.authType, promptText));
+        // record user message for session management
+        this.config.getChatRecordingService()?.recordUserMessage(promptText);
+        // Check if the input contains a slash command
+        // Extract text from the first text block if present
+        const firstTextBlock = params.prompt.find((block) => block.type === 'text');
+        const inputText = firstTextBlock?.text || '';
+        let parts;
+        if (isSlashCommand(inputText)) {
+            // Handle slash command - uses default allowed commands (init, summary, compress)
+            const slashCommandResult = await handleSlashCommand(inputText, pendingSend, this.config, this.settings);
+            parts = await this.#processSlashCommandResult(slashCommandResult, params.prompt);
+            // If parts is null, the command was fully handled (e.g., /summary completed)
+            // Return early without sending to the model
+            if (parts === null) {
+                return { stopReason: 'end_turn' };
+            }
+        }
+        else {
+            // Normal processing for non-slash commands
+            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 = [];
+            let usageMetadata = null;
+            const streamStartTime = Date.now();
+            try {
+                const responseStream = await chat.sendMessageStream(this.config.getModel(), {
+                    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.type === StreamEventType.CHUNK &&
+                        resp.value.candidates &&
+                        resp.value.candidates.length > 0) {
+                        const candidate = resp.value.candidates[0];
+                        for (const part of candidate.content?.parts ?? []) {
+                            if (!part.text) {
+                                continue;
+                            }
+                            this.messageEmitter.emitMessage(part.text, 'assistant', part.thought);
+                        }
+                    }
+                    if (resp.type === StreamEventType.CHUNK && resp.value.usageMetadata) {
+                        usageMetadata = resp.value.usageMetadata;
+                    }
+                    if (resp.type === StreamEventType.CHUNK && resp.value.functionCalls) {
+                        functionCalls.push(...resp.value.functionCalls);
+                    }
+                }
+            }
+            catch (error) {
+                if (getErrorStatus(error) === 429) {
+                    throw new acp.RequestError(429, 'Rate limit exceeded. Try again later.');
+                }
+                throw error;
+            }
+            if (usageMetadata) {
+                const durationMs = Date.now() - streamStartTime;
+                await this.messageEmitter.emitUsageMetadata(usageMetadata, '', durationMs);
+            }
+            if (functionCalls.length > 0) {
+                const toolResponseParts = [];
+                for (const fc of functionCalls) {
+                    const response = await this.runTool(pendingSend.signal, promptId, fc);
+                    toolResponseParts.push(...response);
+                }
+                nextMessage = { role: 'user', parts: toolResponseParts };
+            }
+        }
+        return { stopReason: 'end_turn' };
+    }
+    async sendUpdate(update) {
+        const params = {
+            sessionId: this.sessionId,
+            update,
+        };
+        await this.client.sessionUpdate(params);
+    }
+    async sendAvailableCommandsUpdate() {
+        const abortController = new AbortController();
+        try {
+            // Use default allowed commands from getAvailableCommands
+            const slashCommands = await getAvailableCommands(this.config, abortController.signal);
+            // Convert SlashCommand[] to AvailableCommand[] format for ACP protocol
+            const availableCommands = slashCommands.map((cmd) => ({
+                name: cmd.name,
+                description: cmd.description,
+                input: null,
+            }));
+            const update = {
+                sessionUpdate: 'available_commands_update',
+                availableCommands,
+            };
+            await this.sendUpdate(update);
+        }
+        catch (error) {
+            // Log error but don't fail session creation
+            console.error('Error sending available commands update:', error);
+        }
+    }
+    /**
+     * Requests permission from the client for a tool call.
+     * Used by SubAgentTracker for sub-agent approval requests.
+     */
+    async requestPermission(params) {
+        return this.client.requestPermission(params);
+    }
+    /**
+     * Sets the approval mode for the current session.
+     * Maps ACP approval mode values to core ApprovalMode enum.
+     */
+    async setMode(params) {
+        const modeMap = {
+            plan: ApprovalMode.PLAN,
+            default: ApprovalMode.DEFAULT,
+            'auto-edit': ApprovalMode.AUTO_EDIT,
+            yolo: ApprovalMode.YOLO,
+        };
+        const approvalMode = modeMap[params.modeId];
+        this.config.setApprovalMode(approvalMode);
+        return { modeId: params.modeId };
+    }
+    /**
+     * Sends a current_mode_update notification to the client.
+     * Called after the agent switches modes (e.g., from exit_plan_mode tool).
+     */
+    async sendCurrentModeUpdateNotification(outcome) {
+        // Determine the new mode based on the approval outcome
+        // This mirrors the logic in ExitPlanModeTool.onConfirm
+        let newModeId;
+        switch (outcome) {
+            case ToolConfirmationOutcome.ProceedAlways:
+                newModeId = 'auto-edit';
+                break;
+            case ToolConfirmationOutcome.ProceedOnce:
+            default:
+                newModeId = 'default';
+                break;
+        }
+        const update = {
+            sessionUpdate: 'current_mode_update',
+            modeId: newModeId,
+        };
+        await this.sendUpdate(update);
+    }
+    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,
+                status: 'error',
+                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.`));
+        }
+        // Detect TodoWriteTool early - route to plan updates instead of tool_call events
+        const isTodoWriteTool = tool.name === TodoWriteTool.Name;
+        const isTaskTool = tool.name === TaskTool.Name;
+        const isExitPlanModeTool = tool.name === ExitPlanModeTool.Name;
+        // Track cleanup functions for sub-agent event listeners
+        let subAgentCleanupFunctions = [];
+        try {
+            const invocation = tool.build(args);
+            if (isTaskTool && 'eventEmitter' in invocation) {
+                // Access eventEmitter from TaskTool invocation
+                const taskEventEmitter = invocation.eventEmitter;
+                // Create a SubAgentTracker for this tool execution
+                const subAgentTracker = new SubAgentTracker(this, this.client);
+                // Set up sub-agent tool tracking
+                subAgentCleanupFunctions = subAgentTracker.setup(taskEventEmitter, abortSignal);
+            }
+            const confirmationDetails = this.config.getApprovalMode() !== ApprovalMode.YOLO
+                ? await invocation.shouldConfirmExecute(abortSignal)
+                : false;
+            if (confirmationDetails) {
+                const content = [];
+                if (confirmationDetails.type === 'edit') {
+                    content.push({
+                        type: 'diff',
+                        path: confirmationDetails.fileName,
+                        oldText: confirmationDetails.originalContent,
+                        newText: confirmationDetails.newContent,
+                    });
+                }
+                // Add plan content for exit_plan_mode
+                if (confirmationDetails.type === 'plan') {
+                    content.push({
+                        type: 'content',
+                        content: {
+                            type: 'text',
+                            text: confirmationDetails.plan,
+                        },
+                    });
+                }
+                // Map tool kind, using switch_mode for exit_plan_mode per ACP spec
+                const mappedKind = this.toolCallEmitter.mapToolKind(tool.kind, fc.name);
+                const params = {
+                    sessionId: this.sessionId,
+                    options: toPermissionOptions(confirmationDetails),
+                    toolCall: {
+                        toolCallId: callId,
+                        status: 'pending',
+                        title: invocation.getDescription(),
+                        content,
+                        locations: invocation.toolLocations(),
+                        kind: mappedKind,
+                    },
+                };
+                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);
+                // After exit_plan_mode confirmation, send current_mode_update notification
+                if (isExitPlanModeTool && outcome !== ToolConfirmationOutcome.Cancel) {
+                    await this.sendCurrentModeUpdateNotification(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 if (!isTodoWriteTool) {
+                // Skip tool_call event for TodoWriteTool - use ToolCallEmitter
+                const startParams = {
+                    callId,
+                    toolName: fc.name,
+                    args,
+                    status: 'in_progress',
+                };
+                await this.toolCallEmitter.emitStart(startParams);
+            }
+            const toolResult = await invocation.execute(abortSignal);
+            // Clean up event listeners
+            subAgentCleanupFunctions.forEach((cleanup) => cleanup());
+            // Create response parts first (needed for emitResult and recordToolResult)
+            const responseParts = convertToFunctionResponse(fc.name, callId, toolResult.llmContent);
+            // Handle TodoWriteTool: extract todos and send plan update
+            if (isTodoWriteTool) {
+                const todos = this.planEmitter.extractTodos(toolResult.returnDisplay, args);
+                // Match original logic: emit plan if todos.length > 0 OR if args had todos
+                if ((todos && todos.length > 0) || Array.isArray(args['todos'])) {
+                    await this.planEmitter.emitPlan(todos ?? []);
+                }
+                // Skip tool_call_update event for TodoWriteTool
+                // Still log and return function response for LLM
+            }
+            else {
+                // Normal tool handling: emit result using ToolCallEmitter
+                // Convert toolResult.error to Error type if present
+                const error = toolResult.error
+                    ? new Error(toolResult.error.message)
+                    : undefined;
+                await this.toolCallEmitter.emitResult({
+                    callId,
+                    toolName: fc.name,
+                    args,
+                    message: responseParts,
+                    resultDisplay: toolResult.returnDisplay,
+                    error,
+                    success: !toolResult.error,
+                });
+            }
+            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,
+                status: 'success',
+                success: true,
+                prompt_id: promptId,
+                tool_type: typeof tool !== 'undefined' && tool instanceof DiscoveredMCPTool
+                    ? 'mcp'
+                    : 'native',
+            });
+            // Record tool result for session management
+            this.config.getChatRecordingService()?.recordToolResult(responseParts, {
+                callId,
+                status: 'success',
+                resultDisplay: toolResult.returnDisplay,
+                error: undefined,
+                errorType: undefined,
+            });
+            return responseParts;
+        }
+        catch (e) {
+            // Ensure cleanup on error
+            subAgentCleanupFunctions.forEach((cleanup) => cleanup());
+            const error = e instanceof Error ? e : new Error(String(e));
+            // Use ToolCallEmitter for error handling
+            await this.toolCallEmitter.emitError(callId, error);
+            // Record tool error for session management
+            const errorParts = [
+                {
+                    functionResponse: {
+                        id: callId,
+                        name: fc.name ?? '',
+                        response: { error: error.message },
+                    },
+                },
+            ];
+            this.config.getChatRecordingService()?.recordToolResult(errorParts, {
+                callId,
+                status: 'error',
+                resultDisplay: undefined,
+                error,
+                errorType: undefined,
+            });
+            return errorResponse(error);
+        }
+    }
+    /**
+     * Processes the result of a slash command execution.
+     *
+     * Supported result types in ACP mode:
+     * - submit_prompt: Submits content to the model
+     * - stream_messages: Streams multiple messages to the client (ACP-specific)
+     * - unsupported: Command cannot be executed in ACP mode
+     * - no_command: No command was found, use original prompt
+     *
+     * Note: 'message' type is not supported in ACP mode - commands should use
+     * 'stream_messages' instead for consistent async handling.
+     *
+     * @param result The result from handleSlashCommand
+     * @param originalPrompt The original prompt blocks
+     * @returns Parts to use for the prompt, or null if command was handled without needing model interaction
+     */
+    async #processSlashCommandResult(result, originalPrompt) {
+        switch (result.type) {
+            case 'submit_prompt':
+                // Command wants to submit a prompt to the model
+                // Convert PartListUnion to Part[]
+                return normalizePartList(result.content);
+            case 'message': {
+                // 'message' type is not ideal for ACP mode, but we handle it for compatibility
+                // by converting it to a stream_messages-like notification
+                await this.client.sendCustomNotification('_qwencode/slash_command', {
+                    sessionId: this.sessionId,
+                    command: originalPrompt
+                        .filter((block) => block.type === 'text')
+                        .map((block) => (block.type === 'text' ? block.text : ''))
+                        .join(' '),
+                    messageType: result.messageType,
+                    message: result.content || '',
+                });
+                if (result.messageType === 'error') {
+                    // Throw error to stop execution
+                    throw new Error(result.content || 'Slash command failed.');
+                }
+                // For info messages, return null to indicate command was handled
+                return null;
+            }
+            case 'stream_messages': {
+                // Command returns multiple messages via async generator (ACP-preferred)
+                const command = originalPrompt
+                    .filter((block) => block.type === 'text')
+                    .map((block) => (block.type === 'text' ? block.text : ''))
+                    .join(' ');
+                // Stream all messages to the client
+                for await (const msg of result.messages) {
+                    await this.client.sendCustomNotification('_qwencode/slash_command', {
+                        sessionId: this.sessionId,
+                        command,
+                        messageType: msg.messageType,
+                        message: msg.content,
+                    });
+                    // If we encounter an error message, throw after sending
+                    if (msg.messageType === 'error') {
+                        throw new Error(msg.content || 'Slash command failed.');
+                    }
+                }
+                // All messages sent successfully, return null to indicate command was handled
+                return null;
+            }
+            case 'unsupported': {
+                // Command returned an unsupported result type
+                const unsupportedError = `Slash command not supported in ACP integration: ${result.reason}`;
+                throw new Error(unsupportedError);
+            }
+            case 'no_command':
+                // No command was found or executed, use original prompt
+                return originalPrompt.map((block) => {
+                    if (block.type === 'text') {
+                        return { text: block.text };
+                    }
+                    throw new Error(`Unsupported block type: ${block.type}`);
+                });
+            default: {
+                // Exhaustiveness check
+                const _exhaustive = result;
+                const unknownError = `Unknown slash command result type: ${_exhaustive.type}`;
+                throw new Error(unknownError);
+            }
+        }
+    }
+    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 += ' ';
+                    }
+                }
+                // Append the resolved path spec for display purposes
+                if (resolvedSpec) {
+                    initialQueryText += `@${resolvedSpec}`;
+                }
+            }
+        }
+        // Handle ignored paths message
+        let ignoredPathsMessage = '';
+        if (ignoredPaths.length > 0) {
+            const pathList = ignoredPaths.map((p) => `- ${p}`).join('\n');
+            ignoredPathsMessage = `Note: The following paths were skipped because they are ignored:\n${pathList}\n\n`;
+        }
+        const processedQueryParts = [];
+        // Read files using read_many_files tool
+        if (pathSpecsToRead.length > 0) {
+            const readResult = await readManyFilesTool.buildAndExecute({
+                paths_with_line_ranges: pathSpecsToRead,
+            }, abortSignal);
+            const contentForLlm = typeof readResult.llmContent === 'string'
+                ? readResult.llmContent
+                : JSON.stringify(readResult.llmContent);
+            // Combine content label, ignored paths message, file content, and user query
+            const combinedText = `${ignoredPathsMessage}${contentForLlm}`.trim();
+            processedQueryParts.push({ text: combinedText });
+            processedQueryParts.push({ text: initialQueryText });
+        }
+        else if (embeddedContext.length > 0) {
+            // No @path files to read, but we have embedded context
+            processedQueryParts.push({
+                text: `${ignoredPathsMessage}${initialQueryText}`.trim(),
+            });
+        }
+        else {
+            // No @path files found or resolved
+            processedQueryParts.push({
+                text: `${ignoredPathsMessage}${initialQueryText}`.trim(),
+            });
+        }
+        // Process embedded context from resource blocks
+        for (const contextPart of embeddedContext) {
+            // Type guard for text resources
+            if ('text' in contextPart && contextPart.text) {
+                processedQueryParts.push({
+                    text: `File: ${contextPart.uri}\n${contextPart.text}`,
+                });
+            }
+            // Type guard for blob resources
+            if ('blob' in contextPart && contextPart.blob) {
+                processedQueryParts.push({
+                    inlineData: {
+                        mimeType: contextPart.mimeType ?? 'application/octet-stream',
+                        data: contextPart.blob,
+                    },
+                });
+            }
+        }
+        return processedQueryParts;
+    }
+    debug(msg) {
+        if (this.config.getDebugMode()) {
+            console.warn(msg);
+        }
+    }
+}
+// ============================================================================
+// Helper functions
+// ============================================================================
+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,
+            ];
+        case 'plan':
+            return [
+                {
+                    optionId: ToolConfirmationOutcome.ProceedAlways,
+                    name: `Yes, and auto-accept edits`,
+                    kind: 'allow_always',
+                },
+                {
+                    optionId: ToolConfirmationOutcome.ProceedOnce,
+                    name: `Yes, and manually approve edits`,
+                    kind: 'allow_once',
+                },
+                {
+                    optionId: ToolConfirmationOutcome.Cancel,
+                    name: `No, keep planning (esc)`,
+                    kind: 'reject_once',
+                },
+            ];
+        default: {
+            const unreachable = confirmation;
+            throw new Error(`Unexpected: ${unreachable}`);
+        }
+    }
+}
+//# sourceMappingURL=Session.js.map