@wopr-network/platform-core 1.12.2 → 1.13.0

package/dist/monetization/adapters/ollama-embeddings.test.js

@@ -0,0 +1,178 @@
+import { Credit } from "@wopr-network/platform-core/credits";
+import { describe, expect, it, vi } from "vitest";
+import { createOllamaEmbeddingsAdapter } from "./ollama-embeddings.js";
+import { withMargin } from "./types.js";
+/** Helper to create a mock Response */
+function mockResponse(body, status = 200) {
+    return {
+        ok: status >= 200 && status < 300,
+        status,
+        json: () => Promise.resolve(body),
+        text: () => Promise.resolve(JSON.stringify(body)),
+        headers: new Headers(),
+    };
+}
+/** A successful OpenAI-compatible embeddings response */
+function embeddingsResponse(overrides = {}) {
+    return {
+        model: "nomic-embed-text",
+        data: [{ embedding: [0.1, 0.2, 0.3, 0.4] }],
+        usage: { total_tokens: 5 },
+        ...overrides,
+    };
+}
+function makeConfig(overrides = {}) {
+    return {
+        baseUrl: "http://ollama:11434",
+        costPerUnit: 0.000000005,
+        ...overrides,
+    };
+}
+describe("createOllamaEmbeddingsAdapter", () => {
+    it("returns adapter with correct name and capabilities", () => {
+        const adapter = createOllamaEmbeddingsAdapter(makeConfig());
+        expect(adapter.name).toBe("ollama-embeddings");
+        expect(adapter.capabilities).toEqual(["embeddings"]);
+        expect(adapter.selfHosted).toBe(true);
+    });
+    it("calls /v1/embeddings endpoint", async () => {
+        const body = embeddingsResponse();
+        const fetchFn = vi.fn().mockResolvedValueOnce(mockResponse(body));
+        const adapter = createOllamaEmbeddingsAdapter(makeConfig(), fetchFn);
+        await adapter.embed({ input: "Hello world" });
+        const [url, init] = fetchFn.mock.calls[0];
+        expect(url).toBe("http://ollama:11434/v1/embeddings");
+        expect(init?.method).toBe("POST");
+        expect((init?.headers)["Content-Type"]).toBe("application/json");
+    });
+    it("calculates cost from token count and costPerToken", async () => {
+        const body = embeddingsResponse({ usage: { total_tokens: 100 } });
+        const fetchFn = vi.fn().mockResolvedValueOnce(mockResponse(body));
+        const adapter = createOllamaEmbeddingsAdapter(makeConfig({ costPerToken: 0.000000005 }), fetchFn);
+        const result = await adapter.embed({ input: "test" });
+        // 100 tokens * $0.000000005 = $0.0000005
+        expect(result.cost.toDollars()).toBeCloseTo(0.0000005, 10);
+    });
+    it("applies margin to cost", async () => {
+        const body = embeddingsResponse({ usage: { total_tokens: 1000 } });
+        const fetchFn = vi.fn().mockResolvedValueOnce(mockResponse(body));
+        const adapter = createOllamaEmbeddingsAdapter(makeConfig({ marginMultiplier: 1.5 }), fetchFn);
+        const result = await adapter.embed({ input: "test" });
+        const expectedCost = Credit.fromDollars(1000 * 0.000000005);
+        expect(result.cost.toDollars()).toBeCloseTo(expectedCost.toDollars(), 10);
+        expect(result.charge?.toDollars()).toBeCloseTo(withMargin(expectedCost, 1.5).toDollars(), 10);
+    });
+    it("uses default 1.2 margin (lower than third-party)", async () => {
+        const body = embeddingsResponse({ usage: { total_tokens: 1000 } });
+        const fetchFn = vi.fn().mockResolvedValueOnce(mockResponse(body));
+        const adapter = createOllamaEmbeddingsAdapter(makeConfig(), fetchFn);
+        const result = await adapter.embed({ input: "test" });
+        const expectedCost = Credit.fromDollars(1000 * 0.000000005);
+        expect(result.charge?.toDollars()).toBeCloseTo(withMargin(expectedCost, 1.2).toDollars(), 10);
+    });
+    it("uses default model (nomic-embed-text) when none specified", async () => {
+        const body = embeddingsResponse();
+        const fetchFn = vi.fn().mockResolvedValueOnce(mockResponse(body));
+        const adapter = createOllamaEmbeddingsAdapter(makeConfig(), fetchFn);
+        await adapter.embed({ input: "test" });
+        const reqBody = JSON.parse(fetchFn.mock.calls[0][1]?.body);
+        expect(reqBody.model).toBe("nomic-embed-text");
+    });
+    it("passes requested model through to request", async () => {
+        const body = embeddingsResponse({ model: "mxbai-embed-large" });
+        const fetchFn = vi.fn().mockResolvedValueOnce(mockResponse(body));
+        const adapter = createOllamaEmbeddingsAdapter(makeConfig(), fetchFn);
+        const result = await adapter.embed({ input: "test", model: "mxbai-embed-large" });
+        const reqBody = JSON.parse(fetchFn.mock.calls[0][1]?.body);
+        expect(reqBody.model).toBe("mxbai-embed-large");
+        expect(result.result.model).toBe("mxbai-embed-large");
+    });
+    it("passes dimensions through to request", async () => {
+        const body = embeddingsResponse();
+        const fetchFn = vi.fn().mockResolvedValueOnce(mockResponse(body));
+        const adapter = createOllamaEmbeddingsAdapter(makeConfig(), fetchFn);
+        await adapter.embed({ input: "test", dimensions: 256 });
+        const reqBody = JSON.parse(fetchFn.mock.calls[0][1]?.body);
+        expect(reqBody.dimensions).toBe(256);
+    });
+    it("does not send dimensions when not specified", async () => {
+        const body = embeddingsResponse();
+        const fetchFn = vi.fn().mockResolvedValueOnce(mockResponse(body));
+        const adapter = createOllamaEmbeddingsAdapter(makeConfig(), fetchFn);
+        await adapter.embed({ input: "test" });
+        const reqBody = JSON.parse(fetchFn.mock.calls[0][1]?.body);
+        expect(reqBody.dimensions).toBeUndefined();
+    });
+    it("handles batch input (string[])", async () => {
+        const body = embeddingsResponse({
+            data: [{ embedding: [0.1, 0.2, 0.3] }, { embedding: [0.4, 0.5, 0.6] }],
+            usage: { total_tokens: 10 },
+        });
+        const fetchFn = vi.fn().mockResolvedValueOnce(mockResponse(body));
+        const adapter = createOllamaEmbeddingsAdapter(makeConfig(), fetchFn);
+        const result = await adapter.embed({ input: ["Hello", "World"] });
+        const reqBody = JSON.parse(fetchFn.mock.calls[0][1]?.body);
+        expect(reqBody.input).toEqual(["Hello", "World"]);
+        expect(result.result.embeddings).toHaveLength(2);
+        expect(result.result.embeddings[0]).toEqual([0.1, 0.2, 0.3]);
+        expect(result.result.embeddings[1]).toEqual([0.4, 0.5, 0.6]);
+        expect(result.result.totalTokens).toBe(10);
+    });
+    it("throws on non-2xx response", async () => {
+        const fetchFn = vi.fn().mockResolvedValueOnce(mockResponse({ error: "model not found" }, 404));
+        const adapter = createOllamaEmbeddingsAdapter(makeConfig(), fetchFn);
+        await expect(adapter.embed({ input: "test" })).rejects.toThrow("Ollama embeddings error (404)");
+    });
+    it("throws on 500 server error", async () => {
+        const fetchFn = vi.fn().mockResolvedValueOnce(mockResponse({ error: "internal error" }, 500));
+        const adapter = createOllamaEmbeddingsAdapter(makeConfig(), fetchFn);
+        await expect(adapter.embed({ input: "test" })).rejects.toThrow("Ollama embeddings error (500)");
+    });
+    it("uses custom baseUrl", async () => {
+        const body = embeddingsResponse();
+        const fetchFn = vi.fn().mockResolvedValueOnce(mockResponse(body));
+        const adapter = createOllamaEmbeddingsAdapter(makeConfig({ baseUrl: "http://gpu-node:11434" }), fetchFn);
+        await adapter.embed({ input: "test" });
+        const [url] = fetchFn.mock.calls[0];
+        expect(url).toBe("http://gpu-node:11434/v1/embeddings");
+    });
+    it("uses costPerUnit from SelfHostedAdapterConfig when costPerToken not set", async () => {
+        const body = embeddingsResponse({ usage: { total_tokens: 1000 } });
+        const fetchFn = vi.fn().mockResolvedValueOnce(mockResponse(body));
+        const adapter = createOllamaEmbeddingsAdapter(makeConfig({ costPerUnit: 0.00000001 }), fetchFn);
+        const result = await adapter.embed({ input: "test" });
+        // 1000 tokens * $0.00000001 = $0.00001
+        expect(result.cost.toDollars()).toBeCloseTo(0.00001, 8);
+    });
+    it("costPerToken takes precedence over costPerUnit", async () => {
+        const body = embeddingsResponse({ usage: { total_tokens: 1000 } });
+        const fetchFn = vi.fn().mockResolvedValueOnce(mockResponse(body));
+        const adapter = createOllamaEmbeddingsAdapter(makeConfig({ costPerUnit: 0.00000001, costPerToken: 0.000000005 }), fetchFn);
+        const result = await adapter.embed({ input: "test" });
+        // costPerToken wins: 1000 * $0.000000005 = $0.000005
+        expect(result.cost.toDollars()).toBeCloseTo(0.000005, 10);
+    });
+    it("uses custom defaultModel from config", async () => {
+        const body = embeddingsResponse({ model: "mxbai-embed-large" });
+        const fetchFn = vi.fn().mockResolvedValueOnce(mockResponse(body));
+        const adapter = createOllamaEmbeddingsAdapter(makeConfig({ defaultModel: "mxbai-embed-large" }), fetchFn);
+        await adapter.embed({ input: "test" });
+        const reqBody = JSON.parse(fetchFn.mock.calls[0][1]?.body);
+        expect(reqBody.model).toBe("mxbai-embed-large");
+    });
+    it("normalizes trailing slash in baseUrl", async () => {
+        const body = embeddingsResponse();
+        const fetchFn = vi.fn().mockResolvedValueOnce(mockResponse(body));
+        const adapter = createOllamaEmbeddingsAdapter(makeConfig({ baseUrl: "http://ollama:11434/" }), fetchFn);
+        await adapter.embed({ input: "test" });
+        const [url] = fetchFn.mock.calls[0];
+        expect(url).toBe("http://ollama:11434/v1/embeddings");
+    });
+    it("returns correct totalTokens from response", async () => {
+        const body = embeddingsResponse({ usage: { total_tokens: 42 } });
+        const fetchFn = vi.fn().mockResolvedValueOnce(mockResponse(body));
+        const adapter = createOllamaEmbeddingsAdapter(makeConfig(), fetchFn);
+        const result = await adapter.embed({ input: "test" });
+        expect(result.result.totalTokens).toBe(42);
+    });
+});

