fix(amazonq): Don't show inline completions when a edit is displayed

Author: floralph

packages/amazonq/src/app/inline/EditRendering/displayImage.ts

@@ -286,6 +286,27 @@ export async function displaySvgDecoration(
 ) {
     const originalCode = editor.document.getText()
 
+    // Check if a completion suggestion is currently active - if so, discard edit suggestion
+    if (inlineCompletionProvider && inlineCompletionProvider.isCompletionActive()) {
+        // Emit DISCARD telemetry for edit suggestion that can't be shown due to active completion
+        const params: LogInlineCompletionSessionResultsParams = {
+            sessionId: session.sessionId,
+            completionSessionResult: {
+                [item.itemId]: {
+                    seen: false,
+                    accepted: false,
+                    discarded: true,
+                },
+            },
+            totalSessionDisplayTime: Date.now() - session.requestStartTime,
+            firstCompletionDisplayLatency: session.firstCompletionDisplayLatency,
+            isInlineEdit: true,
+        }
+        languageClient.sendNotification('aws/logInlineCompletionSessionResults', params)
+        getLogger().info('Edit suggestion discarded due to active completion suggestion')
+        return
+    }
+
     await decorationManager.displayEditSuggestion(
         editor,
         svgImage,

packages/amazonq/src/app/inline/completion.ts

@@ -41,7 +41,7 @@ import {
 import { LineTracker } from './stateTracker/lineTracker'
 import { InlineTutorialAnnotation } from './tutorials/inlineTutorialAnnotation'
 import { TelemetryHelper } from './telemetryHelper'
-import { Experiments, getLogger, sleep } from 'aws-core-vscode/shared'
+import { Experiments, getContext, getLogger, sleep } from 'aws-core-vscode/shared'
 import { messageUtils } from 'aws-core-vscode/utils'
 import { showEdits } from './EditRendering/imageRenderer'
 import { ICursorUpdateRecorder } from './cursorUpdateManager'
@@ -237,6 +237,21 @@ export class AmazonQInlineCompletionItemProvider implements InlineCompletionItem
         await vscode.commands.executeCommand(`aws.amazonq.checkInlineSuggestionVisibility`)
     }
 
+    /**
+     * Check if a completion suggestion is currently active/displayed
+     */
+    public isCompletionActive(): boolean {
+        const session = this.sessionManager.getActiveSession()
+        return session !== undefined && session.displayed && !session.suggestions.some((item) => item.isInlineEdit)
+    }
+
+    /**
+     * Check if an edit suggestion is currently active
+     */
+    private isEditSuggestionActive(): boolean {
+        return getContext('aws.amazonq.editSuggestionActive') || false
+    }
+
     // this method is automatically invoked by VS Code as user types
     async provideInlineCompletionItems(
         document: TextDocument,
@@ -435,6 +450,31 @@ ${itemLog}
             // the user typed characters from invoking suggestion cursor position to receiving suggestion position
             const typeahead = document.getText(new Range(position, editor.selection.active))
 
+            // Check if an edit suggestion is currently active - if so, discard completion suggestions
+            if (this.isEditSuggestionActive()) {
+                // Emit DISCARD telemetry for completion suggestions that can't be shown due to active edit
+                for (const item of items) {
+                    if (!item.isInlineEdit && item.itemId) {
+                        const params: LogInlineCompletionSessionResultsParams = {
+                            sessionId: session.sessionId,
+                            completionSessionResult: {
+                                [item.itemId]: {
+                                    seen: false,
+                                    accepted: false,
+                                    discarded: true,
+                                },
+                            },
+                            firstCompletionDisplayLatency: session.firstCompletionDisplayLatency,
+                            totalSessionDisplayTime: performance.now() - session.requestStartTime,
+                        }
+                        this.languageClient.sendNotification(this.logSessionResultMessageName, params)
+                    }
+                }
+                this.sessionManager.clear()
+                logstr += `- completion suggestions discarded due to active edit suggestion`
+                return []
+            }
+
             const itemsMatchingTypeahead = []
 
             for (const item of items) {

packages/amazonq/test/unit/amazonq/apps/inline/completion.test.ts

@@ -419,6 +419,125 @@ describe('InlineCompletionManager', () => {
                     assert.deepStrictEqual((r3 as InlineCompletionItem[])[0].range?.end, new Position(1, 26))
                 })
             })
+
+            it('should return empty array and emit telemetry when edit suggestion is active', async () => {
+                provider = new AmazonQInlineCompletionItemProvider(
+                    languageClient,
+                    recommendationService,
+                    mockSessionManager,
+                    inlineTutorialAnnotation,
+                    documentEventListener
+                )
+
+                // Stub the private method to return true (following existing pattern)
+                sandbox.stub(provider as any, 'isEditSuggestionActive').returns(true)
+
+                const result = await provider.provideInlineCompletionItems(
+                    mockDocument,
+                    mockPosition,
+                    mockContext,
+                    mockToken
+                )
+
+                // Should return empty array
+                assert.deepStrictEqual(result, [])
+
+                // Should emit telemetry for each completion suggestion
+                assert.strictEqual(sendNotificationStub.callCount, 2) // For both mockSuggestions
+
+                // Verify telemetry parameters for first call
+                const firstCall = sendNotificationStub.getCall(0)
+                assert.strictEqual(firstCall.args[0], 'aws/logInlineCompletionSessionResults')
+                const sessionResult = Object.values(firstCall.args[1].completionSessionResult)[0] as any
+                assert.strictEqual(sessionResult.seen, false)
+                assert.strictEqual(sessionResult.accepted, false)
+                assert.strictEqual(sessionResult.discarded, true)
+            })
+
+            it('should only emit telemetry for non-inline-edit items when edit is active', async () => {
+                provider = new AmazonQInlineCompletionItemProvider(
+                    languageClient,
+                    recommendationService,
+                    mockSessionManager,
+                    inlineTutorialAnnotation,
+                    documentEventListener
+                )
+
+                sandbox.stub(provider as any, 'isEditSuggestionActive').returns(true)
+
+                // Mix of inline edits and completions
+                const mixedSuggestions = [
+                    { itemId: 'edit1', insertText: 'diff', isInlineEdit: true },
+                    { itemId: 'completion1', insertText: 'code', isInlineEdit: false },
+                ]
+                getActiveRecommendationStub.returns(mixedSuggestions)
+
+                const result = await provider.provideInlineCompletionItems(
+                    mockDocument,
+                    mockPosition,
+                    mockContext,
+                    mockToken
+                )
+
+                // Should return empty array
+                assert.deepStrictEqual(result, [])
+
+                // Should only emit telemetry for completion, not inline edit
+                assert.strictEqual(sendNotificationStub.callCount, 1)
+                const call = sendNotificationStub.getCall(0)
+                assert(call.args[1].completionSessionResult['completion1'])
+                assert(!call.args[1].completionSessionResult['edit1'])
+            })
+
+            it('should not emit telemetry for items without itemId when edit is active', async () => {
+                provider = new AmazonQInlineCompletionItemProvider(
+                    languageClient,
+                    recommendationService,
+                    mockSessionManager,
+                    inlineTutorialAnnotation,
+                    documentEventListener
+                )
+
+                sandbox.stub(provider as any, 'isEditSuggestionActive').returns(true)
+
+                // Set up suggestions where some don't have itemId
+                const suggestionsWithoutId = [
+                    { insertText: 'code', isInlineEdit: false }, // No itemId
+                    { itemId: 'completion1', insertText: 'code', isInlineEdit: false },
+                ]
+                getActiveRecommendationStub.returns(suggestionsWithoutId)
+
+                const result = await provider.provideInlineCompletionItems(
+                    mockDocument,
+                    mockPosition,
+                    mockContext,
+                    mockToken
+                )
+
+                // Should return empty array
+                assert.deepStrictEqual(result, [])
+
+                // Should only emit telemetry for the item with itemId
+                assert.strictEqual(sendNotificationStub.callCount, 1)
+                const call = sendNotificationStub.getCall(0)
+                assert(call.args[1].completionSessionResult['completion1'])
+            })
+
+            describe('isEditSuggestionActive', () => {
+                it('should return false when no edit suggestion is active', () => {
+                    provider = new AmazonQInlineCompletionItemProvider(
+                        languageClient,
+                        recommendationService,
+                        mockSessionManager,
+                        inlineTutorialAnnotation,
+                        documentEventListener
+                    )
+
+                    // Since getContext returns undefined by default, this should return false
+                    const result = (provider as any).isEditSuggestionActive()
+                    assert.strictEqual(result, false)
+                })
+            })
         })
     })
 })