@wopr-network/platform-core 1.12.2 → 1.13.1

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,
       }),
     );
 

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

@@ -7,18 +7,22 @@
  * registers with an ArbitrageRouter or AdapterSocket.
  *
  * Priority order (cheapest first, when all adapters available):
- *   self-hosted-embeddings (GPU, cheapest — not yet implemented)
+ *   Ollama (GPU, cheapest — $0.005/1M tokens amortized)
  *   → OpenRouter ($0.02/1M tokens via text-embedding-3-small)
  */
 
+import { createOllamaEmbeddingsAdapter, type OllamaEmbeddingsAdapterConfig } from "./ollama-embeddings.js";
 import { createOpenRouterAdapter, type OpenRouterAdapterConfig } from "./openrouter.js";
 import type { ProviderAdapter } from "./types.js";
 
-/** Top-level factory config. Only providers with an API key are instantiated. */
+/** Top-level factory config. Only providers with a key/URL are instantiated. */
 export interface EmbeddingsFactoryConfig {
+  /** Ollama base URL (e.g., "http://ollama:11434"). Omit or empty string to skip. */
+  ollamaBaseUrl?: string;
   /** OpenRouter API key. Omit or empty string to skip. */
   openrouterApiKey?: string;
   /** Per-adapter config overrides */
+  ollama?: Omit<Partial<OllamaEmbeddingsAdapterConfig>, "baseUrl">;
   openrouter?: Omit<Partial<OpenRouterAdapterConfig>, "apiKey">;
 }
 