package/dist/monetization/adapters/rate-table.js

@@ -95,8 +95,15 @@ export const RATE_TABLE = [
         effectivePrice: 0.0247, // = costPerUnit * margin ($24.70 per 1K images)
     },
     // Embeddings
-    // NOTE: No self-hosted embeddings adapter yet — only premium (openrouter) available.
-    // When self-hosted-embeddings lands, add a standard tier entry here.
+    {
+        capability: "embeddings",
+        tier: "standard",
+        provider: "ollama-embeddings",
+        costPerUnit: 0.000000005, // Amortized GPU cost per token ($0.005 per 1M tokens)
+        billingUnit: "per-token",
+        margin: 1.2, // 20% — dashboard default; runtime uses getMargin()
+        effectivePrice: 0.000000006, // = costPerUnit * margin ($0.006 per 1M tokens)
+    },
     {
         capability: "embeddings",
         tier: "premium",
@@ -131,7 +138,6 @@ export const RATE_TABLE = [
     },
     // Future self-hosted adapters will add more entries here:
     // - transcription: self-hosted-whisper (standard) — when GPU adapter exists
-    // - embeddings: self-hosted-embeddings (standard) — when GPU adapter exists
     // - image-generation: self-hosted-sdxl (standard) — when GPU adapter exists
 ];
 /**

package/dist/monetization/adapters/rate-table.test.js

@@ -7,6 +7,12 @@ describe("RATE_TABLE", () => {
         expect(standardTTS).toEqual(expect.objectContaining({ capability: "tts", tier: "standard" }));
         expect(premiumTTS).toEqual(expect.objectContaining({ capability: "tts", tier: "premium" }));
     });
+    it("contains both standard and premium tiers for embeddings", () => {
+        const standard = RATE_TABLE.find((e) => e.capability === "embeddings" && e.tier === "standard");
+        const premium = RATE_TABLE.find((e) => e.capability === "embeddings" && e.tier === "premium");
+        expect(standard).toEqual(expect.objectContaining({ capability: "embeddings", tier: "standard", provider: "ollama-embeddings" }));
+        expect(premium).toEqual(expect.objectContaining({ capability: "embeddings", tier: "premium", provider: "openrouter" }));
+    });
     it("contains both standard and premium tiers for text-generation", () => {
         const standard = RATE_TABLE.find((e) => e.capability === "text-generation" && e.tier === "standard");
         const premium = RATE_TABLE.find((e) => e.capability === "text-generation" && e.tier === "premium");
@@ -36,7 +42,9 @@ describe("RATE_TABLE", () => {
         const standardEntries = RATE_TABLE.filter((e) => e.tier === "standard");
         for (const entry of standardEntries) {
             // Self-hosted providers include "self-hosted-" prefix or are known self-hosted names
-            const isSelfHosted = entry.provider.startsWith("self-hosted-") || entry.provider === "chatterbox-tts";
+            const isSelfHosted = entry.provider.startsWith("self-hosted-") ||
+                entry.provider === "chatterbox-tts" ||
+                entry.provider === "ollama-embeddings";
             expect(isSelfHosted).toBe(true);
         }
     });
@@ -104,6 +112,12 @@ describe("getRatesForCapability", () => {
         expect(rates.map((r) => r.tier)).toContain("standard");
         expect(rates.map((r) => r.tier)).toContain("premium");
     });
+    it("returns both standard and premium for embeddings", () => {
+        const rates = getRatesForCapability("embeddings");
+        expect(rates).toHaveLength(2);
+        expect(rates.map((r) => r.tier)).toContain("standard");
+        expect(rates.map((r) => r.tier)).toContain("premium");
+    });
     it("returns premium-only for transcription (no standard tier yet)", () => {
         const rates = getRatesForCapability("transcription");
         expect(rates).toHaveLength(1);
@@ -141,6 +155,13 @@ describe("calculateSavings", () => {
         // Savings: $2.01 per 100K chars
         expect(savings).toBeCloseTo(2.01, 2);
     });
+    it("calculates savings for embeddings at 1M tokens", () => {
+        const savings = calculateSavings("embeddings", 1_000_000);
+        // Standard (ollama-embeddings): $0.006 per 1M tokens
+        // Premium (openrouter): $0.026 per 1M tokens
+        // Savings: $0.020 per 1M tokens
+        expect(savings).toBeCloseTo(0.02, 3);
+    });
     it("returns zero when capability has no standard tier", () => {
         // Transcription only has premium (deepgram) — no self-hosted whisper yet
         const savings = calculateSavings("transcription", 1000);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wopr-network/platform-core",
-  "version": "1.12.2",
+  "version": "1.13.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/monetization/adapters/bootstrap.test.ts

@@ -19,6 +19,7 @@ describe("bootstrapAdapters", () => {
         deepgramApiKey: "sk-dg",
       },
       embeddings: {
+        ollamaBaseUrl: "http://ollama:11434",
         openrouterApiKey: "sk-or",
       },
       imageGen: {
@@ -27,9 +28,9 @@ describe("bootstrapAdapters", () => {
       },
     });
 
-    // 5 text-gen + 2 TTS + 1 transcription + 1 embeddings + 2 image-gen = 11
-    expect(result.adapters).toHaveLength(11);
-    expect(result.summary.total).toBe(11);
+    // 5 text-gen + 2 TTS + 1 transcription + 2 embeddings + 2 image-gen = 12
+    expect(result.adapters).toHaveLength(12);
+    expect(result.summary.total).toBe(12);
     expect(result.summary.skipped).toBe(0);
   });
 
@@ -72,7 +73,7 @@ describe("bootstrapAdapters", () => {
 
     expect(result.skipped.tts).toEqual(["chatterbox-tts", "elevenlabs"]);
     expect(result.skipped.transcription).toEqual(["deepgram"]);
-    expect(result.skipped.embeddings).toEqual(["openrouter"]);
+    expect(result.skipped.embeddings).toEqual(["ollama-embeddings", "openrouter"]);
     expect(result.skipped["text-generation"]).toEqual(["gemini", "minimax", "kimi", "openrouter"]);
     expect(result.skipped["image-generation"]).toEqual(["replicate", "nano-banana"]);
   });
@@ -136,14 +137,15 @@ describe("bootstrapAdaptersFromEnv", () => {
     vi.stubEnv("CHATTERBOX_BASE_URL", "http://chatterbox:8000");
     vi.stubEnv("ELEVENLABS_API_KEY", "env-el");
     vi.stubEnv("DEEPGRAM_API_KEY", "env-dg");
+    vi.stubEnv("OLLAMA_BASE_URL", "http://ollama:11434");
     vi.stubEnv("REPLICATE_API_TOKEN", "r8-rep");
     vi.stubEnv("NANO_BANANA_API_KEY", "env-nb");
 
     const result = bootstrapAdaptersFromEnv();
 
-    // 5 text-gen + 2 TTS + 1 transcription + 1 embeddings + 2 image-gen = 11
-    expect(result.adapters).toHaveLength(11);
-    expect(result.summary.total).toBe(11);
+    // 5 text-gen + 2 TTS + 1 transcription + 2 embeddings + 2 image-gen = 12
+    expect(result.adapters).toHaveLength(12);
+    expect(result.summary.total).toBe(12);
   });
 
   it("returns empty when no env vars set", () => {
@@ -155,6 +157,7 @@ describe("bootstrapAdaptersFromEnv", () => {
     vi.stubEnv("CHATTERBOX_BASE_URL", "");
     vi.stubEnv("ELEVENLABS_API_KEY", "");
     vi.stubEnv("DEEPGRAM_API_KEY", "");
+    vi.stubEnv("OLLAMA_BASE_URL", "");
     vi.stubEnv("REPLICATE_API_TOKEN", "");
     vi.stubEnv("NANO_BANANA_API_KEY", "");
 
@@ -173,6 +176,7 @@ describe("bootstrapAdaptersFromEnv", () => {
     vi.stubEnv("CHATTERBOX_BASE_URL", "");
     vi.stubEnv("ELEVENLABS_API_KEY", "");
     vi.stubEnv("DEEPGRAM_API_KEY", "");
+    vi.stubEnv("OLLAMA_BASE_URL", "");
     vi.stubEnv("REPLICATE_API_TOKEN", "");
     vi.stubEnv("NANO_BANANA_API_KEY", "");
 

package/src/monetization/adapters/bootstrap.ts

@@ -11,7 +11,7 @@
  *   - text-generation (DeepSeek, Gemini, MiniMax, Kimi, OpenRouter)
  *   - tts (Chatterbox GPU, ElevenLabs)
  *   - transcription (Deepgram)
- *   - embeddings (OpenRouter)
+ *   - embeddings (Ollama GPU, OpenRouter)
  *   - image-generation (Replicate, Nano Banana)
  */
 
