om-memory-system 6.1.1 → 6.2.0

package/dist/services/openrouter-routing-config.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Pure rules for the OpenRouter routing card: check the posted routing, and
+ * turn it into config edits that keep every field the card does not manage.
+ */
+/** The `provider` fields the card owns. Any other field (for example `sort`) is left alone. */
+export declare const MANAGED_PROVIDER_KEYS: readonly ["order", "only", "allow_fallbacks", "data_collection", "zdr"];
+export type RoutingResult = {
+    ok: true;
+    routing: Record<string, unknown>;
+} | {
+    ok: false;
+    error: string;
+};
+/** Check the posted `routing` object. An empty `order` or `only` list is dropped, since it restricts nothing. */
+export declare function parseRouting(input: unknown): RoutingResult;
+/** True when the URL's host is exactly `openrouter.ai`. Routing applies only to that endpoint. */
+export declare function isOpenRouterUrl(value: unknown): boolean;
+/**
+ * The provider object after the save: the saved object without the five managed
+ * fields, plus the posted ones. `undefined` means no provider is left.
+ */
+export declare function mergeProvider(saved: unknown, routing: Record<string, unknown>): Record<string, unknown> | undefined;
+/**
+ * Config edits that remove the whole `provider` object, managed fields or not, and
+ * `memoryExtraParams` when nothing else is in it.
+ */
+export declare function removeProviderEdits(savedExtraParams: unknown): Record<string, unknown>;
+/**
+ * Config edits for `memoryExtraParams.provider`. The nested write keeps the other
+ * members and the file's comments. When no provider is left and nothing else is in
+ * `memoryExtraParams`, the whole key goes. Returns the edits and the new provider.
+ */
+export declare function routingEdits(savedExtraParams: unknown, routing: Record<string, unknown>): {
+    edits: Record<string, unknown>;
+    provider: Record<string, unknown> | undefined;
+};
+/**
+ * Keep the global `memoryExtraParams.provider` when a project file sets `memoryExtraParams`.
+ * The project object replaces the global one as a whole, which would drop a privacy choice
+ * such as `zdr`. Like the endpoint and the key, the routing is global. A project keeps its
+ * other members. Pure on purpose: callers pass the file configs and a log function, and
+ * `CONFIG` is never imported here, because many tests stub `src/config.js`.
+ */
+export declare function keepGlobalProvider(globalConfig: {
+    memoryExtraParams?: unknown;
+}, projectOverrides: {
+    memoryExtraParams?: unknown;
+}, log?: (message: string) => void): void;

package/dist/services/openrouter-routing-config.js

