Skip to content

Local-first 🧠 memory for Hermes Agent that lives in your Obsidian vault and remembers project context. Nightly 😴 dream passes turn repeat corrections into confirmed preferences with measurable confidence. Adapters ship for Claude Code, Codex, and OpenClaw, with an MCP server for anything else.

TypeScript
4.5 KB
Raw Blame
import { test, expect, beforeEach, afterEach } from "bun:test";

import { ZeroEntropyProvider } from "../../../src/core/search/embeddings/zeroentropy.ts";
import { makeProvider } from "../../../src/core/search/embeddings/provider.ts";
import { SearchError } from "../../../src/core/search/types.ts";
import type { ResolvedEmbeddingConfig } from "../../../src/core/search/types.ts";
import { startFakeHttp, type FakeHttp } from "../../helpers/fake-http.ts";
import { fakeCredential } from "../../helpers/fake-credentials.ts";

let server: FakeHttp;

function cfg(overrides: Partial<ResolvedEmbeddingConfig> = {}): ResolvedEmbeddingConfig {
  return Object.freeze({
    enabled: true,
    provider: "zeroentropy",
    baseUrl: server.url,
    model: "zembed-1",
    apiKey: fakeCredential("ze-", "test-key"),
    dimension: null,
    timeoutMs: 5_000,
    concurrency: 2,
    batchSize: 32,
    costGateUsd: 0,
    maxRetries: 3,
    ...overrides,
  });
}

/** ZeroEntropy-shaped handler: POST /models/embed -> {results:[{embedding}]}. */
function zeHandler(dim = 4) {
  return (req: {
    method: string;
    path: string;
    body: unknown;
  }): { status: number; body: unknown } => {
    if (!req.path.endsWith("/models/embed") || req.method !== "POST") {
      return { status: 404, body: { error: "not_found" } };
    }
    const body = req.body as { input: string[]; dimensions?: number };
    const width = body.dimensions ?? dim;
    const results = body.input.map((text, index) => ({
      // Deterministic vector: leading component from length, then index.
      embedding: [text.length, index, ...new Array(Math.max(0, width - 2)).fill(1)],
    }));
    return { status: 200, body: { results, usage: { total_bytes: 1, total_tokens: 1 } } };
  };
}

beforeEach(async () => {
  server = await startFakeHttp();
});

afterEach(async () => {
  await server.close();
});

test("embed() returns unit-normalised vectors in input order", async () => {
  server.setHandler(zeHandler(4));
  const p = new ZeroEntropyProvider(cfg({ dimension: 4 }));
  const out = await p.embed(["aaaa", "bb", "c"]);
  expect(out.length).toBe(3);
  for (const v of out) {
    const norm = Math.sqrt(v.reduce((s, x) => s + x * x, 0));
    expect(norm).toBeCloseTo(1.0, 6);
  }
  // First input longest -> largest leading component before normalisation.
  expect(out[0]![0]).toBeGreaterThan(out[2]![0]!);
});

test("embed() sends Bearer auth and the native request body", async () => {
  let seenAuth = "";
  let seenBody: Record<string, unknown> = {};
  server.setHandler((req) => {
    seenAuth = req.headers["authorization"] ?? "";
    seenBody = req.body as Record<string, unknown>;
    const body = req.body as { input: string[] };
    return {
      status: 200,
      body: { results: body.input.map(() => ({ embedding: [1, 0, 0, 0] })) },
    };
  });
  const p = new ZeroEntropyProvider(cfg({ dimension: 4 }));
  await p.embed(["x"]);
  expect(seenAuth).toBe("Bearer ze-test-key");
  expect(seenBody["model"]).toBe("zembed-1");
  expect(seenBody["input_type"]).toBe("document");
  expect(seenBody["input"]).toEqual(["x"]);
});

test("embed() forwards a configured dimension to the API", async () => {
  let seenDim: unknown;
  server.setHandler((req) => {
    seenDim = (req.body as { dimensions?: number }).dimensions;
    return zeHandler(640)(req);
  });
  const p = new ZeroEntropyProvider(cfg({ dimension: 640 }));
  const out = await p.embed(["x"]);
  expect(seenDim).toBe(640);
  expect(out[0]!.length).toBe(640);
});

test("ping() returns ok with dimension", async () => {
  server.setHandler(zeHandler(4));
  const p = new ZeroEntropyProvider(cfg({ dimension: 4 }));
  const res = await p.ping();
  if (!res.ok) throw new Error("expected ok");
  expect(res.dimension).toBe(4);
});

test("embed() retries on 503 then succeeds", async () => {
  let calls = 0;
  server.setHandler((req) => {
    calls++;
    if (calls === 1) return { status: 503, body: { error: "busy" } };
    return zeHandler(4)(req);
  });
  const p = new ZeroEntropyProvider(cfg({ dimension: 4 }), { backoffMs: [10, 20] });
  const out = await p.embed(["once"]);
  expect(out.length).toBe(1);
  expect(calls).toBe(2);
});

test("makeProvider returns a ZeroEntropyProvider for provider 'zeroentropy'", () => {
  const p = makeProvider(cfg({ dimension: 4 }));
  expect(p).toBeInstanceOf(ZeroEntropyProvider);
  expect(p.name).toBe("zeroentropy");
});

test("makeProvider throws EMBEDDING_KEY_MISSING when key absent", () => {
  expect(() => makeProvider(cfg({ apiKey: null }))).toThrow(SearchError);
});