Feature Request: Prevent Multi-line Suggestions from Disappearing on Matching First Character

[TOMgrec]

Describe the Problem

When using Continue's multi-line code suggestions (e.g., generated by LLMs), the suggestion dismisses immediately if I type the first character that matches the suggestion's first character. This creates a frustrating UX loop:

Example scenario:

Code :

def calculateSum(a, b):
  return 

Suggestion : a + b

If I type a (which matches the suggestion's first character), the entire multi-line suggestion vanishes instantly. This is really annoying as it makes the suggestion appear for a splite time.

This behavior is particularly painful for:

• Multi-line functions, loops, or conditionals
• Common first characters like {, (, ;, return, if, etc.
• Tab-autocomplete trained models expecting "head matching"

Expected behavior (like GitHub Copilot or Cursor): The suggestion should persist as long as subsequent characters continue matching, even if the first character matches exactly.

Wanted behaviour

Modify the suggestion dismissal logic to handle multi-line completions more gracefully:

Head-match persistence

Update the suggestion to remove the matching caracter typed.

Current code:       return |
Suggestion:                a + b;
Typed a:            return a|
New suggestion:              + b;

Proposed solutions

• I know that Continue is already using caching to restore suggestions when backspace is pressed. Maybe use this cache to get a suggestion.
• Otherwise, modify the InlineCompletionProvider to store the last recommandation and to compare it with the last typed caracter.

[TOMgrec]

Here are some of my ideas of to implement this feature.

Modified ContinueCompletionProvider

The idea is to modify the vscode.InlineCompletionItemProvider directly.
Each time a new edit is made, it checks the context and if the next caracter is the same as the first of the suggestion, it updates the selection accordingly.

Some special cases, are for all the brackets (), {} and [] where we might have to check on both ends at once.

continue/extensions/vscode/src/autocomplete/completionProvider.ts

After looking quickly on the source code, I think this might work.

export class ContinueCompletionProvider
  implements vscode.InlineCompletionItemProvider
{

  ...

  public async provideInlineCompletionItems(
    document: vscode.TextDocument,
    position: vscode.Position,
    context: vscode.InlineCompletionContext,
    token: vscode.CancellationToken,
    //@ts-ignore
  ): ProviderResult<InlineCompletionItem[] | InlineCompletionList> {

    ...

@line:189
    // This code checks if there is a selected completion suggestion in the given context and ensures that it is valid
    // To improve the accuracy of suggestions it checks if the user has typed at least 4 characters
    // This helps refine and filter out irrelevant autocomplete options
    if (selectedCompletionInfo) {
      const { text, range } = selectedCompletionInfo;
      const typedText = document.getText(range);

      const typedLength = range.end.character - range.start.character;

@start_insert
      if (text.startsWith(typedText)) {
        // Immediatly returns the old suggestion sliced
        const new_suggestion = text.slice(typedLength)
        
        // Not sure this is the way to do it but you get the idea (from @line:650)

        // Track this ghost text for acceptance detection.
        // Ghost text acceptance can *technically* be acted upon in the command handler for "continue.logNextEditOutcomeAccept".
        // However, there is a substantial delay between accepting and logging, which introduces a lot of race conditions with different event handlers.
        // Plus, separating these concerns seems to make sense logically as well.
        GhostTextAcceptanceTracker.getInstance().setExpectedGhostTextAcceptance(
          document,
          new_suggestion,
          new vscode.Position(currCursorPos.line, currCursorPos.character),
        );

        const nextEditCompletionItem = new vscode.InlineCompletionItem(
          new_suggestion,
          new vscode.Range(
            new vscode.Position(currCursorPos.line, currCursorPos.character),
            new vscode.Position(currCursorPos.line, currCursorPos.character),
          ),
          {
            title: "Log Next Edit Outcome",
            command: "continue.logNextEditOutcomeAccept",
            arguments: [completionId, this.nextEditLoggingService],
          },
        );
        return [nextEditCompletionItem];
      }
@end_insert

      if (typedLength < 4) {
        return null;
      }

      if (!text.startsWith(typedText)) {
        return null;
      }

    }

    ...

  }

  ...

}

Although, creating a special function to handle all the special cases could be usefull.

vscode-copilot-chat/src/extension/completions-core/vscode-node/lib/src/ghostText/current.ts

For reference, here is an extract of the code on the Microsoft vscode-copilot-chat extension that seems to be handling our problem.

export class CurrentGhostText implements ICompletionsCurrentGhostText {
  
  ...

@line:59
  /** Returns the current choices if the request context matches.  */
	getCompletionsForUserTyping(prefix: string, suffix: string): APIChoice[] | undefined {
		const remainingPrefix = this.getRemainingPrefix(prefix, suffix);
		if (remainingPrefix === undefined) { return; }
		// If the first choice text does not match return empty to fall through
		// to either the cache or network.
		if (!startsWithAndExceeds(this.choices[0].completionText, remainingPrefix)) { return; }
		return adjustChoicesStart(this.choices, remainingPrefix);
	}

  ...

}


@line:100
/** Returns choices adjusted to remove the remainingPrefix from the start of the
 * completionText if it matches. */
function adjustChoicesStart(choices: APIChoice[], remainingPrefix: string): APIChoice[] {
	return choices
		.filter(choice => startsWithAndExceeds(choice.completionText, remainingPrefix))
		.map(choice => ({
			...choice,
			completionText: choice.completionText.substring(remainingPrefix.length),
		}));
}

/** Returns true if `prefix` is a prefix of `text` and `text` is longer. */
function startsWithAndExceeds(text: string, prefix: string) {
	return text.startsWith(prefix) && text.length > prefix.length;
}