@crewhaus/embedder 0.1.3 → 0.1.5

package/dist/index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Catalog R12 `embedder` — provider-agnostic text embedding.
+ *
+ * Mirrors `model-router`'s prefix-grammar:
+ *
+ *   openai/text-embedding-3-small    → OpenAI Embeddings API
+ *   voyage/voyage-3                  → Voyage AI
+ *   cohere/embed-v3                  → Cohere (OpenAI-compat endpoint)
+ *   gemini/gemini-embedding-001      → Google Generative Language REST API
+ *   local/<model>@<base-url>         → OpenAI-compatible local server
+ *   mock/deterministic               → in-process hashed BoW vectors (tests + smoke fallback)
+ *
+ * `embed(texts, opts?)` accepts up to 100 texts per call (provider rate
+ * limit) and returns `number[][]` of equal length. Empty input returns
+ * `[]` without making a network call.
+ *
+ * The mock backend produces a deterministic 256-dim vector based on a
+ * hashed bag-of-words representation, suitable for the Section 21 smoke
+ * test when `OPENAI_API_KEY` is unset.
+ *
+ * Layer R12. Pairs with `vector-store`, `tool-retrieve`, `pipeline-engine`.
+ */
+import { CrewhausError } from "@crewhaus/errors";
+export type EmbedderProviderId = "openai" | "voyage" | "cohere" | "gemini" | "local" | "mock";
+export type ParsedEmbedderModel = {
+    readonly providerId: EmbedderProviderId;
+    readonly modelId: string;
+    readonly baseUrl?: string;
+};
+export declare class EmbedderError extends CrewhausError {
+    readonly name = "EmbedderError";
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * Parse an embedder model string with the same prefix grammar
+ * `model-router` uses for chat models.
+ *   openai/text-embedding-3-small
+ *   voyage/voyage-3
+ *   cohere/embed-v3
+ *   gemini/gemini-embedding-001
+ *   local/<model>@<base-url>
+ *   mock/<anything>
+ */
+export declare function parseEmbedderModel(spec: string): ParsedEmbedderModel;
+export type EmbedOptions = {
+    readonly batchSize?: number;
+    readonly signal?: AbortSignal;
+};
+export interface Embedder {
+    readonly model: string;
+    readonly provider: EmbedderProviderId;
+    embed(texts: ReadonlyArray<string>, opts?: EmbedOptions): Promise<number[][]>;
+}
+export type CreateEmbedderOptions = {
+    readonly model: string;
+    /** Override the API key; defaults to provider-specific env vars. */
+    readonly apiKey?: string;
+    /** For "local/" prefix; otherwise ignored. */
+    readonly baseUrl?: string;
+};
+export declare function createEmbedder(opts: CreateEmbedderOptions): Embedder;

package/dist/index.js

@@ -0,0 +1,261 @@
+/**
+ * Catalog R12 `embedder` — provider-agnostic text embedding.
+ *
+ * Mirrors `model-router`'s prefix-grammar:
+ *
+ *   openai/text-embedding-3-small    → OpenAI Embeddings API
+ *   voyage/voyage-3                  → Voyage AI
+ *   cohere/embed-v3                  → Cohere (OpenAI-compat endpoint)
+ *   gemini/gemini-embedding-001      → Google Generative Language REST API
+ *   local/<model>@<base-url>         → OpenAI-compatible local server
+ *   mock/deterministic               → in-process hashed BoW vectors (tests + smoke fallback)
+ *
+ * `embed(texts, opts?)` accepts up to 100 texts per call (provider rate
+ * limit) and returns `number[][]` of equal length. Empty input returns
+ * `[]` without making a network call.
+ *
+ * The mock backend produces a deterministic 256-dim vector based on a
+ * hashed bag-of-words representation, suitable for the Section 21 smoke
+ * test when `OPENAI_API_KEY` is unset.
+ *
+ * Layer R12. Pairs with `vector-store`, `tool-retrieve`, `pipeline-engine`.
+ */
+import { createHash } from "node:crypto";
+import { CrewhausError } from "@crewhaus/errors";
+export class EmbedderError extends CrewhausError {
+    name = "EmbedderError";
+    constructor(message, cause) {
+        super("config", message, cause);
+    }
+}
+/**
+ * Parse an embedder model string with the same prefix grammar
+ * `model-router` uses for chat models.
+ *   openai/text-embedding-3-small
+ *   voyage/voyage-3
+ *   cohere/embed-v3
+ *   gemini/gemini-embedding-001
+ *   local/<model>@<base-url>
+ *   mock/<anything>
+ */
+export function parseEmbedderModel(spec) {
+    if (typeof spec !== "string" || spec.length === 0) {
+        throw new EmbedderError("embedder model must be a non-empty string");
+    }
+    if (spec.startsWith("openai/")) {
+        return { providerId: "openai", modelId: spec.slice("openai/".length) };
+    }
+    if (spec.startsWith("voyage/")) {
+        return { providerId: "voyage", modelId: spec.slice("voyage/".length) };
+    }
+    if (spec.startsWith("cohere/")) {
+        return { providerId: "cohere", modelId: spec.slice("cohere/".length) };
+    }
+    if (spec.startsWith("gemini/")) {
+        return { providerId: "gemini", modelId: spec.slice("gemini/".length) };
+    }
+    if (spec.startsWith("local/")) {
+        const rest = spec.slice("local/".length);
+        const at = rest.lastIndexOf("@");
+        if (at === -1) {
+            throw new EmbedderError(`local/ embedder must be local/<model>@<base-url> (got "${spec}")`);
+        }
+        const modelId = rest.slice(0, at);
+        const baseUrl = rest.slice(at + 1);
+        return { providerId: "local", modelId, baseUrl };
+    }
+    if (spec.startsWith("mock/")) {
+        return { providerId: "mock", modelId: spec.slice("mock/".length) };
+    }
+    throw new EmbedderError(`unknown embedder prefix in "${spec}" — expected openai/, voyage/, cohere/, gemini/, local/<m>@<url>, or mock/`);
+}
+const DEFAULT_BATCH = 100;
+// ---------------------------------------------------------------------------
+// Mock backend — deterministic hashed bag-of-words.
+// ---------------------------------------------------------------------------
+const MOCK_DIM = 256;
+function hashedBow(text, dim) {
+    const out = new Array(dim).fill(0);
+    // Tokenise on word boundaries; lowercased; ASCII-only (good enough for hashed BoW).
+    const tokens = text
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[^a-z0-9]+/g, " ")
+        .split(" ")
+        .filter((t) => t.length > 0);
+    for (const t of tokens) {
+        const h = createHash("sha256").update(t).digest();
+        const slot = h.readUInt32BE(0) % dim;
+        const sign = (h.readUInt8(4) & 1) === 0 ? 1 : -1;
+        out[slot] = (out[slot] ?? 0) + sign;
+    }
+    // L2-normalise so cosine similarity ≈ dot product.
+    let norm = 0;
+    for (const v of out)
+        norm += v * v;
+    norm = Math.sqrt(norm);
+    if (norm === 0)
+        return out;
+    return out.map((v) => v / norm);
+}
+class MockEmbedder {
+    model;
+    provider = "mock";
+    constructor(model) {
+        this.model = model;
+    }
+    async embed(texts) {
+        return texts.map((t) => hashedBow(t, MOCK_DIM));
+    }
+}
+// ---------------------------------------------------------------------------
+// OpenAI / OpenAI-compatible (covers OpenAI cloud + local OpenAI-shaped
+// servers like Ollama, vLLM, llama.cpp).
+// ---------------------------------------------------------------------------
+/**
+ * Normalise a baseUrl before appending `/v1/embeddings`: strip a trailing
+ * slash AND a trailing `/v1` segment so both URL shapes users commonly
+ * supply work (`http://localhost:11434` and `http://localhost:11434/v1`
+ * both resolve to `.../v1/embeddings` — never `.../v1/v1/embeddings`).
+ */
+function normaliseEmbeddingsBaseUrl(baseUrl) {
+    let out = baseUrl;
+    if (out.endsWith("/"))
+        out = out.slice(0, -1);
+    if (out.endsWith("/v1"))
+        out = out.slice(0, -"/v1".length);
+    return out;
+}
+class OpenAILikeEmbedder {
+    model;
+    apiKey;
+    provider;
+    baseUrl;
+    constructor(provider, model, baseUrl, apiKey) {
+        this.model = model;
+        this.apiKey = apiKey;
+        this.provider = provider;
+        this.baseUrl = normaliseEmbeddingsBaseUrl(baseUrl);
+    }
+    async embed(texts, opts = {}) {
+        if (texts.length === 0)
+            return [];
+        const batchSize = opts.batchSize ?? DEFAULT_BATCH;
+        const out = [];
+        for (let i = 0; i < texts.length; i += batchSize) {
+            const batch = texts.slice(i, i + batchSize);
+            const headers = { "content-type": "application/json" };
+            if (this.apiKey !== undefined && this.apiKey.length > 0) {
+                headers["authorization"] = `Bearer ${this.apiKey}`;
+            }
+            const res = await fetch(`${this.baseUrl}/v1/embeddings`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({ model: this.model, input: batch }),
+                ...(opts.signal !== undefined ? { signal: opts.signal } : {}),
+            });
+            if (!res.ok) {
+                const text = await res.text().catch(() => "");
+                throw new EmbedderError(`embedding request failed (${this.provider} ${this.model}): ${res.status} ${text}`);
+            }
+            const json = (await res.json());
+            for (const row of json.data)
+                out.push(row.embedding);
+        }
+        return out;
+    }
+}
+// ---------------------------------------------------------------------------
+// Gemini — Google Generative Language REST API. Not OpenAI-shaped: one
+// POST per text to `models/<model>:embedContent` with the API key as a
+// query param, response carries `embedding.values`. The per-text loop is
+// fine for the embedder's batch sizes (the API has no multi-text body on
+// this endpoint shape).
+// ---------------------------------------------------------------------------
+const GEMINI_EMBED_BASE = "https://generativelanguage.googleapis.com/v1beta";
+class GeminiEmbedder {
+    model;
+    apiKey;
+    baseUrl;
+    provider = "gemini";
+    constructor(model, apiKey, baseUrl = GEMINI_EMBED_BASE) {
+        this.model = model;
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl;
+    }
+    async embed(texts, opts = {}) {
+        if (texts.length === 0)
+            return [];
+        const out = [];
+        for (const text of texts) {
+            const url = `${this.baseUrl}/models/${this.model}:embedContent?key=${encodeURIComponent(this.apiKey)}`;
+            const res = await fetch(url, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ content: { parts: [{ text }] } }),
+                ...(opts.signal !== undefined ? { signal: opts.signal } : {}),
+            });
+            if (!res.ok) {
+                const body = await res.text().catch(() => "");
+                throw new EmbedderError(`embedding request failed (gemini ${this.model}): ${res.status} ${body}`);
+            }
+            const json = (await res.json());
+            const values = json.embedding?.values;
+            if (!Array.isArray(values)) {
+                throw new EmbedderError(`gemini embedding response missing embedding.values (model ${this.model})`);
+            }
+            out.push(values);
+        }
+        return out;
+    }
+}
+export function createEmbedder(opts) {
+    const parsed = parseEmbedderModel(opts.model);
+    switch (parsed.providerId) {
+        case "mock":
+            return new MockEmbedder(parsed.modelId);
+        case "openai": {
+            const apiKey = opts.apiKey ?? process.env["OPENAI_API_KEY"];
+            if (apiKey === undefined || apiKey === "") {
+                throw new EmbedderError("openai embedder requires OPENAI_API_KEY");
+            }
+            return new OpenAILikeEmbedder("openai", parsed.modelId, opts.baseUrl ?? "https://api.openai.com", apiKey);
+        }
+        case "voyage": {
+            const apiKey = opts.apiKey ?? process.env["VOYAGE_API_KEY"];
+            if (apiKey === undefined || apiKey === "") {
+                throw new EmbedderError("voyage embedder requires VOYAGE_API_KEY");
+            }
+            return new OpenAILikeEmbedder("voyage", parsed.modelId, opts.baseUrl ?? "https://api.voyageai.com", apiKey);
+        }
+        case "cohere": {
+            const apiKey = opts.apiKey ?? process.env["COHERE_API_KEY"];
+            if (apiKey === undefined || apiKey === "") {
+                throw new EmbedderError("cohere embedder requires COHERE_API_KEY");
+            }
+            // Cohere's OpenAI-compatible surface lives under /compatibility —
+            // the bare host has no /v1/embeddings path (it 404s).
+            return new OpenAILikeEmbedder("cohere", parsed.modelId, opts.baseUrl ?? "https://api.cohere.ai/compatibility", apiKey);
+        }
+        case "gemini": {
+            // Empty-string env values count as unset so GOOGLE_API_KEY can take
+            // over when GEMINI_API_KEY="" (common in CI matrices).
+            const candidates = [
+                opts.apiKey,
+                process.env["GEMINI_API_KEY"],
+                process.env["GOOGLE_API_KEY"],
+            ];
+            const apiKey = candidates.find((k) => k !== undefined && k !== "");
+            if (apiKey === undefined) {
+                throw new EmbedderError("gemini embedder requires GEMINI_API_KEY (or GOOGLE_API_KEY)");
+            }
+            return new GeminiEmbedder(parsed.modelId, apiKey, opts.baseUrl ?? GEMINI_EMBED_BASE);
+        }
+        case "local":
+            return new OpenAILikeEmbedder("local", parsed.modelId, opts.baseUrl ?? parsed.baseUrl ?? "", opts.apiKey);
+        default: {
+            const exhaustive = parsed.providerId;
+            throw new EmbedderError(`unknown provider "${exhaustive}"`);
+        }
+    }
+}

