opencode-rag-plugin 1.18.1 → 1.19.0

package/dist/quirks/quirk-store.d.ts

@@ -20,8 +20,25 @@ export declare function recallQuirks(deps: QuirkStoreDeps, query: string, option
     topK?: number;
     quirkType?: string;
     tags?: string[];
+    /** Override recallMinScore from config. Used by auto-inject for a lower threshold. */
+    minScore?: number;
 }): Promise<SearchResult[]>;
 /** Lint quirks for low confidence, staleness, duplicates, and orphan source refs. */
 export declare function lintQuirks(deps: QuirkStoreDeps): Promise<string[]>;
 /** Simple Jaccard-based lexical similarity (word overlap). */
 export declare function lexicalSimilarity(a: string, b: string): number;
+/**
+ * Count of meaningful word tokens shared between two texts (Jaccard numerator).
+ *
+ * Tokens are whitespace/punctuation-split, lowercased, and filtered to those
+ * with length ≥ `minTokenLen` (default 3 — skips short filler like "the").
+ *
+ * Used by the quirk auto-inject gate: candidate quirks that share no tokens
+ * with the user's *current* message (i.e. they matched only against the prior
+ * assistant text in the combined recall query) are filtered out. This prevents
+ * meta-quirks (quirks about quirks themselves) from being injected into
+ * unrelated tasks, e.g. when the agent previously explained how quirks work.
+ *
+ * Set `memory.autoInjectMinTokenOverlap` to `0` to disable the gate.
+ */
+export declare function sharedWords(a: string, b: string, minTokenLen?: number): number;

package/dist/quirks/quirk-store.js