@@ -121,7 +121,7 @@ export function bootstrapAdapters(config: BootstrapConfig): BootstrapResult {
  *   - DEEPSEEK_API_KEY, GEMINI_API_KEY, MINIMAX_API_KEY, KIMI_API_KEY, OPENROUTER_API_KEY (text-gen)
  *   - CHATTERBOX_BASE_URL, ELEVENLABS_API_KEY (TTS)
  *   - DEEPGRAM_API_KEY (transcription)
- *   - OPENROUTER_API_KEY (embeddings)
+ *   - OLLAMA_BASE_URL, OPENROUTER_API_KEY (embeddings)
  *   - REPLICATE_API_TOKEN, NANO_BANANA_API_KEY (image-gen)
  *
  * Accepts optional per-capability config overrides.
@@ -146,6 +146,7 @@ export function bootstrapAdaptersFromEnv(overrides?: Partial<BootstrapConfig>):
       ...overrides?.transcription,
     },
     embeddings: {
+      ollamaBaseUrl: process.env.OLLAMA_BASE_URL,
       openrouterApiKey: process.env.OPENROUTER_API_KEY,
       ...overrides?.embeddings,
     },

package/src/monetization/adapters/embeddings-factory.test.ts

@@ -1,34 +1,75 @@
 import { afterAll, beforeEach, describe, expect, it, vi } from "vitest";
 import { createEmbeddingsAdapters, createEmbeddingsAdaptersFromEnv } from "./embeddings-factory.js";
