@aws/lsp-codewhisperer 0.0.39 → 0.0.41

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

@@ -5,6 +5,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgenticChatController = void 0;
+const crypto = require("crypto");
 const path = require("path");
 const codewhisperer_streaming_1 = require("@amzn/codewhisperer-streaming");
 const protocol_1 = require("@aws/language-server-runtimes/protocol");
@@ -37,7 +38,8 @@ 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 grepSearch_1 = require("./tools/grepSearch");
+const fuzzySearch_1 = require("./tools/fuzzySearch");
 const lsp_core_2 = require("@aws/lsp-core");
 const diff_1 = require("diff");
 const constants_2 = require("./constants");
@@ -59,6 +61,8 @@ class AgenticChatController {
     #contextCommandsProvider;
     #stoppedToolUses = new Set();
     #userWrittenCodeTracker;
+    #toolUseStartTimes = {};
+    #toolUseLatencies = [];
     /**
      * Determines the appropriate message ID for a tool use based on tool type and name
      * @param toolType The type of tool being used
@@ -79,7 +83,7 @@ class AgenticChatController {
         this.#serviceManager = serviceManager;
         this.#chatHistoryDb = new chatDb_1.ChatDatabase(features);
         this.#tabBarController = new tabBarController_1.TabBarController(features, this.#chatHistoryDb, telemetryService);
-        this.#additionalContextProvider = new addtionalContextProvider_1.AdditionalContextProvider(features.workspace, features.lsp);
+        this.#additionalContextProvider = new addtionalContextProvider_1.AdditionalContextProvider(features.workspace);
         this.#contextCommandsProvider = new contextCommandsProvider_1.ContextCommandsProvider(this.#features.logging, this.#features.chat, this.#features.workspace, this.#features.lsp);
     }
     async onButtonClick(params) {
@@ -117,7 +121,7 @@ class AgenticChatController {
             try {
                 await this.#undoFileChange(toolUseId, session.data);
                 this.#updateUndoButtonAfterClick(params.tabId, toolUseId, session.data);
-                this.#telemetryController.emitInteractWithAgenticChat('RejectDiff', params.tabId);
+                this.#telemetryController.emitInteractWithAgenticChat('RejectDiff', params.tabId, session.data?.pairProgrammingMode, session.data?.getConversationType());
             }
             catch (err) {
                 return { success: false, failureReason: err.message };
@@ -277,20 +281,26 @@ class AgenticChatController {
                 // depends on it
                 session.conversationId = (0, uuid_1.v4)();
             }
+            const chatResultStream = this.#getChatResultStream(params.partialResultToken);
             token.onCancellationRequested(async () => {
                 this.#log('cancellation requested');
+                // Abort all operations immediately
+                session.abortRequest();
+                void this.#invalidateAllShellCommands(params.tabId, session);
+                session.rejectAllDeferredToolExecutions(new lsp_core_1.CancellationError('user'));
+                // Then update UI to inform the user
                 await this.#showUndoAllIfRequired(chatResultStream, session);
+                await chatResultStream.updateOngoingProgressResult('Canceled');
                 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'));
+                // Finally, send telemetry/metrics
+                this.#telemetryController.emitInteractWithAgenticChat('StopChat', params.tabId, session.pairProgrammingMode, session.getConversationType());
+                await this.#telemetryController.emitAddMessageMetric(params.tabId, metric.metric, 'Cancelled');
             });
-            const chatResultStream = this.#getChatResultStream(params.partialResultToken);
+            session.setConversationType('AgenticChat');
             const additionalContext = await this.#additionalContextProvider.getAdditionalContext(triggerContext, params.context);
             if (additionalContext.length) {
                 triggerContext.documentReference =
@@ -298,8 +308,11 @@ class AgenticChatController {
             }
             // Get the initial request input
             const initialRequestInput = await this.#prepareRequestInput(params, session, triggerContext, additionalContext, chatResultStream);
+            // Generate a unique ID for this prompt
+            const promptId = crypto.randomUUID();
+            session.setCurrentPromptId(promptId);
             // Start the agent loop
-            const finalResult = await this.#runAgentLoop(initialRequestInput, session, metric, chatResultStream, params.tabId, session.conversationId, token, triggerContext.documentReference);
+            const finalResult = await this.#runAgentLoop(initialRequestInput, session, metric, chatResultStream, params.tabId, promptId, session.conversationId, token, triggerContext.documentReference);
             // Phase 5: Result Handling - This happens only once
             return await this.#handleFinalResult(finalResult, session, params, metric, triggerContext, isNewConversation, chatResultStream);
         }
@@ -327,7 +340,7 @@ class AgenticChatController {
                     buttons: [],
                 };
             }
-            return this.#handleRequestError(err, errorMessageId, params.tabId, metric);
+            return this.#handleRequestError(session.conversationId, err, errorMessageId, params.tabId, metric, session.pairProgrammingMode);
         }
     }
     /**
@@ -342,17 +355,18 @@ class AgenticChatController {
     /**
      * Runs the agent loop, making requests and processing tool uses until completion
      */
-    async #runAgentLoop(initialRequestInput, session, metric, chatResultStream, tabId, conversationIdentifier, token, documentReference) {
+    async #runAgentLoop(initialRequestInput, session, metric, chatResultStream, tabId, promptId, conversationIdentifier, token, documentReference) {
         let currentRequestInput = { ...initialRequestInput };
         let finalResult = null;
         let iterationCount = 0;
         let shouldDisplayMessage = true;
         metric.recordStart();
-        while (iterationCount < constants_2.maxAgentLoopIterations) {
+        while (true) {
             iterationCount++;
             this.#debug(`Agent loop iteration ${iterationCount} for conversation id:`, conversationIdentifier || '');
             // Check for cancellation
-            if (token?.isCancellationRequested) {
+            if (this.#isPromptCanceled(token, session, promptId)) {
+                this.#debug('Stopping agent loop - cancelled by user');
                 throw new lsp_core_1.CancellationError('user');
             }
             const currentMessage = currentRequestInput.conversationState?.currentMessage;
@@ -360,9 +374,10 @@ class AgenticChatController {
             if (!currentMessage || !conversationId) {
                 this.#debug(`Warning: ${!currentMessage ? 'currentMessage' : ''}${!currentMessage && !conversationId ? ' and ' : ''}${!conversationId ? 'conversationIdentifier' : ''} is empty in agent loop iteration ${iterationCount}.`);
             }
+            const remainingCharacterBudget = this.truncateRequest(currentRequestInput);
             //  Fix the history to maintain invariants
             if (currentMessage) {
-                const isHistoryValid = this.#chatHistoryDb.fixHistory(tabId, currentMessage, conversationIdentifier ?? '');
+                const isHistoryValid = this.#chatHistoryDb.fixAndValidateHistory(tabId, currentMessage, conversationIdentifier ?? '', remainingCharacterBudget);
                 if (!isHistoryValid) {
                     this.#features.logging.warn('Skipping request due to invalid tool result/tool use relationship');
                     break;
@@ -377,20 +392,31 @@ class AgenticChatController {
             const loadingMessageId = `loading-${(0, uuid_1.v4)()}`;
             await chatResultStream.writeResultBlock({ ...constants_1.loadingMessage, messageId: loadingMessageId });
             // Phase 3: Request Execution
-            this.#truncateRequest(currentRequestInput);
+            // Note: these logs are very noisy, but contain information redacted on the backend.
+            this.#debug(`generateAssistantResponse Request: ${JSON.stringify(currentRequestInput, undefined, 2)}`);
             const response = await session.generateAssistantResponse(currentRequestInput);
+            if (response.$metadata.requestId) {
+                metric.mergeWith({
+                    requestIds: [response.$metadata.requestId],
+                });
+            }
             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,
-                    shouldDisplayMessage: shouldDisplayMessage,
-                });
+                if (this.#isPromptCanceled(token, session, promptId)) {
+                    this.#debug('Skipping adding user message to history - cancelled by user');
+                }
+                else {
+                    this.#chatHistoryDb.addMessage(tabId, 'cwc', conversationIdentifier, {
+                        body: currentMessage.userInputMessage?.content ?? '',
+                        type: 'prompt',
+                        userIntent: currentMessage.userInputMessage?.userIntent,
+                        origin: currentMessage.userInputMessage?.origin,
+                        userInputMessageContext: currentMessage.userInputMessage?.userInputMessageContext,
+                        shouldDisplayMessage: shouldDisplayMessage,
+                    });
+                }
             }
             shouldDisplayMessage = true;
             // Phase 4: Response Processing
@@ -402,34 +428,43 @@ class AgenticChatController {
             // and we want to auto-retry
             if (!result.success && result.error.startsWith(constants_2.responseTimeoutPartialMsg)) {
                 const content = 'You took too long to respond - try to split up the work into smaller steps. Do not apologize.';
-                this.#chatHistoryDb.addMessage(tabId, 'cwc', conversationIdentifier ?? '', {
-                    body: 'Response timed out - message took too long to generate',
-                    type: 'answer',
-                    shouldDisplayMessage: false,
-                });
+                if (!this.#isPromptCanceled(token, session, promptId)) {
+                    this.#chatHistoryDb.addMessage(tabId, 'cwc', conversationIdentifier ?? '', {
+                        body: 'Response timed out - message took too long to generate',
+                        type: 'answer',
+                        shouldDisplayMessage: false,
+                    });
+                }
                 currentRequestInput = this.#updateRequestInputWithToolResults(currentRequestInput, [], content);
                 shouldDisplayMessage = false;
+                // set the in progress tool use UI status to Error
+                await chatResultStream.updateOngoingProgressResult('Error');
                 continue;
             }
             //  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,