@@ -146,13 +146,13 @@ export async function recallQuirks(deps, query, options) {
     if (options?.quirkType) {
         filter.languages = [options.quirkType];
     }
-    const recallMinScore = deps.cfg.memory?.recallMinScore ?? 0.72;
+    const recallMinScore = options?.minScore ?? deps.cfg.memory?.recallMinScore ?? 0.72;
     const raw = await retrieve(query, deps.embedder, deps.store, {
         topK: topK * 3,
         minScore: recallMinScore,
         keywordIndex: deps.keywordIndex,
         keywordWeight: deps.cfg.retrieval.hybridSearch?.keywordWeight,
-        hybridEnabled: false,
+        hybridEnabled: true,
         queryPrefix: deps.cfg.embedding.queryPrefix,
         filter,
     });
@@ -185,13 +185,13 @@ export async function lintQuirks(deps) {
     const cfg = deps.cfg.memory;
     for (const q of quirks) {
         if (q.confidence < (cfg?.minConfidence ?? 0.5)) {
-            issues.push(`Low confidence (${q.confidence}): "${q.content.slice(0, 60)}..." [${q.id}]`);
+            issues.push(`Low confidence (${q.confidence}): "${q.content}" [${q.id}]`);
         }
         if (cfg?.decay?.enabled && q.lastObserved) {
             const ageDays = (Date.now() - new Date(q.lastObserved).getTime()) / 86_400_000;
             const halfLife = cfg.decay.halfLifeDays;
             if (halfLife > 0 && ageDays > halfLife * 2) {
-                issues.push(`Stale (${Math.round(ageDays)}d old): "${q.content.slice(0, 60)}..." [${q.id}]`);
+                issues.push(`Stale (${Math.round(ageDays)}d old): "${q.content}" [${q.id}]`);
             }
         }
     }
@@ -200,7 +200,7 @@ export async function lintQuirks(deps) {
         for (let j = i + 1; j < quirks.length; j++) {
             const sim = lexicalSimilarity(quirks[i].content, quirks[j].content);
             if (sim > 0.85) {
-                issues.push(`Near-duplicate (${(sim * 100).toFixed(0)}% similar): "${quirks[i].content.slice(0, 50)}..." ↔ "${quirks[j].content.slice(0, 50)}..."`);
+                issues.push(`Near-duplicate (${(sim * 100).toFixed(0)}% similar): "${quirks[i].content}" ↔ "${quirks[j].content}"`);
             }
         }
     }
@@ -214,4 +214,31 @@ export function lexicalSimilarity(a, b) {
     const union = new Set([...wordsA, ...wordsB]);
     return union.size === 0 ? 0 : intersection.size / union.size;
 }
+/**
+ * Count of meaningful word tokens shared between two texts (Jaccard numerator).
+ *
+ * Tokens are whitespace/punctuation-split, lowercased, and filtered to those
+ * with length ≥ `minTokenLen` (default 3 — skips short filler like "the").
+ *
+ * Used by the quirk auto-inject gate: candidate quirks that share no tokens
+ * with the user's *current* message (i.e. they matched only against the prior
+ * assistant text in the combined recall query) are filtered out. This prevents
+ * meta-quirks (quirks about quirks themselves) from being injected into
+ * unrelated tasks, e.g. when the agent previously explained how quirks work.
+ *
+ * Set `memory.autoInjectMinTokenOverlap` to `0` to disable the gate.
+ */
+export function sharedWords(a, b, minTokenLen = 3) {
+    const tokensA = a.toLowerCase().split(/\W+/).filter((w) => w.length >= minTokenLen);
+    const wordsB = new Set(b.toLowerCase().split(/\W+/).filter((w) => w.length >= minTokenLen));
+    let count = 0;
+    const seen = new Set();
+    for (const tok of tokensA) {
+        if (wordsB.has(tok) && !seen.has(tok)) {
+            seen.add(tok);
+            count++;
+        }
+    }
+    return count;
+}
 //# sourceMappingURL=quirk-store.js.map

package/dist/tui.js

@@ -345,10 +345,16 @@ function buildSettingCategories(cfg, ro, providers) {
     const docModeRo = (ro.documentationMode ?? {});
     const wikiModeCfg = (cfg.wikiMode ?? {});
     const wikiModeRo = (ro.wikiMode ?? {});
+    const memoryCfg = (cfg.memory ?? {});
+    const memoryRo = (ro.memory ?? {});
     const embeddingCfg = (cfg.embedding ?? {});
     const embeddingRo = (ro.embedding ?? {});
     const tuiCfg = (cfg.tui ?? {});
     const tuiRo = (ro.tui ?? {});
+    const indexingCfg = (cfg.indexing ?? {});
+    const indexingRo = (ro.indexing ?? {});
+    const chunkingCfg = (cfg.chunking ?? {});
+    const chunkingRo = (ro.chunking ?? {});
     const modelOptions = providers ? buildModelOptions(providers) : undefined;
     function displayModel(roProvider, roModel, cfgProvider, cfgModel, defaultProvider, defaultModel) {
         const p = roProvider ?? cfgProvider ?? defaultProvider;
@@ -416,6 +422,31 @@ function buildSettingCategories(cfg, ro, providers) {
                 },
             ],
         },
+        {
+            id: "chunking",
+            label: "Chunking",
+            description: "Configure how files are split into chunks",
+            entries: [
+                {
+                    path: ["indexing", "chunkOverlap"],
+                    label: "Chunk overlap (lines)",
+                    type: "number",
+                    currentValue: indexingRo.chunkOverlap ?? indexingCfg.chunkOverlap ?? 0,
+                },
+                {
+                    path: ["indexing", "maxSvgSizeBytes"],
+                    label: "Max SVG size (bytes)",
+                    type: "number",
+                    currentValue: indexingRo.maxSvgSizeBytes ?? indexingCfg.maxSvgSizeBytes ?? 1_048_576,
+                },
+                {
+                    path: ["chunking", "nodeTypes"],
+                    label: "Node types (JSON)",
+                    type: "json",
+                    currentValue: chunkingRo.nodeTypes ?? chunkingCfg.nodeTypes ?? {},
+                },
+            ],
+        },
         {
             id: "embedding",
             label: "Embedding",
@@ -488,6 +519,67 @@ function buildSettingCategories(cfg, ro, providers) {
                 },
             ],
         },
+        {
+            id: "memory",
+            label: "Quirk Memory",
+            description: "Configure experiential memory — gotchas, preferences, decisions recalled across sessions",
+            entries: [
+                {
+                    path: ["memory", "enabled"],
+                    label: "Quirk memory enabled",
+                    type: "boolean",
+                    currentValue: memoryRo.enabled ?? memoryCfg.enabled ?? true,
+                },
+                {
+                    path: ["memory", "autoInject"],
+                    label: "Auto-inject quirks",
+                    type: "boolean",
+                    currentValue: memoryRo.autoInject ?? memoryCfg.autoInject ?? false,
+                },
+                {
+                    path: ["memory", "recallMinScore"],
+                    label: "User prompt min score",
+                    type: "number",
+                    currentValue: memoryRo.recallMinScore ?? memoryCfg.recallMinScore ?? 0.72,
+                },
+                {
+                    path: ["memory", "autoInjectMinScore"],
+                    label: "System prompt min score",
+                    type: "number",
+                    currentValue: memoryRo.autoInjectMinScore ?? memoryCfg.autoInjectMinScore ?? 0.6,
+                },
+                {
+                    path: ["memory", "autoInjectLatencyBudgetMs"],
+                    label: "Latency budget (ms)",
+                    type: "number",
+                    currentValue: memoryRo.autoInjectLatencyBudgetMs ?? memoryCfg.autoInjectLatencyBudgetMs ?? 2000,
+                },
+                {
+                    path: ["memory", "minConfidence"],
+                    label: "Min confidence",
+                    type: "number",
+                    currentValue: memoryRo.minConfidence ?? memoryCfg.minConfidence ?? 0.5,
+                },
+                {
+                    path: ["memory", "passiveCapture"],
+                    label: "Passive capture",
+                    type: "boolean",
+                    currentValue: memoryRo.passiveCapture ?? memoryCfg.passiveCapture ?? false,
+                },
+                {
+                    path: ["memory", "promptEnforcement"],
+                    label: "Prompt enforcement",
+                    type: "boolean",
+                    currentValue: memoryRo.promptEnforcement ?? memoryCfg.promptEnforcement ?? true,
+                },
+                {
+                    path: ["memory", "sessionEndExtraction"],
+                    label: "Session-end extraction",
+                    type: "boolean",
+                    currentValue: memoryRo.sessionEndExtraction ?? memoryCfg.sessionEndExtraction ?? true,
+                },
+            ],
+        },
         {
             id: "keybindings",
             label: "Keybindings",
@@ -564,7 +656,7 @@ async function openSettingsDialog(api) {
     function showSettingMenu(cat) {
         const options = [
             ...cat.entries.map((s) => ({
-                title: `${s.label}: ${s.type === "boolean" ? (s.currentValue ? "Yes" : "No") : String(s.currentValue)}`,
+                title: `${s.label}: ${s.type === "boolean" ? (s.currentValue ? "Yes" : "No") : s.type === "json" ? JSON.stringify(s.currentValue) : String(s.currentValue)}`,
                 value: s.path.join("."),
                 description: s.options ? "Select to open model picker" : (s.type === "boolean" ? "Select to toggle" : "Select to edit"),
             })),
@@ -594,6 +686,9 @@ async function openSettingsDialog(api) {
                         title: "Settings",
                         message: `${entry.label}: ${newVal ? "Yes" : "No"}`,
                     });
+                    if (entry.path[0] === "indexing" || entry.path[0] === "chunking") {
+                        api.ui.toast({ variant: "warning", title: "Settings", message: "Chunking changed. Re-index required." });
+                    }
                     entry.currentValue = newVal;
                     showSettingMenu(cat);
                 }
@@ -612,6 +707,9 @@ async function openSettingsDialog(api) {
                                     title: "Settings",
                                     message: `${entry.label}: ${num}`,
                                 });
+                                if (entry.path[0] === "indexing" || entry.path[0] === "chunking") {
+                                    api.ui.toast({ variant: "warning", title: "Settings", message: "Chunking changed. Re-index required." });
+                                }
                                 entry.currentValue = num;
                             }
                             showSettingMenu(cat);
@@ -621,6 +719,41 @@ async function openSettingsDialog(api) {
                         },
                     }));
                 }
