pi-vault-mind 0.14.2 → 0.16.3

package/dist/test/embedding-probe.test.js

@@ -0,0 +1,424 @@
+import { strict as assert } from "node:assert";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it, mock } from "node:test";
+import { probeEmbeddingEndpoint } from "../src/embedding-probe.js";
+const PROVIDER_ENV_KEYS = [
+    "PVM_API_TOKEN",
+    "PVM_LOCAL_EMBEDDING_API_KEY",
+    "PVM_REMOTE_EMBEDDING_API_KEY",
+    "PVM_MODAL_READ_TOKEN",
+    "PVM_MODAL_WRITE_TOKEN",
+];
+const configWith = (embedding = {}) => ({
+    dataDir: ".lancedb",
+    embedding,
+});
+const jsonResponse = (body, status = 200) => new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+});
+const createFetch = (handler) => {
+    const calls = [];
+    const injectedFetch = async (input, init) => {
+        const request = input instanceof Request ? input : null;
+        const headers = new Headers(request?.headers);
+        new Headers(init?.headers).forEach((value, key) => {
+            headers.set(key, value);
+        });
+        const call = {
+            url: request?.url ?? String(input),
+            method: init?.method ?? request?.method ?? "GET",
+            headers,
+        };
+        calls.push(call);
+        return handler(call, calls.length - 1);
+    };
+    return { fetch: injectedFetch, calls };
+};
+const logValue = (value) => {
+    if (value instanceof Error)
+        return `${value.name}: ${value.message}`;
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+};
+const captureConsole = () => {
+    const entries = [];
+    const capture = (...args) => entries.push(args.map(logValue).join(" "));
+    mock.method(console, "debug", capture);
+    mock.method(console, "error", capture);
+    mock.method(console, "info", capture);
+    mock.method(console, "log", capture);
+    mock.method(console, "warn", capture);
+    return entries;
+};
+describe("probeEmbeddingEndpoint", () => {
+    let originalCwd;
+    let scratchDir;
+    let savedEnvironment;
+    beforeEach(() => {
+        originalCwd = process.cwd();
+        scratchDir = fs.mkdtempSync(path.join(os.tmpdir(), "pvm-embedding-probe-"));
+        process.chdir(scratchDir);
+        savedEnvironment = {};
+        for (const key of PROVIDER_ENV_KEYS) {
+            savedEnvironment[key] = process.env[key];
+            delete process.env[key];
+        }
+    });
+    afterEach(() => {
+        mock.restoreAll();
+        process.chdir(originalCwd);
+        for (const key of PROVIDER_ENV_KEYS) {
+            const saved = savedEnvironment[key];
+            if (saved === undefined)
+                delete process.env[key];
+            else
+                process.env[key] = saved;
+        }
+        fs.rmSync(scratchDir, { recursive: true, force: true });
+    });
+    describe("provider and URL normalization", () => {
+        it("normalizes an Ollama base URL and returns sorted models with injected-clock latency", async () => {
+            const { fetch, calls } = createFetch(() => jsonResponse({
+                models: [{ name: "zeta-embed:latest" }, { name: "alpha-embed:latest" }],
+            }));
+            const clock = [400, 437];
+            const result = await probeEmbeddingEndpoint({
+                target: "local",
+                url: "http://127.0.0.1:11434/v1/embeddings/",
+                model: "zeta-embed:latest",
+            }, { fetch, now: () => clock.shift() ?? 437, config: configWith() });
+            assert.deepEqual(calls.map(({ url, method }) => ({ url, method })), [{ url: "http://127.0.0.1:11434/api/tags", method: "GET" }]);
+            assert.deepEqual(result, {
+                ok: true,
+                target: "local",
+                endpoint: "http://127.0.0.1:11434",
+                models: [
+                    { id: "alpha-embed:latest", name: "alpha-embed:latest", dim: null },
+                    { id: "zeta-embed:latest", name: "zeta-embed:latest", dim: null },
+                ],
+                selectedModelAvailable: true,
+                latencyMs: 37,
+                error: null,
+            });
+        });
+        it("falls back from Ollama tags to an OpenAI-compatible model catalog", async () => {
+            const { fetch, calls } = createFetch(({ url }) => {
+                if (url.endsWith("/api/tags"))
+                    return jsonResponse({ error: "not Ollama" }, 404);
+                return jsonResponse({ data: [{ id: "text-embed-z" }, { id: "text-embed-a" }] });
+            });
+            const result = await probeEmbeddingEndpoint({
+                target: "local",
+                url: "https://embeddings.example.test/v1/",
+                model: "not-installed",
+            }, { fetch, now: () => 10, config: configWith() });
+            assert.deepEqual(calls.map(({ url }) => url), ["https://embeddings.example.test/api/tags", "https://embeddings.example.test/v1/models"]);
+            assert.deepEqual(result.models, [
+                { id: "text-embed-a", name: "text-embed-a", dim: null },
+                { id: "text-embed-z", name: "text-embed-z", dim: null },
+            ]);
+            assert.equal(result.endpoint, "https://embeddings.example.test");
+            assert.equal(result.selectedModelAvailable, false);
+            assert.equal(result.ok, true);
+            assert.equal(result.error, null);
+        });
+        it("normalizes Modal models, preserves native dimensions, and sorts by ID", async () => {
+            const { fetch, calls } = createFetch(() => jsonResponse({
+                default: "embeddinggemma",
+                models: [
+                    { key: "snowflake-arctic-embed", native_dim: 1024 },
+                    { key: "embeddinggemma", native_dim: 768 },
+                ],
+            }));
+            const result = await probeEmbeddingEndpoint({
+                target: "remote",
+                url: "https://workspace--vault-mind.modal.run/",
+                model: "missing-model",
+            }, { fetch, now: () => 25, config: configWith() });
+            assert.deepEqual(calls.map(({ url }) => url), ["https://workspace--vault-mind.modal.run/models"]);
+            assert.deepEqual(result, {
+                ok: true,
+                target: "remote",
+                endpoint: "https://workspace--vault-mind.modal.run",
+                models: [
+                    { id: "embeddinggemma", name: "embeddinggemma", dim: 768 },
+                    {
+                        id: "snowflake-arctic-embed",
+                        name: "snowflake-arctic-embed",
+                        dim: 1024,
+                    },
+                ],
+                selectedModelAvailable: false,
+                latencyMs: 0,
+                error: null,
+            });
+        });
+        it("falls back from Modal models to OpenAI models after stripping /v1/embeddings", async () => {
+            const { fetch, calls } = createFetch(({ url }) => {
+                if (url.endsWith("/models") && !url.endsWith("/v1/models")) {
+                    return jsonResponse({ detail: "not Modal" }, 404);
+                }
+                return jsonResponse({ data: [{ id: "remote-z" }, { id: "remote-a" }] });
+            });
+            const result = await probeEmbeddingEndpoint({
+                target: "remote",
+                url: "https://api.example.test/v1/embeddings",
+            }, { fetch, now: () => 90, config: configWith() });
+            assert.deepEqual(calls.map(({ url }) => url), ["https://api.example.test/models", "https://api.example.test/v1/models"]);
+            assert.deepEqual(result.models, [
+                { id: "remote-a", name: "remote-a", dim: null },
+                { id: "remote-z", name: "remote-z", dim: null },
+            ]);
+            assert.equal(result.endpoint, "https://api.example.test");
+            assert.equal(result.selectedModelAvailable, null);
+            assert.equal(result.ok, true);
+            assert.equal(result.error, null);
+        });
+    });
+    describe("credential isolation", () => {
+        const transientCases = [
+            {
+                name: "local uses only the transient apiKey",
+                request: {
+                    target: "local",
+                    url: "http://127.0.0.1:11434",
+                    transientSecrets: {
+                        apiKey: "LOCAL_TRANSIENT_SENTINEL",
+                        readApiKey: "REMOTE_READ_TRANSIENT_SENTINEL",
+                        writeApiKey: "REMOTE_WRITE_TRANSIENT_SENTINEL",
+                    },
+                },
+                config: configWith({ apiKey: "LOCAL_CONFIG_SENTINEL" }),
+                expectedAuthorization: "Bearer LOCAL_TRANSIENT_SENTINEL",
+            },
+            {
+                name: "remote prefers the transient readApiKey over unscoped and write keys",
+                request: {
+                    target: "remote",
+                    url: "https://probe.example.test",
+                    transientSecrets: {
+                        apiKey: "REMOTE_TRANSIENT_SENTINEL",
+                        readApiKey: "REMOTE_READ_TRANSIENT_SENTINEL",
+                        writeApiKey: "REMOTE_WRITE_TRANSIENT_SENTINEL",
+                    },
+                },
+                config: configWith({
+                    remoteApiKey: "REMOTE_CONFIG_SENTINEL",
+                    remoteReadApiKey: "REMOTE_READ_CONFIG_SENTINEL",
+                }),
+                expectedAuthorization: "Bearer REMOTE_READ_TRANSIENT_SENTINEL",
+            },
+            {
+                name: "remote falls back to the transient unscoped apiKey when readApiKey is absent",
+                request: {
+                    target: "remote",
+                    url: "https://probe.example.test",
+                    transientSecrets: {
+                        apiKey: "REMOTE_TRANSIENT_SENTINEL",
+                        writeApiKey: "REMOTE_WRITE_TRANSIENT_SENTINEL",
+                    },
+                },
+                config: configWith({ remoteReadApiKey: "REMOTE_READ_CONFIG_SENTINEL" }),
+                expectedAuthorization: "Bearer REMOTE_TRANSIENT_SENTINEL",
+            },
+        ];
+        for (const testCase of transientCases) {
+            it(testCase.name, async () => {
+                const { fetch, calls } = createFetch(() => testCase.request.target === "local"
+                    ? jsonResponse({ models: [{ name: "embeddinggemma" }] })
+                    : jsonResponse({ models: [{ key: "embeddinggemma", native_dim: 768 }] }));
+                const result = await probeEmbeddingEndpoint(testCase.request, {
+                    fetch,
+                    now: () => 0,
+                    config: testCase.config,
+                });
+                assert.equal(result.ok, true);
+                assert.equal(calls[0].headers.get("authorization"), testCase.expectedAuthorization);
+            });
+        }
+        it("uses matching stored credentials without persisting, echoing, or logging any credential", async () => {
+            const storeDir = path.join(scratchDir, ".vault-mind");
+            const storePath = path.join(storeDir, "vault-mind.env");
+            fs.mkdirSync(storeDir, { recursive: true });
+            const storedBytes = [
+                'PVM_API_TOKEN="BRIDGE_TOKEN_SENTINEL"',
+                'PVM_LOCAL_EMBEDDING_API_KEY="LOCAL_STORED_SENTINEL"',
+                'PVM_REMOTE_EMBEDDING_API_KEY="REMOTE_STORED_SENTINEL"',
+                'PVM_MODAL_READ_TOKEN="REMOTE_READ_STORED_SENTINEL"',
+                'PVM_MODAL_WRITE_TOKEN="REMOTE_WRITE_STORED_SENTINEL"',
+                'UNRELATED_SETTING="keep-me"',
+                "",
+            ].join("\n");
+            fs.writeFileSync(storePath, storedBytes, "utf-8");
+            const consoleEntries = captureConsole();
+            const localRequest = {
+                target: "local",
+                url: "http://127.0.0.1:11434",
+            };
+            const remoteRequest = {
+                target: "remote",
+                url: "https://probe.example.test",
+            };
+            const transientRequest = {
+                ...remoteRequest,
+                transientSecrets: { readApiKey: "REMOTE_READ_TRANSIENT_SENTINEL" },
+            };
+            const config = configWith({
+                apiKey: "LOCAL_LEGACY_SENTINEL",
+                remoteApiKey: "REMOTE_LEGACY_SENTINEL",
+                remoteReadApiKey: "REMOTE_READ_LEGACY_SENTINEL",
+            });
+            const originalRequests = structuredClone({ localRequest, remoteRequest, transientRequest });
+            const originalConfig = structuredClone(config);
+            const { fetch, calls } = createFetch(({ url }) => url.endsWith("/api/tags")
+                ? jsonResponse({ models: [{ name: "local-model" }] })
+                : jsonResponse({ models: [{ key: "remote-model", native_dim: 768 }] }));
+            const localResult = await probeEmbeddingEndpoint(localRequest, {
+                fetch,
+                now: () => 1,
+                config,
+            });
+            const remoteResult = await probeEmbeddingEndpoint(remoteRequest, {
+                fetch,
+                now: () => 1,
+                config,
+            });
+            const transientResult = await probeEmbeddingEndpoint(transientRequest, {
+                fetch,
+                now: () => 1,
+                config,
+            });
+            assert.deepEqual(calls.map(({ headers }) => headers.get("authorization")), [
+                "Bearer LOCAL_STORED_SENTINEL",
+                "Bearer REMOTE_READ_STORED_SENTINEL",
+                "Bearer REMOTE_READ_TRANSIENT_SENTINEL",
+            ]);
+            assert.equal(fs.readFileSync(storePath, "utf-8"), storedBytes);
+            assert.deepEqual(fs.readdirSync(storeDir), ["vault-mind.env"]);
+            assert.deepEqual({ localRequest, remoteRequest, transientRequest }, originalRequests);
+            assert.deepEqual(config, originalConfig);
+            const observableText = JSON.stringify({
+                localResult,
+                remoteResult,
+                transientResult,
+                consoleEntries,
+            });
+            for (const sentinel of [
+                "BRIDGE_TOKEN_SENTINEL",
+                "LOCAL_STORED_SENTINEL",
+                "REMOTE_STORED_SENTINEL",
+                "REMOTE_READ_STORED_SENTINEL",
+                "REMOTE_WRITE_STORED_SENTINEL",
+                "REMOTE_READ_TRANSIENT_SENTINEL",
+                "LOCAL_LEGACY_SENTINEL",
+                "REMOTE_LEGACY_SENTINEL",
+                "REMOTE_READ_LEGACY_SENTINEL",
+            ]) {
+                assert.equal(observableText.includes(sentinel), false, `leaked ${sentinel}`);
+            }
+        });
+    });
+    describe("validation and normalized failures", () => {
+        const invalidCases = [
+            {
+                name: "rejects an unknown target before fetching",
+                request: {
+                    target: "other",
+                    url: "https://probe.example.test",
+                },
+                message: /target/i,
+            },
+            {
+                name: "rejects a malformed URL before fetching",
+                request: { target: "local", url: "not a URL" },
+                message: /url/i,
+            },
+            {
+                name: "rejects a non-HTTP URL before fetching",
+                request: { target: "remote", url: "file:///tmp/provider" },
+                message: /url|http/i,
+            },
+        ];
+        for (const testCase of invalidCases) {
+            it(testCase.name, async () => {
+                const { fetch, calls } = createFetch(() => {
+                    throw new Error("fetch must not run for invalid input");
+                });
+                const result = await probeEmbeddingEndpoint(testCase.request, {
+                    fetch,
+                    now: () => 5,
+                    config: configWith(),
+                });
+                assert.equal(calls.length, 0);
+                assert.equal(result.ok, false);
+                assert.deepEqual(result.models, []);
+                assert.equal(result.selectedModelAvailable, null);
+                assert.equal(result.latencyMs, null);
+                assert.equal(result.error?.code, "invalid_request");
+                assert.match(result.error?.message ?? "", testCase.message);
+            });
+        }
+        it("maps HTTP 401 to unauthorized without returning the provider body", async () => {
+            const bodySentinel = "PROVIDER_401_BODY_SENTINEL";
+            const consoleEntries = captureConsole();
+            const { fetch } = createFetch(() => new Response(`credential rejected: ${bodySentinel}`, { status: 401 }));
+            const result = await probeEmbeddingEndpoint({ target: "remote", url: "https://probe.example.test" }, { fetch, now: () => 12, config: configWith() });
+            assert.equal(result.ok, false);
+            assert.equal(result.error?.code, "unauthorized");
+            assert.match(result.error?.message ?? "", /authoriz|credential/i);
+            assert.equal(JSON.stringify({ result, consoleEntries }).includes(bodySentinel), false);
+        });
+        it("maps fetch failures to unreachable without exposing transport details", async () => {
+            const transportSentinel = "TRANSPORT_DETAIL_SENTINEL";
+            const consoleEntries = captureConsole();
+            const { fetch } = createFetch(() => {
+                throw new TypeError(`fetch failed: ${transportSentinel}`);
+            });
+            const result = await probeEmbeddingEndpoint({ target: "local", url: "http://127.0.0.1:11434" }, { fetch, now: () => 12, config: configWith() });
+            assert.equal(result.ok, false);
+            assert.equal(result.error?.code, "unreachable");
+            assert.match(result.error?.message ?? "", /unreach|connect/i);
+            assert.equal(JSON.stringify({ result, consoleEntries }).includes(transportSentinel), false);
+        });
+        it("maps non-401 HTTP failures to provider_error without response-body or console leakage", async () => {
+            const bodySentinel = "PROVIDER_RESPONSE_BODY_SENTINEL";
+            const transientSentinel = "TRANSIENT_ERROR_PATH_SENTINEL";
+            const storedSentinel = "STORED_ERROR_PATH_SENTINEL";
+            const consoleEntries = captureConsole();
+            const { fetch } = createFetch(() => new Response(`upstream detail ${bodySentinel}`, { status: 503 }));
+            const result = await probeEmbeddingEndpoint({
+                target: "remote",
+                url: "https://probe.example.test",
+                transientSecrets: { readApiKey: transientSentinel },
+            }, {
+                fetch,
+                now: () => 12,
+                config: configWith({ remoteReadApiKey: storedSentinel }),
+            });
+            assert.equal(result.ok, false);
+            assert.equal(result.error?.code, "provider_error");
+            assert.match(result.error?.message ?? "", /provider|endpoint/i);
+            const observableText = JSON.stringify({ result, consoleEntries });
+            assert.equal(observableText.includes(bodySentinel), false);
+            assert.equal(observableText.includes(transientSentinel), false);
+            assert.equal(observableText.includes(storedSentinel), false);
+        });
+        it("treats a successful HTTP response with an unknown catalog shape as provider_error", async () => {
+            const malformedBodySentinel = "MALFORMED_CATALOG_SENTINEL";
+            const { fetch } = createFetch(() => jsonResponse({ models: "not-an-array", detail: malformedBodySentinel }));
+            const result = await probeEmbeddingEndpoint({ target: "local", url: "http://127.0.0.1:11434" }, { fetch, now: () => 20, config: configWith() });
+            assert.equal(result.ok, false);
+            assert.equal(result.error?.code, "provider_error");
+            assert.equal(JSON.stringify(result).includes(malformedBodySentinel), false);
+        });
+    });
+});