@@ -35,13 +39,26 @@ export interface EmbeddingsFactoryResult {
 /**
  * Create embeddings adapters from the provided config.
  *
- * Returns only adapters whose API key is present and non-empty.
+ * Returns only adapters whose key/URL is present and non-empty.
  * Order matches arbitrage priority: cheapest first.
  */
 export function createEmbeddingsAdapters(config: EmbeddingsFactoryConfig): EmbeddingsFactoryResult {
   const adapters: ProviderAdapter[] = [];
   const skipped: string[] = [];
 
+  // Ollama — $0.005/1M tokens (self-hosted GPU, cheapest)
+  if (config.ollamaBaseUrl) {
+    adapters.push(
+      createOllamaEmbeddingsAdapter({
+        baseUrl: config.ollamaBaseUrl,
+        costPerUnit: 0.000000005,
+        ...config.ollama,
+      }),
+    );
+  } else {
+    skipped.push("ollama-embeddings");
+  }
+
   // OpenRouter — $0.02/1M tokens (text-embedding-3-small via OpenAI)
   if (config.openrouterApiKey) {
     adapters.push(createOpenRouterAdapter({ ...config.openrouter, apiKey: config.openrouterApiKey }));
@@ -49,8 +66,6 @@ export function createEmbeddingsAdapters(config: EmbeddingsFactoryConfig): Embed
     skipped.push("openrouter");
   }
 
-  // Future: self-hosted-embeddings will go BEFORE openrouter (GPU tier, cheapest)
-
   const adapterMap = new Map<string, ProviderAdapter>();
   for (const adapter of adapters) {
     adapterMap.set(adapter.name, adapter);
@@ -62,15 +77,17 @@ export function createEmbeddingsAdapters(config: EmbeddingsFactoryConfig): Embed
 /**
  * Create embeddings adapters from environment variables.
  *
- * Reads API keys from:
+ * Reads config from:
+ *   - OLLAMA_BASE_URL (for self-hosted Ollama embeddings)
  *   - OPENROUTER_API_KEY
  *
  * Accepts optional per-adapter overrides.
  */
 export function createEmbeddingsAdaptersFromEnv(
-  overrides?: Omit<EmbeddingsFactoryConfig, "openrouterApiKey">,
+  overrides?: Omit<EmbeddingsFactoryConfig, "ollamaBaseUrl" | "openrouterApiKey">,
 ): EmbeddingsFactoryResult {
   return createEmbeddingsAdapters({
+    ollamaBaseUrl: process.env.OLLAMA_BASE_URL,
     openrouterApiKey: process.env.OPENROUTER_API_KEY,
     ...overrides,
   });

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

@@ -0,0 +1,235 @@
+import { Credit } from "@wopr-network/platform-core/credits";
+import { describe, expect, it, vi } from "vitest";
+import type { FetchFn, OllamaEmbeddingsAdapterConfig } from "./ollama-embeddings.js";
+import { createOllamaEmbeddingsAdapter } from "./ollama-embeddings.js";
+import { withMargin } from "./types.js";
+
+/** Helper to create a mock Response */
+function mockResponse(body: unknown, status = 200): Response {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    json: () => Promise.resolve(body),
+    text: () => Promise.resolve(JSON.stringify(body)),
+    headers: new Headers(),
+  } as Response;
+}
+
+/** A successful OpenAI-compatible embeddings response */
+function embeddingsResponse(overrides: Record<string, unknown> = {}) {
+  return {
+    model: "nomic-embed-text",
+    data: [{ embedding: [0.1, 0.2, 0.3, 0.4] }],
+    usage: { total_tokens: 5 },
+    ...overrides,
+  };
+}
+
+function makeConfig(overrides: Partial<OllamaEmbeddingsAdapterConfig> = {}): OllamaEmbeddingsAdapterConfig {
+  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<FetchFn>().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 as Record<string, string>)["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<FetchFn>().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<FetchFn>().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<FetchFn>().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<FetchFn>().mockResolvedValueOnce(mockResponse(body));
+
+    const adapter = createOllamaEmbeddingsAdapter(makeConfig(), fetchFn);
+    await adapter.embed({ input: "test" });
+
+    const reqBody = JSON.parse(fetchFn.mock.calls[0][1]?.body as string);
+    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<FetchFn>().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 as string);
+    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<FetchFn>().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 as string);
+    expect(reqBody.dimensions).toBe(256);
+  });
+
+  it("does not send dimensions when not specified", async () => {
+    const body = embeddingsResponse();
+    const fetchFn = vi.fn<FetchFn>().mockResolvedValueOnce(mockResponse(body));
+
+    const adapter = createOllamaEmbeddingsAdapter(makeConfig(), fetchFn);
+    await adapter.embed({ input: "test" });
+
+    const reqBody = JSON.parse(fetchFn.mock.calls[0][1]?.body as string);
+    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<FetchFn>().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 as string);
+    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<FetchFn>().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<FetchFn>().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<FetchFn>().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<FetchFn>().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<FetchFn>().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<FetchFn>().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 as string);
+    expect(reqBody.model).toBe("mxbai-embed-large");
+  });
+
+  it("normalizes trailing slash in baseUrl", async () => {
+    const body = embeddingsResponse();
+    const fetchFn = vi.fn<FetchFn>().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<FetchFn>().mockResolvedValueOnce(mockResponse(body));
+
+    const adapter = createOllamaEmbeddingsAdapter(makeConfig(), fetchFn);
+    const result = await adapter.embed({ input: "test" });
+
+    expect(result.result.totalTokens).toBe(42);
+  });
+});

package/src/monetization/adapters/ollama-embeddings.ts