package/package.json

@@ -1,18 +1,21 @@
 {
   "name": "@crewhaus/embedder",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "description": "Embedding provider — openai/voyage/cohere/local/mock backends with prefix-grammar selector",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
   "scripts": {
     "test": "bun test src"
   },
   "dependencies": {
-    "@crewhaus/errors": "0.1.3"
+    "@crewhaus/errors": "0.1.5"
   },
   "license": "Apache-2.0",
   "author": {
@@ -32,5 +35,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "files": ["src", "README.md", "LICENSE", "NOTICE"]
+  "files": ["dist", "README.md", "LICENSE", "NOTICE"]
 }

package/src/index.test.ts

@@ -1,502 +0,0 @@
-import { afterEach, describe, expect, mock, spyOn, test } from "bun:test";
-import { EmbedderError, createEmbedder, parseEmbedderModel } from "./index";
-
-describe("parseEmbedderModel", () => {
-  test("parses openai/<model>", () => {
-    expect(parseEmbedderModel("openai/text-embedding-3-small")).toEqual({
-      providerId: "openai",
-      modelId: "text-embedding-3-small",
-    });
-  });
-  test("parses voyage/<model>", () => {
-    expect(parseEmbedderModel("voyage/voyage-3")).toEqual({
-      providerId: "voyage",
-      modelId: "voyage-3",
-    });
-  });
-  test("parses cohere/<model>", () => {
-    expect(parseEmbedderModel("cohere/embed-v3")).toEqual({
-      providerId: "cohere",
-      modelId: "embed-v3",
-    });
-  });
-  test("parses local/<model>@<url>", () => {
-    expect(parseEmbedderModel("local/nomic-embed@http://localhost:11434")).toEqual({
-      providerId: "local",
-      modelId: "nomic-embed",
-      baseUrl: "http://localhost:11434",
-    });
-  });
-  test("parses mock/deterministic", () => {
-    expect(parseEmbedderModel("mock/det")).toEqual({
-      providerId: "mock",
-      modelId: "det",
-    });
-  });
-  test("rejects unknown prefix", () => {
-    expect(() => parseEmbedderModel("foo/bar")).toThrow(EmbedderError);
-  });
-  test("rejects local/ without @<url>", () => {
-    expect(() => parseEmbedderModel("local/m")).toThrow(/local\/<model>/);
-  });
-});
-
-describe("mock embedder (deterministic BoW)", () => {
-  test("embed returns the requested number of vectors", async () => {
-    const e = createEmbedder({ model: "mock/det" });
-    const out = await e.embed(["alpha", "bravo", "charlie"]);
-    expect(out.length).toBe(3);
-  });
-  test("each vector is 256-dim", async () => {
-    const e = createEmbedder({ model: "mock/det" });
-    const out = await e.embed(["hello world"]);
-    expect(out[0]?.length).toBe(256);
-  });
-  test("identical input → identical output (deterministic)", async () => {
-    const e = createEmbedder({ model: "mock/det" });
-    const a = await e.embed(["how now brown cow"]);
-    const b = await e.embed(["how now brown cow"]);
-    expect(a[0]).toEqual(b[0] ?? []);
-  });
-  test("similar texts have higher cosine similarity than dissimilar ones (sanity)", async () => {
-    const e = createEmbedder({ model: "mock/det" });
-    const [a, b, c] = await e.embed([
-      "the quick brown fox jumps",
-      "the brown fox is quick",
-      "purple snorkel velocity vortex",
-    ]);
-    const cos = (x?: number[], y?: number[]): number => {
-      if (x === undefined || y === undefined) return 0;
-      let s = 0;
-      for (let i = 0; i < x.length; i += 1) s += (x[i] ?? 0) * (y[i] ?? 0);
-      return s;
-    };
-    expect(cos(a, b)).toBeGreaterThan(cos(a, c));
-  });
-  test("empty input returns empty array (no network call)", async () => {
-    const e = createEmbedder({ model: "mock/det" });
-    expect(await e.embed([])).toEqual([]);
-  });
-});
-
-describe("provider construction", () => {
-  test("openai requires OPENAI_API_KEY", () => {
-    const original = process.env["OPENAI_API_KEY"];
-    process.env["OPENAI_API_KEY"] = "";
-    try {
-      expect(() => createEmbedder({ model: "openai/text-embedding-3-small" })).toThrow(
-        /OPENAI_API_KEY/,
-      );
-    } finally {
-      if (original !== undefined) process.env["OPENAI_API_KEY"] = original;
-      else process.env["OPENAI_API_KEY"] = "";
-    }
-  });
-
-  test("local/ accepts the parsed baseUrl", () => {
-    const e = createEmbedder({ model: "local/x@http://localhost:11434" });
-    expect(e.provider).toBe("local");
-    expect(e.model).toBe("x");
-  });
-});
-
-/**
- * Section 30 — embedder snapshot tests. Each provider's deterministic
- * mode (mock embedder) produces stable magnitudes per known input. The
- * production-path tests are gated on env vars and skipped in CI; the
- * deterministic snapshots here lock in the wire-shape expectations.
- */
-describe("Section 30 — embedder magnitude snapshots", () => {
-  // Using the mock embedder as the snapshot source — production paths
-  // (openai/voyage/cohere) are exercised by their respective providers
-  // when env vars are set; the mock keeps CI stable.
-  const FIXTURE_TEXTS = [
-    "The mitochondria is the powerhouse of the cell.",
-    "Lorem ipsum dolor sit amet.",
-    "How many roads must a man walk down?",
-    '10 PRINT "hello world"',
-    "🔥 Some emoji 🚀",
-  ];
-
-  test("mock embedder produces stable magnitudes for a 5-text fixture", async () => {
-    const e = createEmbedder({ model: "mock/det" });
-    const vecs = await e.embed(FIXTURE_TEXTS);
-    expect(vecs.length).toBe(5);
-    const mags = vecs.map((v) => Math.sqrt(v.reduce((s, x) => s + x * x, 0)));
-    // All magnitudes positive + bounded (deterministic BoW emits unit-ish vectors).
-    for (const m of mags) {
-      expect(m).toBeGreaterThan(0);
-      expect(m).toBeLessThan(100);
-    }
-    // Magnitude stability run-over-run.
-    const e2 = createEmbedder({ model: "mock/det" });
-    const vecs2 = await e2.embed(FIXTURE_TEXTS);
-    const mags2 = vecs2.map((v) => Math.sqrt(v.reduce((s, x) => s + x * x, 0)));
-    for (let i = 0; i < mags.length; i++) {
-      expect(Math.abs((mags[i] ?? 0) - (mags2[i] ?? 0))).toBeLessThan(1e-9);
-    }
-  });
-
-  test("mock provider field reports correctly", () => {
-    expect(createEmbedder({ model: "mock/d" }).provider).toBe("mock");
-  });
-
-  test("openai/voyage/cohere construct without API key throws fail-loud", () => {
-    expect(() => createEmbedder({ model: "openai/text-embedding-3-small" })).toThrow();
-    expect(() => createEmbedder({ model: "voyage/voyage-3" })).toThrow();
-    expect(() => createEmbedder({ model: "cohere/embed-v3" })).toThrow();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// createEmbedder — provider branch coverage (env + explicit key).
-// ---------------------------------------------------------------------------
-
-/** Save/restore a single env var around a callback. */
-function withEnv(key: string, value: string | undefined, fn: () => void): void {
-  const original = process.env[key];
-  if (value === undefined) delete process.env[key];
-  else process.env[key] = value;
-  try {
-    fn();
-  } finally {
-    if (original === undefined) delete process.env[key];
-    else process.env[key] = original;
-  }
-}
-
-describe("createEmbedder — provider construction branches", () => {
-  test("openai reads OPENAI_API_KEY from env when no explicit key", () => {
-    withEnv("OPENAI_API_KEY", "sk-env", () => {
-      const e = createEmbedder({ model: "openai/text-embedding-3-small" });
-      expect(e.provider).toBe("openai");
-      expect(e.model).toBe("text-embedding-3-small");
-    });
-  });
-
-  test("openai accepts an explicit apiKey override", () => {
-    withEnv("OPENAI_API_KEY", undefined, () => {
-      const e = createEmbedder({ model: "openai/text-embedding-3-small", apiKey: "sk-explicit" });
-      expect(e.provider).toBe("openai");
-    });
-  });
-
-  test("voyage reads VOYAGE_API_KEY from env", () => {
-    withEnv("VOYAGE_API_KEY", "voyage-env", () => {
-      const e = createEmbedder({ model: "voyage/voyage-3" });
-      expect(e.provider).toBe("voyage");
-    });
-  });
-
-  test("voyage throws fail-loud when VOYAGE_API_KEY is empty", () => {
-    withEnv("VOYAGE_API_KEY", "", () => {
-      expect(() => createEmbedder({ model: "voyage/voyage-3" })).toThrow(/VOYAGE_API_KEY/);
-    });
-  });
-
-  test("cohere reads COHERE_API_KEY from env", () => {
-    withEnv("COHERE_API_KEY", "cohere-env", () => {
-      const e = createEmbedder({ model: "cohere/embed-v3" });
-      expect(e.provider).toBe("cohere");
-    });
-  });
-
-  test("cohere throws fail-loud when COHERE_API_KEY is empty", () => {
-    withEnv("COHERE_API_KEY", "", () => {
-      expect(() => createEmbedder({ model: "cohere/embed-v3" })).toThrow(/COHERE_API_KEY/);
-    });
-  });
-
-  test("local/ honors an explicit baseUrl override over the parsed one", () => {
-    const e = createEmbedder({
-      model: "local/x@http://parsed:1234",
-      baseUrl: "http://override:5678",
-    });
-    expect(e.provider).toBe("local");
-    expect(e.model).toBe("x");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// OpenAILikeEmbedder.embed — network path (fetch mocked, fully deterministic).
-// ---------------------------------------------------------------------------
-
-describe("OpenAILikeEmbedder.embed (mocked fetch)", () => {
-  afterEach(() => {
-    // spyOn(globalThis, "fetch") registers with bun's mock registry; restore
-    // the real implementation after every test so nothing leaks across files.
-    mock.restore();
-  });
-
-  test("empty input short-circuits without a network call", async () => {
-    const fetchSpy = spyOn(globalThis, "fetch");
-    const e = createEmbedder({ model: "openai/text-embedding-3-small", apiKey: "sk-x" });
-    expect(await e.embed([])).toEqual([]);
-    expect(fetchSpy).not.toHaveBeenCalled();
-  });
-
-  test("posts to /v1/embeddings with an Authorization header and parses data", async () => {
-    let capturedUrl = "";
-    let capturedInit: RequestInit | undefined;
-    const fetchImpl = (async (input: string | URL | Request, init?: RequestInit) => {
-      capturedUrl = String(input);
-      capturedInit = init;
-      return new Response(JSON.stringify({ data: [{ embedding: [0.1, 0.2, 0.3] }] }), {
-        status: 200,
-        headers: { "content-type": "application/json" },
-      });
-    }) as unknown as typeof fetch;
-    const fetchSpy = spyOn(globalThis, "fetch").mockImplementation(fetchImpl);
-
-    const e = createEmbedder({ model: "openai/text-embedding-3-small", apiKey: "sk-secret" });
-    const out = await e.embed(["hello"]);
-
-    expect(out).toEqual([[0.1, 0.2, 0.3]]);
-    expect(capturedUrl).toBe("https://api.openai.com/v1/embeddings");
-    expect(fetchSpy).toHaveBeenCalledTimes(1);
-    const headers = capturedInit?.headers as Record<string, string>;
-    expect(headers["authorization"]).toBe("Bearer sk-secret");
-    expect(headers["content-type"]).toBe("application/json");
-    const body = JSON.parse(String(capturedInit?.body)) as { model: string; input: string[] };
-    expect(body.model).toBe("text-embedding-3-small");
-    expect(body.input).toEqual(["hello"]);
-    // No signal provided → fetch init must not carry one.
-    expect(capturedInit?.signal ?? null).toBeNull();
-  });
-
-  test("local provider without an API key omits the Authorization header", async () => {
-    let capturedInit: RequestInit | undefined;
-    const fetchImpl = (async (_input: string | URL | Request, init?: RequestInit) => {
-      capturedInit = init;
-      return new Response(JSON.stringify({ data: [{ embedding: [1, 0] }] }), { status: 200 });
-    }) as unknown as typeof fetch;
-    spyOn(globalThis, "fetch").mockImplementation(fetchImpl);
-
-    const e = createEmbedder({ model: "local/nomic@http://localhost:11434" });
-    const out = await e.embed(["x"]);
-
-    expect(out).toEqual([[1, 0]]);
-    const headers = capturedInit?.headers as Record<string, string>;
-    expect("authorization" in headers).toBe(false);
-  });
-
-  test("respects a custom batchSize and concatenates batches in order", async () => {
-    const batches: string[][] = [];
-    const fetchImpl = (async (_input: string | URL | Request, init?: RequestInit) => {
-      const parsed = JSON.parse(String(init?.body)) as { input: string[] };
-      batches.push(parsed.input);
-      // Echo one embedding per input text so we can verify ordering.
-      const data = parsed.input.map((t) => ({ embedding: [t.length] }));
-      return new Response(JSON.stringify({ data }), { status: 200 });
-    }) as unknown as typeof fetch;
-    spyOn(globalThis, "fetch").mockImplementation(fetchImpl);
-
-    const e = createEmbedder({ model: "local/m@http://localhost:1234" });
-    const out = await e.embed(["a", "bb", "ccc", "dddd", "eeeee"], { batchSize: 2 });
-
-    // 5 texts / batchSize 2 → batches of [2, 2, 1].
-    expect(batches).toEqual([["a", "bb"], ["ccc", "dddd"], ["eeeee"]]);
-    expect(out).toEqual([[1], [2], [3], [4], [5]]);
-  });
-
-  test("forwards an AbortSignal to fetch", async () => {
-    let capturedSignal: AbortSignal | null | undefined;
-    const fetchImpl = (async (_input: string | URL | Request, init?: RequestInit) => {
-      capturedSignal = init?.signal;
-      return new Response(JSON.stringify({ data: [{ embedding: [0] }] }), { status: 200 });
-    }) as unknown as typeof fetch;
-    spyOn(globalThis, "fetch").mockImplementation(fetchImpl);
-
-    const controller = new AbortController();
-    const e = createEmbedder({ model: "local/m@http://localhost:1234" });
-    await e.embed(["x"], { signal: controller.signal });
-    expect(capturedSignal).toBe(controller.signal);
-  });
-
-  test("throws EmbedderError with status + body on a non-ok response", async () => {
-    const fetchImpl = (async () =>
-      new Response("rate limited", {
-        status: 429,
-        statusText: "Too Many Requests",
-      })) as unknown as typeof fetch;
-    spyOn(globalThis, "fetch").mockImplementation(fetchImpl);
-
-    const e = createEmbedder({ model: "openai/text-embedding-3-small", apiKey: "sk-x" });
-    await expect(e.embed(["x"])).rejects.toThrow(EmbedderError);
-    await expect(e.embed(["x"])).rejects.toThrow(/429 rate limited/);
-  });
-
-  test("non-ok response with an unreadable body still throws (text() rejects)", async () => {
-    // A Response whose .text() rejects exercises the `.catch(() => "")` arm.
-    const brokenResponse = {
-      ok: false,
-      status: 500,
-      text: () => Promise.reject(new Error("stream broken")),
-    } as unknown as Response;
-    const fetchImpl = (async () => brokenResponse) as unknown as typeof fetch;
-    spyOn(globalThis, "fetch").mockImplementation(fetchImpl);
-
-    const e = createEmbedder({ model: "openai/text-embedding-3-small", apiKey: "sk-x" });
-    // Body coerces to empty string → message ends at the status, no trailing text.
-    await expect(e.embed(["x"])).rejects.toThrow(/500 $/);
-  });
-
-  test("a baseUrl already carrying /v1 is not doubled (URL-shape tolerance)", async () => {
-    let capturedUrl = "";
-    const fetchImpl = (async (input: string | URL | Request) => {
-      capturedUrl = String(input);
-      return new Response(JSON.stringify({ data: [{ embedding: [1] }] }), { status: 200 });
-    }) as unknown as typeof fetch;
-    spyOn(globalThis, "fetch").mockImplementation(fetchImpl);
-
-    const e = createEmbedder({ model: "local/nomic@http://localhost:11434/v1" });
-    await e.embed(["x"]);
-    expect(capturedUrl).toBe("http://localhost:11434/v1/embeddings");
-  });
-
-  test("a baseUrl with a trailing slash + /v1/ also normalises", async () => {
-    let capturedUrl = "";
-    const fetchImpl = (async (input: string | URL | Request) => {
-      capturedUrl = String(input);
-      return new Response(JSON.stringify({ data: [{ embedding: [1] }] }), { status: 200 });
-    }) as unknown as typeof fetch;
-    spyOn(globalThis, "fetch").mockImplementation(fetchImpl);
-
-    const e = createEmbedder({ model: "local/nomic@http://localhost:11434/v1/" });
-    await e.embed(["x"]);
-    expect(capturedUrl).toBe("http://localhost:11434/v1/embeddings");
-  });
-
-  test("cohere defaults to the /compatibility OpenAI-compat endpoint (bare host 404s)", async () => {
-    let capturedUrl = "";
-    const fetchImpl = (async (input: string | URL | Request) => {
-      capturedUrl = String(input);
-      return new Response(JSON.stringify({ data: [{ embedding: [0.5] }] }), { status: 200 });
-    }) as unknown as typeof fetch;
-    spyOn(globalThis, "fetch").mockImplementation(fetchImpl);
-
-    const e = createEmbedder({ model: "cohere/embed-v4.0", apiKey: "co-x" });
-    const out = await e.embed(["x"]);
-    expect(out).toEqual([[0.5]]);
-    expect(capturedUrl).toBe("https://api.cohere.ai/compatibility/v1/embeddings");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Gemini backend — REST embedContent (fetch mocked, fully deterministic).
-// ---------------------------------------------------------------------------
-
-describe("gemini embedder (mocked fetch)", () => {
-  afterEach(() => {
-    mock.restore();
-  });
-
-  test("parses gemini/<model>", () => {
-    expect(parseEmbedderModel("gemini/gemini-embedding-001")).toEqual({
-      providerId: "gemini",
-      modelId: "gemini-embedding-001",
-    });
-  });
-
-  test("requires GEMINI_API_KEY or GOOGLE_API_KEY", () => {
-    const prevGemini = process.env["GEMINI_API_KEY"];
-    const prevGoogle = process.env["GOOGLE_API_KEY"];
-    process.env["GEMINI_API_KEY"] = "";
-    process.env["GOOGLE_API_KEY"] = "";
-    try {
-      expect(() => createEmbedder({ model: "gemini/gemini-embedding-001" })).toThrow(
-        /GEMINI_API_KEY/,
-      );
-    } finally {
-      process.env["GEMINI_API_KEY"] = prevGemini;
-      process.env["GOOGLE_API_KEY"] = prevGoogle;
-    }
-  });
-
-  test("falls back to GOOGLE_API_KEY when GEMINI_API_KEY is unset", () => {
-    const prevGemini = process.env["GEMINI_API_KEY"];
-    const prevGoogle = process.env["GOOGLE_API_KEY"];
-    process.env["GEMINI_API_KEY"] = "";
-    process.env["GOOGLE_API_KEY"] = "g-key";
-    try {
-      const e = createEmbedder({ model: "gemini/gemini-embedding-001" });
-      expect(e.provider).toBe("gemini");
-    } finally {
-      process.env["GEMINI_API_KEY"] = prevGemini;
-      process.env["GOOGLE_API_KEY"] = prevGoogle;
-    }
-  });
-
-  test("POSTs models/<model>:embedContent with key query param + {content:{parts:[{text}]}} body and reads embedding.values", async () => {
-    const calls: Array<{ url: string; body: unknown }> = [];
-    const fetchImpl = (async (input: string | URL | Request, init?: RequestInit) => {
-      calls.push({ url: String(input), body: JSON.parse(String(init?.body)) });
-      return new Response(JSON.stringify({ embedding: { values: [0.1, 0.2] } }), {
-        status: 200,
-        headers: { "content-type": "application/json" },
-      });
-    }) as unknown as typeof fetch;
-    spyOn(globalThis, "fetch").mockImplementation(fetchImpl);
-
-    const e = createEmbedder({ model: "gemini/gemini-embedding-001", apiKey: "g-secret" });
-    const out = await e.embed(["alpha", "beta"]);
-
-    // One request per text (the endpoint takes a single content body).
-    expect(calls.length).toBe(2);
-    expect(out).toEqual([
-      [0.1, 0.2],
-      [0.1, 0.2],
-    ]);
-    expect(calls[0]?.url).toBe(
-      "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent?key=g-secret",
-    );
-    expect(calls[0]?.body).toEqual({ content: { parts: [{ text: "alpha" }] } });
-    expect(calls[1]?.body).toEqual({ content: { parts: [{ text: "beta" }] } });
-  });
-
-  test("empty input short-circuits without a network call", async () => {
-    const fetchSpy = spyOn(globalThis, "fetch");
-    const e = createEmbedder({ model: "gemini/gemini-embedding-001", apiKey: "g-x" });
-    expect(await e.embed([])).toEqual([]);
-    expect(fetchSpy).not.toHaveBeenCalled();
-  });
-
-  test("throws EmbedderError on a non-ok response", async () => {
-    const fetchImpl = (async () =>
-      new Response("permission denied", { status: 403 })) as unknown as typeof fetch;
-    spyOn(globalThis, "fetch").mockImplementation(fetchImpl);
-
-    const e = createEmbedder({ model: "gemini/gemini-embedding-001", apiKey: "g-x" });
-    await expect(e.embed(["x"])).rejects.toThrow(EmbedderError);
-    await expect(e.embed(["x"])).rejects.toThrow(/403 permission denied/);
-  });
-
-  test("throws EmbedderError when the response carries no embedding.values", async () => {
-    const fetchImpl = (async () =>
-      new Response(JSON.stringify({ embedding: {} }), { status: 200 })) as unknown as typeof fetch;
-    spyOn(globalThis, "fetch").mockImplementation(fetchImpl);
-
-    const e = createEmbedder({ model: "gemini/gemini-embedding-001", apiKey: "g-x" });
-    await expect(e.embed(["x"])).rejects.toThrow(/embedding\.values/);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// hashedBow — zero-norm branch (no alphanumeric tokens → all-zero vector).
-// ---------------------------------------------------------------------------
-
-describe("mock embedder — zero vector edge case", () => {
-  test("punctuation/whitespace-only text yields an all-zero, non-normalised vector", async () => {
-    const e = createEmbedder({ model: "mock/det" });
-    const [vec] = await e.embed(["   !!! ??? ---   "]);
-    expect(vec?.length).toBe(256);
-    // norm === 0 → returns the raw zero vector unchanged (no divide-by-zero).
-    expect(vec?.every((x) => x === 0)).toBe(true);
-  });
-
-  test("empty string also yields an all-zero vector", async () => {
-    const e = createEmbedder({ model: "mock/det" });
-    const [vec] = await e.embed([""]);
-    expect(vec?.every((x) => x === 0)).toBe(true);
-  });
-});

package/src/index.ts

@@ -1,323 +0,0 @@
-/**
- * Catalog R12 `embedder` — provider-agnostic text embedding.
- *
- * Mirrors `model-router`'s prefix-grammar:
- *
- *   openai/text-embedding-3-small    → OpenAI Embeddings API
- *   voyage/voyage-3                  → Voyage AI
- *   cohere/embed-v3                  → Cohere (OpenAI-compat endpoint)
- *   gemini/gemini-embedding-001      → Google Generative Language REST API
- *   local/<model>@<base-url>         → OpenAI-compatible local server
- *   mock/deterministic               → in-process hashed BoW vectors (tests + smoke fallback)
- *
- * `embed(texts, opts?)` accepts up to 100 texts per call (provider rate
- * limit) and returns `number[][]` of equal length. Empty input returns
- * `[]` without making a network call.
- *
- * The mock backend produces a deterministic 256-dim vector based on a
- * hashed bag-of-words representation, suitable for the Section 21 smoke
- * test when `OPENAI_API_KEY` is unset.
- *
- * Layer R12. Pairs with `vector-store`, `tool-retrieve`, `pipeline-engine`.
- */
-
-import { createHash } from "node:crypto";
-import { CrewhausError } from "@crewhaus/errors";
-
-export type EmbedderProviderId = "openai" | "voyage" | "cohere" | "gemini" | "local" | "mock";
-
-export type ParsedEmbedderModel = {
-  readonly providerId: EmbedderProviderId;
-  readonly modelId: string;
-  readonly baseUrl?: string;
-};
-
-export class EmbedderError extends CrewhausError {
-  override readonly name = "EmbedderError";
-  constructor(message: string, cause?: unknown) {
-    super("config", message, cause);
-  }
-}
-
-/**
- * Parse an embedder model string with the same prefix grammar
- * `model-router` uses for chat models.
- *   openai/text-embedding-3-small
- *   voyage/voyage-3
- *   cohere/embed-v3
- *   gemini/gemini-embedding-001
- *   local/<model>@<base-url>
- *   mock/<anything>
- */
-export function parseEmbedderModel(spec: string): ParsedEmbedderModel {
-  if (typeof spec !== "string" || spec.length === 0) {
-    throw new EmbedderError("embedder model must be a non-empty string");
-  }
-  if (spec.startsWith("openai/")) {
-    return { providerId: "openai", modelId: spec.slice("openai/".length) };
-  }
-  if (spec.startsWith("voyage/")) {
-    return { providerId: "voyage", modelId: spec.slice("voyage/".length) };
-  }
-  if (spec.startsWith("cohere/")) {
-    return { providerId: "cohere", modelId: spec.slice("cohere/".length) };
-  }
-  if (spec.startsWith("gemini/")) {
-    return { providerId: "gemini", modelId: spec.slice("gemini/".length) };
-  }
-  if (spec.startsWith("local/")) {
-    const rest = spec.slice("local/".length);
-    const at = rest.lastIndexOf("@");
-    if (at === -1) {
-      throw new EmbedderError(`local/ embedder must be local/<model>@<base-url> (got "${spec}")`);
-    }
-    const modelId = rest.slice(0, at);
-    const baseUrl = rest.slice(at + 1);
-    return { providerId: "local", modelId, baseUrl };
-  }
-  if (spec.startsWith("mock/")) {
-    return { providerId: "mock", modelId: spec.slice("mock/".length) };
-  }
-  throw new EmbedderError(
-    `unknown embedder prefix in "${spec}" — expected openai/, voyage/, cohere/, gemini/, local/<m>@<url>, or mock/`,
-  );
-}
-
-export type EmbedOptions = {
-  readonly batchSize?: number;
-  readonly signal?: AbortSignal;
-};
-
-export interface Embedder {
-  readonly model: string;
-  readonly provider: EmbedderProviderId;
-  embed(texts: ReadonlyArray<string>, opts?: EmbedOptions): Promise<number[][]>;
-}
-
-const DEFAULT_BATCH = 100;
-
-// ---------------------------------------------------------------------------
-// Mock backend — deterministic hashed bag-of-words.
-// ---------------------------------------------------------------------------
-
-const MOCK_DIM = 256;
-
-function hashedBow(text: string, dim: number): number[] {
-  const out = new Array<number>(dim).fill(0);
-  // Tokenise on word boundaries; lowercased; ASCII-only (good enough for hashed BoW).
-  const tokens = text
-    .toLowerCase()
-    .normalize("NFKD")
-    .replace(/[^a-z0-9]+/g, " ")
-    .split(" ")
-    .filter((t) => t.length > 0);
-  for (const t of tokens) {
-    const h = createHash("sha256").update(t).digest();
-    const slot = h.readUInt32BE(0) % dim;
-    const sign = (h.readUInt8(4) & 1) === 0 ? 1 : -1;
-    out[slot] = (out[slot] ?? 0) + sign;
-  }
-  // L2-normalise so cosine similarity ≈ dot product.
-  let norm = 0;
-  for (const v of out) norm += v * v;
-  norm = Math.sqrt(norm);
-  if (norm === 0) return out;
-  return out.map((v) => v / norm);
-}
-
-class MockEmbedder implements Embedder {
-  readonly provider: EmbedderProviderId = "mock";
-  constructor(public readonly model: string) {}
-  async embed(texts: ReadonlyArray<string>): Promise<number[][]> {
-    return texts.map((t) => hashedBow(t, MOCK_DIM));
-  }
-}
-
-// ---------------------------------------------------------------------------
-// OpenAI / OpenAI-compatible (covers OpenAI cloud + local OpenAI-shaped
-// servers like Ollama, vLLM, llama.cpp).
-// ---------------------------------------------------------------------------
-
-/**
- * Normalise a baseUrl before appending `/v1/embeddings`: strip a trailing
- * slash AND a trailing `/v1` segment so both URL shapes users commonly
- * supply work (`http://localhost:11434` and `http://localhost:11434/v1`
- * both resolve to `.../v1/embeddings` — never `.../v1/v1/embeddings`).
- */
-function normaliseEmbeddingsBaseUrl(baseUrl: string): string {
-  let out = baseUrl;
-  if (out.endsWith("/")) out = out.slice(0, -1);
-  if (out.endsWith("/v1")) out = out.slice(0, -"/v1".length);
-  return out;
-}
-
-class OpenAILikeEmbedder implements Embedder {
-  readonly provider: EmbedderProviderId;
-  private readonly baseUrl: string;
-  constructor(
-    provider: EmbedderProviderId,
-    public readonly model: string,
-    baseUrl: string,
-    private readonly apiKey: string | undefined,
-  ) {
-    this.provider = provider;
-    this.baseUrl = normaliseEmbeddingsBaseUrl(baseUrl);
-  }
-  async embed(texts: ReadonlyArray<string>, opts: EmbedOptions = {}): Promise<number[][]> {
-    if (texts.length === 0) return [];
-    const batchSize = opts.batchSize ?? DEFAULT_BATCH;
-    const out: number[][] = [];
-    for (let i = 0; i < texts.length; i += batchSize) {
-      const batch = texts.slice(i, i + batchSize);
-      const headers: Record<string, string> = { "content-type": "application/json" };
-      if (this.apiKey !== undefined && this.apiKey.length > 0) {
-        headers["authorization"] = `Bearer ${this.apiKey}`;
-      }
-      const res = await fetch(`${this.baseUrl}/v1/embeddings`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({ model: this.model, input: batch }),
-        ...(opts.signal !== undefined ? { signal: opts.signal } : {}),
-      });
-      if (!res.ok) {
-        const text = await res.text().catch(() => "");
-        throw new EmbedderError(
-          `embedding request failed (${this.provider} ${this.model}): ${res.status} ${text}`,
-        );
-      }
-      const json = (await res.json()) as { data: Array<{ embedding: number[] }> };
-      for (const row of json.data) out.push(row.embedding);
-    }
-    return out;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Gemini — Google Generative Language REST API. Not OpenAI-shaped: one
-// POST per text to `models/<model>:embedContent` with the API key as a
-// query param, response carries `embedding.values`. The per-text loop is
-// fine for the embedder's batch sizes (the API has no multi-text body on
-// this endpoint shape).
-// ---------------------------------------------------------------------------
-
-const GEMINI_EMBED_BASE = "https://generativelanguage.googleapis.com/v1beta";
-
-class GeminiEmbedder implements Embedder {
-  readonly provider: EmbedderProviderId = "gemini";
-  constructor(
-    public readonly model: string,
-    private readonly apiKey: string,
-    private readonly baseUrl: string = GEMINI_EMBED_BASE,
-  ) {}
-  async embed(texts: ReadonlyArray<string>, opts: EmbedOptions = {}): Promise<number[][]> {
-    if (texts.length === 0) return [];
-    const out: number[][] = [];
-    for (const text of texts) {
-      const url = `${this.baseUrl}/models/${this.model}:embedContent?key=${encodeURIComponent(this.apiKey)}`;
-      const res = await fetch(url, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ content: { parts: [{ text }] } }),
-        ...(opts.signal !== undefined ? { signal: opts.signal } : {}),
-      });
-      if (!res.ok) {
-        const body = await res.text().catch(() => "");
-        throw new EmbedderError(
-          `embedding request failed (gemini ${this.model}): ${res.status} ${body}`,
-        );
-      }
-      const json = (await res.json()) as { embedding?: { values?: number[] } };
-      const values = json.embedding?.values;
-      if (!Array.isArray(values)) {
-        throw new EmbedderError(
-          `gemini embedding response missing embedding.values (model ${this.model})`,
-        );
-      }
-      out.push(values);
-    }
-    return out;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Factory.
-// ---------------------------------------------------------------------------
-
-export type CreateEmbedderOptions = {
-  readonly model: string;
-  /** Override the API key; defaults to provider-specific env vars. */
-  readonly apiKey?: string;
-  /** For "local/" prefix; otherwise ignored. */
-  readonly baseUrl?: string;
-};
-
-export function createEmbedder(opts: CreateEmbedderOptions): Embedder {
-  const parsed = parseEmbedderModel(opts.model);
-  switch (parsed.providerId) {
-    case "mock":
-      return new MockEmbedder(parsed.modelId);
-    case "openai": {
-      const apiKey = opts.apiKey ?? process.env["OPENAI_API_KEY"];
-      if (apiKey === undefined || apiKey === "") {
-        throw new EmbedderError("openai embedder requires OPENAI_API_KEY");
-      }
-      return new OpenAILikeEmbedder(
-        "openai",
-        parsed.modelId,
-        opts.baseUrl ?? "https://api.openai.com",
-        apiKey,
-      );
-    }
-    case "voyage": {
-      const apiKey = opts.apiKey ?? process.env["VOYAGE_API_KEY"];
-      if (apiKey === undefined || apiKey === "") {
-        throw new EmbedderError("voyage embedder requires VOYAGE_API_KEY");
-      }
-      return new OpenAILikeEmbedder(
-        "voyage",
-        parsed.modelId,
-        opts.baseUrl ?? "https://api.voyageai.com",
-        apiKey,
-      );
-    }
-    case "cohere": {
-      const apiKey = opts.apiKey ?? process.env["COHERE_API_KEY"];
-      if (apiKey === undefined || apiKey === "") {
-        throw new EmbedderError("cohere embedder requires COHERE_API_KEY");
-      }
-      // Cohere's OpenAI-compatible surface lives under /compatibility —
-      // the bare host has no /v1/embeddings path (it 404s).
-      return new OpenAILikeEmbedder(
-        "cohere",
-        parsed.modelId,
-        opts.baseUrl ?? "https://api.cohere.ai/compatibility",
-        apiKey,
-      );
-    }
-    case "gemini": {
-      // Empty-string env values count as unset so GOOGLE_API_KEY can take
-      // over when GEMINI_API_KEY="" (common in CI matrices).
-      const candidates = [
-        opts.apiKey,
-        process.env["GEMINI_API_KEY"],
-        process.env["GOOGLE_API_KEY"],
-      ];
-      const apiKey = candidates.find((k) => k !== undefined && k !== "");
-      if (apiKey === undefined) {
-        throw new EmbedderError("gemini embedder requires GEMINI_API_KEY (or GOOGLE_API_KEY)");
-      }
-      return new GeminiEmbedder(parsed.modelId, apiKey, opts.baseUrl ?? GEMINI_EMBED_BASE);
-    }
-    case "local":
-      return new OpenAILikeEmbedder(
-        "local",
-        parsed.modelId,
-        opts.baseUrl ?? parsed.baseUrl ?? "",
-        opts.apiKey,
-      );
-    default: {
-      const exhaustive: never = parsed.providerId;
-      throw new EmbedderError(`unknown provider "${exhaustive}"`);
-    }
-  }
-}