package/dist/test/embedding-providers.test.js

@@ -0,0 +1,157 @@
+import { strict as assert } from "node:assert";
+import { afterEach, beforeEach, describe, it, mock } from "node:test";
+import { createProvider, OpenAICompatibleProvider } from "../src/embedding-providers.js";
+describe("OpenAICompatibleProvider — authorization behavior", () => {
+    it("uses explicit apiKey when provided", async () => {
+        const fn = new OpenAICompatibleProvider({
+            url: "https://api.example.com/v1",
+            model: "text-embedding-3-small",
+            apiKey: "sk-real-token",
+        });
+        const seen = {};
+        mock.method(globalThis, "fetch", async (_url, init) => {
+            seen.authHeader = new Headers(init?.headers).get("Authorization") ?? undefined;
+            return new Response(JSON.stringify({ data: [{ embedding: [0.1] }] }), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            });
+        });
+        await fn.embed(["hello"], "query");
+        assert.equal(seen.authHeader, "Bearer sk-real-token");
+    });
+    it("omits Authorization header when apiKey is explicitly null", async () => {
+        // Some local servers reject 'Bearer ollama' as invalid auth.
+        // Callers can opt out by passing `apiKey: null`.
+        const fn = new OpenAICompatibleProvider({
+            url: "http://127.0.0.1:11434/v1",
+            model: "nomic-embed-text",
+            apiKey: null,
+        });
+        const seen = {};
+        mock.method(globalThis, "fetch", async (_url, init) => {
+            seen.authHeader = new Headers(init?.headers).get("Authorization") ?? undefined;
+            return new Response(JSON.stringify({ data: [{ embedding: [0.1] }] }), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            });
+        });
+        await fn.embed(["hello"], "query");
+        assert.equal(seen.authHeader, undefined);
+    });
+});
+describe("OpenAICompatibleProvider — embed() contract", () => {
+    afterEach(() => mock.restoreAll());
+    it("returns one vector per text, in order", async () => {
+        const fn = new OpenAICompatibleProvider({
+            url: "http://127.0.0.1:11434/v1",
+            model: "nomic-embed-text",
+            apiKey: "ollama",
+        });
+        mock.method(globalThis, "fetch", async () => {
+            return new Response(JSON.stringify({
+                data: [{ embedding: [0.1, 0.2] }, { embedding: [0.3, 0.4] }, { embedding: [0.5, 0.6] }],
+            }), { status: 200, headers: { "Content-Type": "application/json" } });
+        });
+        const vecs = await fn.embed(["a", "b", "c"], "document");
+        assert.deepEqual(vecs, [
+            [0.1, 0.2],
+            [0.3, 0.4],
+            [0.5, 0.6],
+        ]);
+    });
+    it("throws on a non-2xx response with the status code + body in the message", async () => {
+        const fn = new OpenAICompatibleProvider({
+            url: "http://127.0.0.1:11434/v1",
+            model: "nomic-embed-text",
+        });
+        mock.method(globalThis, "fetch", async () => {
+            return new Response("rate limit exceeded", { status: 429 });
+        });
+        await assert.rejects(() => fn.embed(["a"], "query"), /Embed failed: 429 rate limit exceeded/);
+    });
+    it("throws on a malformed response (missing `data` array)", async () => {
+        const fn = new OpenAICompatibleProvider({
+            url: "http://127.0.0.1:11434/v1",
+            model: "nomic-embed-text",
+        });
+        mock.method(globalThis, "fetch", async () => {
+            return new Response(JSON.stringify({ error: "oops" }), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            });
+        });
+        await assert.rejects(() => fn.embed(["a"], "query"), /Invalid embedding response/);
+    });
+});
+describe("createProvider — factory resolution order", () => {
+    let seenAuthHeaders;
+    afterEach(() => mock.restoreAll());
+    const baseCfg = {
+        dataDir: ".lancedb",
+        embedding: { localUrl: "http://127.0.0.1:11434/v1" },
+    };
+    beforeEach(() => {
+        seenAuthHeaders = [];
+        mock.method(globalThis, "fetch", async (_url, init) => {
+            seenAuthHeaders.push(new Headers(init?.headers).get("Authorization") ?? undefined);
+            return new Response(JSON.stringify({ data: [{ embedding: [0.1] }] }), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            });
+        });
+    });
+    it("picks OpenAICompatible when localUrl is set", async () => {
+        const p = await createProvider(baseCfg);
+        assert.equal(p.id.startsWith("openai-compatible:"), true);
+        assert.equal(p.dim(), undefined);
+    });
+    it("picks Modal when remoteUrl is set (remoteUrl wins over localUrl)", async () => {
+        const cfg = {
+            ...baseCfg,
+            embedding: {
+                ...baseCfg.embedding,
+                remoteUrl: "https://example.modal.run",
+            },
+        };
+        const p = await createProvider(cfg);
+        assert.equal(p.id.startsWith("modal:"), true);
+    });
+    it("throws when no provider is configured and useTransformers is false", async () => {
+        const cfg = {
+            dataDir: ".lancedb",
+            embedding: { useTransformers: false },
+        };
+        await assert.rejects(() => createProvider(cfg), /No embedding provider configured/);
+    });
+    it("local provider resolves PVM_LOCAL_EMBEDDING_API_KEY independently", async () => {
+        const savedLocal = process.env.PVM_LOCAL_EMBEDDING_API_KEY;
+        const savedBridge = process.env.PVM_API_TOKEN;
+        process.env.PVM_LOCAL_EMBEDDING_API_KEY = "LOCAL_PROVIDER_SENTINEL";
+        process.env.PVM_API_TOKEN = "BRIDGE_ONLY_SENTINEL";
+        try {
+            const provider = await createProvider(baseCfg);
+            const vectors = await provider.embed(["contract"], "query");
+            assert.deepEqual(vectors, [[0.1]]);
+            assert.deepEqual(seenAuthHeaders, [
+                "Bearer LOCAL_PROVIDER_SENTINEL",
+                "Bearer LOCAL_PROVIDER_SENTINEL",
+            ]);
+            assert.equal(JSON.stringify(vectors).includes("LOCAL_PROVIDER_SENTINEL"), false);
+            assert.equal(JSON.stringify(vectors).includes("BRIDGE_ONLY_SENTINEL"), false);
+        }
+        finally {
+            if (savedLocal === undefined)
+                delete process.env.PVM_LOCAL_EMBEDDING_API_KEY;
+            else
+                process.env.PVM_LOCAL_EMBEDDING_API_KEY = savedLocal;
+            if (savedBridge === undefined)
+                delete process.env.PVM_API_TOKEN;
+            else
+                process.env.PVM_API_TOKEN = savedBridge;
+        }
+    });
+    it("passes the dims hint to the OpenAI-compatible provider", async () => {
+        const p = await createProvider(baseCfg, { dims: 768 });
+        assert.equal(p.dim(), 768);
+    });
+});