@@ -0,0 +1,120 @@
+/**
+ * Ollama self-hosted embeddings adapter — embeddings on our own GPU infrastructure.
+ *
+ * Points at a self-hosted Ollama container running on our internal network.
+ * Same ProviderAdapter interface as OpenRouter embeddings, but with:
+ * - No API key required (internal container-to-container)
+ * - Amortized GPU cost instead of third-party API invoicing
+ * - Lower margin (cheaper for users = the standard pricing tier)
+ *
+ * Uses Ollama's OpenAI-compatible /v1/embeddings endpoint, so it works with
+ * any Ollama-hosted embedding model (nomic-embed-text, mxbai-embed-large, etc.).
+ *
+ * Cost model:
+ *   Base cost = total_tokens * costPerToken
+ *     Default costPerToken = $0.000000005 (GPU depreciation + electricity)
+ *   Charge = base_cost * marginMultiplier (e.g., 1.2 = 20% margin vs 30% for third-party)
+ */
+
+import { Credit } from "@wopr-network/platform-core/credits";
+import type { FetchFn, SelfHostedAdapterConfig } from "./self-hosted-base.js";
+import type { AdapterResult, EmbeddingsInput, EmbeddingsOutput, ProviderAdapter } from "./types.js";
+import { withMargin } from "./types.js";
+
+// Re-export FetchFn for tests
+export type { FetchFn };
+
+/**
+ * Configuration for the Ollama embeddings adapter.
+ *
+ * Cost precedence: `costPerToken` (if set) > `costPerUnit` (from SelfHostedAdapterConfig).
+ * Use `costPerToken` for adapter-specific overrides; `costPerUnit` is the base config
+ * shared across all self-hosted adapters.
+ */
+export interface OllamaEmbeddingsAdapterConfig extends SelfHostedAdapterConfig {
+  /** Cost per token in USD (amortized GPU time, default: $0.000000005). Takes precedence over costPerUnit. */
+  costPerToken?: number;
+  /** Default embedding model (default: "nomic-embed-text") */
+  defaultModel?: string;
+}
+
+// ~4x cheaper than OpenRouter's text-embedding-3-small ($0.02/1M tokens)
+const DEFAULT_COST_PER_TOKEN = 0.000000005; // $0.005 per 1M tokens
+const DEFAULT_MARGIN = 1.2; // 20% vs 30% for third-party
+const DEFAULT_MODEL = "nomic-embed-text";
+
+/** OpenAI-compatible embeddings response (subset we care about) */
+interface OllamaEmbeddingsResponse {
+  model: string;
+  data: Array<{
+    embedding: number[];
+  }>;
+  usage: {
+    total_tokens: number;
+  };
+}
+
+/**
+ * Create an Ollama self-hosted embeddings adapter.
+ *
+ * Uses factory function pattern (not class) for minimal API surface and easy
+ * dependency injection of fetch for testing.
+ */
+export function createOllamaEmbeddingsAdapter(
+  config: OllamaEmbeddingsAdapterConfig,
+  fetchFn: FetchFn = fetch,
+): ProviderAdapter & Required<Pick<ProviderAdapter, "embed">> {
+  const costPerToken = config.costPerToken ?? config.costPerUnit ?? DEFAULT_COST_PER_TOKEN;
+  const marginMultiplier = config.marginMultiplier ?? DEFAULT_MARGIN;
+  const defaultModel = config.defaultModel ?? DEFAULT_MODEL;
+  const timeoutMs = config.timeoutMs ?? 30000;
+
+  return {
+    name: "ollama-embeddings",
+    capabilities: ["embeddings"] as const,
+    selfHosted: true,
+
+    async embed(input: EmbeddingsInput): Promise<AdapterResult<EmbeddingsOutput>> {
+      const model = input.model ?? defaultModel;
+
+      const body: Record<string, unknown> = {
+        input: input.input,
+        model,
+      };
+      if (input.dimensions !== undefined) {
+        body.dimensions = input.dimensions;
+      }
+
+      const base = config.baseUrl.replace(/\/+$/, "");
+      const res = await fetchFn(`${base}/v1/embeddings`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(timeoutMs),
+      });
+
+      if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Ollama embeddings error (${res.status}): ${text}`);
+      }
+
+      const data = (await res.json()) as OllamaEmbeddingsResponse;
+
+      const totalTokens = data.usage?.total_tokens ?? 0;
+      const cost = Credit.fromDollars(totalTokens * costPerToken);
+      const charge = withMargin(cost, marginMultiplier);
+
+      return {
+        result: {
+          embeddings: data.data.map((d) => d.embedding),
+          model: data.model,
+          totalTokens,
+        },
+        cost,
+        charge,
+      };
+    },
+  };
+}