-                    })),
-                    shouldDisplayMessage: shouldDisplayMessage,
-                });
+                if (this.#isPromptCanceled(token, session, promptId)) {
+                    this.#debug('Skipping adding assistant message to history - cancelled by user');
+                }
+                else {
+                    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,
+                        })),
+                        shouldDisplayMessage: shouldDisplayMessage,
+                    });
+                }
             }
             else {
                 this.#features.logging.warn('No ChatResult body in response, skipping adding to history');
@@ -438,11 +473,13 @@ class AgenticChatController {
             const pendingToolUses = this.#getPendingToolUses(result.data?.toolUses || {});
             if (pendingToolUses.length === 0) {
                 // No more tool uses, we're done
+                this.#telemetryController.emitAgencticLoop_InvokeLLM(response.$metadata.requestId, conversationId, 'AgenticChat', undefined, undefined, 'Succeeded', this.#features.runtime.serverInfo.version ?? '', undefined, session.pairProgrammingMode);
                 finalResult = result;
                 break;
             }
             let content = '';
             let toolResults;
+            session.setConversationType('AgenticChatWithToolUse');
             if (result.success) {
                 // Process tool uses and update the request input for the next iteration
                 toolResults = await this.#processToolUses(pendingToolUses, chatResultStream, session, tabId, token);
@@ -450,7 +487,13 @@ class AgenticChatController {
                     content = 'There was an error processing one or more tool uses. Try again, do not apologize.';
                     shouldDisplayMessage = false;
                 }
-                metric.setDimension('cwsprChatConversationType', 'AgenticChatWithToolUse');
+                const conversationType = session.getConversationType();
+                metric.setDimension('cwsprChatConversationType', conversationType);
+                metric.setDimension('requestIds', metric.metric.requestIds);
+                const toolNames = this.#toolUseLatencies.map(item => item.toolName);
+                const toolUseIds = this.#toolUseLatencies.map(item => item.toolUseId);
+                const latency = this.#toolUseLatencies.map(item => item.latency);
+                this.#telemetryController.emitAgencticLoop_InvokeLLM(response.$metadata.requestId, conversationId, 'AgenticChatWithToolUse', toolNames ?? undefined, toolUseIds ?? undefined, 'Succeeded', this.#features.runtime.serverInfo.version ?? '', latency, session.pairProgrammingMode);
             }
             else {
                 // Send an error card to UI?
@@ -459,17 +502,21 @@ class AgenticChatController {
                     status: codewhisperer_streaming_1.ToolResultStatus.ERROR,
                     content: [{ text: result.error }],
                 }));
+                this.#telemetryController.emitAgencticLoop_InvokeLLM(response.$metadata.requestId, conversationId, 'AgenticChatWithToolUse', undefined, undefined, 'Failed', this.#features.runtime.serverInfo.version ?? '', undefined, session.pairProgrammingMode);
                 if (result.error.startsWith('ToolUse input is invalid JSON:')) {
                     content =
                         'Your toolUse input is incomplete, try again. If the error happens consistently, break this task down into multiple tool uses with smaller input. Do not apologize.';
                     shouldDisplayMessage = false;
                 }
+                // set the in progress tool use UI status to Error
+                await chatResultStream.updateOngoingProgressResult('Error');
+            }
+            if (result.success && this.#toolUseLatencies.length > 0) {
+                // Clear latencies for the next LLM call
+                this.#toolUseLatencies = [];
             }
             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',
