pi-vault-mind 0.14.2 → 0.16.3

package/dist/test/modal-config.test.js

@@ -1,95 +1,121 @@
 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 } from "node:test";
-import { MODAL_TOKEN_ENV, MODAL_TOKEN_ENV_PATH, createModalClient, isModalConfigured, modalUrl, namespacedTableName, resolveBaseUrl, resolveDim, resolveModalToken, resolveModel, resolveWorkspace, } from "../src/modal-config.js";
+import { createModalClient, getModalToken, isModalConfigured, modalTokenEnvPath, modalUrl, namespacedTableName, resolveBaseUrl, resolveDim, resolveModalToken, resolveModel, resolveWorkspace, } from "../src/modal-config.js";
 const makeCfg = (over = {}) => ({
     dataDir: ".lancedb",
     embedding: { remoteUrl: "https://pvm.modal.run" },
     ...over,
 });
+const REMOTE_ENV = "PVM_REMOTE_EMBEDDING_API_KEY";
+const BRIDGE_ENV = "PVM_API_TOKEN";
+const PROVIDER_ENV_KEYS = [
+    REMOTE_ENV,
+    BRIDGE_ENV,
+    "PVM_MODAL_READ_TOKEN",
+    "PVM_MODAL_WRITE_TOKEN",
+];
 describe("modal-config", () => {
-    let origToken;
-    let dotenvExisted = false;
-    let dotenvBak = "";
-    beforeEach(async () => {
-        origToken = process.env[MODAL_TOKEN_ENV];
-        // Also guard against the dotenv file (~/.pi/agent/vault-mind.env)
-        // which resolveModalToken reads as a fallback.
-        const fs = await import("node:fs");
-        if (fs.existsSync(MODAL_TOKEN_ENV_PATH)) {
-            dotenvExisted = true;
-            dotenvBak = `${MODAL_TOKEN_ENV_PATH}.bak`;
-            fs.renameSync(MODAL_TOKEN_ENV_PATH, dotenvBak);
+    let originalCwd;
+    let testDir;
+    let savedEnvironment;
+    beforeEach(() => {
+        originalCwd = process.cwd();
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), "pvm-modal-config-"));
+        process.chdir(testDir);
+        savedEnvironment = {};
+        for (const key of PROVIDER_ENV_KEYS) {
+            savedEnvironment[key] = process.env[key];
+            delete process.env[key];
         }
     });
-    afterEach(async () => {
-        if (origToken === undefined)
-            delete process.env[MODAL_TOKEN_ENV];
-        else
-            process.env[MODAL_TOKEN_ENV] = origToken;
-        if (dotenvExisted) {
-            const fs = await import("node:fs");
-            fs.renameSync(dotenvBak, MODAL_TOKEN_ENV_PATH);
-            dotenvExisted = false;
+    afterEach(() => {
+        for (const key of PROVIDER_ENV_KEYS) {
+            const value = savedEnvironment[key];
+            if (value === undefined)
+                delete process.env[key];
+            else
+                process.env[key] = value;
         }
+        process.chdir(originalCwd);
+        fs.rmSync(testDir, { recursive: true, force: true });
     });
-    it("resolveModalToken: env wins over config apiToken", () => {
-        process.env[MODAL_TOKEN_ENV] = "env-token";
+    it("resolveModalToken: remote provider env wins over legacy config", () => {
+        process.env[REMOTE_ENV] = "REMOTE_ENV_SENTINEL";
         const cfg = makeCfg({
             embedding: {
                 remoteUrl: "https://pvm.modal.run",
-                modal: { baseUrl: "https://x", apiToken: "cfg-token" },
+                remoteApiKey: "REMOTE_LEGACY_SENTINEL",
             },
         });
-        assert.equal(resolveModalToken(cfg), "env-token");
+        assert.equal(resolveModalToken(cfg), "REMOTE_ENV_SENTINEL");
     });
-    it("resolveModalToken: config apiToken is the fallback", () => {
-        delete process.env[MODAL_TOKEN_ENV];
+    it("resolveModalToken: legacy config is the fallback", () => {
         const cfg = makeCfg({
             embedding: {
                 remoteUrl: "https://pvm.modal.run",
-                modal: { baseUrl: "https://x", apiToken: "cfg-token" },
+                remoteApiKey: "REMOTE_LEGACY_SENTINEL",
             },
         });
-        assert.equal(resolveModalToken(cfg), "cfg-token");
-    });
-    it("resolveModalToken: undefined when neither set", () => {
-        delete process.env[MODAL_TOKEN_ENV];
-        const cfg = makeCfg({
-            embedding: { remoteUrl: "https://pvm.modal.run", modal: { baseUrl: "https://x" } },
+        assert.equal(resolveModalToken(cfg), "REMOTE_LEGACY_SENTINEL");
+    });
+    it("PVM_API_TOKEN never resolves a remote provider credential", () => {
+        const cfg = makeCfg();
+        process.env[BRIDGE_ENV] = "BRIDGE_ONLY_SENTINEL";
+        const fromProcess = [
+            resolveModalToken(cfg),
+            getModalToken(cfg, "read"),
+            getModalToken(cfg, "write"),
+        ];
+        delete process.env[BRIDGE_ENV];
+        fs.mkdirSync(path.dirname(modalTokenEnvPath()), { recursive: true });
+        fs.writeFileSync(modalTokenEnvPath(), 'PVM_API_TOKEN="BRIDGE_ONLY_SENTINEL"\n', "utf-8");
+        const fromStore = [
+            resolveModalToken(cfg),
+            getModalToken(cfg, "read"),
+            getModalToken(cfg, "write"),
+        ];
+        const result = { fromProcess, fromStore };
+        assert.deepEqual(result, {
+            fromProcess: [undefined, undefined, undefined],
+            fromStore: [undefined, undefined, undefined],
         });
-        assert.equal(resolveModalToken(cfg), undefined);
+        assert.equal(JSON.stringify(result).includes("BRIDGE_ONLY_SENTINEL"), false);
+        assert.equal(JSON.stringify(result).includes("REMOTE_PROVIDER_SENTINEL"), false);
     });
     it("createModalClient: null when not configured (no baseUrl or token)", () => {
-        delete process.env[MODAL_TOKEN_ENV];
+        delete process.env[REMOTE_ENV];
         assert.equal(createModalClient(makeCfg()), null);
         assert.equal(createModalClient(makeCfg({
-            embedding: { remoteUrl: "https://pvm.modal.run", modal: { baseUrl: "https://x" } },
+            embedding: { remoteUrl: "https://pvm.modal.run" },
         })), null);
     });
     it("createModalClient: builds a client when baseUrl + token present", () => {
-        process.env[MODAL_TOKEN_ENV] = "tok";
+        process.env[REMOTE_ENV] = "tok";
         const c = createModalClient(makeCfg({
-            embedding: { remoteUrl: "https://pvm.modal.run", modal: { baseUrl: "https://x/" } },
+            embedding: { remoteUrl: "https://pvm.modal.run" },
         }));
         assert.ok(c);
     });
     it("isModalConfigured: requires provider modal + baseUrl + token", () => {
-        delete process.env[MODAL_TOKEN_ENV];
+        delete process.env[REMOTE_ENV];
         assert.equal(isModalConfigured(makeCfg()), false);
-        process.env[MODAL_TOKEN_ENV] = "tok";
+        process.env[REMOTE_ENV] = "tok";
         assert.equal(isModalConfigured(makeCfg({
-            embedding: { remoteUrl: "https://pvm.modal.run", modal: { baseUrl: "https://x" } },
+            embedding: { remoteUrl: "https://pvm.modal.run" },
         })), true);
         // ollama provider is not modal-configured
         assert.equal(isModalConfigured(makeCfg({
-            embedding: { localUrl: "http://127.0.0.1:11434/v1", modal: { baseUrl: "https://x" } },
+            embedding: { localUrl: "http://127.0.0.1:11434/v1" },
         })), false);
     });
-    it("resolveModel: per-collection override wins, then modal.model, default embeddinggemma", () => {
+    it("resolveModel: per-collection override wins, then embedding.model, default embeddinggemma", () => {
         const cfg = makeCfg({
             embedding: {
                 remoteUrl: "https://pvm.modal.run",
-                modal: { baseUrl: "https://x", model: "global-model" },
+                model: "global-model",
                 collectionModels: { special: { model: "special-model", dim: 128 } },
             },
         });
@@ -98,11 +124,11 @@ describe("modal-config", () => {
         assert.equal(resolveModel(cfg, "other"), "global-model");
         assert.equal(resolveModel(makeCfg()), "embeddinggemma");
     });
-    it("resolveDim: per-collection override wins, then modal.dim", () => {
+    it("resolveDim: per-collection override wins, then embedding.dim", () => {
         const cfg = makeCfg({
             embedding: {
                 remoteUrl: "https://pvm.modal.run",
-                modal: { baseUrl: "https://x", dim: 512 },
+                dim: 512,
                 collectionModels: { special: { model: "m", dim: 128 } },
             },
         });
@@ -110,63 +136,50 @@ describe("modal-config", () => {
         assert.equal(resolveDim(cfg, "special"), 128);
         assert.equal(resolveDim(makeCfg()), undefined);
     });
-    it("resolveModalToken: dotenv file is a fallback when env is unset", async () => {
-        delete process.env[MODAL_TOKEN_ENV];
-        const fs = await import("node:fs");
-        const path = await import("node:path");
-        const dir = path.dirname(MODAL_TOKEN_ENV_PATH);
-        if (!fs.existsSync(dir))
-            fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(MODAL_TOKEN_ENV_PATH, 'PVM_API_TOKEN="dotenv-token"\n', "utf-8");
-        try {
-            const cfg = makeCfg({
-                embedding: { remoteUrl: "https://pvm.modal.run", modal: { baseUrl: "https://x" } },
-            });
-            assert.equal(resolveModalToken(cfg), "dotenv-token");
-        }
-        finally {
-            fs.rmSync(MODAL_TOKEN_ENV_PATH, { force: true });
-        }
+    it("resolveModalToken: dotenv file is a fallback when env is unset", () => {
+        fs.mkdirSync(path.dirname(modalTokenEnvPath()), { recursive: true });
+        fs.writeFileSync(modalTokenEnvPath(), 'PVM_REMOTE_EMBEDDING_API_KEY="dotenv-token"\n', "utf-8");
+        const cfg = makeCfg({
+            embedding: { remoteUrl: "https://pvm.modal.run" },
+        });
+        assert.equal(resolveModalToken(cfg), "dotenv-token");
     });
     it("modalUrl derives the canonical service URL from workspace", () => {
         assert.equal(modalUrl("kylebrodeur"), "https://kylebrodeur--pi-vault-mind-embed-embeddingservice-fastapi-app.modal.run");
     });
-    it("resolveBaseUrl: explicit baseUrl wins over derived workspace URL", () => {
+    it("resolveBaseUrl: explicit remoteUrl wins over derived workspace URL", () => {
         const cfg = makeCfg({
             embedding: {
-                remoteUrl: "https://pvm.modal.run",
-                modal: {
-                    baseUrl: "https://explicit.example.com",
-                    workspace: "kylebrodeur",
-                },
+                remoteUrl: "https://explicit.example.com",
+                workspace: "kylebrodeur",
             },
         });
         assert.equal(resolveBaseUrl(cfg), "https://explicit.example.com");
     });
-    it("resolveBaseUrl: derives URL from workspace when baseUrl is missing", () => {
+    it("resolveBaseUrl: derives URL from workspace when remoteUrl is missing", () => {
         const cfg = makeCfg({
-            embedding: { remoteUrl: "https://pvm.modal.run", modal: { workspace: "kylebrodeur" } },
+            embedding: { workspace: "kylebrodeur" },
         });
         assert.equal(resolveBaseUrl(cfg), modalUrl("kylebrodeur"));
     });
     it("resolveWorkspace returns the configured workspace slug", () => {
         const cfg = makeCfg({
-            embedding: { remoteUrl: "https://pvm.modal.run", modal: { workspace: "kylebrodeur" } },
+            embedding: { remoteUrl: "https://pvm.modal.run", workspace: "kylebrodeur" },
         });
         assert.equal(resolveWorkspace(cfg), "kylebrodeur");
         assert.equal(resolveWorkspace(makeCfg()), undefined);
     });
     it("createModalClient: builds a client from workspace-derived URL", () => {
-        process.env[MODAL_TOKEN_ENV] = "tok";
+        process.env[REMOTE_ENV] = "tok";
         const c = createModalClient(makeCfg({
-            embedding: { remoteUrl: "https://pvm.modal.run", modal: { workspace: "kylebrodeur" } },
+            embedding: { workspace: "kylebrodeur" },
         }));
         assert.ok(c);
     });
-    it("isModalConfigured: true when workspace + token are present (no explicit baseUrl)", () => {
-        process.env[MODAL_TOKEN_ENV] = "tok";
+    it("isModalConfigured: true when remoteUrl + token are present (no explicit workspace)", () => {
+        process.env[REMOTE_ENV] = "tok";
         assert.equal(isModalConfigured(makeCfg({
-            embedding: { remoteUrl: "https://pvm.modal.run", modal: { workspace: "kylebrodeur" } },
+            embedding: { remoteUrl: "https://pvm.modal.run", workspace: "kylebrodeur" },
         })), true);
     });
     it("namespacedTableName mirrors the server's ADR-3 scheme", () => {

package/dist/test/model-readiness.test.js

@@ -0,0 +1,122 @@
+import { strict as assert } from "node:assert";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { after, before, beforeEach, describe, it } from "node:test";
+import { _resetAuthCache } from "../src/auth.js";
+import { fakePi, fetchJson, makeVault, startTestServer, TEST_TOKEN, } from "./helpers/server.js";
+const envVar = "PVM_API_TOKEN";
+const readyResponse = {
+    status: "ready",
+    model: { id: "test-model-id", name: "Test Model Name", provider: "test-provider" },
+};
+const allStatuses = [
+    { status: "model-registry-error" },
+    { status: "model-registry-empty" },
+    { status: "provider-authentication-required", authSource: "models_json_key" },
+    { status: "configured-provider-unavailable", providerId: "test-provider-down" },
+    { status: "model-selection-required" },
+    { status: "current-model-unavailable", modelId: "test-current-model" },
+    readyResponse,
+];
+describe("GET /vault-mind/model-readiness", () => {
+    let vaultPath;
+    let port;
+    let srv;
+    let savedEnv;
+    let savedCwd;
+    let callbackCalls;
+    const responseSentinel = "CALLBACK_RESPONSE_SENTINEL_42";
+    const baseCallback = async () => {
+        callbackCalls++;
+        return { ...readyResponse, model: { ...readyResponse.model, name: responseSentinel } };
+    };
+    before(async () => {
+        savedEnv = process.env[envVar];
+        savedCwd = process.cwd();
+        process.env[envVar] = TEST_TOKEN;
+        vaultPath = makeVault("model-readiness");
+        process.chdir(vaultPath);
+        fs.mkdirSync(path.join(vaultPath, ".vault-mind"), { recursive: true });
+        srv = await startTestServer(fakePi, baseCallback);
+        port = srv.port;
+    });
+    after(() => {
+        try {
+            srv.stop();
+        }
+        catch {
+            // ignore double-stop
+        }
+        if (savedEnv === undefined)
+            delete process.env[envVar];
+        else
+            process.env[envVar] = savedEnv;
+        process.chdir(savedCwd);
+        if (fs.existsSync(vaultPath))
+            fs.rmSync(vaultPath, { recursive: true, force: true });
+        _resetAuthCache();
+    });
+    beforeEach(() => {
+        callbackCalls = 0;
+    });
+    it("requires bearer auth and rejects requests without a token", async () => {
+        const { status, body } = await fetchJson(port, "GET", "/vault-mind/model-readiness");
+        assert.equal(status, 401);
+        assert.ok(typeof body === "object" && body !== null);
+        assert.equal(body.error, "unauthorized");
+        assert.equal(callbackCalls, 0, "callback must not run for unauthenticated request");
+        assert.equal(JSON.stringify(body).includes(responseSentinel), false, "sentinel must not leak");
+    });
+    it("rejects non-GET methods with 405", async () => {
+        const { status, body } = await fetchJson(port, "POST", "/vault-mind/model-readiness", {
+            token: TEST_TOKEN,
+        });
+        assert.equal(status, 405);
+        assert.ok(typeof body === "object" && body !== null);
+        assert.equal(body.error, "Method not allowed");
+        assert.equal(callbackCalls, 0, "callback must not run for disallowed method");
+        assert.equal(JSON.stringify(body).includes(responseSentinel), false, "sentinel must not leak");
+    });
+    it("returns 500 when the readiness callback is not installed", async () => {
+        const previous = srv.serverState.getModelReadiness;
+        srv.serverState.getModelReadiness = undefined;
+        try {
+            const { status, body } = await fetchJson(port, "GET", "/vault-mind/model-readiness", {
+                token: TEST_TOKEN,
+            });
+            assert.equal(status, 500);
+            assert.ok(typeof body === "object" && body !== null);
+            assert.equal(body.error, "Readiness callback not installed");
+        }
+        finally {
+            srv.serverState.getModelReadiness = previous;
+        }
+    });
+    it("returns every valid readiness status unchanged", async () => {
+        for (const expected of allStatuses) {
+            srv.serverState.getModelReadiness = async () => expected;
+            const { status, body } = await fetchJson(port, "GET", "/vault-mind/model-readiness", {
+                token: TEST_TOKEN,
+            });
+            assert.equal(status, 200, `expected 200 for status ${expected.status}`);
+            assert.deepEqual(body, expected, `status ${expected.status} must round-trip unchanged`);
+        }
+    });
+    it("redacts callback failures to model-registry-error without leaking exception details", async () => {
+        const sentinel = "SENTINEL_EXCEPTION_TEXT_98765";
+        srv.serverState.getModelReadiness = async () => {
+            throw new Error(sentinel);
+        };
+        const { status, body } = await fetchJson(port, "GET", "/vault-mind/model-readiness", {
+            token: TEST_TOKEN,
+        });
+        assert.equal(status, 200);
+        assert.deepEqual(body, { status: "model-registry-error" });
+        assert.equal(JSON.stringify(body).includes(sentinel), false, "sentinel must not leak");
+    });
+    it("clears the readiness callback on server stop", () => {
+        assert.equal(typeof srv.serverState.getModelReadiness, "function");
+        srv.stop();
+        assert.equal(srv.serverState.getModelReadiness, undefined);
+    });
+});

package/dist/test/model-router.test.js

@@ -0,0 +1,99 @@
+import { strict as assert } from "node:assert";
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { defaultModelRouterChoices, scaffoldModelRouterConfig } from "../src/model-router.js";
+import { resolveVaultMindPaths } from "../src/utils.js";
+const savedAgentDir = process.env.PI_CODING_AGENT_DIR;
+const savedHome = process.env.HOME;
+describe("defaultModelRouterChoices", () => {
+    it("returns the tuned primary model and a 4-entry fallback sequence", () => {
+        const { primary, fallbackSequence } = defaultModelRouterChoices();
+        assert.equal(primary, "ollama/gemma4:31b-cloud");
+        assert.ok(Array.isArray(fallbackSequence));
+        assert.equal(fallbackSequence.length, 4);
+    });
+    it("includes the common baseline entries regardless of platform", () => {
+        const { fallbackSequence } = defaultModelRouterChoices();
+        for (const entry of ["ollama/gemma4:e4b", "ollama/gemma3:4b", "ollama/*"]) {
+            assert.ok(fallbackSequence.includes(entry), `expected fallbackSequence to include ${entry}`);
+        }
+    });
+    it("includes exactly one of the platform-specific mid-tier variants", () => {
+        const { fallbackSequence } = defaultModelRouterChoices();
+        const macVariant = fallbackSequence.includes("ollama/gemma4:12b-mlx");
+        const otherVariant = fallbackSequence.includes("ollama/gemma4:12b");
+        // Exactly one of the two platform-specific entries is present — never both,
+        // never neither — without hardcoding which platform CI happens to run on.
+        assert.notEqual(macVariant, otherVariant);
+    });
+});
+describe("scaffoldModelRouterConfig", () => {
+    let testDir;
+    beforeEach(() => {
+        testDir = path.join(tmpdir(), `model-router-test-${randomUUID()}`);
+        fs.mkdirSync(testDir, { recursive: true });
+        // Isolate the resolved agent dir under the temp vault so this test never
+        // touches the real ~/.pi/agent (getAgentDir() falls back to homedir()
+        // when PI_CODING_AGENT_DIR is unset).
+        process.env.PI_CODING_AGENT_DIR = path.join(testDir, ".vault-mind", ".pi", "agent");
+        process.env.HOME = testDir;
+    });
+    afterEach(() => {
+        if (savedAgentDir === undefined) {
+            Reflect.deleteProperty(process.env, "PI_CODING_AGENT_DIR");
+        }
+        else {
+            process.env.PI_CODING_AGENT_DIR = savedAgentDir;
+        }
+        if (savedHome === undefined) {
+            Reflect.deleteProperty(process.env, "HOME");
+        }
+        else {
+            process.env.HOME = savedHome;
+        }
+        try {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+        catch {
+            /* ignore */
+        }
+    });
+    it("resolves to resolveVaultMindPaths(cwd).modelRouter", () => {
+        const expectedPath = resolveVaultMindPaths(testDir).modelRouter;
+        const result = scaffoldModelRouterConfig(testDir);
+        assert.equal(result.path, expectedPath);
+    });
+    it("creates model-router.json with the tuned defaults on first call", () => {
+        const expectedPath = resolveVaultMindPaths(testDir).modelRouter;
+        const result = scaffoldModelRouterConfig(testDir);
+        assert.deepEqual(result, { created: true, path: expectedPath });
+        assert.ok(fs.existsSync(expectedPath), "expected model-router.json to be written");
+        const parsed = JSON.parse(fs.readFileSync(expectedPath, "utf-8"));
+        assert.equal(parsed.defaultProfile, "auto");
+        assert.equal(typeof parsed.features, "object");
+        assert.ok(parsed.features);
+        assert.equal(typeof parsed.rateLimitFallback, "object");
+        assert.ok(Array.isArray(parsed.rateLimitFallback.fallbackSequence));
+        for (const tier of ["high", "medium", "low"]) {
+            const profile = parsed.profiles.auto[tier];
+            assert.ok(profile, `expected profiles.auto.${tier} to be defined`);
+            assert.equal(typeof profile.model, "string");
+            assert.equal(typeof profile.thinking, "string");
+        }
+    });
+    it("never overwrites an existing model-router.json (idempotent)", () => {
+        const expectedPath = resolveVaultMindPaths(testDir).modelRouter;
+        const first = scaffoldModelRouterConfig(testDir);
+        assert.equal(first.created, true);
+        const written = JSON.parse(fs.readFileSync(expectedPath, "utf-8"));
+        written.defaultProfile = "custom";
+        fs.writeFileSync(expectedPath, `${JSON.stringify(written, null, 2)}\n`, "utf-8");
+        const second = scaffoldModelRouterConfig(testDir);
+        assert.deepEqual(second, { created: false, path: expectedPath });
+        const unchanged = JSON.parse(fs.readFileSync(expectedPath, "utf-8"));
+        assert.equal(unchanged.defaultProfile, "custom");
+    });
+});

package/dist/test/obsidian-client.test.js

@@ -0,0 +1,42 @@
+import { strict as assert } from "node:assert";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { VaultMindClient } from "../packages/obsidian/src/client.js";
+describe("VaultMindClient", () => {
+    let originalFetch;
+    beforeEach(() => {
+        originalFetch = globalThis.fetch;
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    it("listActivity encodes filters and returns activity events", async () => {
+        const jobId = "job/with spaces&symbols";
+        const responseBody = [
+            {
+                id: 1,
+                jobId,
+                ts: "2026-07-12T00:00:00.000Z",
+                kind: "status",
+                label: "status changed",
+                tone: "neutral",
+            },
+        ];
+        let captured;
+        globalThis.fetch = async (input, init) => {
+            const rawUrl = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+            captured = { url: new URL(rawUrl), init: init ?? {} };
+            return new Response(JSON.stringify(responseBody), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            });
+        };
+        const client = new VaultMindClient({ host: "127.0.0.1", port: 11435, token: "client-token" });
+        const result = await client.listActivity({ jobId, limit: 7 });
+        assert.deepEqual(result, responseBody);
+        assert.ok(captured);
+        assert.equal(captured.url.pathname, "/agent/activity");
+        assert.equal(captured.url.searchParams.get("jobId"), jobId);
+        assert.equal(captured.url.searchParams.get("limit"), "7");
+        assert.equal(captured.init.method, "GET");
+    });
+});

package/dist/test/personalize.test.js

@@ -17,7 +17,7 @@ const setupConfig = (dir) => {
         injectors: [],
         vaultMind: {
             dataDir: ".lancedb",
-            embedding: { provider: "transformers" },
+            embedding: {},
             ftsEnabled: false,
             graph: { enabled: false },
         },