@aws/lsp-codewhisperer 0.0.32 → 0.0.34

package/out/language-server/agenticChat/agenticChatController.js

@@ -5,8 +5,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgenticChatController = void 0;
+const path = require("path");
 const codewhisperer_streaming_1 = require("@amzn/codewhisperer-streaming");
 const protocol_1 = require("@aws/language-server-runtimes/protocol");
+const protocol_2 = require("@aws/language-server-runtimes/protocol");
 const server_interface_1 = require("@aws/language-server-runtimes/server-interface");
 const uuid_1 = require("uuid");
 const types_1 = require("../../shared/telemetry/types");
@@ -16,10 +18,31 @@ const chatTelemetryController_1 = require("../chat/telemetry/chatTelemetryContro
 const quickActions_1 = require("../chat/quickActions");
 const metric_1 = require("../../shared/telemetry/metric");
 const utils_2 = require("../../shared/utils");
-const triggerContext_1 = require("../chat/contexts/triggerContext");
 const constants_1 = require("../chat/constants");
 const errors_1 = require("../../shared/amazonQServiceManager/errors");
 const AmazonQTokenServiceManager_1 = require("../../shared/amazonQServiceManager/AmazonQTokenServiceManager");
+const tabBarController_1 = require("./tabBarController");
+const chatDb_1 = require("./tools/chatDb/chatDb");
+const agenticChatEventParser_1 = require("./agenticChatEventParser");
+const agenticChatResultStream_1 = require("./agenticChatResultStream");
+const textFormatting_1 = require("./textFormatting");
+const agenticChatTriggerContext_1 = require("./context/agenticChatTriggerContext");
+const addtionalContextProvider_1 = require("./context/addtionalContextProvider");
+const contextUtils_1 = require("./context/contextUtils");
+const contextCommandsProvider_1 = require("./context/contextCommandsProvider");
+const localProjectContextController_1 = require("../../shared/localProjectContextController");
+const lsp_core_1 = require("@aws/lsp-core");
+const fsRead_1 = require("./tools/fsRead");
+const listDirectory_1 = require("./tools/listDirectory");
+const fsWrite_1 = require("./tools/fsWrite");
+const executeBash_1 = require("./tools/executeBash");
+const toolShared_1 = require("./tools/toolShared");
+const fileSearch_1 = require("./tools/fileSearch");
+const lsp_core_2 = require("@aws/lsp-core");
+const diff_1 = require("diff");
+const constants_2 = require("./constants");
+const vscode_uri_1 = require("vscode-uri");
+const errors_2 = require("./errors");
 class AgenticChatController {
     #features;
     #chatSessionManagementService;
@@ -27,20 +50,202 @@ class AgenticChatController {
     #triggerContext;
     #customizationArn;
     #telemetryService;
-    #amazonQServiceManager;
-    constructor(chatSessionManagementService, features, telemetryService, amazonQServiceManager) {
+    #serviceManager;
+    #tabBarController;
+    #chatHistoryDb;
+    #additionalContextProvider;
+    #contextCommandsProvider;
+    #stoppedToolUses = new Set();
+    /**
+     * Determines the appropriate message ID for a tool use based on tool type and name
+     * @param toolType The type of tool being used
+     * @param toolUse The tool use object
+     * @returns The message ID to use
+     */
+    #getMessageIdForToolUse(toolType, toolUse) {
+        const toolUseId = toolUse.toolUseId;
+        // Return plain toolUseId for executeBash, add "_permission" suffix for all other tools
+        return toolUse.name === 'executeBash' || toolType === 'executeBash' ? toolUseId : `${toolUseId}_permission`;
+    }
+    constructor(chatSessionManagementService, features, telemetryService, serviceManager) {
         this.#features = features;
         this.#chatSessionManagementService = chatSessionManagementService;
-        this.#triggerContext = new triggerContext_1.QChatTriggerContext(features.workspace, features.logging);
+        this.#triggerContext = new agenticChatTriggerContext_1.AgenticChatTriggerContext(features);
         this.#telemetryController = new chatTelemetryController_1.ChatTelemetryController(features, telemetryService);
         this.#telemetryService = telemetryService;
-        this.#amazonQServiceManager = amazonQServiceManager;
+        this.#serviceManager = serviceManager;
+        this.#chatHistoryDb = new chatDb_1.ChatDatabase(features);
+        this.#tabBarController = new tabBarController_1.TabBarController(features, this.#chatHistoryDb);
+        this.#additionalContextProvider = new addtionalContextProvider_1.AdditionalContextProvider(features.workspace, features.lsp);
+        this.#contextCommandsProvider = new contextCommandsProvider_1.ContextCommandsProvider(this.#features.logging, this.#features.chat, this.#features.workspace, this.#features.lsp);
+    }
+    async onButtonClick(params) {
+        this.#log(`onButtonClick event with params: ${JSON.stringify(params)}`);
+        const session = this.#chatSessionManagementService.getSession(params.tabId);
+        if (params.buttonId === 'run-shell-command' ||
+            params.buttonId === 'reject-shell-command' ||
+            params.buttonId === 'allow-tools') {
+            if (!session.data) {
+                return { success: false, failureReason: `could not find chat session for tab: ${params.tabId} ` };
+            }
+            // For 'allow-tools', remove suffix as permission card needs to be seperate from file list card
+            const messageId = params.buttonId === 'allow-tools' && params.messageId.endsWith('_permission')
+                ? params.messageId.replace('_permission', '')
+                : params.messageId;
+            const handler = session.data.getDeferredToolExecution(messageId);
+            if (!handler?.reject || !handler.resolve) {
+                return {
+                    success: false,
+                    failureReason: `could not find deferred tool execution for message: ${messageId} `,
+                };
+            }
+            params.buttonId === 'reject-shell-command'
+                ? (() => {
+                    handler.reject(new toolShared_1.ToolApprovalException('Command was rejected.', true));
+                    this.#stoppedToolUses.add(messageId);
+                })()
+                : handler.resolve();
+            return {
+                success: true,
+            };
+        }
+        else if (params.buttonId === 'undo-changes') {
+            const toolUseId = params.messageId;
+            try {
+                await this.#undoFileChange(toolUseId, session.data);
+                this.#updateUndoButtonAfterClick(params.tabId, toolUseId, session.data);
+                this.#telemetryController.emitInteractWithAgenticChat('RejectDiff', params.tabId);
+            }
+            catch (err) {
+                return { success: false, failureReason: err.message };
+            }
+            return {
+                success: true,
+            };
+        }
+        else if (params.buttonId === 'undo-all-changes') {
+            const toolUseId = params.messageId.replace('_undoall', '');
+            await this.#undoAllFileChanges(params.tabId, toolUseId, session.data);
+            return {
+                success: true,
+            };
+        }
+        else if (params.buttonId === 'stop-shell-command') {
+            this.#stoppedToolUses.add(params.messageId);
+            await this.#renderStoppedShellCommand(params.tabId, params.messageId);
+            return { success: true };
+        }
+        else {
+            return {
+                success: false,
+                failureReason: 'not implemented',
+            };
+        }
+    }
+    async #undoFileChange(toolUseId, session) {
+        this.#log(`Reverting file change for tooluseId: ${toolUseId}`);
+        const toolUse = session?.toolUseLookup.get(toolUseId);
+        const input = toolUse?.input;
+        if (toolUse?.fileChange?.before) {
+            await this.#features.workspace.fs.writeFile(input.path, toolUse.fileChange.before);
+        }
+        else {
+            await this.#features.workspace.fs.rm(input.path);
+        }
+    }
+    #updateUndoButtonAfterClick(tabId, toolUseId, session) {
+        const cachedToolUse = session?.toolUseLookup.get(toolUseId);
+        if (!cachedToolUse) {
+            return;
+        }
+        const fileList = cachedToolUse.chatResult?.header?.fileList;
+        const button = cachedToolUse.chatResult?.header?.buttons?.filter(button => button.id !== 'undo-changes');
+        const updatedHeader = {
+            ...cachedToolUse.chatResult?.header,
+            buttons: button,
+            status: {
+                status: 'error',
+                icon: 'cancel',
+                text: 'Change discarded',
+            },
+            muted: true,
+        };
+        if (fileList && fileList.filePaths && fileList.details) {
+            const updatedFileList = {
+                ...fileList,
+                muted: true,
+            };
+            const updatedDetails = { ...fileList.details };
+            for (const filePath of fileList.filePaths) {
+                if (updatedDetails[filePath]) {
+                    ;
+                    updatedDetails[filePath] = {
+                        ...updatedDetails[filePath],
+                        clickable: false,
+                    };
+                }
+            }
+            updatedFileList.details = updatedDetails;
+            updatedHeader.fileList = updatedFileList;
+        }
+        this.#features.chat.sendChatUpdate({
+            tabId,
+            data: {
+                messages: [
+                    {
+                        ...cachedToolUse.chatResult,
+                        header: updatedHeader,
+                    },
+                ],
+            },
+        });
+    }
+    async #undoAllFileChanges(tabId, toolUseId, session) {
+        this.#log(`Reverting all file changes starting from ${toolUseId}`);
+        const toUndo = session?.toolUseLookup.get(toolUseId)?.relatedToolUses;
+        if (!toUndo) {
+            return;
+        }
+        for (const messageId of [...toUndo].reverse()) {
+            await this.onButtonClick({ buttonId: 'undo-changes', messageId, tabId });
+        }
+    }
+    async onCreatePrompt(params) {
+        const newFilePath = (0, contextUtils_1.getNewPromptFilePath)(params.promptName);
+        const newFileContent = '';
+        try {
+            await this.#features.workspace.fs.mkdir((0, contextUtils_1.getUserPromptsDirectory)(), { recursive: true });
+            await this.#features.workspace.fs.writeFile(newFilePath, newFileContent, { mode: 0o600 });
+            await this.#features.lsp.window.showDocument({ uri: vscode_uri_1.URI.file(newFilePath).toString() });
+        }
+        catch (e) {
+            this.#features.logging.warn(`Error creating prompt file: ${e}`);
+        }
     }
     dispose() {
         this.#chatSessionManagementService.dispose();
         this.#telemetryController.dispose();
+        this.#chatHistoryDb.close();
+        this.#contextCommandsProvider?.dispose();
+    }
+    async onListConversations(params) {
+        return this.#tabBarController.onListConversations(params);
+    }
+    async onConversationClick(params) {
+        return this.#tabBarController.onConversationClick(params);
+    }
+    async #sendProgressToClient(chunk, partialResultToken) {
+        if (!(0, utils_2.isNullish)(partialResultToken)) {
+            await this.#features.lsp.sendProgress(protocol_1.chatRequestType, partialResultToken, chunk);
+        }
+    }
+    #getChatResultStream(partialResultToken) {
+        return new agenticChatResultStream_1.AgenticChatResultStream(async (result) => {
+            return this.#sendProgressToClient(result, partialResultToken);
+        });
     }
     async onChatPrompt(params, token) {
+        // Phase 1: Initial Setup - This happens only once
         const maybeDefaultResponse = (0, utils_1.getDefaultChatResponse)(params.prompt.prompt);
         if (maybeDefaultResponse) {
             return maybeDefaultResponse;
@@ -48,92 +253,978 @@ class AgenticChatController {
         const sessionResult = this.#chatSessionManagementService.getSession(params.tabId);
         const { data: session, success } = sessionResult;
         if (!success) {
-            return new server_interface_1.ResponseError(protocol_1.ErrorCodes.InternalError, sessionResult.error);
+            return new server_interface_1.ResponseError(protocol_2.ErrorCodes.InternalError, sessionResult.error);
         }
+        session.rejectAllDeferredToolExecutions(new toolShared_1.ToolApprovalException('Command ignored: new prompt', false));
+        await this.#invalidateAllShellCommands(params.tabId, session);
         const metric = new metric_1.Metric({
-            cwsprChatConversationType: 'Chat',
+            cwsprChatConversationType: 'AgenticChat',
         });
-        const triggerContext = await this.#getTriggerContext(params, metric);
-        const isNewConversation = !session.conversationId;
-        token.onCancellationRequested(() => {
-            this.#log('cancellation requested');
-            session.abortRequest();
-        });
-        let response;
-        let requestInput;
-        const conversationIdentifier = session?.conversationId ?? 'New conversation';
         try {
-            this.#log('Request for conversation id:', conversationIdentifier);
-            const profileArn = AmazonQTokenServiceManager_1.AmazonQTokenServiceManager.getInstance(this.#features).getActiveProfileArn();
-            requestInput = this.#triggerContext.getChatParamsFromTrigger(params, triggerContext, codewhisperer_streaming_1.ChatTriggerType.MANUAL, this.#customizationArn, profileArn);
-            metric.recordStart();
-            response = await session.sendMessage(requestInput);
-            this.#log('Response for conversation id:', conversationIdentifier, JSON.stringify(response.$metadata));
+            const triggerContext = await this.#getTriggerContext(params, metric);
+            const isNewConversation = !session.conversationId;
+            session.contextListSent = false;
+            if (isNewConversation) {
+                // agentic chat does not support conversationId in API response,
+                // so we set it to random UUID per session, as other chat functionality
+                // depends on it
+                session.conversationId = (0, uuid_1.v4)();
+            }
+            token.onCancellationRequested(async () => {
+                this.#log('cancellation requested');
+                await this.#getChatResultStream(params.partialResultToken).writeResultBlock({
+                    type: 'directive',
+                    messageId: 'stopped' + (0, uuid_1.v4)(),
+                    body: 'You stopped your current work, please provide additional examples or ask another question.',
+                });
+                this.#telemetryController.emitInteractWithAgenticChat('StopChat', params.tabId);
+                session.abortRequest();
+                void this.#invalidateAllShellCommands(params.tabId, session);
+                session.rejectAllDeferredToolExecutions(new lsp_core_1.CancellationError('user'));
+            });
+            const chatResultStream = this.#getChatResultStream(params.partialResultToken);
+            const additionalContext = await this.#additionalContextProvider.getAdditionalContext(triggerContext, params.prompt.context);
+            if (additionalContext.length) {
+                triggerContext.documentReference =
+                    this.#additionalContextProvider.getFileListFromContext(additionalContext);
+            }
+            // Get the initial request input
+            const initialRequestInput = await this.#prepareRequestInput(params, session, triggerContext, additionalContext, chatResultStream);
+            // Start the agent loop
+            const finalResult = await this.#runAgentLoop(initialRequestInput, session, metric, chatResultStream, params.tabId, session.conversationId, token, triggerContext.documentReference);
+            // Phase 5: Result Handling - This happens only once
+            return await this.#handleFinalResult(finalResult, session, params, metric, triggerContext, isNewConversation, chatResultStream);
         }
         catch (err) {
-            if ((0, utils_2.isAwsError)(err) || ((0, utils_2.isObject)(err) && 'statusCode' in err && typeof err.statusCode === 'number')) {
-                metric.setDimension('cwsprChatRepsonseCode', err.statusCode ?? 400);
-                this.#telemetryController.emitMessageResponseError(params.tabId, metric.metric);
-            }
-            if (err instanceof errors_1.AmazonQServicePendingSigninError) {
-                this.#log(`Q Chat SSO Connection error: ${(0, utils_2.getErrorMessage)(err)}`);
-                return (0, utils_1.createAuthFollowUpResult)('full-auth');
-            }
-            if (err instanceof errors_1.AmazonQServicePendingProfileError) {
-                this.#log(`Q Chat SSO Connection error: ${(0, utils_2.getErrorMessage)(err)}`);
-                const followUpResult = (0, utils_1.createAuthFollowUpResult)('use-supported-auth');
-                // Access first element in array
-                if (followUpResult.followUp?.options) {
-                    followUpResult.followUp.options[0].pillText = 'Select Q Developer Profile';
-                }
-                return followUpResult;
-            }
-            const authFollowType = (0, utils_1.getAuthFollowUpType)(err);
-            if (authFollowType) {
-                this.#log(`Q auth error: ${(0, utils_2.getErrorMessage)(err)}`);
-                return (0, utils_1.createAuthFollowUpResult)(authFollowType);
+            // HACK: the chat-client needs to have a partial event with the associated messageId sent before it can accept the final result.
+            // Without this, the `thinking` indicator never goes away.
+            // Note: buttons being explicitly empty is required for this hack to work.
+            const errorMessageId = `error-message-id-${(0, uuid_1.v4)()}`;
+            await this.#sendProgressToClient({
+                type: 'answer',
+                body: '',
+                messageId: errorMessageId,
+                buttons: [],
+            }, params.partialResultToken);
+            if (this.isUserAction(err, token)) {
+                /**
+                 * when the session is aborted it generates an error.
+                 * we need to resolve this error with an answer so the
+                 * stream stops
+                 */
+                return {
+                    type: 'answer',
+                    body: '',
+                    messageId: errorMessageId,
+                    buttons: [],
+                };
             }
-            this.#log(`Q api request error ${err instanceof Error ? err.message : 'unknown'}`);
-            return new server_interface_1.ResponseError(server_interface_1.LSPErrorCodes.RequestFailed, err instanceof Error ? err.message : 'Unknown request error');
+            return this.#handleRequestError(err, errorMessageId, params.tabId, metric);
         }
-        try {
-            const result = await this.#processSendMessageResponse(response, metric.mergeWith({
+    }
+    /**
+     * Prepares the initial request input for the chat prompt
+     */
+    async #prepareRequestInput(params, session, triggerContext, additionalContext, chatResultStream) {
+        this.#debug('Preparing request input');
+        const profileArn = AmazonQTokenServiceManager_1.AmazonQTokenServiceManager.getInstance().getActiveProfileArn();
+        const requestInput = await this.#triggerContext.getChatParamsFromTrigger(params, triggerContext, codewhisperer_streaming_1.ChatTriggerType.MANUAL, this.#customizationArn, chatResultStream, profileArn, [], this.#getTools(session), additionalContext);
+        return requestInput;
+    }
+    /**
+     * Runs the agent loop, making requests and processing tool uses until completion
+     */
+    async #runAgentLoop(initialRequestInput, session, metric, chatResultStream, tabId, conversationIdentifier, token, documentReference) {
+        let currentRequestInput = { ...initialRequestInput };
+        let finalResult = null;
+        let iterationCount = 0;
+        metric.recordStart();
+        while (iterationCount < constants_2.maxAgentLoopIterations) {
+            iterationCount++;
+            this.#debug(`Agent loop iteration ${iterationCount} for conversation id:`, conversationIdentifier || '');
+            // Check for cancellation
+            if (token?.isCancellationRequested) {
+                throw new lsp_core_1.CancellationError('user');
+            }
+            const currentMessage = currentRequestInput.conversationState?.currentMessage;
+            const conversationId = conversationIdentifier ?? '';
+            if (!currentMessage || !conversationId) {
+                this.#debug(`Warning: ${!currentMessage ? 'currentMessage' : ''}${!currentMessage && !conversationId ? ' and ' : ''}${!conversationId ? 'conversationIdentifier' : ''} is empty in agent loop iteration ${iterationCount}.`);
+            }
+            //  Fix the history to maintain invariants
+            if (currentMessage) {
+                this.#chatHistoryDb.fixHistory(tabId, currentMessage, conversationIdentifier ?? '');
+            }
+            //  Retrieve the history from DB; Do not include chatHistory for requests going to Mynah Backend
+            currentRequestInput.conversationState.history = currentRequestInput.conversationState?.currentMessage
+                ?.userInputMessage?.userIntent
+                ? []
+                : this.#chatHistoryDb.getMessages(tabId);
+            // Add loading message before making the request
+            const loadingMessageId = `loading-${(0, uuid_1.v4)()}`;
+            await chatResultStream.writeResultBlock({ ...constants_1.loadingMessage, messageId: loadingMessageId });
+            // Phase 3: Request Execution
+            this.#validateRequest(currentRequestInput);
+            const response = await session.generateAssistantResponse(currentRequestInput);
+            this.#features.logging.info(`generateAssistantResponse ResponseMetadata: ${lsp_core_2.loggingUtils.formatObj(response.$metadata)}`);
+            await chatResultStream.removeResultBlock(loadingMessageId);
+            //  Add the current user message to the history DB
+            if (currentMessage && conversationIdentifier) {
+                this.#chatHistoryDb.addMessage(tabId, 'cwc', conversationIdentifier, {
+                    body: currentMessage.userInputMessage?.content ?? '',
+                    type: 'prompt',
+                    userIntent: currentMessage.userInputMessage?.userIntent,
+                    origin: currentMessage.userInputMessage?.origin,
+                    userInputMessageContext: currentMessage.userInputMessage?.userInputMessageContext,
+                });
+            }
+            // Phase 4: Response Processing
+            const result = await this.#processGenerateAssistantResponseResponse(response, metric.mergeWith({
                 cwsprChatResponseCode: response.$metadata.httpStatusCode,
                 cwsprChatMessageId: response.$metadata.requestId,