@@ -478,19 +525,58 @@ class AgenticChatController {
     }
     /**
      * performs truncation of request before sending to backend service.
+     * Returns the remaining character budget for chat history.
      * @param request
      */
-    #truncateRequest(request) {
-        // Note: these logs are very noisy, but contain information redacted on the backend.
-        this.#debug(`generateAssistantResponse Request: ${JSON.stringify(request, undefined, 2)}`);
+    truncateRequest(request) {
+        let remainingCharacterBudget = constants_2.generateAssistantResponseInputLimit;
         if (!request?.conversationState?.currentMessage?.userInputMessage) {
-            return;
+            return remainingCharacterBudget;
         }
         const message = request.conversationState?.currentMessage?.userInputMessage?.content;
-        if (message && message.length > constants_2.generateAssistantResponseInputLimit) {
-            this.#debug(`Truncating userInputMessage to ${constants_2.generateAssistantResponseInputLimit} characters}`);
-            request.conversationState.currentMessage.userInputMessage.content = message.substring(0, constants_2.generateAssistantResponseInputLimit);
+        // 1. prioritize user input message
+        let truncatedUserInputMessage = '';
+        if (message) {
+            if (message.length > constants_2.generateAssistantResponseInputLimit) {
+                this.#debug(`Truncating userInputMessage to ${constants_2.generateAssistantResponseInputLimit} characters}`);
+                truncatedUserInputMessage = message.substring(0, constants_2.generateAssistantResponseInputLimit);
+                remainingCharacterBudget = remainingCharacterBudget - truncatedUserInputMessage.length;
+                request.conversationState.currentMessage.userInputMessage.content = truncatedUserInputMessage;
+            }
+            else {
+                remainingCharacterBudget = remainingCharacterBudget - message.length;
+            }
+        }
+        // 2. try to fit @context into budget
+        let truncatedRelevantDocuments = [];
+        if (request.conversationState.currentMessage.userInputMessage.userInputMessageContext?.editorState
+            ?.relevantDocuments) {
+            for (const relevantDoc of request.conversationState.currentMessage.userInputMessage.userInputMessageContext
+                ?.editorState?.relevantDocuments) {
+                const docLength = relevantDoc?.text?.length || 0;
+                if (remainingCharacterBudget > docLength) {
+                    truncatedRelevantDocuments.push(relevantDoc);
+                    remainingCharacterBudget = remainingCharacterBudget - docLength;
+                }
+            }
+            request.conversationState.currentMessage.userInputMessage.userInputMessageContext.editorState.relevantDocuments =
+                truncatedRelevantDocuments;
+        }
+        // 3. try to fit current file context
+        let truncatedCurrentDocument = undefined;
+        if (request.conversationState.currentMessage.userInputMessage.userInputMessageContext?.editorState?.document) {
+            const docLength = request.conversationState.currentMessage.userInputMessage.userInputMessageContext?.editorState?.document
+                .text?.length || 0;
+            if (remainingCharacterBudget > docLength) {
+                truncatedCurrentDocument =
+                    request.conversationState.currentMessage.userInputMessage.userInputMessageContext?.editorState
+                        ?.document;
+                remainingCharacterBudget = remainingCharacterBudget - docLength;
+            }
+            request.conversationState.currentMessage.userInputMessage.userInputMessageContext.editorState.document =
+                truncatedCurrentDocument;
         }
+        return remainingCharacterBudget;
     }
     /**
      * Extracts tool uses that need to be processed
@@ -525,28 +611,38 @@ class AgenticChatController {
             if (!toolUse.name || !toolUse.toolUseId)
                 continue;
             session.toolUseLookup.set(toolUse.toolUseId, toolUse);
+            // Record the start time for this tool use for latency calculation
+            if (toolUse.toolUseId) {
+                this.#toolUseStartTimes[toolUse.toolUseId] = Date.now();
+            }
             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`);
                 }
+                // remove progress UI
+                await chatResultStream.removeResultBlockAndUpdateUI(agenticChatResultStream_1.progressPrefix + toolUse.toolUseId);
                 // 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,
-                    });
+                // fsWrite can take a long time, so we render fsWrite  Explanatory upon partial streaming responses.
+                if (toolUse.name !== 'fsWrite') {
+                    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 'grepSearch':
+                    case 'fuzzySearch':
                     case 'fsWrite':
                     case 'executeBash': {
                         const toolMap = {
@@ -554,7 +650,8 @@ class AgenticChatController {
                             listDirectory: { Tool: listDirectory_1.ListDirectory },
                             fsWrite: { Tool: fsWrite_1.FsWrite },
                             executeBash: { Tool: executeBash_1.ExecuteBash },
-                            fileSearch: { Tool: fileSearch_1.FileSearch },
+                            grepSearch: { Tool: grepSearch_1.GrepSearch },
+                            fuzzySearch: { Tool: fuzzySearch_1.FuzzySearch },
                         };
                         const { Tool } = toolMap[toolUse.name];
                         const tool = new Tool(this.#features);
@@ -568,13 +665,13 @@ class AgenticChatController {
                             cachedButtonBlockId = await chatResultStream.writeResultBlock(confirmationResult);
                             const isExecuteBash = toolUse.name === 'executeBash';
                             if (isExecuteBash) {
-                                this.#telemetryController.emitInteractWithAgenticChat('GeneratedCommand', tabId);
+                                this.#telemetryController.emitInteractWithAgenticChat('GeneratedCommand', tabId, session.pairProgrammingMode, session.getConversationType());
                             }
                             if (requiresAcceptance) {
                                 await this.waitForToolApproval(toolUse, chatResultStream, cachedButtonBlockId, session);
                             }
                             if (isExecuteBash) {
-                                this.#telemetryController.emitInteractWithAgenticChat('RunCommand', tabId);
+                                this.#telemetryController.emitInteractWithAgenticChat('RunCommand', tabId, session.pairProgrammingMode, session.getConversationType());
                             }
                         }
                         break;
@@ -627,19 +724,22 @@ class AgenticChatController {
                 switch (toolUse.name) {
                     case 'fsRead':
                     case 'listDirectory':
-                    case 'fileSearch':
+                    case 'fuzzySearch':
                         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
+                    // no need to write tool result for listDir,fsRead,fuzzySearch 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.
+                    case 'grepSearch':
+                        const grepSearchResult = this.#processGrepSearchResult(toolUse, result, chatResultStream);
+                        if (grepSearchResult) {
+                            await chatResultStream.writeResultBlock(grepSearchResult);
+                        }
                         break;
                     case 'fsWrite':
                         const input = toolUse.input;
@@ -653,7 +753,7 @@ class AgenticChatController {
                                 fileChange: { ...cachedToolUse.fileChange, after: doc?.getText() },
                             });
                         }
-                        this.#telemetryController.emitInteractWithAgenticChat('GeneratedDiff', tabId);
+                        this.#telemetryController.emitInteractWithAgenticChat('GeneratedDiff', tabId, session.pairProgrammingMode, session.getConversationType());
                         await chatResultStream.writeResultBlock(chatResult);
                         break;
                     default:
@@ -666,8 +766,21 @@ class AgenticChatController {
                         break;
                 }
                 this.#updateUndoAllState(toolUse, session);
-                if (toolUse.name) {
-                    this.#telemetryController.emitToolUseSuggested(toolUse, session.conversationId ?? '', this.#features.runtime.serverInfo.version ?? '');
+                if (toolUse.name && toolUse.toolUseId) {
+                    // Calculate latency if we have a start time for this tool use
+                    let latency = undefined;
+                    if (this.#toolUseStartTimes[toolUse.toolUseId]) {
+                        latency = Date.now() - this.#toolUseStartTimes[toolUse.toolUseId];
+                        delete this.#toolUseStartTimes[toolUse.toolUseId];
+                        if (latency !== undefined) {
+                            this.#toolUseLatencies.push({
+                                toolName: toolUse.name,
+                                toolUseId: toolUse.toolUseId,
+                                latency: latency,
+                            });
+                        }
+                    }
+                    this.#telemetryController.emitToolUseSuggested(toolUse, session.conversationId ?? '', this.#features.runtime.serverInfo.version ?? '', latency, session.pairProgrammingMode);
                 }
             }
             catch (err) {
@@ -700,6 +813,68 @@ class AgenticChatController {
                         continue;
                     }
                 }
+                // display fs write failure status in the UX of that file card
+                if (toolUse.name === 'fsWrite' && toolUse.toolUseId) {
+                    const existingCard = chatResultStream.getMessageBlockId(toolUse.toolUseId);
+                    const fsParam = toolUse.input;
+                    const fileName = path.basename(fsParam.path);
+                    const errorResult = {
+                        type: 'tool',
+                        messageId: toolUse.toolUseId,
+                        header: {
+                            fileList: {
+                                filePaths: [fileName],
+                                details: {
+                                    [fileName]: {
+                                        description: fsParam.path,
+                                    },
+                                },
+                            },
+                            status: {
+                                status: 'error',
+                                icon: 'error',
+                                text: 'Error',
+                            },
+                        },
+                    };
+                    if (existingCard) {
+                        await chatResultStream.overwriteResultBlock(errorResult, existingCard);
+                    }
+                    else {
+                        await chatResultStream.writeResultBlock(errorResult);
+                    }
+                }
+                else if (toolUse.name === 'executeBash' && toolUse.toolUseId) {
+                    const existingCard = chatResultStream.getMessageBlockId(toolUse.toolUseId);
+                    const command = toolUse.input.command;
+                    const completedErrorResult = {
+                        type: 'tool',
+                        messageId: toolUse.toolUseId,
+                        body: `\`\`\`shell\n${command}\n\`\`\``,
+                        header: {
+                            body: 'shell',
+                            status: {
+                                status: 'success',
+                                icon: 'ok',
+                                text: 'Completed',
+                            },
+                            buttons: [],
+                        },
+                    };
+                    if (existingCard) {
+                        await chatResultStream.overwriteResultBlock(completedErrorResult, existingCard);
+                    }
+                    else {
+                        this.#features.chat.sendChatUpdate({
+                            tabId,
+                            state: { inProgress: false },
+                            data: {
+                                messages: [completedErrorResult],
+                            },
+                        });
+                    }
+                    this.#stoppedToolUses.add(toolUse.toolUseId);
+                }
                 const errMsg = err instanceof Error ? err.message : 'unknown error';
                 this.#log(`Error running tool ${toolUse.name}:`, errMsg);
                 results.push({
@@ -783,11 +958,15 @@ class AgenticChatController {
      * @param err
      * @returns
      */
-    isUserAction(err, token) {
+    isUserAction(err, token, session) {
         return (lsp_core_1.CancellationError.isUserCancelled(err) ||
             err instanceof toolShared_1.ToolApprovalException ||
+            (0, errors_2.isRequestAbortedError)(err) ||
             (token?.isCancellationRequested ?? false));
     }
+    #isPromptCanceled(token, session, promptId) {
+        return token?.isCancellationRequested === true || !session.isCurrentPrompt(promptId);
+    }
     #validateToolResult(toolUse, result) {
         let maxToolResponseSize;
         switch (toolUse.name) {
@@ -925,7 +1104,7 @@ class AgenticChatController {
                     },
                 };
                 break;
-            case 'fileSearch':
+            case 'fuzzySearch':
                 const searchPath = toolUse.input.path;
                 header = {
                     body: 'File Search',
@@ -1158,7 +1337,7 @@ class AgenticChatController {
             title =
                 toolUse.name === 'fsRead'
                     ? `${itemCount} file${itemCount > 1 ? 's' : ''} read`
-                    : toolUse.name === 'fileSearch'
+                    : toolUse.name === 'fuzzySearch'
                         ? `${itemCount} ${itemCount === 1 ? 'directory' : 'directories'} searched`
                         : `${itemCount} ${itemCount === 1 ? 'directory' : 'directories'} listed`;
         }
@@ -1181,6 +1360,59 @@ class AgenticChatController {
             body: '',
         };
     }
+    /**
+     * Process grep search results and format them for display in the chat UI
+     */
+    #processGrepSearchResult(toolUse, result, chatResultStream) {
+        if (toolUse.name !== 'grepSearch') {
+            return undefined;
+        }
+        let messageIdToUpdate = toolUse.toolUseId;
+        const currentId = chatResultStream.getMessageIdToUpdateForTool(toolUse.name);
+        if (currentId) {
+            messageIdToUpdate = currentId;
+        }
+        else {
+            chatResultStream.setMessageIdToUpdateForTool(toolUse.name, messageIdToUpdate);
+        }
+        // Extract search results from the tool output
+        const output = result.output.content;
+        if (!output || !output.fileMatches || !Array.isArray(output.fileMatches)) {
+            return {
+                type: 'tool',
+                messageId: messageIdToUpdate,
+                body: 'No search results found.',
+            };
+        }
+        // Process the matches into a structured format
+        const matches = output.fileMatches;
+        const fileDetails = {};
+        // Create file details directly from matches
+        for (const match of matches) {
+            const filePath = match.filePath;
+            if (!filePath)
+                continue;
+            fileDetails[`${filePath} (${match.matches.length} ${match.matches.length <= 1 ? 'result' : 'results'})`] = {
+                description: filePath,
+                lineRanges: [{ first: -1, second: -1 }],
+            };
+        }
+        // Create sorted array of file paths
+        const sortedFilePaths = Object.keys(fileDetails);
+        // Create the context list for display
+        const query = toolUse.input?.query || 'search term';
+        const contextList = {
+            rootFolderTitle: `Grepped for "${query}", ${output.matchCount}  ${output.matchCount <= 1 ? 'result' : 'results'} found`,
+            filePaths: sortedFilePaths,
+            details: fileDetails,
+        };
+        return {
+            type: 'tool',
+            fileList: contextList,
+            messageId: messageIdToUpdate,
+            body: '',
+        };
+    }
     /**
      * Updates the request input with tool results for the next iteration
      */
