@vellumai/assistant 0.11.0 → 0.11.1-staging.2

package/src/persistence/embeddings/__tests__/plugin-facade-index.test.ts

@@ -0,0 +1,73 @@
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { runInPluginContext } from "../../../plugins/plugin-execution-context.js";
+
+// ---------------------------------------------------------------------------
+// Verifies the facade's plugin-scoping guard: the index operations must run
+// inside a plugin execution context, and they pass the context's plugin name
+// (never a caller argument) down to the host layer. This file runs in its own
+// Bun process, so these mocks cannot leak elsewhere.
+// ---------------------------------------------------------------------------
+
+const received = { plugin: null as string | null };
+
+mock.module("../plugin-index.js", () => ({
+  computeEmbedding: async () => ({
+    vector: [0],
+    provider: "p",
+    model: "m",
+    dimensions: 1,
+  }),
+  computeSparseEmbedding: () => ({ indices: [], values: [] }),
+  indexDocument: async (_cfg: unknown, plugin: string) => {
+    received.plugin = plugin;
+    return { documentId: "d", provider: "p", model: "m", dimensions: 1 };
+  },
+  queryIndex: async (_cfg: unknown, plugin: string) => {
+    received.plugin = plugin;
+    return [];
+  },
+  getDocument: async (plugin: string) => {
+    received.plugin = plugin;
+    return null;
+  },
+  removeDocument: async (plugin: string) => {
+    received.plugin = plugin;
+  },
+}));
+mock.module("../../../config/loader.js", () => ({ getConfig: () => ({}) }));
+
+const facade = await import("../plugin-facade.js");
+
+beforeEach(() => {
+  received.plugin = null;
+});
+
+afterAll(() => {
+  mock.restore();
+});
+
+describe("plugin index facade guard", () => {
+  test("index/query/get/remove reject outside any plugin context", async () => {
+    await expect(facade.indexDocument("x")).rejects.toThrow(
+      /active plugin execution context/,
+    );
+    await expect(facade.queryIndex("x")).rejects.toThrow(
+      /active plugin execution context/,
+    );
+    await expect(facade.getDocument("d")).rejects.toThrow(
+      /active plugin execution context/,
+    );
+    await expect(facade.removeDocument("d")).rejects.toThrow(
+      /active plugin execution context/,
+    );
+  });
+
+  test("the context's plugin name is what reaches the host layer", async () => {
+    await runInPluginContext("alice", () => facade.getDocument("d"));
+    expect(received.plugin).toBe("alice");
+
+    await runInPluginContext("bob", () => facade.indexDocument("note"));
+    expect(received.plugin).toBe("bob");
+  });
+});

package/src/persistence/embeddings/__tests__/plugin-index.test.ts