@@ -0,0 +1,143 @@
+/**
+ * Pure rules for the OpenRouter routing card: check the posted routing, and
+ * turn it into config edits that keep every field the card does not manage.
+ */
+/** The `provider` fields the card owns. Any other field (for example `sort`) is left alone. */
+export const MANAGED_PROVIDER_KEYS = [
+    "order",
+    "only",
+    "allow_fallbacks",
+    "data_collection",
+    "zdr",
+];
+// A provider slug (`deepinfra`) or a full endpoint slug with up to two more segments, such as
+// `google-vertex/us-east5` or `baseten/fp4/us`. OpenRouter accepts both in `order` and `only`.
+const SEGMENT = "[a-z0-9][a-z0-9._-]{0,63}";
+const SLUG = new RegExp(`^${SEGMENT}(?:/${SEGMENT}){0,2}$`, "i");
+const MAX_SLUGS = 20;
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function slugList(name, value) {
+    if (!Array.isArray(value))
+        return `${name} must be a list of provider slugs`;
+    if (value.length > MAX_SLUGS)
+        return `${name} can list at most ${MAX_SLUGS} providers`;
+    const seen = new Set();
+    for (const entry of value) {
+        if (typeof entry !== "string" || !SLUG.test(entry)) {
+            return `${name} has a provider slug that is not valid (letters, digits, dot, dash and underscore, with a slash between parts)`;
+        }
+        const key = entry.toLowerCase();
+        if (seen.has(key))
+            return `${name} lists a provider more than once`;
+        seen.add(key);
+    }
+    return value;
+}
+/** Check the posted `routing` object. An empty `order` or `only` list is dropped, since it restricts nothing. */
+export function parseRouting(input) {
+    if (!isPlainObject(input))
+        return { ok: false, error: "routing must be an object" };
+    const routing = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (key === "data_collection") {
+            if (value !== "deny")
+                return { ok: false, error: 'data_collection can only be "deny"' };
+            routing[key] = value;
+        }
+        else if (key === "zdr") {
+            if (value !== true)
+                return { ok: false, error: "zdr can only be true" };
+            routing[key] = value;
+        }
+        else if (key === "allow_fallbacks") {
+            if (value !== false)
+                return { ok: false, error: "allow_fallbacks can only be false" };
+            routing[key] = value;
+        }
+        else if (key === "order" || key === "only") {
+            const list = slugList(key, value);
+            if (typeof list === "string")
+                return { ok: false, error: list };
+            if (list.length > 0)
+                routing[key] = list;
+        }
+        else {
+            return { ok: false, error: `routing has a field that is not supported: ${key}` };
+        }
+    }
+    return { ok: true, routing };
+}
+/** True when the URL's host is exactly `openrouter.ai`. Routing applies only to that endpoint. */
+export function isOpenRouterUrl(value) {
+    if (typeof value !== "string")
+        return false;
+    try {
+        return new URL(value).hostname === "openrouter.ai";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The provider object after the save: the saved object without the five managed
+ * fields, plus the posted ones. `undefined` means no provider is left.
+ */
+export function mergeProvider(saved, routing) {
+    const merged = isPlainObject(saved) ? { ...saved } : {};
+    for (const key of MANAGED_PROVIDER_KEYS)
+        delete merged[key];
+    Object.assign(merged, routing);
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+/**
+ * Config edits that remove the whole `provider` object, managed fields or not, and
+ * `memoryExtraParams` when nothing else is in it.
+ */
+export function removeProviderEdits(savedExtraParams) {
+    const extra = isPlainObject(savedExtraParams) ? savedExtraParams : undefined;
+    const others = extra ? Object.keys(extra).filter((key) => key !== "provider") : [];
+    if (!extra || others.length === 0) {
+        return savedExtraParams === undefined ? {} : { memoryExtraParams: undefined };
+    }
+    return { "memoryExtraParams.provider": undefined };
+}
+/**
+ * Config edits for `memoryExtraParams.provider`. The nested write keeps the other
+ * members and the file's comments. When no provider is left and nothing else is in
+ * `memoryExtraParams`, the whole key goes. Returns the edits and the new provider.
+ */
+export function routingEdits(savedExtraParams, routing) {
+    const extra = isPlainObject(savedExtraParams) ? savedExtraParams : undefined;
+    const provider = mergeProvider(extra?.provider, routing);
+    if (provider) {
+        // A saved value that is not an object cannot hold a nested key, so it is replaced.
+        return {
+            edits: extra
+                ? { "memoryExtraParams.provider": provider }
+                : { memoryExtraParams: { provider } },
+            provider,
+        };
+    }
+    return { edits: removeProviderEdits(savedExtraParams), provider };
+}
+/**
+ * Keep the global `memoryExtraParams.provider` when a project file sets `memoryExtraParams`.
+ * The project object replaces the global one as a whole, which would drop a privacy choice
+ * such as `zdr`. Like the endpoint and the key, the routing is global. A project keeps its
+ * other members. Pure on purpose: callers pass the file configs and a log function, and
+ * `CONFIG` is never imported here, because many tests stub `src/config.js`.
+ */
+export function keepGlobalProvider(globalConfig, projectOverrides, log) {
+    const provider = isPlainObject(globalConfig.memoryExtraParams)
+        ? globalConfig.memoryExtraParams.provider
+        : undefined;
+    if (!isPlainObject(provider) || !("memoryExtraParams" in projectOverrides))
+        return;
+    const own = isPlainObject(projectOverrides.memoryExtraParams)
+        ? projectOverrides.memoryExtraParams
+        : {};
+    if ("provider" in own) {
+        log?.("Project config cannot change memoryExtraParams.provider; the global routing is used");
+    }
+    projectOverrides.memoryExtraParams = { ...own, provider };
+}

package/dist/services/settings-snapshot.d.ts

@@ -18,6 +18,7 @@ export declare function getSettingsSnapshot(directory: string): {
         resolvesInWebApp: boolean;
         warning: string | null;
     };
+    openrouterProvider: Record<string, unknown> | null;
     effective: {
         opencode: import("./ai/live-model-choice.js").AutoCaptureProviderStatus;
         pi: import("./ai/live-model-choice.js").PiLiveModelChoice;

package/dist/services/settings-snapshot.js

@@ -126,6 +126,9 @@ function nestedSetting(path, defaultValue, global, project) {
         hasGlobal,
     };
 }
+const plainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    ? value
+    : null;
 export function getSettingsSnapshot(directory) {
     const global = readSettingsFile(getGlobalConfigSourcePath());
     const project = readSettingsFile(projectFile(directory));
@@ -218,6 +221,8 @@ export function getSettingsSnapshot(directory) {
         secrets,
         fallback: { model: CONFIG.memoryModel ?? null, configured: isExternalModelReady(CONFIG) },
         externalKey: memoryKeyStatus(global.memoryApiKey),
+        // The OpenRouter routing card reads the saved `provider` object of memoryExtraParams.
+        openrouterProvider: plainObject(plainObject(global.memoryExtraParams)?.provider),
         effective: {
             opencode: getAutoCaptureProviderStatus(CONFIG),
             pi: resolvePiLiveModel(CONFIG),

package/dist/services/tag-migration.d.ts

@@ -0,0 +1,48 @@
+import { type ProviderErrorKind } from "./ai/provider-error-kind.js";
+import type { buildMemoryProviderConfig } from "./ai/provider-config.js";
+import type { AIProviderType } from "./ai/session/session-types.js";
+export interface ApiResponse<T> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+export type TagMigrationConfig = Parameters<typeof buildMemoryProviderConfig>[0] & {
+    memoryProvider: AIProviderType;
+};
+/**
+ * One batch's answer. `error` and `errorKind` describe the failure that stopped the run,
+ * or else the first failure of the run.
+ */
+export interface TagMigrationBatch {
+    processed: number;
+    total: number;
+    hasMore: boolean;
+    tagged: number;
+    failed: number;
+    errorKind?: ProviderErrorKind;
+    error?: string;
+}
+interface MigrationProgress {
+    processed: number;
+    total: number;
+    currentBatch: number;
+    totalBatches: number;
+    isComplete: boolean;
+    tagged: number;
+    errors: string[];
+    errorKind?: ProviderErrorKind;
+}
+export declare function handleDetectTagMigration(): Promise<ApiResponse<{
+    needsMigration: boolean;
+    count: number;
+}>>;
+export declare function handleGetTagMigrationProgress(): Promise<ApiResponse<MigrationProgress>>;
+/**
+ * Tag the memories that have no tags, a few per request. Only untagged
+ * memories are touched: tagged ones keep their vectors. A memory that fails
+ * is recorded and passed over, so one bad row cannot stall the run. An error
+ * that fails every memory the same way (no credit, a rejected key) ends the
+ * run at once, so a later run starts over with every untagged memory.
+ */
+export declare function runTagMigrationBatch(config: TagMigrationConfig, batchSize?: number): Promise<ApiResponse<TagMigrationBatch>>;
+export {};

package/dist/services/tag-migration.js

@@ -0,0 +1,183 @@
+/**
+ * AI tag backfill for memories saved without tags. Moved out of api-handlers.ts,
+ * which sits at its file-size ceiling. The caller passes the config, so this
+ * module never imports CONFIG.
+ */
+import { embeddingService } from "./embedding.js";
+import { tursoShardManager } from "./turso/shard-manager.js";
+import { tursoVectorSearch } from "./turso/vector-search.js";
+import { tursoConnectionManager } from "./turso/connection-manager.js";
+import { ensureTursoReady } from "./turso/ready.js";
+import { formatTagsForEmbedding } from "./turso/vector-utils.js";
+import { UNTAGGED_NORMAL_PREDICATE } from "./memory-kind.js";
+import { log } from "./logger.js";
+import { resettable } from "./spaces/store-handles.js";
+import { providerErrorKind } from "./ai/provider-error-kind.js";
+const idleMigration = () => ({
+    processed: 0,
+    total: 0,
+    currentBatch: 0,
+    totalBatches: 0,
+    isComplete: true,
+    tagged: 0,
+    errors: [],
+});
+let migrationProgress = idleMigration();
+/** The untagged memories this migration run covers, fixed when the run starts. */
+let migrationQueue = [];
+/** Goes up on a memory space switch, so a batch still running for the old space stops. */
+let spaceGeneration = 0;
+/** The batch now running. Batches run one at a time, so two never take the same memories. */
+let batchInFlight = Promise.resolve();
+// The queue holds paths in the active space, so a space switch drops the run.
+// The next batch then builds a new queue for the new space.
+resettable("tag-migration", null, () => {
+    spaceGeneration++;
+    migrationProgress = idleMigration();
+});
+/** The longest error text sent to the page. */
+const ERROR_TEXT_LIMIT = 300;
+export async function handleDetectTagMigration() {
+    try {
+        await ensureTursoReady();
+        let untaggedCount = 0;
+        for (const shard of await tursoShardManager.getAllShards("project", "")) {
+            const db = await tursoConnectionManager.getConnection(shard.dbPath);
+            const row = await db.get(`SELECT COUNT(*) as count FROM memories WHERE ${UNTAGGED_NORMAL_PREDICATE}`);
+            untaggedCount += Number(row?.count ?? 0);
+        }
+        return { success: true, data: { needsMigration: untaggedCount > 0, count: untaggedCount } };
+    }
+    catch (error) {
+        return { success: false, error: String(error) };
+    }
+}
+export async function handleGetTagMigrationProgress() {
+    return { success: true, data: migrationProgress };
+}
+/** The error as the page may show it: short, and with the API key removed. */
+function pageErrorText(error, apiKey) {
+    let text = error instanceof Error ? error.message : String(error);
+    if (apiKey)
+        text = text.split(apiKey).join("[redacted]");
+    return text.length > ERROR_TEXT_LIMIT ? `${text.slice(0, ERROR_TEXT_LIMIT)}…` : text;
+}
+/**
+ * Tag the memories that have no tags, a few per request. Only untagged
+ * memories are touched: tagged ones keep their vectors. A memory that fails
+ * is recorded and passed over, so one bad row cannot stall the run. An error
+ * that fails every memory the same way (no credit, a rejected key) ends the
+ * run at once, so a later run starts over with every untagged memory.
+ */
+export function runTagMigrationBatch(config, batchSize = 5) {
+    const run = batchInFlight.then(() => runOneBatch(config, batchSize));
+    batchInFlight = run.catch(() => undefined);
+    return run;
+}
+async function runOneBatch(config, batchSize) {
+    const generation = spaceGeneration;
+    try {
+        await ensureTursoReady();
+        const { AIProviderFactory } = await import("./ai/ai-provider-factory.js");
+        const { buildMemoryProviderConfig } = await import("./ai/provider-config.js");
+        const providerConfig = buildMemoryProviderConfig(config, {
+            maxIterations: 1,
+            iterationTimeout: 30000,
+        });
+        const provider = AIProviderFactory.createProvider(config.memoryProvider, providerConfig);
+        if (migrationProgress.isComplete) {
+            migrationQueue = [];
+            for (const shard of await tursoShardManager.getAllShards("project", "")) {
+                const db = await tursoConnectionManager.getConnection(shard.dbPath);
+                const rows = await db.all(`SELECT id FROM memories WHERE ${UNTAGGED_NORMAL_PREDICATE} ORDER BY id`);
+                for (const row of rows)
+                    migrationQueue.push({ id: String(row.id), dbPath: shard.dbPath });
+            }
+            migrationProgress = {
+                ...idleMigration(),
+                total: migrationQueue.length,
+                totalBatches: Math.ceil(migrationQueue.length / batchSize),
+                isComplete: migrationQueue.length === 0,
+            };
+        }
+        const batch = migrationQueue.slice(migrationProgress.processed, migrationProgress.processed + batchSize);
+        let stopped = false;
+        for (const item of batch) {
+            if (generation !== spaceGeneration) {
+                return { success: false, error: "The memory space changed during tagging" };
+            }
+            try {
+                const db = await tursoConnectionManager.getConnection(item.dbPath);
+                const m = await db.get("SELECT * FROM memories WHERE id = ?", [item.id]);
+                // Tagged or deleted since the run started: nothing to do.
+                if (!m || (m.tags && String(m.tags).trim()))
+                    continue;
+                const prompt = `Generate 2-4 short technical tags for this memory content:\n\n${m.content}\n\nReturn ONLY a comma-separated list of tags.`;
+                const result = await provider.executeToolCall("You are a technical tagger.", prompt, {
+                    type: "function",
+                    function: {
+                        name: "save_tags",
+                        description: "Save generated tags",
+                        parameters: {
+                            type: "object",
+                            properties: { tags: { type: "array", items: { type: "string" } } },
+                            required: ["tags"],
+                        },
+                    },
+                }, `migration_${m.id}`);
+                const tags = Array.isArray(result.data?.tags)
+                    ? result.data.tags.map((t) => String(t).trim().toLowerCase()).filter(Boolean)
+                    : [];
+                if (!result.success || tags.length === 0) {
+                    throw new Error(result.error ?? "The model returned no tags");
+                }
+                const vector = await embeddingService.embedWithTimeout(m.content, { task: "document" });
+                const tagsVector = await embeddingService.embedWithTimeout(formatTagsForEmbedding(tags), {
+                    task: "document",
+                });
+                // One statement, so a memory never ends up tagged with stale vectors.
+                await tursoVectorSearch.updateVector(db, m.id, vector, tagsVector, tags.join(","));
+                migrationProgress.tagged++;
+            }
+            catch (e) {
+                const errorMsg = pageErrorText(e, config.memoryApiKey);
+                const kind = providerErrorKind(errorMsg);
+                log("Migration error for memory", { id: item.id, error: errorMsg, kind }, "error");
+                if (kind === "other") {
+                    migrationProgress.errors.push(errorMsg);
+                    migrationProgress.errorKind ??= kind;
+                }
+                else {
+                    // This error ends the run, so it is the one the page reports.
+                    migrationProgress.errors.unshift(errorMsg);
+                    migrationProgress.errorKind = kind;
+                    stopped = true;
+                }
+            }
+            finally {
+                migrationProgress.processed++;
+            }
+            if (stopped)
+                break;
+        }
+        migrationProgress.currentBatch++;
+        const hasMore = !stopped && migrationProgress.processed < migrationProgress.total;
+        if (!hasMore)
+            migrationProgress.isComplete = true;
+        const { processed, total, tagged, errors, errorKind } = migrationProgress;
+        return {
+            success: true,
+            data: {
+                processed,
+                total,
+                hasMore,
+                tagged,
+                failed: errors.length,
+                ...(errors.length > 0 ? { errorKind, error: errors[0] } : {}),
+            },
+        };
+    }
+    catch (error) {
+        return { success: false, error: String(error) };
+    }
+}

package/dist/services/web-route-modules.js

@@ -2,6 +2,7 @@ import { routeChat } from "./chat/chat-routes.js";
 import { linkedSettingsFrom } from "./linked-search.js";
 import { routeMemorisations } from "./memorisation-routes.js";
 import { routeMemoryHosts } from "./memory-host-routes.js";
+import { routeOpenRouter } from "./openrouter-routes.js";
 import { routeProfileCleanup } from "./profile-cleanup-routes.js";
 import { routeSpaceTransfers } from "./space-transfer-routes.js";
 import { routeSpaces } from "./space-routes.js";
@@ -21,6 +22,9 @@ export async function routeModules(path, method, url, req, ctx) {
     const hosts = await routeMemoryHosts(path, method, url, readBody, config);
     if (hosts !== undefined)
         return hosts;
+    const openRouter = await routeOpenRouter(path, method, url, readBody, ctx);
+    if (openRouter !== undefined)
+        return openRouter;
     if (path === "/api/skills" || path.startsWith("/api/skills/")) {
         const { routeSkills } = await import("./skill-routes.js");
         return routeSkills(path, method, url, readBody, ctx);