om-memory-system 6.2.0 → 6.3.0

package/dist/importer/external-api-test.d.ts

@@ -1,4 +1,4 @@
-import { CONFIG } from "../config.js";
+import type { MemoryProviderRuntimeConfig } from "../services/ai/provider-config.js";
 export type ExternalApiTestResult = {
     ok: true;
     model: string;
@@ -10,7 +10,9 @@ export type ExternalApiTestResult = {
  * One small call to the saved external API from this process, with a small
  * output limit. The error never contains the key.
  */
-export declare function testExternalApi(config?: typeof CONFIG, createProvider?: (provider: string, providerConfig: Record<string, unknown>) => {
+export declare function testExternalApi(given?: MemoryProviderRuntimeConfig & {
+    memoryProvider: string;
+}, createProvider?: (provider: string, providerConfig: Record<string, unknown>) => {
     executeToolCall: (...args: any[]) => Promise<{
         success: boolean;
         error?: string;

package/dist/importer/external-api-test.js

@@ -1,5 +1,4 @@
 import { randomUUID } from "node:crypto";
-import { CONFIG } from "../config.js";
 import { safeHealthError } from "../services/safe-health-error.js";
 const OUTPUT_LIMIT = 64;
 const TIMEOUT_MS = 20_000;
@@ -15,7 +14,9 @@ function outputLimitParams(provider) {
  * One small call to the saved external API from this process, with a small
  * output limit. The error never contains the key.
  */
-export async function testExternalApi(config = CONFIG, createProvider) {
+export async function testExternalApi(given, createProvider) {
+    // The real config loads only when no config is passed, so tests never read it.
+    const config = given ?? (await import("../config.js")).CONFIG;
     const secrets = [config.memoryApiKey];
     try {
         const { buildMemoryProviderConfig } = await import("../services/ai/provider-config.js");

package/dist/services/ai/provider-config.d.ts

@@ -1,5 +1,5 @@
 import type { ProviderConfig } from "./providers/base-provider.js";
-interface MemoryProviderRuntimeConfig {
+export interface MemoryProviderRuntimeConfig {
     memoryProvider?: string;
     memoryModel?: string;
     memoryApiUrl?: string;

package/dist/services/openrouter-models.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The OpenRouter model list, reduced to ID and name for the Model field
+ * suggestions. It reads one public OpenRouter list without an API key. `fetch`
+ * and the clock come in as arguments, so the module needs no config and tests
+ * need no network.
+ */
+export type ModelRow = {
+    id: string;
+    name: string;
+};
+export type ModelsResult = {
+    ok: true;
+    models: ModelRow[];
+} | {
+    ok: false;
+    error: string;
+};
+export type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+export declare function createOpenRouterModels(deps: {
+    fetch: FetchLike;
+    now: () => number;
+    timeoutMs?: number;
+}): {
+    list: () => Promise<ModelsResult>;
+};

package/dist/services/openrouter-models.js

@@ -0,0 +1,58 @@
+/**
+ * The OpenRouter model list, reduced to ID and name for the Model field
+ * suggestions. It reads one public OpenRouter list without an API key. `fetch`
+ * and the clock come in as arguments, so the module needs no config and tests
+ * need no network.
+ */
+const URL_MODELS = "https://openrouter.ai/api/v1/models";
+const CACHE_TTL_MS = 60 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 10_000;
+const text = (value) => typeof value === "string" && value.trim() ? value : undefined;
+export function createOpenRouterModels(deps) {
+    const timeoutMs = deps.timeoutMs ?? FETCH_TIMEOUT_MS;
+    let cache;
+    async function list() {
+        if (cache && deps.now() - cache.at < CACHE_TTL_MS)
+            return { ok: true, models: cache.models };
+        let response;
+        try {
+            response = await deps.fetch(URL_MODELS, {
+                method: "GET",
+                headers: { Accept: "application/json" },
+                signal: AbortSignal.timeout(timeoutMs),
+            });
+        }
+        catch (error) {
+            const name = error instanceof Error ? error.name : "";
+            if (name === "TimeoutError" || name === "AbortError") {
+                return { ok: false, error: "OpenRouter did not answer within 10 seconds." };
+            }
+            return { ok: false, error: "OpenRouter could not be reached." };
+        }
+        if (!response.ok) {
+            return { ok: false, error: `OpenRouter answered with status ${response.status}.` };
+        }
+        let body;
+        try {
+            body = await response.json();
+        }
+        catch {
+            return { ok: false, error: "OpenRouter sent a reply that could not be read." };
+        }
+        const rows = body?.data;
+        if (!Array.isArray(rows)) {
+            return { ok: false, error: "OpenRouter sent a model list in an unknown form." };
+        }
+        const models = [];
+        for (const row of rows) {
+            const id = text(row?.id);
+            if (id)
+                models.push({ id, name: text(row.name) ?? id });
+        }
+        models.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+        // Only a good answer is cached, so a failed fetch is tried again on the next request.
+        cache = { at: deps.now(), models };
+        return { ok: true, models };
+    }
+    return { list };
+}

package/dist/services/openrouter-providers.d.ts

@@ -5,10 +5,16 @@
  * arguments, so the module needs no config and tests need no network.
  */
 export type ProviderPolicy = "zdr" | "safety" | "unknown";
+/** US dollars per 1M tokens. Only set when both values are known. */
+export type ProviderPrice = {
+    input: number;
+    output: number;
+};
 export type ProviderRow = {
     slug: string;
     name: string;
     policy: ProviderPolicy;
+    price?: ProviderPrice;
 };
 export type ProviderFailure = "unknown-model" | "timeout" | "unreachable";
 export type ProvidersResult = {

package/dist/services/openrouter-providers.js

@@ -24,6 +24,16 @@ class ListError extends Error {
     }
 }
 const text = (value) => typeof value === "string" && value.trim() ? value : undefined;
+/** A per-token price string such as "0.000000256" as US dollars per 1M tokens. Missing, non-numeric or negative gives undefined. */
+function pricePerMillion(value) {
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    const perToken = Number(value);
+    if (!Number.isFinite(perToken) || perToken < 0)
+        return undefined;
+    return Math.round(perToken * 1_000_000 * 1e6) / 1e6;
+}
+const lowest = (a, b) => a === undefined ? b : b === undefined ? a : Math.min(a, b);
 export function createOpenRouterProviders(deps) {
     const timeoutMs = deps.timeoutMs ?? FETCH_TIMEOUT_MS;
     let zdrCache;
@@ -91,6 +101,8 @@ export function createOpenRouterProviders(deps) {
                 throw new ListError("unreachable", "OpenRouter sent a provider list in an unknown form.");
             }
             const bySlug = new Map();
+            // Lowest input and output price per slug, found independently across its endpoints.
+            const prices = new Map();
             for (const endpoint of endpoints) {
                 const tag = text(endpoint?.tag);
                 const name = text(endpoint?.provider_name);
@@ -100,6 +112,11 @@ export function createOpenRouterProviders(deps) {
                 const modelId = text(endpoint?.model_id);
                 const flag = tag && modelId ? flags.get(`${modelId}\n${tag}`) : undefined;
                 const policy = flag === undefined ? "unknown" : flag ? "safety" : "zdr";
+                const pricing = endpoint?.pricing;
+                const lows = prices.get(slug) ?? {};
+                lows.input = lowest(lows.input, pricePerMillion(pricing?.prompt));
+                lows.output = lowest(lows.output, pricePerMillion(pricing?.completion));
+                prices.set(slug, lows);
                 const seen = bySlug.get(slug);
                 if (!seen) {
                     bySlug.set(slug, { slug, name: name ?? slug, policy });
@@ -108,6 +125,12 @@ export function createOpenRouterProviders(deps) {
                     seen.policy = policy;
                 }
             }
+            // A price needs both values. A slug with only one of them shows no price.
+            for (const [slug, row] of bySlug) {
+                const { input, output } = prices.get(slug) ?? {};
+                if (input !== undefined && output !== undefined)
+                    row.price = { input, output };
+            }
             const providers = [...bySlug.values()].sort((a, b) => a.name.localeCompare(b.name));
             if (providers.length === 0) {
                 throw new ListError("unknown-model", "OpenRouter has no providers for that model.");

package/dist/services/openrouter-routes.js

@@ -1,13 +1,19 @@
 import { log } from "./logger.js";
+import { createOpenRouterModels } from "./openrouter-models.js";
 import { createOpenRouterProviders, isModelId } from "./openrouter-providers.js";
 import { isOpenRouterUrl, parseRouting, removeProviderEdits, routingEdits, } from "./openrouter-routing-config.js";
 const PROVIDERS_PATH = "/api/settings/external-api/openrouter-providers";
+const MODELS_PATH = "/api/settings/external-api/openrouter-models";
 const ROUTING_PATH = "/api/settings/external-api/openrouter-routing";
 /** Reads `globalThis.fetch` at call time, so a test can replace it. */
 const providers = createOpenRouterProviders({
     fetch: (input, init) => globalThis.fetch(input, init),
     now: () => Date.now(),
 });
+const models = createOpenRouterModels({
+    fetch: (input, init) => globalThis.fetch(input, init),
+    now: () => Date.now(),
+});
 const NOT_OPENROUTER = "Save the OpenRouter endpoint first. Routing applies only to an OpenRouter API URL.";
 const fail = (status, error) => ({ status, body: { error } });
 /**
@@ -23,6 +29,9 @@ export async function routeOpenRouter(path, method, url, readBody, ctx) {
         }
         return { status: 200, body: await providers.list(model) };
     }
+    if (path === MODELS_PATH && method === "GET") {
+        return { status: 200, body: await models.list() };
+    }
     if (path === ROUTING_PATH && method === "POST") {
         const body = await readBody();
         if (typeof body?.revision !== "string")