@@ -0,0 +1,323 @@
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { SparseEmbedding } from "../embedding-types.js";
+
+// ---------------------------------------------------------------------------
+// Boundary mocks. This file runs in its own Bun process (see scripts/test.ts),
+// so mock.module here cannot leak into other test files. The fake Qdrant
+// honors the same (target_type, target_id, plugin) scoping the real client
+// enforces, so cross-plugin isolation is actually exercised.
+// ---------------------------------------------------------------------------
+
+interface StoredPoint {
+  target_type: string;
+  target_id: string;
+  plugin?: string;
+  [k: string]: unknown;
+}
+interface UpsertCall {
+  targetType: string;
+  targetId: string;
+  payload: Record<string, unknown>;
+  sparse?: SparseEmbedding;
+}
+
+const calls = {
+  upserts: [] as UpsertCall[],
+  hybrid: [] as Array<{ filter?: unknown }>,
+  search: [] as Array<{ limit: number; filter: unknown }>,
+  get: [] as Array<{ targetId: string; plugin?: string }>,
+  deleteScoped: [] as Array<{ targetId: string; plugin: string }>,
+  deletePlugin: [] as string[],
+};
+// Keyed by the (globally unique, namespace-qualified) target_id.
+const store = new Map<string, StoredPoint>();
+
+/** Extract a matched value for `key` from a Qdrant-style must filter. */
+function mustValue(filter: unknown, key: string): unknown {
+  const must =
+    (filter as { must?: Array<Record<string, unknown>> })?.must ?? [];
+  for (const cond of must) {
+    if (cond.key === key) {
+      return (cond.match as { value?: unknown } | undefined)?.value;
+    }
+  }
+  return undefined;
+}
+
+function pointsMatchingFilter(filter: unknown): StoredPoint[] {
+  const tt = mustValue(filter, "target_type");
+  const plugin = mustValue(filter, "plugin");
+  return [...store.values()].filter(
+    (p) =>
+      (tt === undefined || p.target_type === tt) &&
+      (plugin === undefined || p.plugin === plugin),
+  );
+}
+
+const fakeQdrant = {
+  async upsert(
+    targetType: string,
+    targetId: string,
+    _vector: number[],
+    payload: Record<string, unknown>,
+    sparse?: SparseEmbedding,
+  ) {
+    calls.upserts.push({ targetType, targetId, payload, sparse });
+    store.set(targetId, {
+      target_type: targetType,
+      target_id: targetId,
+      ...payload,
+    });
+    return targetId;
+  },
+  async hybridSearch(params: { filter?: unknown }) {
+    calls.hybrid.push({ filter: params.filter });
+    return pointsMatchingFilter(params.filter).map((p) => ({
+      id: p.target_id,
+      score: 0.9,
+      payload: p,
+    }));
+  },
+  async search(_vector: number[], limit: number, filter: unknown) {
+    calls.search.push({ limit, filter });
+    return pointsMatchingFilter(filter).map((p) => ({
+      id: p.target_id,
+      score: 0.5,
+      payload: p,
+    }));
+  },
+  async getByTarget(
+    targetType: string,
+    targetId: string,
+    opts?: { plugin?: string },
+  ) {
+    calls.get.push({ targetId, plugin: opts?.plugin });
+    const p = store.get(targetId);
+    if (!p || p.target_type !== targetType) {
+      return null;
+    }
+    if (opts?.plugin !== undefined && p.plugin !== opts.plugin) {
+      return null;
+    }
+    return { id: targetId, payload: p };
+  },
+  async deleteByTargetAndPlugin(
+    targetType: string,
+    targetId: string,
+    plugin: string,
+  ) {
+    calls.deleteScoped.push({ targetId, plugin });
+    const p = store.get(targetId);
+    if (p && p.target_type === targetType && p.plugin === plugin) {
+      store.delete(targetId);
+    }
+  },
+  async deleteByPlugin(plugin: string) {
+    calls.deletePlugin.push(plugin);
+    for (const [k, p] of [...store.entries()]) {
+      if (p.plugin === plugin) {
+        store.delete(k);
+      }
+    }
+  },
+};
+
+mock.module("../qdrant-client.js", () => ({
+  getQdrantClient: () => fakeQdrant,
+}));
+mock.module("../qdrant-circuit-breaker.js", () => ({
+  withQdrantBreaker: <T>(fn: () => Promise<T>) => fn(),
+}));
+mock.module("../embed.js", () => ({
+  embedWithRetry: async () => ({
+    provider: "gemini",
+    model: "test-embed-model",
+    vectors: [[0.1, 0.2, 0.3]],
+  }),
+}));
+mock.module("../embedding-backend.js", () => ({
+  getMemoryBackendStatus: async () => ({
+    enabled: true,
+    degraded: false,
+    provider: "gemini",
+    model: "test-embed-model",
+    reason: null,
+  }),
+  // Mirror the real encoder: text with word chars yields a non-empty sparse
+  // vector; a whitespace/punctuation-only string yields an empty one (which
+  // drives the dense-only query fallback).
+  generateSparseEmbedding: (text: string): SparseEmbedding =>
+    /[\p{L}\p{N}]/u.test(text)
+      ? { indices: [1, 2], values: [0.5, 0.5] }
+      : { indices: [], values: [] },
+}));
+
+const {
+  computeEmbedding,
+  computeSparseEmbedding,
+  indexDocument,
+  queryIndex,
+  getDocument,
+  removeDocument,
+  purgeEmbeddingsForPlugin,
+} = await import("../plugin-index.js");
+
+// A stand-in config; every host boundary that reads it is mocked above.
+const CONFIG = {} as never;
+
+beforeEach(() => {
+  store.clear();
+  calls.upserts.length = 0;
+  calls.hybrid.length = 0;
+  calls.search.length = 0;
+  calls.get.length = 0;
+  calls.deleteScoped.length = 0;
+  calls.deletePlugin.length = 0;
+});
+
+afterAll(() => {
+  mock.restore();
+});
+
+describe("compute-only", () => {
+  test("computeEmbedding returns the dense vector with provenance", async () => {
+    const result = await computeEmbedding(CONFIG, "hello world");
+    expect(result.vector).toEqual([0.1, 0.2, 0.3]);
+    expect(result.provider).toBe("gemini");
+    expect(result.model).toBe("test-embed-model");
+    expect(result.dimensions).toBe(3);
+    // Compute-only: nothing is persisted.
+    expect(calls.upserts).toHaveLength(0);
+  });
+
+  test("computeSparseEmbedding is pure, no upsert", () => {
+    const sparse = computeSparseEmbedding("budget call notes");
+    expect(sparse.indices.length).toBeGreaterThan(0);
+    expect(calls.upserts).toHaveLength(0);
+  });
+});
+
+describe("plugin-owned index", () => {
+  test("indexDocument tags the plugin, namespace-qualifies the point, returns a bare id", async () => {
+    const res = await indexDocument(
+      CONFIG,
+      "ledger",
+      "budget call with Alice",
+      {
+        metadata: { rowId: "row-42" },
+      },
+    );
+    expect(res.documentId).toBeTruthy();
+    expect(calls.upserts).toHaveLength(1);
+    const up = calls.upserts[0];
+    expect(up.targetType).toBe("plugin_index");
+    // Point id is namespace-qualified; the bare id round-trips via document_id.
+    expect(up.targetId).toBe(`ledger:${res.documentId}`);
+    expect(up.payload.plugin).toBe("ledger");
+    expect(up.payload.document_id).toBe(res.documentId);
+    expect(up.payload.meta).toEqual({ rowId: "row-42" });
+    expect(up.payload.text).toBe("budget call with Alice");
+    // Text input carries a sparse vector for hybrid search.
+    expect(up.sparse?.indices.length).toBeGreaterThan(0);
+  });
+
+  test("indexDocument reuses a caller-supplied documentId (update path)", async () => {
+    const first = await indexDocument(CONFIG, "ledger", "v1", {
+      documentId: "fixed-id",
+    });
+    const second = await indexDocument(CONFIG, "ledger", "v2", {
+      documentId: "fixed-id",
+    });
+    expect(first.documentId).toBe("fixed-id");
+    expect(second.documentId).toBe("fixed-id");
+    expect(calls.upserts.map((u) => u.targetId)).toEqual([
+      "ledger:fixed-id",
+      "ledger:fixed-id",
+    ]);
+  });
+
+  test("two plugins can share a documentId without colliding", async () => {
+    await indexDocument(CONFIG, "ledger", "ledger note", {
+      documentId: "shared",
+    });
+    await indexDocument(CONFIG, "drive", "drive note", {
+      documentId: "shared",
+    });
+    // Distinct namespace-qualified points, not one overwritten point.
+    expect(store.size).toBe(2);
+    const ledgerDoc = await getDocument("ledger", "shared");
+    const driveDoc = await getDocument("drive", "shared");
+    expect(ledgerDoc?.text).toBe("ledger note");
+    expect(driveDoc?.text).toBe("drive note");
+  });
+
+  test("queryIndex hybrid-searches scoped to the calling plugin", async () => {
+    await indexDocument(CONFIG, "ledger", "budget call", {
+      metadata: { rowId: "row-1" },
+    });
+    const hits = await queryIndex(CONFIG, "ledger", "budget");
+    expect(calls.hybrid).toHaveLength(1);
+    const filter = calls.hybrid[0].filter as {
+      must: Array<Record<string, { value: string }>>;
+    };
+    expect(filter.must).toEqual(
+      expect.arrayContaining([
+        { key: "target_type", match: { value: "plugin_index" } },
+        { key: "plugin", match: { value: "ledger" } },
+      ]),
+    );
+    expect(hits[0]).toMatchObject({
+      documentId: expect.any(String),
+      text: "budget call",
+      metadata: { rowId: "row-1" },
+    });
+  });
+
+  test("queryIndex only returns the calling plugin's documents", async () => {
+    await indexDocument(CONFIG, "ledger", "budget call", { documentId: "a" });
+    await indexDocument(CONFIG, "drive", "budget report", { documentId: "b" });
+    const hits = await queryIndex(CONFIG, "ledger", "budget");
+    expect(hits.map((h) => h.documentId)).toEqual(["a"]);
+  });
+
+  test("queryIndex falls back to dense-only when the query has no tokens", async () => {
+    await indexDocument(CONFIG, "ledger", "budget call");
+    await queryIndex(CONFIG, "ledger", "   ");
+    expect(calls.hybrid).toHaveLength(0);
+    expect(calls.search).toHaveLength(1);
+  });
+
+  test("getDocument is scoped: one plugin cannot read another's document", async () => {
+    const { documentId } = await indexDocument(CONFIG, "ledger", "secret note");
+    // Owner can read it back.
+    const own = await getDocument("ledger", documentId);
+    expect(own?.text).toBe("secret note");
+    // A different plugin guessing the id gets nothing (plugin-scoped filter).
+    const other = await getDocument("evil", documentId);
+    expect(other).toBeNull();
+    expect(calls.get.at(-1)).toEqual({
+      targetId: `evil:${documentId}`,
+      plugin: "evil",
+    });
+  });
+
+  test("removeDocument deletes scoped to the calling plugin", async () => {
+    const { documentId } = await indexDocument(CONFIG, "ledger", "note");
+    await removeDocument("ledger", documentId);
+    expect(calls.deleteScoped).toEqual([
+      { targetId: `ledger:${documentId}`, plugin: "ledger" },
+    ]);
+    expect(await getDocument("ledger", documentId)).toBeNull();
+  });
+
+  test("purgeEmbeddingsForPlugin drops the whole plugin namespace", async () => {
+    await indexDocument(CONFIG, "ledger", "a");
+    await indexDocument(CONFIG, "ledger", "b");
+    await indexDocument(CONFIG, "other", "c");
+    await purgeEmbeddingsForPlugin("ledger");
+    expect(calls.deletePlugin).toEqual(["ledger"]);
+    // The other plugin's document survives.
+    expect([...store.values()].map((p) => p.plugin)).toEqual(["other"]);
+  });
+});