+                else if (entry.type === "json") {
+                    api.ui.dialog.replace(() => api.ui.DialogPrompt({
+                        title: `Edit ${entry.label}`,
+                        placeholder: "JSON",
+                        value: JSON.stringify(entry.currentValue, null, 2),
+                        onConfirm: (input) => {
+                            try {
+                                const parsed = JSON.parse(input);
+                                if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+                                    api.ui.toast({ variant: "error", title: "Settings", message: "Value must be a JSON object" });
+                                    showSettingMenu(cat);
+                                    return;
+                                }
+                                saveRuntimeOverride(storePath, entry.path, parsed);
+                                saveConfigValue(configPath, entry.path, parsed);
+                                api.ui.toast({
+                                    variant: "success",
+                                    title: "Settings",
+                                    message: `${entry.label}: updated`,
+                                });
+                                if (entry.path[0] === "indexing" || entry.path[0] === "chunking") {
+                                    api.ui.toast({ variant: "warning", title: "Settings", message: "Chunking changed. Re-index required." });
+                                }
+                                entry.currentValue = parsed;
+                            }
+                            catch {
+                                api.ui.toast({ variant: "error", title: "Settings", message: "Invalid JSON" });
+                            }
+                            showSettingMenu(cat);
+                        },
+                        onCancel: () => {
+                            showSettingMenu(cat);
+                        },
+                    }));
+                }
                 else {
                     api.ui.dialog.replace(() => api.ui.DialogPrompt({
                         title: `Edit ${entry.label}`,

package/dist/vectorstore/lancedb.d.ts

@@ -90,6 +90,20 @@ export declare class LanceDbStore implements VectorStore {
      * @returns An array of chunk summaries.
      */
     getChunks(offset: number, limit: number): Promise<ChunkSummary[]>;
+    /**
+     * Fetch chunks with their embedding vectors included (for embedding projection).
+     * @param limit - Maximum number of rows to return.
+     * @returns Array of { id, filePath, language, startLine, endLine, description, embedding }.
+     */
+    getChunksWithEmbeddings(limit: number): Promise<{
+        id: string;
+        filePath: string;
+        language: string;
+        startLine: number;
+        endLine: number;
+        description: string;
+        embedding: number[];
+    }[]>;
     /**
      * Perform ANN search internally, returning results scored as cosine similarity (0-1).
      * This method is called by `search()` and handles the actual query logic.
@@ -157,5 +171,24 @@ export declare class LanceDbStore implements VectorStore {
      */
     deleteByFilePath(filePath: string): Promise<void>;
     private deleteByFilePathInternal;
+    /**
+     * Verify that data in the store is actually readable.
+     * Reads the `content` column (a large text field stored in data fragments,
+     * not in the version manifest) for the first few rows.  If any of the
+     * underlying `.lance` data files are missing from disk, LanceDB throws a
+     * corruption error ("Not found: ... .lance") and we return false.
+     *
+     * This catches silent corruption where countRows() returns metadata from
+     * the version manifest while the actual row data on disk is gone.
+     */
+    checkIntegrity(): Promise<boolean>;
+    /**
+     * Execute an async function with automatic corruption recovery.
+     * If the function throws a LanceDB corruption error, tryRepair() is run
+     * and the function is retried once.  If repair fails, the original error
+     * is re-thrown so callers/higher layers can handle it (e.g. return
+     * fallback data, clear the manifest, or trigger a rebuild).
+     */
+    private withCorruptionRecovery;
     private tryRepair;
 }

package/dist/vectorstore/lancedb.js

@@ -384,26 +384,28 @@ export class LanceDbStore {
      * @returns An array of file summaries sorted by file path.
      */
     async listFiles() {
-        const table = await this.getTable();
-        const count = await table.countRows();
-        if (count === 0)
-            return [];
-        const rows = await table.query().select(["filePath", "language"]).limit(count).toArray();
-        const fileMap = new Map();
-        for (const row of rows) {
-            const filePath = row.filePath;
-            const language = row.language;
-            const existing = fileMap.get(filePath);
-            if (existing) {
-                existing.chunkCount++;
-            }
-            else {
-                fileMap.set(filePath, { language, chunkCount: 1 });
+        return this.withCorruptionRecovery(async () => {
+            const table = await this.getTable();
+            const count = await table.countRows();
+            if (count === 0)
+                return [];
+            const rows = await table.query().select(["filePath", "language"]).limit(count).toArray();
+            const fileMap = new Map();
+            for (const row of rows) {
+                const filePath = row.filePath;
+                const language = row.language;
+                const existing = fileMap.get(filePath);
+                if (existing) {
+                    existing.chunkCount++;
+                }
+                else {
+                    fileMap.set(filePath, { language, chunkCount: 1 });
+                }
             }
-        }
-        return Array.from(fileMap.entries())
-            .map(([filePath, info]) => ({ filePath, ...info }))
-            .sort((a, b) => a.filePath.localeCompare(b.filePath));
+            return Array.from(fileMap.entries())
+                .map(([filePath, info]) => ({ filePath, ...info }))
+                .sort((a, b) => a.filePath.localeCompare(b.filePath));
+        });
     }
     /**
      * Retrieve all chunks for a specific file path, sorted by start line.
@@ -411,39 +413,41 @@ export class LanceDbStore {
      * @returns An array of chunks for that file.
      */
     async getChunksByFilePath(filePath) {
-        const table = await this.getTable();
-        const normalizedPath = normalizeFilePath(filePath).replace(/'/g, "''");
-        const rows = await table.query()
-            .select(QUERY_COLUMNS)
-            .where(`filePath = '${normalizedPath}'`)
-            .toArray();
-        return rows
-            .map((row) => {
-            let tags;
-            try {
-                const raw = row.tags;
-                if (raw)
-                    tags = JSON.parse(raw);
-            }
-            catch {
-                tags = undefined;
-            }
-            return {
-                id: row.id,
-                content: row.content,
-                description: row.description ?? "",
-                metadata: {
-                    filePath: row.filePath,
-                    startLine: row.startLine,
-                    endLine: row.endLine,
-                    language: row.language,
-                    kind: row.kind || undefined,
-                    quirkType: row.quirkType || undefined,
-                    tags,
-                },
-            };
-        })
-            .sort((a, b) => a.metadata.startLine - b.metadata.startLine);
+        return this.withCorruptionRecovery(async () => {
+            const table = await this.getTable();
+            const normalizedPath = normalizeFilePath(filePath).replace(/'/g, "''");
+            const rows = await table.query()
+                .select(QUERY_COLUMNS)
+                .where(`filePath = '${normalizedPath}'`)
+                .toArray();
+            return rows
+                .map((row) => {
+                let tags;
+                try {
+                    const raw = row.tags;
+                    if (raw)
+                        tags = JSON.parse(raw);
+                }
+                catch {
+                    tags = undefined;
+                }
+                return {
+                    id: row.id,
+                    content: row.content,
+                    description: row.description ?? "",
+                    metadata: {
+                        filePath: row.filePath,
+                        startLine: row.startLine,
+                        endLine: row.endLine,
+                        language: row.language,
+                        kind: row.kind || undefined,
+                        quirkType: row.quirkType || undefined,
+                        tags,
+                    },
+                };
+            })
+                .sort((a, b) => a.metadata.startLine - b.metadata.startLine);
+        });
     }
     /**
      * Retrieve a paginated list of all chunks without embeddings.
@@ -452,24 +456,51 @@ export class LanceDbStore {
      * @returns An array of chunk summaries.
      */
     async getChunks(offset, limit) {
-        const table = await this.getTable();
-        const rows = await table.query()
-            .select(QUERY_COLUMNS)
-            .offset(offset)
-            .limit(limit)
-            .toArray();
-        return rows.map((row) => ({
-            id: row.id,
-            filePath: row.filePath,
-            language: row.language,
-            startLine: row.startLine,
-            endLine: row.endLine,
-            content: row.content,
-            description: row.description ?? "",
-            kind: row.kind ?? "",
-            quirkType: row.quirkType ?? "",
-            tags: row.tags ?? "",
-        }));
+        return this.withCorruptionRecovery(async () => {
+            const table = await this.getTable();
+            const rows = await table.query()
+                .select(QUERY_COLUMNS)
+                .offset(offset)
+                .limit(limit)
+                .toArray();
+            return rows.map((row) => ({
+                id: row.id,
+                filePath: row.filePath,
+                language: row.language,
+                startLine: row.startLine,
+                endLine: row.endLine,
+                content: row.content,
+                description: row.description ?? "",
+                kind: row.kind ?? "",
+                quirkType: row.quirkType ?? "",
+                tags: row.tags ?? "",
+            }));
+        });
+    }
+    /**
+     * Fetch chunks with their embedding vectors included (for embedding projection).
+     * @param limit - Maximum number of rows to return.
+     * @returns Array of { id, filePath, language, startLine, endLine, description, embedding }.
+     */
+    async getChunksWithEmbeddings(limit) {
+        return this.withCorruptionRecovery(async () => {
+            const table = await this.getTable();
+            const rows = await table.query()
+                .select([...QUERY_COLUMNS, "embedding"])
+                .limit(limit)
+                .toArray();
+            return rows
+                .filter((r) => r.embedding && typeof r.embedding === "object")
+                .map((row) => ({
+                id: row.id,
+                filePath: row.filePath,
+                language: row.language,
+                startLine: row.startLine,
+                endLine: row.endLine,
+                description: row.description ?? "",
+                embedding: Array.from(row.embedding),
+            }));
+        });
     }
     /**
      * Perform ANN search internally, returning results scored as cosine similarity (0-1).
@@ -548,7 +579,13 @@ export class LanceDbStore {
     async optimize() {
         try {
             const table = await this.getTable();
-            await table.optimize({ cleanupOlderThan: new Date(), deleteUnverified: false });
+            // Clean up versions older than 1 hour — not "right now" — so in-flight
+            // queries (e.g. Web UI search, background auto-index) can finish before
+            // their data files are reclaimed.  Using new Date() here caused data-file
+            // race conditions where a reader got "Not found: … .lance" because the
+            // GC deleted fragments that the current version still referenced.
+            const threshold = new Date(Date.now() - 60 * 60 * 1000);
+            await table.optimize({ cleanupOlderThan: threshold, deleteUnverified: false });
         }
         catch {
             // Optimize is best-effort — must not break indexing.
@@ -564,15 +601,17 @@ export class LanceDbStore {
             const tableNames = await db.tableNames();
             if (!tableNames.includes(TABLE_NAME))
                 return [];
-            const table = await this.getTable();
-            const rows = await table.query().select(["filePath"]).toArray();
-            const paths = new Set();
-            for (const row of rows) {
-                const fp = row.filePath;
-                if (fp)
-                    paths.add(fp);
-            }
-            return Array.from(paths);
+            return this.withCorruptionRecovery(async () => {
+                const table = await this.getTable();
+                const rows = await table.query().select(["filePath"]).toArray();
+                const paths = new Set();
+                for (const row of rows) {
+                    const fp = row.filePath;
+                    if (fp)
+                        paths.add(fp);
+                }
+                return Array.from(paths);
+            });
         }
         catch {
             return [];
@@ -708,6 +747,56 @@ export class LanceDbStore {
         const normalizedPath = normalizeFilePath(filePath).replace(/'/g, "''");
         await table.delete(`filePath = '${normalizedPath}'`);
     }
+    /**
+     * Verify that data in the store is actually readable.
+     * Reads the `content` column (a large text field stored in data fragments,
+     * not in the version manifest) for the first few rows.  If any of the
+     * underlying `.lance` data files are missing from disk, LanceDB throws a
+     * corruption error ("Not found: ... .lance") and we return false.
+     *
+     * This catches silent corruption where countRows() returns metadata from
+     * the version manifest while the actual row data on disk is gone.
+     */
+    async checkIntegrity() {
+        try {
+            const db = await this.getDb();
+            const tableNames = await db.tableNames();
+            if (!tableNames.includes(TABLE_NAME))
+                return true;
+            const table = await this.getTable();
+            const count = await table.countRows();
+            if (count === 0)
+                return true;
+            // Read the `content` column (stored in data fragments, not in the
+            // version manifest) for the first few rows.  If a fragment is
+            // missing, LanceDB will fail with a "Not found" corruption error.
+            const rows = await table.query().select(["id", "content"]).limit(10).toArray();
+            return rows.length > 0;
+        }
+        catch (err) {
+            if (isCorruptionError(err))
+                return false;
+            return true;
+        }
+    }
+    /**
+     * Execute an async function with automatic corruption recovery.
+     * If the function throws a LanceDB corruption error, tryRepair() is run
+     * and the function is retried once.  If repair fails, the original error
+     * is re-thrown so callers/higher layers can handle it (e.g. return
+     * fallback data, clear the manifest, or trigger a rebuild).
+     */
+    async withCorruptionRecovery(fn) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            if (isCorruptionError(err) && await this.tryRepair()) {
+                return fn();
+            }
+            throw err;
+        }
+    }
     async tryRepair() {
         try {
             this.table = null;

package/dist/web/api.d.ts

@@ -5,6 +5,7 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { LanceDbStore } from "../vectorstore/lancedb.js";
 import { KeywordIndex } from "../retriever/keyword-index.js";
 import type { RagConfig } from "../core/config.js";
+import type { EmbeddingProvider } from "../core/interfaces.js";
 /** Internal shape for a JSON API response: an HTTP status code and a serialisable body. */
 interface ApiResponse {
     status: number;
@@ -27,7 +28,7 @@ interface ApiResponse {
  * @param cfg          - Active RAG configuration (used by quirk endpoints).
  * @returns An async handler that returns `true` when a route matched or `false` otherwise.
  */
-export declare function createApiHandler(store: LanceDbStore, keywordIndex: KeywordIndex, storePath: string, cwd?: string, cfg?: RagConfig): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
+export declare function createApiHandler(store: LanceDbStore, keywordIndex: KeywordIndex, storePath: string, cwd?: string, cfg?: RagConfig, getEmbedder?: () => Promise<EmbeddingProvider>): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
 /**
  * Perform token-usage analysis for a single evaluation session.
  *