feat: add user-friendly way to toggle between FIM and next edit

core/autocomplete/CompletionProvider.ts

@@ -215,12 +215,6 @@ export class CompletionProvider {
         const multiline =
           !helper.options.transform || shouldCompleteMultiline(helper);
 
-        const rawGeneration = await llm.complete(
-          prompt,
-          token,
-          completionOptions,
-        );
-
         const completionStream =
           this.completionStreamer.streamCompletionWithFilters(
             token,

core/config/loadLocalAssistants.ts

@@ -35,7 +35,11 @@ async function getDefinitionFilesInDir(
     }
 
     const overrideDefaultIgnores = ignore()
-      .add(DEFAULT_IGNORE_FILETYPES.filter((t) => t !== "config.yaml"))
+      .add(
+        DEFAULT_IGNORE_FILETYPES.filter(
+          (t) => t !== "config.yaml" && t !== "config.yml",
+        ),
+      )
       .add(DEFAULT_IGNORE_DIRS);
 
     const uris = await walkDir(dir, ide, {

core/config/loadLocalAssistants.vitest.ts

@@ -18,6 +18,8 @@ describe("ASSISTANTS getAllDotContinueDefinitionFiles with fileExtType option",
       [".continue/assistants/assistant2.yml", "yaml content 2"],
       [".continue/assistants/assistant3.md", "markdown content 1"],
       [".continue/assistants/assistant4.txt", "txt content"],
+      [".continue/assistants/config.yaml", "txt content"],
+      [".continue/assistants/config.yml", "txt content"],
     ]);
   });
 
@@ -38,9 +40,14 @@ describe("ASSISTANTS getAllDotContinueDefinitionFiles with fileExtType option",
       options,
       "assistants",
     );
-    expect(result).toHaveLength(2);
+    expect(result).toHaveLength(4);
     expect(result.map((f) => f.path.split("/").pop())).toEqual(
-      expect.arrayContaining(["assistant1.yaml", "assistant2.yml"]),
+      expect.arrayContaining([
+        "assistant1.yaml",
+        "assistant2.yml",
+        "config.yaml",
+        "config.yml",
+      ]),
     );
     expect(result.map((f) => f.path.split("/").pop())).not.toContain(
       "assistant3.md",
@@ -69,6 +76,12 @@ describe("ASSISTANTS getAllDotContinueDefinitionFiles with fileExtType option",
     expect(result.map((f) => f.path.split("/").pop())).not.toContain(
       "assistant2.yml",
     );
+    expect(result.map((f) => f.path.split("/").pop())).not.toContain(
+      "config.yml",
+    );
+    expect(result.map((f) => f.path.split("/").pop())).not.toContain(
+      "config.yaml",
+    );
   });
 
   it("should return all supported files when fileExtType is not specified", async () => {
@@ -83,11 +96,13 @@ describe("ASSISTANTS getAllDotContinueDefinitionFiles with fileExtType option",
       options,
       "assistants",
     );
-    expect(result).toHaveLength(3);
+    expect(result).toHaveLength(5);
     expect(result.map((f) => f.path.split("/").pop())).toEqual(
       expect.arrayContaining([
         "assistant1.yaml",
         "assistant2.yml",
+        "config.yml",
+        "config.yaml",
         "assistant3.md",
       ]),
     );
@@ -124,9 +139,14 @@ describe("ASSISTANTS getAllDotContinueDefinitionFiles with fileExtType option",
       workspaceOnOptions,
       "assistants",
     );
-    expect(workspaceResult).toHaveLength(2);
+    expect(workspaceResult).toHaveLength(4);
     expect(workspaceResult.map((f) => f.path.split("/").pop())).toEqual(
-      expect.arrayContaining(["assistant1.yaml", "assistant2.yml"]),
+      expect.arrayContaining([
+        "assistant1.yaml",
+        "assistant2.yml",
+        "config.yaml",
+        "config.yml",
+      ]),
     );
   });
 
@@ -187,7 +207,7 @@ describe("ASSISTANTS getAllDotContinueDefinitionFiles with fileExtType option",
       options,
       "assistants",
     );
-    expect(result).toHaveLength(2);
+    expect(result).toHaveLength(4);
     const yamlFile = result.find((f) => f.path.includes("assistant1.yaml"));
     expect(yamlFile?.content).toBe("yaml content 1");
   });
@@ -212,9 +232,14 @@ describe("ASSISTANTS getAllDotContinueDefinitionFiles with fileExtType option",
       "assistants",
     );
     // Should only get lowercase extensions (current implementation)
