@aws/lsp-codewhisperer 0.0.50 → 0.0.52

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [0.0.52](https://github.com/aws/language-servers/compare/lsp-codewhisperer/v0.0.51...lsp-codewhisperer/v0.0.52) (2025-06-17)
+
+
+### Bug Fixes
+
+* **amazonq:** filter languages at workspace context server onDeleteFiles ([#1684](https://github.com/aws/language-servers/issues/1684)) ([4272eec](https://github.com/aws/language-servers/commit/4272eec6ce4554560fdf8888d85d31315db2d964))
+* send AmazonQ.md as a rule, do not automatically send README.md ([#1688](https://github.com/aws/language-servers/issues/1688)) ([c7a0656](https://github.com/aws/language-servers/commit/c7a0656ae3624082062f697b1564e589e943e4a8))
+* update MCP tools implementation ([#1676](https://github.com/aws/language-servers/issues/1676)) ([51b7870](https://github.com/aws/language-servers/commit/51b7870d7144d593249a3da001b7f1047aa3b642))
+
+## [0.0.51](https://github.com/aws/language-servers/compare/lsp-codewhisperer/v0.0.50...lsp-codewhisperer/v0.0.51) (2025-06-17)
+
+
+### Features
+
+* add packageId property to references in req.json ([#1570](https://github.com/aws/language-servers/issues/1570)) ([3b14b17](https://github.com/aws/language-servers/commit/3b14b173369936fe9bcee130a15f2ae1d39c9cb9))
+* support per region model selection ([#1683](https://github.com/aws/language-servers/issues/1683)) ([0b81b37](https://github.com/aws/language-servers/commit/0b81b37c15a8c407ec04904abb4bdccf829aa1c1))
+
+
+### Bug Fixes
+
+* add latency metrics for invokeLLM metric ([#1681](https://github.com/aws/language-servers/issues/1681)) ([0cac52c](https://github.com/aws/language-servers/commit/0cac52c3d037da8fc4403f030738256b07195e76))
+* adding normalizePathFromUri to mcpUtils to handle uri paths ([#1653](https://github.com/aws/language-servers/issues/1653)) ([20532bf](https://github.com/aws/language-servers/commit/20532bf276967c33c43a677e1c1621451c58b9a9))
+* **amazonq:** prevent workspace context server initialization workflow from overlapping ([#1668](https://github.com/aws/language-servers/issues/1668)) ([1625abd](https://github.com/aws/language-servers/commit/1625abd2a9fa969859236cfe1b57fa1cdd2dcc33))
+* clear IDE context for auto-retry requests not initiated by the user ([#1680](https://github.com/aws/language-servers/issues/1680)) ([13c9455](https://github.com/aws/language-servers/commit/13c94558706d0181c1a2d64b439be90a601e8f74))
+* timeout only works for the first time in the loop ([#1675](https://github.com/aws/language-servers/issues/1675)) ([ab50985](https://github.com/aws/language-servers/commit/ab50985eb0dac1888769f7fb703aa8d6f50c1b89))
+* use NodeHttpHandler when configuring requestHandler ([#1670](https://github.com/aws/language-servers/issues/1670)) ([7b620a8](https://github.com/aws/language-servers/commit/7b620a82b7acb4fbdbb5b88661be661dd575d152))
+* when user add a new server, it would load global persona at first time ([#1667](https://github.com/aws/language-servers/issues/1667)) ([a3cf388](https://github.com/aws/language-servers/commit/a3cf3880d178ae74f2136abb798f6a8f08fe76e2))
+
 ## [0.0.50](https://github.com/aws/language-servers/compare/lsp-codewhisperer/v0.0.49...lsp-codewhisperer/v0.0.50) (2025-06-16)
 
 

package/out/language-server/agenticChat/agenticChatController.d.ts

@@ -131,6 +131,10 @@ export declare class AgenticChatController implements ChatHandlers {
      * @returns `undefined` on success, or error message on failure.
      */
     onManageSubscription(tabId: string, awsAccountId?: string): Promise<string | undefined>;
+    /**
+     * Calculates time to first chunk and time between chunks
+     */
+    recordChunk(chunkType: string): void;
     onPromptInputOptionChange(params: PromptInputOptionChangeParams): void;
     updateConfiguration: (newConfig: AmazonQWorkspaceConfig) => void;
     restorePreviousChats(): Promise<void>;

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

@@ -71,6 +71,13 @@ class AgenticChatController {
     #toolUseLatencies = [];
     #mcpEventHandler;
     #paidTierMode;
+    // latency metrics
+    #llmRequestStartTime = 0;
+    #toolCallLatencies = [];
+    #toolStartTime = 0;
+    #timeToFirstChunk = -1;
+    #timeBetweenChunks = [];
+    #lastChunkTime = 0;
     /**
      * Determines the appropriate message ID for a tool use based on tool type and name
      * @param toolType The type of tool being used
@@ -89,6 +96,10 @@ class AgenticChatController {
         this.#telemetryController = new chatTelemetryController_1.ChatTelemetryController(features, telemetryService);
         this.#telemetryService = telemetryService;
         this.#serviceManager = serviceManager;
+        this.#serviceManager?.onRegionChange(region => {
+            // @ts-ignore
+            this.#features.chat.chatOptionsUpdate({ region });
+        });
         this.#chatHistoryDb = new chatDb_1.ChatDatabase(features);
         this.#tabBarController = new tabBarController_1.TabBarController(features, this.#chatHistoryDb, telemetryService, (tabId) => this.sendPinnedContext(tabId));
         this.#additionalContextProvider = new addtionalContextProvider_1.AdditionalContextProvider(features, this.#chatHistoryDb);
@@ -423,6 +434,9 @@ class AgenticChatController {
         while (true) {
             iterationCount++;
             this.#debug(`Agent loop iteration ${iterationCount} for conversation id:`, conversationIdentifier || '');
+            this.#toolCallLatencies = [];
+            this.#timeToFirstChunk = -1;
+            this.#timeBetweenChunks = [];
             // Check for cancellation
             if (this.#isPromptCanceled(token, session, promptId)) {
                 this.#debug('Stopping agent loop - cancelled by user');
@@ -455,6 +469,7 @@ class AgenticChatController {
             // Add loading message before making the request
             const loadingMessageId = `loading-${(0, uuid_1.v4)()}`;
             await chatResultStream.writeResultBlock({ ...constants_1.loadingMessage, messageId: loadingMessageId });
+            this.#llmRequestStartTime = Date.now();
             // Phase 3: Request Execution
             // Note: these logs are very noisy, but contain information redacted on the backend.
             this.#debug(`generateAssistantResponse Request: ${JSON.stringify(currentRequestInput, undefined, 2)}`);
@@ -490,6 +505,8 @@ class AgenticChatController {
                 cwsprChatResponseCode: response.$metadata.httpStatusCode,
                 cwsprChatMessageId: response.$metadata.requestId,
             }), chatResultStream, session, documentReference);
+            const llmLatency = Date.now() - this.#llmRequestStartTime;
+            this.#debug(`LLM Response Latency: ${llmLatency}`);
             // This is needed to handle the case where the response stream times out
             // and we want to auto-retry
             if (!result.success && result.error.startsWith(constants_2.responseTimeoutPartialMsg)) {
@@ -545,8 +562,9 @@ class AgenticChatController {
             // Check if we have any tool uses that need to be processed
             const pendingToolUses = this.#getPendingToolUses(result.data?.toolUses || {});
             if (pendingToolUses.length === 0) {
+                this.recordChunk('agent_loop_done');
                 // 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);
+                this.#telemetryController.emitAgencticLoop_InvokeLLM(response.$metadata.requestId, conversationId, 'AgenticChat', undefined, undefined, 'Succeeded', this.#features.runtime.serverInfo.version ?? '', [llmLatency], this.#toolCallLatencies, this.#timeToFirstChunk, this.#timeBetweenChunks, session.pairProgrammingMode);
                 finalResult = result;
                 break;
             }
@@ -560,13 +578,14 @@ class AgenticChatController {
                     content = 'There was an error processing one or more tool uses. Try again, do not apologize.';
                     shouldDisplayMessage = false;
                 }
+                const toolCallLatency = Date.now() - this.#toolStartTime;
+                this.#toolCallLatencies.push(toolCallLatency);
                 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);
+                this.#telemetryController.emitAgencticLoop_InvokeLLM(response.$metadata.requestId, conversationId, 'AgenticChatWithToolUse', toolNames ?? undefined, toolUseIds ?? undefined, 'Succeeded', this.#features.runtime.serverInfo.version ?? '', [llmLatency], this.#toolCallLatencies, this.#timeToFirstChunk, this.#timeBetweenChunks, session.pairProgrammingMode);
             }
             else {
                 // Send an error card to UI?
@@ -575,7 +594,7 @@ class AgenticChatController {
                     status: codewhisperer_streaming_client_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);
+                this.#telemetryController.emitAgencticLoop_InvokeLLM(response.$metadata.requestId, conversationId, 'AgenticChatWithToolUse', undefined, undefined, 'Failed', this.#features.runtime.serverInfo.version ?? '', [llmLatency], this.#toolCallLatencies, this.#timeToFirstChunk, this.#timeBetweenChunks, 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.';
@@ -694,6 +713,8 @@ class AgenticChatController {
                 if (!availableToolNames.includes(toolUse.name)) {
                     throw new Error(`Tool ${toolUse.name} is not available in the current mode`);
                 }
+                this.recordChunk(`tool_execution_start - ${toolUse.name}`);
+                this.#toolStartTime = Date.now();
                 // 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
@@ -1215,7 +1236,7 @@ class AgenticChatController {
                         content: {
                             header: {
                                 icon: 'tools',
-                                body: `${toolName}`,
+                                body: `${originalToolName ?? (toolType || toolUse.name)}`,
                                 status: {
                                     status: isAccept ? 'success' : 'error',
                                     icon: isAccept ? 'ok' : 'cancel',
@@ -1572,6 +1593,16 @@ class AgenticChatController {
         updatedRequestInput.conversationState.currentMessage.userInputMessage.userInputMessageContext.toolResults =
             [];
         updatedRequestInput.conversationState.currentMessage.userInputMessage.content = content;
+        // don't pass in IDE context again in the followup toolUse/toolResult loop as it confuses the model and is not necessary
+        updatedRequestInput.conversationState.currentMessage.userInputMessage.userInputMessageContext.editorState =
+            {
+                ...updatedRequestInput.conversationState.currentMessage.userInputMessage.userInputMessageContext
+                    .editorState,
+                document: undefined,
+                relevantDocuments: undefined,
+                cursorState: undefined,
+                useRelevantDocuments: false,
+            };
         for (const toolResult of toolResults) {
             this.#debug(`ToolResult: ${JSON.stringify(toolResult)}`);
             updatedRequestInput.conversationState.currentMessage.userInputMessage.userInputMessageContext.toolResults.push({
@@ -1922,7 +1953,14 @@ class AgenticChatController {
         this.#telemetryController.activeTabId = params.tabId;
         // Since model selection is mandatory, the only time modelId is not set is when the chat history is empty.
         // In that case, we use the default modelId.
-        const modelId = this.#chatHistoryDb.getModelId() ?? constants_2.defaultModelId;
+        let modelId = this.#chatHistoryDb.getModelId() ?? constants_2.defaultModelId;
+        const region = AmazonQTokenServiceManager_1.AmazonQTokenServiceManager.getInstance().getRegion();
+        if (region === 'eu-central-1') {
+            // Only 3.7 Sonnet is available in eu-central-1 for now
+            modelId = 'CLAUDE_3_7_SONNET_20250219_V1_0';
+            // @ts-ignore
+            this.#features.chat.chatOptionsUpdate({ region });
+        }
         this.#features.chat.chatOptionsUpdate({ modelId: modelId, tabId: params.tabId });
         if (!params.restoredTab) {
             this.sendPinnedContext(params.tabId);
@@ -2285,8 +2323,9 @@ class AgenticChatController {
     }
     async #processGenerateAssistantResponseResponseWithTimeout(response, metric, chatResultStream, session, contextList) {
         const abortController = new AbortController();
+        let timeoutId;
         const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => {
+            timeoutId = setTimeout(() => {
                 abortController.abort();
                 reject(new errors_2.AgenticChatError(`${constants_2.responseTimeoutPartialMsg} ${constants_2.responseTimeoutMs}ms`, 'ResponseProcessingTimeout'));
             }, constants_2.responseTimeoutMs);
@@ -2294,9 +2333,12 @@ class AgenticChatController {
         const streamWriter = chatResultStream.getResultStreamWriter();
         const processResponsePromise = this.#processGenerateAssistantResponseResponse(response, metric, chatResultStream, streamWriter, session, contextList, abortController.signal);
         try {
-            return await Promise.race([processResponsePromise, timeoutPromise]);
+            const result = await Promise.race([processResponsePromise, timeoutPromise]);
+            clearTimeout(timeoutId);
+            return result;
         }
         catch (err) {
+            clearTimeout(timeoutId);
             await streamWriter.close();
             if (err instanceof errors_2.AgenticChatError && err.code === 'ResponseProcessingTimeout') {
                 return { success: false, error: err.message };
@@ -2378,6 +2420,10 @@ class AgenticChatController {
                 await streamWriter.close();
                 return result;
             }
+            // Track when chunks appear to user
+            if (chatEvent.assistantResponseEvent && result.data.chatResult.body) {
+                this.recordChunk('chunk');
+            }
             // make sure to save code reference events
             if (chatEvent.assistantResponseEvent || chatEvent.codeReferenceEvent) {
                 await streamWriter.write(result.data.chatResult);
@@ -2442,6 +2488,23 @@ class AgenticChatController {
         }
         return chatEventParser.getResult();
     }
+    /**
+     * Calculates time to first chunk and time between chunks
+     */
+    recordChunk(chunkType) {
+        if (this.#timeToFirstChunk === -1) {
+            this.#timeToFirstChunk = Date.now() - this.#llmRequestStartTime;
+            this.#lastChunkTime = Date.now();
+        }
+        else {
+            const timeBetweenChunks = Date.now() - this.#lastChunkTime;
+            this.#timeBetweenChunks.push(timeBetweenChunks);
+            this.#lastChunkTime = Date.now();
+            if (chunkType !== 'chunk') {
+                this.#debug(`Time between chunks [${chunkType}]: ${timeBetweenChunks}ms (total chunks: ${this.#timeBetweenChunks.length})`);
+            }
+        }
+    }
     onPromptInputOptionChange(params) {
         const sessionResult = this.#chatSessionManagementService.getSession(params.tabId);
         const { data: session, success } = sessionResult;