-            }), params.partialResultToken);
-            session.conversationId = result.data?.conversationId;
-            this.#log('Session conversation id:', session.conversationId || '');
-            if (session.conversationId) {
-                this.#telemetryController.setConversationId(params.tabId, session.conversationId);
-                if (isNewConversation) {
-                    this.#telemetryController.updateTriggerInfo(params.tabId, {
-                        startTrigger: {
-                            hasUserSnippet: metric.metric.cwsprChatHasCodeSnippet ?? false,
-                            triggerType: triggerContext.triggerType,
-                        },
+            }), chatResultStream, session, documentReference);
+            //  Add the current assistantResponse message to the history DB
+            if (result.data?.chatResult.body !== undefined) {
+                this.#chatHistoryDb.addMessage(tabId, 'cwc', conversationIdentifier ?? '', {
+                    body: result.data?.chatResult.body,
+                    type: 'answer',
+                    codeReference: result.data.chatResult.codeReference,
+                    relatedContent: result.data.chatResult.relatedContent?.content &&
+                        result.data.chatResult.relatedContent.content.length > 0
+                        ? result.data?.chatResult.relatedContent
+                        : undefined,
+                    toolUses: Object.keys(result.data?.toolUses)
+                        .filter(k => result.data.toolUses[k].stop)
+                        .map(k => ({
+                        toolUseId: result.data.toolUses[k].toolUseId,
+                        name: result.data.toolUses[k].name,
+                        input: result.data.toolUses[k].input,
+                    })),
+                });
+            }
+            else {
+                this.#features.logging.warn('No ChatResult body in response, skipping adding to history');
+            }
+            // Check if we have any tool uses that need to be processed
+            const pendingToolUses = this.#getPendingToolUses(result.data?.toolUses || {});
+            if (pendingToolUses.length === 0) {
+                // No more tool uses, we're done
+                finalResult = result;
+                break;
+            }
+            let content = '';
+            let toolResults;
+            if (result.success) {
+                // Process tool uses and update the request input for the next iteration
+                toolResults = await this.#processToolUses(pendingToolUses, chatResultStream, session, tabId, token);
+                if (toolResults.some(toolResult => toolResult.status === codewhisperer_streaming_1.ToolResultStatus.ERROR)) {
+                    content = 'There was an error processing one or more tool uses. Please try again.';
+                }
+                metric.setDimension('cwsprChatConversationType', 'AgenticChatWithToolUse');
+            }
+            else {
+                // Send an error card to UI?
+                toolResults = pendingToolUses.map(toolUse => ({
+                    toolUseId: toolUse.toolUseId,
+                    status: codewhisperer_streaming_1.ToolResultStatus.ERROR,
+                    content: [{ text: result.error }],
+                }));
+                if (result.error.startsWith('ToolUse input is invalid JSON:')) {
+                    content =
+                        'Your toolUse input is incomplete because it is too large. Break this task down into multiple tool uses with smaller input.';
+                }
+            }
+            currentRequestInput = this.#updateRequestInputWithToolResults(currentRequestInput, toolResults, content);
+        }
+        if (iterationCount >= constants_2.maxAgentLoopIterations) {
+            throw new errors_2.AgenticChatError('Agent loop reached iteration limit', 'MaxAgentLoopIterations');
+        }
+        return (finalResult || {
+            success: false,
+            error: 'Agent loop failed to produce a final result',
+            data: { chatResult: {}, toolUses: {} },
+        });
+    }
+    /**
+     * performs pre-validation of request before sending to backend service.
+     * @param request
+     */
+    #validateRequest(request) {
+        // Note: these logs are very noisy, but contain information redacted on the backend.
+        this.#debug(`generateAssistantResponse Request: ${JSON.stringify(request, undefined, 2)}`);
+        const message = request.conversationState?.currentMessage?.userInputMessage?.content;
+        if (message && message.length > constants_2.generateAssistantResponseInputLimit) {
+            throw new errors_2.AgenticChatError(`Message is too long with ${message.length} characters, max is ${constants_2.generateAssistantResponseInputLimit}`, 'PromptCharacterLimit');
+        }
+    }
+    /**
+     * Extracts tool uses that need to be processed
+     */
+    #getPendingToolUses(toolUses) {
+        return Object.values(toolUses).filter(toolUse => toolUse.stop);
+    }
+    /**
+     * Creates a promise that does not resolve until the user accepts or rejects the tool usage.
+     * @param toolUseId
+     * @param toolUseName
+     * @param resultStream
+     * @param promptBlockId id of approval block. This allows us to overwrite the buttons with 'accepted' or 'rejected' text.
+     * @param session
+     */
+    async waitForToolApproval(toolUse, resultStream, promptBlockId, session) {
+        const deferred = this.#createDeferred();
+        session.setDeferredToolExecution(toolUse.toolUseId, deferred.resolve, deferred.reject);
+        this.#log(`Prompting for tool approval for tool: ${toolUse.name}`);
+        await deferred.promise;
+        // Note: we want to overwrite the button block because it already exists in the stream.
+        await resultStream.overwriteResultBlock(this.#getUpdateToolConfirmResult(toolUse, true), promptBlockId);
+    }
+    /**
+     * Processes tool uses by running the tools and collecting results
+     */
+    async #processToolUses(toolUses, chatResultStream, session, tabId, token) {
+        const results = [];
+        for (const toolUse of toolUses) {
+            // Store buttonBlockId to use it in `catch` block if needed
+            let cachedButtonBlockId;
+            if (!toolUse.name || !toolUse.toolUseId)
+                continue;
+            session.toolUseLookup.set(toolUse.toolUseId, toolUse);
+            try {
+                // TODO: Can we move this check in the event parser before the stream completes?
+                const availableToolNames = this.#getTools(session).map(tool => tool.toolSpecification.name);
+                if (!availableToolNames.includes(toolUse.name)) {
+                    throw new Error(`Tool ${toolUse.name} is not available in the current mode`);
+                }
+                // fsRead and listDirectory write to an existing card and could show nothing in the current position
+                if (!['fsWrite', 'fsRead', 'listDirectory'].includes(toolUse.name)) {
+                    await this.#showUndoAllIfRequired(chatResultStream, session);
+                }
+                const { explanation } = toolUse.input;
+                if (explanation) {
+                    await chatResultStream.writeResultBlock({
+                        type: 'directive',
+                        messageId: toolUse.toolUseId + '_explanation',
+                        body: explanation,
+                    });
+                }
+                switch (toolUse.name) {
+                    case 'fsRead':
+                    case 'listDirectory':
+                    case 'fileSearch':
+                    case 'fsWrite':
+                    case 'executeBash': {
+                        const toolMap = {
+                            fsRead: { Tool: fsRead_1.FsRead },
+                            listDirectory: { Tool: listDirectory_1.ListDirectory },
+                            fsWrite: { Tool: fsWrite_1.FsWrite },
+                            executeBash: { Tool: executeBash_1.ExecuteBash },
+                            fileSearch: { Tool: fileSearch_1.FileSearch },
+                        };
+                        const { Tool } = toolMap[toolUse.name];
+                        const tool = new Tool(this.#features);
+                        // Get the approved paths from the session
+                        const approvedPaths = session.approvedPaths;
+                        // Pass the approved paths to the tool's requiresAcceptance method
+                        const { requiresAcceptance, warning } = await tool.requiresAcceptance(toolUse.input, approvedPaths);
+                        if (requiresAcceptance || toolUse.name === 'executeBash') {
+                            // for executeBash, we till send the confirmation message without action buttons
+                            const confirmationResult = this.#processToolConfirmation(toolUse, requiresAcceptance, warning);
+                            cachedButtonBlockId = await chatResultStream.writeResultBlock(confirmationResult);
+                            const isExecuteBash = toolUse.name === 'executeBash';
+                            if (isExecuteBash) {
+                                this.#telemetryController.emitInteractWithAgenticChat('GeneratedCommand', tabId);
+                            }
+                            if (requiresAcceptance) {
+                                await this.waitForToolApproval(toolUse, chatResultStream, cachedButtonBlockId, session);
+                            }
+                            if (isExecuteBash) {
+                                this.#telemetryController.emitInteractWithAgenticChat('RunCommand', tabId);
+                            }
+                        }
+                        break;
+                    }
+                    case 'codeSearch':
+                        // no need to write tool message for code search.
+                        break;
+                    default:
+                        this.#features.logging.warn(`Recieved unrecognized tool: ${toolUse.name}`);
+                        await chatResultStream.writeResultBlock({
+                            type: 'tool',
+                            body: `${(0, textFormatting_1.executeToolMessage)(toolUse)}`,
+                            messageId: toolUse.toolUseId,
+                        });
+                        break;
+                }
+                if (toolUse.name === 'fsWrite') {
+                    const input = toolUse.input;
+                    const document = await this.#triggerContext.getTextDocument(input.path);
+                    session.toolUseLookup.set(toolUse.toolUseId, {
+                        ...toolUse,
+                        fileChange: { before: document?.getText() },
+                    });
+                }
+                // After approval, add the path to the approved paths in the session
+                const inputPath = toolUse.input?.path || toolUse.input?.cwd;
+                if (inputPath) {
+                    session.addApprovedPath(inputPath);
+                }
+                const ws = this.#getWritableStream(chatResultStream, toolUse);
+                const result = await this.#features.agent.runTool(toolUse.name, toolUse.input, token, ws);
+                let toolResultContent;
+                if (typeof result === 'string') {
+                    toolResultContent = { text: result };
+                }
+                else if (Array.isArray(result)) {
+                    toolResultContent = { json: { items: result } };
+                }
+                else if (typeof result === 'object') {
+                    toolResultContent = { json: result };
+                }
+                else
+                    toolResultContent = { text: JSON.stringify(result) };
+                this.#validateToolResult(toolUse, toolResultContent);
+                results.push({
+                    toolUseId: toolUse.toolUseId,
+                    status: 'success',
+                    content: [toolResultContent],
+                });
+                switch (toolUse.name) {
+                    case 'fsRead':
+                    case 'listDirectory':
+                    case 'fileSearch':
+                        const initialListDirResult = this.#processReadOrListOrSearch(toolUse, chatResultStream);
+                        if (initialListDirResult) {
+                            await chatResultStream.writeResultBlock(initialListDirResult);
+                        }
+                        break;
+                    // no need to write tool result for listDir,fsRead,fileSearch into chat stream
+                    case 'executeBash':
+                        // no need to write tool result for listDir and fsRead into chat stream
+                        // executeBash will stream the output instead of waiting until the end
+                        break;
+                    case 'codeSearch':
+                        // no need to write tool result for code search.
+                        break;
+                    case 'fsWrite':
+                        const input = toolUse.input;
+                        const doc = await this.#triggerContext.getTextDocument(input.path);
+                        const chatResult = await this.#getFsWriteChatResult(toolUse, doc, session);
+                        const cachedToolUse = session.toolUseLookup.get(toolUse.toolUseId);
+                        if (cachedToolUse) {
+                            session.toolUseLookup.set(toolUse.toolUseId, {
+                                ...cachedToolUse,
+                                chatResult,
+                                fileChange: { ...cachedToolUse.fileChange, after: doc?.getText() },
+                            });
+                        }
+                        this.#telemetryController.emitInteractWithAgenticChat('GeneratedDiff', tabId);
+                        await chatResultStream.writeResultBlock(chatResult);
+                        break;
+                    default:
+                        this.#features.logging.warn(`Processing unrecognized tool: ${toolUse.name}`);
+                        await chatResultStream.writeResultBlock({
+                            type: 'tool',
+                            body: (0, textFormatting_1.toolResultMessage)(toolUse, result),
+                            messageId: toolUse.toolUseId,
+                        });
+                        break;
+                }
+                this.#updateUndoAllState(toolUse, session);
+                if (toolUse.name) {
+                    this.#telemetryController.emitToolUseSuggested(toolUse, session.conversationId ?? '', this.#features.runtime.serverInfo.version ?? '');
+                }
+            }
+            catch (err) {
+                if (this.isUserAction(err, token)) {
+                    if (toolUse.name === 'executeBash') {
+                        if (err instanceof toolShared_1.ToolApprovalException) {
+                            if (cachedButtonBlockId) {
+                                await chatResultStream.overwriteResultBlock(this.#getUpdateToolConfirmResult(toolUse, false), cachedButtonBlockId);
+                                if (err.shouldShowMessage) {
+                                    await chatResultStream.writeResultBlock({
+                                        type: 'answer',
+                                        messageId: `reject-message-${toolUse.toolUseId}`,
+                                        body: err.message || 'Command was rejected.',
+                                    });
+                                }
+                            }
+                            else {
+                                this.#features.logging.warn('Failed to update tool block: no blockId is available.');
+                            }
+                        }
+                        throw err;
+                    }
+                    if (err instanceof lsp_core_1.CancellationError) {
+                        results.push({
+                            toolUseId: toolUse.toolUseId,
+                            status: codewhisperer_streaming_1.ToolResultStatus.ERROR,
+                            content: [{ text: 'Command stopped by user' }],
+                        });
+                        continue;
+                    }
+                }
+                const errMsg = err instanceof Error ? err.message : 'unknown error';
+                this.#log(`Error running tool ${toolUse.name}:`, errMsg);
+                results.push({
+                    toolUseId: toolUse.toolUseId,
+                    status: 'error',
+                    content: [{ json: { error: err instanceof Error ? err.message : 'Unknown error' } }],
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Updates the currentUndoAllId state in the session
+     */
+    #updateUndoAllState(toolUse, session) {
+        if (toolUse.name === 'fsRead' || toolUse.name === 'listDirectory') {
+            return;
+        }
+        if (toolUse.name === 'fsWrite') {
+            if (session.currentUndoAllId === undefined) {
+                session.currentUndoAllId = toolUse.toolUseId;
+            }
+            if (session.currentUndoAllId) {
+                const prev = session.toolUseLookup.get(session.currentUndoAllId);
+                if (prev && toolUse.toolUseId) {
+                    const relatedToolUses = prev.relatedToolUses || new Set();
+                    relatedToolUses.add(toolUse.toolUseId);
+                    session.toolUseLookup.set(session.currentUndoAllId, {
+                        ...prev,
+                        relatedToolUses,
                     });
-                    this.#telemetryController.emitStartConversationMetric(params.tabId, metric.metric);
                 }
             }
-            metric.setDimension('codewhispererCustomizationArn', requestInput.conversationState?.customizationArn);
-            await this.#telemetryController.emitAddMessageMetric(params.tabId, metric.metric);
-            this.#telemetryController.updateTriggerInfo(params.tabId, {
-                lastMessageTrigger: {
-                    ...triggerContext,
-                    messageId: response.$metadata.requestId,
-                    followUpActions: new Set(result.data?.chatResult.followUp?.options
-                        ?.map(option => option.prompt ?? '')
-                        .filter(prompt => prompt.length > 0)),
+        }
+        else {
+            session.currentUndoAllId = undefined;
+        }
+    }
+    /**
+     * Shows an "Undo all changes" button if there are multiple related file changes
+     * that can be undone together.
+     */
+    async #showUndoAllIfRequired(chatResultStream, session) {
+        if (session.currentUndoAllId === undefined) {
+            return;
+        }
+        const toUndo = session.toolUseLookup.get(session.currentUndoAllId)?.relatedToolUses;
+        if (!toUndo || toUndo.size <= 1) {
+            return;
+        }
+        await chatResultStream.writeResultBlock({
+            type: 'answer',
+            messageId: `${session.currentUndoAllId}_undoall`,
+            buttons: [
+                {
+                    id: 'undo-all-changes',
+                    text: 'Undo all changes',
+                    icon: 'undo',
+                    status: 'clear',
+                    keepCardAfterClick: false,
                 },
+            ],
+        });
+        session.currentUndoAllId = undefined;
+    }
+    /**
+     * Determines if error is thrown as a result of a user action (Ex. rejecting tool, stop button)
+     * @param err
+     * @returns
+     */
+    isUserAction(err, token) {
+        return (lsp_core_1.CancellationError.isUserCancelled(err) ||
+            err instanceof toolShared_1.ToolApprovalException ||
+            (token?.isCancellationRequested ?? false));
+    }
+    #validateToolResult(toolUse, result) {
+        let maxToolResponseSize;
+        switch (toolUse.name) {
+            case 'fsRead':
+            case 'executeBash':
+                // fsRead and executeBash already have truncation logic
+                return;
+            case 'listDirectory':
+                maxToolResponseSize = 30_000;
+                break;
+            default:
+                maxToolResponseSize = 100_000;
+                break;
+        }
+        if ((result.text && result.text.length > maxToolResponseSize) ||
+            (result.json && JSON.stringify(result.json).length > maxToolResponseSize)) {
+            throw Error(`${toolUse.name} output exceeds maximum character limit of ${maxToolResponseSize}`);
+        }
+    }
+    #getWritableStream(chatResultStream, toolUse) {
+        if (toolUse.name !== 'executeBash') {
+            return;
+        }
+        const toolMsgId = toolUse.toolUseId;
+        const chatMsgId = chatResultStream.getResult().messageId;
+        let headerEmitted = false;
+        const initialHeader = {
+            body: 'shell',
+            buttons: [{ id: 'stop-shell-command', text: 'Stop', icon: 'stop' }],
+        };
+        const completedHeader = {
+            body: 'shell',
+            status: { status: 'success', icon: 'ok', text: 'Completed' },
+            buttons: [],
+        };
+        return new WritableStream({
+            write: async (chunk) => {
+                if (this.#stoppedToolUses.has(toolMsgId))
+                    return;
+                await chatResultStream.writeResultBlock({
+                    type: 'tool',
+                    messageId: toolMsgId,
+                    body: chunk,
+                    header: headerEmitted ? undefined : initialHeader,
+                });
+                headerEmitted = true;
+            },
+            close: async () => {
+                if (this.#stoppedToolUses.has(toolMsgId))
+                    return;
+                await chatResultStream.writeResultBlock({
+                    type: 'tool',
+                    messageId: toolMsgId,
+                    body: '```',
+                    header: completedHeader,
+                });
+                await chatResultStream.writeResultBlock({
+                    type: 'answer',
+                    messageId: chatMsgId,
+                    body: '',
+                    header: undefined,
+                });
+                this.#stoppedToolUses.add(toolMsgId);
+            },
+        });
+    }
+    /**
+     * Creates an updated ChatResult for tool confirmation based on tool type
+     * @param toolUse The tool use object
+     * @param isAccept Whether the tool was accepted or rejected
+     * @param toolType Optional tool type for specialized handling
+     * @returns ChatResult with appropriate confirmation UI
+     */
+    #getUpdateToolConfirmResult(toolUse, isAccept, toolType) {
+        const toolName = toolType || toolUse.name;
+        // Handle bash commands with special formatting
+        if (toolName === 'executeBash') {
+            return {
+                messageId: toolUse.toolUseId,
+                type: 'tool',
+                body: '```shell\n' + toolUse.input.command + '\n',
+                header: {
+                    body: 'shell',
+                    ...(isAccept
+                        ? {}
+                        : {
+                            status: {
+                                status: 'error',
+                                icon: 'cancel',
+                                text: 'Rejected',
+                            },
+                        }),
+                    buttons: isAccept ? [{ id: 'stop-shell-command', text: 'Stop', icon: 'stop' }] : [],
+                },
+            };
+        }
+        // For file operations and other tools, create appropriate confirmation UI
+        let header;
+        let body;
+        switch (toolName) {
+            case 'fsWrite':
+                const writeFilePath = toolUse.input.path;
+                header = {
+                    body: 'File Write',
+                    status: {
+                        status: isAccept ? 'success' : 'error',
+                        icon: isAccept ? 'ok' : 'cancel',
+                        text: isAccept ? 'Allowed' : 'Rejected',
+                    },
+                };
+                body = isAccept
+                    ? `File modification allowed: \`${writeFilePath}\``
+                    : `File modification rejected: \`${writeFilePath}\``;
+                break;
+            case 'fsRead':
+            case 'listDirectory':
+                // Common handling for read operations
+                const path = toolUse.input.path;
+                const isDirectory = toolName === 'listDirectory';
+                header = {
+                    body: isDirectory ? 'Directory Listing' : 'File Read',
+                    status: {
+                        status: isAccept ? 'success' : 'error',
+                        icon: isAccept ? 'ok' : 'cancel',
+                        text: isAccept ? 'Allowed' : 'Rejected',
+                    },
+                };
+                body = isAccept
+                    ? `${isDirectory ? 'Directory listing' : 'File read'} allowed: \`${path}\``
+                    : `${isDirectory ? 'Directory listing' : 'File read'} rejected: \`${path}\``;
+                break;
+            case 'fileSearch':
+                const searchPath = toolUse.input.path;
+                header = {
+                    body: 'File Search',
+                    status: {
+                        status: isAccept ? 'success' : 'error',
+                        icon: isAccept ? 'ok' : 'cancel',
+                        text: isAccept ? 'Allowed' : 'Rejected',
+                    },
+                };
+                body = isAccept ? `File search allowed: \`${searchPath}\`` : `File search rejected: \`${searchPath}\``;
+                break;
+            default:
+                // Generic handler for other tool types
+                header = {
+                    body: toolUse.name || 'Tool',
+                    status: {
+                        status: isAccept ? 'success' : 'error',
+                        icon: isAccept ? 'ok' : 'cancel',
+                        text: isAccept ? 'Allowed' : 'Rejected',
+                    },
+                };
+                body = isAccept ? `Tool execution allowed: ${toolUse.name}` : `Tool execution rejected: ${toolUse.name}`;
+                break;
+        }
+        return {
+            messageId: this.#getMessageIdForToolUse(toolType, toolUse),
+            type: 'tool',
+            body,
+            header,
+        };
+    }
+    async #renderStoppedShellCommand(tabId, messageId) {
+        const session = this.#chatSessionManagementService.getSession(tabId).data;
+        const toolUse = session?.toolUseLookup.get(messageId);
+        const command = toolUse.input.command;
+        await this.#features.chat.sendChatUpdate({
+            tabId,
+            state: { inProgress: false },
+            data: {
+                messages: [
+                    {
+                        messageId,
+                        type: 'tool',
+                        body: `\`\`\`shell\n${command}\n\`\`\``,
+                        header: {
+                            body: 'shell',
+                            status: {
+                                status: 'error',
+                                icon: 'stop',
+                                text: 'Stopped',
+                            },
+                            buttons: [],
+                        },
+                    },
+                ],
+            },
+        });
+    }
+    #processToolConfirmation(toolUse, requiresAcceptance, warning, toolType) {
+        let buttons = [];
+        let header;
+        let body;
+        switch (toolType || toolUse.name) {
+            case 'executeBash':
+                buttons = requiresAcceptance
+                    ? [
+                        {
+                            id: 'run-shell-command',
+                            text: 'Run',
+                            icon: 'play',
+                        },
+                        {
+                            id: 'reject-shell-command',
+                            status: 'dimmed-clear',
+                            text: 'Reject',
+                            icon: 'cancel',
+                        },
+                    ]
+                    : [];
+                header = {
+                    status: requiresAcceptance
+                        ? {
+                            icon: 'warning',
+                            status: 'warning',
+                            position: 'left',
+                            // TODO: Add `description` if necessary to show a tooltip
+                        }
+                        : {},
+                    body: 'shell',
+                    buttons,
+                };
+                const commandString = toolUse.input.command;
+                body = '```shell\n' + commandString;
+                break;
+            case 'fsWrite':
+                buttons = [
+                    {
+                        id: 'allow-tools', // Reusing the same ID for simplicity, could be changed to 'allow-write-tools'
+                        text: 'Allow',
+                        icon: 'ok',
+                        status: 'clear',
+                    },
+                ];
+                header = {
+                    icon: 'warning',
+                    iconForegroundStatus: 'warning',
+                    body: '#### Allow file modification outside of your workspace',
+                    buttons,
+                };
+                const writeFilePath = toolUse.input.path;
+                body = `I need permission to modify files in your workspace.\n\`${writeFilePath}\``;
+                break;
+            case 'fsRead':
+            case 'listDirectory':
+            default:
+                buttons = [
+                    {
+                        id: 'allow-tools',
+                        text: 'Allow',
+                        icon: 'ok',
+                        status: 'clear',
+                    },
+                ];
+                header = {
+                    icon: 'warning',
+                    iconForegroundStatus: 'warning',
+                    body: '#### Allow read-only tools outside your workspace',
+                    buttons,
+                };
+                // ⚠️ Warning: This accesses files outside the workspace
+                const readFilePath = toolUse.input.path;
+                body = `I need permission to read files and list directories outside the workspace.\n\`${readFilePath}\``;
+                break;
+        }
+        return {
+            type: 'tool',
+            messageId: this.#getMessageIdForToolUse(toolType, toolUse),
+            header,
+            body: warning ? warning + (toolType === 'executeBash' ? '' : '\n\n') + body : body,
+        };
+    }
+    async #getFsWriteChatResult(toolUse, doc, session) {
+        const input = toolUse.input;
+        const oldContent = session.toolUseLookup.get(toolUse.toolUseId)?.fileChange?.before ?? '';
+        // Get just the filename instead of the full path
+        const fileName = path.basename(input.path);
+        const diffChanges = (0, diff_1.diffLines)(oldContent, doc?.getText() ?? '');
+        const changes = diffChanges.reduce((acc, { count = 0, added, removed }) => {
+            if (added) {
+                acc.added += count;
+            }
+            else if (removed) {
+                acc.deleted += count;
+            }
+            return acc;
+        }, { added: 0, deleted: 0 });
+        return {
+            type: 'tool',
+            messageId: toolUse.toolUseId,
+            header: {
+                fileList: {
+                    filePaths: [fileName],
+                    details: {
+                        [fileName]: {
+                            changes,
+                            description: input.path,
+                        },
+                    },
+                },
+                buttons: [{ id: 'undo-changes', text: 'Undo', icon: 'undo' }],
+            },
+        };
+    }
+    #processReadOrListOrSearch(toolUse, chatResultStream) {
+        let messageIdToUpdate = toolUse.toolUseId;
+        const currentId = chatResultStream.getMessageIdToUpdateForTool(toolUse.name);
+        if (currentId) {
+            messageIdToUpdate = currentId;
+        }
+        else {
+            chatResultStream.setMessageIdToUpdateForTool(toolUse.name, messageIdToUpdate);
+        }
+        const currentPath = toolUse.input?.path;
+        if (!currentPath)
+            return;
+        const existingPaths = chatResultStream.getMessageOperation(messageIdToUpdate)?.filePaths || [];
+        // Check if path already exists in the list
+        const isPathAlreadyProcessed = existingPaths.some(path => path.relativeFilePath === currentPath);
+        if (!isPathAlreadyProcessed) {
+            const currentFileDetail = {
+                relativeFilePath: currentPath,
+                lineRanges: [{ first: -1, second: -1 }],
+            };
+            chatResultStream.addMessageOperation(messageIdToUpdate, toolUse.name, [
+                ...existingPaths,
+                currentFileDetail,
+            ]);
+        }
+        let title;
+        const itemCount = chatResultStream.getMessageOperation(messageIdToUpdate)?.filePaths.length;
+        const filePathsPushed = chatResultStream.getMessageOperation(messageIdToUpdate)?.filePaths ?? [];
+        if (!itemCount) {
+            title = 'Gathering context';
+        }
+        else {
+            title =
+                toolUse.name === 'fsRead'
+                    ? `${itemCount} file${itemCount > 1 ? 's' : ''} read`
+                    : toolUse.name === 'fileSearch'
+                        ? `${itemCount} ${itemCount === 1 ? 'directory' : 'directories'} searched`
+                        : `${itemCount} ${itemCount === 1 ? 'directory' : 'directories'} listed`;
+        }
+        const details = {};
+        for (const item of filePathsPushed) {
+            details[item.relativeFilePath] = {
+                lineRanges: item.lineRanges,
+                description: item.relativeFilePath,
+            };
+        }
+        const fileList = {
+            rootFolderTitle: title,
+            filePaths: filePathsPushed.map(item => item.relativeFilePath),
+            details,
+        };
+        return {
+            type: 'tool',
+            fileList,
+            messageId: messageIdToUpdate,
+            body: '',
+        };
+    }
+    /**
+     * Updates the request input with tool results for the next iteration
+     */
+    #updateRequestInputWithToolResults(requestInput, toolResults, content) {
+        // Create a deep copy of the request input
+        const updatedRequestInput = JSON.parse(JSON.stringify(requestInput));
+        // Add tool results to the request
+        updatedRequestInput.conversationState.currentMessage.userInputMessage.userInputMessageContext.toolResults =
+            [];
+        updatedRequestInput.conversationState.currentMessage.userInputMessage.content = content;
+        for (const toolResult of toolResults) {
+            this.#debug(`ToolResult: ${JSON.stringify(toolResult)}`);
+            updatedRequestInput.conversationState.currentMessage.userInputMessage.userInputMessageContext.toolResults.push({
+                ...toolResult,
             });
-            return result.success
-                ? result.data.chatResult
-                : new server_interface_1.ResponseError(server_interface_1.LSPErrorCodes.RequestFailed, result.error);
         }