@@ -1222,6 +1454,7 @@ class AgenticChatController {
         }
         metric.setDimension('codewhispererCustomizationArn', this.#customizationArn);
         metric.setDimension('languageServerVersion', this.#features.runtime.serverInfo.version);
+        metric.setDimension('enabled', session.pairProgrammingMode);
         const profileArn = AmazonQTokenServiceManager_1.AmazonQTokenServiceManager.getInstance().getActiveProfileArn();
         if (profileArn) {
             this.#telemetryService.updateProfileArn(profileArn);
@@ -1241,7 +1474,7 @@ class AgenticChatController {
                 cwsprChatFocusFileContextLength: triggerContext.text?.length,
             });
         }
-        await this.#telemetryController.emitAddMessageMetric(params.tabId, metric.metric);
+        await this.#telemetryController.emitAddMessageMetric(params.tabId, metric.metric, 'Succeeded');
         this.#telemetryController.updateTriggerInfo(params.tabId, {
             lastMessageTrigger: {
                 ...triggerContext,
@@ -1256,18 +1489,22 @@ class AgenticChatController {
     /**
      * Handles errors that occur during the request
      */
-    #handleRequestError(err, errorMessageId, tabId, metric) {
+    async #handleRequestError(conversationId, err, errorMessageId, tabId, metric, agenticCodingMode) {
         const errorMessage = (0, utils_2.getErrorMessage)(err);
         const requestID = (0, utils_2.getRequestID)(err) ?? '';
         metric.setDimension('cwsprChatResponseCode', (0, utils_2.getHttpStatusCode)(err) ?? 0);
         metric.setDimension('languageServerVersion', this.#features.runtime.serverInfo.version);
+        metric.metric.requestIds = [requestID];
+        metric.metric.cwsprChatMessageId = errorMessageId;
+        metric.metric.cwsprChatConversationId = conversationId;
+        await this.#telemetryController.emitAddMessageMetric(tabId, metric.metric, 'Failed');
         // use custom error message for unactionable errors (user-dependent errors like PromptCharacterLimit)
         if (err.code && err.code in errors_2.unactionableErrorCodes) {
             const customErrMessage = errors_2.unactionableErrorCodes[err.code];
-            this.#telemetryController.emitMessageResponseError(tabId, metric.metric, requestID, customErrMessage);
+            this.#telemetryController.emitMessageResponseError(tabId, metric.metric, requestID, customErrMessage, agenticCodingMode);
         }
         else {
-            this.#telemetryController.emitMessageResponseError(tabId, metric.metric, requestID, errorMessage ?? constants_2.genericErrorMsg);
+            this.#telemetryController.emitMessageResponseError(tabId, metric.metric, requestID, errorMessage ?? constants_2.genericErrorMsg, agenticCodingMode);
         }
         let authFollowType = undefined;
         // first check if there is an AmazonQ related auth follow up
@@ -1288,7 +1525,9 @@ class AgenticChatController {
                 // Clear the chat history in the database for this tab
                 this.#chatHistoryDb.clearTab(tabId);
             }
-            const errorBody = err.code === 'QModelResponse' && requestID ? `${err.message}\n\nRequest ID: ${requestID}` : err.message;
+            const errorBody = err.code === 'QModelResponse' && requestID
+                ? `${err.message} \n\nRequest ID: ${requestID} `
+                : err.message;
             return new server_interface_1.ResponseError(server_interface_1.LSPErrorCodes.RequestFailed, err.message, {
                 type: 'answer',
                 body: errorBody,
@@ -1299,7 +1538,7 @@ class AgenticChatController {
         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,
+            body: requestID ? `${constants_2.genericErrorMsg} \n\nRequest ID: ${requestID}` : constants_2.genericErrorMsg,
             messageId: errorMessageId,
             buttons: [],
         });
@@ -1356,7 +1595,7 @@ class AgenticChatController {
                 missingParams.push('cursorPosition');
             if (!params.code)
                 missingParams.push('code');
-            this.#log(`Q Chat server failed to insert code. Missing required parameters for insert code: ${missingParams.join(', ')}`);
+            this.#log(`Q Chat server failed to insert code.Missing required parameters for insert code: ${missingParams.join(', ')}`);
             return;
         }
         let cursorPosition = params.cursorPosition;
@@ -1544,7 +1783,7 @@ class AgenticChatController {
     }
     async #resolveAbsolutePath(relativePath) {
         try {
-            const workspaceFolders = lsp_core_1.workspaceUtils.getWorkspaceFolderPaths(this.#features.lsp);
+            const workspaceFolders = lsp_core_1.workspaceUtils.getWorkspaceFolderPaths(this.#features.workspace);
             for (const workspaceRoot of workspaceFolders) {
                 const candidatePath = path.join(workspaceRoot, relativePath);
                 if (await this.#features.workspace.fs.exists(candidatePath)) {
@@ -1636,6 +1875,56 @@ class AgenticChatController {
             throw err;
         }
     }
+    async #showToolUseIntermediateResult(data, chatResultStream, streamWriter) {
+        // extract the key value from incomplete JSON response stream
+        function extractKey(incompleteJson, key) {
+            const pattern = new RegExp(`"${key}":\\s*"([^"]*)"`, 'g');
+            const match = pattern.exec(incompleteJson);
+            return match?.[1];
+        }
+        const toolUses = Object.values(data.toolUses);
+        for (const toolUse of toolUses) {
+            if (toolUse.name === 'fsWrite' && typeof toolUse.input === 'string') {
+                const filepath = extractKey(toolUse.input, 'path');
+                const msgId = agenticChatResultStream_1.progressPrefix + toolUse.toolUseId;
+                // render fs write UI as soon as fs write starts
+                if (filepath && !chatResultStream.hasMessage(msgId)) {
+                    const fileName = path.basename(filepath);
+                    await streamWriter.close();
+                    await chatResultStream.writeResultBlock({
+                        type: 'tool',
+                        messageId: msgId,
+                        header: {
+                            fileList: {
+                                filePaths: [fileName],
+                                details: {
+                                    [fileName]: {
+                                        description: filepath,
+                                    },
+                                },
+                            },
+                            status: {
+                                status: 'info',
+                                icon: 'progress',
+                                text: '',
+                            },
+                        },
+                    });
+                }
+                // render the tool use explanatory as soon as this is received for fsWrite
+                const explanation = extractKey(toolUse.input, 'explanation');
+                const messageId = agenticChatResultStream_1.progressPrefix + toolUse.toolUseId + '_explanation';
+                if (explanation && !chatResultStream.hasMessage(messageId)) {
+                    await streamWriter.close();
+                    await chatResultStream.writeResultBlock({
+                        type: 'directive',
+                        messageId: messageId,
+                        body: explanation,
+                    });
+                }
+            }
+        }
+    }
     async #processGenerateAssistantResponseResponse(response, metric, chatResultStream, streamWriter, session, contextList, abortSignal) {
         const requestId = response.$metadata.requestId;
         const chatEventParser = new agenticChatEventParser_1.AgenticChatEventParser(requestId, metric, this.#features.logging);
@@ -1666,6 +1955,7 @@ class AgenticChatController {
             }
             if (chatEvent.toolUseEvent) {
                 await this.#showLoadingIfRequired(chatEvent.toolUseEvent, streamWriter, toolUseStartTimes, toolUseLoadingTimeouts);
+                await this.#showToolUseIntermediateResult(result.data, chatResultStream, streamWriter);
             }
         }
         await streamWriter.close();
@@ -1687,6 +1977,10 @@ class AgenticChatController {
         if (!toolUseEvent.stop && toolUseId) {
             if (!toolUseStartTimes[toolUseId]) {
                 toolUseStartTimes[toolUseId] = Date.now();
+                // Also record in the class-level toolUseStartTimes for latency calculation
+                if (!this.#toolUseStartTimes[toolUseId]) {
+                    this.#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`);