package/src/persistence/embeddings/embed.ts

@@ -31,16 +31,22 @@ export async function embedWithRetry(
       return await embedWithBackend(config, texts, opts);
     } catch (err) {
       lastError = err;
-      if (opts?.signal?.aborted || isAbortError(err)) throw err;
+      if (opts?.signal?.aborted || isAbortError(err)) {
+        throw err;
+      }
       const isTransient = isTransientEmbeddingError(err);
-      if (!isTransient || attempt === EMBED_MAX_RETRIES) throw err;
+      if (!isTransient || attempt === EMBED_MAX_RETRIES) {
+        throw err;
+      }
       const delay = computeRetryDelay(attempt, EMBED_BASE_DELAY_MS);
       log.warn(
         { err, attempt: attempt + 1, delayMs: Math.round(delay) },
         "Transient embedding failure, retrying",
       );
       await abortableSleep(delay, opts?.signal);
-      if (opts?.signal?.aborted) throw err;
+      if (opts?.signal?.aborted) {
+        throw err;
+      }
     }
   }
   throw lastError;
@@ -51,7 +57,9 @@ export async function embedWithRetry(
  * immediately rather than being retried.
  */
 export function isAbortError(err: unknown): boolean {
-  if (!(err instanceof Error)) return false;
+  if (!(err instanceof Error)) {
+    return false;
+  }
   return err.name === "AbortError" || err.name === "APIUserAbortError";
 }
 
@@ -69,14 +77,20 @@ export function isTransientEmbeddingError(err: unknown): boolean {
 function getErrorStatusCode(err: Error): unknown {
   if ("status" in err) {
     const status = (err as { status: unknown }).status;
-    if (status != null) return status;
+    if (status != null) {
+      return status;
+    }
+  }
+  if ("statusCode" in err) {
+    return (err as { statusCode: unknown }).statusCode;
   }
-  if ("statusCode" in err) return (err as { statusCode: unknown }).statusCode;
   return undefined;
 }
 
 function isHttpStatusError(err: unknown): boolean {
-  if (!(err instanceof Error)) return false;
+  if (!(err instanceof Error)) {
+    return false;
+  }
   const status = getErrorStatusCode(err);
   if (typeof status === "number") {
     return status === 429 || (status >= 500 && status < 600);

package/src/persistence/embeddings/embedding-backend.test.ts

@@ -128,7 +128,9 @@ describe("isEmbeddingDimensionAvailable", () => {
     dim: number,
   ): Promise<ReturnType<typeof mock>> {
     const { backend } = await selectEmbeddingBackend(config);
-    if (!backend) throw new Error("expected a backend to be selected");
+    if (!backend) {
+      throw new Error("expected a backend to be selected");
+    }
     const embedMock = mock(async () => [new Array(dim).fill(0)]);
     (backend as { embed: typeof backend.embed }).embed =
       embedMock as unknown as typeof backend.embed;
@@ -153,7 +155,9 @@ describe("isEmbeddingDimensionAvailable", () => {
   test("returns false when the backend probe throws (unreachable)", async () => {
     const config = localConfigWithVectorSize(384);
     const { backend } = await selectEmbeddingBackend(config);
-    if (!backend) throw new Error("expected a backend to be selected");
+    if (!backend) {
+      throw new Error("expected a backend to be selected");
+    }
     (backend as { embed: typeof backend.embed }).embed = (async () => {
       throw new Error("backend unreachable");
     }) as unknown as typeof backend.embed;
@@ -209,7 +213,9 @@ describe("isEmbeddingDimensionAvailable", () => {
 
     // Stub the primary (local) → 384.
     const { backend: primary } = await selectEmbeddingBackend(config);
-    if (!primary) throw new Error("expected a primary backend");
+    if (!primary) {
+      throw new Error("expected a primary backend");
+    }
     (primary as { embed: typeof primary.embed }).embed = mock(async () => [
       new Array(384).fill(0),
     ]) as unknown as typeof primary.embed;
@@ -225,7 +231,9 @@ describe("isEmbeddingDimensionAvailable", () => {
         qdrant: { vectorSize: 3072 },
       },
     } as unknown as AssistantConfig);
-    if (!openai) throw new Error("expected an openai fallback backend");
+    if (!openai) {
+      throw new Error("expected an openai fallback backend");
+    }
     (openai as { embed: typeof openai.embed }).embed = mock(async () => [
       new Array(3072).fill(0),
     ]) as unknown as typeof openai.embed;