pi-vault-mind 0.14.2 → 0.16.3

package/dist/src/config-keys.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Canonical flat key paths for vaultMind config access.
+ *
+ * This is the SINGLE SOURCE OF TRUTH for config key string literals used
+ * by the setup wizard, CLI, HTTP server, and Obsidian plugin. When a field
+ * is renamed in src/types.ts, update ONLY this file and regenerate the JSON
+ * (scripts/generate-config-keys-json.mjs).
+ *
+ * Two shapes are provided:
+ *   - EMBEDDING_FLAT_KEYS: bare key names on vaultMind.embedding (for dynamic access)
+ *   - VAULT_MIND_CONFIG_KEYS: fully-qualified dotted paths (for static access)
+ */
+/** Bare key names on vaultMind.embedding — used by setup wizard, CLI, HTTP, and plugin. */
+export declare const EMBEDDING_FLAT_KEYS: readonly ["remoteUrl", "localUrl", "model", "apiKey", "dim", "useTransformers", "workspace", "remoteApiKey", "remoteReadApiKey", "remoteWriteApiKey", "fallback", "sync", "collectionModels", "coalesce"];
+/** Fully-qualified dotted key paths that the plugin's reconfigure form reads/writes. */
+export declare const VAULT_MIND_CONFIG_KEYS: readonly ["vaultMind.embedding.remoteUrl", "vaultMind.embedding.localUrl", "vaultMind.embedding.model", "vaultMind.embedding.workspace", "vaultMind.embedding.dim", "vaultMind.embedding.useTransformers", "vaultMind.embedding.remoteApiKey", "vaultMind.embedding.fallback", "vaultMind.embedding.sync", "vaultMind.ftsEnabled", "vaultMind.graph", "vaultMind.vaults.default.autoStart", "extensionCompatibility.pi-context.enabled"];

package/dist/src/config-keys.js

@@ -0,0 +1,45 @@
+/**
+ * Canonical flat key paths for vaultMind config access.
+ *
+ * This is the SINGLE SOURCE OF TRUTH for config key string literals used
+ * by the setup wizard, CLI, HTTP server, and Obsidian plugin. When a field
+ * is renamed in src/types.ts, update ONLY this file and regenerate the JSON
+ * (scripts/generate-config-keys-json.mjs).
+ *
+ * Two shapes are provided:
+ *   - EMBEDDING_FLAT_KEYS: bare key names on vaultMind.embedding (for dynamic access)
+ *   - VAULT_MIND_CONFIG_KEYS: fully-qualified dotted paths (for static access)
+ */
+/** Bare key names on vaultMind.embedding — used by setup wizard, CLI, HTTP, and plugin. */
+export const EMBEDDING_FLAT_KEYS = [
+    "remoteUrl",
+    "localUrl",
+    "model",
+    "apiKey",
+    "dim",
+    "useTransformers",
+    "workspace",
+    "remoteApiKey",
+    "remoteReadApiKey",
+    "remoteWriteApiKey",
+    "fallback",
+    "sync",
+    "collectionModels",
+    "coalesce",
+];
+/** Fully-qualified dotted key paths that the plugin's reconfigure form reads/writes. */
+export const VAULT_MIND_CONFIG_KEYS = [
+    "vaultMind.embedding.remoteUrl",
+    "vaultMind.embedding.localUrl",
+    "vaultMind.embedding.model",
+    "vaultMind.embedding.workspace",
+    "vaultMind.embedding.dim",
+    "vaultMind.embedding.useTransformers",
+    "vaultMind.embedding.remoteApiKey",
+    "vaultMind.embedding.fallback",
+    "vaultMind.embedding.sync",
+    "vaultMind.ftsEnabled",
+    "vaultMind.graph",
+    "vaultMind.vaults.default.autoStart",
+    "extensionCompatibility.pi-context.enabled",
+];

