chore: delete stale memory host bridges

packages/memory-host-sdk/src/host/embeddings.test.ts

@@ -1,8 +1,122 @@
-import { describe, expect, it } from "vitest";
-import { DEFAULT_LOCAL_MODEL } from "./embeddings.js";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createLocalEmbeddingProvider, DEFAULT_LOCAL_MODEL } from "./embeddings.js";
+
+const nodeLlamaMock = vi.hoisted(() => ({
+  importNodeLlamaCpp: vi.fn(),
+}));
+
+vi.mock("./node-llama.js", () => ({
+  importNodeLlamaCpp: nodeLlamaMock.importNodeLlamaCpp,
+}));
+
+beforeEach(() => {
+  nodeLlamaMock.importNodeLlamaCpp.mockReset();
+});
+
+afterEach(() => {
+  vi.resetAllMocks();
+});
+
+function mockLocalEmbeddingRuntime(vector = new Float32Array([2.35, 3.45, 0.63, 4.3])) {
+  const getEmbeddingFor = vi.fn().mockResolvedValue({ vector });
+  const createEmbeddingContext = vi.fn().mockResolvedValue({ getEmbeddingFor });
+  const loadModel = vi.fn().mockResolvedValue({ createEmbeddingContext });
+  const resolveModelFile = vi.fn(async (modelPath: string) => `/resolved/${modelPath}`);
+
+  nodeLlamaMock.importNodeLlamaCpp.mockResolvedValue({
+    getLlama: async () => ({ loadModel }),
+    resolveModelFile,
+    LlamaLogLevel: { error: 0 },
+  } as never);
+
+  return { createEmbeddingContext, getEmbeddingFor, loadModel, resolveModelFile };
+}
+
+describe("local embedding provider", () => {
+  it("normalizes local embeddings and resolves the default local model", async () => {
+    const runtime = mockLocalEmbeddingRuntime();
+
+    const provider = await createLocalEmbeddingProvider({
+      config: {} as never,
+      provider: "local",
+      model: "",
+      fallback: "none",
+    });
+
+    const embedding = await provider.embedQuery("test query");
+    const magnitude = Math.sqrt(embedding.reduce((sum, value) => sum + value * value, 0));
 
-describe("package embeddings barrel", () => {
-  it("re-exports the source local embedding contract", () => {
     expect(DEFAULT_LOCAL_MODEL).toContain("embeddinggemma");
+    expect(magnitude).toBeCloseTo(1, 5);
+    expect(runtime.resolveModelFile).toHaveBeenCalledWith(DEFAULT_LOCAL_MODEL, undefined);
+    expect(runtime.getEmbeddingFor).toHaveBeenCalledWith("test query");
+  });
+
+  it("passes default contextSize (4096) to createEmbeddingContext when not configured", async () => {
+    const runtime = mockLocalEmbeddingRuntime();
+
+    const provider = await createLocalEmbeddingProvider({
+      config: {} as never,
+      provider: "local",
+      model: "",
+      fallback: "none",
+    });
+
+    await provider.embedQuery("context size default test");
+
+    expect(runtime.createEmbeddingContext).toHaveBeenCalledWith({ contextSize: 4096 });
+  });
+
+  it("passes configured contextSize to createEmbeddingContext", async () => {
+    const runtime = mockLocalEmbeddingRuntime();
+
+    const provider = await createLocalEmbeddingProvider({
+      config: {} as never,
+      provider: "local",
+      model: "",
+      fallback: "none",
+      local: { contextSize: 2048 },
+    });
+
+    await provider.embedQuery("context size custom test");
+
+    expect(runtime.createEmbeddingContext).toHaveBeenCalledWith({ contextSize: 2048 });
+  });
+
+  it('passes "auto" contextSize to createEmbeddingContext when explicitly set', async () => {
+    const runtime = mockLocalEmbeddingRuntime();
+
+    const provider = await createLocalEmbeddingProvider({
+      config: {} as never,
+      provider: "local",
+      model: "",
+      fallback: "none",
+      local: { contextSize: "auto" },
+    });
+
+    await provider.embedQuery("context size auto test");
+
+    expect(runtime.createEmbeddingContext).toHaveBeenCalledWith({ contextSize: "auto" });
+  });
+
+  it("trims explicit local model paths and cache directories", async () => {
+    const runtime = mockLocalEmbeddingRuntime(new Float32Array([1, 0]));
+
+    const provider = await createLocalEmbeddingProvider({
+      config: {} as never,
+      provider: "local",
+      model: "",
+      fallback: "none",
+      local: {
+        modelPath: "  /models/embed.gguf  ",
+        modelCacheDir: "  /cache/models  ",
+      },
+    });
+
+    await provider.embedBatch(["a", "b"]);
+
+    expect(provider.model).toBe("/models/embed.gguf");
+    expect(runtime.resolveModelFile).toHaveBeenCalledWith("/models/embed.gguf", "/cache/models");
+    expect(runtime.getEmbeddingFor).toHaveBeenCalledTimes(2);
   });
 });