+import * as ollamaModule from "./ollama-embeddings.js";
 import * as openrouterModule from "./openrouter.js";
 
 describe("createEmbeddingsAdapters", () => {
-  it("creates adapter when API key provided", () => {
+  it("creates all adapters when all config provided", () => {
     const result = createEmbeddingsAdapters({
+      ollamaBaseUrl: "http://ollama:11434",
       openrouterApiKey: "sk-or",
     });
 
-    expect(result.adapters).toHaveLength(1);
-    expect(result.adapterMap.size).toBe(1);
+    expect(result.adapters).toHaveLength(2);
+    expect(result.adapterMap.size).toBe(2);
     expect(result.skipped).toHaveLength(0);
   });
 
-  it("adapter is openrouter", () => {
+  it("orders adapters cheapest first (ollama before openrouter)", () => {
     const result = createEmbeddingsAdapters({
+      ollamaBaseUrl: "http://ollama:11434",
       openrouterApiKey: "sk-or",
     });
 
+    expect(result.adapters[0].name).toBe("ollama-embeddings");
+    expect(result.adapters[1].name).toBe("openrouter");
+  });
+
+  it("ollama adapter is self-hosted", () => {
+    const result = createEmbeddingsAdapters({
+      ollamaBaseUrl: "http://ollama:11434",
+    });
+
+    expect(result.adapters[0].selfHosted).toBe(true);
+  });
+
+  it("creates only openrouter when no ollama URL", () => {
+    const result = createEmbeddingsAdapters({
+      openrouterApiKey: "sk-or",
+    });
+
+    expect(result.adapters).toHaveLength(1);
     expect(result.adapters[0].name).toBe("openrouter");
+    expect(result.skipped).toEqual(["ollama-embeddings"]);
+  });
+
+  it("creates only ollama when no openrouter key", () => {
+    const result = createEmbeddingsAdapters({
+      ollamaBaseUrl: "http://ollama:11434",
+    });
+
+    expect(result.adapters).toHaveLength(1);
+    expect(result.adapters[0].name).toBe("ollama-embeddings");
+    expect(result.skipped).toEqual(["openrouter"]);
   });
 
-  it("skips openrouter when no API key", () => {
+  it("skips both when no config", () => {
     const result = createEmbeddingsAdapters({});
 
     expect(result.adapters).toHaveLength(0);
-    expect(result.skipped).toEqual(["openrouter"]);
+    expect(result.skipped).toEqual(["ollama-embeddings", "openrouter"]);
   });
 
-  it("skips adapter with empty string key", () => {
+  it("skips ollama with empty string URL", () => {
+    const result = createEmbeddingsAdapters({
+      ollamaBaseUrl: "",
+    });
+
+    expect(result.adapters).toHaveLength(0);
+    expect(result.skipped).toContain("ollama-embeddings");
+  });
+
+  it("skips openrouter with empty string key", () => {
     const result = createEmbeddingsAdapters({
       openrouterApiKey: "",
     });
@@ -37,24 +78,31 @@ describe("createEmbeddingsAdapters", () => {
     expect(result.skipped).toContain("openrouter");
   });
 
-  it("adapter supports embeddings capability", () => {
+  it("both adapters support embeddings capability", () => {
     const result = createEmbeddingsAdapters({
+      ollamaBaseUrl: "http://ollama:11434",
       openrouterApiKey: "sk-or",
     });
 
-    expect(result.adapters[0].capabilities).toContain("embeddings");
+    for (const adapter of result.adapters) {
+      expect(adapter.capabilities).toContain("embeddings");
+    }
   });
 
-  it("adapter implements embed", () => {
+  it("both adapters implement embed", () => {
     const result = createEmbeddingsAdapters({
+      ollamaBaseUrl: "http://ollama:11434",
       openrouterApiKey: "sk-or",
     });
 
-    expect(typeof result.adapters[0].embed).toBe("function");
+    for (const adapter of result.adapters) {
+      expect(typeof adapter.embed).toBe("function");
+    }
   });
 
   it("adapterMap keys match adapter names", () => {
     const result = createEmbeddingsAdapters({
+      ollamaBaseUrl: "http://ollama:11434",
       openrouterApiKey: "sk-or",
     });
 
@@ -63,17 +111,17 @@ describe("createEmbeddingsAdapters", () => {
     }
   });
 
-  it("passes per-adapter config overrides to adapter constructor", () => {
-    const spy = vi.spyOn(openrouterModule, "createOpenRouterAdapter");
+  it("passes per-adapter config overrides to ollama constructor", () => {
+    const spy = vi.spyOn(ollamaModule, "createOllamaEmbeddingsAdapter");
 
     createEmbeddingsAdapters({
-      openrouterApiKey: "sk-or",
-      openrouter: { marginMultiplier: 1.5 },
+      ollamaBaseUrl: "http://ollama:11434",
+      ollama: { marginMultiplier: 1.5 },
     });
 
     expect(spy).toHaveBeenCalledWith(
       expect.objectContaining({
-        apiKey: "sk-or",
+        baseUrl: "http://ollama:11434",
         marginMultiplier: 1.5,
       }),
     );
@@ -81,15 +129,22 @@ describe("createEmbeddingsAdapters", () => {
     spy.mockRestore();
   });
 
-  it("apiKey cannot be overridden via openrouter config", () => {
-    // Ensure apiKey always comes from openrouterApiKey, not from spread
-    const result = createEmbeddingsAdapters({
-      openrouterApiKey: "sk-real",
-      openrouter: { apiKey: "sk-evil" } as never,
+  it("passes per-adapter config overrides to openrouter constructor", () => {
+    const spy = vi.spyOn(openrouterModule, "createOpenRouterAdapter");
+
+    createEmbeddingsAdapters({
+      openrouterApiKey: "sk-or",
+      openrouter: { marginMultiplier: 1.5 },
     });
 
-    expect(result.adapters).toHaveLength(1);
-    expect(result.adapters[0].name).toBe("openrouter");
+    expect(spy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        apiKey: "sk-or",
+        marginMultiplier: 1.5,
+      }),
+    );
+
+    spy.mockRestore();
   });
 });
 
@@ -102,37 +157,51 @@ describe("createEmbeddingsAdaptersFromEnv", () => {
     vi.unstubAllEnvs();
   });
 
-  it("reads key from environment variable", () => {
+  it("reads keys from environment variables", () => {
+    vi.stubEnv("OLLAMA_BASE_URL", "http://ollama:11434");
     vi.stubEnv("OPENROUTER_API_KEY", "env-or");
 
     const result = createEmbeddingsAdaptersFromEnv();
 
-    expect(result.adapters).toHaveLength(1);
-    expect(result.adapters[0].name).toBe("openrouter");
+    expect(result.adapters).toHaveLength(2);
+    expect(result.adapters[0].name).toBe("ollama-embeddings");
+    expect(result.adapters[1].name).toBe("openrouter");
     expect(result.skipped).toHaveLength(0);
   });
 
-  it("returns empty when no env var set", () => {
+  it("returns empty when no env vars set", () => {
+    vi.stubEnv("OLLAMA_BASE_URL", "");
     vi.stubEnv("OPENROUTER_API_KEY", "");
 
     const result = createEmbeddingsAdaptersFromEnv();
 
     expect(result.adapters).toHaveLength(0);
-    expect(result.skipped).toEqual(["openrouter"]);
+    expect(result.skipped).toEqual(["ollama-embeddings", "openrouter"]);
   });
 
-  it("passes per-adapter overrides alongside env key to adapter constructor", () => {
+  it("creates only ollama when only OLLAMA_BASE_URL set", () => {
+    vi.stubEnv("OLLAMA_BASE_URL", "http://ollama:11434");
+    vi.stubEnv("OPENROUTER_API_KEY", "");
+
+    const result = createEmbeddingsAdaptersFromEnv();
+
+    expect(result.adapters).toHaveLength(1);
+    expect(result.adapters[0].name).toBe("ollama-embeddings");
+  });
+
+  it("passes per-adapter overrides alongside env vars", () => {
+    vi.stubEnv("OLLAMA_BASE_URL", "http://ollama:11434");
     vi.stubEnv("OPENROUTER_API_KEY", "env-or");
-    const spy = vi.spyOn(openrouterModule, "createOpenRouterAdapter");
+    const spy = vi.spyOn(ollamaModule, "createOllamaEmbeddingsAdapter");
 
     createEmbeddingsAdaptersFromEnv({
-      openrouter: { marginMultiplier: 1.2 },
+      ollama: { marginMultiplier: 1.1 },
     });
 
     expect(spy).toHaveBeenCalledWith(
       expect.objectContaining({
-        apiKey: "env-or",
-        marginMultiplier: 1.2,
+        baseUrl: "http://ollama:11434",
+        marginMultiplier: 1.1,
       }),
     );