-        catch (err) {
-            this.#log('Error encountered during response streaming:', err instanceof Error ? err.message : 'unknown');
-            return new server_interface_1.ResponseError(server_interface_1.LSPErrorCodes.RequestFailed, err instanceof Error ? err.message : 'Unknown error occured during response stream');
+        return updatedRequestInput;
+    }
+    /**
+     * Handles the final result after the agent loop completes
+     */
+    async #handleFinalResult(result, session, params, metric, triggerContext, isNewConversation, chatResultStream) {
+        if (!result.success) {
+            throw new errors_2.AgenticChatError(result.error, 'FailedResult');
+        }
+        const conversationId = session.conversationId;
+        this.#debug('Final session conversation id:', conversationId || '');
+        if (conversationId) {
+            this.#telemetryController.setConversationId(params.tabId, conversationId);
+            if (isNewConversation) {
+                this.#telemetryController.updateTriggerInfo(params.tabId, {
+                    startTrigger: {
+                        hasUserSnippet: metric.metric.cwsprChatHasCodeSnippet ?? false,
+                        triggerType: triggerContext.triggerType,
+                    },
+                });
+                this.#telemetryController.emitStartConversationMetric(params.tabId, metric.metric);
+            }
         }
+        metric.setDimension('codewhispererCustomizationArn', this.#customizationArn);
+        metric.setDimension('languageServerVersion', this.#features.runtime.serverInfo.version);
+        const profileArn = AmazonQTokenServiceManager_1.AmazonQTokenServiceManager.getInstance().getActiveProfileArn();
+        if (profileArn) {
+            this.#telemetryService.updateProfileArn(profileArn);
+        }
+        if (triggerContext.contextInfo) {
+            metric.mergeWith({
+                cwsprChatHasContextList: triggerContext.documentReference?.filePaths?.length ? true : false,
+                cwsprChatFolderContextCount: triggerContext.contextInfo.contextCount.folderContextCount,
+                cwsprChatFileContextCount: triggerContext.contextInfo.contextCount.fileContextCount,
+                cwsprChatRuleContextCount: triggerContext.contextInfo.contextCount.ruleContextCount,
+                cwsprChatPromptContextCount: triggerContext.contextInfo.contextCount.promptContextCount,
+                cwsprChatFileContextLength: triggerContext.contextInfo.contextLength.fileContextLength,
+                cwsprChatRuleContextLength: triggerContext.contextInfo.contextLength.ruleContextLength,
+                cwsprChatPromptContextLength: triggerContext.contextInfo.contextLength.promptContextLength,
+                cwsprChatCodeContextCount: triggerContext.contextInfo.contextCount.codeContextCount,
+                cwsprChatCodeContextLength: triggerContext.contextInfo.contextLength.codeContextLength,
+                cwsprChatFocusFileContextLength: triggerContext.text?.length,
+            });
+        }
+        await this.#telemetryController.emitAddMessageMetric(params.tabId, metric.metric);
+        this.#telemetryController.updateTriggerInfo(params.tabId, {
+            lastMessageTrigger: {
+                ...triggerContext,
+                messageId: result.data?.chatResult.messageId,
+                followUpActions: new Set(result.data?.chatResult.followUp?.options
+                    ?.map(option => option.prompt ?? '')
+                    .filter(prompt => prompt.length > 0)),
+            },
+        });
+        return chatResultStream.getResult();
+    }
+    /**
+     * Handles errors that occur during the request
+     */
+    #handleRequestError(err, errorMessageId, tabId, metric) {
+        let errorMessage;
+        let requestID;
+        if ((0, utils_2.isAwsError)(err) || ((0, utils_2.isObject)(err) && typeof (0, utils_2.getHttpStatusCode)(err) === 'number')) {
+            if (err instanceof codewhisperer_streaming_1.CodeWhispererStreamingServiceException) {
+                errorMessage = err.message;
+                requestID = err.$metadata.requestId;
+            }
+            else if (err?.cause?.message) {
+                errorMessage = err?.cause?.message;
+                requestID = err.cause?.$metadata.requestId;
+            }
+            else if (err instanceof Error || err?.message) {
+                errorMessage = err.message;
+            }
+            metric.setDimension('cwsprChatResponseCode', (0, utils_2.getHttpStatusCode)(err) ?? 0);
+            metric.setDimension('languageServerVersion', this.#features.runtime.serverInfo.version);
+            this.#telemetryController.emitMessageResponseError(tabId, metric.metric, requestID, errorMessage);
+        }
+        let authFollowType = undefined;
+        // first check if there is an AmazonQ related auth follow up
+        if (err.cause instanceof errors_1.AmazonQError) {
+            authFollowType = (0, utils_1.getAuthFollowUpType)(err.cause);
+        }
+        // if not check full error for auth follow up
+        if (!authFollowType) {
+            authFollowType = (0, utils_1.getAuthFollowUpType)(err);
+        }
+        if (authFollowType) {
+            this.#log(`Q auth error: ${(0, utils_2.getErrorMessage)(err)}`);
+            return (0, utils_1.createAuthFollowUpResult)(authFollowType);
+        }
+        if (errors_2.customerFacingErrorCodes.includes(err.code)) {
+            this.#features.logging.error(`${lsp_core_2.loggingUtils.formatErr(err)}`);
+            return new server_interface_1.ResponseError(server_interface_1.LSPErrorCodes.RequestFailed, err.message, {
+                type: 'answer',
+                body: err.message,
+                messageId: errorMessageId,
+                buttons: [],
+            });
+        }
+        this.#features.logging.error(`Unknown Error: ${lsp_core_2.loggingUtils.formatErr(err)}`);
+        return new server_interface_1.ResponseError(server_interface_1.LSPErrorCodes.RequestFailed, err.message, {
+            type: 'answer',
+            body: requestID ? constants_2.genericErrorMsg + `\n\nRequest ID: ${requestID}` : constants_2.genericErrorMsg,
+            messageId: errorMessageId,
+            buttons: [],
+        });
     }
     async onInlineChatPrompt(params, token) {
         // TODO: This metric needs to be removed later, just added for now to be able to create a ChatEventParser object
@@ -144,12 +1235,11 @@ class AgenticChatController {
         let response;
         let requestInput;
         try {
-            const profileArn = AmazonQTokenServiceManager_1.AmazonQTokenServiceManager.getInstance(this.#features).getActiveProfileArn();
-            requestInput = this.#triggerContext.getChatParamsFromTrigger(params, triggerContext, codewhisperer_streaming_1.ChatTriggerType.INLINE_CHAT, this.#customizationArn, profileArn);
-            if (!this.#amazonQServiceManager) {
+            requestInput = await this.#triggerContext.getChatParamsFromTrigger(params, triggerContext, codewhisperer_streaming_1.ChatTriggerType.INLINE_CHAT, this.#customizationArn);
+            if (!this.#serviceManager) {
                 throw new Error('amazonQServiceManager is not initialized');
             }
-            const client = this.#amazonQServiceManager.getStreamingClient();
+            const client = this.#serviceManager.getStreamingClient();
             response = await client.sendMessage(requestInput);
             this.#log('Response for inline chat', JSON.stringify(response.$metadata), JSON.stringify(response));
         }
@@ -158,7 +1248,7 @@ class AgenticChatController {
                 this.#log(`Q Inline Chat SSO Connection error: ${(0, utils_2.getErrorMessage)(err)}`);
                 return new server_interface_1.ResponseError(server_interface_1.LSPErrorCodes.RequestFailed, err.message);
             }
-            this.#log(`Q api request error ${err instanceof Error ? err.message : 'unknown'}`);
+            this.#log(`Q api request error ${err instanceof Error ? JSON.stringify(err) : 'unknown'}`);
             return new server_interface_1.ResponseError(server_interface_1.LSPErrorCodes.RequestFailed, err instanceof Error ? err.message : 'Unknown request error');
         }
         try {
@@ -175,6 +1265,7 @@ class AgenticChatController {
             return new server_interface_1.ResponseError(server_interface_1.LSPErrorCodes.RequestFailed, err instanceof Error ? err.message : 'Unknown error occurred during inline chat response stream');
         }
     }
+    async onInlineChatResult(handler) { }
     async onCodeInsertToCursorPosition(params) {
         // Implementation based on https://github.com/aws/aws-toolkit-vscode/blob/1814cc84228d4bf20270574c5980b91b227f31cf/packages/core/src/amazonq/commons/controllers/contentController.ts#L38
         if (!params.textDocument || !params.cursorPosition || !params.code) {
@@ -230,8 +1321,8 @@ class AgenticChatController {
         const workspaceEdit = {
             edit: {
                 documentChanges: [
-                    protocol_1.TextDocumentEdit.create({ uri: params.textDocument.uri, version: 0 }, [
-                        protocol_1.TextEdit.insert(cursorPosition, textWithIndent),
+                    protocol_2.TextDocumentEdit.create({ uri: params.textDocument.uri, version: 0 }, [
+                        protocol_2.TextEdit.insert(cursorPosition, textWithIndent),
                     ]),
                 ],
             },
@@ -250,10 +1341,44 @@ class AgenticChatController {
         const { success } = this.#chatSessionManagementService.deleteSession(params.tabId);
         return success;
     }
+    async onFileClicked(params) {
+        const session = this.#chatSessionManagementService.getSession(params.tabId);
+        const toolUseId = params.messageId;
+        const toolUse = toolUseId ? session.data?.toolUseLookup.get(toolUseId) : undefined;
+        if (toolUse?.name === 'fsWrite') {
+            const input = toolUse.input;
+            this.#features.lsp.workspace.openFileDiff({
+                originalFileUri: input.path,
+                originalFileContent: toolUse.fileChange?.before,
+                isDeleted: false,
+                fileContent: toolUse.fileChange?.after,
+            });
+        }
+        else if (toolUse?.name === 'fsRead') {
+            await this.#features.lsp.window.showDocument({ uri: vscode_uri_1.URI.file(params.filePath).toString() });
+        }
+        else {
+            const absolutePath = params.fullPath ?? (await this.#resolveAbsolutePath(params.filePath));
+            if (absolutePath) {
+                await this.#features.lsp.window.showDocument({ uri: vscode_uri_1.URI.file(absolutePath).toString() });
+            }
+        }
+    }
     onFollowUpClicked() { }
     onInfoLinkClick() { }
     onLinkClick() { }
-    onReady() { }
+    async onReady() {
+        await this.#tabBarController.loadChats();
+        try {
+            const localProjectContextController = await localProjectContextController_1.LocalProjectContextController.getInstance();
+            const contextItems = await localProjectContextController.getContextCommandItems();
+            await this.#contextCommandsProvider.processContextCommandUpdate(contextItems);
+            void this.#contextCommandsProvider.maybeUpdateCodeSymbols();
+        }
+        catch (error) {
+            this.#log('Error initializing context commands: ' + error);
+        }
+    }
     onSendFeedback({ tabId, feedbackPayload }) {
         this.#features.telemetry.emitMetric({
             name: 'amazonq_sendFeedback',
@@ -294,6 +1419,7 @@ class AgenticChatController {
             });
             this.#telemetryController.activeTabId = undefined;
         }
+        this.#chatHistoryDb.updateTabOpenState(params.tabId, false);
         this.#chatSessionManagementService.deleteSession(params.tabId);
         this.#telemetryController.removeConversation(params.tabId);
     }
@@ -308,6 +1434,7 @@ class AgenticChatController {
                     },
                 });
                 this.#telemetryController.removeConversation(params.tabId);
+                this.#chatHistoryDb.clearTab(params.tabId);
                 sessionResult.data?.clear();
                 return {};
             }
@@ -326,10 +1453,33 @@ class AgenticChatController {
                 return {};
         }
     }
+    async onTabBarAction(params) {
+        return this.#tabBarController.onTabBarAction(params);
+    }
     async #getInlineChatTriggerContext(params) {
         let triggerContext = await this.#triggerContext.getNewTriggerContext(params);
         return triggerContext;
     }
+    async #resolveAbsolutePath(relativePath) {
+        try {
+            const workspaceFolders = lsp_core_1.workspaceUtils.getWorkspaceFolderPaths(this.#features.lsp);
+            for (const workspaceRoot of workspaceFolders) {
+                const candidatePath = path.join(workspaceRoot, relativePath);
+                if (await this.#features.workspace.fs.exists(candidatePath)) {
+                    return candidatePath;
+                }
+            }
+            // handle prompt file outside of workspace
+            if (relativePath.endsWith(contextUtils_1.promptFileExtension)) {
+                return path.join((0, contextUtils_1.getUserPromptsDirectory)(), relativePath);
+            }
+            this.#features.logging.error(`File not found: ${relativePath}`);
+        }
+        catch (e) {
+            this.#features.logging.error(`Error resolving absolute path: ${e.message}`);
+        }
+        return undefined;
+    }
     async #getTriggerContext(params, metric) {
         const lastMessageTrigger = this.#telemetryController.getLastMessageTrigger(params.tabId);
         let triggerContext;
@@ -356,19 +1506,64 @@ class AgenticChatController {
         });
         return triggerContext;
     }