package/dist/src/discover-schema.js

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { Type } from "typebox";
-import { ensureDir, findConfig } from "./utils.js";
+import { ensureDir, getConfigPath } from "./utils.js";
 /** Infer a single JSON value's type. */
 export const inferType = (value) => {
     if (value === null || value === undefined)
@@ -88,7 +88,7 @@ export const discoverSchemaFromFile = (filePath, sample = 100) => {
 };
 /** Read the mutable project config object, or an empty object if none exists. */
 const readProjectConfig = (cwd) => {
-    const cfgPath = findConfig(cwd).project || path.join(cwd, "pi-vault-mind.config.json");
+    const cfgPath = getConfigPath(cwd);
     if (!fs.existsSync(cfgPath))
         return {};
     try {
@@ -100,7 +100,7 @@ const readProjectConfig = (cwd) => {
 };
 /** Persist the project config with standard formatting. */
 const writeProjectConfig = (cwd, obj) => {
-    const cfgPath = findConfig(cwd).project || path.join(cwd, "pi-vault-mind.config.json");
+    const cfgPath = getConfigPath(cwd);
     ensureDir(cfgPath);
     fs.writeFileSync(cfgPath, `${JSON.stringify(obj, null, 2)}\n`, "utf-8");
     return cfgPath;
@@ -151,7 +151,7 @@ export const registerDiscoverSchemaTool = (pi) => {
         description: "Infer the schema of an unconfigured .jsonl file by sampling its first N rows and register it as a collection.",
         promptSnippet: 'discover_schema(file="data/events.jsonl", name="events", sample=100)',
         promptGuidelines: [
-            "Use when you have a .jsonl file that is not yet mapped in pi-vault-mind.config.json.",
+            "Use when you have a .jsonl file that is not yet mapped in .vault-mind/vault-mind.config.json.",
             "The tool reads the first N rows, infers field names and JSON types, and writes a CollectionDef to the project config.",
         ],
         parameters: Type.Object({

package/dist/src/edits.d.ts

@@ -0,0 +1,21 @@
+export interface PendingEdit {
+    id: string;
+    path: string;
+    agentId: string;
+    role: string;
+    dispatchId: string;
+    oldText: string;
+    newText: string;
+    status: "pending" | "applied" | "rejected";
+    createdAt: number;
+}
+export declare function listEdits(cwd: string, filePath?: string): PendingEdit[];
+export declare function getEdit(cwd: string, id: string): PendingEdit | undefined;
+export declare function createEdit(cwd: string, edit: Omit<PendingEdit, "id" | "status" | "createdAt">): PendingEdit;
+export declare function applyEdit(cwd: string, id: string): {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function rejectEdit(cwd: string, id: string): boolean;

package/dist/src/edits.js

@@ -0,0 +1,75 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getConfigPath } from "./utils.js";
+function editsPath(cwd) {
+    return path.join(path.dirname(getConfigPath(cwd)), "edits.jsonl");
+}
+export function listEdits(cwd, filePath) {
+    const p = editsPath(cwd);
+    if (!fs.existsSync(p))
+        return [];
+    const edits = fs
+        .readFileSync(p, "utf-8")
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((e) => e !== null);
+    if (filePath)
+        return edits.filter((e) => e.path === filePath);
+    return edits;
+}
+export function getEdit(cwd, id) {
+    return listEdits(cwd).find((e) => e.id === id);
+}
+export function createEdit(cwd, edit) {
+    const full = {
+        ...edit,
+        id: randomUUID(),
+        status: "pending",
+        createdAt: Date.now(),
+    };
+    fs.appendFileSync(editsPath(cwd), `${JSON.stringify(full)}\n`, "utf-8");
+    return full;
+}
+export function applyEdit(cwd, id) {
+    const edit = getEdit(cwd, id);
+    if (edit?.status !== "pending")
+        return { ok: false, error: "Edit not found or already resolved" };
+    const filePath = path.join(cwd, edit.path);
+    if (!fs.existsSync(filePath))
+        return { ok: false, error: `File not found: ${edit.path}` };
+    const content = fs.readFileSync(filePath, "utf-8");
+    // Count occurrences — only replace if oldText appears exactly once
+    const occurrences = content.split(edit.oldText).length - 1;
+    if (occurrences === 0)
+        return { ok: false, error: "oldText not found in file" };
+    if (occurrences > 1)
+        return {
+            ok: false,
+            error: `oldText appears ${occurrences} times — ambiguous match, cannot auto-apply`,
+        };
+    const newContent = content.replace(edit.oldText, edit.newText);
+    fs.writeFileSync(filePath, newContent, "utf-8");
+    updateEditStatus(cwd, id, "applied");
+    return { ok: true };
+}
+export function rejectEdit(cwd, id) {
+    const edit = getEdit(cwd, id);
+    if (edit?.status !== "pending")
+        return false;
+    updateEditStatus(cwd, id, "rejected");
+    return true;
+}
+function updateEditStatus(cwd, id, status) {
+    const edits = listEdits(cwd);
+    const updated = edits.map((e) => (e.id === id ? { ...e, status } : e));
+    fs.writeFileSync(editsPath(cwd), `${updated.map((e) => JSON.stringify(e)).join("\n")}\n`, "utf-8");
+}

package/dist/src/embedding-probe.d.ts

@@ -0,0 +1,34 @@
+import type { VaultMindConfig } from "./types.js";
+export interface EmbeddingProbeRequest {
+    target: "local" | "remote";
+    url: string;
+    workspace?: string;
+    model?: string;
+    transientSecrets?: {
+        apiKey?: string;
+        readApiKey?: string;
+        writeApiKey?: string;
+    };
+}
+export interface EmbeddingModelOption {
+    id: string;
+    name: string;
+    dim: number | null;
+}
+export interface EmbeddingProbeResponse {
+    ok: boolean;
+    target: "local" | "remote";
+    endpoint: string;
+    models: readonly EmbeddingModelOption[];
+    selectedModelAvailable: boolean | null;
+    latencyMs: number | null;
+    error: {
+        code: "invalid_request" | "unauthorized" | "unreachable" | "provider_error";
+        message: string;
+    } | null;
+}
+export declare function probeEmbeddingEndpoint(request: EmbeddingProbeRequest, options?: {
+    fetch?: typeof fetch;
+    now?: () => number;
+    config?: VaultMindConfig;
+}): Promise<EmbeddingProbeResponse>;

package/dist/src/embedding-probe.js

@@ -0,0 +1,142 @@
+import { resolveEmbeddingSecret } from "./embedding-secrets.js";
+const normalizeEndpointUrl = (url) => {
+    const suffixes = ["/v1/embeddings", "/v1", "/"];
+    let base = url;
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const suffix of suffixes) {
+            if (base.endsWith(suffix)) {
+                base = base.slice(0, -suffix.length);
+                changed = true;
+            }
+        }
+    }
+    return base;
+};
+const isValidHttpUrl = (url) => {
+    try {
+        const parsed = new URL(url);
+        return parsed.protocol === "http:" || parsed.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+};
+const isString = (value) => typeof value === "string";
+const isNumber = (value) => typeof value === "number" && Number.isFinite(value);
+const isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const hasStringField = (obj, key) => key in obj && isString(obj[key]);
+const hasNumberField = (obj, key) => key in obj && isNumber(obj[key]);
+const isOllamaCatalog = (body) => {
+    if (!isObject(body) || !("models" in body) || !Array.isArray(body.models))
+        return false;
+    return body.models.every((m) => isObject(m) && hasStringField(m, "name"));
+};
+const isModalCatalog = (body) => {
+    if (!isObject(body) || !("models" in body) || !Array.isArray(body.models))
+        return false;
+    return body.models.every((m) => isObject(m) && hasStringField(m, "key") && hasNumberField(m, "native_dim"));
+};
+const isOpenAiCatalog = (body) => {
+    if (!isObject(body) || !("data" in body) || !Array.isArray(body.data))
+        return false;
+    return body.data.every((d) => isObject(d) && hasStringField(d, "id"));
+};
+const normalizeModels = (body) => {
+    if (isOllamaCatalog(body)) {
+        return body.models.map((m) => ({ id: m.name, name: m.name, dim: null }));
+    }
+    if (isModalCatalog(body)) {
+        return body.models.map((m) => ({ id: m.key, name: m.key, dim: m.native_dim }));
+    }
+    if (isOpenAiCatalog(body)) {
+        return body.data.map((d) => ({ id: d.id, name: d.id, dim: null }));
+    }
+    return null;
+};
+const sortModels = (models) => [...models].sort((a, b) => a.id.localeCompare(b.id));
+const buildErrorResponse = (target, endpoint, code, message) => ({
+    ok: false,
+    target,
+    endpoint,
+    models: [],
+    selectedModelAvailable: null,
+    latencyMs: null,
+    error: { code, message },
+});
+const resolveAuthorizationHeader = (request, cfg) => {
+    const cwd = request.workspace;
+    if (request.target === "local") {
+        if (request.transientSecrets?.apiKey)
+            return request.transientSecrets.apiKey;
+        if (cfg)
+            return resolveEmbeddingSecret(cfg, "localApiKey", { cwd });
+        return undefined;
+    }
+    // Remote read path: never select write-scoped credentials.
+    if (request.transientSecrets?.readApiKey)
+        return request.transientSecrets.readApiKey;
+    if (request.transientSecrets?.apiKey)
+        return request.transientSecrets.apiKey;
+    if (cfg) {
+        const readToken = resolveEmbeddingSecret(cfg, "remoteReadApiKey", { cwd });
+        if (readToken)
+            return readToken;
+        return resolveEmbeddingSecret(cfg, "remoteApiKey", { cwd });
+    }
+    return undefined;
+};
+export async function probeEmbeddingEndpoint(request, options) {
+    const fetchImpl = options?.fetch ?? fetch;
+    const nowImpl = options?.now ?? Date.now;
+    const cfg = options?.config;
+    const base = normalizeEndpointUrl(request.url);
+    if (request.target !== "local" && request.target !== "remote") {
+        return buildErrorResponse("local", base, "invalid_request", "Invalid target");
+    }
+    if (!isValidHttpUrl(base)) {
+        return buildErrorResponse(request.target, base, "invalid_request", "Invalid URL");
+    }
+    const target = request.target;
+    const discoveryUrls = target === "local"
+        ? [`${base}/api/tags`, `${base}/v1/models`]
+        : [`${base}/models`, `${base}/v1/models`];
+    const headers = {};
+    const auth = resolveAuthorizationHeader(request, cfg);
+    if (auth)
+        headers.Authorization = `Bearer ${auth}`;
+    const start = nowImpl();
+    try {
+        for (const url of discoveryUrls) {
+            const res = await fetchImpl(url, { method: "GET", headers });
+            if (res.status === 401) {
+                return buildErrorResponse(target, base, "unauthorized", "Authorization failed");
+            }
+            if (!res.ok) {
+                if (res.status === 404)
+                    continue;
+                return buildErrorResponse(target, base, "provider_error", "Provider returned an error");
+            }
+            const body = (await res.json());
+            const models = normalizeModels(body);
+            if (models === null)
+                continue;
+            const sorted = sortModels(models);
+            const selectedModelAvailable = request.model == null ? null : sorted.some((m) => m.id === request.model);
+            return {
+                ok: true,
+                target,
+                endpoint: base,
+                models: sorted,
+                selectedModelAvailable,
+                latencyMs: nowImpl() - start,
+                error: null,
+            };
+        }
+        return buildErrorResponse(target, base, "provider_error", "Provider returned an error");
+    }
+    catch {
+        return buildErrorResponse(target, base, "unreachable", "Endpoint is unreachable");
+    }
+}

package/dist/src/embedding-providers.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Embedding provider interface + concrete implementations.
+ *
+ * The vector-store layer (currently `src/lance.ts`) is decoupled from the
+ * vector-generator layer (this file). A provider only knows how to turn
+ * text into `number[][]`; the store adapter wraps the provider into the
+ * store-specific class (e.g. LanceDB's `TextEmbeddingFunction`) for its
+ * schema/auto-embed needs. Adding a new vector store means writing a new
+ * adapter; adding a new provider means implementing this interface.
+ *
+ * ── Provider contract ─────────────────────────────────────────────────────
+ *   `embed(texts, task)` — same-length batch, one vector per text, in order.
+ *   `dim()`              — output dimensionality (the store needs this to
+ *                          build the schema; `undefined` is allowed when the
+ *                          dim is learned lazily from the first response).
+ *   `init()`             — optional one-time setup (network probe, model
+ *                          download). Idempotent.
+ *
+ * The coalescer in `src/embed-queue.ts` already consumes the same
+ * `EmbedFn = (texts, task) => Promise<number[][]>` shape — the coalescer
+ * path doesn't even need the provider class, just the function. We keep
+ * `EmbeddingProvider` as a class for the dim/init convenience, and the
+ * factory at the bottom of this file returns both the provider and its
+ * matching `EmbedFn` closure.
+ */
+import type { EmbedTask } from "./embed-queue.js";
+import type { VaultMindConfig } from "./types.js";
+/**
+ * The store-agnostic provider contract. A store adapter (e.g. the Lance
+ * adapter in `lance.ts`) wraps an instance of this into the store's own
+ * embedding-function class. The coalescer in `embed-queue.ts` consumes
+ * just the `embed()` method via the `EmbedFn` closure.
+ */
+export interface EmbeddingProvider {
+    /** Identifier for logging + the coalescer cache key. */
+    readonly id: string;
+    /**
+     * Output dimensionality. May be `undefined` when the dim is unknown
+     * until the first embed call completes (e.g. Modal's `/embed`
+     * response carries the dim; the store schema is updated lazily).
+     */
+    dim(): number | undefined;
+    /**
+     * Embed a batch of texts. Same length out as in, one vector per text,
+     * in order. `task` selects query vs document so providers can pick a
+     * task-specific prompt (Ollama / Modal both use this).
+     */
+    embed(texts: string[], task: EmbedTask): Promise<number[][]>;
+    /**
+     * One-time setup. Idempotent — calling twice is a no-op. Network
+     * probes, model downloads, etc. should happen here. Implementations
+     * should never throw on a best-effort connectivity check; the caller
+     * will fall back if the actual `embed` call fails later.
+     */
+    init(): Promise<void>;
+}
+/** Default bearer for local /v1/embeddings endpoints (Ollama, LM Studio, …). */
+export declare const DEFAULT_OLLAMA_API_KEY = "ollama";
+export interface OpenAICompatibleProviderOptions {
+    url: string;
+    model: string;
+    /**
+     * Bearer token. Defaults to `"ollama"` for local endpoints; pass
+     * `null` explicitly to omit the header (e.g. unauthenticated remote
+     * servers that don't validate the header). Most production endpoints
+     * should pass an actual token.
+     */
+    apiKey?: string | null;
+    /** Output dim, if known up front. */
+    dims?: number;
+}
+/**
+ * OpenAI-compatible embedding provider. Works with any `/v1/embeddings`
+ * endpoint — Ollama, LM Studio, vLLM, Modal, OpenAI, etc. The endpoint
+ * contract is the OpenAI `/v1/embeddings` request/response shape.
+ */
+export declare class OpenAICompatibleProvider implements EmbeddingProvider {
+    readonly id: string;
+    private readonly url;
+    private readonly model;
+    private readonly apiKey;
+    private readonly dimsValue;
+    constructor(options: OpenAICompatibleProviderOptions);
+    dim(): number | undefined;
+    init(): Promise<void>;
+    embed(texts: string[], _task: EmbedTask): Promise<number[][]>;
+}
+/**
+ * Offline transformers.js provider. Works on any Node.js with no network
+ * after the model is downloaded. Fixed dim 384, fixed model
+ * `Xenova/all-MiniLM-L6-v2`. The dim is small enough to fit in the
+ * `useTransformers: true` escape hatch (a fallback when no URL is
+ * configured) but it does NOT share a vector space with `embeddinggemma`,
+ * so it's only useful for local dev / testing.
+ */
+export declare class TransformersProvider implements EmbeddingProvider {
+    readonly id = "transformers:Xenova/all-MiniLM-L6-v2";
+    private extractor;
+    private initPromise;
+    dim(): number | undefined;
+    init(): Promise<void>;
+    embed(texts: string[]): Promise<number[][]>;
+}
+/**
+ * Modal cloud embedding provider. Hits the deployed ASGI app's `/embed`
+ * endpoint (see `src/modal-client.ts`). The dim is learned lazily from
+ * the first response and cached by the caller.
+ */
+export declare class ModalProvider implements EmbeddingProvider {
+    readonly id: string;
+    private readonly cfg;
+    private readonly collection;
+    private readonly dimsValue;
+    constructor(cfg: VaultMindConfig, collection?: string, dimsValue?: number);
+    dim(): number | undefined;
+    init(): Promise<void>;
+    embed(texts: string[], task: EmbedTask): Promise<number[][]>;
+}
+/**
+ * Pick the right provider for a vault config. Resolution order matches the
+ * pre-refactor behavior in `lance.ts:getEmbeddingFunction`:
+ *
+ *   1. `embedding.remoteUrl` → Modal cloud
+ *   2. `embedding.localUrl`  → OpenAI-compatible (Ollama, LM Studio, etc.)
+ *   3. `embedding.useTransformers !== false` → transformers.js offline
+ *
+ * To add a new provider, add a class above and a branch here. No
+ * downstream code (lance, coalescer, plugin) needs to change.
+ */
+export declare const createProvider: (cfg: VaultMindConfig, opts?: {
+    collection?: string;
+    dims?: number;
+}) => Promise<EmbeddingProvider>;

package/dist/src/embedding-providers.js

@@ -0,0 +1,173 @@
+import { resolveEmbeddingSecret } from "./embedding-secrets.js";
+import { createModalClient, resolveDim, resolveModel } from "./modal-config.js";
+// ── OpenAI-compatible provider (any /v1/embeddings endpoint) ──────────────
+/** Default bearer for local /v1/embeddings endpoints (Ollama, LM Studio, …). */
+export const DEFAULT_OLLAMA_API_KEY = "ollama";
+/**
+ * OpenAI-compatible embedding provider. Works with any `/v1/embeddings`
+ * endpoint — Ollama, LM Studio, vLLM, Modal, OpenAI, etc. The endpoint
+ * contract is the OpenAI `/v1/embeddings` request/response shape.
+ */
+export class OpenAICompatibleProvider {
+    id;
+    url;
+    model;
+    apiKey;
+    dimsValue;
+    constructor(options) {
+        this.url = options.url;
+        this.model = options.model;
+        // 0.16.0+ default: "ollama" for local endpoints. Matches
+        // AgentModelProvider's behavior. Callers passing `null` explicitly
+        // get no Authorization header (some local servers reject "Bearer
+        // ollama" as invalid auth).
+        this.apiKey = options.apiKey === null ? null : (options.apiKey ?? DEFAULT_OLLAMA_API_KEY);
+        this.dimsValue = options.dims;
+        this.id = `openai-compatible:${options.url}:${options.model}`;
+    }
+    dim() {
+        return this.dimsValue;
+    }
+    async init() {
+        // Best-effort connectivity check; failures are non-fatal.
+        try {
+            const baseUrl = this.url.replace(/\/v1\/embeddings\/?$/, "").replace(/\/+$/, "");
+            const headers = {};
+            if (this.apiKey)
+                headers.Authorization = `Bearer ${this.apiKey}`;
+            await fetch(`${baseUrl}/v1/models`, { headers });
+        }
+        catch (err) {
+            console.warn(`[pi-vault-mind] Cannot reach embedding endpoint at ${this.url}: ${err}`);
+        }
+    }
+    async embed(texts, _task) {
+        const endpoint = this.url.endsWith("/v1/embeddings")
+            ? this.url
+            : `${this.url.replace(/\/+$/, "")}/v1/embeddings`;
+        const headers = { "Content-Type": "application/json" };
+        if (this.apiKey)
+            headers.Authorization = `Bearer ${this.apiKey}`;
+        const resp = await fetch(endpoint, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ model: this.model, input: texts }),
+        });
+        if (!resp.ok) {
+            const body = await resp.text().catch(() => "");
+            throw new Error(`Embed failed: ${resp.status} ${body}`);
+        }
+        const data = (await resp.json());
+        if (!data.data || !Array.isArray(data.data)) {
+            throw new Error("Invalid embedding response");
+        }
+        return data.data.map((d) => d.embedding);
+    }
+}
+// ── Transformers.js provider (fully offline) ───────────────────────────────
+/**
+ * Offline transformers.js provider. Works on any Node.js with no network
+ * after the model is downloaded. Fixed dim 384, fixed model
+ * `Xenova/all-MiniLM-L6-v2`. The dim is small enough to fit in the
+ * `useTransformers: true` escape hatch (a fallback when no URL is
+ * configured) but it does NOT share a vector space with `embeddinggemma`,
+ * so it's only useful for local dev / testing.
+ */
+export class TransformersProvider {
+    id = "transformers:Xenova/all-MiniLM-L6-v2";
+    extractor = null;
+    initPromise = null;
+    dim() {
+        return 384;
+    }
+    async init() {
+        if (!this.initPromise) {
+            this.initPromise = (async () => {
+                const { pipeline } = await import("@xenova/transformers");
+                this.extractor = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
+            })();
+        }
+        return this.initPromise;
+    }
+    async embed(texts) {
+        await this.init();
+        const embeddings = [];
+        for (const text of texts) {
+            const result = await this.extractor(text, { pooling: "mean", normalize: true });
+            embeddings.push(Array.from(result.data));
+        }
+        return embeddings;
+    }
+}
+// ── Modal provider (cloud, /embed endpoint) ────────────────────────────────
+/**
+ * Modal cloud embedding provider. Hits the deployed ASGI app's `/embed`
+ * endpoint (see `src/modal-client.ts`). The dim is learned lazily from
+ * the first response and cached by the caller.
+ */
+export class ModalProvider {
+    id;
+    cfg;
+    collection;
+    dimsValue;
+    constructor(cfg, collection, dimsValue) {
+        this.cfg = cfg;
+        this.collection = collection;
+        this.dimsValue = dimsValue;
+        const model = resolveModel(cfg, collection);
+        this.id = `modal:${model}:${dimsValue ?? "native"}`;
+    }
+    dim() {
+        return this.dimsValue;
+    }
+    async init() {
+        // No-op: Modal client is built per-embed; no persistent connection.
+    }
+    async embed(texts, task) {
+        const client = createModalClient(this.cfg);
+        if (!client) {
+            throw new Error("Modal provider not configured (missing baseUrl or token).");
+        }
+        const res = await client.embed(texts, {
+            model: resolveModel(this.cfg, this.collection),
+            dim: resolveDim(this.cfg, this.collection),
+            task,
+        });
+        return res.vectors;
+    }
+}
+// ── Factory ────────────────────────────────────────────────────────────────
+/**
+ * Pick the right provider for a vault config. Resolution order matches the
+ * pre-refactor behavior in `lance.ts:getEmbeddingFunction`:
+ *
+ *   1. `embedding.remoteUrl` → Modal cloud
+ *   2. `embedding.localUrl`  → OpenAI-compatible (Ollama, LM Studio, etc.)
+ *   3. `embedding.useTransformers !== false` → transformers.js offline
+ *
+ * To add a new provider, add a class above and a branch here. No
+ * downstream code (lance, coalescer, plugin) needs to change.
+ */
+export const createProvider = async (cfg, opts = {}) => {
+    if (cfg.embedding.remoteUrl) {
+        const provider = new ModalProvider(cfg, opts.collection, opts.dims);
+        await provider.init();
+        return provider;
+    }
+    if (cfg.embedding.localUrl) {
+        const provider = new OpenAICompatibleProvider({
+            url: cfg.embedding.localUrl,
+            model: cfg.embedding.model || "embeddinggemma",
+            apiKey: resolveEmbeddingSecret(cfg, "localApiKey") ?? DEFAULT_OLLAMA_API_KEY,
+            dims: opts.dims,
+        });
+        await provider.init();
+        return provider;
+    }
+    if (cfg.embedding.useTransformers !== false) {
+        const provider = new TransformersProvider();
+        await provider.init();
+        return provider;
+    }
+    throw new Error("No embedding provider configured. Set remoteUrl, localUrl, or useTransformers: true.");
+};