diff --git a/.continue/rules/typescript-enum-usage.md b/.continue/rules/typescript-enum-usage.md
new file mode 100644
index 00000000000..34728c1d5af
--- /dev/null
+++ b/.continue/rules/typescript-enum-usage.md
@@ -0,0 +1,6 @@
+---
+globs: "**/*.{ts,tsx}"
+alwaysApply: false
+---
+
+Use enums instead of simple string unions when possible in TypeScript code
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 2497e28dc9c..348566cd889 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -8,9 +8,9 @@
 - [] The relevant docs, if any, have been updated or created
 - [] The relevant tests, if any, have been updated or created
 
-## Screenshots
+## Screen recording or screenshot
 
-[ For visual changes, include screenshots. Screen recordings are particularly helpful, and appreciated! ]
+[ When applicable, please include a short screen recording or screenshot - this makes it much easier for us as contributors to review and understand your changes. See [this PR](https://github.com/continuedev/continue/pull/6455) as a good example. ]
 
 ## Tests
 
diff --git a/.github/workflows/jetbrains-release.yaml b/.github/workflows/jetbrains-release.yaml
index 956d249c4c0..531129c790b 100644
--- a/.github/workflows/jetbrains-release.yaml
+++ b/.github/workflows/jetbrains-release.yaml
@@ -63,7 +63,6 @@ jobs:
 
       - name: Bump version in gradle.properties
         run: |
-          cd extensions/intellij
           awk '/pluginVersion=/{split($0,a,"="); split(a[2],b,"."); b[3]+=1; printf "%s=%s.%s.%s\n",a[1],b[1],b[2],b[3];next}1' gradle.properties > tmp && mv tmp gradle.properties
           rm -rf tmp
           NEW_VERSION=$(grep 'pluginVersion=' gradle.properties | cut -d'=' -f2)
@@ -224,10 +223,6 @@ jobs:
       #     apple-product-id: dev.continue.continue-binary
       #     options: --options runtime --entitlements entitlements.xml
 
-      # Build plugin
-      - name: Build plugin
-        run: ./gradlew buildPlugin
-
       # Publish the plugin to JetBrains Marketplace
       - name: Publish EAP Plugin
         if: github.event_name == 'release' || github.event.inputs.publish_build == 'true'
@@ -237,7 +232,7 @@ jobs:
           PRIVATE_KEY: ${{ secrets.JETBRAINS_PRIVATE_KEY }}
           PRIVATE_KEY_PASSWORD: ${{ secrets.JETBRAINS_PRIVATE_KEY_PASSWORD }}
           RELEASE_CHANNEL: eap
-        run: ./gradlew publishPlugin
+        run: ./gradlew publishPlugin --info --stacktrace
 
       - name: Publish Stable Plugin
         if: github.event_name == 'release' || github.event.inputs.publish_build == 'true'
@@ -247,7 +242,7 @@ jobs:
           PRIVATE_KEY: ${{ secrets.JETBRAINS_PRIVATE_KEY }}
           PRIVATE_KEY_PASSWORD: ${{ secrets.JETBRAINS_PRIVATE_KEY_PASSWORD }}
           RELEASE_CHANNEL: default
-        run: ./gradlew publishPlugin
+        run: ./gradlew publishPlugin --info --stacktrace
 
       # Prepare plugin archive content for creating artifact
       - name: Prepare Plugin Artifact
diff --git a/.github/workflows/pr_checks.yaml b/.github/workflows/pr_checks.yaml
index 2deffe08fb9..e3d8be5e4b8 100644
--- a/.github/workflows/pr_checks.yaml
+++ b/.github/workflows/pr_checks.yaml
@@ -53,7 +53,10 @@ jobs:
 
   install-config-yaml:
     needs: install-root
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
     steps:
       - uses: actions/checkout@v4
 
@@ -80,7 +83,10 @@ jobs:
 
   install-openai-adapters:
     needs: install-root
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
     steps:
       - uses: actions/checkout@v4
 
@@ -136,7 +142,10 @@ jobs:
 
   install-core:
     needs: install-root
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
     steps:
       - uses: actions/checkout@v4
 
@@ -384,7 +393,10 @@ jobs:
   install-vscode:
     needs:
       [install-root, install-core, install-config-yaml, install-openai-adapters]
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
     steps:
       - uses: actions/checkout@v4
 
@@ -666,7 +678,10 @@ jobs:
           echo "Test files: ${{ steps.vscode-get-test-file-matrix.outputs.test_file_matrix }}"
 
   vscode-package-extension:
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
     needs:
       [
         install-vscode,
@@ -723,7 +738,7 @@ jobs:
       - name: Upload build artifact
         uses: actions/upload-artifact@v4
         with:
-          name: vscode-extension-build
+          name: vscode-extension-build-${{ runner.os }}
           path: extensions/vscode/build
 
   vscode-download-e2e-dependencies:
@@ -820,7 +835,7 @@ jobs:
       - name: Download build artifact
         uses: actions/download-artifact@v4
         with:
-          name: vscode-extension-build
+          name: vscode-extension-build-Linux
           path: extensions/vscode/build
 
       - name: Download e2e dependencies
diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index c277e816e3b..324ac997a1b 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -5,7 +5,7 @@
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
         <option name="externalProjectPath" value="$PROJECT_DIR$/extensions/intellij" />
-        <option name="gradleJvm" value="homebrew-17" />
+        <option name="gradleJvm" value="#JAVA_HOME" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$/extensions/intellij" />
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 6d89e465518..9824071c127 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -192,6 +192,7 @@ To keep the Continue codebase clean and maintainable, we expect the following fr
 - Keep changes focused. Multiple unrelated fixes should be opened as separate PRs
 - Write or update tests for new functionality
 - Update relevant documentation in the `docs` folder
+- **For new features**: Include a short screen recording or screenshot demonstrating the new functionality. This makes it much easier for us as contributors to review and understand your changes. See [this PR](https://github.com/continuedev/continue/pull/6455) as a good example
 - Open a PR against the `main` branch. Make sure to fill in the PR template
 
 ### Formatting
diff --git a/core/autocomplete/CompletionProvider.ts b/core/autocomplete/CompletionProvider.ts
index e6111a5086f..0d974e31721 100644
--- a/core/autocomplete/CompletionProvider.ts
+++ b/core/autocomplete/CompletionProvider.ts
@@ -10,7 +10,7 @@ import { BracketMatchingService } from "./filtering/BracketMatchingService.js";
 import { CompletionStreamer } from "./generation/CompletionStreamer.js";
 import { postprocessCompletion } from "./postprocessing/index.js";
 import { shouldPrefilter } from "./prefiltering/index.js";
-import { getAllSnippets } from "./snippets/index.js";
+import { getAllSnippetsWithoutRace } from "./snippets/index.js";
 import { renderPrompt } from "./templating/index.js";
 import { GetLspDefinitionsFunction } from "./types.js";
 import { AutocompleteDebouncer } from "./util/AutocompleteDebouncer.js";
@@ -121,6 +121,12 @@ export class CompletionProvider {
       ...config?.tabAutocompleteOptions,
       ...llm.autocompleteOptions,
     };
+
+    // Enable static contextualization if defined.
+    if (config?.experimental?.enableStaticContextualization) {
+      options.experimental_enableStaticContextualization = true;
+    }
+
     return options;
   }
 
@@ -171,7 +177,7 @@ export class CompletionProvider {
       }
 
       const [snippetPayload, workspaceDirs] = await Promise.all([
-        getAllSnippets({
+        getAllSnippetsWithoutRace({
           helper,
           ide: this.ide,
           getDefinitionsFromLsp: this.getDefinitionsFromLsp,
@@ -258,6 +264,10 @@ export class CompletionProvider {
         ...helper.options,
       };
 
+      if (options.experimental_enableStaticContextualization) {
+        outcome.enabledStaticContextualization = true;
+      }
+
       //////////
 
       // Save to cache
diff --git a/core/autocomplete/context/ContextRetrievalService.ts b/core/autocomplete/context/ContextRetrievalService.ts
index f521d292ad6..e7e9e60a467 100644
--- a/core/autocomplete/context/ContextRetrievalService.ts
+++ b/core/autocomplete/context/ContextRetrievalService.ts
@@ -2,16 +2,19 @@ import { IDE } from "../..";
 import {
   AutocompleteCodeSnippet,
   AutocompleteSnippetType,
+  AutocompleteStaticSnippet,
 } from "../snippets/types";
 import { HelperVars } from "../util/HelperVars";
 
 import { ImportDefinitionsService } from "./ImportDefinitionsService";
 import { getSymbolsForSnippet } from "./ranking";
 import { RootPathContextService } from "./root-path-context/RootPathContextService";
+import { StaticContextService } from "./static-context/StaticContextService";
 
 export class ContextRetrievalService {
   private importDefinitionsService: ImportDefinitionsService;
   private rootPathContextService: RootPathContextService;
+  private staticContextService: StaticContextService;
 
   constructor(private readonly ide: IDE) {
     this.importDefinitionsService = new ImportDefinitionsService(this.ide);
@@ -19,6 +22,7 @@ export class ContextRetrievalService {
       this.importDefinitionsService,
       this.ide,
     );
+    this.staticContextService = new StaticContextService(this.ide);
   }
 
   public async getSnippetsFromImportDefinitions(
@@ -71,6 +75,12 @@ export class ContextRetrievalService {
     );
   }
 
+  public async getStaticContextSnippets(
+    helper: HelperVars,
+  ): Promise<AutocompleteStaticSnippet[]> {
+    return this.staticContextService.getContext(helper);
+  }
+
   /**
    * Initialize the import definitions cache for a file.
    * This is normally done automatically when the active text editor changes,
diff --git a/core/autocomplete/context/static-context/StaticContextService.ts b/core/autocomplete/context/static-context/StaticContextService.ts
new file mode 100644
index 00000000000..b955a38ff4c
--- /dev/null
+++ b/core/autocomplete/context/static-context/StaticContextService.ts
@@ -0,0 +1,888 @@
+import * as fs from "fs/promises";
+import path from "path";
+import { pathToFileURL } from "url";
+import Parser from "web-tree-sitter";
+import { IDE, Position } from "../../..";
+import { localPathOrUriToPath } from "../../../util/pathToUri";
+import { getFullLanguageName, getQueryForFile } from "../../../util/treeSitter";
+import {
+  AutocompleteSnippetType,
+  AutocompleteStaticSnippet,
+} from "../../snippets/types";
+import { getAst } from "../../util/ast";
+import { HelperVars } from "../../util/HelperVars";
+import {
+  extractFunctionTypeFromDecl,
+  extractTopLevelDecls,
+  findEnclosingTypeDeclaration,
+  unwrapToBaseType,
+} from "./tree-sitter-utils";
+import {
+  HoleContext,
+  RelevantHeaders,
+  RelevantTypes,
+  StaticContext,
+  TypeSpanAndSourceFile,
+  TypeSpanAndSourceFileAndAst,
+} from "./types";
+
+export class StaticContextService {
+  private readonly ide: IDE;
+
+  constructor(ide: IDE) {
+    this.ide = ide;
+  }
+
+  public logAutocompleteStaticSnippet(
+    ctx: StaticContext,
+    label = "Static Snippet",
+  ) {
+    console.log(`=== ${label} ===`);
+    console.log("Hole Type:", ctx.holeType);
+
+    console.log(`\nRelevant Types (${ctx.relevantTypes.size} files):`);
+    ctx.relevantTypes.forEach((types, filepath) => {
+      console.log(`  📁 ${filepath}`);
+      types.forEach((type) => console.log(`    • ${type}`));
+    });
+
+    console.log(`\nRelevant Headers (${ctx.relevantHeaders.size} files):`);
+    ctx.relevantHeaders.forEach((headers, filepath) => {
+      console.log(`  📁 ${filepath}`);
+      headers.forEach((header) => console.log(`    • ${header}`));
+    });
+  }
+
+  public static formatAutocompleteStaticSnippet(ctx: StaticContext): string {
+    let output = `AutocompleteStaticSnippet:\n`;
+    output += `  holeType: ${ctx.holeType}\n`;
+
+    output += `  relevantTypes:\n`;
+    if (ctx.relevantTypes.size === 0) {
+      output += `    (none)\n`;
+    } else {
+      ctx.relevantTypes.forEach((types, filepath) => {
+        output += `    ${filepath}: [${types.join(", ")}]\n`;
+      });
+    }
+
+    output += `  relevantHeaders:\n`;
+    if (ctx.relevantHeaders.size === 0) {
+      output += `    (none)\n`;
+    } else {
+      ctx.relevantHeaders.forEach((headers, filepath) => {
+        output += `    ${filepath}: [${headers.join(", ")}]\n`;
+      });
+    }
+
+    return output;
+  }
+
+  public async getContext(
+    helper: HelperVars,
+  ): Promise<AutocompleteStaticSnippet[]> {
+    const start = Date.now();
+    const tsFiles = await this.getTypeScriptFilesFromWorkspaces(
+      helper.workspaceUris,
+    );
+    // Get the three contexts holeContext, relevantTypes, relevantHeaders.
+    const holeContext = await this.getHoleContext(
+      helper.fileContents,
+      helper.filepath,
+      helper.pos,
+    );
+
+    const relevantTypes = await this.extractRelevantTypes(
+      holeContext.fullHoverResult,
+      holeContext.functionName,
+      holeContext.range.start.line,
+      holeContext.source,
+      new Map<string, string>(),
+    );
+
+    // if (this.language === "typescript") {
+    //   repo = getAllTSFiles(this.repoPath);
+    // } else if (this.language === "ocaml") {
+    //   repo = getAllOCamlFiles(this.repoPath);
+    // }
+    //
+
+    const relevantHeaders = await this.extractRelevantHeaders(
+      tsFiles,
+      relevantTypes,
+      holeContext.functionTypeSpan,
+      helper.pos,
+      holeContext.returnTypeIsAny,
+    );
+
+    const relevantTypesToReturn: Map<string, string[]> = new Map<
+      string,
+      string[]
+    >();
+    relevantTypes.forEach(({ typeSpan: v, sourceFile: src }, _) => {
+      if (relevantTypesToReturn.has(src)) {
+        const updated = relevantTypesToReturn.get(src)!;
+        updated.push(v);
+        relevantTypesToReturn.set(src, updated);
+      } else {
+        relevantTypesToReturn.set(src, [v]);
+      }
+    });
+
+    const relevantHeadersToReturn: Map<string, string[]> = new Map<
+      string,
+      string[]
+    >();
+    relevantHeaders.forEach(({ typeSpan: v, sourceFile: src }) => {
+      if (relevantHeadersToReturn.has(src)) {
+        const updated = relevantHeadersToReturn.get(src)!;
+        if (!updated.includes(v)) {
+          updated.push(v);
+        }
+        relevantHeadersToReturn.set(src, updated);
+      } else {
+        relevantHeadersToReturn.set(src, [v]);
+      }
+    });
+
+    const ctx = {
+      holeType: holeContext.functionTypeSpan,
+      relevantTypes: relevantTypesToReturn,
+      relevantHeaders: relevantHeadersToReturn,
+    };
+    const end = Date.now();
+
+    this.logAutocompleteStaticSnippet(ctx);
+
+    // console.log(end - start);
+
+    const snippets: AutocompleteStaticSnippet[] = [];
+
+    snippets.push({
+      type: AutocompleteSnippetType.Static,
+      filepath: pathToFileURL(path.resolve(holeContext.source)).toString(),
+      content: holeContext.fullHoverResult,
+    });
+
+    for (const [filepath, typs] of ctx.relevantTypes.entries()) {
+      snippets.push({
+        type: AutocompleteSnippetType.Static,
+        filepath: pathToFileURL(path.resolve(filepath)).toString(),
+        content: typs.join("\n"),
+      });
+    }
+
+    for (const [filepath, headers] of ctx.relevantHeaders.entries()) {
+      snippets.push({
+        type: AutocompleteSnippetType.Static,
+        filepath: pathToFileURL(path.resolve(filepath)).toString(),
+        content: headers.join("\n"),
+      });
+    }
+
+    return snippets;
+  }
+
+  private async getHoleContext(
+    sketchFileContent: string,
+    sketchFilePath: string,
+    cursorPosition: Position,
+  ): Promise<HoleContext> {
+    // We need to inject the hole @ to trigger a treesitter error node.
+    sketchFilePath = localPathOrUriToPath(sketchFilePath);
+    // const sketchFileContent = await fs.readFile(sketchFilePath, "utf8");
+    const injectedContent = this.insertAtPosition(
+      sketchFileContent,
+      cursorPosition,
+      "@;",
+    );
+
+    // The hole's position is cursorPosition.
+
+    // Use treesitter to parse.
+    const ast = await getAst(sketchFilePath, injectedContent);
+    if (!ast) {
+      throw new Error("failed to get ast");
+    }
+    const language = getFullLanguageName(sketchFilePath);
+    const query = await getQueryForFile(
+      sketchFilePath,
+      `static-context-queries/hole-queries/${language}.scm`,
+    );
+    if (!query) {
+      throw new Error(
+        `getHoleContext: failed to get query for file ${sketchFilePath} and language ${language}`,
+      );
+    }
+
+    const captures = query.captures(ast.rootNode);
+    const res: HoleContext = {
+      fullHoverResult: "",
+      functionName: "",
+      functionTypeSpan: "",
+      returnTypeIsAny: false,
+      range: {
+        start: { line: 0, character: 0 },
+        end: { line: 0, character: 0 },
+      },
+      source: `file://${sketchFilePath}`,
+    };
+    let paramsTypes = "";
+    for (const c of captures) {
+      const { name, node } = c;
+      // console.log(`${name} →`, node.text, node.startPosition, node.endPosition);
+
+      switch (name) {
+        case "function.decl": {
+          res.fullHoverResult = node.text;
+          break;
+        }
+        case "function.name": {
+          res.functionName = node.text;
+          break;
+        }
+        case "function.params": {
+          paramsTypes = node.text;
+          res.range = {
+            start: {
+              line: node.startPosition.row,
+              character: node.startPosition.column,
+            },
+            end: {
+              line: node.endPosition.row,
+              character: node.endPosition.column,
+            },
+          };
+          break;
+        }
+        case "function.type": {
+          res.functionTypeSpan = node.text;
+          res.range = {
+            start: {
+              line: node.startPosition.row,
+              character: node.startPosition.column,
+            },
+            end: {
+              line: node.endPosition.row,
+              character: node.endPosition.column,
+            },
+          };
+          break;
+        }
+      }
+    }
+
+    if (res.functionTypeSpan === "") {
+      res.functionTypeSpan = `${paramsTypes} => any`;
+      res.returnTypeIsAny = true;
+    }
+
+    return res;
+  }
+
+  private async extractRelevantTypes(
+    declText: string,
+    typeName: string,
+    startLine: number,
+    currentFile: string,
+    foundContents: Map<string, string>, // uri -> contents
+  ): Promise<RelevantTypes> {
+    const foundSoFar = new Map<string, TypeSpanAndSourceFileAndAst>(); // identifier -> [full hover result, source]
+
+    await this.extractRelevantTypesHelper(
+      declText,
+      typeName,
+      startLine,
+      foundSoFar,
+      currentFile,
+      foundContents,
+    );
+
+    return foundSoFar;
+  }
+
+  private async extractRelevantTypesHelper(
+    declText: string,
+    typeName: string,
+    startLine: number,
+    foundSoFar: Map<string, TypeSpanAndSourceFileAndAst>, // identifier -> [full hover result, source]
+    currentFile: string,
+    foundContents: Map<string, string>, // uri -> contents
+  ) {
+    if (!foundSoFar.has(typeName)) {
+      const ast = await getAst(currentFile, declText);
+      if (!ast) {
+        throw new Error(`failed to get ast for file ${currentFile}`);
+      }
+      foundSoFar.set(typeName, {
+        typeSpan: declText,
+        sourceFile: currentFile.slice(7),
+        ast: ast,
+      });
+
+      const language = getFullLanguageName(currentFile);
+      const query = await getQueryForFile(
+        currentFile,
+        `static-context-queries/relevant-types-queries/${language}-extract-identifiers.scm`,
+      );
+      if (!query) {
+        throw new Error(
+          `failed to get query for file ${currentFile} and language ${language}`,
+        );
+      }
+
+      const identifiers = query.captures(ast.rootNode);
+
+      for (const { name, node } of identifiers) {
+        if (foundSoFar.has(node.text)) continue;
+
+        try {
+          const typeDefinitionResult = await this.ide.gotoTypeDefinition({
+            filepath: currentFile,
+            position: {
+              character: node.startPosition.column,
+              line: startLine + node.startPosition.row,
+            },
+          });
+
+          if (typeDefinitionResult.length > 0) {
+            const tdLocation = typeDefinitionResult[0];
+
+            let content = "";
+
+            if (foundContents.has(tdLocation.filepath)) {
+              content = foundContents.get(tdLocation.filepath)!;
+            } else {
+              content = await fs.readFile(
+                localPathOrUriToPath(tdLocation.filepath),
+                "utf8",
+              );
+              foundContents.set(tdLocation.filepath, content);
+            }
+
+            const ast = await getAst(tdLocation.filepath, content);
+            if (!ast) {
+              throw new Error(
+                `failed to get ast for file ${tdLocation.filepath}`,
+              );
+            }
+            const decl = findEnclosingTypeDeclaration(
+              content,
+              tdLocation.range.start.line,
+              tdLocation.range.start.character,
+              ast,
+            );
+            if (!decl) {
+              // throw new Error(`failed to get decl for file ${tdLocation.uri}`);
+              console.error(
+                `failed to get decl for file ${tdLocation.filepath}`,
+              );
+            }
+
+            if (decl) {
+              await this.extractRelevantTypesHelper(
+                decl.fullText,
+                node.text,
+                tdLocation.range.start.line,
+                foundSoFar,
+                tdLocation.filepath,
+                foundContents,
+              );
+            } else {
+              // console.log("decl not found");
+            }
+          } else {
+            // console.log("td not found");
+          }
+        } catch (err) {
+          console.log(err);
+        }
+      }
+    }
+  }
+
+  private async extractRelevantHeaders(
+    sources: string[],
+    relevantTypes: Map<string, TypeSpanAndSourceFileAndAst>,
+    holeType: string,
+    cursorPosition: Position,
+    returnTypeIsAny: boolean,
+  ): Promise<RelevantHeaders> {
+    const relevantContext = new Set<TypeSpanAndSourceFile>();
+    if (returnTypeIsAny) return relevantContext;
+    // NOTE: This is necessary because TypeScript sucks.
+    // There is no way to compare objects by value,
+    // so sets of objects starts to accumulate tons of duplicates.
+    const relevantContextMap = new Map<string, TypeSpanAndSourceFile>();
+    const foundNormalForms = new Map<string, string>();
+
+    const targetTypes = await this.generateTargetTypes(relevantTypes, holeType);
+
+    for (const source of sources) {
+      const topLevelDecls = await extractTopLevelDecls(source);
+      for (const tld of topLevelDecls) {
+        // pattern 0 is let/const, 1 is var, 2 is fun
+        // if (!seenDecls.has(JSON.stringify()) {
+        const originalDeclText =
+          tld.pattern === 2
+            ? tld.captures.find((d) => d.name === "top.fn.decl")!.node.text
+            : tld.captures.find((d) => d.name === "top.var.decl")!.node.text;
+
+        if (tld.pattern === 2) {
+          // build a type span
+          // TODO: this fails sometimes with Cannot read properties of undefined (reading 'text')
+          // most likely due to my scm query and how I'm not attaching param name along with param type
+          let funcType = "";
+          try {
+            funcType = extractFunctionTypeFromDecl(tld);
+          } catch (err) {
+            // Most likely is the case that there is no explicit return type annotation.
+            const sigHelp = await this.ide.getSignatureHelp({
+              filepath: source,
+              position: cursorPosition,
+            });
+            if (!sigHelp) continue;
+            funcType = sigHelp.signatures[0].label;
+
+            // TODO: This only works for TypeScript.
+            function convertToArrowType(signature: string): string {
+              // Handle various function declaration formats.
+              const patterns = [
+                // Standard: functionName(params): returnType.
+                /^(\w+)\s*\((.*?)\)\s*:\s*(.+)$/,
+                // With generics: functionName<T>(params): returnType.
+                /^(\w+)\s*<[^>]*>\s*\((.*?)\)\s*:\s*(.+)$/,
+                // With modifiers: export function functionName(params): returnType.
+                /^(?:export\s+)?(?:function\s+)?(\w+)\s*\((.*?)\)\s*:\s*(.+)$/,
+              ];
+
+              for (const pattern of patterns) {
+                const match = signature.match(pattern);
+                if (match) {
+                  const [, , parameters, returnType] = match;
+                  return `(${parameters}) => ${returnType}`;
+                }
+              }
+
+              return signature;
+            }
+
+            funcType = convertToArrowType(funcType);
+          }
+          const wrapped = `type __TMP = ${funcType};`;
+
+          const ast = await getAst("file.ts", wrapped);
+          if (!ast) {
+            throw new Error(`failed to generate ast for ${wrapped}`);
+          }
+
+          // console.log(ast.rootNode);
+          const alias = ast.rootNode.namedChild(0);
+          // console.log(alias);
+          if (!alias || alias.type !== "type_alias_declaration") {
+            throw new Error(
+              "extractRelevantHeaders: Failed to parse type alias",
+            );
+          }
+
+          const valueNode = alias.childForFieldName("value");
+          if (!valueNode) throw new Error("No type value found");
+
+          const baseNode = unwrapToBaseType(valueNode);
+
+          await this.extractRelevantHeadersHelper(
+            originalDeclText,
+            baseNode,
+            targetTypes,
+            relevantTypes,
+            relevantContext,
+            relevantContextMap,
+            foundNormalForms,
+            source,
+          );
+        } else {
+          const varTypNode = tld.captures.find(
+            (d) => d.name === "top.var.type",
+          )!.node;
+          await this.extractRelevantHeadersHelper(
+            originalDeclText,
+            varTypNode,
+            targetTypes,
+            relevantTypes,
+            relevantContext,
+            relevantContextMap,
+            foundNormalForms,
+            source,
+          );
+        }
+      }
+    }
+
+    for (const v of relevantContextMap.values()) {
+      relevantContext.add(v);
+    }
+
+    return relevantContext;
+  }
+
+  private async extractRelevantHeadersHelper(
+    originalDeclText: string,
+    node: Parser.SyntaxNode,
+    targetTypes: Set<Parser.SyntaxNode>,
+    relevantTypes: Map<string, TypeSpanAndSourceFileAndAst>,
+    relevantContext: Set<TypeSpanAndSourceFile>,
+    relevantContextMap: Map<string, TypeSpanAndSourceFile>,
+    foundNormalForms: Map<string, string>,
+    source: string,
+  ) {
+    for (const typ of targetTypes) {
+      if (
+        await this.isTypeEquivalent(node, typ, relevantTypes, foundNormalForms)
+      ) {
+        const ctx = { typeSpan: originalDeclText, sourceFile: source };
+        relevantContextMap.set(JSON.stringify(ctx), ctx);
+      }
+
+      if (node.type === "function_type") {
+        const retTypeNode = node.namedChildren.find(
+          (c) => c && c.type === "return_type",
+        );
+        if (retTypeNode) {
+          await this.extractRelevantHeadersHelper(
+            originalDeclText,
+            retTypeNode,
+            targetTypes,
+            relevantTypes,
+            relevantContext,
+            relevantContextMap,
+            foundNormalForms,
+            source,
+          );
+        }
+      } else if (node.type === "tuple_type") {
+        for (const c of node.namedChildren) {
+          await this.extractRelevantHeadersHelper(
+            originalDeclText,
+            c!,
+            targetTypes,
+            relevantTypes,
+            relevantContext,
+            relevantContextMap,
+            foundNormalForms,
+            source,
+          );
+        }
+      }
+    }
+  }
+
+  private async generateTargetTypes(
+    relevantTypes: Map<string, TypeSpanAndSourceFileAndAst>,
+    holeType: string,
+  ) {
+    const targetTypes = new Set<Parser.SyntaxNode>();
+    // const ast = relevantTypes.get(holeIdentifier)!.ast;
+    const ast = await getAst("file.ts", `type T = ${holeType};`);
+    if (!ast) {
+      throw new Error(`failed to generate ast for ${holeType}`);
+    }
+
+    const alias = ast.rootNode.namedChild(0);
+    if (!alias || alias.type !== "type_alias_declaration") {
+      throw new Error("generateTargetTypes: Failed to parse type alias");
+    }
+
+    const valueNode = alias.childForFieldName("value");
+    if (!valueNode) throw new Error("No type value found");
+
+    const baseNode = unwrapToBaseType(valueNode);
+    targetTypes.add(baseNode);
+    await this.generateTargetTypesHelper(
+      relevantTypes,
+      holeType,
+      targetTypes,
+      baseNode,
+    );
+
+    return targetTypes;
+  }
+
+  private async generateTargetTypesHelper(
+    relevantTypes: Map<string, TypeSpanAndSourceFileAndAst>,
+    currType: string,
+    targetTypes: Set<Parser.SyntaxNode>,
+    node: Parser.SyntaxNode | null,
+  ): Promise<void> {
+    if (!node) return;
+
+    if (node.type === "function_type") {
+      const returnType = node.childForFieldName("return_type");
+      if (returnType) {
+        targetTypes.add(returnType);
+        await this.generateTargetTypesHelper(
+          relevantTypes,
+          currType,
+          targetTypes,
+          returnType,
+        );
+      }
+    }
+
+    if (node.type === "tuple_type") {
+      for (const child of node.namedChildren) {
+        if (child) {
+          targetTypes.add(child);
+          await this.generateTargetTypesHelper(
+            relevantTypes,
+            currType,
+            targetTypes,
+            child,
+          );
+        }
+      }
+    }
+
+    if (relevantTypes.has(node.text)) {
+      // const ast = relevantTypes.get(node.text)!.ast;
+      const typeSpan = relevantTypes.get(node.text)?.typeSpan;
+
+      // const ast = await getAst("file.ts", `type T = ${typeSpan}`);
+      const ast = await getAst("file.ts", typeSpan!);
+      if (!ast) {
+        throw new Error(`failed to generate ast for ${typeSpan}`);
+      }
+
+      const alias = ast.rootNode.namedChild(0);
+      if (!alias || alias.type !== "type_alias_declaration") {
+        console.error("generateTargetTypesHelper: Failed to parse type alias");
+        return;
+        // throw new Error(
+        //   "generateTargetTypesHelper: Failed to parse type alias",
+        // );
+      }
+
+      const valueNode = alias.childForFieldName("value");
+      if (!valueNode) throw new Error("No type value found");
+
+      const baseNode = unwrapToBaseType(valueNode);
+      await this.generateTargetTypesHelper(
+        relevantTypes,
+        currType,
+        targetTypes,
+        baseNode,
+      );
+    }
+
+    // if (node.type === "type_identifier" || node.type === "predefined_type") {
+    //   return [node.text];
+    // }
+
+    return;
+  }
+
+  private async isTypeEquivalent(
+    node: Parser.SyntaxNode,
+    typ: Parser.SyntaxNode,
+    relevantTypes: Map<string, TypeSpanAndSourceFileAndAst>,
+    foundNormalForms: Map<string, string>,
+  ): Promise<boolean> {
+    if (!node || !typ) {
+      return false;
+    }
+    let normT1 = "";
+    let normT2 = "";
+    if (foundNormalForms.has(node.text)) {
+      // console.log("found t1", true)
+      normT1 = foundNormalForms.get(node.text)!;
+    } else {
+      // console.log("not found t1", false)
+      normT1 = await this.normalize(node, relevantTypes);
+      foundNormalForms.set(node.text, normT1);
+    }
+    if (foundNormalForms.has(typ.text)) {
+      // console.log("found t2", true)
+      normT2 = foundNormalForms.get(typ.text)!;
+    } else {
+      // console.log("not found t2", false)
+      normT2 = await this.normalize(typ, relevantTypes);
+      foundNormalForms.set(typ.text, normT2);
+    }
+    // const normT1 = foundNormalForms.has(t1) ? foundNormalForms.get(t1) : this.normalize2(t1, relevantTypes);
+    // const normT2 = foundNormalForms.has(t2) ? foundNormalForms.get(t2) : this.normalize2(t2, relevantTypes);
+    // console.log(`normal forms: ${normT1} {}{} ${normT2}`)
+    return normT1 === normT2;
+  }
+
+  private async normalize(
+    node: Parser.SyntaxNode,
+    relevantTypes: Map<string, TypeSpanAndSourceFileAndAst>,
+  ): Promise<string> {
+    if (!node) return "";
+
+    switch (node.type) {
+      case "function_type": {
+        const params = node.child(0); // formal_parameters
+        const returnType =
+          node.childForFieldName("type") || node.namedChildren[1]; // function_type → parameters, =>, return
+
+        const paramTypes =
+          params?.namedChildren
+            .map((param) =>
+              this.normalize(
+                param!.childForFieldName("type")! ||
+                  param!.namedChildren.at(-1),
+                relevantTypes,
+              ),
+            )
+            .join(", ") || "";
+
+        const ret = this.normalize(returnType!, relevantTypes);
+        return `(${paramTypes}) => ${ret}`;
+      }
+
+      case "tuple_type": {
+        const elements = node.namedChildren.map((c) =>
+          this.normalize(c!, relevantTypes),
+        );
+        return `[${elements.join(", ")}]`;
+      }
+
+      case "union_type": {
+        const parts = node.namedChildren.map((c) =>
+          this.normalize(c!, relevantTypes),
+        );
+        return parts.join(" | ");
+      }
+
+      case "type_identifier": {
+        const alias = relevantTypes.get(node.text);
+        if (!alias) return node.text;
+
+        // Parse the alias's type span
+        const wrapped = `type __TMP = ${alias};`;
+        const tree = await getAst("file.ts", wrapped);
+        const valueNode = tree!.rootNode
+          .descendantsOfType("type_alias_declaration")[0]
+          ?.childForFieldName("value");
+
+        return this.normalize(valueNode!, relevantTypes);
+      }
+
+      case "predefined_type":
+      case "number":
+      case "string":
+        return node.text;
+
+      default:
+        // Fallback for types like array, etc.
+        return node.text;
+    }
+  }
+
+  private insertAtPosition = (
+    contents: string,
+    cursorPosition: { line: number; character: number },
+    insertText: string,
+  ): string => {
+    const lines = contents.split(/\r?\n/); // Handle both LF and CRLF line endings
+    const { line, character } = cursorPosition;
+
+    if (line < 0 || line >= lines.length) {
+      throw new Error("Invalid line number");
+    }
+
+    const targetLine = lines[line];
+    if (character < 0 || character > targetLine.length) {
+      throw new Error("Invalid character index");
+    }
+
+    // Insert the text
+    lines[line] =
+      targetLine.slice(0, character) + insertText + targetLine.slice(character);
+
+    return lines.join("\n"); // Reconstruct the file
+  };
+
+  private async getTypeScriptFilesFromWorkspaces(
+    workspaceUris: string[],
+  ): Promise<string[]> {
+    const tsExtensions = [".ts"];
+    const allTsFiles: string[] = [];
+
+    for (const workspaceUri of workspaceUris) {
+      try {
+        // Convert URI to file path
+        const folderPath = workspaceUri.startsWith("file://")
+          ? new URL(workspaceUri).pathname
+          : workspaceUri;
+
+        const tsFiles = await this.scanDirectoryForTypeScriptFiles(
+          folderPath,
+          tsExtensions,
+        );
+        allTsFiles.push(...tsFiles);
+      } catch (error) {
+        console.error(`Error scanning workspace ${workspaceUri}:`, error);
+      }
+    }
+
+    return allTsFiles;
+  }
+
+  private async scanDirectoryForTypeScriptFiles(
+    dirPath: string,
+    tsExtensions: string[],
+  ): Promise<string[]> {
+    const tsFiles: string[] = [];
+
+    const shouldSkipDirectory = (dirName: string): boolean => {
+      const skipDirs = [
+        "node_modules",
+        ".git",
+        ".vscode",
+        "dist",
+        "build",
+        "out",
+        ".next",
+        "coverage",
+        ".nyc_output",
+        "tmp",
+        "temp",
+        ".cache",
+      ];
+
+      return skipDirs.includes(dirName) || dirName.startsWith(".");
+    };
+
+    async function scanRecursively(currentPath: string): Promise<void> {
+      try {
+        const entries = await fs.readdir(currentPath, {
+          withFileTypes: true,
+        });
+
+        for (const entry of entries) {
+          const fullPath = localPathOrUriToPath(
+            path.join(currentPath, entry.name),
+          );
+
+          if (entry.isDirectory()) {
+            // Skip common directories that typically don't contain source files
+            if (!shouldSkipDirectory(entry.name)) {
+              await scanRecursively(fullPath);
+            }
+          } else if (entry.isFile()) {
+            const extension = path.extname(entry.name).toLowerCase();
+            if (tsExtensions.includes(extension)) {
+              tsFiles.push(fullPath);
+            }
+          }
+        }
+      } catch (error) {
+        console.error(`Error reading directory ${currentPath}:`, error);
+      }
+    }
+
+    await scanRecursively(dirPath);
+    return tsFiles;
+  }
+}
diff --git a/core/autocomplete/context/static-context/tree-sitter-utils.ts b/core/autocomplete/context/static-context/tree-sitter-utils.ts
new file mode 100644
index 00000000000..6e751f54783
--- /dev/null
+++ b/core/autocomplete/context/static-context/tree-sitter-utils.ts
@@ -0,0 +1,222 @@
+import * as fs from "fs/promises";
+import Parser from "web-tree-sitter";
+import { getFullLanguageName, getQueryForFile } from "../../../util/treeSitter";
+import { getAst } from "../../util/ast";
+
+export interface TypeDeclarationResult {
+  name: string;
+  fullText: string;
+  startLine: number;
+  startColumn: number;
+  endLine: number;
+  endColumn: number;
+  kind: string;
+}
+
+export function findEnclosingTypeDeclaration(
+  sourceCode: string,
+  cursorLine: number,
+  cursorColumn: number,
+  ast: Parser.Tree,
+): TypeDeclarationResult | null {
+  const point = { row: cursorLine, column: cursorColumn };
+  let node = ast.rootNode.descendantForPosition(point);
+
+  while (
+    node &&
+    ![
+      "type_alias_declaration",
+      "interface_declaration",
+      "enum_declaration",
+    ].includes(node.type)
+  ) {
+    if (!node.parent) return null;
+    node = node.parent;
+  }
+
+  if (!node) return null;
+
+  const nameNode = node.childForFieldName("name");
+  const name = nameNode?.text ?? "<anonymous>";
+  const fullText = sourceCode.slice(node.startIndex, node.endIndex);
+
+  return {
+    name,
+    fullText,
+    startLine: node.startPosition.row,
+    startColumn: node.startPosition.column,
+    endLine: node.endPosition.row,
+    endColumn: node.endPosition.column,
+    kind: node.type,
+  };
+}
+
+export async function extractTopLevelDecls(
+  currentFile: string,
+  givenParser?: Parser,
+) {
+  const ast = await getAst(currentFile, await fs.readFile(currentFile, "utf8"));
+  if (!ast) {
+    throw new Error(`failed to get ast for file ${currentFile}`);
+  }
+  let language;
+  if (givenParser) {
+    language = givenParser.getLanguage();
+  } else {
+    language = getFullLanguageName(currentFile);
+  }
+
+  const query = await getQueryForFile(
+    currentFile,
+    `static-context-queries/relevant-headers-queries/${language}-get-toplevel-headers.scm`,
+  );
+  if (!query) {
+    throw new Error(
+      `failed to get query for file ${currentFile} and language ${language}`,
+    );
+  }
+  return query.matches(ast.rootNode);
+}
+
+export async function extractTopLevelDeclsWithFormatting(
+  currentFile: string,
+  givenParser?: Parser,
+) {
+  const ast = await getAst(currentFile, await fs.readFile(currentFile, "utf8"));
+  if (!ast) {
+    throw new Error(`failed to get ast for file ${currentFile}`);
+  }
+  let language;
+  if (givenParser) {
+    language = givenParser.getLanguage();
+  } else {
+    language = getFullLanguageName(currentFile);
+  }
+
+  const query = await getQueryForFile(
+    currentFile,
+    `static-context-queries/relevant-headers-queries/${language}-get-toplevel-headers.scm`,
+  );
+  if (!query) {
+    throw new Error(
+      `failed to get query for file ${currentFile} and language ${language}`,
+    );
+  }
+  const matches = query.matches(ast.rootNode);
+
+  const results = [];
+
+  for (const match of matches) {
+    const item: {
+      declaration: string;
+      nodeType: string;
+      name: string;
+      declaredType: string;
+      returnType?: string;
+    } = {
+      declaration: "",
+      nodeType: "",
+      name: "",
+      declaredType: "",
+    };
+
+    for (const { name, node } of match.captures) {
+      if (name === "top.var.decl") {
+        item.nodeType = "variable";
+        item.declaration = node.text;
+
+        // Attempt to get the declared type (e.g., const x: string = ...)
+        const typeNode = node.descendantsOfType("type_annotation")[0];
+        if (typeNode) {
+          item.declaredType = typeNode.text.replace(/^:\s*/, "");
+        }
+      } else if (name === "top.var.name" || name === "top.fn.name") {
+        item.name = node.text;
+      } else if (name === "top.fn.decl") {
+        item.nodeType = "function";
+        item.declaration = node.text;
+
+        // Get the return type (e.g., function foo(): string)
+        const returnTypeNode = node.childForFieldName("return_type");
+        if (returnTypeNode) {
+          item.returnType = returnTypeNode.text.replace(/^:\s*/, "");
+        }
+
+        // Get declaredType if needed (TypeScript style)
+        const nameNode = node.childForFieldName("name");
+        if (nameNode && nameNode.nextSibling?.type === "type_annotation") {
+          item.declaredType = nameNode.nextSibling.text.replace(/^:\s*/, "");
+        }
+      }
+    }
+
+    if (item.name && item.declaration) {
+      results.push(item);
+    }
+  }
+
+  return results;
+}
+
+export function extractFunctionTypeFromDecl(match: Parser.QueryMatch): string {
+  let paramsNode: Parser.SyntaxNode | undefined = undefined;
+  let returnNode: Parser.SyntaxNode | undefined = undefined;
+
+  for (const capture of match.captures) {
+    if (capture.name === "top.fn.param.type") {
+      paramsNode = capture.node;
+    } else if (capture.name === "top.fn.type") {
+      returnNode = capture.node;
+    }
+  }
+
+  if (!paramsNode) {
+    console.error(
+      `extractFunctionTypeFromDecl: paramsNode ${paramsNode} not found`,
+    );
+    throw new Error(
+      `extractFunctionTypeFromDecl: paramsNode ${paramsNode} not found`,
+    );
+  }
+
+  if (!returnNode) {
+    console.error(
+      `extractFunctionTypeFromDecl: returnNode ${returnNode} not found`,
+    );
+    throw new Error(
+      `extractFunctionTypeFromDecl: returnNode ${returnNode} not found`,
+    );
+  }
+
+  return `(${paramsNode!.text}) => ${returnNode!.text}`;
+}
+
+export function unwrapToBaseType(node: Parser.SyntaxNode): Parser.SyntaxNode {
+  if (
+    [
+      "function_type",
+      "tuple_type",
+      "type_identifier",
+      "predefined_type",
+    ].includes(node.type)
+  ) {
+    return node;
+  }
+
+  for (const child of node.namedChildren) {
+    const unwrapped = unwrapToBaseType(child!);
+    if (
+      unwrapped !== child ||
+      [
+        "function_type",
+        "tuple_type",
+        "type_identifier",
+        "predefined_type",
+      ].includes(unwrapped.type)
+    ) {
+      return unwrapped;
+    }
+  }
+
+  return node;
+}
diff --git a/core/autocomplete/context/static-context/types.ts b/core/autocomplete/context/static-context/types.ts
new file mode 100644
index 00000000000..1aa8b473ddd
--- /dev/null
+++ b/core/autocomplete/context/static-context/types.ts
@@ -0,0 +1,33 @@
+import { Tree } from "web-tree-sitter";
+import { Range } from "../../..";
+
+export interface TypeSpanAndSourceFile {
+  typeSpan: string;
+  sourceFile: string;
+}
+
+export interface TypeSpanAndSourceFileAndAst extends TypeSpanAndSourceFile {
+  ast: Tree;
+}
+
+export interface HoleContext {
+  fullHoverResult: string;
+  functionName: string;
+  functionTypeSpan: string;
+  returnTypeIsAny: boolean;
+  range: Range;
+  source: string;
+}
+
+export type RelevantTypes = Map<string, TypeSpanAndSourceFileAndAst>;
+export type RelevantHeaders = Set<TypeSpanAndSourceFile>;
+
+export type Filepath = string;
+export type RelevantType = string;
+export type RelevantHeader = string;
+
+export interface StaticContext {
+  holeType: string;
+  relevantTypes: Map<Filepath, RelevantType[]>;
+  relevantHeaders: Map<Filepath, RelevantHeader[]>;
+}
diff --git a/core/autocomplete/filtering/streamTransforms/filterCodeBlock.ts b/core/autocomplete/filtering/streamTransforms/filterCodeBlock.ts
new file mode 100644
index 00000000000..d9cb8e8acbe
--- /dev/null
+++ b/core/autocomplete/filtering/streamTransforms/filterCodeBlock.ts
@@ -0,0 +1,146 @@
+import { LineStream } from "../../../diff/util";
+
+import {
+  collectAllLines,
+  MarkdownBlockStateTracker,
+} from "../../../utils/markdownUtils";
+
+import {
+  processBlockNesting,
+  shouldStopAtMarkdownBlock,
+} from "../../../utils/streamMarkdownUtils";
+
+import { hasNestedMarkdownBlocks, shouldChangeLineAndStop } from "./lineStream";
+
+/**
+ * Filters and processes lines from a code block, removing unnecessary markers and handling edge cases.
+ * Now includes markdown-aware processing to handle nested markdown blocks properly.
+ *
+ * @param {LineStream} rawLines - The input stream of lines to filter.
+ * @param {string} filepath - Optional filepath to determine if this is a markdown file.
+ * @yields {string} Filtered and processed lines from the code block.
+ *
+ * @description
+ * This generator function performs the following tasks:
+ * 1. Removes initial lines that should be removed before the actual code starts.
+ * 2. For markdown files, applies nested markdown block logic to avoid premature termination.
+ * 3. For mixed content, uses simplified processing to avoid premature termination.
+ * 4. For traditional code blocks, uses original logic.
+ * 5. Yields processed lines that are part of the actual code block content.
+ */
+export async function* filterCodeBlockLines(
+  rawLines: LineStream,
+  filepath?: string,
+): LineStream {
+  // Collect all lines for analysis
+  const allLines = await collectAllLines(rawLines);
+
+  // Check if it has nested markdown blocks (like ```markdown or ```md)
+  const firstLine = allLines[0] || "";
+  const hasNestedMarkdown = hasNestedMarkdownBlocks(firstLine, filepath);
+
+  // TARGETED FIX: Detect if this is mixed content (markdown headers + code blocks)
+  // But exclude cases where we have nested markdown blocks
+  const hasMarkdownHeaders = allLines.some(
+    (line) => line.trim().startsWith("#") && !line.trim().startsWith("```"),
+  );
+
+  const hasCodeBlocks = allLines.some(
+    (line) => line.trim().startsWith("```") && line.trim().length >= 3,
+  );
+  const isMixedContent =
+    hasMarkdownHeaders && hasCodeBlocks && !hasNestedMarkdown;
+
+  // If this is mixed content, use simplified processing
+  if (isMixedContent) {
+    for (let i = 0; i < allLines.length; i++) {
+      const line = allLines[i];
+
+      // Skip initial wrapper lines if they exist
+      if (i === 0 && shouldRemoveLineBeforeStart(line)) {
+        continue;
+      }
+
+      yield line;
+    }
+    return;
+  }
+
+  // Original logic for non-mixed content
+  let seenFirstFence = false;
+  let nestCount = 0;
+
+  // Create optimized state tracker for markdown block analysis if needed
+  let markdownStateTracker: MarkdownBlockStateTracker | undefined;
+  if (hasNestedMarkdown) {
+    markdownStateTracker = new MarkdownBlockStateTracker(allLines);
+  }
+
+  for (let i = 0; i < allLines.length; i++) {
+    const line = allLines[i];
+
+    // Process block nesting logic for the first fence
+    const nesting = processBlockNesting(
+      line,
+      seenFirstFence,
+      shouldRemoveLineBeforeStart,
+    );
+    if (nesting.shouldSkip) {
+      continue; // Filter out starting ``` or START block
+    }
+    if (!seenFirstFence && nesting.newSeenFirstFence) {
+      seenFirstFence = true;
+      nestCount = 1;
+    }
+
+    if (nestCount > 0) {
+      // Inside a block including the outer block
+      const changedEndLine = shouldChangeLineAndStop(line);
+      if (typeof changedEndLine === "string") {
+        // Ending a block with just backticks (```) or STOP
+
+        // For markdown files with nested markdown blocks, apply special logic
+        if (
+          hasNestedMarkdown &&
+          line.trim() === "```" &&
+          markdownStateTracker
+        ) {
+          if (shouldStopAtMarkdownBlock(markdownStateTracker, i)) {
+            return; // Stop without yielding the final closing ```
+          } else {
+            // This is an inner block delimiter, yield it as content
+            yield line;
+            continue;
+          }
+        }
+
+        // Original logic for non-markdown files or simple cases
+        nestCount--;
+        if (nestCount === 0) {
+          // We've closed the outer wrapper - stop without yielding the closing ```
+          return;
+        } else {
+          // This is a nested block closing, yield it as content
+          yield line;
+        }
+      } else if (line.startsWith("```")) {
+        // Going into a nested codeblock
+        nestCount++;
+        yield line;
+      } else {
+        // Otherwise just yield the line as content
+        yield line;
+      }
+    }
+  }
+}
+
+function shouldRemoveLineBeforeStart(line: string): boolean {
+  return (
+    line.trimStart().startsWith("```") ||
+    line.trim() === "[CODE]" ||
+    line.trim() === "<COMPLETION>" ||
+    line.trim() === "<START EDITING HERE>" ||
+    line.trim() === "{{FILL_HERE}}"
+  );
+}
diff --git a/core/autocomplete/filtering/streamTransforms/filterCodeBlock.vitest.ts b/core/autocomplete/filtering/streamTransforms/filterCodeBlock.vitest.ts
new file mode 100644
index 00000000000..78936a28c21
--- /dev/null
+++ b/core/autocomplete/filtering/streamTransforms/filterCodeBlock.vitest.ts
@@ -0,0 +1,452 @@
+// eslint-disable-next-line max-lines-per-function
+import { beforeEach, describe, expect, it, Mock, vi } from "vitest";
+
+import * as lineStream from "./lineStream";
+
+describe("filterCodeBlock", () => {
+  let mockFullStop: Mock;
+
+  async function getLineGenerator(lines: any) {
+    return (async function* () {
+      for (const line of lines) {
+        yield line;
+      }
+    })();
+  }
+
+  async function getFilteredLines(results: any) {
+    const output = [];
+
+    for await (const line of results) {
+      output.push(line);
+    }
+
+    return output;
+  }
+
+  beforeEach(() => {
+    mockFullStop = vi.fn();
+  });
+
+  it("should handle unfenced code", async () => {
+    const linesGenerator = await getLineGenerator(["const x = 5;"]);
+
+    const result = lineStream.filterCodeBlockLines(linesGenerator);
+    const filteredLines = await getFilteredLines(result);
+
+    expect(filteredLines).toEqual(["const x = 5;"]);
+  });
+
+  it("should handle unfenced code with a code block", async () => {
+    const linesGenerator = await getLineGenerator([
+      "const x = 5;",
+      "```bash",
+      "ls -al",
+      "```",
+    ]);
+
+    const result = lineStream.filterCodeBlockLines(linesGenerator);
+    const filteredLines = await getFilteredLines(result);
+
+    expect(filteredLines).toEqual(["const x = 5;", "```bash", "ls -al", "```"]);
+  });
+
+  it("should handle unfenced code with a complex code block", async () => {
+    const linesGenerator = await getLineGenerator([
+      "# Manual Testing Sandbox",
+      "",
+      "## Project Structure",
+      "",
+      "```",
+      "manual-testing-sandbox/",
+      "├── readme.md                           # Project documentation",
+      "├── package.json                        # Node.js dependencies and scripts",
+      "├── tsconfig.json                       # TypeScript configuration",
+      "├── jest.config.js                      # Jest testing configuration",
+      "├── requirements.txt                    # Python dependencies",
+      "├── Dockerfile                          # Docker container configuration",
+      "├── data.json                           # Sample JSON data",
+      "├── example.ipynb                       # Jupyter notebook example",
+      "│",
+      "├── src/                                # Source code directory",
+      "│   ├── example.ts                      # TypeScript example",
+      "│   ├── JsonToMarkdownConverter.ts      # JSON to Markdown converter",
+      "│   ├── JsonToMarkdownConverter.test.ts # Tests for JSON converter",
+      "│   ├── MarkdownProcessor.ts            # Markdown processing utility",
+      "│   └── MarkdownProcessor.test.ts       # Tests for Markdown processor",
+      "│",
+      "├── react-calculator/                   # React calculator application",
+      "├── calculator_test/                    # Java calculator implementation",
+      "│   ├── Calculator.java                 # Calculator class",
+      "│   └── Main.java                       # Main application entry",
+      "│",
+      "├── nested-folder/                      # Nested project example",
+      "│   ├── helloNested.py                  # Python script",
+      "│   ├── package.json                    # Nested package configuration",
+      "│   └── rules.md                        # Documentation",
+      "│",
+      "├── coverage/                           # Test coverage reports",
+      "├── logs/                               # Application logs",
+      "│",
+      "└── Test Files                          # Various language examples",
+      "    ├── AdvancedPage.tsx                # React TypeScript component",
+      "    ├── Calculator.java                 # Java calculator",
+      "    ├── program.cs                      # C# program",
+      "    ├── query.sql                       # SQL query example",
+      "    ├── test.css                        # CSS styles",
+      "    ├── test.html                       # HTML page",
+      "    ├── test.js                         # JavaScript code",
+      "    ├── test.kt                         # Kotlin example",
+      "    ├── test.php                        # PHP script",
+      "    ├── test.py                         # Python script",
+      "    ├── test.rb                         # Ruby script",
+      "    ├── test.rs                         # Rust code",
+      "    ├── test.sh                         # Shell script",
+      "    └── test.ts                         # TypeScript code",
+      "```",
+    ]);
+
+    const result = lineStream.filterCodeBlockLines(linesGenerator);
+    const filteredLines = await getFilteredLines(result);
+
+    expect(filteredLines).toEqual([
+      "# Manual Testing Sandbox",
+      "",
+      "## Project Structure",
+      "",
+      "```",
+      "manual-testing-sandbox/",
+      "├── readme.md                           # Project documentation",
+      "├── package.json                        # Node.js dependencies and scripts",
+      "├── tsconfig.json                       # TypeScript configuration",
+      "├── jest.config.js                      # Jest testing configuration",
+      "├── requirements.txt                    # Python dependencies",
+      "├── Dockerfile                          # Docker container configuration",
+      "├── data.json                           # Sample JSON data",
+      "├── example.ipynb                       # Jupyter notebook example",
+      "│",
+      "├── src/                                # Source code directory",
+      "│   ├── example.ts                      # TypeScript example",
+      "│   ├── JsonToMarkdownConverter.ts      # JSON to Markdown converter",
+      "│   ├── JsonToMarkdownConverter.test.ts # Tests for JSON converter",
+      "│   ├── MarkdownProcessor.ts            # Markdown processing utility",
+      "│   └── MarkdownProcessor.test.ts       # Tests for Markdown processor",
+      "│",
+      "├── react-calculator/                   # React calculator application",
+      "├── calculator_test/                    # Java calculator implementation",
+      "│   ├── Calculator.java                 # Calculator class",
+      "│   └── Main.java                       # Main application entry",
+      "│",
+      "├── nested-folder/                      # Nested project example",
+      "│   ├── helloNested.py                  # Python script",
+      "│   ├── package.json                    # Nested package configuration",
+      "│   └── rules.md                        # Documentation",
+      "│",
+      "├── coverage/                           # Test coverage reports",
+      "├── logs/                               # Application logs",
+      "│",
+      "└── Test Files                          # Various language examples",
+      "    ├── AdvancedPage.tsx                # React TypeScript component",
+      "    ├── Calculator.java                 # Java calculator",
+      "    ├── program.cs                      # C# program",
+      "    ├── query.sql                       # SQL query example",
+      "    ├── test.css                        # CSS styles",
+      "    ├── test.html                       # HTML page",
+      "    ├── test.js                         # JavaScript code",
+      "    ├── test.kt                         # Kotlin example",
+      "    ├── test.php                        # PHP script",
+      "    ├── test.py                         # Python script",
+      "    ├── test.rb                         # Ruby script",
+      "    ├── test.rs                         # Rust code",
+      "    ├── test.sh                         # Shell script",
+      "    └── test.ts                         # TypeScript code",
+      "```",
+    ]);
+  });
+
+  it("should handle unfenced code with two code blocks", async () => {
+    const linesGenerator = await getLineGenerator([
+      "const x = 5;",
+      "```bash",
+      "ls -al",
+      "```",
+      "```bash",
+      "ls -al",
+      "```",
+    ]);
+
+    const result = lineStream.filterCodeBlockLines(linesGenerator);
+    const filteredLines = await getFilteredLines(result);
+
+    expect(filteredLines).toEqual([
+      "const x = 5;",
+      "```bash",
+      "ls -al",
+      "```",
+      "```bash",
+      "ls -al",
+      "```",
+    ]);
+  });
+
+  it("should remove lines before the first valid line", async () => {
+    const linesGenerator = await getLineGenerator(["```ts", "const x = 5;"]);
+
+    const result = lineStream.filterCodeBlockLines(linesGenerator);
+    const filteredLines = await getFilteredLines(result);
+
+    expect(filteredLines).toEqual(["const x = 5;"]);
+  });
+
+  it("should remove outer blocks", async () => {
+    const linesGenerator = await getLineGenerator([
+      "```ts",
+      "const x = 5;",
+      "```",
+    ]);
+
+    const result = lineStream.filterCodeBlockLines(linesGenerator);
+    const filteredLines = await getFilteredLines(result);
+
+    expect(filteredLines).toEqual(["const x = 5;"]);
+  });
+
+  it("should leave inner blocks intact", async () => {
+    const linesGenerator = await getLineGenerator([
+      "```md",
+      "const x = 5;",
+      "```bash",
+      "ls -al",
+      "```",
+      "```",
+    ]);
+
+    const result = lineStream.filterCodeBlockLines(linesGenerator);
+    const filteredLines = await getFilteredLines(result);
+
+    expect(filteredLines).toEqual(["const x = 5;", "```bash", "ls -al", "```"]);
+  });
+
+  it("should ignore ticks inside of code blocks such as tests", async () => {
+    const linesGenerator = await getLineGenerator([
+      "```typescript",
+      'it("should handle included inner ticks", async () => {',
+      " const linesGenerator = await getLineGenerator([`",
+      ' "```md"',
+      ' "const x = 5;"',
+      ' "```bash"',
+      ' "echo ```test```"',
+      ' "```"',
+      ' "```"',
+      "]);",
+      "```",
+    ]);
+
+    const result = lineStream.filterCodeBlockLines(linesGenerator);
+    const filteredLines = await getFilteredLines(result);
+
+    expect(filteredLines).toEqual([
+      'it("should handle included inner ticks", async () => {',
+      " const linesGenerator = await getLineGenerator([`",
+      ' "```md"',
+      ' "const x = 5;"',
+      ' "```bash"',
+      ' "echo ```test```"',
+      ' "```"',
+      ' "```"',
+      "]);",
+    ]);
+  });
+
+  it("should handle included inner ticks", async () => {
+    const linesGenerator = await getLineGenerator([
+      "```md",
+      "const x = 5;",
+      "```bash",
+      "echo ```test```",
+      "```",
+      "```",
+    ]);
+
+    const result = lineStream.filterCodeBlockLines(linesGenerator);
+    const filteredLines = await getFilteredLines(result);
+
+    expect(filteredLines).toEqual([
+      "const x = 5;",
+      "```bash",
+      "echo ```test```",
+      "```",
+    ]);
+  });
+
+  it("should leave single inner blocks intact but not return trailing text", async () => {
+    const linesGenerator = await getLineGenerator([
+      "```md",
+      "const x = 5;",
+      "```bash",
+      "ls -al",
+      "```",
+      "```",
+      "trailing text",
+    ]);
+
+    const result = lineStream.filterCodeBlockLines(linesGenerator);
+    const filteredLines = await getFilteredLines(result);
+
+    expect(filteredLines).toEqual(["const x = 5;", "```bash", "ls -al", "```"]);
+  });
+
+  it("should leave double inner blocks intact but not return trailing text", async () => {
+    const linesGenerator = await getLineGenerator([
+      "```md",
+      "const x = 5;",
+      "```bash",
+      "ls -al",
+      "```",
+      "const y = 10;",
+      "```sh",
+      "echo `hello world`",
+      "```",
+      "```",
+      "trailing text",
+    ]);
+
+    const result = lineStream.filterCodeBlockLines(linesGenerator);
+    const filteredLines = await getFilteredLines(result);
+
+    expect(filteredLines).toEqual([
+      "const x = 5;",
+      "```bash",
+      "ls -al",
+      "```",
+      "const y = 10;",
+      "```sh",
+      "echo `hello world`",
+      "```",
+    ]);
+  });
+
+  it("should leave inner blocks intact but not return trailing or leading text", async () => {
+    const linesGenerator = await getLineGenerator([
+      "[CODE]",
+      "const x = 5;",
+      "```bash",
+      "ls -al",
+      "```",
+      "[/CODE]",
+      "trailing text",
+    ]);
+
+    const result = lineStream.filterCodeBlockLines(linesGenerator);
+    const filteredLines = await getFilteredLines(result);
+
+    expect(filteredLines).toEqual(["const x = 5;", "```bash", "ls -al", "```"]);
+  });
+
+  // Markdown-aware tests
+  it("should handle markdown files with nested code blocks and a filename is included", async () => {
+    const linesGenerator = await getLineGenerator([
+      "```markdown README.md",
+      "# Project Structure",
+      "",
+      "```",
+      "debug-test-folder/",
+      "├── AdvancedPage.tsx",
+      "├── Calculator.java",
+      "└── test.ts",
+      "```",
+      "```",
+    ]);
+
+    const result = lineStream.filterCodeBlockLines(linesGenerator, "README.md");
+    const filteredLines = await getFilteredLines(result);
+
+    // Should include all content up to the final closing ```
+    expect(filteredLines).toEqual([
+      "# Project Structure",
+      "",
+      "```",
+      "debug-test-folder/",
+      "├── AdvancedPage.tsx",
+      "├── Calculator.java",
+      "└── test.ts",
+      "```",
+    ]);
+  });
+
+  // Markdown-aware tests
+  it("should handle markdown files with nested code blocks and a filename is excluded", async () => {
+    const linesGenerator = await getLineGenerator([
+      "```markdown README.md",
+      "# Project Structure",
+      "",
+      "```",
+      "debug-test-folder/",
+      "├── AdvancedPage.tsx",
+      "├── Calculator.java",
+      "└── test.ts",
+      "```",
+      "```",
+    ]);
+
+    const result = lineStream.filterCodeBlockLines(linesGenerator);
+    const filteredLines = await getFilteredLines(result);
+
+    // Should include all content up to the final closing ```
+    expect(filteredLines).toEqual([
+      "# Project Structure",
+      "",
+      "```",
+      "debug-test-folder/",
+      "├── AdvancedPage.tsx",
+      "├── Calculator.java",
+      "└── test.ts",
+      "```",
+    ]);
+  });
+
+  it("should handle non-markdown files normally with filepath parameter", async () => {
+    const linesGenerator = await getLineGenerator([
+      "```",
+      "function test() {",
+      "  return 'hello';",
+      "}",
+      "```",
+    ]);
+
+    const result = lineStream.filterCodeBlockLines(linesGenerator, "test.js");
+    const filteredLines = await getFilteredLines(result);
+
+    expect(filteredLines).toEqual([
+      "function test() {",
+      "  return 'hello';",
+      "}",
+    ]);
+  });
+
+  it("should handle simple markdown code blocks", async () => {
+    const linesGenerator = await getLineGenerator([
+      "```",
+      "Here's some code:",
+      "```",
+      "function example() {",
+      "  console.log('test');",
+      "}",
+      "```",
+    ]);
+
+    const result = lineStream.filterCodeBlockLines(linesGenerator, "README.md");
+    const filteredLines = await getFilteredLines(result);
+
+    // Should remove the outer markdown wrapper, and return just the inner content.
+    // The lack of an end tag should cause it to return all remaining lines.
+    expect(filteredLines).toEqual([
+      "Here's some code:",
+      "```",
+      "function example() {",
+      "  console.log('test');",
+      "}",
+      "```",
+    ]);
+  });
+});
diff --git a/core/autocomplete/filtering/streamTransforms/lineStream.ts b/core/autocomplete/filtering/streamTransforms/lineStream.ts
index bc193cb127a..3cf1cec9f74 100644
--- a/core/autocomplete/filtering/streamTransforms/lineStream.ts
+++ b/core/autocomplete/filtering/streamTransforms/lineStream.ts
@@ -3,6 +3,11 @@ import { distance } from "fastest-levenshtein";
 import { DiffLine } from "../../..";
 import { LineStream } from "../../../diff/util";
 
+import { headerIsMarkdown, isMarkdownFile } from "../../../utils/markdownUtils";
+import { processBlockNesting as processBlockNestingUtil } from "../../../utils/streamMarkdownUtils";
+
+export { filterCodeBlockLines } from "./filterCodeBlock";
+
 export type LineFilter = (args: {
   lines: LineStream;
   fullStop: () => void;
@@ -50,13 +55,72 @@ function shouldRemoveLineBeforeStart(line: string): boolean {
   );
 }
 
-function shouldChangeLineAndStop(line: string): string | undefined {
+/**
+ * Shared utility for validating patterns in lines to avoid code duplication.
+ * Checks if a pattern appears in a valid context (not inside quotes or identifiers).
+ */
+export function validatePatternInLine(
+  line: string,
+  pattern: string,
+): {
+  isValid: boolean;
+  patternIndex: number;
+  beforePattern: string;
+} {
+  const patternIndex = line.indexOf(pattern);
+
+  if (patternIndex === -1) {
+    return { isValid: false, patternIndex: -1, beforePattern: "" };
+  }
+
+  // Check if pattern is preceded by a non-whitespace character
+  // If so, it might be part of an identifier, so don't handle it
+  if (patternIndex > 0) {
+    const charBefore = line[patternIndex - 1];
+    if (charBefore && !charBefore.match(/\s/)) {
+      return { isValid: false, patternIndex, beforePattern: "" };
+    }
+  }
+
+  // Check if pattern appears to be inside quotes
+  // Simple heuristic: count unmatched quotes before the pattern
+  const beforePattern = line.substring(0, patternIndex);
+  const singleQuotes = (beforePattern.match(/'/g) || []).length;
+  const doubleQuotes = (beforePattern.match(/"/g) || []).length;
+
+  // If there's an odd number of quotes before pattern, we're likely inside quotes
+  if (singleQuotes % 2 !== 0 || doubleQuotes % 2 !== 0) {
+    return { isValid: false, patternIndex, beforePattern };
+  }
+
+  return { isValid: true, patternIndex, beforePattern };
+}
+
+export function shouldChangeLineAndStop(line: string): string | undefined {
   if (line.trimStart() === "```") {
     return line;
   }
 
+  // Check if [/CODE] appears in the line
   if (line.includes(CODE_STOP_BLOCK)) {
-    return line.split(CODE_STOP_BLOCK)[0].trimEnd();
+    const validation = validatePatternInLine(line, CODE_STOP_BLOCK);
+
+    if (!validation.isValid) {
+      return undefined;
+    }
+
+    // Get the trimmed line to check if [/CODE] is at logical start
+    const trimmedLine = line.trimStart();
+
+    if (trimmedLine.startsWith(CODE_STOP_BLOCK)) {
+      // [/CODE] is at the logical start (after whitespace only)
+      if (trimmedLine === CODE_STOP_BLOCK) {
+        return line; // Return the whole line including leading whitespace
+      }
+    }
+
+    // [/CODE] appears after some content (separated by whitespace) - return part before
+    return validation.beforePattern.trimEnd();
   }
 
   return undefined;
@@ -71,6 +135,32 @@ function isUselessLine(line: string): boolean {
   return hasUselessLine || trimmed.startsWith("// end");
 }
 
+/**
+ * Determines if the code block has nested markdown blocks.
+ */
+export function hasNestedMarkdownBlocks(
+  firstLine: string,
+  filepath?: string,
+): boolean {
+  return (
+    (firstLine.startsWith("```") &&
+      headerIsMarkdown(firstLine.replace(/`/g, ""))) ||
+    Boolean(filepath && isMarkdownFile(filepath))
+  );
+}
+
+// Wrapper for processBlockNesting with local shouldRemoveLineBeforeStart function
+export function processBlockNesting(
+  line: string,
+  seenFirstFence: boolean,
+): { newSeenFirstFence: boolean; shouldSkip: boolean } {
+  return processBlockNestingUtil(
+    line,
+    seenFirstFence,
+    shouldRemoveLineBeforeStart,
+  );
+}
+
 export const USELESS_LINES = [""];
 export const CODE_KEYWORDS_ENDING_IN_SEMICOLON = ["def"];
 export const CODE_STOP_BLOCK = "[/CODE]";
@@ -138,7 +228,7 @@ export async function* avoidPathLine(
   // Sometimes the model with copy this pattern, which is unwanted
   for await (const line of stream) {
     if (line.startsWith(`${comment} Path: `)) {
-      continue;
+      continue; // continue in the Continue codebase! How meta!
     }
     yield line;
   }
@@ -261,7 +351,40 @@ export async function* stopAtLines(
   linesToStopAt: string[] = LINES_TO_STOP_AT,
 ): LineStream {
   for await (const line of stream) {
-    if (linesToStopAt.some((stopAt) => line.trim().includes(stopAt))) {
+    let shouldStop = false;
+
+    // Check each stop phrase
+    for (const stopAt of linesToStopAt) {
+      if (line.includes(stopAt)) {
+        const validation = validatePatternInLine(line, stopAt);
+
+        if (!validation.isValid) {
+          continue;
+        }
+
+        // Get the trimmed line to check if stop phrase is at logical start
+        const trimmedLine = line.trimStart();
+
+        if (trimmedLine.startsWith(stopAt)) {
+          // Stop phrase is at the logical start (after whitespace only) - should stop
+          shouldStop = true;
+          break;
+        } else {
+          // Stop phrase appears after some content - check if it's separated by whitespace
+          const contentBeforeStopPhrase = validation.beforePattern.trimEnd();
+          if (
+            contentBeforeStopPhrase.length < validation.beforePattern.length
+          ) {
+            // There's whitespace before the stop phrase, so it's properly separated
+            shouldStop = true;
+            break;
+          }
+          // If no whitespace separation, it's part of larger text, so continue
+        }
+      }
+    }
+
+    if (shouldStop) {
       fullStop();
       break;
     }
@@ -329,64 +452,6 @@ export async function* removeTrailingWhitespace(
   }
 }
 
-/**
- * Filters and processes lines from a code block, removing unnecessary markers and handling edge cases.
- *
- * @param {LineStream} rawLines - The input stream of lines to filter.
- * @yields {string} Filtered and processed lines from the code block.
- *
- * @description
- * This generator function performs the following tasks:
- * 1. Removes initial lines that should be removed before the actual code starts.
- * 2. Filters out ending code block markers (```) unless they are the last line.
- * 3. Handles special cases where lines should be changed and the stream should stop.
- * 4. Yields processed lines that are part of the actual code block content.
- */
-export async function* filterCodeBlockLines(rawLines: LineStream): LineStream {
-  let seenFirstFence = false;
-  // nestCount is set to 1 when the entire code block is wrapped with ``` or START blocks. It's then incremented
-  // when an inner code block is discovered to avoid exiting the function prematurly. The function will exit early
-  // when all blocks are matched. When no outer fence is discovered the function will always continue to the end.
-  let nestCount = 0;
-
-  for await (const line of rawLines) {
-    if (!seenFirstFence) {
-      if (shouldRemoveLineBeforeStart(line)) {
-        // Filter out starting ``` or START block
-        continue;
-      }
-      // Regardless of a fence or START block start tracking the nesting level
-      seenFirstFence = true;
-      nestCount = 1;
-    }
-
-    if (nestCount > 0) {
-      // Inside a block including the outer block
-      const changedEndLine = shouldChangeLineAndStop(line);
-      if (typeof changedEndLine === "string") {
-        // Ending a block with just backticks (```) or STOP
-        nestCount--;
-        if (nestCount === 0) {
-          // if we are closing the outer block then exit early
-          // only exit early if the outer block was started with a block
-          // it it was text, we will never exit early
-          return;
-        } else {
-          // otherwise just yield the line
-          yield line;
-        }
-      } else if (line.startsWith("```")) {
-        // Going into a nested codeblock
-        nestCount++;
-        yield line;
-      } else {
-        // otherwise just yield the line
-        yield line;
-      }
-    }
-  }
-}
-
 /**
  * Filters out English explanations at the start of a code block.
  *
diff --git a/core/autocomplete/filtering/streamTransforms/lineStream.vitest.ts b/core/autocomplete/filtering/streamTransforms/lineStream.vitest.ts
index 8861b968c29..741c2b12541 100644
--- a/core/autocomplete/filtering/streamTransforms/lineStream.vitest.ts
+++ b/core/autocomplete/filtering/streamTransforms/lineStream.vitest.ts
@@ -1,5 +1,10 @@
 import { beforeEach, describe, expect, it, Mock, vi } from "vitest";
 
+import {
+  collectAllLines,
+  MarkdownBlockStateTracker,
+} from "../../../utils/markdownUtils";
+import { shouldStopAtMarkdownBlock } from "../../../utils/streamMarkdownUtils";
 import * as lineStream from "./lineStream";
 
 // eslint-disable-next-line max-lines-per-function
@@ -174,6 +179,93 @@ describe("lineStream", () => {
       expect(filteredLines).toEqual(["const x = 5;", "let y = 10;"]);
       expect(mockFullStop).toHaveBeenCalledTimes(1);
     });
+
+    it("should stop at lines with leading whitespace", async () => {
+      const linesGenerator = await getLineGenerator([
+        "const x = 5;",
+        "let y = 10;",
+        `    ${lineStream.LINES_TO_STOP_AT[0]}`,
+        "const z = 15;",
+      ]);
+
+      const result = lineStream.stopAtLines(linesGenerator, mockFullStop);
+      const filteredLines = await getFilteredLines(result);
+
+      expect(filteredLines).toEqual(["const x = 5;", "let y = 10;"]);
+      expect(mockFullStop).toHaveBeenCalledTimes(1);
+    });
+
+    it("should NOT stop when stop phrase is inside quotes", async () => {
+      const linesGenerator = await getLineGenerator([
+        "const x = 5;",
+        'console.log("# End of file. not really");',
+        "let y = 10;",
+        "const z = 15;",
+      ]);
+
+      const result = lineStream.stopAtLines(linesGenerator, mockFullStop);
+      const filteredLines = await getFilteredLines(result);
+
+      // Should not stop, should yield all lines
+      expect(filteredLines).toEqual([
+        "const x = 5;",
+        'console.log("# End of file. not really");',
+        "let y = 10;",
+        "const z = 15;",
+      ]);
+      expect(mockFullStop).toHaveBeenCalledTimes(0);
+    });
+
+    it("should NOT stop when stop phrase is inside single quotes", async () => {
+      const linesGenerator = await getLineGenerator([
+        "const x = 5;",
+        "const message = '# End of file. not really';",
+        "let y = 10;",
+      ]);
+
+      const result = lineStream.stopAtLines(linesGenerator, mockFullStop);
+      const filteredLines = await getFilteredLines(result);
+
+      expect(filteredLines).toEqual([
+        "const x = 5;",
+        "const message = '# End of file. not really';",
+        "let y = 10;",
+      ]);
+      expect(mockFullStop).toHaveBeenCalledTimes(0);
+    });
+
+    it("should NOT stop when stop phrase is part of larger text", async () => {
+      const linesGenerator = await getLineGenerator([
+        "const x = 5;",
+        "// This function stops<STOP EDITING HERE>after processing",
+        "let y = 10;",
+      ]);
+
+      const result = lineStream.stopAtLines(linesGenerator, mockFullStop);
+      const filteredLines = await getFilteredLines(result);
+
+      expect(filteredLines).toEqual([
+        "const x = 5;",
+        "// This function stops<STOP EDITING HERE>after processing",
+        "let y = 10;",
+      ]);
+      expect(mockFullStop).toHaveBeenCalledTimes(0);
+    });
+
+    it("should stop when stop phrase appears properly at start of content", async () => {
+      const linesGenerator = await getLineGenerator([
+        "const x = 5;",
+        "let y = 10;",
+        "# End of file. Done here",
+        "const z = 15;",
+      ]);
+
+      const result = lineStream.stopAtLines(linesGenerator, mockFullStop);
+      const filteredLines = await getFilteredLines(result);
+
+      expect(filteredLines).toEqual(["const x = 5;", "let y = 10;"]);
+      expect(mockFullStop).toHaveBeenCalledTimes(1);
+    });
   });
 
   describe("skipPrefixes", () => {
@@ -301,6 +393,37 @@ describe("lineStream", () => {
       ]);
     });
 
+    it("should ignore ticks inside of code blocks such as tests", async () => {
+      const linesGenerator = await getLineGenerator([
+        "```typescript",
+        'it("should handle included inner ticks", async () => {',
+        " const linesGenerator = await getLineGenerator([`",
+        ' "```md"',
+        ' "const x = 5;"',
+        ' "```bash"',
+        ' "echo ```test```"',
+        ' "```"',
+        ' "```"',
+        "]);",
+        "```",
+      ]);
+
+      const result = lineStream.filterCodeBlockLines(linesGenerator);
+      const filteredLines = await getFilteredLines(result);
+
+      expect(filteredLines).toEqual([
+        'it("should handle included inner ticks", async () => {',
+        " const linesGenerator = await getLineGenerator([`",
+        ' "```md"',
+        ' "const x = 5;"',
+        ' "```bash"',
+        ' "echo ```test```"',
+        ' "```"',
+        ' "```"',
+        "]);",
+      ]);
+    });
+
     it("should handle included inner ticks", async () => {
       const linesGenerator = await getLineGenerator([
         "```md",
@@ -395,6 +518,119 @@ describe("lineStream", () => {
         "```",
       ]);
     });
+
+    // Markdown-aware tests
+    it("should handle markdown files with nested code blocks and a filename is included", async () => {
+      const linesGenerator = await getLineGenerator([
+        "```markdown README.md",
+        "# Project Structure",
+        "",
+        "```",
+        "debug-test-folder/",
+        "├── AdvancedPage.tsx",
+        "├── Calculator.java",
+        "└── test.ts",
+        "```",
+        "```",
+      ]);
+
+      const result = lineStream.filterCodeBlockLines(
+        linesGenerator,
+        "README.md",
+      );
+      const filteredLines = await getFilteredLines(result);
+
+      // Should include all content up to the final closing ```
+      expect(filteredLines).toEqual([
+        "# Project Structure",
+        "",
+        "```",
+        "debug-test-folder/",
+        "├── AdvancedPage.tsx",
+        "├── Calculator.java",
+        "└── test.ts",
+        "```",
+      ]);
+    });
+
+    // Markdown-aware tests
+    it("should handle markdown files with nested code blocks and a filename is excluded", async () => {
+      const linesGenerator = await getLineGenerator([
+        "```markdown README.md",
+        "# Project Structure",
+        "",
+        "```",
+        "debug-test-folder/",
+        "├── AdvancedPage.tsx",
+        "├── Calculator.java",
+        "└── test.ts",
+        "```",
+        "```",
+      ]);
+
+      const result = lineStream.filterCodeBlockLines(linesGenerator);
+      const filteredLines = await getFilteredLines(result);
+
+      // Should include all content up to the final closing ```
+      expect(filteredLines).toEqual([
+        "# Project Structure",
+        "",
+        "```",
+        "debug-test-folder/",
+        "├── AdvancedPage.tsx",
+        "├── Calculator.java",
+        "└── test.ts",
+        "```",
+      ]);
+    });
+
+    it("should handle non-markdown files normally with filepath parameter", async () => {
+      const linesGenerator = await getLineGenerator([
+        "```",
+        "function test() {",
+        "  return 'hello';",
+        "}",
+        "```",
+      ]);
+
+      const result = lineStream.filterCodeBlockLines(linesGenerator, "test.js");
+      const filteredLines = await getFilteredLines(result);
+
+      expect(filteredLines).toEqual([
+        "function test() {",
+        "  return 'hello';",
+        "}",
+      ]);
+    });
+
+    it("should handle simple markdown code blocks", async () => {
+      const linesGenerator = await getLineGenerator([
+        "```",
+        "Here's some code:",
+        "```",
+        "function example() {",
+        "  console.log('test');",
+        "}",
+        "```",
+      ]);
+
+      const result = lineStream.filterCodeBlockLines(
+        linesGenerator,
+        "README.md",
+      );
+      const filteredLines = await getFilteredLines(result);
+
+      // Should remove the outer markdown wrapper, and return just the inner content.
+      // The lack of an end tag should cause it to return all remaining lines.
+      expect(filteredLines).toEqual([
+        "Here's some code:",
+        "```",
+        "function example() {",
+        "  console.log('test');",
+        "}",
+        "```",
+      ]);
+    });
   });
 
   describe("filterEnglishLinesAtStart", () => {
@@ -613,4 +849,453 @@ describe("lineStream", () => {
       expect(mockFullStop).toHaveBeenCalledTimes(1);
     });
   });
+
+  // Tests for new helper functions
+
+  describe("hasNestedMarkdownBlocks", () => {
+    it("should detect nested markdown blocks from first line", () => {
+      expect(lineStream.hasNestedMarkdownBlocks("```markdown", undefined)).toBe(
+        true,
+      );
+      expect(lineStream.hasNestedMarkdownBlocks("```md", undefined)).toBe(true);
+      expect(lineStream.hasNestedMarkdownBlocks("```gfm", undefined)).toBe(
+        true,
+      );
+    });
+
+    it("should detect nested markdown blocks from filepath", () => {
+      expect(
+        lineStream.hasNestedMarkdownBlocks("```typescript", "README.md"),
+      ).toBe(true);
+      expect(
+        lineStream.hasNestedMarkdownBlocks("```javascript", "docs.markdown"),
+      ).toBe(true);
+    });
+
+    it("should return false for non-markdown scenarios", () => {
+      expect(
+        lineStream.hasNestedMarkdownBlocks("```typescript", "script.js"),
+      ).toBe(false);
+      expect(lineStream.hasNestedMarkdownBlocks("```python", undefined)).toBe(
+        false,
+      );
+      expect(
+        lineStream.hasNestedMarkdownBlocks("const x = 5;", undefined),
+      ).toBe(false);
+    });
+
+    it("should handle complex first line scenarios", () => {
+      expect(
+        lineStream.hasNestedMarkdownBlocks("```markdown README.md", undefined),
+      ).toBe(true);
+      expect(
+        lineStream.hasNestedMarkdownBlocks("```md with extra text", undefined),
+      ).toBe(true);
+    });
+  });
+
+  describe("collectAllLines", () => {
+    it("should collect all lines from a stream", async () => {
+      const linesGenerator = await getLineGenerator([
+        "line1",
+        "line2",
+        "line3",
+      ]);
+
+      const result = await collectAllLines(linesGenerator);
+
+      expect(result).toEqual(["line1", "line2", "line3"]);
+    });
+
+    it("should handle empty stream", async () => {
+      const linesGenerator = await getLineGenerator([]);
+
+      const result = await collectAllLines(linesGenerator);
+
+      expect(result).toEqual([]);
+    });
+
+    it("should handle stream with empty lines", async () => {
+      const linesGenerator = await getLineGenerator(["", "line2", "", "line4"]);
+
+      const result = await collectAllLines(linesGenerator);
+
+      expect(result).toEqual(["", "line2", "", "line4"]);
+    });
+  });
+
+  describe("shouldStopAtMarkdownBlock", () => {
+    it("should return false when current line is not closing backticks", () => {
+      const allLines = ["```markdown", "content", "more content"];
+      const state = new MarkdownBlockStateTracker(allLines);
+      expect(shouldStopAtMarkdownBlock(state, 2)).toBe(false);
+    });
+
+    it("should handle simple nested markdown case", () => {
+      const allLines = ["```markdown", "# Title", "```"];
+      const state = new MarkdownBlockStateTracker(allLines);
+      expect(shouldStopAtMarkdownBlock(state, 2)).toBe(true);
+    });
+
+    it("should handle complex nested markdown with inner code blocks", () => {
+      const allLines = [
+        "```markdown",
+        "# Title",
+        "```javascript",
+        "console.log('hello');",
+        "```",
+        "```",
+      ];
+      const state = new MarkdownBlockStateTracker(allLines);
+      // At index 4 (first inner closing), should not stop
+      expect(shouldStopAtMarkdownBlock(state, 4)).toBe(false);
+      // At index 5 (outer closing), should stop
+      expect(shouldStopAtMarkdownBlock(state, 5)).toBe(true);
+    });
+
+    it("should handle multiple bare backticks scenario", () => {
+      const allLines = [
+        "```markdown",
+        "Content with ```inline code```",
+        "```",
+        "More content",
+        "```",
+      ];
+      const state = new MarkdownBlockStateTracker(allLines);
+      // At index 2, should not stop (not the last bare backticks)
+      expect(shouldStopAtMarkdownBlock(state, 2)).toBe(false);
+      // At index 4, should stop (last bare backticks)
+      expect(shouldStopAtMarkdownBlock(state, 4)).toBe(true);
+    });
+  });
+
+  describe("shouldChangeLineAndStop", () => {
+    it("should handle [/CODE] at start of line", () => {
+      const result = lineStream.shouldChangeLineAndStop("[/CODE]");
+      expect(result).toBe("[/CODE]");
+    });
+
+    it("should handle [/CODE] with leading whitespace", () => {
+      const result = lineStream.shouldChangeLineAndStop("    [/CODE]");
+      expect(result).toBe("    [/CODE]");
+    });
+
+    it("should return partial line before [/CODE] when at start/after whitespace", () => {
+      const result = lineStream.shouldChangeLineAndStop(
+        "some code [/CODE] more text",
+      );
+      expect(result).toBe("some code");
+    });
+
+    it("should NOT trigger on [/CODE] within quotes or non-whitespace preceded", () => {
+      // This test demonstrates the current bug - it WILL fail initially
+      const result = lineStream.shouldChangeLineAndStop(
+        'console.log("test [/CODE] end");',
+      );
+      expect(result).toBeUndefined(); // Should not trigger stopping
+    });
+
+    it("should NOT trigger on [/CODE] in middle of identifier", () => {
+      // Another case that shows the bug
+      const result = lineStream.shouldChangeLineAndStop(
+        'const var[/CODE]Name = "test";',
+      );
+      expect(result).toBeUndefined(); // Should not trigger stopping
+    });
+
+    it("should handle ``` with trimStart correctly", () => {
+      const result = lineStream.shouldChangeLineAndStop("    ```");
+      expect(result).toBe("    ```");
+    });
+
+    it("should NOT handle ``` in middle of line", () => {
+      const result = lineStream.shouldChangeLineAndStop(
+        'console.log("test ``` end");',
+      );
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe("MarkdownBlockState", () => {
+    it("should initialize with correct state", () => {
+      const allLines = ["```markdown", "content", "```", "more content", "```"];
+      const state = new MarkdownBlockStateTracker(allLines);
+
+      // Test basic initialization - we can't directly test private properties,
+      // but we can test the behavior through shouldStopAtPosition
+      expect(state).toBeDefined();
+    });
+
+    it("should correctly identify bare backticks positions", () => {
+      const allLines = ["```markdown", "```", "content", "```"];
+      const state = new MarkdownBlockStateTracker(allLines);
+
+      // At position 1 (first bare backticks), should not stop
+      expect(state.shouldStopAtPosition(1)).toBe(false);
+      // At position 3 (last bare backticks), should stop
+      expect(state.shouldStopAtPosition(3)).toBe(true);
+    });
+
+    it("should maintain state across multiple calls", () => {
+      const allLines = [
+        "```markdown",
+        "# Title",
+        "```javascript",
+        "console.log('test');",
+        "```",
+        "More content",
+        "```",
+      ];
+      const state = new MarkdownBlockStateTracker(allLines);
+
+      // Process positions incrementally
+      expect(state.shouldStopAtPosition(2)).toBe(false); // Start of inner block
+      expect(state.shouldStopAtPosition(4)).toBe(false); // End of inner block
+      expect(state.shouldStopAtPosition(6)).toBe(true); // End of outer block
+    });
+
+    it("should handle complex nesting scenarios efficiently", () => {
+      const allLines = [
+        "```markdown",
+        "# Documentation",
+        "```typescript",
+        "interface Config {",
+        "  name: string;",
+        "}",
+        "```",
+        "",
+        "```bash",
+        "npm install",
+        "```",
+        "",
+        "Final notes",
+        "```",
+      ];
+      const state = new MarkdownBlockStateTracker(allLines);
+
+      // Test multiple positions in sequence
+      expect(state.shouldStopAtPosition(6)).toBe(false); // End of first inner block
+      expect(state.shouldStopAtPosition(10)).toBe(false); // End of second inner block
+      expect(state.shouldStopAtPosition(13)).toBe(true); // End of outer markdown block
+    });
+
+    it("should handle non-backtick lines correctly", () => {
+      const allLines = ["```markdown", "regular content", "```"];
+      const state = new MarkdownBlockStateTracker(allLines);
+
+      // Position 1 is not backticks, should return false
+      expect(state.shouldStopAtPosition(1)).toBe(false);
+    });
+
+    it("should handle empty lines and edge cases", () => {
+      const allLines = ["```markdown", "", "```"];
+      const state = new MarkdownBlockStateTracker(allLines);
+
+      expect(state.shouldStopAtPosition(1)).toBe(false); // Empty line
+      expect(state.shouldStopAtPosition(2)).toBe(true); // Closing backticks
+    });
+
+    it("should reset nest count when reaching final bare backticks", () => {
+      const allLines = ["```markdown", "content", "```"];
+      const state = new MarkdownBlockStateTracker(allLines);
+
+      // First call should stop and reset count
+      expect(state.shouldStopAtPosition(2)).toBe(true);
+
+      // If we had more content, it should start fresh
+      // (This tests the internal state management)
+    });
+  });
+
+  describe("shouldStopAtMarkdownBlock optimization", () => {
+    it("should maintain performance benefits with state reuse", () => {
+      const allLines = Array.from({ length: 100 }, (_, i) => {
+        if (i === 0) return "```markdown";
+        if (i === 99) return "```";
+        if (i % 10 === 0) return "```javascript";
+        if (i % 10 === 5) return "```";
+        return `line ${i}`;
+      });
+
+      const state = new MarkdownBlockStateTracker(allLines);
+
+      // Test that we can call multiple times without recomputing everything
+      const start = performance.now();
+
+      // Test several positions in sequence
+      for (let i = 10; i < 90; i += 10) {
+        if (allLines[i].trim() === "```") {
+          shouldStopAtMarkdownBlock(state, i);
+        }
+      }
+
+      const duration = performance.now() - start;
+      expect(duration).toBeLessThan(10); // Should be very fast due to state caching
+    });
+  });
+
+  describe("filterCodeBlockLines with optimized MarkdownBlockState", () => {
+    it("should use optimized state tracker for markdown files", async () => {
+      const linesGenerator = await getLineGenerator([
+        "```markdown",
+        "# Documentation",
+        "```typescript",
+        "const config = { name: 'test' };",
+        "```",
+        "Final notes",
+        "```",
+      ]);
+
+      const result = lineStream.filterCodeBlockLines(
+        linesGenerator,
+        "README.md",
+      );
+      const filteredLines = await getFilteredLines(result);
+
+      expect(filteredLines).toEqual([
+        "# Documentation",
+        "```typescript",
+        "const config = { name: 'test' };",
+        "```",
+        "Final notes",
+      ]);
+    });
+
+    it("should fall back to legacy behavior when no markdown nesting detected", async () => {
+      const linesGenerator = await getLineGenerator([
+        "```typescript",
+        "const x = 5;",
+        "```",
+      ]);
+
+      const result = lineStream.filterCodeBlockLines(
+        linesGenerator,
+        "script.ts",
+      );
+      const filteredLines = await getFilteredLines(result);
+
+      expect(filteredLines).toEqual(["const x = 5;"]);
+    });
+
+    it("should handle mixed markdown and code scenarios with optimization", async () => {
+      const linesGenerator = await getLineGenerator([
+        "```md",
+        "## API Reference",
+        "",
+        "```javascript",
+        "async function fetchData() {",
+        "  return await fetch('/api/data');",
+        "}",
+        "```",
+        "",
+        "Usage notes and more documentation.",
+        "```",
+      ]);
+
+      const result = lineStream.filterCodeBlockLines(linesGenerator);
+      const filteredLines = await getFilteredLines(result);
+
+      expect(filteredLines).toEqual([
+        "## API Reference",
+        "",
+        "```javascript",
+        "async function fetchData() {",
+        "  return await fetch('/api/data');",
+        "}",
+        "```",
+        "",
+        "Usage notes and more documentation.",
+      ]);
+    });
+  });
+
+  describe("validatePatternInLine", () => {
+    it("should return false when pattern is not found", () => {
+      const result = lineStream.validatePatternInLine(
+        "const x = 5;",
+        "[/CODE]",
+      );
+      expect(result.isValid).toBe(false);
+      expect(result.patternIndex).toBe(-1);
+      expect(result.beforePattern).toBe("");
+    });
+
+    it("should return false when pattern is preceded by non-whitespace", () => {
+      const result = lineStream.validatePatternInLine(
+        'const var[/CODE]Name = "test";',
+        "[/CODE]",
+      );
+      expect(result.isValid).toBe(false);
+      expect(result.patternIndex).toBe(9);
+    });
+
+    it("should return false when pattern is inside double quotes", () => {
+      const result = lineStream.validatePatternInLine(
+        'console.log("test [/CODE] end");',
+        "[/CODE]",
+      );
+      expect(result.isValid).toBe(false);
+      expect(result.patternIndex).toBe(18);
+    });
+
+    it("should return false when pattern is inside single quotes", () => {
+      const result = lineStream.validatePatternInLine(
+        "const message = 'test [/CODE] end';",
+        "[/CODE]",
+      );
+      expect(result.isValid).toBe(false);
+      expect(result.patternIndex).toBe(22);
+    });
+
+    it("should return true when pattern is properly separated by whitespace", () => {
+      const result = lineStream.validatePatternInLine(
+        "some code [/CODE] more text",
+        "[/CODE]",
+      );
+      expect(result.isValid).toBe(true);
+      expect(result.patternIndex).toBe(10);
+      expect(result.beforePattern).toBe("some code ");
+    });
+
+    it("should return true when pattern is at start of line", () => {
+      const result = lineStream.validatePatternInLine("[/CODE]", "[/CODE]");
+      expect(result.isValid).toBe(true);
+      expect(result.patternIndex).toBe(0);
+      expect(result.beforePattern).toBe("");
+    });
+
+    it("should return true when pattern has only whitespace before it", () => {
+      const result = lineStream.validatePatternInLine("    [/CODE]", "[/CODE]");
+      expect(result.isValid).toBe(true);
+      expect(result.patternIndex).toBe(4);
+      expect(result.beforePattern).toBe("    ");
+    });
+
+    it("should handle complex quote scenarios correctly", () => {
+      // Unmatched quote should make it invalid
+      const result1 = lineStream.validatePatternInLine(
+        'const x = "unclosed quote [/CODE]',
+        "[/CODE]",
+      );
+      expect(result1.isValid).toBe(false);
+
+      // Matched quotes should make it valid
+      const result2 = lineStream.validatePatternInLine(
+        'const x = "closed"; [/CODE]',
+        "[/CODE]",
+      );
+      expect(result2.isValid).toBe(true);
+    });
+
+    it("should work with different patterns", () => {
+      const result1 = lineStream.validatePatternInLine(
+        "# End of file. Done",
+        "# End of file.",
+      );
+      expect(result1.isValid).toBe(true);
+
+      const result2 = lineStream.validatePatternInLine("    ```", "```");
+      expect(result2.isValid).toBe(true);
+    });
+  });
 });
diff --git a/core/autocomplete/snippets/getAllSnippets.ts b/core/autocomplete/snippets/getAllSnippets.ts
index 702356198cb..079127abc44 100644
--- a/core/autocomplete/snippets/getAllSnippets.ts
+++ b/core/autocomplete/snippets/getAllSnippets.ts
@@ -11,6 +11,7 @@ import {
   AutocompleteCodeSnippet,
   AutocompleteDiffSnippet,
   AutocompleteSnippetType,
+  AutocompleteStaticSnippet,
 } from "./types";
 
 const IDE_SNIPPETS_ENABLED = false; // ideSnippets is not used, so it's temporarily disabled
@@ -24,6 +25,7 @@ export interface SnippetPayload {
   diffSnippets: AutocompleteDiffSnippet[];
   clipboardSnippets: AutocompleteClipboardSnippet[];
   recentlyOpenedFileSnippets: AutocompleteCodeSnippet[];
+  staticSnippet: AutocompleteStaticSnippet[];
 }
 
 function racePromise<T>(promise: Promise<T[]>, timeout = 100): Promise<T[]> {
@@ -185,6 +187,7 @@ export const getAllSnippets = async ({
     diffSnippets,
     clipboardSnippets,
     recentlyOpenedFileSnippets,
+    staticSnippet,
   ] = await Promise.all([
     racePromise(contextRetrievalService.getRootPathSnippets(helper)),
     racePromise(
@@ -196,6 +199,9 @@ export const getAllSnippets = async ({
     [], // racePromise(getDiffSnippets(ide)) // temporarily disabled, see https://github.com/continuedev/continue/pull/5882,
     racePromise(getClipboardSnippets(ide)),
     racePromise(getSnippetsFromRecentlyOpenedFiles(helper, ide)), // giving this one a little more time to complete
+    helper.options.experimental_enableStaticContextualization
+      ? racePromise(contextRetrievalService.getStaticContextSnippets(helper))
+      : [],
   ]);
 
   return {
@@ -207,6 +213,7 @@ export const getAllSnippets = async ({
     clipboardSnippets,
     recentlyVisitedRangesSnippets: helper.input.recentlyVisitedRanges,
     recentlyOpenedFileSnippets,
+    staticSnippet,
   };
 };
 
@@ -231,6 +238,7 @@ export const getAllSnippetsWithoutRace = async ({
     diffSnippets,
     clipboardSnippets,
     recentlyOpenedFileSnippets,
+    staticSnippet,
   ] = await Promise.all([
     contextRetrievalService.getRootPathSnippets(helper),
     contextRetrievalService.getSnippetsFromImportDefinitions(helper),
@@ -240,6 +248,9 @@ export const getAllSnippetsWithoutRace = async ({
     [], // racePromise(getDiffSnippets(ide)) // temporarily disabled, see https://github.com/continuedev/continue/pull/5882,
     getClipboardSnippets(ide),
     getSnippetsFromRecentlyOpenedFiles(helper, ide),
+    helper.options.experimental_enableStaticContextualization
+      ? contextRetrievalService.getStaticContextSnippets(helper)
+      : [],
   ]);
 
   return {
@@ -251,5 +262,6 @@ export const getAllSnippetsWithoutRace = async ({
     clipboardSnippets,
     recentlyVisitedRangesSnippets: helper.input.recentlyVisitedRanges,
     recentlyOpenedFileSnippets,
+    staticSnippet,
   };
 };
diff --git a/core/autocomplete/snippets/types.ts b/core/autocomplete/snippets/types.ts
index e43b59862a3..be820609b10 100644
--- a/core/autocomplete/snippets/types.ts
+++ b/core/autocomplete/snippets/types.ts
@@ -2,6 +2,7 @@ export enum AutocompleteSnippetType {
   Code = "code",
   Diff = "diff",
   Clipboard = "clipboard",
+  Static = "static",
 }
 
 interface BaseAutocompleteSnippet {
@@ -23,7 +24,13 @@ export interface AutocompleteClipboardSnippet extends BaseAutocompleteSnippet {
   copiedAt: string;
 }
 
+export interface AutocompleteStaticSnippet extends BaseAutocompleteSnippet {
+  type: AutocompleteSnippetType.Static;
+  filepath: string;
+}
+
 export type AutocompleteSnippet =
   | AutocompleteCodeSnippet
   | AutocompleteDiffSnippet
-  | AutocompleteClipboardSnippet;
+  | AutocompleteClipboardSnippet
+  | AutocompleteStaticSnippet;
diff --git a/core/autocomplete/templating/filtering.ts b/core/autocomplete/templating/filtering.ts
index 2abb98c7d44..94fe312e2f5 100644
--- a/core/autocomplete/templating/filtering.ts
+++ b/core/autocomplete/templating/filtering.ts
@@ -4,6 +4,7 @@ import {
   AutocompleteCodeSnippet,
   AutocompleteSnippet,
   AutocompleteSnippetType,
+  AutocompleteStaticSnippet,
 } from "../snippets/types";
 import { HelperVars } from "../util/HelperVars";
 import { formatOpenedFilesContext } from "./formatOpenedFilesContext";
@@ -32,9 +33,9 @@ const shuffleArray = <T>(array: T[]): T[] => {
 };
 
 function filterSnippetsAlreadyInCaretWindow(
-  snippets: AutocompleteCodeSnippet[],
+  snippets: (AutocompleteCodeSnippet | AutocompleteStaticSnippet)[],
   caretWindow: string,
-): AutocompleteCodeSnippet[] {
+): (AutocompleteCodeSnippet | AutocompleteStaticSnippet)[] {
   return snippets.filter(
     (s) => s.content.trim() !== "" && !caretWindow.includes(s.content.trim()),
   );
@@ -52,7 +53,11 @@ export const getSnippets = (
     recentlyOpenedFiles: payload.recentlyOpenedFileSnippets,
     base: shuffleArray(
       filterSnippetsAlreadyInCaretWindow(
-        [...payload.rootPathSnippets, ...payload.importDefinitionSnippets],
+        [
+          ...payload.rootPathSnippets,
+          ...payload.importDefinitionSnippets,
+          ...payload.staticSnippet,
+        ],
         helper.prunedCaretWindow,
       ),
     ),
@@ -107,7 +112,11 @@ export const getSnippets = (
       defaultPriority: 99, // make sure it's the last one to be processed, but still possible to override
       snippets: shuffleArray(
         filterSnippetsAlreadyInCaretWindow(
-          [...payload.rootPathSnippets, ...payload.importDefinitionSnippets],
+          [
+            ...payload.rootPathSnippets,
+            ...payload.importDefinitionSnippets,
+            ...payload.staticSnippet,
+          ],
           helper.prunedCaretWindow,
         ),
       ),
diff --git a/core/autocomplete/templating/formatting.ts b/core/autocomplete/templating/formatting.ts
index 2a91ad4384e..583873c2d30 100644
--- a/core/autocomplete/templating/formatting.ts
+++ b/core/autocomplete/templating/formatting.ts
@@ -5,6 +5,7 @@ import {
   AutocompleteDiffSnippet,
   AutocompleteSnippet,
   AutocompleteSnippetType,
+  AutocompleteStaticSnippet,
 } from "../snippets/types";
 import { HelperVars } from "../util/HelperVars";
 
@@ -51,6 +52,12 @@ const formatDiffSnippet = (
   return snippet;
 };
 
+const formatStaticSnippet = (
+  snippet: AutocompleteStaticSnippet,
+): AutocompleteStaticSnippet => {
+  return snippet;
+};
+
 const commentifySnippet = (
   helper: HelperVars,
   snippet: AutocompleteSnippet,
@@ -81,6 +88,8 @@ export const formatSnippets = (
             return formatDiffSnippet(snippet);
           case AutocompleteSnippetType.Clipboard:
             return formatClipboardSnippet(snippet, workspaceDirs);
+          case AutocompleteSnippetType.Static:
+            return formatStaticSnippet(snippet);
         }
       })
       .map((item) => {
diff --git a/core/autocomplete/util/AutocompleteLoggingService.ts b/core/autocomplete/util/AutocompleteLoggingService.ts
index 2e4d19844ef..58b3d2d0dbc 100644
--- a/core/autocomplete/util/AutocompleteLoggingService.ts
+++ b/core/autocomplete/util/AutocompleteLoggingService.ts
@@ -105,24 +105,27 @@ export class AutocompleteLoggingService {
     });
 
     const { prompt, completion, prefix, suffix, ...restOfOutcome } = outcome;
-    void Telemetry.capture(
-      "autocomplete",
-      {
-        accepted: restOfOutcome.accepted,
-        cacheHit: restOfOutcome.cacheHit,
-        completionId: restOfOutcome.completionId,
-        completionOptions: restOfOutcome.completionOptions,
-        debounceDelay: restOfOutcome.debounceDelay,
-        fileExtension: getUriFileExtension(restOfOutcome.filepath),
-        maxPromptTokens: restOfOutcome.maxPromptTokens,
-        modelName: restOfOutcome.modelName,
-        modelProvider: restOfOutcome.modelProvider,
-        multilineCompletions: restOfOutcome.multilineCompletions,
-        time: restOfOutcome.time,
-        useRecentlyEdited: restOfOutcome.useRecentlyEdited,
-        numLines: restOfOutcome.numLines,
-      },
-      true,
-    );
+    const toLog = {
+      accepted: restOfOutcome.accepted,
+      cacheHit: restOfOutcome.cacheHit,
+      completionId: restOfOutcome.completionId,
+      completionOptions: restOfOutcome.completionOptions,
+      debounceDelay: restOfOutcome.debounceDelay,
+      fileExtension: getUriFileExtension(restOfOutcome.filepath),
+      maxPromptTokens: restOfOutcome.maxPromptTokens,
+      modelName: restOfOutcome.modelName,
+      modelProvider: restOfOutcome.modelProvider,
+      multilineCompletions: restOfOutcome.multilineCompletions,
+      time: restOfOutcome.time,
+      useRecentlyEdited: restOfOutcome.useRecentlyEdited,
+      numLines: restOfOutcome.numLines,
+    };
+
+    outcome.enabledStaticContextualization
+      ? void Telemetry.capture("autocomplete", {
+          ...toLog,
+          enabledStaticContextualization: true,
+        })
+      : void Telemetry.capture("autocomplete", toLog);
   }
 }
diff --git a/core/autocomplete/util/types.ts b/core/autocomplete/util/types.ts
index 1d5bb72869b..0a993da6a7b 100644
--- a/core/autocomplete/util/types.ts
+++ b/core/autocomplete/util/types.ts
@@ -38,4 +38,5 @@ export interface AutocompleteOutcome extends TabAutocompleteOptions {
   completionId: string;
   uniqueId: string;
   timestamp: string;
+  enabledStaticContextualization?: boolean;
 }
diff --git a/core/commands/slash/customSlashCommand.ts b/core/commands/slash/customSlashCommand.ts
index c27a41f4cde..9526cbca89c 100644
--- a/core/commands/slash/customSlashCommand.ts
+++ b/core/commands/slash/customSlashCommand.ts
@@ -11,5 +11,6 @@ export function convertCustomCommandToSlashCommand(
     description: customCommand.description ?? "",
     prompt: customCommand.prompt,
     source: "json-custom-command",
+    promptFile: customCommand.sourceFile, // TODO refactor promptFile to align with sourceFile
   };
 }
diff --git a/core/commands/slash/promptBlockSlashCommand.ts b/core/commands/slash/promptBlockSlashCommand.ts
index 00530b8bda4..4f3446a21dd 100644
--- a/core/commands/slash/promptBlockSlashCommand.ts
+++ b/core/commands/slash/promptBlockSlashCommand.ts
@@ -9,5 +9,6 @@ export function convertPromptBlockToSlashCommand(
     description: prompt.description ?? "",
     prompt: prompt.prompt,
     source: "yaml-prompt-block",
+    promptFile: prompt.sourceFile, // Align with the sourceFile property
   };
 }
diff --git a/core/config/ConfigHandler.ts b/core/config/ConfigHandler.ts
index bea67960a2a..600bc9dcf77 100644
--- a/core/config/ConfigHandler.ts
+++ b/core/config/ConfigHandler.ts
@@ -433,7 +433,7 @@ export class ConfigHandler {
     if (!this.currentProfile) {
       return {
         config: undefined,
-        errors: [],
+        errors: [{ message: "Current profile not found", fatal: true }],
         configLoadInterrupted: true,
       };
     }
@@ -496,7 +496,7 @@ export class ConfigHandler {
     if (!this.currentProfile) {
       return {
         config: undefined,
-        errors: [],
+        errors: [{ message: "Current profile not found", fatal: true }],
         configLoadInterrupted: true,
       };
     }
@@ -510,7 +510,7 @@ export class ConfigHandler {
     if (!this.currentProfile) {
       return {
         config: undefined,
-        errors: [],
+        errors: [{ message: "Current profile not found", fatal: true }],
         configLoadInterrupted: true,
       };
     }
@@ -526,7 +526,10 @@ export class ConfigHandler {
     return config;
   }
 
-  async openConfigProfile(profileId?: string) {
+  async openConfigProfile(
+    profileId?: string,
+    element?: { sourceFile?: string },
+  ) {
     let openProfileId = profileId || this.currentProfile?.profileDescription.id;
     if (!openProfileId) {
       return;
@@ -534,8 +537,10 @@ export class ConfigHandler {
     const profile = this.currentOrg.profiles.find(
       (p) => p.profileDescription.id === openProfileId,
     );
+
     if (profile?.profileDescription.profileType === "local") {
-      await this.ide.openFile(profile.profileDescription.uri);
+      const configFile = element?.sourceFile ?? profile.profileDescription.uri;
+      await this.ide.openFile(configFile);
     } else {
       const env = await getControlPlaneEnv(this.ide.getIdeSettings());
       await this.ide.openUrl(`${env.APP_URL}${openProfileId}`);
diff --git a/core/config/load.ts b/core/config/load.ts
index 17630b18399..6002dba6d76 100644
--- a/core/config/load.ts
+++ b/core/config/load.ts
@@ -663,6 +663,7 @@ function llmToSerializedModelDescription(llm: ILLM): ModelDescription {
     configurationStatus: llm.getConfigurationStatus(),
     apiKeyLocation: llm.apiKeyLocation,
     envSecretLocations: llm.envSecretLocations,
+    sourceFile: llm.sourceFile,
   };
 }
 
diff --git a/core/config/sharedConfig.ts b/core/config/sharedConfig.ts
index c720f4272aa..568a30af823 100644
--- a/core/config/sharedConfig.ts
+++ b/core/config/sharedConfig.ts
@@ -22,6 +22,7 @@ export const sharedConfigSchema = z
     optInNextEditFeature: z.boolean(),
     enableExperimentalTools: z.boolean(),
     codebaseToolCallingOnly: z.boolean(),
+    enableStaticContextualization: z.boolean(),
 
     // `ui` in `ContinueConfig`
     showSessionTabs: z.boolean(),
@@ -188,6 +189,10 @@ export function modifyAnyConfigWithSharedConfig<
     configCopy.experimental.codebaseToolCallingOnly =
       sharedConfig.codebaseToolCallingOnly;
   }
+  if (sharedConfig.enableStaticContextualization !== undefined) {
+    configCopy.experimental.enableStaticContextualization =
+      sharedConfig.enableStaticContextualization;
+  }
 
   return configCopy;
 }
diff --git a/core/config/yaml/loadYaml.ts b/core/config/yaml/loadYaml.ts
index d9b024e2701..641c26936aa 100644
--- a/core/config/yaml/loadYaml.ts
+++ b/core/config/yaml/loadYaml.ts
@@ -60,6 +60,8 @@ function convertYamlRuleToContinueRule(rule: Rule): RuleWithSource {
       rule: rule.rule,
       globs: rule.globs,
       name: rule.name,
+      ruleFile: rule.sourceFile,
+      alwaysApply: rule.alwaysApply,
     };
   }
 }
@@ -239,8 +241,8 @@ async function configYamlToContinueConfig(options: {
     startUrl: doc.startUrl,
     rootUrl: doc.rootUrl,
     faviconUrl: doc.faviconUrl,
-    maxDepth: doc.maxDepth,
     useLocalCrawling: doc.useLocalCrawling,
+    sourceFile: doc.sourceFile,
   }));
 
   config.mcpServers?.forEach((mcpServer) => {
@@ -446,6 +448,7 @@ async function configYamlToContinueConfig(options: {
     (config.mcpServers ?? []).map((server) => ({
       id: server.name,
       name: server.name,
+      sourceFile: server.sourceFile,
       transport: {
         type: "stdio",
         args: [],
diff --git a/core/core.ts b/core/core.ts
index 16db61e246c..a978d2530f9 100644
--- a/core/core.ts
+++ b/core/core.ts
@@ -354,7 +354,10 @@ export class Core {
     });
 
     on("config/openProfile", async (msg) => {
-      await this.configHandler.openConfigProfile(msg.data.profileId);
+      await this.configHandler.openConfigProfile(
+        msg.data.profileId,
+        msg.data?.element,
+      );
     });
 
     on("config/reload", async (msg) => {
diff --git a/core/edit/lazy/replace.ts b/core/edit/lazy/replace.ts
index 1a5ba704df3..e7ec47dc9f5 100644
--- a/core/edit/lazy/replace.ts
+++ b/core/edit/lazy/replace.ts
@@ -1,8 +1,5 @@
 import { ILLM } from "../..";
-import {
-  filterLeadingNewline,
-  stopAtLines,
-} from "../../autocomplete/filtering/streamTransforms/lineStream";
+import { filterLeadingNewline } from "../../autocomplete/filtering/streamTransforms/lineStream";
 import { streamLines } from "../../diff/util";
 import { dedent } from "../../util";
 
@@ -90,11 +87,18 @@ export async function* getReplacementWithLlm(
       { role: "assistant", content: assistantPrompt },
     ],
     abortController.signal,
+    {
+      raw: true,
+      prediction: undefined,
+      reasoning: false,
+    },
   );
 
   let lines = streamLines(completion);
   lines = filterLeadingNewline(lines);
-  lines = stopAtLines(lines, () => {}, ["```"]);
+  // We want to retrive everything from the llm
+  // then let the filterCodeBlocks function clean up for any trailing text.
+  // if we stop here early, we run the risk of loosing inner markdown content.
 
   for await (const line of lines) {
     yield line;
diff --git a/core/edit/lazy/streamLazyApply.test.ts b/core/edit/lazy/streamLazyApply.test.ts
new file mode 100644
index 00000000000..3a829b5f47c
--- /dev/null
+++ b/core/edit/lazy/streamLazyApply.test.ts
@@ -0,0 +1,459 @@
+import { streamLazyApply } from "./streamLazyApply";
+
+// Mock LLM for testing
+class MockLLM {
+  model = "claude-3-5-sonnet-20241022";
+  providerName = "anthropic";
+
+  async *streamChat(messages: any[], signal?: AbortSignal) {
+    // Simulate LLM response for markdown file with nested blocks
+    const lines = [
+      "# Project Structure",
+      "",
+      "```markdown README.md",
+      "# Project Structure",
+      "",
+      "```",
+      ".",
+      "├── src/",
+      "│   └── main.js",
+      "└── package.json",
+      "```",
+      "```",
+    ];
+
+    // Yield each line separately (more realistic streaming)
+    for (const line of lines) {
+      yield line;
+    }
+  }
+}
+
+class MockJavaScriptLLM {
+  model = "claude-3-5-sonnet-20241022";
+  providerName = "anthropic";
+
+  async *streamChat(messages: any[], signal?: AbortSignal) {
+    // Simulate LLM response for JavaScript file
+    const lines = [
+      "function calculateSum(a, b) {",
+      "  return a + b;",
+      "}",
+      "",
+      "function calculateProduct(a, b) {",
+      "  return a * b;",
+      "}",
+    ];
+
+    for (const line of lines) {
+      yield line;
+    }
+  }
+}
+
+class MockPythonLLM {
+  model = "claude-3-5-sonnet-20241022";
+  providerName = "anthropic";
+
+  async *streamChat(messages: any[], signal?: AbortSignal) {
+    // Simulate LLM response for Python file
+    const lines = [
+      "def calculate_sum(a, b):",
+      "    return a + b",
+      "",
+      "def calculate_product(a, b):",
+      "    return a * b",
+    ];
+
+    for (const line of lines) {
+      yield line;
+    }
+  }
+}
+
+class MockWithUnchangedCodeLLM {
+  model = "claude-3-5-sonnet-20241022";
+  providerName = "anthropic";
+
+  async *streamChat(messages: any[], signal?: AbortSignal) {
+    // Simulate LLM response with UNCHANGED_CODE markers
+    const lines = [
+      "function newFunction() {",
+      "  return 'new';",
+      "}",
+      "",
+      "// ... unchanged code ...",
+      "",
+      "function anotherFunction() {",
+      "  return 'updated';",
+      "}",
+    ];
+
+    for (const line of lines) {
+      yield line;
+    }
+  }
+}
+
+class MockTypeScriptLLM {
+  model = "claude-3-5-sonnet-20241022";
+  providerName = "anthropic";
+
+  async *streamChat(messages: any[], signal?: AbortSignal) {
+    const lines = [
+      "interface User {",
+      "  id: number;",
+      "  name: string;",
+      "}",
+      "",
+      "function getUser(id: number): User {",
+      "  return { id, name: 'Test User' };",
+      "}",
+    ];
+
+    for (const line of lines) {
+      yield line;
+    }
+  }
+}
+
+class MockEmptyLLM {
+  model = "claude-3-5-sonnet-20241022";
+  providerName = "anthropic";
+
+  async *streamChat(messages: any[], signal?: AbortSignal) {
+    // Empty response
+    return;
+  }
+}
+
+class MockSimpleLLM {
+  model = "claude-3-5-sonnet-20241022";
+  providerName = "anthropic";
+
+  async *streamChat(messages: any[], signal?: AbortSignal) {
+    const lines = ["function test() {", "  return true;", "}"];
+    for (const line of lines) {
+      yield line;
+    }
+  }
+}
+
+class MockRegularMarkdownLLM {
+  model = "claude-3-5-sonnet-20241022";
+  providerName = "anthropic";
+
+  async *streamChat(messages: any[], signal?: AbortSignal) {
+    // Simulate regular markdown with simple code block
+    const lines = [
+      "# Debug Test Folder",
+      "The sole purpose of this folder is to open it when debugging.",
+      "",
+      "## File Structure",
+      "```",
+      "debug-test-folder/",
+      "├── AdvancedPage.tsx",
+      "├── Calculator.java",
+      "├── Dockerfile",
+      "└── test.ts",
+      "```",
+    ];
+
+    for (const line of lines) {
+      yield line;
+    }
+  }
+}
+
+describe("streamLazyApply", () => {
+  test("should handle markdown files with nested blocks without stopping early", async () => {
+    const oldCode = "# Project\n\nBasic readme content.";
+    const newCode = `# Project Structure
+
+\`\`\`markdown README.md
+# Project Structure
+
+\`\`\`
+.
+├── src/
+│   └── main.js
+└── package.json
+\`\`\`
+\`\`\``;
+    const filename = "README.md";
+    const llm = new MockLLM() as any;
+    const abortController = new AbortController();
+
+    const diffLines = [];
+    for await (const diffLine of streamLazyApply(
+      oldCode,
+      filename,
+      newCode,
+      llm,
+      abortController,
+    )) {
+      diffLines.push(diffLine);
+    }
+
+    // Should have received diff lines (not empty)
+    expect(diffLines.length).toBeGreaterThan(0);
+
+    // Should contain the nested markdown content
+    const allContent = diffLines.map((d) => d.line).join("\n");
+    expect(allContent).toContain("```markdown README.md");
+    expect(allContent).toContain("└── package.json");
+
+    // Should not have been truncated at the first ```
+    expect(allContent).toContain("src/");
+  });
+
+  test("should handle JavaScript files correctly", async () => {
+    const oldCode = "function calculateSum(a, b) {\n  return a + b;\n}";
+    const newCode = `function calculateSum(a, b) {
+  return a + b;
+}
+
+function calculateProduct(a, b) {
+  return a * b;
+}`;
+    const filename = "calculator.js";
+    const llm = new MockJavaScriptLLM() as any;
+    const abortController = new AbortController();
+
+    const diffLines = [];
+    for await (const diffLine of streamLazyApply(
+      oldCode,
+      filename,
+      newCode,
+      llm,
+      abortController,
+    )) {
+      diffLines.push(diffLine);
+    }
+
+    // Should have received diff lines
+    expect(diffLines.length).toBeGreaterThan(0);
+
+    // Should contain the JavaScript functions
+    const allContent = diffLines.map((d) => d.line).join("\n");
+    expect(allContent).toContain("calculateSum");
+    expect(allContent).toContain("calculateProduct");
+  });
+
+  test("should handle Python files correctly", async () => {
+    const oldCode = "def calculate_sum(a, b):\n    return a + b";
+    const newCode = `def calculate_sum(a, b):
+    return a + b
+
+def calculate_product(a, b):
+    return a * b`;
+    const filename = "calculator.py";
+    const llm = new MockPythonLLM() as any;
+    const abortController = new AbortController();
+
+    const diffLines = [];
+    for await (const diffLine of streamLazyApply(
+      oldCode,
+      filename,
+      newCode,
+      llm,
+      abortController,
+    )) {
+      diffLines.push(diffLine);
+    }
+
+    // Should have received diff lines
+    expect(diffLines.length).toBeGreaterThan(0);
+
+    // Should contain the Python functions
+    const allContent = diffLines.map((d) => d.line).join("\n");
+    expect(allContent).toContain("calculate_sum");
+    expect(allContent).toContain("calculate_product");
+  });
+
+  test("should handle UNCHANGED_CODE markers in responses", async () => {
+    const oldCode = `function oldFunction() {
+  return 'old';
+}
+
+function existingFunction() {
+  return 'existing';
+}`;
+    const newCode = `function newFunction() {
+  return 'new';
+}
+
+function existingFunction() {
+  return 'existing';
+}
+
+function anotherFunction() {
+  return 'updated';
+}`;
+    const filename = "example.js";
+    const llm = new MockWithUnchangedCodeLLM() as any;
+    const abortController = new AbortController();
+
+    const diffLines = [];
+    for await (const diffLine of streamLazyApply(
+      oldCode,
+      filename,
+      newCode,
+      llm,
+      abortController,
+    )) {
+      diffLines.push(diffLine);
+    }
+
+    // Should have received diff lines
+    expect(diffLines.length).toBeGreaterThan(0);
+
+    // Should contain new and updated functions
+    const allContent = diffLines.map((d) => d.line).join("\n");
+    expect(allContent).toContain("newFunction");
+    expect(allContent).toContain("anotherFunction");
+  });
+
+  test("should handle TypeScript files correctly", async () => {
+    const oldCode = "interface User {\n  id: number;\n}";
+    const newCode = `interface User {
+  id: number;
+  name: string;
+}
+
+function getUser(id: number): User {
+  return { id, name: 'Test User' };
+}`;
+    const filename = "user.ts";
+    const llm = new MockTypeScriptLLM() as any;
+    const abortController = new AbortController();
+
+    const diffLines = [];
+    for await (const diffLine of streamLazyApply(
+      oldCode,
+      filename,
+      newCode,
+      llm,
+      abortController,
+    )) {
+      diffLines.push(diffLine);
+    }
+
+    // Should have received diff lines
+    expect(diffLines.length).toBeGreaterThan(0);
+
+    // Should contain TypeScript interface and function
+    const allContent = diffLines.map((d) => d.line).join("\n");
+    expect(allContent).toContain("interface User");
+    expect(allContent).toContain("getUser");
+    expect(allContent).toContain("name: string");
+  });
+
+  test("should work with empty LLM responses", async () => {
+    const oldCode = "function test() { return 1; }";
+    const newCode = "function test() { return 2; }";
+    const filename = "test.js";
+    const llm = new MockEmptyLLM() as any;
+    const abortController = new AbortController();
+
+    const diffLines = [];
+    for await (const diffLine of streamLazyApply(
+      oldCode,
+      filename,
+      newCode,
+      llm,
+      abortController,
+    )) {
+      diffLines.push(diffLine);
+    }
+
+    // Should handle empty response gracefully
+    expect(diffLines).toBeDefined();
+  });
+
+  test("should correctly identify markdown vs non-markdown files", async () => {
+    // Test that our isMarkdownFile logic works
+    const markdownFiles = ["README.md", "docs.markdown", "example.gfm"];
+    const nonMarkdownFiles = [
+      "script.js",
+      "code.py",
+      "style.css",
+      "component.tsx",
+    ];
+
+    // This is more of a unit test, but verifies our file detection logic
+    // We can test this indirectly by checking that different file types
+    // are processed through different code paths
+
+    const oldCode = "function test() { return false; }";
+    const newCode = "function test() { return true; }";
+    const llm = new MockSimpleLLM() as any;
+
+    // Test each file type
+    for (const filename of [...markdownFiles, ...nonMarkdownFiles]) {
+      const abortController = new AbortController();
+      const diffLines = [];
+
+      for await (const diffLine of streamLazyApply(
+        oldCode,
+        filename,
+        newCode,
+        llm,
+        abortController,
+      )) {
+        diffLines.push(diffLine);
+      }
+
+      // Should work for all file types
+      expect(diffLines.length).toBeGreaterThan(0);
+
+      const allContent = diffLines.map((d) => d.line).join("\n");
+      expect(allContent).toContain("test");
+    }
+  });
+
+  test("should handle regular markdown files with simple code blocks", async () => {
+    const oldCode = "# Old Content";
+    const newCode = `# Debug Test Folder
+The sole purpose of this folder is to open it when debugging.
+
+## File Structure
+\`\`\`
+debug-test-folder/
+├── AdvancedPage.tsx
+├── Calculator.java
+├── Dockerfile
+└── test.ts
+\`\`\``;
+
+    const filename = "README.md";
+    const llm = new MockRegularMarkdownLLM() as any;
+    const abortController = new AbortController();
+
+    const diffLines = [];
+    for await (const diffLine of streamLazyApply(
+      oldCode,
+      filename,
+      newCode,
+      llm,
+      abortController,
+    )) {
+      diffLines.push(diffLine);
+    }
+
+    // Should have received diff lines (not empty)
+    expect(diffLines.length).toBeGreaterThan(0);
+
+    // Should contain the full file structure
+    const allContent = diffLines.map((d) => d.line).join("\n");
+    expect(allContent).toContain("Debug Test Folder");
+    expect(allContent).toContain("File Structure");
+    expect(allContent).toContain("debug-test-folder/");
+    expect(allContent).toContain("├── AdvancedPage.tsx");
+    expect(allContent).toContain("└── test.ts");
+
+    // Should not have been truncated at the opening ```
+    expect(allContent).toContain("Calculator.java");
+    expect(allContent).toContain("Dockerfile");
+  });
+});
diff --git a/core/edit/lazy/streamLazyApply.ts b/core/edit/lazy/streamLazyApply.ts
index f8ec0905c69..f806e956f4c 100644
--- a/core/edit/lazy/streamLazyApply.ts
+++ b/core/edit/lazy/streamLazyApply.ts
@@ -2,11 +2,11 @@ import {
   filterLeadingAndTrailingNewLineInsertion,
   filterLeadingNewline,
   removeTrailingWhitespace,
-  stopAtLines,
 } from "../../autocomplete/filtering/streamTransforms/lineStream.js";
 import { streamDiff } from "../../diff/streamDiff.js";
 import { LineStream, streamLines } from "../../diff/util.js";
 import { DiffLine, ILLM } from "../../index.js";
+import { stopAtLinesWithMarkdownSupport } from "../../utils/streamMarkdownUtils.js";
 
 import { lazyApplyPromptForModel, UNCHANGED_CODE } from "./prompts.js";
 import { BUFFER_LINES_BELOW, getReplacementWithLlm } from "./replace.js";
@@ -44,9 +44,12 @@ export async function* streamLazyApply(
   }
 
   let lazyCompletionLines = streamLines(lazyCompletion, true);
-  // Process line output
-  // lazyCompletionLines = filterEnglishLinesAtStart(lazyCompletionLines);
-  lazyCompletionLines = stopAtLines(lazyCompletionLines, () => {}, ["```"]);
+
+  lazyCompletionLines = stopAtLinesWithMarkdownSupport(
+    lazyCompletionLines,
+    filename,
+  );
+
   lazyCompletionLines = filterLeadingNewline(lazyCompletionLines);
   lazyCompletionLines = removeTrailingWhitespace(lazyCompletionLines);
 
@@ -92,7 +95,6 @@ async function* streamFillUnchangedCode(
           newLines.push(replacementLine);
           replacement += replacementLine + "\n";
         }
-
         // Yield the buffered lines
         for (const bufferedLine of buffer) {
           yield bufferedLine;
diff --git a/core/edit/recursiveStream.ts b/core/edit/recursiveStream.ts
index 004563cdb42..d249755f4ac 100644
--- a/core/edit/recursiveStream.ts
+++ b/core/edit/recursiveStream.ts
@@ -63,7 +63,8 @@ export async function* recursiveStream(
     }
   } else {
     const generator = llm.streamChat(prompt, abortController.signal, {
-      prediction,
+      raw: true,
+      prediction: undefined,
       reasoning: false,
     });
 
diff --git a/core/edit/streamDiffLines.ts b/core/edit/streamDiffLines.ts
index c2cd32b0e2c..7cf1af2f741 100644
--- a/core/edit/streamDiffLines.ts
+++ b/core/edit/streamDiffLines.ts
@@ -55,11 +55,7 @@ export async function* addIndentation(
 }
 
 function modelIsInept(model: string): boolean {
-  return !(
-    model.includes("gpt") ||
-    model.includes("claude") ||
-    model.includes("nova")
-  );
+  return !(model.includes("gpt") || model.includes("claude"));
 }
 
 export async function* streamDiffLines({
diff --git a/core/index.d.ts b/core/index.d.ts
index aca447d9887..5cd3c7be42a 100644
--- a/core/index.d.ts
+++ b/core/index.d.ts
@@ -238,6 +238,7 @@ export interface SiteIndexingConfig {
   maxDepth?: number;
   faviconUrl?: string;
   useLocalCrawling?: boolean;
+  sourceFile?: string;
 }
 
 export interface DocsIndexingDetails {
@@ -661,6 +662,8 @@ export interface LLMOptions {
   deploymentId?: string;
 
   env?: Record<string, string | number | boolean>;
+
+  sourceFile?: string;
 }
 
 type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<
@@ -875,6 +878,8 @@ export interface IDE {
 
   // LSP
   gotoDefinition(location: Location): Promise<RangeInFile[]>;
+  gotoTypeDefinition(location: Location): Promise<RangeInFile[]>; // TODO: add to jetbrains
+  getSignatureHelp(location: Location): Promise<SignatureHelp | null>; // TODO: add to jetbrains
 
   // Callbacks
   onDidChangeActiveTextEditor(callback: (fileUri: string) => void): void;
@@ -1039,6 +1044,7 @@ export interface CustomCommand {
   name: string;
   prompt: string;
   description?: string;
+  sourceFile?: string;
 }
 
 export interface Prediction {
@@ -1156,6 +1162,8 @@ export interface ModelDescription {
   capabilities?: ModelCapability;
   roles?: ModelRole[];
   configurationStatus?: LLMConfigurationStatuses;
+
+  sourceFile?: string;
 }
 
 export interface JSONEmbedOptions {
@@ -1213,6 +1221,7 @@ export interface TabAutocompleteOptions {
   experimental_includeRecentlyVisitedRanges: boolean | number;
   experimental_includeRecentlyEditedRanges: boolean | number;
   experimental_includeDiff: boolean | number;
+  experimental_enableStaticContextualization: boolean;
 }
 
 export interface StdioOptions {
@@ -1310,6 +1319,7 @@ export interface MCPServerStatus extends MCPOptions {
   tools: MCPTool[];
   resources: MCPResource[];
   resourceTemplates: MCPResourceTemplate[];
+  sourceFile?: string;
 }
 
 export interface ContinueUIConfig {
@@ -1412,6 +1422,68 @@ export interface RangeInFileWithNextEditInfo {
 
 export type SetCodeToEditPayload = RangeInFileWithContents | FileWithContents;
 
+/**
+ * Signature help represents the signature of something
+ * callable. There can be multiple signatures but only one
+ * active and only one active parameter.
+ */
+export class SignatureHelp {
+  /**
+   * One or more signatures.
+   */
+  signatures: SignatureInformation[];
+
+  /**
+   * The active signature.
+   */
+  activeSignature: number;
+
+  /**
+   * The active parameter of the active signature.
+   */
+  activeParameter: number;
+}
+
+/**
+ * Represents the signature of something callable. A signature
+ * can have a label, like a function-name, a doc-comment, and
+ * a set of parameters.
+ */
+export class SignatureInformation {
+  /**
+   * The label of this signature. Will be shown in
+   * the UI.
+   */
+  label: string;
+
+  /**
+   * The parameters of this signature.
+   */
+  parameters: ParameterInformation[];
+
+  /**
+   * The index of the active parameter.
+   *
+   * If provided, this is used in place of {@linkcode SignatureHelp.activeParameter}.
+   */
+  activeParameter?: number;
+}
+
+/**
+ * Represents a parameter of a callable-signature. A parameter can
+ * have a label and a doc-comment.
+ */
+export class ParameterInformation {
+  /**
+   * The label of this signature.
+   *
+   * Either a string or inclusive start and exclusive end offsets within its containing
+   * {@link SignatureInformation.label signature label}. *Note*: A label of type string must be
+   * a substring of its containing signature information's {@link SignatureInformation.label label}.
+   */
+  label: string | [number, number];
+}
+
 /**
  * Represents the configuration for a quick action in the Code Lens.
  * Quick actions are custom commands that can be added to function and class declarations.
@@ -1482,6 +1554,12 @@ export interface ExperimentalConfig {
    * instead of embeddings, FTS, recently edited files, etc.
    */
   codebaseToolCallingOnly?: boolean;
+
+  /**
+   * If enabled, static contextualization will be used to
+   * gather context for the model where necessary.
+   */
+  enableStaticContextualization?: boolean;
 }
 
 export interface AnalyticsConfig {
diff --git a/core/llm/index.ts b/core/llm/index.ts
index fa16b8591d6..0df366bbf25 100644
--- a/core/llm/index.ts
+++ b/core/llm/index.ts
@@ -187,6 +187,9 @@ export abstract class BaseLLM implements ILLM {
   maxEmbeddingChunkSize: number;
   maxEmbeddingBatchSize: number;
 
+  //URI to local block defining this LLM
+  sourceFile?: string;
+
   private _llmOptions: LLMOptions;
 
   protected openaiAdapter?: BaseLlmApi;
@@ -290,6 +293,7 @@ export abstract class BaseLLM implements ILLM {
     this.embeddingId = `${this.constructor.name}::${this.model}::${this.maxEmbeddingChunkSize}`;
 
     this.autocompleteOptions = options.autocompleteOptions;
+    this.sourceFile = options.sourceFile;
   }
 
   getConfigurationStatus() {
diff --git a/core/llm/llms/Anthropic.ts b/core/llm/llms/Anthropic.ts
index 98a6f14f170..1f3647e0cff 100644
--- a/core/llm/llms/Anthropic.ts
+++ b/core/llm/llms/Anthropic.ts
@@ -172,52 +172,10 @@ class Anthropic extends BaseLLM {
     }
   }
 
-  protected async *_streamChat(
-    messages: ChatMessage[],
-    signal: AbortSignal,
-    options: CompletionOptions,
+  async *handleResponse(
+    response: any,
+    stream: boolean | undefined,
   ): AsyncGenerator<ChatMessage> {
-    if (!this.apiKey || this.apiKey === "") {
-      throw new Error(
-        "Request not sent. You have an Anthropic model configured in your config.json, but the API key is not set.",
-      );
-    }
-
-    const systemMessage = stripImages(
-      messages.filter((m) => m.role === "system")[0]?.content ?? "",
-    );
-    const shouldCacheSystemMessage = !!(
-      this.cacheBehavior?.cacheSystemMessage && systemMessage
-    );
-
-    const msgs = this.convertMessages(messages);
-    const response = await this.fetch(new URL("messages", this.apiBase), {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        "anthropic-version": "2023-06-01",
-        "x-api-key": this.apiKey as string,
-        ...(shouldCacheSystemMessage || this.cacheBehavior?.cacheConversation
-          ? { "anthropic-beta": "prompt-caching-2024-07-31" }
-          : {}),
-      },
-      body: JSON.stringify({
-        ...this.convertArgs(options),
-        messages: msgs,
-        system: shouldCacheSystemMessage
-          ? [
-              {
-                type: "text",
-                text: systemMessage,
-                cache_control: { type: "ephemeral" },
-              },
-            ]
-          : systemMessage,
-      }),
-      signal,
-    });
-
     if (response.status === 499) {
       return; // Aborted by user
     }
@@ -237,7 +195,7 @@ class Anthropic extends BaseLLM {
       );
     }
 
-    if (options.stream === false) {
+    if (stream === false) {
       const data = await response.json();
       const cost = data.usage
         ? {
@@ -348,6 +306,55 @@ class Anthropic extends BaseLLM {
       usage,
     };
   }
+
+  protected async *_streamChat(
+    messages: ChatMessage[],
+    signal: AbortSignal,
+    options: CompletionOptions,
+  ): AsyncGenerator<ChatMessage> {
+    if (!this.apiKey || this.apiKey === "") {
+      throw new Error(
+        "Request not sent. You have an Anthropic model configured in your config.json, but the API key is not set.",
+      );
+    }
+
+    const systemMessage = stripImages(
+      messages.filter((m) => m.role === "system")[0]?.content ?? "",
+    );
+    const shouldCacheSystemMessage = !!(
+      this.cacheBehavior?.cacheSystemMessage && systemMessage
+    );
+
+    const msgs = this.convertMessages(messages);
+    const response = await this.fetch(new URL("messages", this.apiBase), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "anthropic-version": "2023-06-01",
+        "x-api-key": this.apiKey as string,
+        ...(shouldCacheSystemMessage || this.cacheBehavior?.cacheConversation
+          ? { "anthropic-beta": "prompt-caching-2024-07-31" }
+          : {}),
+      },
+      body: JSON.stringify({
+        ...this.convertArgs(options),
+        messages: msgs,
+        system: shouldCacheSystemMessage
+          ? [
+              {
+                type: "text",
+                text: systemMessage,
+                cache_control: { type: "ephemeral" },
+              },
+            ]
+          : systemMessage,
+      }),
+      signal,
+    });
+
+    yield* this.handleResponse(response, options.stream);
+  }
 }
 
 export default Anthropic;
diff --git a/core/llm/llms/Gemini.ts b/core/llm/llms/Gemini.ts
index c6d32b501fe..7caf2db7d75 100644
--- a/core/llm/llms/Gemini.ts
+++ b/core/llm/llms/Gemini.ts
@@ -200,6 +200,7 @@ class Gemini extends BaseLLM {
     messages: ChatMessage[],
     options: CompletionOptions,
     isV1API: boolean,
+    includeToolIds: boolean,
   ): GeminiChatRequestBody {
     const toolCallIdToNameMap = new Map<string, string>();
     messages.forEach((msg) => {
@@ -231,7 +232,7 @@ class Gemini extends BaseLLM {
               parts: [
                 {
                   functionResponse: {
-                    id: msg.toolCallId,
+                    id: includeToolIds ? msg.toolCallId : undefined,
                     name: functionName || "unknown",
                     response: {
                       output: msg.content, // "output" key is opinionated - not all functions will output objects
@@ -406,7 +407,7 @@ class Gemini extends BaseLLM {
     const isV1API = !!this.apiBase?.includes("/v1/");
 
     // Convert chat messages to contents
-    const body = this.prepareBody(messages, options, isV1API);
+    const body = this.prepareBody(messages, options, isV1API, true);
 
     const response = await this.fetch(apiURL, {
       method: "POST",
diff --git a/core/llm/llms/Mistral.ts b/core/llm/llms/Mistral.ts
index 2174220502a..7e9c7769429 100644
--- a/core/llm/llms/Mistral.ts
+++ b/core/llm/llms/Mistral.ts
@@ -67,7 +67,7 @@ class Mistral extends OpenAI {
     return Mistral.modelConversion[model] ?? model;
   }
 
-  protected _convertArgs(options: any, messages: ChatMessage[]) {
+  _convertArgs(options: any, messages: ChatMessage[]) {
     const finalOptions = super._convertArgs(options, messages);
 
     const lastMessage = finalOptions.messages[finalOptions.messages.length - 1];
diff --git a/core/llm/llms/VertexAI.ts b/core/llm/llms/VertexAI.ts
index c3c2c9bf4d6..cb828bedb50 100644
--- a/core/llm/llms/VertexAI.ts
+++ b/core/llm/llms/VertexAI.ts
@@ -254,24 +254,7 @@ class VertexAI extends BaseLLM {
       signal,
     });
 
-    if (response.status === 499) {
-      return; // Aborted by user
-    }
-
-    if (options.stream === false) {
-      const data = await response.json();
-      yield { role: "assistant", content: data.content[0].text };
-      return;
-    }
-
-    for await (const value of streamSse(response)) {
-      if (value.type === "message_start") {
-        console.log(value);
-      }
-      if (value.delta?.text) {
-        yield { role: "assistant", content: value.delta.text };
-      }
-    }
+    yield* this.anthropicInstance.handleResponse(response, options.stream);
   }
 
   // Gemini
@@ -285,17 +268,19 @@ class VertexAI extends BaseLLM {
       this.apiBase,
     );
 
-    const body = this.geminiInstance.prepareBody(messages, options, false);
+    // For some reason gemini through vertex does not support ids in functionResponses yet
+    const body = this.geminiInstance.prepareBody(
+      messages,
+      options,
+      false,
+      false,
+    );
     const response = await this.fetch(apiURL, {
       method: "POST",
       body: JSON.stringify(body),
       signal,
     });
-    for await (const message of this.geminiInstance.processGeminiResponse(
-      streamResponse(response),
-    )) {
-      yield message;
-    }
+    yield* this.geminiInstance.processGeminiResponse(streamResponse(response));
   }
 
   private async *streamChatBison(
diff --git a/core/llm/toolSupport.ts b/core/llm/toolSupport.ts
index aa98c65a766..8bf88e3d49f 100644
--- a/core/llm/toolSupport.ts
+++ b/core/llm/toolSupport.ts
@@ -83,11 +83,12 @@ export const PROVIDER_TOOL_SUPPORT: Record<string, (model: string) => boolean> =
       return model.toLowerCase().includes("gemini");
     },
     vertexai: (model) => {
+      const lowerCaseModel = model.toLowerCase();
       // All gemini models except flash 2.0 lite support function calling
-      return (
-        model.toLowerCase().includes("gemini") &&
-        !model.toLowerCase().includes("lite")
-      );
+      if (lowerCaseModel.includes("lite")) {
+        return false;
+      }
+      return ["claude", "gemini"].some((val) => lowerCaseModel.includes(val));
     },
     bedrock: (model) => {
       if (
diff --git a/core/protocol/core.ts b/core/protocol/core.ts
index 3f648bbb77c..71dec36cebe 100644
--- a/core/protocol/core.ts
+++ b/core/protocol/core.ts
@@ -102,7 +102,10 @@ export type ToCoreFromIdeOrWebviewProtocol = {
     ),
     void,
   ];
-  "config/openProfile": [{ profileId: string | undefined }, void];
+  "config/openProfile": [
+    { profileId: string | undefined; element?: { sourceFile?: string } },
+    void,
+  ];
   "config/updateSharedConfig": [SharedConfigSchema, SharedConfigSchema];
   "config/updateSelectedModel": [
     {
diff --git a/core/protocol/ide.ts b/core/protocol/ide.ts
index ba4cf4f880b..c67b8c94a3d 100644
--- a/core/protocol/ide.ts
+++ b/core/protocol/ide.ts
@@ -10,6 +10,7 @@ import type {
   Problem,
   Range,
   RangeInFile,
+  SignatureHelp,
   TerminalOptions,
   Thread,
 } from "../";
@@ -82,6 +83,8 @@ export type ToIdeFromWebviewOrCoreProtocol = {
   getFileStats: [{ files: string[] }, FileStatsMap];
 
   gotoDefinition: [{ location: Location }, RangeInFile[]];
+  gotoTypeDefinition: [{ location: Location }, RangeInFile[]];
+  getSignatureHelp: [{ location: Location }, SignatureHelp | null];
 
   getControlPlaneSessionInfo: [
     { silent: boolean; useOnboarding: boolean },
diff --git a/core/protocol/messenger/messageIde.ts b/core/protocol/messenger/messageIde.ts
index 30d9b817740..2365117c095 100644
--- a/core/protocol/messenger/messageIde.ts
+++ b/core/protocol/messenger/messageIde.ts
@@ -13,6 +13,7 @@ import type {
   Problem,
   Range,
   RangeInFile,
+  SignatureHelp,
   TerminalOptions,
   Thread,
 } from "../..";
@@ -45,6 +46,14 @@ export class MessageIde implements IDE {
     return this.request("gotoDefinition", { location });
   }
 
+  async gotoTypeDefinition(location: Location): Promise<RangeInFile[]> {
+    return this.request("gotoTypeDefinition", { location });
+  }
+
+  async getSignatureHelp(location: Location): Promise<SignatureHelp | null> {
+    return this.request("getSignatureHelp", { location });
+  }
+
   onDidChangeActiveTextEditor(callback: (fileUri: string) => void): void {
     this.on("didChangeActiveTextEditor", (data) => callback(data.filepath));
   }
diff --git a/core/tools/definitions/createRuleBlock.ts b/core/tools/definitions/createRuleBlock.ts
index 92aecb15862..8f19c5955eb 100644
--- a/core/tools/definitions/createRuleBlock.ts
+++ b/core/tools/definitions/createRuleBlock.ts
@@ -16,7 +16,7 @@ export const createRuleBlock: Tool = {
       'Creates a "rule" that can be referenced in future conversations. This should be used whenever you want to establish code standards / preferences that should be applied consistently, or when you want to avoid making a mistake again. To modify existing rules, use the edit tool instead.\n\nRule Types:\n- Always: Include only "rule" (always included in model context)\n- Auto Attached: Include "rule", "globs", and/or "regex" (included when files match patterns)\n- Agent Requested: Include "rule" and "description" (AI decides when to apply based on description)\n- Manual: Include only "rule" (only included when explicitly mentioned using @ruleName)',
     parameters: {
       type: "object",
-      required: ["name", "rule", "description"],
+      required: ["name", "rule"],
       properties: {
         name: {
           type: "string",
diff --git a/core/tools/definitions/ls.ts b/core/tools/definitions/ls.ts
index 979f9450b4d..71f4e5cf97f 100644
--- a/core/tools/definitions/ls.ts
+++ b/core/tools/definitions/ls.ts
@@ -16,12 +16,11 @@ export const lsTool: Tool = {
     description: "List files and folders in a given directory",
     parameters: {
       type: "object",
-      required: ["dirPath", "recursive"],
       properties: {
         dirPath: {
           type: "string",
           description:
-            "The directory path relative to the root of the project. Always use forward slash paths like '/'. rather than e.g. '.'",
+            "The directory path relative to the root of the project. Use forward slash paths like '/'. rather than e.g. '.'",
         },
         recursive: {
           type: "boolean",
diff --git a/core/tools/definitions/runTerminalCommand.ts b/core/tools/definitions/runTerminalCommand.ts
index f9ddd4f9a5c..fe5e032de5c 100644
--- a/core/tools/definitions/runTerminalCommand.ts
+++ b/core/tools/definitions/runTerminalCommand.ts
@@ -20,7 +20,7 @@ export function getPreferredShell(): string {
   }
 }
 
-export const PLATFORM_INFO = `Choose terminal commands and scripts optimized for ${os.platform} and ${os.arch} and shell ${getPreferredShell()}.`;
+export const PLATFORM_INFO = `Choose terminal commands and scripts optimized for ${os.platform()} and ${os.arch()} and shell ${getPreferredShell()}.`;
 
 export const runTerminalCommandTool: Tool = {
   type: "function",
diff --git a/core/tools/implementations/codebaseTool.ts b/core/tools/implementations/codebaseTool.ts
index fe4f77aceb9..4af0579bfd0 100644
--- a/core/tools/implementations/codebaseTool.ts
+++ b/core/tools/implementations/codebaseTool.ts
@@ -1,22 +1,15 @@
 import { ToolImpl } from ".";
 import { RangeInFile } from "../..";
 import { retrieveContextItemsFromEmbeddings } from "../../context/retrieval/retrieval";
+import { getStringArg } from "../parseArgs";
 
 export const codebaseToolImpl: ToolImpl = async (args, extras) => {
-  if (!args.query || args.query.trim() === "") {
-    return [
-      {
-        name: "Error",
-        description: "Codebase search error",
-        content: "Query parameter is required and cannot be empty.",
-      },
-    ];
-  }
+  const query = getStringArg(args, "query");
 
   try {
     const contextExtras = {
       config: extras.config,
-      fullInput: args.query,
+      fullInput: query,
       embeddingsProvider: extras.config.selectedModelByRole.embed,
       reranker: extras.config.selectedModelByRole.rerank,
       llm: extras.llm,
@@ -39,7 +32,7 @@ export const codebaseToolImpl: ToolImpl = async (args, extras) => {
         {
           name: "No Results",
           description: "Codebase search",
-          content: `No relevant code found for query: "${args.query}". This could mean:
+          content: `No relevant code found for query: "${query}". This could mean:
 - The codebase hasn't been indexed yet
 - No code matches the search criteria
 - Embeddings provider is not configured
diff --git a/core/tools/implementations/createNewFile.ts b/core/tools/implementations/createNewFile.ts
index 5b18f03d3ab..0677e7dcd0f 100644
--- a/core/tools/implementations/createNewFile.ts
+++ b/core/tools/implementations/createNewFile.ts
@@ -2,20 +2,24 @@ import { inferResolvedUriFromRelativePath } from "../../util/ideUtils";
 
 import { ToolImpl } from ".";
 import { getCleanUriPath, getUriPathBasename } from "../../util/uri";
+import { getStringArg } from "../parseArgs";
 
 export const createNewFileImpl: ToolImpl = async (args, extras) => {
+  const filepath = getStringArg(args, "filepath");
+  const contents = getStringArg(args, "contents", true);
+
   const resolvedFileUri = await inferResolvedUriFromRelativePath(
-    args.filepath,
+    filepath,
     extras.ide,
   );
   if (resolvedFileUri) {
     const exists = await extras.ide.fileExists(resolvedFileUri);
     if (exists) {
       throw new Error(
-        `File ${args.filepath} already exists. Use the edit tool to edit this file`,
+        `File ${filepath} already exists. Use the edit tool to edit this file`,
       );
     }
-    await extras.ide.writeFile(resolvedFileUri, args.contents);
+    await extras.ide.writeFile(resolvedFileUri, contents);
     await extras.ide.openFile(resolvedFileUri);
     await extras.ide.saveFile(resolvedFileUri);
     if (extras.codeBaseIndexer) {
diff --git a/core/tools/implementations/createRuleBlock.ts b/core/tools/implementations/createRuleBlock.ts
index e433c233db3..8e8ebcf9019 100644
--- a/core/tools/implementations/createRuleBlock.ts
+++ b/core/tools/implementations/createRuleBlock.ts
@@ -2,6 +2,11 @@ import { createRuleMarkdown } from "@continuedev/config-yaml";
 import { ToolImpl } from ".";
 import { RuleWithSource } from "../..";
 import { createRuleFilePath } from "../../config/markdown/utils";
+import {
+  getBooleanArg,
+  getOptionalStringArg,
+  getStringArg,
+} from "../parseArgs";
 
 export type CreateRuleBlockArgs = Pick<
   Required<RuleWithSource>,
@@ -9,11 +14,21 @@ export type CreateRuleBlockArgs = Pick<
 > &
   Pick<RuleWithSource, "globs" | "regex" | "description" | "alwaysApply">;
 
-export const createRuleBlockImpl: ToolImpl = async (
-  { name, rule, ...otherArgs }: CreateRuleBlockArgs,
-  extras,
-) => {
-  const fileContent = createRuleMarkdown(name, rule, otherArgs);
+export const createRuleBlockImpl: ToolImpl = async (args, extras) => {
+  const name = getStringArg(args, "name");
+  const rule = getStringArg(args, "rule");
+
+  const description = getOptionalStringArg(args, "description");
+  const regex = getOptionalStringArg(args, "regex");
+  const globs = getOptionalStringArg(args, "globs");
+  const alwaysApply = getBooleanArg(args, "alwaysApply", false);
+
+  const fileContent = createRuleMarkdown(name, rule, {
+    alwaysApply,
+    description,
+    globs,
+    regex,
+  });
 
   const [localContinueDir] = await extras.ide.getWorkspaceDirs();
   const ruleFilePath = createRuleFilePath(localContinueDir, name);
@@ -24,7 +39,7 @@ export const createRuleBlockImpl: ToolImpl = async (
   return [
     {
       name: "New Rule Block",
-      description: otherArgs.description || "",
+      description: description || "",
       uri: {
         type: "file",
         value: ruleFilePath,
diff --git a/core/tools/implementations/fetchUrlContent.ts b/core/tools/implementations/fetchUrlContent.ts
index 16259780a68..95b5b216b05 100644
--- a/core/tools/implementations/fetchUrlContent.ts
+++ b/core/tools/implementations/fetchUrlContent.ts
@@ -1,10 +1,13 @@
 import { ToolImpl } from ".";
 import { getUrlContextItems } from "../../context/providers/URLContextProvider";
+import { getStringArg } from "../parseArgs";
 
 const DEFAULT_FETCH_URL_CHAR_LIMIT = 20000;
 
 export const fetchUrlContentImpl: ToolImpl = async (args, extras) => {
-  const contextItems = await getUrlContextItems(args.url, extras.fetch);
+  const url = getStringArg(args, "url");
+
+  const contextItems = await getUrlContextItems(url, extras.fetch);
 
   // Track truncated content
   const truncatedUrls: string[] = [];
@@ -12,7 +15,7 @@ export const fetchUrlContentImpl: ToolImpl = async (args, extras) => {
   // Check and truncate each context item
   const processedItems = contextItems.map((item) => {
     if (item.content.length > DEFAULT_FETCH_URL_CHAR_LIMIT) {
-      truncatedUrls.push(args.url);
+      truncatedUrls.push(url);
       return {
         ...item,
         content: item.content.substring(0, DEFAULT_FETCH_URL_CHAR_LIMIT),
diff --git a/core/tools/implementations/globSearch.ts b/core/tools/implementations/globSearch.ts
index 1e551d9e2d7..04a105556a4 100644
--- a/core/tools/implementations/globSearch.ts
+++ b/core/tools/implementations/globSearch.ts
@@ -1,10 +1,13 @@
 import { ToolImpl } from ".";
 import { ContextItem } from "../..";
+import { getStringArg } from "../parseArgs";
 
 const MAX_AGENT_GLOB_RESULTS = 100;
+
 export const fileGlobSearchImpl: ToolImpl = async (args, extras) => {
+  const pattern = getStringArg(args, "pattern");
   const results = await extras.ide.getFileResults(
-    args.pattern,
+    pattern,
     MAX_AGENT_GLOB_RESULTS,
   );
   const contextItems: ContextItem[] = [
diff --git a/core/tools/implementations/grepSearch.ts b/core/tools/implementations/grepSearch.ts
index b1383966930..b75c21891d9 100644
--- a/core/tools/implementations/grepSearch.ts
+++ b/core/tools/implementations/grepSearch.ts
@@ -1,6 +1,7 @@
 import { ToolImpl } from ".";
 import { ContextItem } from "../..";
 import { formatGrepSearchResults } from "../../util/grepSearch";
+import { getStringArg } from "../parseArgs";
 
 const DEFAULT_GREP_SEARCH_RESULTS_LIMIT = 100;
 const DEFAULT_GREP_SEARCH_CHAR_LIMIT = 5000; // ~1000 tokens, will keep truncation simply for now
@@ -41,8 +42,10 @@ function splitGrepResultsByFile(content: string): ContextItem[] {
 }
 
 export const grepSearchImpl: ToolImpl = async (args, extras) => {
+  const query = getStringArg(args, "query");
+
   const results = await extras.ide.getSearchResults(
-    args.query,
+    query,
     DEFAULT_GREP_SEARCH_RESULTS_LIMIT,
   );
   const { formatted, numResults, truncated } = formatGrepSearchResults(
@@ -63,7 +66,7 @@ export const grepSearchImpl: ToolImpl = async (args, extras) => {
 
   let contextItems: ContextItem[] = [];
 
-  const splitByFile: boolean = args.splitByFile || false;
+  const splitByFile: boolean = args?.splitByFile || false;
   if (splitByFile) {
     contextItems = splitGrepResultsByFile(formatted);
   } else {
diff --git a/core/tools/implementations/readFile.ts b/core/tools/implementations/readFile.ts
index 4736d0b4c8d..a026d0f47d3 100644
--- a/core/tools/implementations/readFile.ts
+++ b/core/tools/implementations/readFile.ts
@@ -2,28 +2,28 @@ import { resolveRelativePathInDir } from "../../util/ideUtils";
 import { getUriPathBasename } from "../../util/uri";
 
 import { ToolImpl } from ".";
+import { getStringArg } from "../parseArgs";
 import { throwIfFileExceedsHalfOfContext } from "./readFileLimit";
 
 export const readFileImpl: ToolImpl = async (args, extras) => {
-  const firstUriMatch = await resolveRelativePathInDir(
-    args.filepath,
-    extras.ide,
-  );
+  const filepath = getStringArg(args, "filepath");
+
+  const firstUriMatch = await resolveRelativePathInDir(filepath, extras.ide);
   if (!firstUriMatch) {
-    throw new Error(`Could not find file ${args.filepath}`);
+    throw new Error(`Could not find file ${filepath}`);
   }
   const content = await extras.ide.readFile(firstUriMatch);
 
   await throwIfFileExceedsHalfOfContext(
-    args.filepath,
+    filepath,
     content,
     extras.config.selectedModelByRole.chat,
   );
 
   return [
     {
-      name: getUriPathBasename(args.filepath),
-      description: args.filepath,
+      name: getUriPathBasename(firstUriMatch),
+      description: filepath,
       content,
       uri: {
         type: "file",
diff --git a/core/tools/implementations/requestRule.ts b/core/tools/implementations/requestRule.ts
index a8801f344a1..61467e429e9 100644
--- a/core/tools/implementations/requestRule.ts
+++ b/core/tools/implementations/requestRule.ts
@@ -1,13 +1,14 @@
 import { ToolImpl } from ".";
+import { getStringArg } from "../parseArgs";
 
 export const requestRuleImpl: ToolImpl = async (args, extras) => {
+  const name = getStringArg(args, "name");
+
   // Find the rule by name in the config
-  const rule = extras.config.rules.find((r) => r.name === args.name);
+  const rule = extras.config.rules.find((r) => r.name === name);
 
   if (!rule || !rule.ruleFile) {
-    throw new Error(
-      `Rule with name "${args.name}" not found or has no file path`,
-    );
+    throw new Error(`Rule with name "${name}" not found or has no file path`);
   }
 
   return [
diff --git a/core/tools/implementations/runTerminalCommand.ts b/core/tools/implementations/runTerminalCommand.ts
index 3336a100685..201d7635817 100644
--- a/core/tools/implementations/runTerminalCommand.ts
+++ b/core/tools/implementations/runTerminalCommand.ts
@@ -24,6 +24,7 @@ import {
   isProcessBackgrounded,
   removeBackgroundedProcess,
 } from "../../util/processTerminalBackgroundStates";
+import { getBooleanArg, getStringArg } from "../parseArgs";
 
 const asyncExec = util.promisify(childProcess.exec);
 
@@ -50,8 +51,11 @@ const ENABLED_FOR_REMOTES = [
 ];
 
 export const runTerminalCommandImpl: ToolImpl = async (args, extras) => {
+  const command = getStringArg(args, "command");
   // Default to waiting for completion if not specified
-  const waitForCompletion = args.waitForCompletion !== false;
+  const waitForCompletion =
+    getBooleanArg(args, "waitForCompletion", false) ?? true;
+
   const ideInfo = await extras.ide.getIdeInfo();
   const toolCallId = extras.toolCallId || "";
 
@@ -84,7 +88,7 @@ export const runTerminalCommandImpl: ToolImpl = async (args, extras) => {
               }
 
               // Use spawn with color environment
-              const childProc = childProcess.spawn(args.command, {
+              const childProc = childProcess.spawn(command, {
                 cwd,
                 shell: true,
                 env: getColorEnv(), // Add enhanced environment for colors
@@ -229,7 +233,7 @@ export const runTerminalCommandImpl: ToolImpl = async (args, extras) => {
         // Standard execution, waiting for completion
         try {
           // Use color environment for exec as well
-          const output = await asyncExec(args.command, {
+          const output = await asyncExec(command, {
             cwd,
             env: getColorEnv(),
           });
@@ -258,7 +262,7 @@ export const runTerminalCommandImpl: ToolImpl = async (args, extras) => {
         // but don't attach any listeners other than error
         try {
           // Use spawn with color environment
-          const childProc = childProcess.spawn(args.command, {
+          const childProc = childProcess.spawn(command, {
             cwd,
             shell: true,
             env: getColorEnv(), // Add color environment
@@ -309,7 +313,7 @@ export const runTerminalCommandImpl: ToolImpl = async (args, extras) => {
 
   // For remote environments, just run the command
   // Note: waitForCompletion is not supported in remote environments yet
-  await extras.ide.runCommand(args.command);
+  await extras.ide.runCommand(command);
   return [
     {
       name: "Terminal",
diff --git a/core/tools/implementations/searchWeb.ts b/core/tools/implementations/searchWeb.ts
index c7b64feb367..3d331ebfd62 100644
--- a/core/tools/implementations/searchWeb.ts
+++ b/core/tools/implementations/searchWeb.ts
@@ -1,10 +1,13 @@
 import { ToolImpl } from ".";
 import { fetchSearchResults } from "../../context/providers/WebContextProvider";
+import { getStringArg } from "../parseArgs";
 
 const DEFAULT_WEB_SEARCH_CHAR_LIMIT = 8000;
 
 export const searchWebImpl: ToolImpl = async (args, extras) => {
-  const webResults = await fetchSearchResults(args.query, 5, extras.fetch);
+  const query = getStringArg(args, "query");
+
+  const webResults = await fetchSearchResults(query, 5, extras.fetch);
 
   // Track truncated results
   const truncatedResults: string[] = [];
diff --git a/core/tools/implementations/viewSubdirectory.ts b/core/tools/implementations/viewSubdirectory.ts
index c62887dc5be..b7897aae8a4 100644
--- a/core/tools/implementations/viewSubdirectory.ts
+++ b/core/tools/implementations/viewSubdirectory.ts
@@ -2,9 +2,11 @@ import generateRepoMap from "../../util/generateRepoMap";
 import { resolveRelativePathInDir } from "../../util/ideUtils";
 
 import { ToolImpl } from ".";
+import { getStringArg } from "../parseArgs";
 
 export const viewSubdirectoryImpl: ToolImpl = async (args: any, extras) => {
-  const { directory_path } = args;
+  const directory_path = getStringArg(args, "directory_path");
+
   const uri = await resolveRelativePathInDir(directory_path, extras.ide);
 
   if (!uri) {
diff --git a/core/tools/parseArgs.ts b/core/tools/parseArgs.ts
index 8ee794eb5cb..1e7709ddc26 100644
--- a/core/tools/parseArgs.ts
+++ b/core/tools/parseArgs.ts
@@ -12,3 +12,52 @@ export function safeParseToolCallArgs(
     return {};
   }
 }
+
+export function getStringArg(
+  args: any,
+  argName: string,
+  allowEmpty = false,
+): string {
+  if (!args || !(argName in args) || typeof args[argName] !== "string") {
+    throw new Error(
+      `\`${argName}\` argument is required${allowEmpty ? "" : " and must not be empty"}. (type string)`,
+    );
+  }
+  if (!allowEmpty && !args[argName].trim()) {
+    throw new Error(`Argument ${argName} must not be empty`);
+  }
+  return args[argName];
+}
+
+export function getOptionalStringArg(
+  args: any,
+  argName: string,
+  allowEmpty = false,
+) {
+  if (typeof args?.[argName] === "undefined") {
+    return undefined;
+  }
+  return getStringArg(args, argName, allowEmpty);
+}
+
+export function getBooleanArg(args: any, argName: string, required = false) {
+  if (!args || !(argName in args)) {
+    if (required) {
+      throw new Error(`Argument \`${argName}\` is required (type boolean)`);
+    } else {
+      return undefined;
+    }
+  }
+  if (typeof args[argName] === "string") {
+    if (args[argName].toLowerCase() === "false") {
+      return false;
+    }
+    if (args[argName].toLowerCase() === "true") {
+      return true;
+    }
+  }
+  if (typeof args[argName] !== "boolean") {
+    throw new Error(`Argument \`${argName}\` must be a boolean true or false`);
+  }
+  return args[argName];
+}
diff --git a/core/tools/parseArgs.vitest.ts b/core/tools/parseArgs.vitest.ts
new file mode 100644
index 00000000000..b501191f0f6
--- /dev/null
+++ b/core/tools/parseArgs.vitest.ts
@@ -0,0 +1,248 @@
+import { describe, expect, it } from "vitest";
+import { ToolCallDelta } from "..";
+import {
+  getBooleanArg,
+  getOptionalStringArg,
+  getStringArg,
+  safeParseToolCallArgs,
+} from "./parseArgs";
+
+describe("safeParseToolCallArgs", () => {
+  it("should parse valid JSON arguments", () => {
+    const toolCall: ToolCallDelta = {
+      id: "1",
+      function: {
+        name: "testFunction",
+        arguments: '{"name": "test", "value": 123}',
+      },
+    };
+
+    const result = safeParseToolCallArgs(toolCall);
+    expect(result).toEqual({ name: "test", value: 123 });
+  });
+
+  it("should parse valid JSON arguments with whitespace", () => {
+    const toolCall: ToolCallDelta = {
+      id: "1",
+      function: {
+        name: "testFunction",
+        arguments: '  {"name": "test", "value": 123}  ',
+      },
+    };
+
+    const result = safeParseToolCallArgs(toolCall);
+    expect(result).toEqual({ name: "test", value: 123 });
+  });
+
+  it("should return empty object for invalid JSON", () => {
+    const toolCall: ToolCallDelta = {
+      id: "1",
+      function: {
+        name: "testFunction",
+        arguments: '{"name": "test", value: 123', // Invalid JSON
+      },
+    };
+
+    const result = safeParseToolCallArgs(toolCall);
+    expect(result).toEqual({});
+  });
+
+  it("should return empty object when arguments is empty", () => {
+    const toolCall: ToolCallDelta = {
+      id: "1",
+      function: {
+        name: "testFunction",
+        arguments: "",
+      },
+    };
+
+    const result = safeParseToolCallArgs(toolCall);
+    expect(result).toEqual({});
+  });
+
+  it("should return empty object when arguments is null or undefined", () => {
+    const toolCall1: ToolCallDelta = {
+      id: "1",
+      function: {
+        name: "testFunction",
+        arguments: null as any,
+      },
+    };
+
+    const toolCall2: ToolCallDelta = {
+      id: "1",
+      function: {
+        name: "testFunction",
+        arguments: undefined,
+      },
+    };
+
+    expect(safeParseToolCallArgs(toolCall1)).toEqual({});
+    expect(safeParseToolCallArgs(toolCall2)).toEqual({});
+  });
+
+  it("should handle case when function is undefined", () => {
+    const toolCall: ToolCallDelta = {
+      id: "1",
+      function: undefined,
+    };
+
+    const result = safeParseToolCallArgs(toolCall);
+    expect(result).toEqual({});
+  });
+});
+
+describe("getStringArg", () => {
+  it("should return string argument when valid", () => {
+    const args = { name: "test" };
+    const result = getStringArg(args, "name");
+    expect(result).toBe("test");
+  });
+
+  it("should throw error when argument is missing", () => {
+    const args = { otherArg: "test" };
+    expect(() => getStringArg(args, "name")).toThrowError(
+      "`name` argument is required and must not be empty. (type string)",
+    );
+  });
+
+  it("should throw error when argument is not a string", () => {
+    const args = { name: 123 };
+    expect(() => getStringArg(args, "name")).toThrowError(
+      "`name` argument is required and must not be empty. (type string)",
+    );
+  });
+
+  it("should throw error when argument is empty and empty not allowed", () => {
+    const args = { name: "" };
+    expect(() => getStringArg(args, "name")).toThrowError(
+      "Argument name must not be empty",
+    );
+
+    const argsWithSpace = { name: "   " };
+    expect(() => getStringArg(argsWithSpace, "name")).toThrowError(
+      "Argument name must not be empty",
+    );
+  });
+
+  it("should accept empty string when allowEmpty is true", () => {
+    const args = { name: "" };
+    const result = getStringArg(args, "name", true);
+    expect(result).toBe("");
+
+    const argsWithSpace = { name: "   " };
+    const resultWithSpace = getStringArg(argsWithSpace, "name", true);
+    expect(resultWithSpace).toBe("   ");
+  });
+
+  it("should handle null or undefined args", () => {
+    expect(() => getStringArg(null, "name")).toThrowError(
+      "`name` argument is required and must not be empty. (type string)",
+    );
+    expect(() => getStringArg(undefined, "name")).toThrowError(
+      "`name` argument is required and must not be empty. (type string)",
+    );
+  });
+});
+
+describe("getOptionalStringArg", () => {
+  it("should return undefined when argument is not provided", () => {
+    const args = { otherArg: "test" };
+    const result = getOptionalStringArg(args, "name");
+    expect(result).toBeUndefined();
+  });
+
+  it("should return string argument when valid", () => {
+    const args = { name: "test" };
+    const result = getOptionalStringArg(args, "name");
+    expect(result).toBe("test");
+  });
+
+  it("should throw error when argument is not a string", () => {
+    const args = { name: 123 };
+    expect(() => getOptionalStringArg(args, "name")).toThrowError(
+      "`name` argument is required and must not be empty. (type string)",
+    );
+  });
+
+  it("should throw error when argument is empty and empty not allowed", () => {
+    const args = { name: "" };
+    expect(() => getOptionalStringArg(args, "name")).toThrowError(
+      "Argument name must not be empty",
+    );
+  });
+
+  it("should accept empty string when allowEmpty is true", () => {
+    const args = { name: "" };
+    const result = getOptionalStringArg(args, "name", true);
+    expect(result).toBe("");
+  });
+
+  it("should handle null or undefined args", () => {
+    expect(getOptionalStringArg(null, "name")).toBeUndefined();
+    expect(getOptionalStringArg(undefined, "name")).toBeUndefined();
+  });
+});
+
+describe("getBooleanArg", () => {
+  it("should return boolean argument when valid", () => {
+    const argsTrue = { flag: true };
+    const argsFalse = { flag: false };
+
+    expect(getBooleanArg(argsTrue, "flag")).toBe(true);
+    expect(getBooleanArg(argsFalse, "flag")).toBe(false);
+  });
+
+  it("should return undefined when argument is not provided and not required", () => {
+    const args = { otherArg: true };
+    const result = getBooleanArg(args, "flag");
+    expect(result).toBeUndefined();
+  });
+
+  it("should throw error when argument is not provided and required", () => {
+    const args = { otherArg: true };
+    expect(() => getBooleanArg(args, "flag", true)).toThrowError(
+      "Argument `flag` is required (type boolean)",
+    );
+  });
+
+  it('should handle string "true" and "false" values', () => {
+    const argsStringTrue = { flag: "true" };
+    const argsStringFalse = { flag: "false" };
+    const argsStringTrueUppercase = { flag: "TRUE" };
+    const argsStringFalseUppercase = { flag: "FALSE" };
+
+    expect(getBooleanArg(argsStringTrue, "flag")).toBe(true);
+    expect(getBooleanArg(argsStringFalse, "flag")).toBe(false);
+    expect(getBooleanArg(argsStringTrueUppercase, "flag")).toBe(true);
+    expect(getBooleanArg(argsStringFalseUppercase, "flag")).toBe(false);
+  });
+
+  it("should throw error when argument is not a boolean or valid boolean string", () => {
+    const argsNumber = { flag: 1 };
+    const argsInvalidString = { flag: "yes" };
+    const argsObject = { flag: {} };
+
+    expect(() => getBooleanArg(argsNumber, "flag")).toThrowError(
+      "Argument `flag` must be a boolean true or false",
+    );
+    expect(() => getBooleanArg(argsInvalidString, "flag")).toThrowError(
+      "Argument `flag` must be a boolean true or false",
+    );
+    expect(() => getBooleanArg(argsObject, "flag")).toThrowError(
+      "Argument `flag` must be a boolean true or false",
+    );
+  });
+
+  it("should handle null or undefined args", () => {
+    expect(getBooleanArg(null, "flag")).toBeUndefined();
+    expect(getBooleanArg(undefined, "flag")).toBeUndefined();
+
+    expect(() => getBooleanArg(null, "flag", true)).toThrowError(
+      "Argument `flag` is required (type boolean)",
+    );
+    expect(() => getBooleanArg(undefined, "flag", true)).toThrowError(
+      "Argument `flag` is required (type boolean)",
+    );
+  });
+});
diff --git a/core/util/filesystem.ts b/core/util/filesystem.ts
index d76afe45186..a67cc4c8876 100644
--- a/core/util/filesystem.ts
+++ b/core/util/filesystem.ts
@@ -13,6 +13,7 @@ import {
   Problem,
   Range,
   RangeInFile,
+  SignatureHelp,
   TerminalOptions,
   Thread,
   ToastType,
@@ -44,6 +45,14 @@ class FileSystemIde implements IDE {
     return Promise.resolve([]);
   }
 
+  gotoTypeDefinition(location: Location): Promise<RangeInFile[]> {
+    return Promise.resolve([]);
+  }
+
+  getSignatureHelp(location: Location): Promise<SignatureHelp | null> {
+    return Promise.resolve(null);
+  }
+
   onDidChangeActiveTextEditor(callback: (fileUri: string) => void): void {
     return;
   }
diff --git a/core/util/parameters.ts b/core/util/parameters.ts
index cadbe9a4735..147c3979ad0 100644
--- a/core/util/parameters.ts
+++ b/core/util/parameters.ts
@@ -24,6 +24,7 @@ export const DEFAULT_AUTOCOMPLETE_OPTS: TabAutocompleteOptions = {
   experimental_includeRecentlyVisitedRanges: true,
   experimental_includeRecentlyEditedRanges: true,
   experimental_includeDiff: true,
+  experimental_enableStaticContextualization: false,
 };
 
 export const COUNT_COMPLETION_REJECTED_AFTER = 10_000;
diff --git a/core/utils/markdownUtils.ts b/core/utils/markdownUtils.ts
new file mode 100644
index 00000000000..365f728119d
--- /dev/null
+++ b/core/utils/markdownUtils.ts
@@ -0,0 +1,136 @@
+/**
+ * Utility functions for working with markdown files and code blocks
+ */
+
+/**
+ * Determines if a code block header indicates markdown content
+ */
+export function headerIsMarkdown(header: string): boolean {
+  return (
+    header === "md" ||
+    header === "markdown" ||
+    header === "gfm" ||
+    header === "github-markdown" ||
+    header.includes(" md") ||
+    header.includes(" markdown") ||
+    header.includes(" gfm") ||
+    header.includes(" github-markdown") ||
+    header.split(" ")[0]?.split(".").pop() === "md" ||
+    header.split(" ")[0]?.split(".").pop() === "markdown" ||
+    header.split(" ")[0]?.split(".").pop() === "gfm"
+  );
+}
+
+/**
+ * Determines if a file is a markdown file based on its filepath.
+ */
+export function isMarkdownFile(filepath?: string): boolean {
+  if (!filepath) {
+    return false;
+  }
+
+  const ext = filepath.split(".").pop()?.toLowerCase() || "";
+  return ["md", "markdown", "gfm"].includes(ext);
+}
+
+/**
+ * State tracker for markdown block analysis to avoid recomputing on each call.
+ * Optimized to handle nested markdown code blocks.
+ */
+export class MarkdownBlockStateTracker {
+  protected trimmedLines: string[];
+  protected bareBacktickPositions: number[];
+  private markdownNestCount: number = 0;
+  private lastProcessedIndex: number = -1;
+
+  constructor(allLines: string[]) {
+    this.trimmedLines = allLines.map((l) => l.trim());
+    // Pre-compute positions of all bare backtick lines for faster lookup
+    this.bareBacktickPositions = [];
+    for (let i = 0; i < this.trimmedLines.length; i++) {
+      if (this.trimmedLines[i].match(/^`+$/)) {
+        this.bareBacktickPositions.push(i);
+      }
+    }
+  }
+
+  /**
+   * Determines if we should stop at the given markdown block position.
+   * Maintains state across calls to avoid redundant computation.
+   */
+  shouldStopAtPosition(currentIndex: number): boolean {
+    if (this.trimmedLines[currentIndex] !== "```") {
+      return false;
+    }
+
+    // Process any lines we haven't seen yet up to currentIndex
+    for (let j = this.lastProcessedIndex + 1; j <= currentIndex; j++) {
+      const currentLine = this.trimmedLines[j];
+
+      if (this.markdownNestCount > 0) {
+        // Inside a markdown block
+        if (currentLine.match(/^`+$/)) {
+          // Found bare backticks - check if this is the last one
+          if (j === currentIndex) {
+            const remainingBareBackticks =
+              this.getRemainingBareBackticksAfter(j);
+            if (remainingBareBackticks === 0) {
+              this.markdownNestCount = 0;
+              this.lastProcessedIndex = j;
+              return true;
+            }
+          }
+        } else if (currentLine.startsWith("```")) {
+          // Going into a nested codeblock
+          this.markdownNestCount++;
+        }
+      } else {
+        // Not inside a markdown block yet
+        if (currentLine.startsWith("```")) {
+          const header = currentLine.replaceAll("`", "");
+          if (headerIsMarkdown(header)) {
+            this.markdownNestCount = 1;
+          }
+        }
+      }
+    }
+
+    this.lastProcessedIndex = currentIndex;
+    return false;
+  }
+
+  /**
+   * Efficiently determines if there are remaining bare backticks after the given position.
+   */
+  getRemainingBareBackticksAfter(currentIndex: number): number {
+    return this.bareBacktickPositions.filter((pos) => pos > currentIndex)
+      .length;
+  }
+
+  /**
+   * Checks if the line at the given index is a bare backtick line.
+   */
+  isBareBacktickLine(index: number): boolean {
+    return this.bareBacktickPositions.includes(index);
+  }
+
+  /**
+   * Gets the trimmed lines array.
+   */
+  getTrimmedLines(): string[] {
+    return this.trimmedLines;
+  }
+}
+
+/**
+ * Collects all lines from a LineStream into an array for analysis.
+ */
+export async function collectAllLines<T>(
+  stream: AsyncGenerator<T>,
+): Promise<T[]> {
+  const allLines: T[] = [];
+  for await (const line of stream) {
+    allLines.push(line);
+  }
+  return allLines;
+}
diff --git a/core/utils/markdownUtils.vitest.ts b/core/utils/markdownUtils.vitest.ts
new file mode 100644
index 00000000000..c21c275877b
--- /dev/null
+++ b/core/utils/markdownUtils.vitest.ts
@@ -0,0 +1,306 @@
+import { describe, expect, it } from "vitest";
+import {
+  collectAllLines,
+  headerIsMarkdown,
+  isMarkdownFile,
+  MarkdownBlockStateTracker,
+} from "./markdownUtils";
+
+describe("headerIsMarkdown", () => {
+  // Test exact match with common Markdown identifiers
+  it("should identify exact matches with common Markdown identifiers", () => {
+    expect(headerIsMarkdown("md")).toBe(true);
+    expect(headerIsMarkdown("markdown")).toBe(true);
+    expect(headerIsMarkdown("gfm")).toBe(true);
+    expect(headerIsMarkdown("github-markdown")).toBe(true);
+  });
+
+  // Test identifiers preceded by a space
+  it("should identify identifiers preceded by a space", () => {
+    expect(headerIsMarkdown("lang md")).toBe(true);
+    expect(headerIsMarkdown("something markdown")).toBe(true);
+    expect(headerIsMarkdown("language gfm")).toBe(true);
+    expect(headerIsMarkdown("spec github-markdown")).toBe(true);
+  });
+
+  // Test file extensions
+  it("should identify file names with markdown extensions", () => {
+    expect(headerIsMarkdown("example.md")).toBe(true);
+    expect(headerIsMarkdown("document.markdown")).toBe(true);
+    expect(headerIsMarkdown("readme.gfm")).toBe(true);
+  });
+
+  // Test more complex cases with extensions
+  it("should identify file names with markdown extensions followed by other text", () => {
+    expect(headerIsMarkdown("example.md additional text")).toBe(true);
+    expect(headerIsMarkdown("document.markdown with some description")).toBe(
+      true,
+    );
+    expect(headerIsMarkdown("readme.gfm v2.0")).toBe(true);
+  });
+
+  // Test non-markdown cases
+  it("should not identify non-markdown headers", () => {
+    expect(headerIsMarkdown("javascript")).toBe(false);
+    expect(headerIsMarkdown("typescript")).toBe(false);
+    expect(headerIsMarkdown("plain")).toBe(false);
+    expect(headerIsMarkdown("python")).toBe(false);
+  });
+
+  // Test edge cases
+  it("should handle edge cases correctly", () => {
+    expect(headerIsMarkdown("")).toBe(false);
+    expect(headerIsMarkdown("mdx")).toBe(false); // Similar but not exactly "md"
+    expect(headerIsMarkdown("readme md")).toBe(true);
+    expect(headerIsMarkdown("md.js")).toBe(false); // "md" is not the extension
+  });
+
+  // Test case sensitivity
+  it("should respect case sensitivity", () => {
+    expect(headerIsMarkdown("MD")).toBe(false);
+    expect(headerIsMarkdown("MARKDOWN")).toBe(false);
+    expect(headerIsMarkdown("example.MD")).toBe(false);
+    expect(headerIsMarkdown("lang MD")).toBe(false);
+  });
+
+  // Test with special characters and spacing
+  it("should handle special characters and spacing correctly", () => {
+    expect(headerIsMarkdown("  md")).toBe(true); // Space before "md"
+    expect(headerIsMarkdown("md  ")).toBe(true); // Space after "md"
+    expect(headerIsMarkdown("hello-md")).toBe(false); // "md" with hyphen prefix
+    expect(headerIsMarkdown("markdown:")).toBe(false); // "markdown" with suffix
+  });
+});
+
+describe("isMarkdownFile", () => {
+  it("should identify markdown files by .md extension", () => {
+    expect(isMarkdownFile("README.md")).toBe(true);
+    expect(isMarkdownFile("docs/guide.md")).toBe(true);
+    expect(isMarkdownFile("/path/to/file.md")).toBe(true);
+  });
+
+  it("should identify markdown files by .markdown extension", () => {
+    expect(isMarkdownFile("README.markdown")).toBe(true);
+    expect(isMarkdownFile("docs/guide.markdown")).toBe(true);
+    expect(isMarkdownFile("/path/to/file.markdown")).toBe(true);
+  });
+
+  it("should identify markdown files by .gfm extension", () => {
+    expect(isMarkdownFile("README.gfm")).toBe(true);
+    expect(isMarkdownFile("docs/guide.gfm")).toBe(true);
+    expect(isMarkdownFile("/path/to/file.gfm")).toBe(true);
+  });
+
+  it("should handle case insensitive extensions", () => {
+    expect(isMarkdownFile("README.MD")).toBe(true);
+    expect(isMarkdownFile("guide.MARKDOWN")).toBe(true);
+    expect(isMarkdownFile("file.GFM")).toBe(true);
+  });
+
+  it("should return false for non-markdown files", () => {
+    expect(isMarkdownFile("script.js")).toBe(false);
+    expect(isMarkdownFile("style.css")).toBe(false);
+    expect(isMarkdownFile("data.json")).toBe(false);
+    expect(isMarkdownFile("document.txt")).toBe(false);
+  });
+
+  it("should return false for undefined or empty filepath", () => {
+    expect(isMarkdownFile(undefined)).toBe(false);
+    expect(isMarkdownFile("")).toBe(false);
+  });
+
+  it("should return false for files without extensions", () => {
+    expect(isMarkdownFile("README")).toBe(false);
+    expect(isMarkdownFile("Dockerfile")).toBe(false);
+  });
+
+  it("should handle files with multiple dots", () => {
+    expect(isMarkdownFile("file.backup.md")).toBe(true);
+    expect(isMarkdownFile("config.test.js")).toBe(false);
+  });
+});
+
+describe("MarkdownBlockStateTracker", () => {
+  it("should initialize correctly with empty lines", () => {
+    const tracker = new MarkdownBlockStateTracker([]);
+    expect(tracker.shouldStopAtPosition(0)).toBe(false);
+  });
+
+  it("should initialize correctly with non-markdown lines", () => {
+    const tracker = new MarkdownBlockStateTracker([
+      "const x = 5;",
+      "console.log(x);",
+    ]);
+    expect(tracker.shouldStopAtPosition(0)).toBe(false);
+    expect(tracker.shouldStopAtPosition(1)).toBe(false);
+  });
+
+  it("should detect simple markdown blocks", () => {
+    const tracker = new MarkdownBlockStateTracker([
+      "```markdown",
+      "# Title",
+      "```",
+    ]);
+    expect(tracker.shouldStopAtPosition(0)).toBe(false); // Opening
+    expect(tracker.shouldStopAtPosition(1)).toBe(false); // Content
+    expect(tracker.shouldStopAtPosition(2)).toBe(true); // Closing
+  });
+
+  it("should handle nested code blocks within markdown", () => {
+    const tracker = new MarkdownBlockStateTracker([
+      "```md",
+      "Here's some code:",
+      "```javascript",
+      "console.log('hello');",
+      "```",
+      "More content",
+      "```",
+    ]);
+    expect(tracker.shouldStopAtPosition(2)).toBe(false); // Inner opening
+    expect(tracker.shouldStopAtPosition(4)).toBe(false); // Inner closing
+    expect(tracker.shouldStopAtPosition(6)).toBe(true); // Outer closing
+  });
+
+  it("should handle multiple bare backticks", () => {
+    const tracker = new MarkdownBlockStateTracker([
+      "```markdown",
+      "Content with ```inline``` code",
+      "```",
+      "More content",
+      "```",
+    ]);
+    expect(tracker.shouldStopAtPosition(2)).toBe(false); // First bare backticks
+    expect(tracker.shouldStopAtPosition(4)).toBe(true); // Last bare backticks
+  });
+
+  it("should handle non-markdown code blocks", () => {
+    const tracker = new MarkdownBlockStateTracker([
+      "```javascript",
+      "console.log('hello');",
+      "```",
+    ]);
+    expect(tracker.shouldStopAtPosition(2)).toBe(false); // Not a markdown block
+  });
+
+  it("should handle mixed markdown types", () => {
+    const tracker = new MarkdownBlockStateTracker([
+      "```gfm",
+      "# GitHub Flavored Markdown",
+      "```",
+    ]);
+    expect(tracker.shouldStopAtPosition(2)).toBe(true);
+  });
+
+  it("should handle state persistence across multiple calls", () => {
+    const tracker = new MarkdownBlockStateTracker([
+      "```markdown",
+      "# Documentation",
+      "```typescript",
+      "interface Config {}",
+      "```",
+      "Final notes",
+      "```",
+    ]);
+
+    // Process incrementally
+    expect(tracker.shouldStopAtPosition(2)).toBe(false); // Inner opening
+    expect(tracker.shouldStopAtPosition(4)).toBe(false); // Inner closing
+    expect(tracker.shouldStopAtPosition(6)).toBe(true); // Outer closing
+  });
+
+  it("should handle lines that are not closing backticks", () => {
+    const tracker = new MarkdownBlockStateTracker([
+      "```markdown",
+      "Regular content line",
+      "```",
+    ]);
+    expect(tracker.shouldStopAtPosition(1)).toBe(false); // Not backticks
+  });
+
+  it("should provide access to trimmed lines", () => {
+    const tracker = new MarkdownBlockStateTracker([
+      "  ```markdown  ",
+      "  # Title  ",
+      "  ```  ",
+    ]);
+    const trimmedLines = tracker.getTrimmedLines();
+    expect(trimmedLines).toEqual(["```markdown", "# Title", "```"]);
+  });
+
+  it("should identify bare backtick lines correctly", () => {
+    const tracker = new MarkdownBlockStateTracker([
+      "```markdown",
+      "```",
+      "content",
+      "```",
+    ]);
+    expect(tracker.isBareBacktickLine(0)).toBe(false); // Has language
+    expect(tracker.isBareBacktickLine(1)).toBe(true); // Bare backticks
+    expect(tracker.isBareBacktickLine(2)).toBe(false); // Content
+    expect(tracker.isBareBacktickLine(3)).toBe(true); // Bare backticks
+  });
+
+  it("should count remaining bare backticks correctly", () => {
+    const tracker = new MarkdownBlockStateTracker([
+      "```markdown",
+      "```",
+      "content",
+      "```",
+      "more content",
+      "```",
+    ]);
+    expect(tracker.getRemainingBareBackticksAfter(0)).toBe(3); // After opening
+    expect(tracker.getRemainingBareBackticksAfter(1)).toBe(2); // After first bare
+    expect(tracker.getRemainingBareBackticksAfter(3)).toBe(1); // After second bare
+    expect(tracker.getRemainingBareBackticksAfter(5)).toBe(0); // After last bare
+  });
+});
+
+describe("collectAllLines", () => {
+  async function* createAsyncGenerator<T>(items: T[]): AsyncGenerator<T> {
+    for (const item of items) {
+      yield item;
+    }
+  }
+
+  it("should collect all lines from a stream", async () => {
+    const stream = createAsyncGenerator(["line1", "line2", "line3"]);
+    const result = await collectAllLines(stream);
+    expect(result).toEqual(["line1", "line2", "line3"]);
+  });
+
+  it("should handle empty streams", async () => {
+    const stream = createAsyncGenerator([]);
+    const result = await collectAllLines(stream);
+    expect(result).toEqual([]);
+  });
+
+  it("should handle streams with mixed types", async () => {
+    const stream = createAsyncGenerator([1, "text", null, true]);
+    const result = await collectAllLines(stream);
+    expect(result).toEqual([1, "text", null, true]);
+  });
+
+  it("should handle streams with empty strings", async () => {
+    const stream = createAsyncGenerator(["", "line2", "", "line4"]);
+    const result = await collectAllLines(stream);
+    expect(result).toEqual(["", "line2", "", "line4"]);
+  });
+
+  it("should handle large streams", async () => {
+    const largeArray = Array.from({ length: 1000 }, (_, i) => `line${i}`);
+    const stream = createAsyncGenerator(largeArray);
+    const result = await collectAllLines(stream);
+    expect(result).toEqual(largeArray);
+  });
+
+  it("should handle object streams", async () => {
+    const objects = [
+      { type: "new", line: "const x = 5;" },
+      { type: "old", line: "let y = 10;" },
+    ];
+    const stream = createAsyncGenerator(objects);
+    const result = await collectAllLines(stream);
+    expect(result).toEqual(objects);
+  });
+});
diff --git a/core/utils/streamMarkdownUtils.ts b/core/utils/streamMarkdownUtils.ts
new file mode 100644
index 00000000000..88e8eabec39
--- /dev/null
+++ b/core/utils/streamMarkdownUtils.ts
@@ -0,0 +1,98 @@
+import { LineStream } from "../diff/util";
+import { isMarkdownFile, MarkdownBlockStateTracker } from "./markdownUtils";
+
+/**
+ * Determines if we should stop at a markdown block based on nested markdown logic.
+ * This handles the complex case where markdown blocks contain other markdown blocks.
+ * Uses optimized state tracking to avoid redundant computation.
+ */
+export function shouldStopAtMarkdownBlock(
+  stateTracker: MarkdownBlockStateTracker,
+  currentIndex: number,
+): boolean {
+  return stateTracker.shouldStopAtPosition(currentIndex);
+}
+
+/**
+ * Processes block nesting logic and returns updated state.
+ */
+export function processBlockNesting(
+  line: string,
+  seenFirstFence: boolean,
+  shouldRemoveLineBeforeStart: (line: string) => boolean,
+): { newSeenFirstFence: boolean; shouldSkip: boolean } {
+  if (!seenFirstFence && shouldRemoveLineBeforeStart(line)) {
+    return { newSeenFirstFence: false, shouldSkip: true };
+  }
+
+  if (!seenFirstFence) {
+    return { newSeenFirstFence: true, shouldSkip: false };
+  }
+
+  return { newSeenFirstFence: seenFirstFence, shouldSkip: false };
+}
+
+/**
+ * Stream transformation that stops when encountering a markdown code block ending.
+ * Handles nested markdown blocks in markdown files.
+ */
+export async function* stopAtLinesWithMarkdownSupport(
+  lines: LineStream,
+  filename: string,
+): LineStream {
+  if (!isMarkdownFile(filename)) {
+    for await (const line of lines) {
+      if (line.trim() === "```") {
+        return;
+      }
+      yield line;
+    }
+    return;
+  }
+
+  const allLines: string[] = [];
+  for await (const line of lines) {
+    allLines.push(line);
+  }
+
+  const source = allLines.join("\n");
+  if (!source.match(/```(\w*|.*)(md|markdown|gfm|github-markdown)/)) {
+    // No nested markdown blocks detected, check for simple ``` stopping condition
+    let foundStandaloneBackticks = false;
+    for (let i = 0; i < allLines.length; i++) {
+      if (allLines[i].trim() === "```") {
+        // Found standalone backticks, yield lines up to this point
+        for (let j = 0; j < i; j++) {
+          yield allLines[j];
+        }
+        foundStandaloneBackticks = true;
+        return;
+      }
+    }
+
+    // No standalone backticks found, yield all lines
+    if (!foundStandaloneBackticks) {
+      for (const line of allLines) {
+        yield line;
+      }
+    }
+    return;
+  }
+
+  // Use optimized state tracker for markdown block analysis
+  const stateTracker = new MarkdownBlockStateTracker(allLines);
+
+  for (let i = 0; i < allLines.length; i++) {
+    if (stateTracker.shouldStopAtPosition(i)) {
+      for (let j = 0; j < i; j++) {
+        yield allLines[j];
+      }
+      return;
+    }
+  }
+
+  // If we get here, yield all lines
+  for (const line of allLines) {
+    yield line;
+  }
+}
diff --git a/core/utils/streamMarkdownUtils.vitest.ts b/core/utils/streamMarkdownUtils.vitest.ts
new file mode 100644
index 00000000000..097b1fbd57a
--- /dev/null
+++ b/core/utils/streamMarkdownUtils.vitest.ts
@@ -0,0 +1,102 @@
+import { expect, test } from "vitest";
+import { LineStream } from "../diff/util";
+import {
+  processBlockNesting,
+  stopAtLinesWithMarkdownSupport,
+} from "./streamMarkdownUtils";
+
+test("processBlockNesting correctly handles starting blocks", () => {
+  // Mock function to determine which lines should be removed
+  const shouldRemoveLineBeforeStart = (line: string) =>
+    line === "[CODE]" || line === "```";
+
+  // Test not seeing first fence yet
+  const result1 = processBlockNesting(
+    "[CODE]",
+    false,
+    shouldRemoveLineBeforeStart,
+  );
+  expect(result1.newSeenFirstFence).toBe(false);
+  expect(result1.shouldSkip).toBe(true);
+
+  // Test not seeing first fence but line shouldn't be removed
+  const result2 = processBlockNesting(
+    "normal code",
+    false,
+    shouldRemoveLineBeforeStart,
+  );
+  expect(result2.newSeenFirstFence).toBe(true);
+  expect(result2.shouldSkip).toBe(false);
+
+  // Test already seen first fence
+  const result3 = processBlockNesting(
+    "more code",
+    true,
+    shouldRemoveLineBeforeStart,
+  );
+  expect(result3.newSeenFirstFence).toBe(true);
+  expect(result3.shouldSkip).toBe(false);
+});
+
+test("stopAtLinesWithMarkdownSupport handles non-markdown files", async () => {
+  // Create a mock line stream
+  const mockLines = ["line 1", "line 2", "```", "line 4"];
+  const lineStream: LineStream = (async function* () {
+    for (const line of mockLines) {
+      yield line;
+    }
+  })();
+
+  // Test with a non-markdown file
+  const filename = "test.js";
+  const result = stopAtLinesWithMarkdownSupport(lineStream, filename);
+
+  // Should only yield lines up to the backticks
+  const collected = [];
+  for await (const line of result) {
+    collected.push(line);
+  }
+
+  expect(collected).toEqual(["line 1", "line 2"]);
+});
+
+test("stopAtLinesWithMarkdownSupport handles markdown files with no nested blocks", async () => {
+  // Create a mock line stream with markdown content - but NOT nested markdown blocks
+  const mockLines = [
+    "Some markdown text",
+    "",
+    "```javascript",
+    "function test() {",
+    "  return true;",
+    "}",
+    "```",
+    "More text",
+  ];
+
+  const lineStream: LineStream = (async function* () {
+    for (const line of mockLines) {
+      yield line;
+    }
+  })();
+
+  // Test with a markdown file
+  const filename = "test.md";
+  const result = stopAtLinesWithMarkdownSupport(lineStream, filename);
+
+  // Should yield everything since there's no nested markdown blocks
+  const collected = [];
+  for await (const line of result) {
+    collected.push(line);
+  }
+
+  // The function should stop at the standalone ``` line (not yield it or lines after)
+  // This is the correct behavior - it stops when it encounters standalone backticks
+  expect(collected).toEqual([
+    "Some markdown text",
+    "",
+    "```javascript",
+    "function test() {",
+    "  return true;",
+    "}",
+  ]);
+});
diff --git a/docs/customize/context/codebase.mdx b/docs/customize/context/codebase.mdx
index 674167045a2..5cad74c5991 100644
--- a/docs/customize/context/codebase.mdx
+++ b/docs/customize/context/codebase.mdx
@@ -94,4 +94,4 @@ If you need to force a refresh of the index, reload the VS Code window with <kbd
 
 ## Repository map
 
-Models in the Claude 3, Llama 3.1/3.2, Gemini 1.5, and GPT-4o families will automatically use a [repository map](../custom-providers.mdx#repository-map) during codebase retrieval, which allows the model to understand the structure of your codebase and use it to answer questions. Currently, the repository map only contains the filepaths in the codebase.
+Models in the Claude 3, Llama 3.1/3.2, Gemini 1.5, and GPT-4o families will automatically use a [repository map](../custom-providers#repository-map) during codebase retrieval, which allows the model to understand the structure of your codebase and use it to answer questions. Currently, the repository map only contains the filepaths in the codebase.
diff --git a/docs/customize/context/documentation.mdx b/docs/customize/context/documentation.mdx
index d2bb0f5f00b..2b36fb7213d 100644
--- a/docs/customize/context/documentation.mdx
+++ b/docs/customize/context/documentation.mdx
@@ -54,7 +54,7 @@ The `@Docs` context provider works by
 
 ### Hub `docs` Blocks
 
-@Docs uses [`docs` blocks](../../hub/blocks/block-types.md#docs) in Assistants from the hub. Visit the hub to [explore `docs` blocks](https://hub.continue.dev/explore/docs) or [create your own](https://hub.continue.dev/new?type=block&blockType=docs).
+@Docs uses [`docs` blocks](../../hub/blocks/block-types#docs) in Assistants from the hub. Visit the hub to [explore `docs` blocks](https://hub.continue.dev/explore/docs) or [create your own](https://hub.continue.dev/new?type=block&blockType=docs).
 
 ### Through the `@Docs` Context Provider
 
@@ -354,7 +354,6 @@ The following configuration example includes:
     - title: My Private Docs
       startUrl: http://10.2.1.2/docs
       faviconUrl: http://10.2.1.2/docs/assets/favicon.ico
-      maxDepth: 4
       useLocalCrawling: true
   ```
   </Tab>
diff --git a/docs/customize/deep-dives/slash-commands.mdx b/docs/customize/deep-dives/slash-commands.mdx
index 7057575bd88..81579d3ed67 100644
--- a/docs/customize/deep-dives/slash-commands.mdx
+++ b/docs/customize/deep-dives/slash-commands.mdx
@@ -15,7 +15,7 @@ Slash commands can be combined with additional instructions, including [context
 
 ### Assistant prompt blocks
 
-The easiest way to add a slash command is by adding [`prompt` blocks](../../hub/blocks/block-types.md#prompts) to your assistant, which show up as slash commands in [Chat](../../features/chat/how-it-works.mdx).
+The easiest way to add a slash command is by adding [`prompt` blocks](../../hub/blocks/block-types#prompts) to your assistant, which show up as slash commands in [Chat](../../features/chat/how-it-works.mdx).
 
 ### Prompt files
 
diff --git a/docs/customize/model-providers/top-level/azure.mdx b/docs/customize/model-providers/top-level/azure.mdx
index 26392fe1b1b..c91404df988 100644
--- a/docs/customize/model-providers/top-level/azure.mdx
+++ b/docs/customize/model-providers/top-level/azure.mdx
@@ -48,7 +48,13 @@ We recommend configuring **GPT-4o** as your chat model.
 
 ## Autocomplete model
 
-We recommend configuring **Codestral** as your autocomplete model. If you use Azure AI Foundry to deploy Codestral:
+We recommend configuring **Codestral** as your autocomplete model. 
+
+<Info>
+**Note:** Azure AI Foundry does not provide the FIM (Fill-in-Middle) endpoint required for autocomplete functionality. To use Codestral for autocomplete, deploy it through **Azure Machine Learning Studio** instead, which provides the necessary `/v1/fim/completions` endpoint.
+</Info>
+
+If you use Azure Machine Learning Studio to deploy Codestral:
 
 <Tabs>
 	<Tab title="YAML">
diff --git a/docs/customize/model-roles/embeddings.mdx b/docs/customize/model-roles/embeddings.mdx
index c82f3d35591..feb7f675dc6 100644
--- a/docs/customize/model-roles/embeddings.mdx
+++ b/docs/customize/model-roles/embeddings.mdx
@@ -21,7 +21,7 @@ You can add `embed` to a model's `roles` to specify that it can be used to embed
 
 If you have the ability to use any model, we recommend `voyage-code-3`, which is listed below along with the rest of the options for embeddings models.
 
-If you want to generate embeddings locally, we recommend using `nomic-embed-text` with [Ollama](../model-providers/top-level/ollama.mdx#embeddings-model).
+If you want to generate embeddings locally, we recommend using `nomic-embed-text` with [Ollama](../model-providers/top-level/ollama#embeddings-model).
 
 ### Voyage AI
 
@@ -57,7 +57,7 @@ After obtaining an API key from [here](https://www.voyageai.com/), you can confi
 
 ### Ollama
 
-See [here](../model-providers/top-level/ollama.mdx#embeddings-model) for instructions on how to use Ollama for embeddings.
+See [here](../model-providers/top-level/ollama#embeddings-model) for instructions on how to use Ollama for embeddings.
 
 ### Transformers.js (currently VS Code only)
 
@@ -118,36 +118,36 @@ See [here](../model-providers/top-level/ollama.mdx#embeddings-model) for instruc
 
 ### OpenAI
 
-See [here](../model-providers/top-level/openai.mdx#embeddings-model) for instructions on how to use OpenAI for embeddings.
+See [here](../model-providers/top-level/openai#embeddings-model) for instructions on how to use OpenAI for embeddings.
 
 ### Cohere
 
-See [here](../model-providers/more/cohere.mdx#embeddings-model) for instructions on how to use Cohere for embeddings.
+See [here](../model-providers/more/cohere#embeddings-model) for instructions on how to use Cohere for embeddings.
 
 ### Gemini
 
-See [here](../model-providers/top-level/gemini.mdx#embeddings-model) for instructions on how to use Gemini for embeddings.
+See [here](../model-providers/top-level/gemini#embeddings-model) for instructions on how to use Gemini for embeddings.
 
 ### Vertex
 
-See [here](../model-providers/top-level/vertexai.mdx#embeddings-model) for instructions on how to use Vertex for embeddings.
+See [here](../model-providers/top-level/vertexai#embeddings-model) for instructions on how to use Vertex for embeddings.
 
 ### Mistral
 
-See [here](../model-providers/top-level/mistral.mdx#embeddings-model) for instructions on how to use Mistral for embeddings.
+See [here](../model-providers/top-level/mistral#embeddings-model) for instructions on how to use Mistral for embeddings.
 
 ### NVIDIA
 
-See [here](../model-providers/more/nvidia.mdx#embeddings-model) for instructions on how to use NVIDIA for embeddings.
+See [here](../model-providers/more/nvidia#embeddings-model) for instructions on how to use NVIDIA for embeddings.
 
 ### Bedrock
 
-See [here](../model-providers/top-level/bedrock.mdx#embeddings-model) for instructions on how to use Bedrock for embeddings.
+See [here](../model-providers/top-level/bedrock#embeddings-model) for instructions on how to use Bedrock for embeddings.
 
 ### WatsonX
 
-See [here](../model-providers/more/watsonx.mdx#embeddings-model) for instructions on how to use WatsonX for embeddings.
+See [here](../model-providers/more/watsonx#embeddings-model) for instructions on how to use WatsonX for embeddings.
 
 ### LMStudio
 
-See [here](../model-providers/more/lmstudio.mdx#embeddings-model) for instructions on how to use LMStudio for embeddings.
+See [here](../model-providers/more/lmstudio#embeddings-model) for instructions on how to use LMStudio for embeddings.
diff --git a/docs/features/chat/model-setup.mdx b/docs/features/chat/model-setup.mdx
index bd7238e5f33..c1ebd019aee 100644
--- a/docs/features/chat/model-setup.mdx
+++ b/docs/features/chat/model-setup.mdx
@@ -25,6 +25,13 @@ These models have varying tool calling and reasoning capabilities.
 3. Add `GEMINI_API_KEY` as a [User Secret](https://docs.continue.dev/hub/secrets/secret-types#user-secrets) on Continue Hub [here](https://hub.continue.dev/settings/secrets)
 4. Click `Reload config` in the assistant selector in the Continue IDE extension
 
+[Kimi K2](hub.continue.dev/togetherai/kimi-k2-instruct) from Moonshot AI
+
+1. Get your API key from [Together AI](https://api.together.ai)
+2. Add [Kimi K2](hub.continue.dev/togetherai/kimi-k2-instruct) to your assistant on Continue Hub
+3. Add `TOGETHER_API_KEY` as a [User Secret](https://docs.continue.dev/hub/secrets/secret-types#user-secrets) on Continue Hub [here](https://hub.continue.dev/settings/secrets)
+4. Click `Reload config` in the assistant selector in the Continue IDE extension
+
 [o3](https://hub.continue.dev/openai/o3) from OpenAI
 
 1. Get your API key from [OpenAI](https://platform.openai.com)
@@ -46,10 +53,10 @@ These models have varying tool calling and reasoning capabilities.
 3. Add `MISTRAL_API_KEY` as a [User Secret](https://docs.continue.dev/hub/secrets/secret-types#user-secrets) on Continue Hub [here](https://hub.continue.dev/settings/secrets)
 4. Click `Reload config` in the assistant selector in the Continue IDE extension
 
-[Kimi K2](hub.continue.dev/togetherai/kimi-k2-instruct) from Moonshot AI
+[DeepSeek-V3](https://hub.continue.dev/togetherai/deepseek-v3) from DeepSeek
 
-1. Get your API key from [TogetherAI](https://api.together.ai)
-2. Add [Kimi K2](hub.continue.dev/togetherai/kimi-k2-instruct) to your assistant on Continue Hub
+1. Get your API key from [Together AI](https://api.together.ai)
+2. Add [DeepSeek-V3](https://hub.continue.dev/togetherai/deepseek-v3) to your assistant on Continue Hub
 3. Add `TOGETHER_API_KEY` as a [User Secret](https://docs.continue.dev/hub/secrets/secret-types#user-secrets) on Continue Hub [here](https://hub.continue.dev/settings/secrets)
 4. Click `Reload config` in the assistant selector in the Continue IDE extension
 
@@ -59,21 +66,27 @@ These models can be run on your computer if you have enough VRAM.
 
 Their limited tool calling and reasoning capabilities will make it challenging to use Agent mode.
 
-[Qwen2.5-Coder 7B](https://hub.continue.dev/ollama/qwen2.5-coder-7b) from Qwen
+[Qwen2.5-Coder 32B](https://hub.continue.dev/ollama/qwen2.5-coder-32b)
 
-1. Add [Qwen2.5-Coder 7B](https://hub.continue.dev/ollama/qwen2.5-coder-7b) to your assistant on Continue Hub
+1. Add [Qwen2.5-Coder 32B](https://hub.continue.dev/ollama/qwen2.5-coder-32b) to your assistant on Continue Hub
 2. Run the model with [Ollama](https://docs.continue.dev/guides/ollama-guide#using-ollama-with-continue-a-developers-guide)
 3. Click `Reload config` in the assistant selector in the Continue IDE extension
 
-[Gemma 3 4B](https://hub.continue.dev/ollama/gemma3-4b) from Google
+[Devstral Small 27B](https://hub.continue.dev/ollama/devstral)
 
-1. Add [Gemma 3 4B](https://hub.continue.dev/ollama/gemma3-4b) to your assistant on Continue Hub
+1. Add [Devstral Small](https://hub.continue.dev/ollama/devstral) to your assistant on Continue Hub
+2. Run the model with [Ollama](https://docs.continue.dev/guides/ollama-guide#using-ollama-with-continue-a-developers-guide)
+3. Click `Reload config` in the assistant selector in the Continue IDE extension
+
+[Qwen2.5-Coder 7B](https://hub.continue.dev/ollama/qwen2.5-coder-7b) from Qwen
+
+1. Add [Qwen2.5-Coder 7B](https://hub.continue.dev/ollama/qwen2.5-coder-7b) to your assistant on Continue Hub
 2. Run the model with [Ollama](https://docs.continue.dev/guides/ollama-guide#using-ollama-with-continue-a-developers-guide)
 3. Click `Reload config` in the assistant selector in the Continue IDE extension
 
-[Llama 3.1 8B](https://hub.continue.dev/ollama/llama3.1-8b) from Meta
+[Gemma 3 4B](https://hub.continue.dev/ollama/gemma3-4b) from Google
 
-1. Add [Llama 3.1 8B](https://hub.continue.dev/ollama/llama3.1-8b) to your assistant on Continue Hub
+1. Add [Gemma 3 4B](https://hub.continue.dev/ollama/gemma3-4b) to your assistant on Continue Hub
 2. Run the model with [Ollama](https://docs.continue.dev/guides/ollama-guide#using-ollama-with-continue-a-developers-guide)
 3. Click `Reload config` in the assistant selector in the Continue IDE extension
 
diff --git a/docs/features/edit/context-selection.mdx b/docs/features/edit/context-selection.mdx
index a7c3459c9e3..0cbff11c59c 100644
--- a/docs/features/edit/context-selection.mdx
+++ b/docs/features/edit/context-selection.mdx
@@ -4,8 +4,4 @@ The input you provide is included in the prompt.
 
 ## Code to Edit
 
-The **entire contents** of each file (the current file for Jetbrains inline Edit, the `Code to Edit` item for VS Code Edit mode) are included in the prompt for context. The model will only attempt to edit the highlighted/specified ranges.
-
-## Context Providers
-
-In VS Code Edit mode, you can use `@` to add context using [Context Providers](/customize/custom-providers), similar to [Chat](/features/chat/context-selection). Some context providers may be disabled in Edit mode.
+The **entire contents** of the current file are included in the prompt for context. The model will only attempt to edit the highlighted/specified ranges.
diff --git a/docs/features/edit/how-to-customize.mdx b/docs/features/edit/how-to-customize.mdx
index 1375d7b9d15..74f06a5496a 100644
--- a/docs/features/edit/how-to-customize.mdx
+++ b/docs/features/edit/how-to-customize.mdx
@@ -6,4 +6,6 @@ You can configure particular models from your Assistant to be used for Edit and
 2. Click the cube icon to expand the "Models" section
 3. Use the dropdowns to select models for Edit and Apply
 
+![Edit model selection](/images/edit-model.png)
+
 Learn more about the [Edit role](/customize/model-roles/edit) and [Apply role](/customize/model-roles/apply).
diff --git a/docs/features/edit/quick-start.mdx b/docs/features/edit/quick-start.mdx
index 087ac5e1562..aa2d9b5d494 100644
--- a/docs/features/edit/quick-start.mdx
+++ b/docs/features/edit/quick-start.mdx
@@ -14,7 +14,7 @@ Edit is recommended for small, targeted changes, such as
 
 ## Highlight code and activate
 
-Highlight the block of code you would like to modify and press `cmd/ctrl` + `i` to active Edit mode. You can also enter Edit mode by pressing `cmd/ctrl` + `i` with no code highlighted, which will default to editing the current file.
+Highlight the block of code you would like to modify and press `Cmd+I` (Mac) or `Ctrl+I` (Windows/Linux) to activate Edit mode. You can also press `Cmd/Ctrl+I` with no code highlighted, which will default to inserting code at the current cursor location.
 
 ## Describe code changes
 
@@ -24,23 +24,12 @@ Describe the changes you would like the model to make to your highlighted code.
 
 Proposed changes appear as inline diffs within your highlighted text.
 
-You can navigate through each proposed change, accepting or rejecting them using `cmd/ctrl` + `opt` + `y` (to accept) or `cmd/ctrl` + `opt` + `n` (to reject).
+You can navigate through each proposed change, accepting or rejecting them using `Cmd+Opt+Y` (Mac) or `Ctrl+Alt+Y` (Windows/Linux) to accept, or `Cmd+Opt+N` (Mac) or `Ctrl+Alt+N` (Windows/Linux) to reject.
 
-You can also accept or reject all changes at once using `cmd/ctrl` + `shift` + `enter` (to accept) or `cmd/ctrl` + `shift` + `delete/backspace` (to reject).
+You can also accept or reject all changes at once using `Cmd+Shift+Enter` (Mac) or `Ctrl+Shift+Enter` (Windows/Linux) to accept, or `Cmd+Shift+Delete` (Mac) or `Ctrl+Shift+Backspace` (Windows/Linux) to reject.
 
-If you want to request a new suggestion for the same highlighted code section, you can use `cmd/ctrl` + `i` to re-prompt the model.
+If you want to request a new suggestion for the same highlighted code section, you can use `Cmd+I` (Mac) or `Ctrl+I` (Windows/Linux) to re-prompt the model.
 
-## VS Code
-
-In VS Code, Edit is implemented in the extension sidebar with a similar interface to [Chat](/features/chat/how-it-works), and you can also enter Edit mode by using the Mode Selector below the main Chat input to select `Edit`.
-
-![edit mode selected](/images/features/edit/images/select-edit-mode-75c8f01861ebe03177986a5b7f21f746.png)
-
-You can also reject and accept diffs using the `Reject All` and `Accept All` buttons that show up in the Chat when diffs are present (see examples below).
-
-### Adding Code to Edit
-
-Along with adding highlighted code, you can also manually add files to edit using the `Add file` combobox or by clicking the dropdown and selecting `Add all open files` to add all files that are currently open in the editor.
 
 ## Jetbrains
 
diff --git a/docs/getting-started/overview.mdx b/docs/getting-started/overview.mdx
index b0de6d490a4..d3b6b3269ca 100644
--- a/docs/getting-started/overview.mdx
+++ b/docs/getting-started/overview.mdx
@@ -27,7 +27,7 @@ description: "To quickly understand what you can do with Continue, check out eac
 <Tab title="Edit">
 [Edit](/features/edit/quick-start) is a convenient way to modify code without leaving your current file
 
-![edit](/images/edit-d522442f88e715924b4c9f4c83900e3a.gif)
+![edit](/images/edit.gif)
 
 <Info>
   Learn more about [Edit](/features/edit/quick-start)
diff --git a/docs/images/edit-model.png b/docs/images/edit-model.png
new file mode 100644
index 00000000000..f6886495631
Binary files /dev/null and b/docs/images/edit-model.png differ
diff --git a/docs/images/edit.gif b/docs/images/edit.gif
index a1629930c6d..7f7cd0b1579 100644
Binary files a/docs/images/edit.gif and b/docs/images/edit.gif differ
diff --git a/docs/reference.mdx b/docs/reference.mdx
index ca1983241f1..670100f241f 100644
--- a/docs/reference.mdx
+++ b/docs/reference.mdx
@@ -357,8 +357,6 @@ List of documentation sites to index.
 
 - `name` (**required**): Name of the documentation site, displayed in dropdowns, etc.
 - `startUrl` (**required**): Start page for crawling - usually root or intro page for docs
-
-- `maxDepth`: Maximum link depth for crawling. Default `4`
 - `favicon`: URL for site favicon (default is `/favicon.ico` from `startUrl`).
 - `useLocalCrawling`: Skip the default crawler and only crawl using a local crawler.
 
@@ -507,7 +505,6 @@ context:
     params:
       startUrl: https://docs.example.com/introduction
       rootUrl: https://docs.example.com
-      maxDepth: 3
 mcpServers:
   - name: DevServer
     command: npm
diff --git a/docs/reference/continue-mcp.mdx b/docs/reference/continue-mcp.mdx
index 6045d0ff120..bd7d7d3cf10 100644
--- a/docs/reference/continue-mcp.mdx
+++ b/docs/reference/continue-mcp.mdx
@@ -4,54 +4,25 @@ description: Set up an MCP server to search Continue documentation
 keywords: [mcp, documentation, search, mintlify, reference]
 ---
 
-The continue-docs MCP Server allows you to search and retrieve information from the Continue documentation directly within your agent conversations. This is powered by Mintlify's MCP server generation.
+The Continue Documentation MCP Server allows you to search and retrieve information from the Continue documentation directly within your agent conversations.
 
-## Installation
+## Set up
 
-### Step 1: Install the MCP Server
-
-Run the following command to install the continue-docs MCP server:
-
-```bash
-npx mint-mcp add docs.continue.dev
-```
-
-When prompted, select "All" from the selection menu:
-
-![mintlify cli selection tree](/images/mintlify-cli-selection-tree.png)
-
-This command will:
-
-- Download and install the MCP server locally
-- Set up the search tool for Continue documentation
-- Create the necessary configuration files
-
-<Info>
-Take note of the installation path displayed after running the command above. You'll need to replace in the configuration below with your actual installation path.
-
-It will look like this: `/path/to/user/.mcp/docs.continue.dev/src/index.js`
-
-</Info>
-
-### Step 2: Configure Continue
+### Configure Continue
 
 1. Create a folder called `.continue/mcpServers` at the top level of your workspace
 2. Add a file called `continue-docs-mcp.yaml` to this folder
 3. Write the following contents and save:
 
-````yaml title=".continue/mcpServers/continue-docs-mcp.yaml"
 ```yaml title=".continue/mcpServers/continue-docs-mcp.yaml"
 name: Continue Documentation MCP
 version: 0.0.1
 schema: v1
 mcpServers:
-  - name: Continue Docs Search
-    command: node
-    args:
-      - "/path/to/user/.mcp/docs.continue.dev/src/index.js"
-````
+  - uses: continuedev/continue-docs-mcp
+```
 
-### Step 3: Enable Agent Mode
+### Enable Agent Mode
 
 MCP servers only work in agent mode. Make sure to switch to agent mode in Continue before testing.
 
@@ -62,77 +33,28 @@ Once configured, you can use the MCP server to search Continue documentation:
 ### Model Configuration Help
 
 ```
-Search for model setup instructions in the Continue docs
+How do I add Claude 4 Sonnet as a model from Bedrock in Continue?
 ```
 
 ### Context Providers
 
 ```
-Find documentation about context providers and how to configure them
-```
-
-### Autocomplete Setup
-
-```
-How do I configure autocomplete in Continue?
-```
-
-### Slash Commands
-
-```
-Search for information about custom slash commands
+What context providers are available in Continue?
 ```
 
-### Troubleshooting
+### Customization
 
 ```
-Find troubleshooting information for Continue extension issues
+How do I add custom rules to my assistant in Continue?
 ```
 
-## Test Plan
-
-Use this test plan to verify your MCP server is working correctly:
-
-### Prerequisites
-
-- Continue extension is installed and running
-- Agent mode is enabled
-- MCP server configuration file exists in `.continue/mcpServers/`
-
-### Test Cases
-
-#### 1. Basic Documentation Search
-
-- **Query**: "Search the Continue docs for information about model setup"
-- **Expected**: Returns structured information about configuring models
-- **Pass/Fail**: ☐
-
-#### 2. Context Provider Documentation
-
-- **Query**: "Find documentation about context providers in Continue"
-- **Expected**: Returns information about available context providers
-- **Pass/Fail**: ☐
-
-#### 3. Feature-Specific Search
-
-- **Query**: "How do I configure autocomplete in Continue?"
-- **Expected**: Returns autocomplete setup instructions
-- **Pass/Fail**: ☐
-
-#### 4. MCP Documentation Search
-
-- **Query**: "Search for MCP server setup instructions"
-- **Expected**: Returns MCP configuration information
-- **Pass/Fail**: ☐
-
 ## Troubleshooting
 
 ### MCP Server Not Loading
 
-1. **Check configuration**: Ensure your YAML configuration uses the npx command approach
-2. **Verify installation**: Run `npx mint-mcp add continue-docs` to confirm the server can be accessed
-3. **Check agent mode**: MCP servers only work in agent mode
-4. **Restart Continue**: Try restarting the Continue extension
+1. **Check configuration**: Ensure your YAML configuration uses the correct `uses` field with `continuedev/continue-docs-mcp`
+2. **Check agent mode**: MCP servers only work in agent mode
+3. **Restart Continue**: Try restarting the Continue extension
 
 ### No Search Results
 
@@ -140,20 +62,6 @@ Use this test plan to verify your MCP server is working correctly:
 2. **Check query format**: Try rephrasing your search query
 3. **Test with known topics**: Search for well-documented features like "model configuration"
 
-### Permission Issues
-
-If you encounter permission errors, ensure npx has proper permissions:
-
-```bash
-npm config get prefix
-```
-
-## Advanced Configuration
-
-### Using Environment Variables
-
-You can configure the MCP server with environment variables:
-
 ## Related Documentation
 
 - [MCP Overview](/customize/deep-dives/mcp)
diff --git a/extensions/intellij/.run/Run Extension.run.xml b/extensions/intellij/.run/Run Extension.run.xml
index 4bd794de1ee..30a38f6c453 100644
--- a/extensions/intellij/.run/Run Extension.run.xml	
+++ b/extensions/intellij/.run/Run Extension.run.xml	
@@ -20,7 +20,6 @@
                     <option value="runIde"/>
                 </list>
             </option>
-             <option name="vmOptions" value="-Dide.browser.jcef.out-of-process.enabled=false"/>
         </ExternalSystemSettings>
         <ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
         <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
diff --git a/extensions/intellij/.run/Run Qodana.run.xml b/extensions/intellij/.run/Run Qodana.run.xml
index 6f97329cfa0..1c660cf15f7 100644
--- a/extensions/intellij/.run/Run Qodana.run.xml	
+++ b/extensions/intellij/.run/Run Qodana.run.xml	
@@ -19,7 +19,6 @@
 <!--          <option value="runInspections" />-->
 <!--        </list>-->
 <!--      </option>-->
-<!--       <option name="vmOptions" value="-Dide.browser.jcef.out-of-process.enabled=false"/>-->
 <!--    </ExternalSystemSettings>-->
 <!--    <ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>-->
 <!--    <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>-->
diff --git a/extensions/intellij/.run/Run Test IDE.run.xml b/extensions/intellij/.run/Run Test IDE.run.xml
index 2d7e4fc0b18..94ab5809f9c 100644
--- a/extensions/intellij/.run/Run Test IDE.run.xml	
+++ b/extensions/intellij/.run/Run Test IDE.run.xml	
@@ -13,7 +13,6 @@
                     <option value="runIdeForUiTests"/>
                 </list>
             </option>
-             <option name="vmOptions" value="-Dide.browser.jcef.out-of-process.enabled=false"/>
         </ExternalSystemSettings>
         <ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
         <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
diff --git a/extensions/intellij/.run/Run Tests.run.xml b/extensions/intellij/.run/Run Tests.run.xml
index 1bdcaa1c0f8..b6b880942e6 100644
--- a/extensions/intellij/.run/Run Tests.run.xml	
+++ b/extensions/intellij/.run/Run Tests.run.xml	
@@ -13,7 +13,6 @@
           <option value="test" />
         </list>
       </option>
-       <option name="vmOptions" value="-Dide.browser.jcef.out-of-process.enabled=false"/>
     </ExternalSystemSettings>
     <ExternalSystemDebugServerProcess>true</ExternalSystemDebugServerProcess>
     <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
diff --git a/extensions/intellij/build.gradle.kts b/extensions/intellij/build.gradle.kts
index fb85ded90b2..8dc8ce73812 100644
--- a/extensions/intellij/build.gradle.kts
+++ b/extensions/intellij/build.gradle.kts
@@ -9,6 +9,8 @@ fun Sync.prepareSandbox() {
 }
 
 val remoteRobotVersion = "0.11.23"
+val isEap get() = environment("RELEASE_CHANNEL").orNull == "eap"
+val pluginVersion = properties("pluginVersion").get()
 
 plugins {
     id("java")
@@ -22,21 +24,14 @@ plugins {
 }
 
 group = properties("pluginGroup").get()
+version = if (isEap) "$pluginVersion-eap" else pluginVersion
 
-version = properties("pluginVersion").get()
-
-// Configure project's dependencies
 repositories {
     mavenCentral()
     maven { url = uri("https://packages.jetbrains.team/maven/p/ij/intellij-dependencies") }
 }
 
-// Dependencies are managed with Gradle version catalog - read more:
-// https://docs.gradle.org/current/userguide/platforms.html#sub:version-catalog
 dependencies {
-    implementation("com.squareup.okhttp3:okhttp:4.12.0") {
-        exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib")
-    }
     implementation("org.jetbrains.kotlin:kotlin-stdlib:1.4.32")
     implementation("com.posthog.java:posthog:1.+")
     implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.0")
@@ -48,22 +43,6 @@ dependencies {
     testImplementation("com.squareup.okhttp3:logging-interceptor:4.12.0")
     testImplementation("com.automation-remarks:video-recorder-junit5:2.0")
     testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.3")
-
-
-    // Exclude vulnerable Log4j from all dependencies
-    configurations.all {
-        resolutionStrategy {
-            eachDependency {
-                if (requested.group == "log4j" && requested.name == "log4j") {
-                    useTarget("org.slf4j:log4j-over-slf4j:1.7.36")
-                }
-            }
-        }
-    }
-
-    // Add Log4j 2.x explicitly
-    implementation("org.apache.logging.log4j:log4j-core:2.20.0")
-    implementation("org.apache.logging.log4j:log4j-api:2.20.0")
     testImplementation(kotlin("test"))
 }
 
@@ -105,7 +84,7 @@ koverReport { defaults { xml { onCheck = true } } }
 
 tasks {
     downloadRobotServerPlugin {
-        version.set(remoteRobotVersion)
+        version = remoteRobotVersion
     }
 
     prepareSandbox {
@@ -120,13 +99,14 @@ tasks {
         prepareSandbox()
     }
 
-    wrapper { gradleVersion = properties("gradleVersion").get() }
+    wrapper {
+        gradleVersion = properties("gradleVersion").get()
+    }
 
     patchPluginXml {
-        version.set(properties("pluginVersion"))
-        sinceBuild.set(properties("pluginSinceBuild"))
-        untilBuild.set(properties("pluginUntilBuild"))
-        pluginDescription.set(
+        sinceBuild = properties("pluginSinceBuild")
+        untilBuild = properties("pluginUntilBuild")
+        pluginDescription =
             providers.fileContents(layout.projectDirectory.file("README.md")).asText.map {
                 val start = "<!-- Plugin description -->"
                 val end = "<!-- Plugin description end -->"
@@ -140,7 +120,6 @@ tasks {
                     subList(indexOf(start) + 1, indexOf(end)).joinToString("\n").let(::markdownToHTML)
                 }
             }
-        )
     }
 
     // Configure UI tests plugin
@@ -167,7 +146,7 @@ tasks {
         // See ContinueExtensionSettingsService.kt for more info.
         // Currently commented out however since test fail in CI with this version
 //        intellij {
-//            version.set("2024.1")
+//            version = "2024.1"
 //        }
     }
 
@@ -178,17 +157,10 @@ tasks {
     }
 
     publishPlugin {
-        //        dependsOn("patchChangelog")
         token = environment("PUBLISH_TOKEN")
-        // The pluginVersion is based on the SemVer (https://semver.org) and supports pre-release
-        // labels, like 2.1.7-alpha.3
-        // Specify pre-release label to publish the plugin in a custom Release Channel automatically.
-        // Read more:
-        // https://plugins.jetbrains.com/docs/intellij/deployment.html#specifying-a-release-channel
-        channels.set(listOf(environment("RELEASE_CHANNEL").getOrElse("eap")))
-
-        // We always hide the stable releases until a few days of EAP have proven them stable
-        //        hidden = environment("RELEASE_CHANNEL").map { it == "stable" }.getOrElse(false)
+
+        val channel = if (isEap) "eap" else "default"
+        channels = listOf(channel)
     }
 
     runIde {
diff --git a/extensions/intellij/gradle.properties b/extensions/intellij/gradle.properties
index a1c5d01c15a..2b6ee66d4bc 100644
--- a/extensions/intellij/gradle.properties
+++ b/extensions/intellij/gradle.properties
@@ -3,7 +3,7 @@ pluginGroup=com.github.continuedev.continueintellijextension
 pluginName=continue-intellij-extension
 pluginRepositoryUrl=https://github.com/continuedev/continue
 # SemVer format -> https://semver.org
-pluginVersion=1.0.30
+pluginVersion=1.0.31
 # Supported build number ranges and IntelliJ Platform versions -> https://plugins.jetbrains.com/docs/intellij/build-number-ranges.html
 pluginSinceBuild=223
 # IntelliJ Platform Properties -> https://plugins.jetbrains.com/docs/intellij/tools-gradle-intellij-plugin.html#configuration-intellij-extension
diff --git a/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/auth/ContinueAuthService.kt b/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/auth/ContinueAuthService.kt
index 13ceaf81072..4538b877139 100644
--- a/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/auth/ContinueAuthService.kt
+++ b/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/auth/ContinueAuthService.kt
@@ -1,5 +1,6 @@
 package com.github.continuedev.continueintellijextension.auth
 
+import com.github.continuedev.continueintellijextension.error.ContinueErrorService
 import com.github.continuedev.continueintellijextension.services.ContinueExtensionSettings
 import com.github.continuedev.continueintellijextension.services.ContinuePluginService
 import com.google.gson.Gson
@@ -10,24 +11,22 @@ import com.intellij.ide.util.PropertiesComponent
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.components.Service
 import com.intellij.openapi.components.service
+import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.project.Project
 import com.intellij.remoteServer.util.CloudConfigurationUtil.createCredentialAttributes
+import com.intellij.util.io.HttpRequests
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import okhttp3.MediaType.Companion.toMediaType
-import okhttp3.OkHttpClient
-import okhttp3.Request
-import okhttp3.RequestBody.Companion.toRequestBody
-import java.net.URL
+import kotlin.time.Duration.Companion.minutes
 
 @Service
 class ContinueAuthService {
     private val coroutineScope = CoroutineScope(Dispatchers.IO)
+    private val log = Logger.getInstance(ContinueAuthService::class.java)
 
     companion object {
-        fun getInstance(): ContinueAuthService = service<ContinueAuthService>()
         private const val CREDENTIALS_USER = "ContinueAuthUser"
         private const val ACCESS_TOKEN_KEY = "ContinueAccessToken"
         private const val REFRESH_TOKEN_KEY = "ContinueRefreshToken"
@@ -77,73 +76,47 @@ class ContinueAuthService {
     }
 
     private fun updateRefreshToken(token: String) {
-        // Launch a coroutine to call the suspend function
-        coroutineScope.launch {
-            try {
-                val response = refreshToken(token)
-                val accessToken = response["accessToken"] as? String
-                val refreshToken = response["refreshToken"] as? String
-                val user = response["user"] as? Map<*, *>
-                val firstName = user?.get("firstName") as? String
-                val lastName = user?.get("lastName") as? String
-                val label = "$firstName $lastName"
-                val id = user?.get("id") as? String
-                val email = user?.get("email") as? String
-
-                // Persist the session info
-                setRefreshToken(refreshToken!!)
-                val sessionInfo =
-                    ControlPlaneSessionInfo(accessToken!!, ControlPlaneSessionInfo.Account(email!!, label))
-                setControlPlaneSessionInfo(sessionInfo)
-
-                // Notify listeners
-                ApplicationManager.getApplication().messageBus.syncPublisher(AuthListener.TOPIC)
-                    .handleUpdatedSessionInfo(sessionInfo)
-
-            } catch (e: Exception) {
-                // Handle any exceptions
-                println("Exception while refreshing token: ${e.message}")
-            }
+        try {
+            val response = refreshToken(token)
+            val accountLabel = "${response.user.firstName} ${response.user.lastName}"
+
+            // Persist the session info
+            setRefreshToken(response.refreshToken)
+            val account = ControlPlaneSessionInfo.Account(response.user.email, accountLabel)
+            val sessionInfo = ControlPlaneSessionInfo(response.accessToken, account)
+            setControlPlaneSessionInfo(sessionInfo)
+
+            // Notify listeners
+            ApplicationManager.getApplication().messageBus.syncPublisher(AuthListener.TOPIC)
+                .handleUpdatedSessionInfo(sessionInfo)
+        } catch (e: Exception) {
+            service<ContinueErrorService>().report(e, "Exception while refreshing token ${e.message}")
         }
     }
 
     private fun setupRefreshTokenInterval() {
-        // Launch a coroutine to refresh the token every 30 minutes
         coroutineScope.launch {
             while (true) {
                 val refreshToken = getRefreshToken()
                 if (refreshToken != null) {
                     updateRefreshToken(refreshToken)
                 }
-
-                kotlinx.coroutines.delay(15 * 60 * 1000) // 15 minutes in milliseconds
+                log.info("Token refreshed, retrying in 15 minutes")
+                delay(15.minutes)
             }
         }
     }
 
-    private suspend fun refreshToken(refreshToken: String) = withContext(Dispatchers.IO) {
-        val client = OkHttpClient()
-        val url = URL(getControlPlaneUrl()).toURI().resolve("/auth/refresh").toURL()
-        val jsonBody = mapOf("refreshToken" to refreshToken)
-        val jsonString = Gson().toJson(jsonBody)
-        val requestBody = jsonString.toRequestBody("application/json".toMediaType())
-
-        val request = Request.Builder()
-            .url(url)
-            .post(requestBody)
-            .header("Content-Type", "application/json")
-            .build()
-
-        val response = client.newCall(request).execute()
-
-        val responseBody = response.body?.string()
+    private fun refreshToken(refreshToken: String): RefreshTokenResponse {
         val gson = Gson()
-        val responseMap = gson.fromJson(responseBody, Map::class.java)
-
-        responseMap
+        val jsonBody = gson.toJson(mapOf("refreshToken" to refreshToken))
+        val url = getControlPlaneUrl() + "/auth/refresh"
+        val response = HttpRequests.post(url, HttpRequests.JSON_CONTENT_TYPE)
+            .connect { connection -> connection.write(jsonBody.toByteArray()) }
+            .toString()
+        return gson.fromJson(response, RefreshTokenResponse::class.java)
     }
 
-
     private fun openSignInPage(project: Project, useOnboarding: Boolean): String? {
         var authUrl: String? = null
         val coreMessenger = project.service<ContinuePluginService>().coreMessenger
@@ -256,6 +229,17 @@ class ContinueAuthService {
         setAccountLabel(info.account.label)
     }
 
+    private data class RefreshTokenResponse(
+        val accessToken: String,
+        val refreshToken: String,
+        val user: User,
+    ) {
+        data class User(
+            val firstName: String,
+            val lastName: String,
+            val email: String
+        )
+    }
 }
 
 // Data class to represent the ControlPlaneSessionInfo
diff --git a/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/continue/CoreMessenger.kt b/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/continue/CoreMessenger.kt
index 8ccb078380a..1c0ab242a14 100644
--- a/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/continue/CoreMessenger.kt
+++ b/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/continue/CoreMessenger.kt
@@ -7,9 +7,11 @@ import com.github.continuedev.continueintellijextension.`continue`.process.Conti
 import com.github.continuedev.continueintellijextension.services.ContinuePluginService
 import com.github.continuedev.continueintellijextension.utils.uuid
 import com.google.gson.Gson
+import com.google.gson.JsonSyntaxException
 import com.intellij.openapi.components.service
+import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.project.Project
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CoroutineScope
 
 class CoreMessenger(
     private val project: Project,
@@ -20,6 +22,7 @@ class CoreMessenger(
     private val gson = Gson()
     private val responseListeners = mutableMapOf<String, (Any?) -> Unit>()
     private val process = startContinueProcess()
+    private val log = Logger.getInstance(CoreMessenger::class.java)
 
     fun request(messageType: String, data: Any?, messageId: String?, onResponse: (Any?) -> Unit) {
         val id = messageId ?: uuid()
@@ -38,13 +41,13 @@ class CoreMessenger(
     }
 
     private fun handleMessage(json: String) {
-        val responseMap = gson.fromJson(json, Map::class.java)
+        val responseMap = tryToParse(json) ?: return
         val messageId = responseMap["messageId"].toString()
         val messageType = responseMap["messageType"].toString()
         val data = responseMap["data"]
 
         // IDE listeners
-        if (MessageTypes.IDE_MESSAGE_TYPES.contains(messageType)) {
+        if (messageType in MessageTypes.IDE_MESSAGE_TYPES) {
             ideProtocolClient.handleMessage(json) { data ->
                 val message = gson.toJson(mapOf("messageId" to messageId, "messageType" to messageType, "data" to data))
                 process.write(message)
@@ -52,8 +55,9 @@ class CoreMessenger(
         }
 
         // Forward to webview
-        if (MessageTypes.PASS_THROUGH_TO_WEBVIEW.contains(messageType)) {
+        if (messageType in MessageTypes.PASS_THROUGH_TO_WEBVIEW) {
             val continuePluginService = project.service<ContinuePluginService>()
+            // todo: is this a bug below (messageType = ID)? verify
             continuePluginService.sendToWebview(messageType, responseMap["data"], messageType)
         }
 
@@ -68,6 +72,15 @@ class CoreMessenger(
         }
     }
 
+    // todo: map<*, *> = code smell
+    private fun tryToParse(json: String): Map<*, *>? =
+        try {
+            gson.fromJson(json, Map::class.java)
+        } catch (_: JsonSyntaxException) {
+            log.warn("Invalid message JSON: $json") // example: NODE_ENV undefined
+            null
+        }
+
     fun killSubProcess() {
         process.close()
     }
diff --git a/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/continue/IdeProtocolClient.kt b/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/continue/IdeProtocolClient.kt
index 08a5e8d1846..66ea992a46d 100644
--- a/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/continue/IdeProtocolClient.kt
+++ b/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/continue/IdeProtocolClient.kt
@@ -8,12 +8,13 @@ import com.github.continuedev.continueintellijextension.editor.DiffStreamService
 import com.github.continuedev.continueintellijextension.editor.EditorUtils
 import com.github.continuedev.continueintellijextension.error.ContinueErrorService
 import com.github.continuedev.continueintellijextension.protocol.*
-import com.github.continuedev.continueintellijextension.services.*
-import com.github.continuedev.continueintellijextension.utils.*
+import com.github.continuedev.continueintellijextension.services.ContinueExtensionSettings
+import com.github.continuedev.continueintellijextension.services.ContinuePluginService
+import com.github.continuedev.continueintellijextension.utils.getMachineUniqueID
+import com.github.continuedev.continueintellijextension.utils.uuid
 import com.google.gson.Gson
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.command.WriteCommandAction
-import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.components.service
 import com.intellij.openapi.editor.SelectionModel
 import com.intellij.openapi.fileEditor.FileEditorManager
@@ -21,7 +22,10 @@ import com.intellij.openapi.project.DumbAware
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.openapi.wm.ToolWindowManager
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.launch
 import java.awt.Toolkit
 import java.awt.datatransfer.StringSelection
 
@@ -323,7 +327,11 @@ class IdeProtocolClient(
                     }
 
                     "runCommand" -> {
-                        // Running commands not yet supported in JetBrains
+                        val params = Gson().fromJson(
+                            dataElement.toString(),
+                            RunCommandParams::class.java
+                        )
+                        ide.runCommand(params.command, params.options)
                         respond(null)
                     }
 
diff --git a/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/continue/IntelliJIde.kt b/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/continue/IntelliJIde.kt
index d6980afb819..2f1889fb43c 100644
--- a/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/continue/IntelliJIde.kt
+++ b/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/continue/IntelliJIde.kt
@@ -1,4 +1,3 @@
-
 package com.github.continuedev.continueintellijextension.`continue`
 
 import com.github.continuedev.continueintellijextension.*
@@ -27,12 +26,14 @@ import com.intellij.openapi.fileEditor.FileDocumentManager
 import com.intellij.openapi.fileEditor.FileEditorManager
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.project.guessProjectDir
-import com.intellij.openapi.util.IconLoader
 import com.intellij.openapi.vfs.LocalFileSystem
 import com.intellij.openapi.vfs.VirtualFileManager
+import com.intellij.openapi.wm.ToolWindowManager
 import com.intellij.psi.PsiDocumentManager
 import com.intellij.testFramework.LightVirtualFile
 import kotlinx.coroutines.*
+import org.jetbrains.plugins.terminal.ShellTerminalWidget
+import org.jetbrains.plugins.terminal.TerminalView
 import java.awt.Toolkit
 import java.awt.datatransfer.DataFlavor
 import java.io.BufferedReader
@@ -54,7 +55,7 @@ class IntelliJIDE(
     init {
         try {
             val os = getOS()
-            
+
             if (os == OS.LINUX || os == OS.MAC) {
                 val file = File(ripgrep)
                 if (!file.canExecute()) {
@@ -135,7 +136,33 @@ class IntelliJIDE(
     }
 
     override suspend fun getTerminalContents(): String {
-        return ""
+        return withContext(Dispatchers.EDT) {
+            try {
+                val toolWindow = ToolWindowManager.getInstance(project).getToolWindow("Terminal")
+
+                val terminalView = TerminalView.getInstance(project)
+                // Find the first terminal widget selected, whatever its state, running command or not.
+                val widget = terminalView.getWidgets().filterIsInstance<ShellTerminalWidget>().firstOrNull {
+                    toolWindow?.getContentManager()?.getContent(it)?.isSelected ?: false
+                }
+
+                if (widget != null) {
+                    val textBuffer = widget.terminalTextBuffer
+                    val stringBuilder = StringBuilder()
+                    // Iterate through all lines in the buffer (history + screen)
+                    for (i in 0 until textBuffer.historyLinesCount + textBuffer.screenLinesCount) {
+                        stringBuilder.append(textBuffer.getLine(i).text).append('\n')
+                    }
+                    stringBuilder.toString()
+                } else {
+                    "" // Return empty if no terminal is available
+                }
+            } catch (e: Exception) {
+                println("Error getting terminal contents: ${e.message}")
+                e.printStackTrace()
+                "" // Return empty on error
+            }
+        }
     }
 
     override suspend fun getDebugLocals(threadIndex: Int): String {
@@ -220,8 +247,65 @@ class IntelliJIDE(
         }
     }
 
-    override suspend fun runCommand(command: String) {
-        throw NotImplementedError("runCommand not implemented in IntelliJ")
+    override suspend fun runCommand(command: String, options: TerminalOptions?) {
+        val terminalOptions =
+            options ?: TerminalOptions(reuseTerminal = true, terminalName = null, waitForCompletion = false)
+
+        ApplicationManager.getApplication().invokeLater {
+            try {
+                val toolWindow = ToolWindowManager.getInstance(project).getToolWindow("Terminal")
+                toolWindow?.activate({
+                    try {
+                        val terminalView = TerminalView.getInstance(project)
+                        var widget: ShellTerminalWidget? = null
+
+                        // 1. Handle reuseTerminal option
+                        if (terminalOptions.reuseTerminal == true && terminalView.getWidgets().isNotEmpty()) {
+                            // 2. Find by terminalName if provided
+                            if (terminalOptions.terminalName != null) {
+                                widget = terminalView.getWidgets().filterIsInstance<ShellTerminalWidget>()
+                                    .firstOrNull {
+                                        toolWindow.contentManager.getContent(it).tabName == terminalOptions.terminalName
+                                                && !it.hasRunningCommands()
+                                    }
+                            } else {
+                                // 3. Find active terminal, or fall back to the first one
+                                widget = terminalView.getWidgets().filterIsInstance<ShellTerminalWidget>()
+                                    .firstOrNull { toolWindow.contentManager.getContent(it).isSelected }
+                                    ?: terminalView.getWidgets().filterIsInstance<ShellTerminalWidget>().firstOrNull {
+                                        !it.hasRunningCommands()
+                                    }
+                            }
+                        }
+
+                        // 4. Create a new terminal if needed
+                        if (widget == null) {
+                            widget = terminalView.createLocalShellWidget(
+                                project.basePath,
+                                terminalOptions.terminalName,
+                                true
+                            )
+                        } else {
+                            // Ensure the found widget is visible
+                            val content = toolWindow.contentManager.getContent(widget)
+                            if (content != null) {
+                                toolWindow.contentManager.setSelectedContent(content, true)
+                            }
+                        }
+
+                        // 5. Show and send text
+                        widget.ttyConnector?.write(command)
+
+                    } catch (e: Exception) {
+                        println("Error during terminal widget handling: ${e.message}")
+                        e.printStackTrace()
+                    }
+                }, true)
+            } catch (e: Exception) {
+                println("Error activating terminal tool window: ${e.message}")
+                e.printStackTrace()
+            }
+        }
     }
 
     override suspend fun saveFile(filepath: String) {
@@ -343,7 +427,7 @@ class IntelliJIDE(
                 }
 
                 val command = GeneralCommandLine(commandArgs)
-    
+
                 command.setWorkDirectory(project.basePath)
                 val results = ExecUtil.execAndGetOutput(command).stdout
                 return results.split("\n")
@@ -357,11 +441,12 @@ class IntelliJIDE(
             throw NotImplementedError("Ripgrep not supported, this workspace is remote")
         }
     }
+
     override suspend fun getSearchResults(query: String, maxResults: Int?): String {
         val ideInfo = this.getIdeInfo()
         if (ideInfo.remoteName == "local") {
             try {
-                 val commandArgs = mutableListOf(
+                val commandArgs = mutableListOf(
                     ripgrep,
                     "-i",
                     "--ignore-file",
@@ -372,20 +457,20 @@ class IntelliJIDE(
                     "2",
                     "--heading"
                 )
-                
+
                 // Conditionally add maxResults flag
                 if (maxResults != null) {
                     commandArgs.add("-m")
                     commandArgs.add(maxResults.toString())
                 }
-                
+
                 // Add the search query and path
                 commandArgs.add("-e")
                 commandArgs.add(query)
                 commandArgs.add(".")
 
                 val command = GeneralCommandLine(commandArgs)
-    
+
                 command.setWorkDirectory(project.basePath)
                 return ExecUtil.execAndGetOutput(command).stdout
             } catch (exception: Exception) {
@@ -594,6 +679,14 @@ class IntelliJIDE(
         throw NotImplementedError("gotoDefinition not implemented yet")
     }
 
+    override suspend fun gotoTypeDefinition(location: Location): List<RangeInFile> {
+        throw NotImplementedError("gotoTypeDefinition not implemented yet")
+    }
+
+    override suspend fun getSignatureHelp(location: Location): SignatureHelp? {
+        throw NotImplementedError("getSignatureHelp not implemented yet")
+    }
+
     override fun onDidChangeActiveTextEditor(callback: (filepath: String) -> Unit) {
         throw NotImplementedError("onDidChangeActiveTextEditor not implemented yet")
     }
diff --git a/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/continue/process/ContinueBinaryProcess.kt b/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/continue/process/ContinueBinaryProcess.kt
index eb45cc4da4d..f10dd9d6542 100644
--- a/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/continue/process/ContinueBinaryProcess.kt
+++ b/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/continue/process/ContinueBinaryProcess.kt
@@ -1,5 +1,6 @@
 package com.github.continuedev.continueintellijextension.`continue`.process
 
+import com.github.continuedev.continueintellijextension.error.ContinueErrorService
 import com.github.continuedev.continueintellijextension.services.TelemetryService
 import com.github.continuedev.continueintellijextension.utils.OS
 import com.github.continuedev.continueintellijextension.utils.getContinueBinaryPath
@@ -44,11 +45,8 @@ class ContinueBinaryProcess(private val onExit: () -> Unit) : ContinueProcess {
                 err = err.substring(doneIndex + delimiter.length)
             }
         }
-
-        println("Core process exited with output: $err")
-
-        val telemetryService = service<TelemetryService>()
-        telemetryService.capture("jetbrains_core_exit", mapOf("error" to err))
+        service<ContinueErrorService>().reportMessage("Core process exited with output: $err")
+        service<TelemetryService>().capture("jetbrains_core_exit", mapOf("error" to err))
     }
 
     private companion object {
@@ -67,6 +65,7 @@ class ContinueBinaryProcess(private val onExit: () -> Unit) : ContinueProcess {
             elevatePermissions()
         }
 
+        // todo: consider setting permissions ahead-of-time during build/packaging, not at runtime
         private fun elevatePermissions() {
             val path = getContinueBinaryPath()
             val permissions = setOf(
diff --git a/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/error/ContinueErrorService.kt b/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/error/ContinueErrorService.kt
index 21f920ef9fd..35e23d8a266 100644
--- a/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/error/ContinueErrorService.kt
+++ b/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/error/ContinueErrorService.kt
@@ -6,6 +6,7 @@ import com.intellij.openapi.components.Service
 import com.intellij.openapi.diagnostic.Attachment
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.extensions.PluginId
+import com.intellij.openapi.util.SystemInfo
 import com.intellij.ui.jcef.JBCefApp
 import io.sentry.Hint
 import io.sentry.Sentry
@@ -26,6 +27,8 @@ class ContinueErrorService {
             config.setTag("ide_version", ApplicationInfo.getInstance().build.asString())
             config.setTag("jcef_supported", JBCefApp.isSupported().toString())
             config.setTag("plugin_version", PluginManagerCore.getPlugin(PluginId.getId(PLUGIN_ID))?.version)
+            config.setTag("system", SystemInfo.OS_NAME)
+            config.setTag("system_version", SystemInfo.OS_VERSION)
         }
     }
 
@@ -39,7 +42,14 @@ class ContinueErrorService {
         sentryEvent.message = Message().apply { this.message = message }
         val hint = Hint.withAttachments(attachments?.map { SentryAttachment(it.bytes, it.path) })
         Sentry.captureEvent(sentryEvent, hint)
-        log.warn("Problem sent to Sentry: $message", throwable)
+        log.warn("Exception sent to Sentry: $message", throwable)
+    }
+
+    fun reportMessage(
+        message: String,
+    ) {
+        Sentry.captureMessage(message)
+        log.warn("Message sent to Sentry: $message")
     }
 
     private companion object {
diff --git a/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/protocol/ide.kt b/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/protocol/ide.kt
index bf377e675bc..bc199b35a57 100644
--- a/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/protocol/ide.kt
+++ b/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/protocol/ide.kt
@@ -1,6 +1,7 @@
 package com.github.continuedev.continueintellijextension.protocol
 
-import com.github.continuedev.continueintellijextension.*
+import com.github.continuedev.continueintellijextension.Range
+import com.github.continuedev.continueintellijextension.TerminalOptions
 
 data class GetControlPlaneSessionInfoParams(val silent: Boolean, val useOnboarding: Boolean)
 
@@ -59,4 +60,6 @@ data class GetGitRootPathParams(val dir: String)
 
 data class ListDirParams(val dir: String)
 
-data class GetFileStatsParams(val files: List<String>)
\ No newline at end of file
+data class GetFileStatsParams(val files: List<String>)
+
+data class RunCommandParams(val command: String, val options: TerminalOptions?)
diff --git a/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/services/ContinueExtensionSettingsService.kt b/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/services/ContinueExtensionSettingsService.kt
index 4e41179851c..057a8759393 100644
--- a/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/services/ContinueExtensionSettingsService.kt
+++ b/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/services/ContinueExtensionSettingsService.kt
@@ -1,25 +1,25 @@
 package com.github.continuedev.continueintellijextension.services
 
-import com.github.continuedev.continueintellijextension.constants.getConfigJsPath
 import com.github.continuedev.continueintellijextension.constants.getConfigJsonPath
-import com.intellij.execution.target.value.constant
+import com.github.continuedev.continueintellijextension.error.ContinueErrorService
 import com.intellij.openapi.application.ApplicationInfo
 import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.components.*
+import com.intellij.openapi.components.PersistentStateComponent
+import com.intellij.openapi.components.State
+import com.intellij.openapi.components.Storage
+import com.intellij.openapi.components.service
 import com.intellij.openapi.options.Configurable
 import com.intellij.openapi.project.DumbAware
-import com.intellij.openapi.util.SystemInfo
 import com.intellij.util.concurrency.AppExecutorUtil
+import com.intellij.util.io.HttpRequests
 import com.intellij.util.messages.Topic
-import kotlinx.serialization.Serializable
 import kotlinx.serialization.decodeFromString
 import kotlinx.serialization.json.Json
-import okhttp3.OkHttpClient
-import okhttp3.Request
 import java.awt.GridBagConstraints
 import java.awt.GridBagLayout
 import java.io.File
 import java.io.IOException
+import java.net.URL
 import java.util.concurrent.ScheduledFuture
 import java.util.concurrent.TimeUnit
 import javax.swing.*
@@ -72,11 +72,10 @@ class ContinueSettingsComponent : DumbAware {
     }
 }
 
-@Serializable
-class ContinueRemoteConfigSyncResponse {
-    var configJson: String? = null
-    var configJs: String? = null
-}
+data class ContinueRemoteConfigSyncResponse(
+    var configJson: String?,
+    var configJs: String?
+)
 
 @State(
     name = "com.github.continuedev.continueintellijextension.services.ContinueExtensionSettings",
@@ -117,50 +116,23 @@ open class ContinueExtensionSettings : PersistentStateComponent<ContinueExtensio
 
     // Sync remote config from server
     private fun syncRemoteConfig() {
-        val state = instance.continueState
-
-        if (state.remoteConfigServerUrl != null && state.remoteConfigServerUrl!!.isNotEmpty()) {
-            // download remote config as json file
-
-            val client = OkHttpClient()
-            val baseUrl = state.remoteConfigServerUrl?.removeSuffix("/")
-
-            val requestBuilder = Request.Builder().url("${baseUrl}/sync")
-
-            if (state.userToken != null) {
-                requestBuilder.addHeader("Authorization", "Bearer ${state.userToken}")
-            }
-
-            val request = requestBuilder.build()
-            var configResponse: ContinueRemoteConfigSyncResponse? = null
-
+        val remoteServerUrl = state.remoteConfigServerUrl
+        val token = state.userToken
+        if (remoteServerUrl != null && remoteServerUrl.isNotEmpty()) {
+            val baseUrl = remoteServerUrl.removeSuffix("/")
             try {
-                client.newCall(request).execute().use { response ->
-                    if (!response.isSuccessful) throw IOException("Unexpected code $response")
-
-                    response.body?.string()?.let { responseBody ->
-                        try {
-                            configResponse =
-                                Json.decodeFromString<ContinueRemoteConfigSyncResponse>(responseBody)
-                        } catch (e: Exception) {
-                            e.printStackTrace()
-                            return
-                        }
-                    }
-                }
+                val url = "$baseUrl/sync"
+                val responseBody = HttpRequests.post(url, HttpRequests.JSON_CONTENT_TYPE)
+                    .tuner { connection ->
+                        if (token != null)
+                            connection.addRequestProperty("Authorization", "Bearer $token")
+                    }.readString()
+                val response = Json.decodeFromString<ContinueRemoteConfigSyncResponse>(responseBody)
+                val file = File(getConfigJsonPath(URL(url).host))
+                response.configJs.let { file.writeText(it!!) }
+                response.configJson.let { file.writeText(it!!) }
             } catch (e: IOException) {
-                e.printStackTrace()
-                return
-            }
-
-            if (configResponse?.configJson?.isNotEmpty()!!) {
-                val file = File(getConfigJsonPath(request.url.host))
-                file.writeText(configResponse!!.configJson!!)
-            }
-
-            if (configResponse?.configJs?.isNotEmpty()!!) {
-                val file = File(getConfigJsPath(request.url.host))
-                file.writeText(configResponse!!.configJs!!)
+                service<ContinueErrorService>().report(e, "Unexpected exception during remote config sync")
             }
         }
     }
@@ -174,7 +146,7 @@ open class ContinueExtensionSettings : PersistentStateComponent<ContinueExtensio
 
         instance.remoteSyncFuture = AppExecutorUtil.getAppScheduledExecutorService()
             .scheduleWithFixedDelay(
-                { syncRemoteConfig() },
+                ::syncRemoteConfig,
                 0,
                 continueState.remoteConfigSyncPeriod.toLong(),
                 TimeUnit.MINUTES
diff --git a/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/types.kt b/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/types.kt
index b7680fceb9f..133c80e63a1 100644
--- a/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/types.kt
+++ b/extensions/intellij/src/main/kotlin/com/github/continuedev/continueintellijextension/types.kt
@@ -64,6 +64,68 @@ data class RangeInFileWithContents(
     val contents: String
 )
 
+/**
+ * Signature help represents the signature of something
+ * callable. There can be multiple signatures but only one
+ * active and only one active parameter.
+ */
+data class SignatureHelp(
+    /**
+     * One or more signatures.
+     */
+    val signatures: List<SignatureInformation>,
+
+    /**
+     * The active signature.
+     */
+    val activeSignature: Int,
+
+    /**
+     * The active parameter of the active signature.
+     */
+    val activeParameter: Int
+)
+
+/**
+ * Represents the signature of something callable. A signature
+ * can have a label, like a function-name, a doc-comment, and
+ * a set of parameters.
+ */
+data class SignatureInformation(
+    /**
+     * The label of this signature. Will be shown in
+     * the UI.
+     */
+    val label: String,
+
+    /**
+     * The parameters of this signature.
+     */
+    val parameters: List<ParameterInformation>,
+
+    /**
+     * The index of the active parameter.
+     *
+     * If provided, this is used in place of [SignatureHelp.activeParameter].
+     */
+    val activeParameter: Int? = null
+)
+
+/**
+ * Represents a parameter of a callable-signature. A parameter can
+ * have a label and a doc-comment.
+ */
+data class ParameterInformation(
+    /**
+     * The label of this signature.
+     *
+     * Either a string or inclusive start and exclusive end offsets within its containing
+     * [SignatureInformation.label] signature label. *Note*: A label of type string must be
+     * a substring of its containing signature information's [SignatureInformation.label] label.
+     */
+    val label: String // Note: Kotlin doesn't have union types, so this represents the string case
+)
+
 data class ControlPlaneSessionInfo(
     val accessToken: String,
     val account: Account
@@ -91,6 +153,11 @@ data class ContinueRcJson(
     val mergeBehavior: ConfigMergeType
 )
 
+data class TerminalOptions(
+    val reuseTerminal: Boolean?,
+    val terminalName: String?,
+    val waitForCompletion: Boolean?
+)
 
 interface IDE {
     suspend fun getIdeInfo(): IdeInfo
@@ -134,7 +201,7 @@ interface IDE {
 
     suspend fun openUrl(url: String)
 
-    suspend fun runCommand(command: String)
+    suspend fun runCommand(command: String, options: TerminalOptions?)
 
     suspend fun saveFile(filepath: String)
 
@@ -192,6 +259,8 @@ interface IDE {
 
     // LSP
     suspend fun gotoDefinition(location: Location): List<RangeInFile>
+    suspend fun gotoTypeDefinition(location: Location): List<RangeInFile>
+    suspend fun getSignatureHelp(location: Location): SignatureHelp?
 
     // Callbacks
     fun onDidChangeActiveTextEditor(callback: (filepath: String) -> Unit)
@@ -253,4 +322,4 @@ data class ShowFilePayload(
 sealed class FimResult {
     data class FimEdit(val fimText: String) : FimResult()
     object NotFimEdit : FimResult()
-}
\ No newline at end of file
+}
diff --git a/extensions/intellij/src/main/resources/META-INF/plugin.xml b/extensions/intellij/src/main/resources/META-INF/plugin.xml
index 951338698cd..15a0dd86454 100644
--- a/extensions/intellij/src/main/resources/META-INF/plugin.xml
+++ b/extensions/intellij/src/main/resources/META-INF/plugin.xml
@@ -7,6 +7,7 @@
         <![CDATA[View the latest release notes on <a href="https://github.com/continuedev/continue/releases">GitHub</a>]]></change-notes>
 
     <depends>com.intellij.modules.platform</depends>
+    <depends>org.jetbrains.plugins.terminal</depends>
 
     <!-- See here for why this is optional:  https://github.com/continuedev/continue/issues/2775#issuecomment-2535620877-->
     <depends optional="true" config-file="continueintellijextension-withJSON.xml">
diff --git a/extensions/vscode/package.json b/extensions/vscode/package.json
index eef92dc705f..cb4ae0cf43e 100644
--- a/extensions/vscode/package.json
+++ b/extensions/vscode/package.json
@@ -2,7 +2,7 @@
   "name": "continue",
   "icon": "media/icon.png",
   "author": "Continue Dev, Inc",
-  "version": "1.1.66",
+  "version": "1.1.67",
   "repository": {
     "type": "git",
     "url": "https://github.com/continuedev/continue"
diff --git a/extensions/vscode/src/VsCodeIde.ts b/extensions/vscode/src/VsCodeIde.ts
index dbba251a717..135a0d43f90 100644
--- a/extensions/vscode/src/VsCodeIde.ts
+++ b/extensions/vscode/src/VsCodeIde.ts
@@ -8,7 +8,10 @@ import { getDirectParentDir } from "core/util/uri";
 import * as URI from "uri-js";
 import * as vscode from "vscode";
 
-import { executeGotoProvider } from "./autocomplete/lsp";
+import {
+  executeGotoProvider,
+  executeSignatureHelpProvider,
+} from "./autocomplete/lsp";
 import { isGraniteOnboardingComplete } from "./granite/utils/extensionUtils";
 import { Repository } from "./otherExtensions/git";
 import { SecretStorage } from "./stubs/SecretStorage";
@@ -28,6 +31,7 @@ import type {
   Location,
   Problem,
   RangeInFile,
+  SignatureHelp,
   TerminalOptions,
   Thread,
 } from "core";
@@ -91,6 +95,28 @@ class VsCodeIde implements IDE {
     return result;
   }
 
+  async gotoTypeDefinition(location: Location): Promise<RangeInFile[]> {
+    const result = await executeGotoProvider({
+      uri: vscode.Uri.parse(location.filepath),
+      line: location.position.line,
+      character: location.position.character,
+      name: "vscode.executeTypeDefinitionProvider",
+    });
+
+    return result;
+  }
+
+  async getSignatureHelp(location: Location): Promise<SignatureHelp | null> {
+    const result = await executeSignatureHelpProvider({
+      uri: vscode.Uri.parse(location.filepath),
+      line: location.position.line,
+      character: location.position.character,
+      name: "vscode.executeSignatureHelpProvider",
+    });
+
+    return result;
+  }
+
   onDidChangeActiveTextEditor(callback: (uri: string) => void): void {
     vscode.window.onDidChangeActiveTextEditor((editor) => {
       if (editor) {
diff --git a/extensions/vscode/src/autocomplete/lsp.ts b/extensions/vscode/src/autocomplete/lsp.ts
index a6900291af3..c3d5c11a49f 100644
--- a/extensions/vscode/src/autocomplete/lsp.ts
+++ b/extensions/vscode/src/autocomplete/lsp.ts
@@ -13,7 +13,13 @@ import { intersection } from "core/util/ranges";
 import * as URI from "uri-js";
 import * as vscode from "vscode";
 
-import type { IDE, Range, RangeInFile, RangeInFileWithContents } from "core";
+import type {
+  IDE,
+  Range,
+  RangeInFile,
+  RangeInFileWithContents,
+  SignatureHelp,
+} from "core";
 import type Parser from "web-tree-sitter";
 
 type GotoProviderName =
@@ -23,6 +29,8 @@ type GotoProviderName =
   | "vscode.executeImplementationProvider"
   | "vscode.executeReferenceProvider";
 
+type SignatureHelpProviderName = "vscode.executeSignatureHelpProvider";
+
 interface GotoInput {
   uri: vscode.Uri;
   line: number;
@@ -33,8 +41,19 @@ function gotoInputKey(input: GotoInput) {
   return `${input.name}${input.uri.toString()}${input.line}${input.character}`;
 }
 
+interface SignatureHelpInput {
+  uri: vscode.Uri;
+  line: number;
+  character: number;
+  name: SignatureHelpProviderName;
+}
+function signatureHelpKey(input: SignatureHelpInput) {
+  return `${input.name}${input.uri.toString()}${input.line}${input.character}`;
+}
+
 const MAX_CACHE_SIZE = 500;
 const gotoCache = new Map<string, RangeInFile[]>();
+const signatureHelpCache = new Map<string, vscode.SignatureHelp>();
 
 export async function executeGotoProvider(
   input: GotoInput,
@@ -382,3 +401,36 @@ export const getDefinitionsFromLsp: GetLspDefinitionsFunction = async (
     return [];
   }
 };
+
+export async function executeSignatureHelpProvider(
+  input: SignatureHelpInput,
+): Promise<SignatureHelp | null> {
+  const cacheKey = signatureHelpKey(input);
+  const cached = signatureHelpCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+
+  try {
+    const definitions = (await vscode.commands.executeCommand(
+      input.name,
+      input.uri,
+      new vscode.Position(input.line, input.character),
+    )) as SignatureHelp;
+
+    // Add to cache
+    if (signatureHelpCache.size >= MAX_CACHE_SIZE) {
+      // Remove the oldest item from the cache
+      const oldestKey = signatureHelpCache.keys().next().value;
+      if (oldestKey) {
+        signatureHelpCache.delete(oldestKey);
+      }
+    }
+    signatureHelpCache.set(cacheKey, definitions);
+
+    return definitions;
+  } catch (e) {
+    console.warn(`Error executing ${input.name}:`, e);
+    return null;
+  }
+}
diff --git a/extensions/vscode/src/extension/EditOutcomeTracker.ts b/extensions/vscode/src/extension/EditOutcomeTracker.ts
index c69dbac72f4..69ac452faff 100644
--- a/extensions/vscode/src/extension/EditOutcomeTracker.ts
+++ b/extensions/vscode/src/extension/EditOutcomeTracker.ts
@@ -65,6 +65,7 @@ class EditOutcomeTracker {
         newCodeLines: pendingEdit.newCodeLines,
         lineChange: pendingEdit.lineChange,
         accepted,
+        filepath: pendingEdit.filepath,
       },
     });
 
diff --git a/extensions/vscode/tree-sitter/static-context-queries/hole-queries/typescript.scm b/extensions/vscode/tree-sitter/static-context-queries/hole-queries/typescript.scm
new file mode 100644
index 00000000000..02de3446601
--- /dev/null
+++ b/extensions/vscode/tree-sitter/static-context-queries/hole-queries/typescript.scm
@@ -0,0 +1,59 @@
+;; Capture the variable/function name
+(variable_declarator
+  name: (identifier) @function.name
+  type: (type_annotation
+    (function_type) @function.type))
+
+;; Capture the full parameter list
+(function_type
+  parameters: (formal_parameters) @function.params)
+
+;; Capture the type identifiers used in the parameters
+(formal_parameters
+  (required_parameter
+    type: (type_annotation
+      (type_identifier) @param.type))
+  (required_parameter
+    type: (type_annotation
+      (type_identifier) @param.type)))
+
+;; Capture the return type of the function
+(function_type
+  return_type: (type_identifier) @return.type)
+
+;; Capture any parse errors (e.g., the `@`)
+(ERROR) @error.node
+
+;; Capture the entire function declaration line
+(lexical_declaration) @function.decl
+
+;; Matches import declarations like: import { A, B } from "module";
+(import_statement
+  (import_clause
+    (named_imports
+      (import_specifier
+        name: (identifier) @import.name)))
+  source: (string) @import.source)
+
+;; Capture standalone function declarations
+(function_declaration
+  name: (identifier) @function.name) @function.decl
+
+;; Capture the function signature including parameters and return type
+(function_declaration
+  parameters: (formal_parameters) @function.params
+  return_type: (type_annotation)? @function.type)
+
+;; For function expressions or arrow functions
+(function_type
+  parameters: (formal_parameters) @function.params) @function.decl
+
+;; For arrow functions
+(arrow_function
+  parameters: (formal_parameters) @function.params) @function.decl
+
+;; For function signatures without a body (like in your example)
+(function_signature
+  name: (identifier) @function.name
+  parameters: (formal_parameters) @function.params
+  return_type: (type_annotation)? @function.type) @function.decl
diff --git a/extensions/vscode/tree-sitter/static-context-queries/relevant-headers-queries/typescript-get-toplevel-headers.scm b/extensions/vscode/tree-sitter/static-context-queries/relevant-headers-queries/typescript-get-toplevel-headers.scm
new file mode 100644
index 00000000000..02b0bda7724
--- /dev/null
+++ b/extensions/vscode/tree-sitter/static-context-queries/relevant-headers-queries/typescript-get-toplevel-headers.scm
@@ -0,0 +1,22 @@
+;; Match top-level `var`, `let`, or `const` declarations
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @top.var.name
+    type: (type_annotation
+            (_) @top.var.type))) @top.var.decl
+
+(variable_declaration
+  (variable_declarator
+    name: (identifier) @top.var.name
+    type: (type_annotation
+            (_) @top.var.type))) @top.var.decl
+
+;; Match function declarations
+(function_declaration
+  name: (identifier) @top.fn.name
+  parameters: (formal_parameters
+    (required_parameter
+      pattern: (identifier) @top.fn.param.name
+      type: (type_annotation (_) @top.fn.param.type)))*
+
+  return_type: (type_annotation (_) @top.fn.type)?) @top.fn.decl
diff --git a/extensions/vscode/tree-sitter/static-context-queries/relevant-types-queries/typescript-extract-identifiers.scm b/extensions/vscode/tree-sitter/static-context-queries/relevant-types-queries/typescript-extract-identifiers.scm
new file mode 100644
index 00000000000..b5051cb7751
--- /dev/null
+++ b/extensions/vscode/tree-sitter/static-context-queries/relevant-types-queries/typescript-extract-identifiers.scm
@@ -0,0 +1,10 @@
+;; Capture the type alias name (left-hand side)
+; (type_alias_declaration
+;   name: (type_identifier) @type.name)
+
+;; Capture all identifiers on the right-hand side (value), recursively
+; (type_alias_declaration
+;   value: (_) @type.value)
+
+;; Match all identifiers inside the type value — deeply nested
+(type_identifier) @type.identifier
diff --git a/extensions/vscode/tree-sitter/static-context-queries/relevant-types-queries/typescript-find-typedecl-given-typeidentifier.scm b/extensions/vscode/tree-sitter/static-context-queries/relevant-types-queries/typescript-find-typedecl-given-typeidentifier.scm
new file mode 100644
index 00000000000..b26180e05c6
--- /dev/null
+++ b/extensions/vscode/tree-sitter/static-context-queries/relevant-types-queries/typescript-find-typedecl-given-typeidentifier.scm
@@ -0,0 +1,11 @@
+(type_alias_declaration
+  name: (type_identifier) @type.identifier
+  value: (_) @type.value)
+
+(interface_declaration
+  name: (type_identifier) @type.identifier
+  body: (_) @type.value)
+
+(enum_declaration
+  name: (type_identifier) @type.identifier
+  body: (_) @type.value)
diff --git a/gui/src/components/History/HistoryTableRow.tsx b/gui/src/components/History/HistoryTableRow.tsx
index 65c99233c6e..0143b1488db 100644
--- a/gui/src/components/History/HistoryTableRow.tsx
+++ b/gui/src/components/History/HistoryTableRow.tsx
@@ -79,7 +79,7 @@ export function HistoryTableRow({
         navigate("/");
       }}
     >
-      <div className="flex-1 cursor-pointer space-y-1">
+      <td className="flex-1 cursor-pointer space-y-1">
         {editing ? (
           <div>
             <Input
@@ -114,10 +114,10 @@ export function HistoryTableRow({
                 })}
               </span> */}
         </div>
-      </div>
+      </td>
 
       {hovered && !editing && (
-        <div className="bg-badge absolute right-2 top-1/2 ml-auto flex -translate-y-1/2 transform items-center gap-x-1 rounded-full px-2 py-1 shadow-md">
+        <td className="bg-badge absolute right-2 top-1/2 ml-auto flex -translate-y-1/2 transform items-center gap-x-1 rounded-full px-2 py-1 shadow-md">
           <HeaderButtonWithToolTip
             text="Edit"
             onClick={async (e) => {
@@ -136,7 +136,7 @@ export function HistoryTableRow({
           >
             <TrashIcon width="1em" height="1em" />
           </HeaderButtonWithToolTip>
-        </div>
+        </td>
       )}
     </tr>
   );
diff --git a/gui/src/components/StyledMarkdownPreview/StepContainerPreToolbar/RunInTerminalButton.tsx b/gui/src/components/StyledMarkdownPreview/StepContainerPreToolbar/RunInTerminalButton.tsx
index da0e439c066..4d6aa97bd89 100644
--- a/gui/src/components/StyledMarkdownPreview/StepContainerPreToolbar/RunInTerminalButton.tsx
+++ b/gui/src/components/StyledMarkdownPreview/StepContainerPreToolbar/RunInTerminalButton.tsx
@@ -2,7 +2,6 @@ import { CommandLineIcon } from "@heroicons/react/24/outline";
 import { useContext } from "react";
 import { lightGray, vscForeground } from "../..";
 import { IdeMessengerContext } from "../../../context/IdeMessenger";
-import { isJetBrains } from "../../../util";
 import { extractCommand } from "../utils/commandExtractor";
 
 interface RunInTerminalButtonProps {
@@ -12,11 +11,6 @@ interface RunInTerminalButtonProps {
 export function RunInTerminalButton({ command }: RunInTerminalButtonProps) {
   const ideMessenger = useContext(IdeMessengerContext);
 
-  if (isJetBrains()) {
-    // JetBrains plugin doesn't currently have a way to run the command in the terminal for the user
-    return null;
-  }
-
   function runInTerminal() {
     // Extract just the command line
     const extractedCommand = extractCommand(command);
diff --git a/gui/src/components/StyledMarkdownPreview/utils/headerIsMarkdown.test.ts b/gui/src/components/StyledMarkdownPreview/utils/headerIsMarkdown.test.ts
deleted file mode 100644
index 51649c2513f..00000000000
--- a/gui/src/components/StyledMarkdownPreview/utils/headerIsMarkdown.test.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import { headerIsMarkdown } from "./headerIsMarkdown";
-
-describe("headerIsMarkdown", () => {
-  // Test exact match with common Markdown identifiers
-  it("should identify exact matches with common Markdown identifiers", () => {
-    expect(headerIsMarkdown("md")).toBe(true);
-    expect(headerIsMarkdown("markdown")).toBe(true);
-    expect(headerIsMarkdown("gfm")).toBe(true);
-    expect(headerIsMarkdown("github-markdown")).toBe(true);
-  });
-
-  // Test identifiers preceded by a space
-  it("should identify identifiers preceded by a space", () => {
-    expect(headerIsMarkdown("lang md")).toBe(true);
-    expect(headerIsMarkdown("something markdown")).toBe(true);
-    expect(headerIsMarkdown("language gfm")).toBe(true);
-    expect(headerIsMarkdown("spec github-markdown")).toBe(true);
-  });
-
-  // Test file extensions
-  it("should identify file names with markdown extensions", () => {
-    expect(headerIsMarkdown("example.md")).toBe(true);
-    expect(headerIsMarkdown("document.markdown")).toBe(true);
-    expect(headerIsMarkdown("readme.gfm")).toBe(true);
-  });
-
-  // Test more complex cases with extensions
-  it("should identify file names with markdown extensions followed by other text", () => {
-    expect(headerIsMarkdown("example.md additional text")).toBe(true);
-    expect(headerIsMarkdown("document.markdown with some description")).toBe(
-      true,
-    );
-    expect(headerIsMarkdown("readme.gfm v2.0")).toBe(true);
-  });
-
-  // Test non-markdown cases
-  it("should not identify non-markdown headers", () => {
-    expect(headerIsMarkdown("javascript")).toBe(false);
-    expect(headerIsMarkdown("typescript")).toBe(false);
-    expect(headerIsMarkdown("plain")).toBe(false);
-    expect(headerIsMarkdown("python")).toBe(false);
-  });
-
-  // Test edge cases
-  it("should handle edge cases correctly", () => {
-    expect(headerIsMarkdown("")).toBe(false);
-    expect(headerIsMarkdown("mdx")).toBe(false); // Similar but not exactly "md"
-    expect(headerIsMarkdown("readme md")).toBe(true);
-    expect(headerIsMarkdown("md.js")).toBe(false); // "md" is not the extension
-  });
-
-  // Test case sensitivity
-  it("should respect case sensitivity", () => {
-    expect(headerIsMarkdown("MD")).toBe(false);
-    expect(headerIsMarkdown("MARKDOWN")).toBe(false);
-    expect(headerIsMarkdown("example.MD")).toBe(false);
-    expect(headerIsMarkdown("lang MD")).toBe(false);
-  });
-
-  // Test with special characters and spacing
-  it("should handle special characters and spacing correctly", () => {
-    expect(headerIsMarkdown("  md")).toBe(true); // Space before "md"
-    expect(headerIsMarkdown("md  ")).toBe(true); // Space after "md"
-    expect(headerIsMarkdown("hello-md")).toBe(false); // "md" with hyphen prefix
-    expect(headerIsMarkdown("markdown:")).toBe(false); // "markdown" with suffix
-  });
-});
diff --git a/gui/src/components/StyledMarkdownPreview/utils/headerIsMarkdown.ts b/gui/src/components/StyledMarkdownPreview/utils/headerIsMarkdown.ts
deleted file mode 100644
index cfdba2fde45..00000000000
--- a/gui/src/components/StyledMarkdownPreview/utils/headerIsMarkdown.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-/**
- * Determines if a given header string represents Markdown content.
- *
- * The function checks various patterns to identify Markdown headers:
- * - Exact match with common Markdown identifiers (md, markdown, gfm, github-markdown)
- * - Contains these identifiers preceded by a space
- * - First word has a file extension of md, markdown, or gfm
- *
- * @param header - The string to check for Markdown indicators
- * @returns True if the header represents Markdown content, false otherwise
- */
-export function headerIsMarkdown(header: string): boolean {
-  return (
-    header === "md" ||
-    header === "markdown" ||
-    header === "gfm" ||
-    header === "github-markdown" ||
-    header.includes(" md") ||
-    header.includes(" markdown") ||
-    header.includes(" gfm") ||
-    header.includes(" github-markdown") ||
-    header.split(" ")[0]?.split(".").pop() === "md" ||
-    header.split(" ")[0]?.split(".").pop() === "markdown" ||
-    header.split(" ")[0]?.split(".").pop() === "gfm"
-  );
-}
diff --git a/gui/src/components/StyledMarkdownPreview/utils/patchNestedMarkdown.test.ts b/gui/src/components/StyledMarkdownPreview/utils/patchNestedMarkdown.test.ts
index af94f118dc6..4e347a9e224 100644
--- a/gui/src/components/StyledMarkdownPreview/utils/patchNestedMarkdown.test.ts
+++ b/gui/src/components/StyledMarkdownPreview/utils/patchNestedMarkdown.test.ts
@@ -6,6 +6,14 @@ describe("patchNestedMarkdown", () => {
     expect(patchNestedMarkdown(source)).toBe(source);
   });
 
+  it("should handle nested blocks without a type", () => {
+    const source =
+      "```markdown README.md\n# Project Structure\n\n```\n.\n├── AdvancedPage.tsx\n├── Calculator.java\n├── Dockerfile\n├── calculator_test/\n│   ├── Calculator.java\n│   └── Main.java\n├── data.json\n├── example.ipynb\n├── logs/\n├── nested-folder/\n│   ├── helloNested.py\n│   ├── package.json\n│   └── rules.md\n├── program.cs\n├── query.sql\n├── react-calculator/\n├── readme.md\n├── requirements.txt\n├── test.css\n├── test.html\n├── test.js\n├── test.kt\n├── test.php\n├── test.py\n├── test.rb\n├── test.rs\n├── test.sh\n└── test.ts\n```\n```";
+    const expected =
+      "~~~markdown README.md\n# Project Structure\n\n```\n.\n├── AdvancedPage.tsx\n├── Calculator.java\n├── Dockerfile\n├── calculator_test/\n│   ├── Calculator.java\n│   └── Main.java\n├── data.json\n├── example.ipynb\n├── logs/\n├── nested-folder/\n│   ├── helloNested.py\n│   ├── package.json\n│   └── rules.md\n├── program.cs\n├── query.sql\n├── react-calculator/\n├── readme.md\n├── requirements.txt\n├── test.css\n├── test.html\n├── test.js\n├── test.kt\n├── test.php\n├── test.py\n├── test.rb\n├── test.rs\n├── test.sh\n└── test.ts\n```\n~~~";
+    expect(patchNestedMarkdown(source)).toBe(expected);
+  });
+
   it("should replace backticks with tildes for markdown codeblocks", () => {
     const source = "```markdown\n# Header\nSome text\n```";
     const expected = "~~~markdown\n# Header\nSome text\n~~~";
diff --git a/gui/src/components/StyledMarkdownPreview/utils/patchNestedMarkdown.ts b/gui/src/components/StyledMarkdownPreview/utils/patchNestedMarkdown.ts
index 9be5bfbb225..380c1a18a7c 100644
--- a/gui/src/components/StyledMarkdownPreview/utils/patchNestedMarkdown.ts
+++ b/gui/src/components/StyledMarkdownPreview/utils/patchNestedMarkdown.ts
@@ -7,7 +7,10 @@
 
     Note, this was benchmarked at sub-millisecond
 */
-import { headerIsMarkdown } from "./headerIsMarkdown";
+import {
+  headerIsMarkdown,
+  MarkdownBlockStateTracker,
+} from "../../../../../core/utils/markdownUtils";
 
 export const patchNestedMarkdown = (source: string): string => {
   // Early return if no markdown codeblock pattern is found (including GitHub variants)
@@ -16,21 +19,29 @@ export const patchNestedMarkdown = (source: string): string => {
 
   let nestCount = 0;
   const lines = source.split("\n");
-  const trimmedLines = lines.map((l) => l.trim());
+
+  // Use optimized state tracker for efficient bare backtick analysis
+  const stateTracker = new MarkdownBlockStateTracker(lines);
+  const trimmedLines = stateTracker.getTrimmedLines();
 
   for (let i = 0; i < trimmedLines.length; i++) {
     const line = trimmedLines[i];
 
     if (nestCount > 0) {
       // Inside a markdown block
-      if (line.match(/^`+$/)) {
-        // Ending a block with just backticks (```)
-        nestCount--;
-        if (nestCount === 0) {
-          lines[i] = "~~~"; // End of markdown block
+      if (stateTracker.isBareBacktickLine(i)) {
+        // Found bare backticks - use optimized lookup for remaining count
+        const remainingBareBackticks =
+          stateTracker.getRemainingBareBackticksAfter(i);
+
+        // If this is the last bare backticks, it closes the markdown block
+        if (remainingBareBackticks === 0) {
+          nestCount = 0;
+          lines[i] = "~~~"; // Convert final closing delimiter to tildes
         }
+        // Otherwise, keep as backticks (inner nested block delimiter)
       } else if (line.startsWith("```")) {
-        // Going into a nested codeblock
+        // Going into a nested codeblock (with language identifier)
         nestCount++;
       }
     } else {
diff --git a/gui/src/components/console/Message.tsx b/gui/src/components/console/Message.tsx
index 8c5c35bc625..b15ca3e4aaf 100644
--- a/gui/src/components/console/Message.tsx
+++ b/gui/src/components/console/Message.tsx
@@ -48,7 +48,9 @@ export function renderMessage(message: ChatMessage, includeRole: boolean) {
           {includeRole ? renderMessageRole(message.role) : ""}
           {message.toolCalls
             ? message.toolCalls.map((toolCall) => (
-                <pre>Tool call: {JSON.stringify(toolCall, undefined, 2)}</pre>
+                <pre key={toolCall.id}>
+                  Tool call: {JSON.stringify(toolCall, undefined, 2)}
+                </pre>
               ))
             : ""}
           {renderMessageContent(message)}
diff --git a/gui/src/components/mainInput/ContextStatus.tsx b/gui/src/components/mainInput/ContextStatus.tsx
index a52327dc73c..7a97c276848 100644
--- a/gui/src/components/mainInput/ContextStatus.tsx
+++ b/gui/src/components/mainInput/ContextStatus.tsx
@@ -17,11 +17,7 @@ const ContextStatus = () => {
     return null;
   }
 
-  const barColorClass = isPruned
-    ? "bg-error"
-    : percent > 80
-      ? "bg-warning"
-      : "bg-description";
+  const barColorClass = isPruned ? "bg-error" : "bg-description";
 
   return (
     <div>
@@ -35,28 +31,27 @@ const ContextStatus = () => {
         }}
         clickable
       >
-        <div className="flex flex-col gap-0 text-xs">
+        <div className="flex flex-col gap-0 text-left text-xs">
           <span className="inline-block">
-            {`${percent}% of context filled`}
+            {`${percent}% of context filled.`}
           </span>
           {isPruned && (
             <span className="inline-block">
-              {`Oldest messages are being removed`}
+              {`Oldest messages are being removed.`}
             </span>
           )}
           {history.length > 0 && (
             <div className="flex flex-col gap-1 whitespace-pre">
               <div>
                 <span
-                  className="inline-block cursor-pointer underline"
+                  className="hover:text-link inline-block cursor-pointer underline"
                   onClick={() => compactConversation(history.length - 1)}
                 >
                   Compact conversation
                 </span>
                 {"\n"}
-                <span className="inline-block">or</span> {"\n"}
                 <span
-                  className="inline-block cursor-pointer underline"
+                  className="hover:text-link inline-block cursor-pointer underline"
                   onClick={() => {
                     dispatch(
                       saveCurrentSession({
diff --git a/gui/src/components/mainInput/Lump/EditBlockButton.tsx b/gui/src/components/mainInput/Lump/EditBlockButton.tsx
index 6cdcac4b018..5705deba278 100644
--- a/gui/src/components/mainInput/Lump/EditBlockButton.tsx
+++ b/gui/src/components/mainInput/Lump/EditBlockButton.tsx
@@ -13,6 +13,7 @@ interface EditBlockButtonProps<T extends SectionKey> {
   blockType: T;
   block?: NonNullable<ConfigYaml[T]>[number];
   className?: string;
+  sourceFile?: string;
 }
 
 function isUsesBlock(block: any): block is { uses: string } {
@@ -23,6 +24,7 @@ export default function EditBlockButton<T extends SectionKey>({
   block,
   blockType,
   className = "",
+  sourceFile,
 }: EditBlockButtonProps<T>) {
   const ideMessenger = useContext(IdeMessengerContext);
   const { selectedProfile } = useAuth();
@@ -37,6 +39,7 @@ export default function EditBlockButton<T extends SectionKey>({
     if (selectedProfile?.profileType === "local") {
       ideMessenger.post("config/openProfile", {
         profileId: undefined,
+        element: { sourceFile },
       });
     } else if (block && isUsesBlock(block)) {
       openUrl(`${block.uses}/new-version`);
diff --git a/gui/src/components/mainInput/Lump/LumpToolbar/GeneratingIndicator.tsx b/gui/src/components/mainInput/Lump/LumpToolbar/GeneratingIndicator.tsx
index e6d38d85a73..0f95a4e4050 100644
--- a/gui/src/components/mainInput/Lump/LumpToolbar/GeneratingIndicator.tsx
+++ b/gui/src/components/mainInput/Lump/LumpToolbar/GeneratingIndicator.tsx
@@ -8,8 +8,8 @@ export function GeneratingIndicator({
   testId?: string;
 }) {
   return (
-    <div className="flex items-center" data-testid={testId}>
-      <span className="text-description text-xs">{text}</span>
+    <div className="text-description flex items-center" data-testid={testId}>
+      <span className="text-xs">{text}</span>
       <AnimatedEllipsis />
     </div>
   );
diff --git a/gui/src/components/mainInput/Lump/sections/PromptsSection.tsx b/gui/src/components/mainInput/Lump/sections/PromptsSection.tsx
index c277d7d926a..10fb767b330 100644
--- a/gui/src/components/mainInput/Lump/sections/PromptsSection.tsx
+++ b/gui/src/components/mainInput/Lump/sections/PromptsSection.tsx
@@ -121,6 +121,7 @@ export function PromptsSection() {
     } else {
       ideMessenger.post("config/openProfile", {
         profileId: undefined,
+        element: { sourceFile: (prompt as any).sourceFile },
       });
     }
   };
@@ -149,7 +150,6 @@ export function PromptsSection() {
         index = index + 1;
       }
     }
-
     return promptsWithSlug.sort((a, b) => {
       const aBookmarked = isCommandBookmarked(a.name);
       const bBookmarked = isCommandBookmarked(b.name);
diff --git a/gui/src/components/mainInput/Lump/sections/RulesSection.tsx b/gui/src/components/mainInput/Lump/sections/RulesSection.tsx
index 5f145a169d4..f632cb10a6d 100644
--- a/gui/src/components/mainInput/Lump/sections/RulesSection.tsx
+++ b/gui/src/components/mainInput/Lump/sections/RulesSection.tsx
@@ -60,6 +60,7 @@ const RuleCard: React.FC<RuleCardProps> = ({ rule }) => {
     } else {
       ideMessenger.post("config/openProfile", {
         profileId: undefined,
+        element: { sourceFile: (rule as any).sourceFile },
       });
     }
   };
diff --git a/gui/src/components/mainInput/Lump/sections/docs/DocsIndexingStatus.tsx b/gui/src/components/mainInput/Lump/sections/docs/DocsIndexingStatus.tsx
index 9189a794c31..4b946a1fd30 100644
--- a/gui/src/components/mainInput/Lump/sections/docs/DocsIndexingStatus.tsx
+++ b/gui/src/components/mainInput/Lump/sections/docs/DocsIndexingStatus.tsx
@@ -123,7 +123,11 @@ function DocsIndexingStatus({
               />
             )}
 
-            <EditBlockButton blockType="docs" block={docFromYaml} />
+            <EditBlockButton
+              blockType="docs"
+              block={docFromYaml}
+              sourceFile={docConfig.sourceFile}
+            />
 
             {["aborted", "complete", "failed"].includes(
               status?.status ?? "",
diff --git a/gui/src/components/mainInput/Lump/sections/mcp/MCPSection.tsx b/gui/src/components/mainInput/Lump/sections/mcp/MCPSection.tsx
index 75c0f0725c5..76fb338e9da 100644
--- a/gui/src/components/mainInput/Lump/sections/mcp/MCPSection.tsx
+++ b/gui/src/components/mainInput/Lump/sections/mcp/MCPSection.tsx
@@ -132,7 +132,11 @@ function MCPServerPreview({ server, serverFromYaml }: MCPServerStatusProps) {
 
       {/* Refresh button */}
       <div className="flex items-center gap-2">
-        <EditBlockButton blockType={"mcpServers"} block={serverFromYaml} />
+        <EditBlockButton
+          blockType={"mcpServers"}
+          block={serverFromYaml}
+          sourceFile={server.sourceFile}
+        />
         <div
           className="text-lightgray flex cursor-pointer items-center hover:opacity-80"
           onClick={onRefresh}
diff --git a/gui/src/components/mainInput/Lump/sections/tool-policies/ToolPolicyItem.tsx b/gui/src/components/mainInput/Lump/sections/tool-policies/ToolPolicyItem.tsx
index ad4d289c9ca..28b8d048e7d 100644
--- a/gui/src/components/mainInput/Lump/sections/tool-policies/ToolPolicyItem.tsx
+++ b/gui/src/components/mainInput/Lump/sections/tool-policies/ToolPolicyItem.tsx
@@ -161,8 +161,8 @@ function ToolPolicyItem(props: ToolDropdownItemProps) {
         {parameters ? (
           <>
             <span className="text-xs font-bold">Arguments:</span>
-            {parameters.map((param) => (
-              <div className="block">
+            {parameters.map((param, idx) => (
+              <div key={idx} className="block">
                 <code className="">{param[0]}</code>
                 <span className="ml-1">{`(${param[1].type}):`}</span>
                 <span className="ml-1 italic">{param[1].description}</span>
diff --git a/gui/src/components/modelSelection/ModelSelect.tsx b/gui/src/components/modelSelection/ModelSelect.tsx
index 98a5c7d4f76..3db6bd1b9ce 100644
--- a/gui/src/components/modelSelection/ModelSelect.tsx
+++ b/gui/src/components/modelSelection/ModelSelect.tsx
@@ -10,7 +10,6 @@ import { useAuth } from "../../context/Auth";
 import { IdeMessengerContext } from "../../context/IdeMessenger";
 import { AddModelForm } from "../../forms/AddModelForm";
 import { useAppDispatch, useAppSelector } from "../../redux/hooks";
-import { EMPTY_CONFIG } from "../../redux/slices/configSlice";
 import { setDialogMessage, setShowDialog } from "../../redux/slices/uiSlice";
 import { updateSelectedModelByRole } from "../../redux/thunks/updateSelectedModelByRole";
 import {
@@ -36,6 +35,7 @@ interface Option {
   value: string;
   title: string;
   apiKey?: string;
+  sourceFile?: string;
 }
 
 function modelSelectTitle(model: any): string {
@@ -55,8 +55,6 @@ function ModelOption({
   showMissingApiKeyMsg,
   isSelected,
 }: ModelOptionProps) {
-  const ideMessenger = useContext(IdeMessengerContext);
-
   function handleOptionClick(e: any) {
     if (showMissingApiKeyMsg) {
       e.preventDefault();
@@ -94,6 +92,7 @@ function ModelSelect() {
 
   const isInEdit = useAppSelector((store) => store.session.isInEdit);
   const config = useAppSelector((state) => state.config.config);
+  const isConfigLoading = useAppSelector((state) => state.config.loading);
   const ideMessenger = useContext(IdeMessengerContext);
   const buttonRef = useRef<HTMLButtonElement>(null);
   const [options, setOptions] = useState<Option[]>([]);
@@ -131,6 +130,7 @@ function ModelSelect() {
           value: model.title,
           title: modelSelectTitle(model),
           apiKey: model.apiKey,
+          sourceFile: model.sourceFile,
         };
       }),
     );
@@ -191,7 +191,6 @@ function ModelSelect() {
     );
   }
 
-  const isConfigLoading = config === EMPTY_CONFIG;
   const hasNoModels = allModels?.length === 0;
 
   return (
@@ -229,6 +228,7 @@ function ModelSelect() {
               onClick={() =>
                 ideMessenger.post("config/openProfile", {
                   profileId: undefined,
+                  element: { sourceFile: selectedModel?.sourceFile },
                 })
               }
             />
diff --git a/gui/src/pages/config/ContinueFeaturesMenu.tsx b/gui/src/pages/config/ContinueFeaturesMenu.tsx
index 3f08499ddae..5d8d05687d4 100644
--- a/gui/src/pages/config/ContinueFeaturesMenu.tsx
+++ b/gui/src/pages/config/ContinueFeaturesMenu.tsx
@@ -2,11 +2,15 @@ import ToggleSwitch from "../../components/gui/Switch";
 interface ContinueFeaturesMenuProps {
   optInNextEditFeature: boolean;
   handleOptInNextEditToggle: (value: boolean) => void;
+  enableStaticContextualization: boolean;
+  handleEnableStaticContextualizationToggle: (value: boolean) => void;
 }
 
 export function ContinueFeaturesMenu({
   optInNextEditFeature,
   handleOptInNextEditToggle,
+  enableStaticContextualization,
+  handleEnableStaticContextualizationToggle,
 }: ContinueFeaturesMenuProps) {
   return (
     <div className="flex w-full flex-col gap-y-4">
@@ -19,6 +23,16 @@ export function ContinueFeaturesMenu({
           onToggle={() => handleOptInNextEditToggle(!optInNextEditFeature)}
           text="Enable Next Edit Over Autocomplete"
         />
+
+        <ToggleSwitch
+          isToggled={enableStaticContextualization}
+          onToggle={() =>
+            handleEnableStaticContextualizationToggle(
+              !enableStaticContextualization,
+            )
+          }
+          text="Use Static Contextualization"
+        />
       </div>
     </div>
   );
diff --git a/gui/src/pages/config/ModelRoleSelector.tsx b/gui/src/pages/config/ModelRoleSelector.tsx
index 1b73751b91e..5bdac5b4a92 100644
--- a/gui/src/pages/config/ModelRoleSelector.tsx
+++ b/gui/src/pages/config/ModelRoleSelector.tsx
@@ -48,10 +48,13 @@ const ModelRoleSelector = ({
     onSelect(models.find((m) => m.title === title) ?? null);
   }
 
-  function onClickGear(e: MouseEvent<SVGSVGElement>) {
+  function onClickGear(e: MouseEvent<SVGSVGElement>, model: ModelDescription) {
     e.stopPropagation();
     e.preventDefault();
-    ideMessenger.post("config/openProfile", { profileId: undefined });
+    ideMessenger.post("config/openProfile", {
+      profileId: undefined,
+      element: model,
+    });
   }
 
   function handleOptionClick(
@@ -169,7 +172,9 @@ const ModelRoleSelector = ({
                                 {hoveredIdx === idx && (
                                   <Cog6ToothIcon
                                     className="h-3 w-3 flex-shrink-0"
-                                    onClick={onClickGear}
+                                    onClick={(e: MouseEvent<SVGSVGElement>) =>
+                                      onClickGear(e, option)
+                                    }
                                   />
                                 )}
                                 {option.title === selectedModel?.title && (
diff --git a/gui/src/pages/config/UserSettingsForm.tsx b/gui/src/pages/config/UserSettingsForm.tsx
index 9eea8003b01..d507ef133ce 100644
--- a/gui/src/pages/config/UserSettingsForm.tsx
+++ b/gui/src/pages/config/UserSettingsForm.tsx
@@ -71,6 +71,10 @@ export function UserSettingsForm() {
     handleUpdate({ optInNextEditFeature: value });
   };
 
+  const handleEnableStaticContextualizationToggle = (value: boolean) => {
+    handleUpdate({ enableStaticContextualization: value });
+  };
+
   useEffect(() => {
     // Necessary so that reformatted/trimmed values don't cause dirty state
     setFormPromptPath(promptPath);
@@ -92,6 +96,8 @@ export function UserSettingsForm() {
     config.experimental?.optInNextEditFeature ?? false;
   const codebaseToolCallingOnly =
     config.experimental?.codebaseToolCallingOnly ?? false;
+  const enableStaticContextualization =
+    config.experimental?.enableStaticContextualization ?? false;
 
   const allowAnonymousTelemetry = config.allowAnonymousTelemetry ?? true;
   const disableIndexing = config.disableIndexing ?? false;
@@ -433,6 +439,12 @@ export function UserSettingsForm() {
                   <ContinueFeaturesMenu
                     optInNextEditFeature={optInNextEditFeature}
                     handleOptInNextEditToggle={handleOptInNextEditToggle}
+                    enableStaticContextualization={
+                      enableStaticContextualization
+                    }
+                    handleEnableStaticContextualizationToggle={
+                      handleEnableStaticContextualizationToggle
+                    }
                   />
                 )}
               </div>
diff --git a/gui/src/pages/gui/StreamError.tsx b/gui/src/pages/gui/StreamError.tsx
index f642a6ee828..8245d7f5678 100644
--- a/gui/src/pages/gui/StreamError.tsx
+++ b/gui/src/pages/gui/StreamError.tsx
@@ -76,6 +76,7 @@ const StreamErrorDialog = ({ error }: StreamErrorProps) => {
       onClick={() => {
         ideMessenger.post("config/openProfile", {
           profileId: undefined,
+          element: selectedModel ?? undefined,
         });
       }}
     >
diff --git a/gui/src/pages/gui/ToolCallDiv/FunctionSpecificToolCallDiv.tsx b/gui/src/pages/gui/ToolCallDiv/FunctionSpecificToolCallDiv.tsx
index 378483d71f2..251a32e4e0a 100644
--- a/gui/src/pages/gui/ToolCallDiv/FunctionSpecificToolCallDiv.tsx
+++ b/gui/src/pages/gui/ToolCallDiv/FunctionSpecificToolCallDiv.tsx
@@ -18,25 +18,30 @@ function FunctionSpecificToolCallDiv({
     case BuiltInToolNames.CreateNewFile:
       return (
         <CreateFile
-          relativeFilepath={args.filepath}
-          fileContents={args.contents}
+          relativeFilepath={args?.filepath ?? ""}
+          fileContents={args?.contents ?? ""}
           historyIndex={historyIndex}
         />
       );
     case BuiltInToolNames.EditExistingFile:
       return (
         <EditFile
-          relativeFilePath={args.filepath ?? ""}
-          changes={args.changes ?? ""}
+          relativeFilePath={args?.filepath ?? ""}
+          changes={args?.changes ?? ""}
           toolCallId={toolCall.id}
           historyIndex={historyIndex}
         />
       );
     case BuiltInToolNames.SearchAndReplaceInFile:
+      const changes = args.diffs
+        ? Array.isArray(args.diffs)
+          ? args.diffs.join("\n\n---\n\n")
+          : args.diffs
+        : "";
       return (
         <EditFile
-          relativeFilePath={args.filepath ?? ""}
-          changes={args.diffs ? args.diffs.join("\n\n---\n\n") : ""}
+          relativeFilePath={args?.filepath ?? ""}
+          changes={changes}
           toolCallId={toolCall.id}
           historyIndex={historyIndex}
         />
@@ -44,7 +49,7 @@ function FunctionSpecificToolCallDiv({
     case BuiltInToolNames.RunTerminalCommand:
       return (
         <RunTerminalCommand
-          command={args.command}
+          command={args?.command ?? ""}
           toolCallState={toolCallState}
           toolCallId={toolCall.id}
         />
diff --git a/gui/src/pages/gui/ToolCallDiv/IndicatorBar.tsx b/gui/src/pages/gui/ToolCallDiv/IndicatorBar.tsx
new file mode 100644
index 00000000000..ce56dfd0cbc
--- /dev/null
+++ b/gui/src/pages/gui/ToolCallDiv/IndicatorBar.tsx
@@ -0,0 +1,19 @@
+import { ChevronDownIcon } from "@heroicons/react/24/outline";
+
+interface IndicatorBarProps {
+  text: string;
+  isExpanded: boolean;
+}
+
+export function IndicatorBar({ text, isExpanded }: IndicatorBarProps) {
+  return (
+    <div className="absolute left-0 right-0 top-0 z-10 flex h-8 items-start justify-center pt-1">
+      <div className="border-border bg-editor text-description flex items-center gap-2 rounded border px-2 py-1 text-[11px] shadow-sm">
+        <span>{text}</span>
+        <ChevronDownIcon
+          className={`text-description h-3 w-3 ${isExpanded ? "" : "rotate-180"}`}
+        />
+      </div>
+    </div>
+  );
+}
diff --git a/gui/src/pages/gui/ToolCallDiv/RunTerminalCommand.tsx b/gui/src/pages/gui/ToolCallDiv/RunTerminalCommand.tsx
index 0b3bf1b9df8..566643ec74a 100644
--- a/gui/src/pages/gui/ToolCallDiv/RunTerminalCommand.tsx
+++ b/gui/src/pages/gui/ToolCallDiv/RunTerminalCommand.tsx
@@ -1,10 +1,10 @@
 import { ToolCallState } from "core";
-import styled from "styled-components";
-import { vscForeground } from "../../../components";
+import { useMemo } from "react";
 import Ansi from "../../../components/ansiTerminal/Ansi";
 import StyledMarkdownPreview from "../../../components/StyledMarkdownPreview";
 import { useAppDispatch } from "../../../redux/hooks";
 import { moveTerminalProcessToBackground } from "../../../redux/thunks/moveTerminalProcessToBackground";
+import { TerminalCollapsibleContainer } from "./TerminalCollapsibleContainer";
 
 interface RunTerminalCommandToolCallProps {
   command: string;
@@ -12,64 +12,34 @@ interface RunTerminalCommandToolCallProps {
   toolCallId: string | undefined;
 }
 
-const CommandStatus = styled.div`
-  font-size: 12px;
-  color: var(--vscode-descriptionForeground, ${vscForeground}88);
-  margin-top: 8px;
-  display: flex;
-  align-items: center;
-  padding-left: 8px;
-  padding-right: 8px;
-`;
-
-const StatusIcon = styled.span<{
+interface StatusIconProps {
   status: "running" | "completed" | "failed" | "background";
-}>`
-  width: 8px;
-  height: 8px;
-  border-radius: 50%;
-  margin-right: 8px;
-  background-color: ${(props) =>
-    props.status === "running"
-      ? "var(--vscode-testing-runAction, #4caf50)"
-      : props.status === "completed"
-        ? "var(--vscode-testing-iconPassed, #4caf50)"
-        : props.status === "background"
-          ? "var(--vscode-statusBarItem-prominentBackground, #2196f3)"
-          : "var(--vscode-testing-iconFailed, #f44336)"};
-  ${(props) =>
-    props.status === "running" ? "animation: pulse 1.5s infinite;" : ""}
-`;
-
-// Waiting message styled for consistency
-const WaitingMessage = styled.div`
-  padding: 8px;
-  padding-left: 16px;
-  padding-right: 16px;
-  margin-top: 8px;
-`;
-
-// For consistency with the rest of the styled components
-const AnsiWrapper = styled.div`
-  margin-top: 8px;
-`;
-
-const BackgroundLink = styled.a`
-  font-size: 12px;
-  color: var(--vscode-textLink-foreground, #3794ff);
-  margin-left: 12px;
-  cursor: pointer;
-  text-decoration: none;
-
-  &:hover {
-    text-decoration: underline;
-  }
-`;
+}
+
+function StatusIcon({ status }: StatusIconProps) {
+  const getStatusColor = () => {
+    switch (status) {
+      case "running":
+        return "bg-success";
+      case "completed":
+        return "bg-success";
+      case "background":
+        return "bg-accent";
+      case "failed":
+        return "bg-error";
+      default:
+        return "bg-success";
+    }
+  };
 
-// Just spacing between terminal components and the next toolcall
-const TerminalContainer = styled.div`
-  margin-bottom: 16px;
-`;
+  return (
+    <span
+      className={`mr-2 h-2 w-2 rounded-full ${getStatusColor()} ${
+        status === "running" ? "animate-pulse" : ""
+      }`}
+    />
+  );
+}
 
 export function RunTerminalCommand(props: RunTerminalCommandToolCallProps) {
   const dispatch = useAppDispatch();
@@ -84,6 +54,42 @@ export function RunTerminalCommand(props: RunTerminalCommandToolCallProps) {
   const isRunning = props.toolCallState.status === "calling";
   const hasOutput = terminalContent.length > 0;
 
+  const displayLines = 15;
+
+  // Process terminal content for line limiting
+  const processedTerminalContent = useMemo(() => {
+    if (!terminalContent)
+      return {
+        fullContent: "",
+        limitedContent: "",
+        totalLines: 0,
+        isLimited: false,
+        hiddenLinesCount: 0,
+      };
+
+    const lines = terminalContent.split("\n");
+    const totalLines = lines.length;
+
+    if (totalLines > displayLines) {
+      const lastTwentyLines = lines.slice(-displayLines);
+      return {
+        fullContent: terminalContent,
+        limitedContent: lastTwentyLines.join("\n"),
+        totalLines,
+        isLimited: true,
+        hiddenLinesCount: totalLines - displayLines,
+      };
+    }
+
+    return {
+      fullContent: terminalContent,
+      limitedContent: terminalContent,
+      totalLines,
+      isLimited: false,
+      hiddenLinesCount: 0,
+    };
+  }, [terminalContent]);
+
   // Determine status type
   let statusType: "running" | "completed" | "failed" | "background" =
     "completed";
@@ -96,7 +102,7 @@ export function RunTerminalCommand(props: RunTerminalCommandToolCallProps) {
   }
 
   return (
-    <TerminalContainer>
+    <div className="mb-4">
       {/* Command */}
       <StyledMarkdownPreview
         isRenderingInStepContainer
@@ -105,21 +111,33 @@ export function RunTerminalCommand(props: RunTerminalCommandToolCallProps) {
 
       {/* Terminal output with ANSI support */}
       {isRunning && !hasOutput && (
-        <WaitingMessage>Waiting for output...</WaitingMessage>
+        <div className="mt-2 px-4 py-2">Waiting for output...</div>
       )}
       {hasOutput && (
-        <AnsiWrapper>
-          <Ansi>{terminalContent}</Ansi>
-        </AnsiWrapper>
+        <TerminalCollapsibleContainer
+          collapsible={processedTerminalContent.isLimited}
+          hiddenLinesCount={processedTerminalContent.hiddenLinesCount}
+          className="mt-2"
+          collapsedContent={
+            <div className="mt-2">
+              <Ansi>{processedTerminalContent.limitedContent}</Ansi>
+            </div>
+          }
+          expandedContent={
+            <div className="mt-2">
+              <Ansi>{processedTerminalContent.fullContent}</Ansi>
+            </div>
+          }
+        />
       )}
 
       {/* Status information */}
       {(statusMessage || isRunning) && (
-        <CommandStatus>
+        <div className="text-description mt-2 flex items-center px-2 text-xs">
           <StatusIcon status={statusType} />
           {isRunning ? "Running" : statusMessage}
           {isRunning && props.toolCallId && (
-            <BackgroundLink
+            <span
               onClick={() => {
                 // Dispatch the action to move the command to the background
                 dispatch(
@@ -128,12 +146,13 @@ export function RunTerminalCommand(props: RunTerminalCommandToolCallProps) {
                   }),
                 );
               }}
+              className="text-link ml-3 cursor-pointer text-xs no-underline hover:underline"
             >
               Move to background
-            </BackgroundLink>
+            </span>
           )}
-        </CommandStatus>
+        </div>
       )}
-    </TerminalContainer>
+    </div>
   );
 }
diff --git a/gui/src/pages/gui/ToolCallDiv/TerminalCollapsibleContainer.tsx b/gui/src/pages/gui/ToolCallDiv/TerminalCollapsibleContainer.tsx
new file mode 100644
index 00000000000..1f3ef7cea53
--- /dev/null
+++ b/gui/src/pages/gui/ToolCallDiv/TerminalCollapsibleContainer.tsx
@@ -0,0 +1,61 @@
+import { useState } from "react";
+import { IndicatorBar } from "./IndicatorBar";
+
+interface TerminalCollapsibleContainerProps {
+  collapsedContent: React.ReactNode;
+  expandedContent: React.ReactNode;
+  className?: string;
+  collapsible?: boolean;
+  hiddenLinesCount?: number;
+}
+
+export function TerminalCollapsibleContainer({
+  collapsedContent,
+  expandedContent,
+  className = "",
+  collapsible = false,
+  hiddenLinesCount = 0,
+}: TerminalCollapsibleContainerProps) {
+  const [isExpanded, setIsExpanded] = useState(false);
+
+  if (!collapsible) {
+    return <div className={className}>{collapsedContent}</div>;
+  }
+
+  return (
+    <div className={`relative ${className}`}>
+      {/* Indicator bar - shows for both collapsed and expanded states */}
+      {((!isExpanded && hiddenLinesCount > 0) ||
+        (isExpanded && collapsible)) && (
+        <IndicatorBar
+          text={isExpanded ? "Collapse" : `+${hiddenLinesCount} more lines`}
+          isExpanded={isExpanded}
+        />
+      )}
+
+      {/* Clickable overlay covering the entire content area */}
+      {collapsible && (
+        <div
+          onClick={(e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            setIsExpanded(!isExpanded);
+          }}
+          className="absolute inset-0 z-20 cursor-pointer"
+        />
+      )}
+
+      {/* Content container with proper constraint for gradient */}
+      <div
+        className={`relative overflow-hidden rounded-lg ${collapsible ? "cursor-pointer" : ""}`}
+      >
+        {/* Gradient overlay on top of content - only when collapsed */}
+        {!isExpanded && hiddenLinesCount > 0 && (
+          <div className="from-editor pointer-events-none absolute left-[9px] right-[9px] top-4 z-[5] h-[100px] rounded-t-md bg-gradient-to-b to-transparent" />
+        )}
+
+        {isExpanded ? expandedContent : collapsedContent}
+      </div>
+    </div>
+  );
+}
diff --git a/gui/src/redux/slices/configSlice.ts b/gui/src/redux/slices/configSlice.ts
index 8766014a263..0deb9f6e4b0 100644
--- a/gui/src/redux/slices/configSlice.ts
+++ b/gui/src/redux/slices/configSlice.ts
@@ -68,6 +68,7 @@ export const configSlice = createSlice({
       } else {
         state.config = config;
       }
+      state.loading = false;
     },
     updateConfig: (
       state,
diff --git a/gui/src/redux/thunks/streamNormalInput.ts b/gui/src/redux/thunks/streamNormalInput.ts
index 6c722817bbd..6e95191c4d4 100644
--- a/gui/src/redux/thunks/streamNormalInput.ts
+++ b/gui/src/redux/thunks/streamNormalInput.ts
@@ -253,6 +253,7 @@ export const streamNormalInput = createAsyncThunk<
               rules: appliedRules.map((rule) => ({
                 id: getRuleId(rule),
                 rule: rule.rule,
+                slug: rule.slug,
               })),
             }),
           },
diff --git a/gui/src/util/clientTools/editImpl.ts b/gui/src/util/clientTools/editImpl.ts
index 6873e0512f3..a6f56e7c9f6 100644
--- a/gui/src/util/clientTools/editImpl.ts
+++ b/gui/src/util/clientTools/editImpl.ts
@@ -6,6 +6,11 @@ export const editToolImpl: ClientToolImpl = async (
   toolCallId,
   extras,
 ) => {
+  if (!args.filepath || !args.changes) {
+    throw new Error(
+      "`filepath` and `changes` arguments are required to edit an existing file.",
+    );
+  }
   const firstUriMatch = await resolveRelativePathInDir(
     args.filepath,
     extras.ideMessenger.ide,
diff --git a/packages/config-types/src/index.ts b/packages/config-types/src/index.ts
index 8591c6b746b..fbc2d45fc40 100644
--- a/packages/config-types/src/index.ts
+++ b/packages/config-types/src/index.ts
@@ -210,6 +210,7 @@ export const siteIndexingConfigSchema = z.object({
   maxDepth: z.number().optional(),
   faviconUrl: z.string().optional(),
   useLocalCrawling: z.boolean().optional(),
+  sourceFile: z.string().optional(),
 });
 
 export const controlPlaneConfigSchema = z.object({
diff --git a/packages/config-yaml/src/load/unroll.ts b/packages/config-yaml/src/load/unroll.ts
index 80403b5448a..adbe453244e 100644
--- a/packages/config-yaml/src/load/unroll.ts
+++ b/packages/config-yaml/src/load/unroll.ts
@@ -452,7 +452,15 @@ export async function unrollBlocks(
               registry,
             );
 
-            return { blockType, resolvedBlock, error: null };
+            return {
+              blockType,
+              resolvedBlock,
+              source:
+                injectBlock.uriType === "file"
+                  ? injectBlock.filePath
+                  : undefined,
+              error: null,
+            };
           } catch (err) {
             let msg = "";
             if (injectBlock.uriType === "file") {
@@ -475,7 +483,11 @@ export async function unrollBlocks(
 
         const injectedResults = await Promise.all(injectedBlockPromises);
         const injectedErrors: ConfigValidationError[] = [];
-        const injectedBlocks: { blockType: string; resolvedBlock: any }[] = [];
+        const injectedBlocks: {
+          blockType: string;
+          resolvedBlock: any;
+          source?: string;
+        }[] = [];
 
         for (const result of injectedResults) {
           if (result.error) {
@@ -484,6 +496,7 @@ export async function unrollBlocks(
             injectedBlocks.push({
               blockType: result.blockType,
               resolvedBlock: result.resolvedBlock,
+              source: result.source,
             });
           }
         }
@@ -521,12 +534,21 @@ export async function unrollBlocks(
   }
 
   // Add injected blocks
-  for (const { blockType, resolvedBlock } of injectedResult.injectedBlocks) {
+  for (const {
+    blockType,
+    resolvedBlock,
+    source,
+  } of injectedResult.injectedBlocks) {
     const key = blockType as BlockType;
     if (!unrolledAssistant[key]) {
       unrolledAssistant[key] = [];
     }
-    unrolledAssistant[key]?.push(...((resolvedBlock[blockType] ?? []) as any));
+    const blocksWithSourceFiles = injectLocalSourceFile(
+      key,
+      resolvedBlock,
+      source,
+    );
+    unrolledAssistant[key]?.push(...blocksWithSourceFiles);
   }
 
   const configResult: ConfigResult<AssistantUnrolled> = {
@@ -541,6 +563,39 @@ export async function unrollBlocks(
   return configResult;
 }
 
+function injectLocalSourceFile(
+  blockType: BlockType,
+  resolvedBlock: any,
+  source?: string,
+): (any & { source?: string })[] {
+  const blocks: any[] = resolvedBlock[blockType] ?? [];
+  if (source === undefined) {
+    // If no source is provided, return blocks as is
+    return blocks;
+  }
+  if (blockType === "rules") {
+    // For rules, we need to ensure they are wrapped in an object with a `source
+    return blocks.map((block) => {
+      if (typeof block === "string") {
+        const rule = {
+          sourceFile: source,
+          name: block,
+          rule: block,
+        } as Rule;
+        return rule;
+      } else if (typeof block === "object") {
+        block.sourceFile = source;
+      }
+      return block;
+    });
+  }
+  // For other block types, we can directly inject the source file
+  return blocks.map((block) => ({
+    ...block,
+    sourceFile: source,
+  }));
+}
+
 export async function resolveBlock(
   id: PackageIdentifier,
   inputs: Record<string, string> | undefined,
diff --git a/packages/config-yaml/src/markdown/markdownToRule.ts b/packages/config-yaml/src/markdown/markdownToRule.ts
index 231b2ab4a30..f584a0549e4 100644
--- a/packages/config-yaml/src/markdown/markdownToRule.ts
+++ b/packages/config-yaml/src/markdown/markdownToRule.ts
@@ -112,5 +112,6 @@ export function markdownToRule(
     regex: frontmatter.regex,
     description: frontmatter.description,
     alwaysApply: frontmatter.alwaysApply,
+    sourceFile: id.uriType === "file" ? id.filePath : undefined,
   };
 }
diff --git a/packages/config-yaml/src/schemas/data/autocomplete/index.ts b/packages/config-yaml/src/schemas/data/autocomplete/index.ts
index 458473c3be0..db2186e0f41 100644
--- a/packages/config-yaml/src/schemas/data/autocomplete/index.ts
+++ b/packages/config-yaml/src/schemas/data/autocomplete/index.ts
@@ -36,6 +36,9 @@ export const autocompleteEventAllSchema = baseDevDataAllSchema.extend({
   uniqueId: z.string(),
   timestamp: z.string(),
 
+  // For static contextualization.
+  enabledStaticContextualization: z.boolean().optional(),
+
   // DEPRECATED - no more nested objects after v0.1.0, all flat values
   completionOptions: completionOptionsSchema.optional(),
   disableInFiles: z.array(z.string()).optional(),
diff --git a/packages/config-yaml/src/schemas/data/autocomplete/v0.2.0.ts b/packages/config-yaml/src/schemas/data/autocomplete/v0.2.0.ts
index 5866b986529..123a05b7535 100644
--- a/packages/config-yaml/src/schemas/data/autocomplete/v0.2.0.ts
+++ b/packages/config-yaml/src/schemas/data/autocomplete/v0.2.0.ts
@@ -38,6 +38,9 @@ export const autocompleteEventSchema_0_2_0 = autocompleteEventAllSchema.pick({
   completionId: true,
   uniqueId: true,
 
+  // For static contextualization.
+  enabledStaticContextualization: true,
+
   // Note objects (completionOptions and disableInfiles) removed from 0.1.0 => 0.2.0
 });
 
diff --git a/packages/config-yaml/src/schemas/data/chatInteraction/index.ts b/packages/config-yaml/src/schemas/data/chatInteraction/index.ts
index f13b630af99..14bb36ba9ba 100644
--- a/packages/config-yaml/src/schemas/data/chatInteraction/index.ts
+++ b/packages/config-yaml/src/schemas/data/chatInteraction/index.ts
@@ -13,6 +13,7 @@ export const chatInteractionEventAllSchema = baseDevDataAllSchema.extend({
       z.object({
         id: z.string(),
         rule: z.string(),
+        slug: z.string().optional(),
       }),
     )
     .optional(),
diff --git a/packages/config-yaml/src/schemas/data/editOutcome/index.ts b/packages/config-yaml/src/schemas/data/editOutcome/index.ts
index ec902364c0a..32c34632cf7 100644
--- a/packages/config-yaml/src/schemas/data/editOutcome/index.ts
+++ b/packages/config-yaml/src/schemas/data/editOutcome/index.ts
@@ -12,4 +12,5 @@ export const editOutcomeEventAllSchema = baseDevDataAllSchema.extend({
   newCodeLines: z.number(),
   lineChange: z.number(),
   accepted: z.boolean(),
+  filepath: z.string(),
 });
diff --git a/packages/config-yaml/src/schemas/data/editOutcome/v0.2.0.ts b/packages/config-yaml/src/schemas/data/editOutcome/v0.2.0.ts
index 1fdbfb96746..acd3be4bd0f 100644
--- a/packages/config-yaml/src/schemas/data/editOutcome/v0.2.0.ts
+++ b/packages/config-yaml/src/schemas/data/editOutcome/v0.2.0.ts
@@ -20,6 +20,7 @@ export const editOutcomeEventSchema_0_2_0 = editOutcomeEventAllSchema.pick({
   previousCodeLines: true,
   newCodeLines: true,
   lineChange: true,
+  filepath: true,
 });
 
 export const editOutcomeEventSchema_0_2_0_noCode =
diff --git a/packages/config-yaml/src/schemas/index.ts b/packages/config-yaml/src/schemas/index.ts
index 4ac2aa1f54e..e15a5655d90 100644
--- a/packages/config-yaml/src/schemas/index.ts
+++ b/packages/config-yaml/src/schemas/index.ts
@@ -25,6 +25,7 @@ const mcpServerSchema = z.object({
   cwd: z.string().optional(),
   connectionTimeout: z.number().gt(0).optional(),
   requestOptions: requestOptionsSchema.optional(),
+  sourceFile: z.string().optional(),
 });
 
 export type MCPServer = z.infer<typeof mcpServerSchema>;
@@ -33,6 +34,7 @@ const promptSchema = z.object({
   name: z.string(),
   description: z.string().optional(),
   prompt: z.string(),
+  sourceFile: z.string().optional(),
 });
 
 export type Prompt = z.infer<typeof promptSchema>;
@@ -42,8 +44,8 @@ const docSchema = z.object({
   startUrl: z.string(),
   rootUrl: z.string().optional(),
   faviconUrl: z.string().optional(),
-  maxDepth: z.number().optional(),
   useLocalCrawling: z.boolean().optional(),
+  sourceFile: z.string().optional(),
 });
 
 export type DocsConfig = z.infer<typeof docSchema>;
@@ -55,6 +57,7 @@ const ruleObjectSchema = z.object({
   globs: z.union([z.string(), z.array(z.string())]).optional(),
   regex: z.union([z.string(), z.array(z.string())]).optional(),
   alwaysApply: z.boolean().optional(),
+  sourceFile: z.string().optional(), //TODO refactor RuleWithSource.ruleFile to align with sourceFile
 });
 const ruleSchema = z.union([z.string(), ruleObjectSchema]);
 
diff --git a/packages/config-yaml/src/schemas/models.ts b/packages/config-yaml/src/schemas/models.ts
index 8bdb6b66d82..283ec67812e 100644
--- a/packages/config-yaml/src/schemas/models.ts
+++ b/packages/config-yaml/src/schemas/models.ts
@@ -163,6 +163,7 @@ export const modelSchema = z.union([
   z.object({
     ...baseModelFields,
     provider: z.string().refine((val) => val !== "continue-proxy"),
+    sourceFile: z.string().optional(),
   }),
 ]);
 
diff --git a/packages/openai-adapters/package-lock.json b/packages/openai-adapters/package-lock.json
index 06d32e3726b..73354c249c6 100644
--- a/packages/openai-adapters/package-lock.json
+++ b/packages/openai-adapters/package-lock.json
@@ -15,6 +15,7 @@
         "@continuedev/config-yaml": "^1.0.51",
         "@continuedev/fetch": "^1.0.15",
         "dotenv": "^16.5.0",
+        "google-auth-library": "^10.1.0",
         "json-schema": "^0.4.0",
         "node-fetch": "^3.3.2",
         "openai": "^4.104.0",
@@ -35,7 +36,7 @@
         "semantic-release": "^24.2.7",
         "ts-jest": "^29.2.3",
         "ts-node": "^10.9.2",
-        "vitest": "^1.6.1"
+        "vitest": "^3.2.4"
       }
     },
     "node_modules/@ampproject/remapping": {
@@ -1386,9 +1387,9 @@
       }
     },
     "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.8.tgz",
+      "integrity": "sha512-urAvrUedIqEiFR3FYSLTWQgLu5tb+m0qZw0NBEasUeo6wuqatkMDaRT+1uABiGXEu5vqgPd7FGE1BhsAIy9QVA==",
       "cpu": [
         "ppc64"
       ],
@@ -1399,13 +1400,13 @@
         "aix"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/android-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
-      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.8.tgz",
+      "integrity": "sha512-RONsAvGCz5oWyePVnLdZY/HHwA++nxYWIX1atInlaW6SEkwq6XkP3+cb825EUcRs5Vss/lGh/2YxAb5xqc07Uw==",
       "cpu": [
         "arm"
       ],
@@ -1416,13 +1417,13 @@
         "android"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/android-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
-      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.8.tgz",
+      "integrity": "sha512-OD3p7LYzWpLhZEyATcTSJ67qB5D+20vbtr6vHlHWSQYhKtzUYrETuWThmzFpZtFsBIxRvhO07+UgVA9m0i/O1w==",
       "cpu": [
         "arm64"
       ],
@@ -1433,13 +1434,13 @@
         "android"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/android-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
-      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.8.tgz",
+      "integrity": "sha512-yJAVPklM5+4+9dTeKwHOaA+LQkmrKFX96BM0A/2zQrbS6ENCmxc4OVoBs5dPkCCak2roAD+jKCdnmOqKszPkjA==",
       "cpu": [
         "x64"
       ],
@@ -1450,13 +1451,13 @@
         "android"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
-      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.8.tgz",
+      "integrity": "sha512-Jw0mxgIaYX6R8ODrdkLLPwBqHTtYHJSmzzd+QeytSugzQ0Vg4c5rDky5VgkoowbZQahCbsv1rT1KW72MPIkevw==",
       "cpu": [
         "arm64"
       ],
@@ -1467,13 +1468,13 @@
         "darwin"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/darwin-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
-      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.8.tgz",
+      "integrity": "sha512-Vh2gLxxHnuoQ+GjPNvDSDRpoBCUzY4Pu0kBqMBDlK4fuWbKgGtmDIeEC081xi26PPjn+1tct+Bh8FjyLlw1Zlg==",
       "cpu": [
         "x64"
       ],
@@ -1484,13 +1485,13 @@
         "darwin"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
-      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.8.tgz",
+      "integrity": "sha512-YPJ7hDQ9DnNe5vxOm6jaie9QsTwcKedPvizTVlqWG9GBSq+BuyWEDazlGaDTC5NGU4QJd666V0yqCBL2oWKPfA==",
       "cpu": [
         "arm64"
       ],
@@ -1501,13 +1502,13 @@
         "freebsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
-      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.8.tgz",
+      "integrity": "sha512-MmaEXxQRdXNFsRN/KcIimLnSJrk2r5H8v+WVafRWz5xdSVmWLoITZQXcgehI2ZE6gioE6HirAEToM/RvFBeuhw==",
       "cpu": [
         "x64"
       ],
@@ -1518,13 +1519,13 @@
         "freebsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-arm": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
-      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.8.tgz",
+      "integrity": "sha512-FuzEP9BixzZohl1kLf76KEVOsxtIBFwCaLupVuk4eFVnOZfU+Wsn+x5Ryam7nILV2pkq2TqQM9EZPsOBuMC+kg==",
       "cpu": [
         "arm"
       ],
@@ -1535,13 +1536,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
-      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.8.tgz",
+      "integrity": "sha512-WIgg00ARWv/uYLU7lsuDK00d/hHSfES5BzdWAdAig1ioV5kaFNrtK8EqGcUBJhYqotlUByUKz5Qo6u8tt7iD/w==",
       "cpu": [
         "arm64"
       ],
@@ -1552,13 +1553,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
-      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.8.tgz",
+      "integrity": "sha512-A1D9YzRX1i+1AJZuFFUMP1E9fMaYY+GnSQil9Tlw05utlE86EKTUA7RjwHDkEitmLYiFsRd9HwKBPEftNdBfjg==",
       "cpu": [
         "ia32"
       ],
@@ -1569,13 +1570,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-loong64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
-      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.8.tgz",
+      "integrity": "sha512-O7k1J/dwHkY1RMVvglFHl1HzutGEFFZ3kNiDMSOyUrB7WcoHGf96Sh+64nTRT26l3GMbCW01Ekh/ThKM5iI7hQ==",
       "cpu": [
         "loong64"
       ],
@@ -1586,13 +1587,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
-      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.8.tgz",
+      "integrity": "sha512-uv+dqfRazte3BzfMp8PAQXmdGHQt2oC/y2ovwpTteqrMx2lwaksiFZ/bdkXJC19ttTvNXBuWH53zy/aTj1FgGw==",
       "cpu": [
         "mips64el"
       ],
@@ -1603,13 +1604,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
-      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.8.tgz",
+      "integrity": "sha512-GyG0KcMi1GBavP5JgAkkstMGyMholMDybAf8wF5A70CALlDM2p/f7YFE7H92eDeH/VBtFJA5MT4nRPDGg4JuzQ==",
       "cpu": [
         "ppc64"
       ],
@@ -1620,13 +1621,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
-      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.8.tgz",
+      "integrity": "sha512-rAqDYFv3yzMrq7GIcen3XP7TUEG/4LK86LUPMIz6RT8A6pRIDn0sDcvjudVZBiiTcZCY9y2SgYX2lgK3AF+1eg==",
       "cpu": [
         "riscv64"
       ],
@@ -1637,13 +1638,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-s390x": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
-      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.8.tgz",
+      "integrity": "sha512-Xutvh6VjlbcHpsIIbwY8GVRbwoviWT19tFhgdA7DlenLGC/mbc3lBoVb7jxj9Z+eyGqvcnSyIltYUrkKzWqSvg==",
       "cpu": [
         "s390x"
       ],
@@ -1654,13 +1655,13 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/linux-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
-      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.8.tgz",
+      "integrity": "sha512-ASFQhgY4ElXh3nDcOMTkQero4b1lgubskNlhIfJrsH5OKZXDpUAKBlNS0Kx81jwOBp+HCeZqmoJuihTv57/jvQ==",
       "cpu": [
         "x64"
       ],
@@ -1671,13 +1672,30 @@
         "linux"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.8.tgz",
+      "integrity": "sha512-d1KfruIeohqAi6SA+gENMuObDbEjn22olAR7egqnkCD9DGBG0wsEARotkLgXDu6c4ncgWTZJtN5vcgxzWRMzcw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.8.tgz",
+      "integrity": "sha512-nVDCkrvx2ua+XQNyfrujIG38+YGyuy2Ru9kKVNyh5jAys6n+l44tTtToqHjino2My8VAY6Lw9H7RI73XFi66Cg==",
       "cpu": [
         "x64"
       ],
@@ -1688,13 +1706,30 @@
         "netbsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.8.tgz",
+      "integrity": "sha512-j8HgrDuSJFAujkivSMSfPQSAa5Fxbvk4rgNAS5i3K+r8s1X0p1uOO2Hl2xNsGFppOeHOLAVgYwDVlmxhq5h+SQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
-      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.8.tgz",
+      "integrity": "sha512-1h8MUAwa0VhNCDp6Af0HToI2TJFAn1uqT9Al6DJVzdIBAd21m/G0Yfc77KDM3uF3T/YaOgQq3qTJHPbTOInaIQ==",
       "cpu": [
         "x64"
       ],
@@ -1705,13 +1740,30 @@
         "openbsd"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.8.tgz",
+      "integrity": "sha512-r2nVa5SIK9tSWd0kJd9HCffnDHKchTGikb//9c7HX+r+wHYCpQrSgxhlY6KWV1nFo1l4KFbsMlHk+L6fekLsUg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/sunos-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
-      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.8.tgz",
+      "integrity": "sha512-zUlaP2S12YhQ2UzUfcCuMDHQFJyKABkAjvO5YSndMiIkMimPmxA+BYSBikWgsRpvyxuRnow4nS5NPnf9fpv41w==",
       "cpu": [
         "x64"
       ],
@@ -1722,13 +1774,13 @@
         "sunos"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/win32-arm64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
-      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.8.tgz",
+      "integrity": "sha512-YEGFFWESlPva8hGL+zvj2z/SaK+pH0SwOM0Nc/d+rVnW7GSTFlLBGzZkuSU9kFIGIo8q9X3ucpZhu8PDN5A2sQ==",
       "cpu": [
         "arm64"
       ],
@@ -1739,13 +1791,13 @@
         "win32"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/win32-ia32": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
-      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.8.tgz",
+      "integrity": "sha512-hiGgGC6KZ5LZz58OL/+qVVoZiuZlUYlYHNAmczOm7bs2oE1XriPFi5ZHHrS8ACpV5EjySrnoCKmcbQMN+ojnHg==",
       "cpu": [
         "ia32"
       ],
@@ -1756,13 +1808,13 @@
         "win32"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@esbuild/win32-x64": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
-      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.8.tgz",
+      "integrity": "sha512-cn3Yr7+OaaZq1c+2pe+8yxC8E144SReCQjN6/2ynubzYjvyqZjTXfQJpAcQpsdJq3My7XADANiYGHoFC69pLQw==",
       "cpu": [
         "x64"
       ],
@@ -1773,7 +1825,7 @@
         "win32"
       ],
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       }
     },
     "node_modules/@istanbuljs/load-nyc-config": {
@@ -3859,6 +3911,23 @@
         "@babel/types": "^7.20.7"
       }
     },
+    "node_modules/@types/chai": {
+      "version": "5.2.2",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.2.tgz",
+      "integrity": "sha512-8kB30R7Hwqf40JPiKhVzodJs2Qc1ZJ5zuT3uzw5Hq/dhNCl3G3l83jfpdI1e20BP348+fV7VIL/+FxaXkqBmWg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/deep-eql": "*"
+      }
+    },
+    "node_modules/@types/deep-eql": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+      "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/estree": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
@@ -3926,11 +3995,12 @@
       "dev": true
     },
     "node_modules/@types/node": {
-      "version": "18.19.39",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.39.tgz",
-      "integrity": "sha512-nPwTRDKUctxw3di5b4TfT3I0sWDiWoPQCZjXhvdkINntwr8lcoVCKsTgnXeRubKIlfnV+eN/HYk6Jb40tbcEAQ==",
+      "version": "24.1.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.1.0.tgz",
+      "integrity": "sha512-ut5FthK5moxFKH2T1CUOC6ctR67rQRvvHdFLCD2Ql6KXmMuCrjsSsRI9UsLCm9M18BMwClv4pn327UvB7eeO1w==",
+      "license": "MIT",
       "dependencies": {
-        "undici-types": "~5.26.4"
+        "undici-types": "~7.8.0"
       }
     },
     "node_modules/@types/node-fetch": {
@@ -3976,103 +4046,115 @@
       "dev": true
     },
     "node_modules/@vitest/expect": {
-      "version": "1.6.1",
-      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-1.6.1.tgz",
-      "integrity": "sha512-jXL+9+ZNIJKruofqXuuTClf44eSpcHlgj3CiuNihUF3Ioujtmc0zIa3UJOW5RjDK1YLBJZnWBlPuqhYycLioog==",
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-3.2.4.tgz",
+      "integrity": "sha512-Io0yyORnB6sikFlt8QW5K7slY4OjqNX9jmJQ02QDda8lyM6B5oNgVWoSoKPac8/kgnCUzuHQKrSLtu/uOqqrig==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/spy": "1.6.1",
-        "@vitest/utils": "1.6.1",
-        "chai": "^4.3.10"
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "3.2.4",
+        "@vitest/utils": "3.2.4",
+        "chai": "^5.2.0",
+        "tinyrainbow": "^2.0.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
-    "node_modules/@vitest/runner": {
-      "version": "1.6.1",
-      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-1.6.1.tgz",
-      "integrity": "sha512-3nSnYXkVkf3mXFfE7vVyPmi3Sazhb/2cfZGGs0JRzFsPFvAMBEcrweV1V1GsrstdXeKCTXlJbvnQwGWgEIHmOA==",
+    "node_modules/@vitest/mocker": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-3.2.4.tgz",
+      "integrity": "sha512-46ryTE9RZO/rfDd7pEqFl7etuyzekzEhUbTW3BvmeO/BcCMEgq59BKhek3dXDWgAj4oMK6OZi+vRr1wPW6qjEQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@vitest/utils": "1.6.1",
-        "p-limit": "^5.0.0",
-        "pathe": "^1.1.1"
+        "@vitest/spy": "3.2.4",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.17"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
       }
     },
-    "node_modules/@vitest/runner/node_modules/p-limit": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-5.0.0.tgz",
-      "integrity": "sha512-/Eaoq+QyLSiXQ4lyYV23f14mZRQcXnxfHrN0vCai+ak9G0pp9iEQukIIZq5NccEvwRB8PUnZT0KsOoDCINS1qQ==",
+    "node_modules/@vitest/pretty-format": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-3.2.4.tgz",
+      "integrity": "sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "yocto-queue": "^1.0.0"
-      },
-      "engines": {
-        "node": ">=18"
+        "tinyrainbow": "^2.0.0"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "url": "https://opencollective.com/vitest"
       }
     },
-    "node_modules/@vitest/runner/node_modules/yocto-queue": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-1.2.1.tgz",
-      "integrity": "sha512-AyeEbWOu/TAXdxlV9wmGcR0+yh2j3vYPGOECcIj2S7MkrLyC7ne+oye2BKTItt0ii2PHk4cDy+95+LshzbXnGg==",
+    "node_modules/@vitest/runner": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-3.2.4.tgz",
+      "integrity": "sha512-oukfKT9Mk41LreEW09vt45f8wx7DordoWUZMYdY/cyAk7w5TWkTRCNZYF7sX7n2wB7jyGAl74OxgwhPgKaqDMQ==",
       "dev": true,
       "license": "MIT",
-      "engines": {
-        "node": ">=12.20"
+      "dependencies": {
+        "@vitest/utils": "3.2.4",
+        "pathe": "^2.0.3",
+        "strip-literal": "^3.0.0"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/snapshot": {
-      "version": "1.6.1",
-      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-1.6.1.tgz",
-      "integrity": "sha512-WvidQuWAzU2p95u8GAKlRMqMyN1yOJkGHnx3M1PL9Raf7AQ1kwLKg04ADlCa3+OXUZE7BceOhVZiuWAbzCKcUQ==",
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-3.2.4.tgz",
+      "integrity": "sha512-dEYtS7qQP2CjU27QBC5oUOxLE/v5eLkGqPE0ZKEIDGMs4vKWe7IjgLOeauHsR0D5YuuycGRO5oSRXnwnmA78fQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "magic-string": "^0.30.5",
-        "pathe": "^1.1.1",
-        "pretty-format": "^29.7.0"
+        "@vitest/pretty-format": "3.2.4",
+        "magic-string": "^0.30.17",
+        "pathe": "^2.0.3"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/spy": {
-      "version": "1.6.1",
-      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-1.6.1.tgz",
-      "integrity": "sha512-MGcMmpGkZebsMZhbQKkAf9CX5zGvjkBTqf8Zx3ApYWXr3wG+QvEu2eXWfnIIWYSJExIp4V9FCKDEeygzkYrXMw==",
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-3.2.4.tgz",
+      "integrity": "sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "tinyspy": "^2.2.0"
+        "tinyspy": "^4.0.3"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/utils": {
-      "version": "1.6.1",
-      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-1.6.1.tgz",
-      "integrity": "sha512-jOrrUvXM4Av9ZWiG1EajNto0u96kWAhJ1LmPmJhXXQx/32MecEKd10pOLYgS2BQx1TgkGhloPU1ArDW2vvaY6g==",
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-3.2.4.tgz",
+      "integrity": "sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "diff-sequences": "^29.6.3",
-        "estree-walker": "^3.0.3",
-        "loupe": "^2.3.7",
-        "pretty-format": "^29.7.0"
+        "@vitest/pretty-format": "3.2.4",
+        "loupe": "^3.1.4",
+        "tinyrainbow": "^2.0.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
@@ -4238,13 +4320,13 @@
       "dev": true
     },
     "node_modules/assertion-error": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz",
-      "integrity": "sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==",
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": "*"
+        "node": ">=12"
       }
     },
     "node_modules/async": {
@@ -4377,12 +4459,41 @@
       "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
       "dev": true
     },
+    "node_modules/base64-js": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
     "node_modules/before-after-hook": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-4.0.0.tgz",
       "integrity": "sha512-q6tR3RPqIB1pMiTRMFcZwuG5T8vwp+vUvEG0vuI6B+Rikh5BfPp2fQ82c925FOs+b0lcFQ8CFrL+KbilfZFhOQ==",
       "dev": true
     },
+    "node_modules/bignumber.js": {
+      "version": "9.3.1",
+      "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.3.1.tgz",
+      "integrity": "sha512-Ko0uX15oIUS7wJ3Rb30Fs6SkVbLmPBAKdlm7q9+ak9bbIeFf0MwuBsQV6z7+X768/cHsfg+WlysDWJcmthjsjQ==",
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/bottleneck": {
       "version": "2.19.5",
       "resolved": "https://registry.npmjs.org/bottleneck/-/bottleneck-2.19.5.tgz",
@@ -4472,6 +4583,12 @@
         "node-int64": "^0.4.0"
       }
     },
+    "node_modules/buffer-equal-constant-time": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz",
+      "integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==",
+      "license": "BSD-3-Clause"
+    },
     "node_modules/buffer-from": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
@@ -4530,32 +4647,20 @@
       "peer": true
     },
     "node_modules/chai": {
-      "version": "4.5.0",
-      "resolved": "https://registry.npmjs.org/chai/-/chai-4.5.0.tgz",
-      "integrity": "sha512-RITGBfijLkBddZvnn8jdqoTypxvqbOLYQkGGxXzeFjVHvudaPw0HNFD9x928/eUwYWd2dPCugVqspGALTZZQKw==",
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-5.2.1.tgz",
+      "integrity": "sha512-5nFxhUrX0PqtyogoYOA8IPswy5sZFTOsBFl/9bNsmDLgsxYTzSZQJDPppDnZPTQbzSEm0hqGjWPzRemQCYbD6A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "assertion-error": "^1.1.0",
-        "check-error": "^1.0.3",
-        "deep-eql": "^4.1.3",
-        "get-func-name": "^2.0.2",
-        "loupe": "^2.3.6",
-        "pathval": "^1.1.1",
-        "type-detect": "^4.1.0"
+        "assertion-error": "^2.0.1",
+        "check-error": "^2.1.1",
+        "deep-eql": "^5.0.1",
+        "loupe": "^3.1.0",
+        "pathval": "^2.0.0"
       },
       "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/chai/node_modules/type-detect": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.1.0.tgz",
-      "integrity": "sha512-Acylog8/luQ8L7il+geoSxhEkazvkslg7PSNKOX59mbB9cOveP5aq9h74Y7YU8yDpJwetzQQrfIwtf4Wp4LKcw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=4"
+        "node": ">=18"
       }
     },
     "node_modules/chalk": {
@@ -4584,16 +4689,13 @@
       }
     },
     "node_modules/check-error": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.3.tgz",
-      "integrity": "sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==",
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.1.tgz",
+      "integrity": "sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "get-func-name": "^2.0.2"
-      },
       "engines": {
-        "node": "*"
+        "node": ">= 16"
       }
     },
     "node_modules/ci-info": {
@@ -4778,13 +4880,6 @@
       "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
       "dev": true
     },
-    "node_modules/confbox": {
-      "version": "0.1.8",
-      "resolved": "https://registry.npmjs.org/confbox/-/confbox-0.1.8.tgz",
-      "integrity": "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/config-chain": {
       "version": "1.1.13",
       "resolved": "https://registry.npmjs.org/config-chain/-/config-chain-1.1.13.tgz",
@@ -5026,11 +5121,12 @@
       }
     },
     "node_modules/debug": {
-      "version": "4.3.5",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.5.tgz",
-      "integrity": "sha512-pt0bNEmneDIvdL1Xsd9oDQ/wrQRkXDT4AUWlNZNPKvW5x/jyO9VFXkJUP07vQ2upmw5PlaITaPKc31jK13V+jg==",
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
       "dependencies": {
-        "ms": "2.1.2"
+        "ms": "^2.1.3"
       },
       "engines": {
         "node": ">=6.0"
@@ -5041,11 +5137,6 @@
         }
       }
     },
-    "node_modules/debug/node_modules/ms": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
-      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
-    },
     "node_modules/dedent": {
       "version": "1.5.3",
       "resolved": "https://registry.npmjs.org/dedent/-/dedent-1.5.3.tgz",
@@ -5062,14 +5153,11 @@
       }
     },
     "node_modules/deep-eql": {
-      "version": "4.1.4",
-      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-4.1.4.tgz",
-      "integrity": "sha512-SUwdGfqdKOwxCPeVYjwSyRpJ7Z+fhpwIAtmCUdZIWZ/YP5R9WAsyuSgpLVDi9bjWoN2LXHNss/dk3urXtdQxGg==",
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
+      "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "type-detect": "^4.0.0"
-      },
       "engines": {
         "node": ">=6"
       }
@@ -5173,6 +5261,15 @@
         "readable-stream": "^2.0.2"
       }
     },
+    "node_modules/ecdsa-sig-formatter": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz",
+      "integrity": "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "safe-buffer": "^5.0.1"
+      }
+    },
     "node_modules/ejs": {
       "version": "3.1.10",
       "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.1.10.tgz",
@@ -5397,10 +5494,17 @@
         "is-arrayish": "^0.2.1"
       }
     },
+    "node_modules/es-module-lexer": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
+      "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/esbuild": {
-      "version": "0.21.5",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
-      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.8.tgz",
+      "integrity": "sha512-vVC0USHGtMi8+R4Kz8rt6JhEWLxsv9Rnu/lGYbPR8u47B+DCBksq9JarW0zOO7bs37hyOK1l2/oqtbciutL5+Q==",
       "dev": true,
       "hasInstallScript": true,
       "license": "MIT",
@@ -5408,32 +5512,35 @@
         "esbuild": "bin/esbuild"
       },
       "engines": {
-        "node": ">=12"
+        "node": ">=18"
       },
       "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.21.5",
-        "@esbuild/android-arm": "0.21.5",
-        "@esbuild/android-arm64": "0.21.5",
-        "@esbuild/android-x64": "0.21.5",
-        "@esbuild/darwin-arm64": "0.21.5",
-        "@esbuild/darwin-x64": "0.21.5",
-        "@esbuild/freebsd-arm64": "0.21.5",
-        "@esbuild/freebsd-x64": "0.21.5",
-        "@esbuild/linux-arm": "0.21.5",
-        "@esbuild/linux-arm64": "0.21.5",
-        "@esbuild/linux-ia32": "0.21.5",
-        "@esbuild/linux-loong64": "0.21.5",
-        "@esbuild/linux-mips64el": "0.21.5",
-        "@esbuild/linux-ppc64": "0.21.5",
-        "@esbuild/linux-riscv64": "0.21.5",
-        "@esbuild/linux-s390x": "0.21.5",
-        "@esbuild/linux-x64": "0.21.5",
-        "@esbuild/netbsd-x64": "0.21.5",
-        "@esbuild/openbsd-x64": "0.21.5",
-        "@esbuild/sunos-x64": "0.21.5",
-        "@esbuild/win32-arm64": "0.21.5",
-        "@esbuild/win32-ia32": "0.21.5",
-        "@esbuild/win32-x64": "0.21.5"
+        "@esbuild/aix-ppc64": "0.25.8",
+        "@esbuild/android-arm": "0.25.8",
+        "@esbuild/android-arm64": "0.25.8",
+        "@esbuild/android-x64": "0.25.8",
+        "@esbuild/darwin-arm64": "0.25.8",
+        "@esbuild/darwin-x64": "0.25.8",
+        "@esbuild/freebsd-arm64": "0.25.8",
+        "@esbuild/freebsd-x64": "0.25.8",
+        "@esbuild/linux-arm": "0.25.8",
+        "@esbuild/linux-arm64": "0.25.8",
+        "@esbuild/linux-ia32": "0.25.8",
+        "@esbuild/linux-loong64": "0.25.8",
+        "@esbuild/linux-mips64el": "0.25.8",
+        "@esbuild/linux-ppc64": "0.25.8",
+        "@esbuild/linux-riscv64": "0.25.8",
+        "@esbuild/linux-s390x": "0.25.8",
+        "@esbuild/linux-x64": "0.25.8",
+        "@esbuild/netbsd-arm64": "0.25.8",
+        "@esbuild/netbsd-x64": "0.25.8",
+        "@esbuild/openbsd-arm64": "0.25.8",
+        "@esbuild/openbsd-x64": "0.25.8",
+        "@esbuild/openharmony-arm64": "0.25.8",
+        "@esbuild/sunos-x64": "0.25.8",
+        "@esbuild/win32-arm64": "0.25.8",
+        "@esbuild/win32-ia32": "0.25.8",
+        "@esbuild/win32-x64": "0.25.8"
       }
     },
     "node_modules/escalade": {
@@ -5535,6 +5642,22 @@
         "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
       }
     },
+    "node_modules/expect-type": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.2.2.tgz",
+      "integrity": "sha512-JhFGDVJ7tmDJItKhYgJCGLOWjuK9vPxiXoUFLwLDc99NlmklilbiQJwoctZtt13+xMw91MCk/REan6MWHqDjyA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/extend": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
+      "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==",
+      "license": "MIT"
+    },
     "node_modules/fast-content-type-parse": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/fast-content-type-parse/-/fast-content-type-parse-3.0.0.tgz",
@@ -5870,6 +5993,34 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/gaxios": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/gaxios/-/gaxios-7.1.1.tgz",
+      "integrity": "sha512-Odju3uBUJyVCkW64nLD4wKLhbh93bh6vIg/ZIXkWiLPBrdgtc65+tls/qml+un3pr6JqYVFDZbbmLDQT68rTOQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "extend": "^3.0.2",
+        "https-proxy-agent": "^7.0.1",
+        "node-fetch": "^3.3.2"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/gcp-metadata": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-7.0.1.tgz",
+      "integrity": "sha512-UcO3kefx6dCcZkgcTGgVOTFb7b1LlQ02hY1omMjjrrBzkajRMCFgYOjs7J71WqnuG1k2b+9ppGL7FsOfhZMQKQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "gaxios": "^7.0.0",
+        "google-logging-utils": "^1.0.0",
+        "json-bigint": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/gensync": {
       "version": "1.0.0-beta.2",
       "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
@@ -5889,16 +6040,6 @@
         "node": "6.* || 8.* || >= 10.*"
       }
     },
-    "node_modules/get-func-name": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.2.tgz",
-      "integrity": "sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "*"
-      }
-    },
     "node_modules/get-package-type": {
       "version": "0.1.0",
       "resolved": "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz",
@@ -6023,12 +6164,52 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/google-auth-library": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-10.1.0.tgz",
+      "integrity": "sha512-GspVjZj1RbyRWpQ9FbAXMKjFGzZwDKnUHi66JJ+tcjcu5/xYAP1pdlWotCuIkMwjfVsxxDvsGZXGLzRt72D0sQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "base64-js": "^1.3.0",
+        "ecdsa-sig-formatter": "^1.0.11",
+        "gaxios": "^7.0.0",
+        "gcp-metadata": "^7.0.0",
+        "google-logging-utils": "^1.0.0",
+        "gtoken": "^8.0.0",
+        "jws": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/google-logging-utils": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-1.1.1.tgz",
+      "integrity": "sha512-rcX58I7nqpu4mbKztFeOAObbomBbHU2oIb/d3tJfF3dizGSApqtSwYJigGCooHdnMyQBIw8BrWyK96w3YXgr6A==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=14"
+      }
+    },
     "node_modules/graceful-fs": {
       "version": "4.2.11",
       "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
       "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
       "dev": true
     },
+    "node_modules/gtoken": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/gtoken/-/gtoken-8.0.0.tgz",
+      "integrity": "sha512-+CqsMbHPiSTdtSO14O51eMNlrp9N79gmeqmXeouJOhfucAedHw9noVe/n5uJk3tbKE6a+6ZCQg3RPhVhHByAIw==",
+      "license": "MIT",
+      "dependencies": {
+        "gaxios": "^7.0.0",
+        "jws": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/handlebars": {
       "version": "4.7.8",
       "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.7.8.tgz",
@@ -7186,6 +7367,15 @@
         "node": ">=4"
       }
     },
+    "node_modules/json-bigint": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/json-bigint/-/json-bigint-1.0.0.tgz",
+      "integrity": "sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "bignumber.js": "^9.0.0"
+      }
+    },
     "node_modules/json-parse-better-errors": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz",
@@ -7227,15 +7417,36 @@
         "graceful-fs": "^4.1.6"
       }
     },
-    "node_modules/kleur": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz",
-      "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==",
-      "dev": true,
-      "peer": true,
-      "engines": {
-        "node": ">=6"
-      }
+    "node_modules/jwa": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.1.tgz",
+      "integrity": "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==",
+      "license": "MIT",
+      "dependencies": {
+        "buffer-equal-constant-time": "^1.0.1",
+        "ecdsa-sig-formatter": "1.0.11",
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/jws": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/jws/-/jws-4.0.0.tgz",
+      "integrity": "sha512-KDncfTmOZoOMTFG4mBlG0qUIOlc03fmzH+ru6RgYVZhPkyiy/92Owlt/8UEN+a4TXR1FQetfIpJE8ApdvdVxTg==",
+      "license": "MIT",
+      "dependencies": {
+        "jwa": "^2.0.0",
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/kleur": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz",
+      "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==",
+      "dev": true,
+      "peer": true,
+      "engines": {
+        "node": ">=6"
+      }
     },
     "node_modules/leven": {
       "version": "3.1.0",
@@ -7290,23 +7501,6 @@
         "node": ">=4"
       }
     },
-    "node_modules/local-pkg": {
-      "version": "0.5.1",
-      "resolved": "https://registry.npmjs.org/local-pkg/-/local-pkg-0.5.1.tgz",
-      "integrity": "sha512-9rrA30MRRP3gBD3HTGnC6cDFpaE1kVDWxWgqWJUN0RvDNAo+Nz/9GxB+nHOH0ifbVFy0hSA1V6vFDvnx54lTEQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "mlly": "^1.7.3",
-        "pkg-types": "^1.2.1"
-      },
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/antfu"
-      }
-    },
     "node_modules/locate-path": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz",
@@ -7369,14 +7563,11 @@
       "dev": true
     },
     "node_modules/loupe": {
-      "version": "2.3.7",
-      "resolved": "https://registry.npmjs.org/loupe/-/loupe-2.3.7.tgz",
-      "integrity": "sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==",
+      "version": "3.1.4",
+      "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.1.4.tgz",
+      "integrity": "sha512-wJzkKwJrheKtknCOKNEtDK4iqg/MxmZheEMtSTYvnzRdEYaZzmgH976nenp8WdJRdx5Vc1X/9MO0Oszl6ezeXg==",
       "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "get-func-name": "^2.0.1"
-      }
+      "license": "MIT"
     },
     "node_modules/lru-cache": {
       "version": "5.1.1",
@@ -7619,26 +7810,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/mlly": {
-      "version": "1.7.4",
-      "resolved": "https://registry.npmjs.org/mlly/-/mlly-1.7.4.tgz",
-      "integrity": "sha512-qmdSIPC4bDJXgZTCR7XosJiNKySV7O215tsPtDN9iEO/7q/76b/ijtgRu/+epFXSJhijtTCCGp3DWS549P3xKw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "acorn": "^8.14.0",
-        "pathe": "^2.0.1",
-        "pkg-types": "^1.3.0",
-        "ufo": "^1.5.4"
-      }
-    },
-    "node_modules/mlly/node_modules/pathe": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
-      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/ms": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
@@ -10573,6 +10744,15 @@
         }
       }
     },
+    "node_modules/openai/node_modules/@types/node": {
+      "version": "18.19.120",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.120.tgz",
+      "integrity": "sha512-WtCGHFXnVI8WHLxDAt5TbnCM4eSE+nI0QN2NJtwzcgMhht2eNz6V9evJrk+lwC8bCY8OWV5Ym8Jz7ZEyGnKnMA==",
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~5.26.4"
+      }
+    },
     "node_modules/openai/node_modules/node-fetch": {
       "version": "2.7.0",
       "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
@@ -10592,6 +10772,12 @@
         }
       }
     },
+    "node_modules/openai/node_modules/undici-types": {
+      "version": "5.26.5",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
+      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
+      "license": "MIT"
+    },
     "node_modules/p-each-series": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/p-each-series/-/p-each-series-3.0.0.tgz",
@@ -10816,20 +11002,20 @@
       }
     },
     "node_modules/pathe": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/pathe/-/pathe-1.1.2.tgz",
-      "integrity": "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==",
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/pathval": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/pathval/-/pathval-1.1.1.tgz",
-      "integrity": "sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==",
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz",
+      "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": "*"
+        "node": ">= 14.16"
       }
     },
     "node_modules/picocolors": {
@@ -10963,25 +11149,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/pkg-types": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-1.3.1.tgz",
-      "integrity": "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "confbox": "^0.1.8",
-        "mlly": "^1.7.4",
-        "pathe": "^2.0.1"
-      }
-    },
-    "node_modules/pkg-types/node_modules/pathe": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
-      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/postcss": {
       "version": "8.5.6",
       "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
@@ -11396,8 +11563,7 @@
     "node_modules/safe-buffer": {
       "version": "5.1.2",
       "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
-      "dev": true
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
     },
     "node_modules/semantic-release": {
       "version": "24.2.7",
@@ -12055,9 +12221,9 @@
       }
     },
     "node_modules/strip-literal": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-2.1.1.tgz",
-      "integrity": "sha512-631UJ6O00eNGfMiWG78ck80dfBab8X6IVFB51jZK5Icd7XAs60Z5y7QdSd/wGIklnWvRbUNloVzhOKKmutxQ6Q==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-3.0.0.tgz",
+      "integrity": "sha512-TcccoMhJOM3OebGhSBEmp3UZ2SfDMZUEBdRA/9ynfLi8yYajyWX3JiXArcJt4Umh4vISpspkQIY8ZZoCqjbviA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -12262,10 +12428,72 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/tinyexec": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",
+      "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.14",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.14.tgz",
+      "integrity": "sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.4.4",
+        "picomatch": "^4.0.2"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tinyglobby/node_modules/fdir": {
+      "version": "6.4.6",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.6.tgz",
+      "integrity": "sha512-hiFoqpyZcfNm1yc4u8oWCf9A2c4D3QjCrks3zmoVKVxpQRzmPNar1hUJcBG2RQHvEVGDN+Jm81ZheVLAQMK6+w==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/tinyglobby/node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
     "node_modules/tinypool": {
-      "version": "0.8.4",
-      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-0.8.4.tgz",
-      "integrity": "sha512-i11VH5gS6IFeLY3gMBQ00/MmLncVP7JLXOw1vlgkytLmJK7QnEr7NXf0LBdxfmNPAeyetukOk0bOYrJrFGjYJQ==",
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz",
+      "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      }
+    },
+    "node_modules/tinyrainbow": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-2.0.0.tgz",
+      "integrity": "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -12273,9 +12501,9 @@
       }
     },
     "node_modules/tinyspy": {
-      "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-2.2.1.tgz",
-      "integrity": "sha512-KYad6Vy5VDWV4GH3fjpseMQ/XU2BhIYP7Vzd0LG44qRWm/Yt2WCOTicFdvmgo6gWaqooMQCawTtILVQJupKu7A==",
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-4.0.3.tgz",
+      "integrity": "sha512-t2T/WLB2WRgZ9EpE4jgPJ9w+i66UZfDc8wHh0xrwiRNN+UwH98GIJkTeZqX9rg0i0ptwzqW+uYeIF0T4F8LR7A==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -12442,6 +12670,7 @@
       "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz",
       "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==",
       "dev": true,
+      "peer": true,
       "engines": {
         "node": ">=4"
       }
@@ -12473,13 +12702,6 @@
         "node": ">=14.17"
       }
     },
-    "node_modules/ufo": {
-      "version": "1.6.1",
-      "resolved": "https://registry.npmjs.org/ufo/-/ufo-1.6.1.tgz",
-      "integrity": "sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/uglify-js": {
       "version": "3.19.3",
       "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.19.3.tgz",
@@ -12494,9 +12716,10 @@
       }
     },
     "node_modules/undici-types": {
-      "version": "5.26.5",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
-      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA=="
+      "version": "7.8.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.8.0.tgz",
+      "integrity": "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw==",
+      "license": "MIT"
     },
     "node_modules/unicode-emoji-modifier-base": {
       "version": "1.0.0",
@@ -12639,21 +12862,24 @@
       }
     },
     "node_modules/vite": {
-      "version": "5.4.19",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.19.tgz",
-      "integrity": "sha512-qO3aKv3HoQC8QKiNSTuUM1l9o/XX3+c+VTgLHbJWHZGeTPVAg2XwazI9UWzoxjIJCGCV2zU60uqMzjeLZuULqA==",
+      "version": "7.0.5",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-7.0.5.tgz",
+      "integrity": "sha512-1mncVwJxy2C9ThLwz0+2GKZyEXuC3MyWtAAlNftlZZXZDP3AJt5FmwcMit/IGGaNZ8ZOB2BNO/HFUB+CpN0NQw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "esbuild": "^0.21.3",
-        "postcss": "^8.4.43",
-        "rollup": "^4.20.0"
+        "esbuild": "^0.25.0",
+        "fdir": "^6.4.6",
+        "picomatch": "^4.0.2",
+        "postcss": "^8.5.6",
+        "rollup": "^4.40.0",
+        "tinyglobby": "^0.2.14"
       },
       "bin": {
         "vite": "bin/vite.js"
       },
       "engines": {
-        "node": "^18.0.0 || >=20.0.0"
+        "node": "^20.19.0 || >=22.12.0"
       },
       "funding": {
         "url": "https://github.com/vitejs/vite?sponsor=1"
@@ -12662,19 +12888,25 @@
         "fsevents": "~2.3.3"
       },
       "peerDependencies": {
-        "@types/node": "^18.0.0 || >=20.0.0",
-        "less": "*",
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
         "lightningcss": "^1.21.0",
-        "sass": "*",
-        "sass-embedded": "*",
-        "stylus": "*",
-        "sugarss": "*",
-        "terser": "^5.4.0"
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
       },
       "peerDependenciesMeta": {
         "@types/node": {
           "optional": true
         },
+        "jiti": {
+          "optional": true
+        },
         "less": {
           "optional": true
         },
@@ -12695,74 +12927,112 @@
         },
         "terser": {
           "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
         }
       }
     },
     "node_modules/vite-node": {
-      "version": "1.6.1",
-      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-1.6.1.tgz",
-      "integrity": "sha512-YAXkfvGtuTzwWbDSACdJSg4A4DZiAqckWe90Zapc/sEX3XvHcw1NdurM/6od8J207tSDqNbSsgdCacBgvJKFuA==",
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-3.2.4.tgz",
+      "integrity": "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "cac": "^6.7.14",
-        "debug": "^4.3.4",
-        "pathe": "^1.1.1",
-        "picocolors": "^1.0.0",
-        "vite": "^5.0.0"
+        "debug": "^4.4.1",
+        "es-module-lexer": "^1.7.0",
+        "pathe": "^2.0.3",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0"
       },
       "bin": {
         "vite-node": "vite-node.mjs"
       },
       "engines": {
-        "node": "^18.0.0 || >=20.0.0"
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
-    "node_modules/vitest": {
-      "version": "1.6.1",
-      "resolved": "https://registry.npmjs.org/vitest/-/vitest-1.6.1.tgz",
-      "integrity": "sha512-Ljb1cnSJSivGN0LqXd/zmDbWEM0RNNg2t1QW/XUhYl/qPqyu7CsqeWtqQXHVaJsecLPuDoak2oJcZN2QoRIOag==",
+    "node_modules/vite/node_modules/fdir": {
+      "version": "6.4.6",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.6.tgz",
+      "integrity": "sha512-hiFoqpyZcfNm1yc4u8oWCf9A2c4D3QjCrks3zmoVKVxpQRzmPNar1hUJcBG2RQHvEVGDN+Jm81ZheVLAQMK6+w==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@vitest/expect": "1.6.1",
-        "@vitest/runner": "1.6.1",
-        "@vitest/snapshot": "1.6.1",
-        "@vitest/spy": "1.6.1",
-        "@vitest/utils": "1.6.1",
-        "acorn-walk": "^8.3.2",
-        "chai": "^4.3.10",
-        "debug": "^4.3.4",
-        "execa": "^8.0.1",
-        "local-pkg": "^0.5.0",
-        "magic-string": "^0.30.5",
-        "pathe": "^1.1.1",
-        "picocolors": "^1.0.0",
-        "std-env": "^3.5.0",
-        "strip-literal": "^2.0.0",
-        "tinybench": "^2.5.1",
-        "tinypool": "^0.8.3",
-        "vite": "^5.0.0",
-        "vite-node": "1.6.1",
-        "why-is-node-running": "^2.2.2"
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite/node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/vitest": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-3.2.4.tgz",
+      "integrity": "sha512-LUCP5ev3GURDysTWiP47wRRUpLKMOfPh+yKTx3kVIEiu5KOMeqzpnYNsKyOoVrULivR8tLcks4+lga33Whn90A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/chai": "^5.2.2",
+        "@vitest/expect": "3.2.4",
+        "@vitest/mocker": "3.2.4",
+        "@vitest/pretty-format": "^3.2.4",
+        "@vitest/runner": "3.2.4",
+        "@vitest/snapshot": "3.2.4",
+        "@vitest/spy": "3.2.4",
+        "@vitest/utils": "3.2.4",
+        "chai": "^5.2.0",
+        "debug": "^4.4.1",
+        "expect-type": "^1.2.1",
+        "magic-string": "^0.30.17",
+        "pathe": "^2.0.3",
+        "picomatch": "^4.0.2",
+        "std-env": "^3.9.0",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^0.3.2",
+        "tinyglobby": "^0.2.14",
+        "tinypool": "^1.1.1",
+        "tinyrainbow": "^2.0.0",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0",
+        "vite-node": "3.2.4",
+        "why-is-node-running": "^2.3.0"
       },
       "bin": {
         "vitest": "vitest.mjs"
       },
       "engines": {
-        "node": "^18.0.0 || >=20.0.0"
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       },
       "peerDependencies": {
         "@edge-runtime/vm": "*",
-        "@types/node": "^18.0.0 || >=20.0.0",
-        "@vitest/browser": "1.6.1",
-        "@vitest/ui": "1.6.1",
+        "@types/debug": "^4.1.12",
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "@vitest/browser": "3.2.4",
+        "@vitest/ui": "3.2.4",
         "happy-dom": "*",
         "jsdom": "*"
       },
@@ -12770,6 +13040,9 @@
         "@edge-runtime/vm": {
           "optional": true
         },
+        "@types/debug": {
+          "optional": true
+        },
         "@types/node": {
           "optional": true
         },
@@ -12787,148 +13060,17 @@
         }
       }
     },
-    "node_modules/vitest/node_modules/execa": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/execa/-/execa-8.0.1.tgz",
-      "integrity": "sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "cross-spawn": "^7.0.3",
-        "get-stream": "^8.0.1",
-        "human-signals": "^5.0.0",
-        "is-stream": "^3.0.0",
-        "merge-stream": "^2.0.0",
-        "npm-run-path": "^5.1.0",
-        "onetime": "^6.0.0",
-        "signal-exit": "^4.1.0",
-        "strip-final-newline": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=16.17"
-      },
-      "funding": {
-        "url": "https://github.com/sindresorhus/execa?sponsor=1"
-      }
-    },
-    "node_modules/vitest/node_modules/get-stream": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-8.0.1.tgz",
-      "integrity": "sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=16"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/vitest/node_modules/human-signals": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-5.0.0.tgz",
-      "integrity": "sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=16.17.0"
-      }
-    },
-    "node_modules/vitest/node_modules/is-stream": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-3.0.0.tgz",
-      "integrity": "sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/vitest/node_modules/mimic-fn": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-4.0.0.tgz",
-      "integrity": "sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/vitest/node_modules/npm-run-path": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-5.3.0.tgz",
-      "integrity": "sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "path-key": "^4.0.0"
-      },
-      "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/vitest/node_modules/onetime": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/onetime/-/onetime-6.0.0.tgz",
-      "integrity": "sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "mimic-fn": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/vitest/node_modules/path-key": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz",
-      "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/vitest/node_modules/signal-exit": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
-      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
-    "node_modules/vitest/node_modules/strip-final-newline": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-3.0.0.tgz",
-      "integrity": "sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==",
+    "node_modules/vitest/node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=12"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
     "node_modules/walker": {
diff --git a/packages/openai-adapters/package.json b/packages/openai-adapters/package.json
index 0771c7d8737..94334b70092 100644
--- a/packages/openai-adapters/package.json
+++ b/packages/openai-adapters/package.json
@@ -18,6 +18,7 @@
     "@continuedev/config-yaml": "^1.0.51",
     "@continuedev/fetch": "^1.0.15",
     "dotenv": "^16.5.0",
+    "google-auth-library": "^10.1.0",
     "json-schema": "^0.4.0",
     "node-fetch": "^3.3.2",
     "openai": "^4.104.0",
@@ -38,6 +39,6 @@
     "semantic-release": "^24.2.7",
     "ts-jest": "^29.2.3",
     "ts-node": "^10.9.2",
-    "vitest": "^1.6.1"
+    "vitest": "^3.2.4"
   }
 }
diff --git a/packages/openai-adapters/src/apis/Anthropic.ts b/packages/openai-adapters/src/apis/Anthropic.ts
index 5df8b7a1d95..2b986d1d537 100644
--- a/packages/openai-adapters/src/apis/Anthropic.ts
+++ b/packages/openai-adapters/src/apis/Anthropic.ts
@@ -55,7 +55,7 @@ export class AnthropicApi implements BaseLlmApi {
     return cachingStrategy(cleanBody);
   }
 
-  private _convertToCleanAnthropicBody(oaiBody: ChatCompletionCreateParams) {
+  public _convertToCleanAnthropicBody(oaiBody: ChatCompletionCreateParams) {
     let stop = undefined;
     if (oaiBody.stop && Array.isArray(oaiBody.stop)) {
       stop = oaiBody.stop.filter((x) => x.trim() !== "");
@@ -219,27 +219,9 @@ export class AnthropicApi implements BaseLlmApi {
       ],
     };
   }
-  async *chatCompletionStream(
-    body: ChatCompletionCreateParamsStreaming,
-    signal: AbortSignal,
-  ): AsyncGenerator<ChatCompletionChunk, any, unknown> {
-    body.messages;
-    const response = await customFetch(this.config.requestOptions)(
-      new URL("messages", this.apiBase),
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "application/json",
-          "anthropic-version": "2023-06-01",
-          "anthropic-beta": "prompt-caching-2024-07-31",
-          "x-api-key": this.config.apiKey,
-        },
-        body: JSON.stringify(this._convertBody(body)),
-        signal,
-      },
-    );
 
+  // This is split off so e.g. VertexAI can use it
+  async *handleStreamResponse(response: any, model: string) {
     let lastToolUseId: string | undefined;
     let lastToolUseName: string | undefined;
 
@@ -272,7 +254,7 @@ export class AnthropicApi implements BaseLlmApi {
             case "text_delta":
               yield chatChunk({
                 content: value.delta.text,
-                model: body.model,
+                model,
               });
               break;
             case "input_json_delta":
@@ -280,7 +262,7 @@ export class AnthropicApi implements BaseLlmApi {
                 throw new Error("No tool use found");
               }
               yield chatChunkFromDelta({
-                model: body.model,
+                model,
                 delta: {
                   tool_calls: [
                     {
@@ -308,13 +290,36 @@ export class AnthropicApi implements BaseLlmApi {
     }
 
     yield usageChatChunk({
-      model: body.model,
+      model,
       usage: {
         ...usage,
         total_tokens: usage.completion_tokens + usage.prompt_tokens,
       },
     });
   }
+
+  async *chatCompletionStream(
+    body: ChatCompletionCreateParamsStreaming,
+    signal: AbortSignal,
+  ): AsyncGenerator<ChatCompletionChunk, any, unknown> {
+    body.messages;
+    const response = await customFetch(this.config.requestOptions)(
+      new URL("messages", this.apiBase),
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          "anthropic-version": "2023-06-01",
+          "anthropic-beta": "prompt-caching-2024-07-31",
+          "x-api-key": this.config.apiKey,
+        },
+        body: JSON.stringify(this._convertBody(body)),
+        signal,
+      },
+    );
+    yield* this.handleStreamResponse(response, body.model);
+  }
   async completionNonStream(
     body: CompletionCreateParamsNonStreaming,
     signal: AbortSignal,
diff --git a/packages/openai-adapters/src/apis/Gemini.ts b/packages/openai-adapters/src/apis/Gemini.ts
index c0e441a1df6..91021a8f429 100644
--- a/packages/openai-adapters/src/apis/Gemini.ts
+++ b/packages/openai-adapters/src/apis/Gemini.ts
@@ -84,7 +84,12 @@ export class GeminiApi implements BaseLlmApi {
     }
   }
 
-  private _convertBody(oaiBody: ChatCompletionCreateParams, url: string) {
+  public _convertBody(
+    oaiBody: ChatCompletionCreateParams,
+    url: string,
+    includeToolCallIds: boolean,
+    overrideIsV1?: boolean,
+  ) {
     const generationConfig: any = {};
 
     if (oaiBody.top_p) {
@@ -101,7 +106,7 @@ export class GeminiApi implements BaseLlmApi {
       generationConfig.stopSequences = stop.filter((x) => x.trim() !== "");
     }
 
-    const isV1API = url.includes("/v1/");
+    const isV1API = overrideIsV1 ?? url.includes("/v1/");
 
     const toolCallIdToNameMap = new Map<string, string>();
     oaiBody.messages.forEach((msg) => {
@@ -127,7 +132,7 @@ export class GeminiApi implements BaseLlmApi {
             role: "model" as const,
             parts: msg.tool_calls.map((toolCall) => ({
               functionCall: {
-                id: toolCall.id,
+                id: includeToolCallIds ? toolCall.id : undefined,
                 name: toolCall.function.name,
                 args: safeParseArgs(
                   toolCall.function.arguments,
@@ -145,7 +150,7 @@ export class GeminiApi implements BaseLlmApi {
             parts: [
               {
                 functionResponse: {
-                  id: msg.tool_call_id,
+                  id: includeToolCallIds ? msg.tool_call_id : undefined,
                   name: functionName ?? "unknown",
                   response: {
                     content:
@@ -250,23 +255,9 @@ export class GeminiApi implements BaseLlmApi {
     };
   }
 
-  async *chatCompletionStream(
-    body: ChatCompletionCreateParamsStreaming,
-    signal: AbortSignal,
-  ): AsyncGenerator<ChatCompletionChunk> {
-    const apiURL = new URL(
-      `models/${body.model}:streamGenerateContent?key=${this.config.apiKey}`,
-      this.apiBase,
-    ).toString();
-    const convertedBody = this._convertBody(body, apiURL);
-    const resp = await customFetch(this.config.requestOptions)(apiURL, {
-      method: "POST",
-      body: JSON.stringify(convertedBody),
-      signal,
-    });
-
+  async *handleStreamResponse(response: any, model: string) {
     let buffer = "";
-    for await (const chunk of streamResponse(resp as any)) {
+    for await (const chunk of streamResponse(response as any)) {
       buffer += chunk;
       if (buffer.startsWith("[")) {
         buffer = buffer.slice(1);
@@ -301,11 +292,11 @@ export class GeminiApi implements BaseLlmApi {
             if ("text" in part) {
               yield chatChunk({
                 content: part.text,
-                model: body.model,
+                model,
               });
             } else if ("functionCall" in part) {
               yield chatChunkFromDelta({
-                model: body.model,
+                model,
                 delta: {
                   tool_calls: [
                     {
@@ -333,6 +324,23 @@ export class GeminiApi implements BaseLlmApi {
       }
     }
   }
+
+  async *chatCompletionStream(
+    body: ChatCompletionCreateParamsStreaming,
+    signal: AbortSignal,
+  ): AsyncGenerator<ChatCompletionChunk> {
+    const apiURL = new URL(
+      `models/${body.model}:streamGenerateContent?key=${this.config.apiKey}`,
+      this.apiBase,
+    ).toString();
+    const convertedBody = this._convertBody(body, apiURL, true);
+    const resp = await customFetch(this.config.requestOptions)(apiURL, {
+      method: "POST",
+      body: JSON.stringify(convertedBody),
+      signal,
+    });
+    yield* this.handleStreamResponse(resp, body.model);
+  }
   completionNonStream(
     body: CompletionCreateParamsNonStreaming,
   ): Promise<Completion> {
diff --git a/packages/openai-adapters/src/apis/VertexAI.ts b/packages/openai-adapters/src/apis/VertexAI.ts
new file mode 100644
index 00000000000..74de768b8ca
--- /dev/null
+++ b/packages/openai-adapters/src/apis/VertexAI.ts
@@ -0,0 +1,569 @@
+import { streamSse } from "@continuedev/fetch";
+import { AuthClient, GoogleAuth, JWT, auth } from "google-auth-library";
+import {
+  ChatCompletion,
+  ChatCompletionChunk,
+  ChatCompletionCreateParams,
+  ChatCompletionCreateParamsNonStreaming,
+  ChatCompletionCreateParamsStreaming,
+  Completion,
+  CompletionCreateParamsNonStreaming,
+  CompletionCreateParamsStreaming,
+  CreateEmbeddingResponse,
+  EmbeddingCreateParams,
+  Model,
+} from "openai/resources/index";
+import { VertexAIConfig } from "../types.js";
+import { chatChunk, chatCompletion, customFetch, embedding } from "../util.js";
+import { AnthropicApi } from "./Anthropic.js";
+import {
+  BaseLlmApi,
+  CreateRerankResponse,
+  FimCreateParamsStreaming,
+  RerankCreateParams,
+} from "./base.js";
+import { GeminiApi } from "./Gemini.js";
+import { OpenAIApi } from "./OpenAI.js";
+
+export class VertexAIApi implements BaseLlmApi {
+  anthropicInstance: AnthropicApi;
+  geminiInstance: GeminiApi;
+  mistralInstance: OpenAIApi;
+  private clientPromise?: Promise<AuthClient | void>;
+  static AUTH_SCOPES = "https://www.googleapis.com/auth/cloud-platform";
+
+  constructor(protected config: VertexAIConfig) {
+    this.setupAuthentication();
+
+    // These sub-instances are only used to convert and handle responses,
+    // So do not need apiKey, etc
+    this.anthropicInstance = new AnthropicApi({
+      provider: "anthropic",
+      apiKey: "dud",
+    });
+    this.geminiInstance = new GeminiApi({
+      provider: "gemini",
+      apiKey: "dud",
+    });
+    this.mistralInstance = new OpenAIApi({
+      provider: "mistral",
+      apiKey: "dud",
+    });
+  }
+
+  private setupAuthentication(): void {
+    const { apiKey, env } = this.config;
+    const { region, projectId, keyFile, keyJson } = env || {};
+
+    // Validate authentication configuration
+    if (apiKey) {
+      // Express mode validation
+      if (region || projectId || keyFile || keyJson) {
+        throw new Error(
+          "VertexAI in express mode (apiKey only) cannot be configured with region, projectId, keyFile, or keyJson",
+        );
+      }
+    } else {
+      // Standard mode validation
+      if (!region || !projectId) {
+        throw new Error(
+          "region and projectId are required for VertexAI (when not using express/apiKey mode)",
+        );
+      }
+      if (keyFile && keyJson) {
+        throw new Error(
+          "VertexAI credentials can be configured with either keyFile or keyJson but not both",
+        );
+      }
+    }
+
+    // Set up authentication client
+    if (keyJson) {
+      try {
+        const parsed = JSON.parse(keyJson);
+        if (!parsed?.private_key) {
+          throw new Error("VertexAI: keyJson must contain a valid private key");
+        }
+        parsed.private_key = parsed.private_key.replace(/\\n/g, "\n");
+        const jsonClient = auth.fromJSON(parsed);
+        if (jsonClient instanceof JWT) {
+          jsonClient.scopes = [VertexAIApi.AUTH_SCOPES];
+        } else {
+          throw new Error("VertexAI: keyJson must be a valid JWT");
+        }
+        this.clientPromise = Promise.resolve(jsonClient);
+      } catch (e) {
+        throw new Error("VertexAI: Failed to parse keyJson");
+      }
+    } else if (keyFile) {
+      if (typeof keyFile !== "string") {
+        throw new Error("VertexAI: keyFile must be a string");
+      }
+      this.clientPromise = new GoogleAuth({
+        scopes: VertexAIApi.AUTH_SCOPES,
+        keyFile,
+      })
+        .getClient()
+        .catch((e: Error) => {
+          console.warn(
+            `Failed to load credentials for Vertex AI: ${e.message}`,
+          );
+        });
+    } else if (!apiKey) {
+      // Application Default Credentials
+      this.clientPromise = new GoogleAuth({
+        scopes: VertexAIApi.AUTH_SCOPES,
+      })
+        .getClient()
+        .catch((e: Error) => {
+          console.warn(
+            `Failed to load credentials for Vertex AI: ${e.message}`,
+          );
+        });
+    }
+  }
+
+  private getApiBase(): string {
+    const { apiKey, env } = this.config;
+
+    if (this.config.apiBase) {
+      return this.config.apiBase;
+    }
+
+    if (apiKey) {
+      // Express mode
+      return "https://aiplatform.googleapis.com/v1/";
+    } else {
+      // Standard mode
+      const { region, projectId } = env!;
+      return `https://${region}-aiplatform.googleapis.com/v1/projects/${projectId}/locations/${region}/`;
+    }
+  }
+
+  private determineVertexProvider(
+    model: string,
+  ): "mistral" | "anthropic" | "gemini" | "unknown" {
+    if (
+      model.includes("mistral") ||
+      model.includes("codestral") ||
+      model.includes("mixtral")
+    ) {
+      return "mistral";
+    } else if (model.includes("claude")) {
+      return "anthropic";
+    } else if (model.includes("gemini")) {
+      return "gemini";
+    }
+    return "unknown";
+  }
+
+  private async getAuthHeaders(): Promise<Record<string, string>> {
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      // Accept: "application/json"
+    };
+
+    // TODO - support anthropic prompt caching with "anthropic-beta" header
+
+    if (this.config.apiKey) {
+      // Express mode - no Authorization header needed, API key is in URL
+      return headers;
+    } else {
+      // Standard mode - use OAuth token
+      const client = await this.clientPromise;
+      const result = await client?.getAccessToken();
+      if (!result?.token) {
+        throw new Error(
+          "Could not get an access token. Set up your Google Application Default Credentials.",
+        );
+      }
+      headers.Authorization = `Bearer ${result.token}`;
+      return headers;
+    }
+  }
+
+  private buildUrl(endpoint: string, model?: string): URL {
+    const apiBase = this.getApiBase();
+    const url = new URL(endpoint, apiBase);
+
+    if (this.config.apiKey) {
+      url.searchParams.set("key", this.config.apiKey);
+    }
+
+    return url;
+  }
+
+  private convertAnthropicBody(oaiBody: ChatCompletionCreateParams): object {
+    const body = this.anthropicInstance._convertToCleanAnthropicBody(oaiBody);
+    const { model, ...exceptModel } = body;
+    return {
+      ...exceptModel,
+      anthropic_version: "vertex-2023-10-16",
+    };
+  }
+
+  private convertGeminiBody(
+    oaiBody: ChatCompletionCreateParams,
+    url: URL,
+  ): object {
+    return this.geminiInstance._convertBody(
+      oaiBody,
+      url.toString(),
+      false,
+      false,
+    );
+  }
+
+  async chatCompletionNonStream(
+    body: ChatCompletionCreateParamsNonStreaming,
+    signal: AbortSignal,
+  ): Promise<ChatCompletion> {
+    const vertexProvider = this.determineVertexProvider(body.model);
+
+    if (this.config.apiKey && vertexProvider !== "gemini") {
+      throw new Error(
+        "VertexAI: only gemini models are supported in express (apiKey) mode",
+      );
+    }
+
+    const headers = await this.getAuthHeaders();
+    let url: URL;
+    let requestBody: any;
+
+    switch (vertexProvider) {
+      case "anthropic":
+        url = this.buildUrl(
+          `publishers/anthropic/models/${body.model}:rawPredict`,
+        );
+        requestBody = this.convertAnthropicBody(body);
+        break;
+      case "gemini":
+        url = this.buildUrl(
+          `publishers/google/models/${body.model}:generateContent`,
+        );
+        requestBody = this.convertGeminiBody(body, url);
+        break;
+      case "mistral":
+        url = this.buildUrl(
+          `publishers/mistralai/models/${body.model}:rawPredict`,
+        );
+        requestBody = body;
+        break;
+      default:
+        throw new Error(`Unsupported model: ${body.model}`);
+    }
+
+    const response = await customFetch(this.config.requestOptions)(
+      url.toString(),
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify(requestBody),
+        signal,
+      },
+    );
+
+    const data = await response.json();
+
+    if (!response.ok) {
+      throw new Error(
+        `VertexAI API error: ${response.status} ${response.statusText}\n${JSON.stringify(data)}`,
+      );
+    }
+
+    // Convert response to OpenAI format
+    switch (vertexProvider) {
+      case "anthropic":
+        return chatCompletion({
+          content: data.content?.[0]?.text || "",
+          model: body.model,
+        });
+      case "gemini":
+        return chatCompletion({
+          content: data.candidates?.[0]?.content?.parts?.[0]?.text || "",
+          model: body.model,
+        });
+      case "mistral":
+        return chatCompletion({
+          content: data.choices?.[0]?.message?.content || "",
+          model: body.model,
+        });
+      default:
+        throw new Error(`Unsupported provider: ${vertexProvider}`);
+    }
+  }
+
+  async *chatCompletionStream(
+    body: ChatCompletionCreateParamsStreaming,
+    signal: AbortSignal,
+  ): AsyncGenerator<ChatCompletionChunk> {
+    const vertexProvider = this.determineVertexProvider(body.model);
+
+    if (this.config.apiKey && vertexProvider !== "gemini") {
+      throw new Error(
+        "VertexAI: only gemini models are supported in express (apiKey) mode",
+      );
+    }
+
+    const headers = await this.getAuthHeaders();
+    let url: URL;
+    let requestBody: any;
+
+    switch (vertexProvider) {
+      case "anthropic":
+        url = this.buildUrl(
+          `publishers/anthropic/models/${body.model}:streamRawPredict`,
+        );
+        requestBody = this.convertAnthropicBody(body);
+        break;
+      case "gemini":
+        url = this.buildUrl(
+          `publishers/google/models/${body.model}:streamGenerateContent`,
+        );
+        requestBody = this.convertGeminiBody(body, url);
+        break;
+      case "mistral":
+        url = this.buildUrl(
+          `publishers/mistralai/models/${body.model}:streamRawPredict`,
+        );
+        requestBody = body;
+        break;
+      default:
+        throw new Error(`Unsupported model: ${body.model}`);
+    }
+
+    switch (vertexProvider) {
+      case "mistral":
+        const mistralResponse =
+          await this.mistralInstance.openai.chat.completions.create(
+            this.mistralInstance.modifyChatBody(body),
+            {
+              signal,
+              headers,
+            },
+          );
+        for await (const result of mistralResponse) {
+          yield result;
+        }
+        break;
+      case "anthropic":
+      case "gemini":
+        const response = await customFetch(this.config.requestOptions)(
+          url.toString(),
+          {
+            method: "POST",
+            headers,
+            body: JSON.stringify(requestBody),
+            signal,
+          },
+        );
+
+        if (!response.ok) {
+          const data = await response.json();
+          throw new Error(
+            `VertexAI API error: ${response.status} ${response.statusText}\n${JSON.stringify(data)}`,
+          );
+        }
+
+        if (response.status === 499) {
+          return; // Aborted by user
+        }
+        if (vertexProvider === "gemini") {
+          yield* this.geminiInstance.handleStreamResponse(response, body.model);
+        } else {
+          yield* this.anthropicInstance.handleStreamResponse(
+            response,
+            body.model,
+          );
+        }
+        break;
+    }
+  }
+
+  async completionNonStream(
+    body: CompletionCreateParamsNonStreaming,
+    signal: AbortSignal,
+  ): Promise<Completion> {
+    // Convert completion to chat completion and back
+    const promptText =
+      typeof body.prompt === "string"
+        ? body.prompt
+        : Array.isArray(body.prompt)
+          ? body.prompt.join("")
+          : "";
+
+    const chatBody: ChatCompletionCreateParamsNonStreaming = {
+      model: body.model,
+      messages: [{ role: "user", content: promptText }],
+      max_tokens: body.max_tokens,
+      temperature: body.temperature,
+      top_p: body.top_p,
+      stop: body.stop,
+      stream: false,
+    };
+
+    const chatResponse = await this.chatCompletionNonStream(chatBody, signal);
+
+    return {
+      id: chatResponse.id,
+      object: "text_completion",
+      created: chatResponse.created,
+      model: chatResponse.model,
+      choices: [
+        {
+          text: chatResponse.choices[0]?.message?.content || "",
+          index: 0,
+          logprobs: null,
+          finish_reason: chatResponse.choices[0]?.finish_reason || null,
+        },
+      ],
+      usage: chatResponse.usage,
+    } as Completion;
+  }
+
+  async *completionStream(
+    body: CompletionCreateParamsStreaming,
+    signal: AbortSignal,
+  ): AsyncGenerator<Completion> {
+    // Convert completion to chat completion and back
+    const promptText =
+      typeof body.prompt === "string"
+        ? body.prompt
+        : Array.isArray(body.prompt)
+          ? body.prompt.join("")
+          : "";
+
+    const chatBody: ChatCompletionCreateParamsStreaming = {
+      model: body.model,
+      messages: [{ role: "user", content: promptText }],
+      max_tokens: body.max_tokens,
+      temperature: body.temperature,
+      top_p: body.top_p,
+      stop: body.stop,
+      stream: true,
+    };
+
+    for await (const chatChunk of this.chatCompletionStream(chatBody, signal)) {
+      yield {
+        id: chatChunk.id,
+        object: "text_completion",
+        created: chatChunk.created,
+        model: chatChunk.model,
+        choices: [
+          {
+            text: chatChunk.choices[0]?.delta?.content || "",
+            index: 0,
+            logprobs: null,
+            finish_reason: chatChunk.choices[0]?.finish_reason || null,
+          },
+        ],
+      } as Completion;
+    }
+  }
+
+  async *fimStream(
+    body: FimCreateParamsStreaming,
+    signal: AbortSignal,
+  ): AsyncGenerator<ChatCompletionChunk> {
+    // Only Codestral (Mistral) supports FIM in VertexAI
+    if (!body.model.includes("codestral")) {
+      throw new Error(
+        `FIM is only supported for Codestral models, got: ${body.model}`,
+      );
+    }
+
+    const headers = await this.getAuthHeaders();
+    const url = this.buildUrl(
+      `publishers/mistralai/models/${body.model}:streamRawPredict`,
+    );
+
+    const requestBody = {
+      model: body.model,
+      max_tokens: body.max_tokens,
+      temperature: body.temperature,
+      top_p: body.top_p,
+      stream: body.stream ?? true,
+      stop: body.stop,
+      prompt: body.prompt,
+      suffix: body.suffix,
+    };
+
+    const response = await customFetch(this.config.requestOptions)(
+      url.toString(),
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify(requestBody),
+        signal,
+      },
+    );
+
+    if (!response.ok) {
+      throw new Error(
+        `VertexAI API error: ${response.status} ${response.statusText}`,
+      );
+    }
+
+    for await (const chunk of streamSse(response)) {
+      if (chunk.choices?.[0]?.delta?.content) {
+        yield chatChunk({
+          content: chunk.choices[0].delta.content,
+          model: body.model,
+        });
+      }
+    }
+  }
+
+  async embed(body: EmbeddingCreateParams): Promise<CreateEmbeddingResponse> {
+    const headers = await this.getAuthHeaders();
+    const url = this.buildUrl(`publishers/google/models/${body.model}:predict`);
+
+    // Convert input to text strings
+    const textInputs = Array.isArray(body.input)
+      ? body.input.map((item) =>
+          typeof item === "string" ? item : JSON.stringify(item),
+        )
+      : [
+          typeof body.input === "string"
+            ? body.input
+            : JSON.stringify(body.input),
+        ];
+
+    const requestBody = {
+      instances: textInputs.map((text) => ({ content: text })),
+    };
+
+    const response = await customFetch(this.config.requestOptions)(
+      url.toString(),
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify(requestBody),
+      },
+    );
+
+    if (!response.ok) {
+      throw new Error(
+        `VertexAI API error: ${response.status} ${response.statusText}`,
+      );
+    }
+
+    const data = await response.json();
+    const embeddings = data.predictions.map(
+      (prediction: any) => prediction.embeddings.values,
+    );
+
+    return embedding({
+      data: embeddings,
+      model: body.model,
+    });
+  }
+
+  async rerank(body: RerankCreateParams): Promise<CreateRerankResponse> {
+    throw new Error("Reranking is not supported by VertexAI");
+  }
+
+  async list(): Promise<Model[]> {
+    throw new Error("VertexAI provider does not support model listing.");
+  }
+}
diff --git a/packages/openai-adapters/src/index.ts b/packages/openai-adapters/src/index.ts
index 3e05fb15306..07f849f3375 100644
--- a/packages/openai-adapters/src/index.ts
+++ b/packages/openai-adapters/src/index.ts
@@ -14,6 +14,7 @@ import { MockApi } from "./apis/Mock.js";
 import { MoonshotApi } from "./apis/Moonshot.js";
 import { OpenAIApi } from "./apis/OpenAI.js";
 import { RelaceApi } from "./apis/Relace.js";
+import { VertexAIApi } from "./apis/VertexAI.js";
 import { WatsonXApi } from "./apis/WatsonX.js";
 import { BaseLlmApi } from "./apis/base.js";
 import { LLMConfig, OpenAIConfigSchema } from "./types.js";
@@ -56,6 +57,8 @@ export function constructLlmApi(config: LLMConfig): BaseLlmApi | undefined {
       return new InceptionApi(config);
     case "watsonx":
       return new WatsonXApi(config);
+    case "vertexai":
+      return new VertexAIApi(config);
     case "llamastack":
       return new LlamastackApi(config);
     case "continue-proxy":
diff --git a/packages/openai-adapters/src/types.ts b/packages/openai-adapters/src/types.ts
index 36da5936786..6786ec812c2 100644
--- a/packages/openai-adapters/src/types.ts
+++ b/packages/openai-adapters/src/types.ts
@@ -165,6 +165,19 @@ export const InceptionConfigSchema = OpenAIConfigSchema.extend({
 });
 export type InceptionConfig = z.infer<typeof InceptionConfigSchema>;
 
+export const VertexAIConfigSchema = BasePlusConfig.extend({
+  provider: z.literal("vertexai"),
+  env: z
+    .object({
+      region: z.string().optional(),
+      projectId: z.string().optional(),
+      keyFile: z.string().optional(),
+      keyJson: z.string().optional(),
+    })
+    .optional(),
+});
+export type VertexAIConfig = z.infer<typeof VertexAIConfigSchema>;
+
 // Discriminated union
 export const LLMConfigSchema = z.discriminatedUnion("provider", [
   OpenAIConfigSchema,
@@ -179,6 +192,7 @@ export const LLMConfigSchema = z.discriminatedUnion("provider", [
   JinaConfigSchema,
   MockConfigSchema,
   InceptionConfigSchema,
+  VertexAIConfigSchema,
   LlamastackConfigSchema,
   ContinueProxyConfigSchema,
 ]);
diff --git a/scripts/oneper b/scripts/oneper
new file mode 100755
index 00000000000..52ad8623aec
--- /dev/null
+++ b/scripts/oneper
@@ -0,0 +1,283 @@
+#!/usr/bin/env bash
+set -e
+
+# oneper - Install Continue VS Code extension from PR builds or latest pre-release
+# Usage:
+#   oneper install --pr X     - Install VSIX from PR number X
+#   oneper install --latest   - Install latest pre-release from marketplace
+
+REPO="continuedev/continue"
+ONEPER_DIR="$HOME/.continue/.utils/oneper"
+
+show_help() {
+    echo "oneper - Install Continue VS Code extension from PR builds or latest pre-release"
+    echo ""
+    echo "Usage: oneper <command> [options]"
+    echo "       oneper -h | --help"
+    echo ""
+    echo "Commands:"
+    echo "  install --pr <number> [--platform <platform>]"
+    echo "                           Download and install VSIX from specified PR number"
+    echo "                           Platform options: macos, linux (auto-detected by default)"
+    echo "  install --latest         Install latest pre-release from VS Code marketplace"
+    echo "  clean                    Remove all downloaded VSIX files from oneper cache"
+    echo ""
+    echo "Options:"
+    echo "  -h, --help              Show this help message"
+    echo "  --platform <platform>   Specify platform for PR builds (macos, linux)"
+    echo ""
+    echo "Examples:"
+    echo "  oneper install --pr 123              # Install VSIX from PR #123"
+    echo "  oneper install --pr 123 --platform linux   # Install Linux VSIX from PR #123"
+    echo "  oneper install --latest              # Install latest pre-release"
+    echo "  oneper clean                         # Clear cached VSIX files"
+    echo "  oneper -h                            # Show help"
+    echo ""
+    echo "VSIX files are cached in: ~/.continue/.utils/oneper/"
+}
+
+detect_os() {
+    case "$(uname -s)" in
+        "Darwin")
+            echo "macos"
+            ;;
+        "Linux")
+            echo "linux"
+            ;;
+        *)
+            echo "❌ Unsupported operating system: $(uname -s)" >&2
+            echo "   Supported platforms: macOS, Linux" >&2
+            exit 1
+            ;;
+    esac
+}
+
+check_dependencies() {
+    if ! command -v gh &> /dev/null; then
+        echo "❌ GitHub CLI (gh) is required but not installed."
+        echo "   Install with: brew install gh"
+        exit 1
+    fi
+
+    if ! command -v code &> /dev/null; then
+        echo "❌ VS Code CLI (code) is required but not installed."
+        echo "   Install VS Code and ensure 'code' command is in PATH"
+        exit 1
+    fi
+
+}
+
+ensure_oneper_dir() {
+    if [ ! -d "$ONEPER_DIR" ]; then
+        echo "📁 Creating oneper directory: $ONEPER_DIR"
+        mkdir -p "$ONEPER_DIR"
+    fi
+}
+
+install_from_pr() {
+    local pr_number=$1
+    local platform=${2:-$(detect_os)}  # Auto-detect OS if not specified
+
+    if [ -z "$pr_number" ]; then
+        echo "❌ PR number is required"
+        show_help
+        exit 1
+    fi
+
+    # Map platform names to GitHub runner OS names
+    local artifact_suffix
+    case "$platform" in
+        "macos")
+            artifact_suffix="macOS"
+            ;;
+        "linux")
+            artifact_suffix="Linux"
+            ;;
+        *)
+            echo "❌ Unknown platform: $platform"
+            echo "   Supported platforms: macos, linux"
+            exit 1
+            ;;
+    esac
+
+    echo "🔍 Getting branch name for PR #$pr_number..."
+
+    # First get the branch name for the PR
+    local branch_name=$(gh pr view "$pr_number" --repo "$REPO" --json headRefName --jq '.headRefName')
+
+    if [ -z "$branch_name" ]; then
+        echo "❌ Could not find PR #$pr_number"
+        exit 1
+    fi
+
+    echo "🔍 Finding latest workflow run for branch: $branch_name..."
+
+    # Get the latest successful workflow run for the branch
+    local run_id=$(gh run list \
+        --repo "$REPO" \
+        --workflow="pr_checks.yaml" \
+        --branch="$branch_name" \
+        --json databaseId,status,conclusion \
+        --jq ".[] | select(.status == \"completed\" and .conclusion == \"success\") | .databaseId" \
+        | head -1)
+
+    if [ -z "$run_id" ]; then
+        echo "❌ No successful workflow run found for PR #$pr_number"
+        echo "   Make sure the PR exists and has a successful CI run"
+        exit 1
+    fi
+
+    echo "✅ Found workflow run: $run_id"
+    echo "📥 Downloading vscode-extension-build-$artifact_suffix artifact..."
+
+    # Create temporary directory for download
+    local temp_dir=$(mktemp -d)
+
+    # Download the artifact
+    if ! gh run download "$run_id" \
+        --repo "$REPO" \
+        --name "vscode-extension-build-$artifact_suffix" \
+        --dir "$temp_dir"; then
+        echo "❌ Failed to download artifact vscode-extension-build-$artifact_suffix"
+        echo "   Make sure the workflow run completed successfully for $platform"
+        rm -rf "$temp_dir"
+        exit 1
+    fi
+
+    # Find the VSIX file in the downloaded artifact
+    local vsix_file=$(find "$temp_dir" -name "*.vsix" | head -1)
+
+    if [ -z "$vsix_file" ]; then
+        echo "❌ No VSIX file found in artifact"
+        rm -rf "$temp_dir"
+        exit 1
+    fi
+
+    # Extract version from the original VSIX filename (e.g., continue-1.1.66.vsix -> 1.1.66)
+    local original_filename=$(basename "$vsix_file")
+    local version=$(echo "$original_filename" | sed 's/continue-\(.*\)\.vsix/\1/')
+
+    if [ -z "$version" ]; then
+        echo "⚠️  Could not extract version from filename: $original_filename"
+        version="unknown"
+    fi
+
+    # Create new VSIX name with version and PR number
+    local target_path="$ONEPER_DIR/continue-${version}-${pr_number}.vsix"
+
+    # Check if file already exists and notify about overwrite
+    if [ -f "$target_path" ]; then
+        echo "⚠️  Overwriting existing VSIX: $target_path"
+    fi
+
+    echo "📦 Moving VSIX to: $target_path"
+    mv "$vsix_file" "$target_path"
+
+    # Clean up temp directory
+    rm -rf "$temp_dir"
+
+    # Install the extension
+    echo "🚀 Installing VS Code extension..."
+    if code --install-extension "$target_path"; then
+        echo "✅ Successfully installed Continue extension from PR #$pr_number"
+        echo "📄 VSIX file saved to: $target_path"
+        echo ""
+        echo "💡 To use the new extension version, reload your VS Code window:"
+        echo "   • Press Ctrl+Shift+P (Cmd+Shift+P on Mac)"
+        echo "   • Type 'Developer: Reload Window' and press Enter"
+        echo "   • Or restart VS Code entirely"
+    else
+        echo "❌ Failed to install extension"
+        exit 1
+    fi
+}
+
+install_latest() {
+    echo "🚀 Installing latest pre-release Continue extension..."
+    if code --install-extension --pre-release Continue.continue; then
+        echo "✅ Successfully installed latest pre-release Continue extension"
+        echo ""
+        echo "💡 To use the new extension version, reload your VS Code window:"
+        echo "   • Press Ctrl+Shift+P (Cmd+Shift+P on Mac)"
+        echo "   • Type 'Developer: Reload Window' and press Enter"
+        echo "   • Or restart VS Code entirely"
+    else
+        echo "❌ Failed to install extension"
+        exit 1
+    fi
+}
+
+clean_cache() {
+    if [ ! -d "$ONEPER_DIR" ]; then
+        echo "📁 Oneper cache directory doesn't exist: $ONEPER_DIR"
+        return 0
+    fi
+
+    local file_count=$(find "$ONEPER_DIR" -name "*.vsix" | wc -l | tr -d ' ')
+
+    if [ "$file_count" -eq 0 ]; then
+        echo "✨ Oneper cache is already empty"
+        return 0
+    fi
+
+    echo "🧹 Removing $file_count VSIX file(s) from oneper cache..."
+    rm -f "$ONEPER_DIR"/*.vsix
+
+    echo "✅ Oneper cache cleared successfully"
+    echo "📁 Cache directory: $ONEPER_DIR"
+}
+
+main() {
+    if [ $# -eq 0 ]; then
+        show_help
+        exit 1
+    fi
+
+    # Handle help flags first
+    case "$1" in
+        "-h"|"--help")
+            show_help
+            exit 0
+            ;;
+    esac
+
+    check_dependencies
+    ensure_oneper_dir
+
+    case "$1" in
+        "install")
+            case "$2" in
+                "--pr")
+                    # Parse PR number and optional platform
+                    local pr_number="$3"
+                    local platform=$(detect_os)  # auto-detect OS
+
+                    # Check if --platform is specified to override auto-detection
+                    if [ "$4" = "--platform" ] && [ -n "$5" ]; then
+                        platform="$5"
+                    fi
+
+                    install_from_pr "$pr_number" "$platform"
+                    ;;
+                "--latest")
+                    install_latest
+                    ;;
+                *)
+                    echo "❌ Unknown install option: $2"
+                    show_help
+                    exit 1
+                    ;;
+            esac
+            ;;
+        "clean")
+            clean_cache
+            ;;
+        *)
+            echo "❌ Unknown command: $1"
+            show_help
+            exit 1
+            ;;
+    esac
+}
+
+main "$@"
\ No newline at end of file