-    async #processSendMessageResponse(response, metric, partialResultToken) {
+    async #invalidateAllShellCommands(tabId, session) {
+        for (const [toolUseId, toolUse] of session.toolUseLookup.entries()) {
+            if (toolUse.name !== 'executeBash' || this.#stoppedToolUses.has(toolUseId))
+                continue;
+            const params = toolUse.input;
+            const command = params.command;
+            await this.#features.chat.sendChatUpdate({
+                tabId,
+                state: { inProgress: false },
+                data: {
+                    messages: [
+                        {
+                            messageId: toolUseId,
+                            type: 'tool',
+                            body: `\`\`\`shell\n${command}\n\`\`\``,
+                            header: {
+                                body: 'shell',
+                                status: { status: 'info', icon: 'info', text: 'Ignored' },
+                                buttons: [],
+                            },
+                        },
+                    ],
+                },
+            });
+            this.#stoppedToolUses.add(toolUseId);
+        }
+    }
+    async #processGenerateAssistantResponseResponse(response, metric, chatResultStream, session, contextList) {
         const requestId = response.$metadata.requestId;
-        const chatEventParser = new chatEventParser_1.ChatEventParser(requestId, metric);
-        for await (const chatEvent of response.sendMessageResponse) {
+        const chatEventParser = new agenticChatEventParser_1.AgenticChatEventParser(requestId, metric, this.#features.logging);
+        const streamWriter = chatResultStream.getResultStreamWriter();
+        // Display context transparency list once at the beginning of response
+        // Use a flag to track if contextList has been sent already to avoid ux flickering
+        if (contextList && !session.contextListSent) {
+            await streamWriter.write({ body: '', contextList });
+            session.contextListSent = true;
+        }
+        const toolUseStartTimes = {};
+        const toolUseLoadingTimeouts = {};
+        for await (const chatEvent of response.generateAssistantResponseResponse) {
+            if (chatEvent.assistantResponseEvent) {
+                await this.#showUndoAllIfRequired(chatResultStream, session);
+            }
             const result = chatEventParser.processPartialEvent(chatEvent);
             // terminate early when there is an error
             if (!result.success) {
+                await streamWriter.close();
                 return result;
             }
-            if (!(0, utils_2.isNullish)(partialResultToken)) {
-                await this.#features.lsp.sendProgress(protocol_1.chatRequestType, partialResultToken, result.data.chatResult);
+            // make sure to save code reference events
+            if (chatEvent.assistantResponseEvent || chatEvent.codeReferenceEvent) {
+                await streamWriter.write(result.data.chatResult);
+            }
+            if (chatEvent.toolUseEvent) {
+                await this.#showLoadingIfRequired(chatEvent.toolUseEvent, streamWriter, toolUseStartTimes, toolUseLoadingTimeouts);
             }
         }
+        await streamWriter.close();
         metric.mergeWith({
             cwsprChatFullResponseLatency: metric.getTimeElapsed(),
             cwsprChatFollowUpCount: chatEventParser.totalEvents.followupPromptEvent,
@@ -378,6 +1573,34 @@ class AgenticChatController {
         });
         return chatEventParser.getResult();
     }
+    /**
+     * This is needed to handle the case where a toolUseEvent takes a long time to resolve the stream and looks like
+     * nothing is happening.
+     */
+    async #showLoadingIfRequired(toolUseEvent, streamWriter, toolUseStartTimes, toolUseLoadingTimeouts) {
+        const toolUseId = toolUseEvent.toolUseId;
+        if (!toolUseEvent.stop && toolUseId) {
+            if (!toolUseStartTimes[toolUseId]) {
+                toolUseStartTimes[toolUseId] = Date.now();
+                this.#debug(`ToolUseEvent ${toolUseId} started`);
+                toolUseLoadingTimeouts[toolUseId] = setTimeout(async () => {
+                    this.#debug(`ToolUseEvent ${toolUseId} is taking longer than ${constants_2.loadingThresholdMs}ms, showing loading indicator`);
+                    await streamWriter.write({ ...constants_1.loadingMessage, messageId: `loading-${toolUseId}` });
+                }, constants_2.loadingThresholdMs);
+            }
+        }
+        else if (toolUseEvent.stop && toolUseId) {
+            if (toolUseStartTimes[toolUseId]) {
+                const duration = Date.now() - toolUseStartTimes[toolUseId];
+                this.#debug(`ToolUseEvent ${toolUseId} finished streaming after ${duration}ms`);
+                if (toolUseLoadingTimeouts[toolUseId]) {
+                    clearTimeout(toolUseLoadingTimeouts[toolUseId]);
+                    delete toolUseLoadingTimeouts[toolUseId];
+                }
+                delete toolUseStartTimes[toolUseId];
+            }
+        }
+    }
     async #processSendMessageResponseForInlineChat(response, metric, partialResultToken) {
         const requestId = response.$metadata.requestId;
         const chatEventParser = new chatEventParser_1.ChatEventParser(requestId, metric);
@@ -387,15 +1610,22 @@ class AgenticChatController {
             if (!result.success) {
                 return result;
             }
-            if (!(0, utils_2.isNullish)(partialResultToken)) {
-                await this.#features.lsp.sendProgress(protocol_1.chatRequestType, partialResultToken, result.data.chatResult);
-            }
+            await this.#sendProgressToClient(result.data.chatResult, partialResultToken);
         }
         return chatEventParser.getResult();
     }
+    onPromptInputOptionChange(params) {
+        const sessionResult = this.#chatSessionManagementService.getSession(params.tabId);
+        const { data: session, success } = sessionResult;
+        if (!success) {
+            this.#log('onPromptInputOptionChange: on valid session found');
+            return;
+        }
+        session.pairProgrammingMode = !session.pairProgrammingMode;
+    }
     updateConfiguration = (newConfig) => {
         this.#customizationArn = newConfig.customizationArn;
-        this.#log(`Chat configuration updated to use ${this.#customizationArn}`);
+        this.#log(`Chat configuration updated customizationArn to ${this.#customizationArn}`);
         /*
             The flag enableTelemetryEventsToDestination is set to true temporarily. It's value will be determined through destination
             configuration post all events migration to STE. It'll be replaced by qConfig['enableTelemetryEventsToDestination'] === true
@@ -406,9 +1636,29 @@ class AgenticChatController {
         this.#telemetryService.updateOptOutPreference(updatedOptOutPreference);
         this.#log(`Chat configuration telemetry preference to ${updatedOptOutPreference}`);
     };
+    #getTools(session) {
+        const tools = this.#features.agent.getTools({ format: 'bedrock' });
+        // it's disabled so filter out the write tools
+        if (!session.pairProgrammingMode) {
+            return tools.filter(tool => !['fsWrite', 'executeBash'].includes(tool.toolSpecification?.name || ''));
+        }
+        return tools;
+    }
+    #createDeferred() {
+        let resolve;
+        let reject;
+        const promise = new Promise((res, rej) => {
+            resolve = res;
+            reject = (e) => rej(e);
+        });
+        return { promise, resolve, reject };
+    }
     #log(...messages) {
         this.#features.logging.log(messages.join(' '));
     }
+    #debug(...messages) {
+        this.#features.logging.debug(messages.join(' '));
+    }
 }
 exports.AgenticChatController = AgenticChatController;
 //# sourceMappingURL=agenticChatController.js.map