-    expect(yamlResult).toHaveLength(2);
+    expect(yamlResult).toHaveLength(4);
     expect(yamlResult.map((f) => f.path.split("/").pop())).toEqual(
-      expect.arrayContaining(["assistant1.yaml", "assistant2.yml"]),
+      expect.arrayContaining([
+        "assistant1.yaml",
+        "assistant2.yml",
+        "config.yaml",
+        "config.yml",
+      ]),
     );
     expect(yamlResult.map((f) => f.path.split("/").pop())).not.toContain(
       "assistant5.YAML",

core/nextEdit/NextEditLoggingService.ts

@@ -11,6 +11,16 @@ export class NextEditLoggingService {
   private _abortControllers = new Map<string, AbortController>();
   private _logRejectionTimeouts = new Map<string, NodeJS.Timeout>();
   private _outcomes = new Map<string, NextEditOutcome>();
+  // Track minimal data for completions that get aborted before we have full outcome.
+  private _pendingCompletions = new Map<
+    string,
+    {
+      startTime: number;
+      modelName?: string;
+      modelProvider?: string;
+      filepath?: string;
+    }
+  >();
   _lastDisplayedCompletion: { id: string; displayedAt: number } | undefined =
     undefined;
 
@@ -26,35 +36,71 @@ export class NextEditLoggingService {
   public createAbortController(completionId: string): AbortController {
     const abortController = new AbortController();
     this._abortControllers.set(completionId, abortController);
+    this.trackPendingCompletion(completionId);
     return abortController;
   }
 
   public deleteAbortController(completionId: string) {
     this._abortControllers.delete(completionId);
+    this._pendingCompletions.delete(completionId);
+  }
+
+  // Keep track of a new completion request.
+  public trackPendingCompletion(completionId: string) {
+    this._pendingCompletions.set(completionId, {
+      startTime: Date.now(),
+    });
+  }
+
+  // Update pending completion info as it becomes available.
+  public updatePendingCompletion(
+    completionId: string,
+    data: {
+      modelName?: string;
+      modelProvider?: string;
+      filepath?: string;
+    },
+  ) {
+    const pending = this._pendingCompletions.get(completionId);
+    if (pending) {
+      this._pendingCompletions.set(completionId, { ...pending, ...data });
+    } else {
+      // If we haven't tracked it yet, create new entry with provided data.
+      this._pendingCompletions.set(completionId, {
+        startTime: Date.now(),
+        ...data,
+      });
+    }
   }
 
   public cancel() {
-    this._abortControllers.forEach((abortController, id) => {
+    this._abortControllers.forEach((abortController, completionId) => {
+      this.handleAbort(completionId);
       abortController.abort();
     });
     this._abortControllers.clear();
   }
 
   public accept(completionId: string): NextEditOutcome | undefined {
+    this._pendingCompletions.delete(completionId);
+
     if (this._logRejectionTimeouts.has(completionId)) {
       clearTimeout(this._logRejectionTimeouts.get(completionId));
       this._logRejectionTimeouts.delete(completionId);
     }
     if (this._outcomes.has(completionId)) {
       const outcome = this._outcomes.get(completionId)!;
       outcome.accepted = true;
+      outcome.aborted = false;
       this.logNextEditOutcome(outcome);
       this._outcomes.delete(completionId);
       return outcome;
     }
   }
 
   public reject(completionId: string): NextEditOutcome | undefined {
+    this._pendingCompletions.delete(completionId);
+
     if (this._logRejectionTimeouts.has(completionId)) {
       clearTimeout(this._logRejectionTimeouts.get(completionId));
       this._logRejectionTimeouts.delete(completionId);
@@ -63,6 +109,7 @@ export class NextEditLoggingService {
     if (this._outcomes.has(completionId)) {
       const outcome = this._outcomes.get(completionId)!;
       outcome.accepted = false;
+      outcome.aborted = false;
       this.logNextEditOutcome(outcome);
       this._outcomes.delete(completionId);
       return outcome;
@@ -86,12 +133,19 @@ export class NextEditLoggingService {
   }
 
   public markDisplayed(completionId: string, outcome: NextEditOutcome) {
+    // Remove from pending since we now have full data.
+    this._pendingCompletions.delete(completionId);
+    outcome.aborted = false;
+
     const logRejectionTimeout = setTimeout(() => {
       // Wait 10 seconds, then assume it wasn't accepted
       outcome.accepted = false;
+      outcome.aborted = false;
       this.logNextEditOutcome(outcome);
       this._logRejectionTimeouts.delete(completionId);
+      this._outcomes.delete(completionId);
     }, COUNT_COMPLETION_REJECTED_AFTER);
+
     this._outcomes.set(completionId, outcome);
     this._logRejectionTimeouts.set(completionId, logRejectionTimeout);
 
@@ -124,7 +178,62 @@ export class NextEditLoggingService {
     };
   }
 
+  public handleAbort(completionId: string) {
+    // Clear any pending rejection timeout.
+    if (this._logRejectionTimeouts.has(completionId)) {
+      clearTimeout(this._logRejectionTimeouts.get(completionId));
+      this._logRejectionTimeouts.delete(completionId);
+    }
+
+    // If we have the full outcome, log it as aborted.
+    if (this._outcomes.has(completionId)) {
+      const outcome = this._outcomes.get(completionId)!;
+      outcome.accepted = false;
+      outcome.aborted = true;
+      this.logNextEditOutcome(outcome);
+      this._outcomes.delete(completionId);
+    } else {
+      // Log minimal abort event for requests that never got displayed.
+      const pendingData = this._pendingCompletions.get(completionId);
+
+      const minimalAbortOutcome: Partial<NextEditOutcome> = {
+        completionId,
+        accepted: false,
+        aborted: true,
+        timestamp: Date.now(),
+        uniqueId: completionId,
+        elapsed: pendingData ? Date.now() - pendingData.startTime : 0,
+        modelName: pendingData?.modelName || "unknown",
+        modelProvider: pendingData?.modelProvider || "unknown",
+        fileUri: pendingData?.filepath || "unknown",
+
+        // Empty/default values for fields we don't have.
+        completion: "",
+        prompt: "",
+        userEdits: "",
+        userExcerpts: "",
+        originalEditableRange: "",
+        workspaceDirUri: "",
+        cursorPosition: { line: -1, character: -1 },
+        finalCursorPosition: { line: -1, character: -1 },
+        editableRegionStartLine: -1,
+        editableRegionEndLine: -1,
+        diffLines: [],
+        completionOptions: {},
+      };
+
+      this.logNextEditOutcome(minimalAbortOutcome as NextEditOutcome);
+    }
+
+    // Clean up.
+    this._pendingCompletions.delete(completionId);
+  }
+
   private logNextEditOutcome(outcome: NextEditOutcome) {
+    if (outcome.aborted === undefined) {
+      outcome.aborted = false;
+    }
+
     void DataLogger.getInstance().logDevData({
       name: "nextEditOutcome",
       data: outcome,

core/nextEdit/NextEditProvider.ts

@@ -311,7 +311,11 @@ export class NextEditProvider {
         input.completionId,
       );
       token = controller.signal;
+    } else {
+      // Token was provided externally, just track the completion.
+      this.loggingService.trackPendingCompletion(input.completionId);
     }
+
     const startTime = Date.now();
     const options = await this._getAutocompleteOptions();
 
@@ -325,6 +329,13 @@ export class NextEditProvider {
       return { token, startTime, helper: undefined };
     }
 
+    // Update pending completion with model info.
+    this.loggingService.updatePendingCompletion(input.completionId, {
+      modelName: llm.model,
+      modelProvider: llm.providerName,
+      filepath: input.filepath,
+    });
+
     // Check model capabilities
     if (!modelSupportsNextEdit(llm.capabilities, llm.model, llm.title)) {
       console.error(`${llm.model} is not capable of next edit.`);

core/nextEdit/providers/BaseNextEditProvider.ts

@@ -298,7 +298,7 @@ export abstract class BaseNextEditProvider {
     return {
       elapsed: Date.now() - outcomeCtx.startTime,
       modelProvider: outcomeCtx.llm.underlyingProviderName,
-      modelName: outcomeCtx.llm.model + ":zetaDataset",
+      modelName: outcomeCtx.llm.model,
       completionOptions: null,
       completionId:
         outcomeCtx.completionId || outcomeCtx.helper.input.completionId,

core/nextEdit/types.ts

@@ -63,6 +63,7 @@ export interface NextEditOutcome extends TabAutocompleteOptions {
   cursorPosition: { line: number; character: number };
   finalCursorPosition: { line: number; character: number };
   accepted?: boolean;
+  aborted?: boolean;
   editableRegionStartLine: number;
   editableRegionEndLine: number;
   diffLines: DiffLine[];