@wopr-network/platform-core 1.12.2 → 1.13.1

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

@@ -1,54 +1,106 @@
 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("skips openrouter when no API key", () => {
+    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 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 ollama with empty string URL", () => {
+        const result = createEmbeddingsAdapters({
+            ollamaBaseUrl: "",
+        });
+        expect(result.adapters).toHaveLength(0);
+        expect(result.skipped).toContain("ollama-embeddings");
     });
-    it("skips adapter with empty string key", () => {
+    it("skips openrouter with empty string key", () => {
         const result = createEmbeddingsAdapters({
             openrouterApiKey: "",
         });
         expect(result.adapters).toHaveLength(0);
         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",
         });
         for (const [key, adapter] of result.adapterMap) {
             expect(key).toBe(adapter.name);
         }
     });
-    it("passes per-adapter config overrides to adapter constructor", () => {
+    it("passes per-adapter config overrides to ollama constructor", () => {
+        const spy = vi.spyOn(ollamaModule, "createOllamaEmbeddingsAdapter");
+        createEmbeddingsAdapters({
+            ollamaBaseUrl: "http://ollama:11434",
+            ollama: { marginMultiplier: 1.5 },
+        });
+        expect(spy).toHaveBeenCalledWith(expect.objectContaining({
+            baseUrl: "http://ollama:11434",
+            marginMultiplier: 1.5,
+        }));
+        spy.mockRestore();
+    });
+    it("passes per-adapter config overrides to openrouter constructor", () => {
         const spy = vi.spyOn(openrouterModule, "createOpenRouterAdapter");
         createEmbeddingsAdapters({
             openrouterApiKey: "sk-or",
@@ -60,15 +112,6 @@ 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" },
-        });
-        expect(result.adapters).toHaveLength(1);
-        expect(result.adapters[0].name).toBe("openrouter");
-    });
 });
 describe("createEmbeddingsAdaptersFromEnv", () => {
     beforeEach(() => {
@@ -77,28 +120,39 @@ describe("createEmbeddingsAdaptersFromEnv", () => {
     afterAll(() => {
         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,
         }));
         spy.mockRestore();
     });

package/dist/monetization/adapters/ollama-embeddings.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 type { FetchFn, SelfHostedAdapterConfig } from "./self-hosted-base.js";
+import type { ProviderAdapter } from "./types.js";
+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;
+}
+/**
+ * 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 declare function createOllamaEmbeddingsAdapter(config: OllamaEmbeddingsAdapterConfig, fetchFn?: FetchFn): ProviderAdapter & Required<Pick<ProviderAdapter, "embed">>;

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

@@ -0,0 +1,76 @@
+/**
+ * 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 { withMargin } from "./types.js";
+// ~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";
+/**
+ * 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, fetchFn = fetch) {
+    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"],
+        selfHosted: true,
+        async embed(input) {
+            const model = input.model ?? defaultModel;
+            const body = {
+                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());
+            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,
+            };
+        },
+    };
+}

package/dist/monetization/adapters/ollama-embeddings.test.d.ts

@@ -0,0 +1 @@
+export {};

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.1",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -21,6 +21,7 @@
     "./discovery": "./dist/discovery/index.js",
     "./email": "./dist/email/index.js",
     "./fleet": "./dist/fleet/index.js",
+    "./fleet/profile-store": "./dist/fleet/profile-store.js",
     "./gateway": "./dist/gateway/index.js",
     "./inference": "./dist/inference/index.js",
     "./marketplace": "./dist/marketplace/index.js",
@@ -36,6 +37,39 @@
     "./security": "./dist/security/index.js",
     "./setup": "./dist/setup/index.js",
     "./tenancy": "./dist/tenancy/index.js",
+    "./api/routes/audit": "./dist/api/routes/audit.js",
+    "./api/routes/auth": "./dist/api/routes/auth.js",
+    "./api/routes/health": "./dist/api/routes/health.js",
+    "./api/routes/login-history": "./dist/api/routes/login-history.js",
+    "./api/routes/admin-audit": "./dist/api/routes/admin-audit.js",
+    "./api/routes/admin-audit-helper": "./dist/api/routes/admin-audit-helper.js",
+    "./api/routes/admin-backups": "./dist/api/routes/admin-backups.js",
+    "./api/routes/admin-compliance": "./dist/api/routes/admin-compliance.js",
+    "./api/routes/admin-credits": "./dist/api/routes/admin-credits.js",
+    "./api/routes/admin-inference": "./dist/api/routes/admin-inference.js",
+    "./api/routes/admin-migration": "./dist/api/routes/admin-migration.js",
+    "./api/routes/admin-gpu": "./dist/api/routes/admin-gpu.js",
+    "./api/routes/admin-marketplace": "./dist/api/routes/admin-marketplace.js",
+    "./api/routes/admin-notes": "./dist/api/routes/admin-notes.js",
+    "./api/routes/admin-onboarding": "./dist/api/routes/admin-onboarding.js",
+    "./api/routes/admin-rates": "./dist/api/routes/admin-rates.js",
+    "./api/routes/admin-recovery": "./dist/api/routes/admin-recovery.js",
+    "./api/routes/admin-roles": "./dist/api/routes/admin-roles.js",
+    "./api/routes/activity": "./dist/api/routes/activity.js",
+    "./api/routes/channel-validate": "./dist/api/routes/channel-validate.js",
+    "./api/routes/friends-proxy": "./dist/api/routes/friends-proxy.js",
+    "./api/routes/friends-types": "./dist/api/routes/friends-types.js",
+    "./api/routes/incident-response": "./dist/api/routes/incident-response.js",
+    "./api/routes/internal-nodes": "./dist/api/routes/internal-nodes.js",
+    "./api/routes/quota": "./dist/api/routes/quota.js",
+    "./api/routes/secrets": "./dist/api/routes/secrets.js",
+    "./api/routes/tenant-keys": "./dist/api/routes/tenant-keys.js",
+    "./api/routes/fleet-events": "./dist/api/routes/fleet-events.js",
+    "./api/routes/internal-gpu": "./dist/api/routes/internal-gpu.js",
+    "./api/routes/public-pricing": "./dist/api/routes/public-pricing.js",
+    "./api/routes/secret-audit": "./dist/api/routes/secret-audit.js",
+    "./api/routes/verify-email": "./dist/api/routes/verify-email.js",
+    "./api/routes/ws-auth": "./dist/api/routes/ws-auth.js",
     "./trpc": "./dist/trpc/index.js",
     "./*": "./dist/*.js"
   },