om-memory-system 3.0.0 → 3.1.0-next.4

package/dist/services/ai/live-model-choice.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Which model live capture and profile learning call, the same rule on both
+ * hosts. Pure functions of the config: callers pass CONFIG, so this module
+ * has no dependency on config loading.
+ */
+export interface AutoCaptureProviderRuntimeConfig {
+    opencodeProvider?: string;
+    opencodeModel?: string;
+    memoryProvider?: string;
+    memoryModel?: string;
+    memoryApiUrl?: string;
+    memoryApiKey?: string;
+}
+/**
+ * Where live capture and profile learning send model calls, the same on both hosts:
+ * - `opencode`: the configured host model (`opencodeModel`/`piModel`; "inherit" = session model)
+ * - `manual`: no host model, so the external API (`memoryModel`/`memoryApiUrl`/`memoryApiKey`)
+ * - `session`: neither is set, so the session's own model through the host's sign-in
+ */
+export type AutoCaptureProviderStatus = {
+    ready: true;
+    mode: "opencode" | "manual" | "session";
+    issues: [];
+} | {
+    ready: false;
+    issues: string[];
+};
+export declare function getAutoCaptureProviderStatus(config: AutoCaptureProviderRuntimeConfig): AutoCaptureProviderStatus;
+/** OpenCode host model for live calls, or null when the external API should be used. */
+export declare function resolveOpencodeHostModel(config: AutoCaptureProviderRuntimeConfig): {
+    providerID: string;
+    modelID: string;
+} | null;
+export type PiLiveModelChoice = {
+    kind: "pi";
+    provider: string;
+    model: string;
+} | {
+    kind: "session";
+} | {
+    kind: "manual";
+} | {
+    kind: "unready";
+    issues: string[];
+};
+/** Pi's live model, by the same rule as OpenCode's (`piProvider`/`piModel` in place of `opencode*`). */
+export declare function resolvePiLiveModel(config: AutoCaptureProviderRuntimeConfig & {
+    piProvider?: string;
+    piModel?: string;
+}): PiLiveModelChoice;
+/** True when the external API is fully configured and can serve as a fallback. */
+export declare function isExternalModelReady(config: AutoCaptureProviderRuntimeConfig): boolean;

package/dist/services/ai/live-model-choice.js

@@ -0,0 +1,83 @@
+import { isPlaceholderApiKey } from "./api-key-placeholder.js";
+function hasValue(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+/** External-API readiness alone; any memory* value set counts as intent to use it. */
+function getManualProviderStatus(config) {
+    const hasMemoryModel = hasValue(config.memoryModel);
+    const hasMemoryApiUrl = hasValue(config.memoryApiUrl);
+    const hasMemoryApiKey = hasValue(config.memoryApiKey);
+    const hasPlaceholderMemoryApiKey = isPlaceholderApiKey(config.memoryApiKey);
+    const attempted = hasMemoryModel || hasMemoryApiUrl || hasMemoryApiKey;
+    const issues = [];
+    // The orcarouter provider presets its endpoint and default model, so only
+    // an API key is required for the manual fallback path.
+    if (config.memoryProvider === "orcarouter") {
+        if (!hasMemoryApiKey)
+            issues.push("memoryApiKey is not configured");
+        if (hasPlaceholderMemoryApiKey)
+            issues.push("memoryApiKey contains a placeholder value");
+        return { attempted, ready: hasMemoryApiKey && !hasPlaceholderMemoryApiKey, issues };
+    }
+    if (!hasMemoryModel)
+        issues.push("memoryModel is not configured");
+    if (!hasMemoryApiUrl)
+        issues.push("memoryApiUrl is not configured");
+    if (!hasMemoryApiKey)
+        issues.push("memoryApiKey is not configured");
+    if (hasPlaceholderMemoryApiKey)
+        issues.push("memoryApiKey contains a placeholder value");
+    return {
+        attempted,
+        ready: hasMemoryModel && hasMemoryApiUrl && hasMemoryApiKey && !hasPlaceholderMemoryApiKey,
+        issues,
+    };
+}
+export function getAutoCaptureProviderStatus(config) {
+    const hasOpencodeProvider = hasValue(config.opencodeProvider);
+    const hasOpencodeModel = hasValue(config.opencodeModel);
+    if (hasOpencodeProvider && hasOpencodeModel) {
+        return { ready: true, mode: "opencode", issues: [] };
+    }
+    const manual = getManualProviderStatus(config);
+    if (manual.ready)
+        return { ready: true, mode: "manual", issues: [] };
+    // Nothing configured at all: follow the session's model, as Pi always has.
+    if (!manual.attempted)
+        return { ready: true, mode: "session", issues: [] };
+    // A half-configured external API is a mistake worth reporting, not a silent switch.
+    const issues = [];
+    if (!hasOpencodeProvider)
+        issues.push("opencodeProvider is not configured");
+    if (!hasOpencodeModel)
+        issues.push("opencodeModel is not configured");
+    return { ready: false, issues: [...issues, ...manual.issues] };
+}
+/** OpenCode host model for live calls, or null when the external API should be used. */
+export function resolveOpencodeHostModel(config) {
+    const status = getAutoCaptureProviderStatus(config);
+    if (!status.ready || status.mode === "manual")
+        return null;
+    if (status.mode === "opencode") {
+        return { providerID: config.opencodeProvider.trim(), modelID: config.opencodeModel.trim() };
+    }
+    return { providerID: config.opencodeProvider?.trim() ?? "", modelID: "inherit" };
+}
+/** Pi's live model, by the same rule as OpenCode's (`piProvider`/`piModel` in place of `opencode*`). */
+export function resolvePiLiveModel(config) {
+    if (hasValue(config.piProvider) && hasValue(config.piModel)) {
+        return config.piModel.trim() === "inherit"
+            ? { kind: "session" }
+            : { kind: "pi", provider: config.piProvider.trim(), model: config.piModel.trim() };
+    }
+    const manual = getManualProviderStatus(config);
+    if (manual.ready)
+        return { kind: "manual" };
+    if (!manual.attempted)
+        return { kind: "session" };
+    return { kind: "unready", issues: manual.issues };
+}
+/** True when the external API is fully configured and can serve as a fallback. */
+export function isExternalModelReady(config) {
+    return getManualProviderStatus(config).ready;
+}

package/dist/services/ai/profile-llm-client.js

@@ -1,18 +1,20 @@
 import { CONFIG } from "../../config.js";
+import { resolveOpencodeHostModel } from "./live-model-choice.js";
 import { loadOpencodeProvider } from "./opencode-provider-loader.js";
 let _cachedClient = null;
 let _cachedProvider = null;
 let _cachedModel = null;
 export async function getOpenCodeClient() {
-    const provider = CONFIG.opencodeProvider;
-    const model = CONFIG.opencodeModel;
-    if (!provider || !model) {
-        throw new Error("omms: opencodeProvider and opencodeModel must be configured");
+    const hostModel = resolveOpencodeHostModel(CONFIG);
+    if (!hostModel) {
+        throw new Error("omms: live calls use the external API; no OpenCode model is configured");
     }
+    const { isProviderConnected, getV2Client, resolveOpencodeModelRef } = await loadOpencodeProvider();
+    // "inherit" checks the provider of the model it resolves to.
+    const { providerID: provider, modelID: model } = resolveOpencodeModelRef(hostModel);
     if (_cachedClient && _cachedProvider === provider && _cachedModel === model) {
         return _cachedClient;
     }
-    const { isProviderConnected, getV2Client } = await loadOpencodeProvider();
     if (!isProviderConnected(provider)) {
         throw new Error(`opencode provider '${provider}' is not connected. Check your opencode provider configuration.`);
     }

package/dist/services/user-memory-learning.js

@@ -1,6 +1,7 @@
 import { getTags } from "./tags.js";
 import { log } from "./logger.js";
 import { CONFIG } from "../config.js";
+import { resolveOpencodeHostModel } from "./ai/live-model-choice.js";
 import { userPromptManager } from "./user-prompt/user-prompt-manager.js";
 import { userProfileManager } from "./user-profile/user-profile-manager.js";
 import { sortProfileItems } from "../utils/profile.js";
@@ -491,14 +492,14 @@ async function applyValidations(profileData, llmResult, profileId, prefKeys) {
 async function analyzeUserProfile(context, existingProfile) {
     log("user-profile-learning: analyze called", { hasProfile: !!existingProfile });
     let opencodeProviderError;
-    if (CONFIG.opencodeProvider && CONFIG.opencodeModel) {
+    if (resolveOpencodeHostModel(CONFIG)) {
         log("user-profile-learning: trying opencode provider");
         try {
             const { generateStructuredOutput } = await loadOpencodeProvider();
             const { getOpenCodeClient } = await import("./ai/profile-llm-client.js");
             log("user-profile-learning: opencode provider diag", {
-                provider: CONFIG.opencodeProvider,
-                model: CONFIG.opencodeModel,
+                provider: resolveOpencodeHostModel(CONFIG)?.providerID,
+                model: resolveOpencodeHostModel(CONFIG)?.modelID,
             });
             const v2Client = await getOpenCodeClient();
             const systemPrompt = `You are a user behavior analyst for a coding assistant.
@@ -516,8 +517,8 @@ Use the update_user_profile tool to save the ${existingProfile ? "updated" : "ne
             const result = await Promise.race([
                 generateStructuredOutput({
                     client: v2Client,
-                    providerID: CONFIG.opencodeProvider,
-                    modelID: CONFIG.opencodeModel,
+                    providerID: resolveOpencodeHostModel(CONFIG).providerID,
+                    modelID: resolveOpencodeHostModel(CONFIG).modelID,
                     systemPrompt,
                     userPrompt: context,
                     schema,
@@ -591,7 +592,7 @@ Identify sequences where earlier prompts led to later ones (e.g. "learned X →
 { "paths": [{ "topic": "string", "chain": ["step1", "step2", "step3"], "description": "one sentence summary" }] }
 If no clear chains, return { "paths": [] }.`;
     let result = null;
-    if (CONFIG.opencodeProvider && CONFIG.opencodeModel) {
+    if (resolveOpencodeHostModel(CONFIG)) {
         try {
             const { z } = await import("zod");
             const { generateStructuredOutput } = await loadOpencodeProvider();
@@ -607,8 +608,8 @@ If no clear chains, return { "paths": [] }.`;
                 result = (await Promise.race([
                     generateStructuredOutput({
                         client: v2Client,
-                        providerID: CONFIG.opencodeProvider,
-                        modelID: CONFIG.opencodeModel,
+                        providerID: resolveOpencodeHostModel(CONFIG).providerID,
+                        modelID: resolveOpencodeHostModel(CONFIG).modelID,
                         systemPrompt,
                         userPrompt,
                         schema: z.object({

package/dist/services/user-profile/ai-cleanup.js

@@ -1,4 +1,5 @@
 import { CONFIG } from "../../config.js";
+import { resolveOpencodeHostModel } from "../ai/live-model-choice.js";
 import { log } from "../logger.js";
 import { loadOpencodeProvider } from "../ai/opencode-provider-loader.js";
 import { EXTERNAL_PROFILE_CLEANUP_TIMEOUT_MS, OPENCODE_PROFILE_CLEANUP_TIMEOUT_MS, } from "../request-timeouts.js";
@@ -151,7 +152,7 @@ async function callAICleanup(prompt) {
     // Use opencode internal session when opencodeProvider is configured (same pattern as auto-capture).
     // When the client is available, surface OpenCode errors instead of masking them as
     // "No AI provider configured" via a silent fallback (#177).
-    if (CONFIG.opencodeProvider && CONFIG.opencodeModel) {
+    if (resolveOpencodeHostModel(CONFIG)) {
         const { getV2Client } = await loadOpencodeProvider();
         const v2Client = getV2Client();
         if (v2Client) {
@@ -234,6 +235,11 @@ function raceWithTimeout(promise, ms, message) {
 }
 async function callViaOpencodeWithClient(v2Client, prompt) {
     const t0 = Date.now();
+    const hostModel = resolveOpencodeHostModel(CONFIG) ?? { providerID: "", modelID: "inherit" };
+    // Only "inherit" (or no model configured) needs resolving to the session's recent model.
+    const model = hostModel.modelID === "inherit"
+        ? (await loadOpencodeProvider()).resolveOpencodeModelRef(hostModel)
+        : hostModel;
     const systemPrompt = "You are a user profile cleanup assistant. Merge duplicate entries and return only JSON without markdown wrapping.";
     const created = (await raceWithTimeout(v2Client.session.create({
         title: "omms profile cleanup",
@@ -253,10 +259,7 @@ async function callViaOpencodeWithClient(v2Client, prompt) {
         const TIMEOUT_MS = OPENCODE_PROFILE_CLEANUP_TIMEOUT_MS;
         const promptResult = await raceWithTimeout(v2Client.session.prompt({
             sessionID,
-            model: {
-                providerID: CONFIG.opencodeProvider || "bs-aigw",
-                modelID: CONFIG.opencodeModel || "deepseek-v4-flash",
-            },
+            model,
             system: systemPrompt,
             parts: [{ type: "text", text: prompt }],
             // `noReply` suppresses assistant generation; cleanup needs the JSON reply (#177).

package/dist/services/user-profile/user-profile-manager.js

@@ -2,6 +2,7 @@ import { join } from "node:path";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { tursoConnectionManager } from "../turso/connection-manager.js";
 import { CONFIG } from "../../config.js";
+import { resolveOpencodeHostModel } from "../ai/live-model-choice.js";
 import { safeArray } from "./profile-utils.js";
 import { EmbeddingService } from "../embedding.js";
 import { log } from "../logger.js";
@@ -1178,7 +1179,7 @@ A: "${descA}"
 B: "${descB}"
 
 Answer JSON only: { "duplicate": true|false, "reason": "one sentence explanation" }`;
-        if (CONFIG.opencodeProvider && CONFIG.opencodeModel) {
+        if (resolveOpencodeHostModel(CONFIG)) {
             try {
                 const { z } = await import("zod");
                 const { generateStructuredOutput } = await loadOpencodeProvider();
@@ -1194,8 +1195,8 @@ Answer JSON only: { "duplicate": true|false, "reason": "one sentence explanation
                     const result = await Promise.race([
                         generateStructuredOutput({
                             client: v2Client,
-                            providerID: CONFIG.opencodeProvider,
-                            modelID: CONFIG.opencodeModel,
+                            providerID: resolveOpencodeHostModel(CONFIG).providerID,
+                            modelID: resolveOpencodeHostModel(CONFIG).modelID,
                             systemPrompt: "You are a semantic duplicate detector. Output valid JSON.",
                             userPrompt: prompt,
                             schema: z.object({ duplicate: z.boolean(), reason: z.string() }),
@@ -1365,7 +1366,7 @@ A: "${descA}"
 B: "${descB}"
 
 Answer JSON only: { "conflict": true|false, "reason": "one sentence explanation" }`;
-        if (CONFIG.opencodeProvider && CONFIG.opencodeModel) {
+        if (resolveOpencodeHostModel(CONFIG)) {
             try {
                 const { z } = await import("zod");
                 const { generateStructuredOutput } = await loadOpencodeProvider();
@@ -1381,8 +1382,8 @@ Answer JSON only: { "conflict": true|false, "reason": "one sentence explanation"
                     const result = await Promise.race([
                         generateStructuredOutput({
                             client: v2Client,
-                            providerID: CONFIG.opencodeProvider,
-                            modelID: CONFIG.opencodeModel,
+                            providerID: resolveOpencodeHostModel(CONFIG).providerID,
+                            modelID: resolveOpencodeHostModel(CONFIG).modelID,
                             systemPrompt: "You are a preference contradiction detector. Output valid JSON.",
                             userPrompt: prompt,
                             schema: z.object({ conflict: z.boolean(), reason: z.string() }),
@@ -1481,7 +1482,7 @@ ${evidenceList}
 
 Generate a concise, abstract description of the user's general behavioral tendency.`;
         let newDescription = null;
-        if (CONFIG.opencodeProvider && CONFIG.opencodeModel) {
+        if (resolveOpencodeHostModel(CONFIG)) {
             try {
                 newDescription = await this.callOpencodeProvider(systemPrompt, userPrompt);
             }
@@ -1602,7 +1603,7 @@ Generate a concise, abstract description of the user's general behavioral tenden
         }
         catch (e) {
             log("profile description evolution: native provider not connected", {
-                provider: CONFIG.opencodeProvider,
+                provider: resolveOpencodeHostModel(CONFIG)?.providerID,
                 error: String(e),
             });
             return null;
@@ -1612,8 +1613,8 @@ Generate a concise, abstract description of the user's general behavioral tenden
         const result = await Promise.race([
             generateStructuredOutput({
                 client: v2Client,
-                providerID: CONFIG.opencodeProvider,
-                modelID: CONFIG.opencodeModel,
+                providerID: resolveOpencodeHostModel(CONFIG).providerID,
+                modelID: resolveOpencodeHostModel(CONFIG).modelID,
                 systemPrompt,
                 userPrompt,
                 schema,

package/dist/v2/adapter.js

@@ -1,3 +1,4 @@
+import { OPENCODE_IMPORT_COMMAND, OPENCODE_IMPORT_DESCRIPTION, runOpencodeImportCommand, } from "../adapters/opencode/import-command.js";
 import { log } from "../services/logger.js";
 import { eventBelongsToLocation, legacyToolResult, toLegacyEvent } from "./legacy-client.js";
 const memoryInput = {
@@ -127,6 +128,32 @@ export async function registerV2Adapter(ctx, legacy, memory) {
             async ask() { },
         })),
     }));
+    // Same command as V1 and Pi. V2 runs it natively, so no model turn relays the report.
+    await ctx.command?.transform?.((editor) => editor.add({
+        name: OPENCODE_IMPORT_COMMAND,
+        description: OPENCODE_IMPORT_DESCRIPTION,
+        execute: async (invocation) => {
+            const sessionID = invocation.sessionID;
+            const report = await runOpencodeImportCommand({
+                argsText: invocation.prompt?.text ?? "",
+                directory: ctx.location.directory,
+                sessionModel: async () => {
+                    try {
+                        const session = await ctx.session.get({ sessionID });
+                        const model = session?.model ?? session?.data?.model;
+                        return model?.providerID && model?.id
+                            ? { providerID: String(model.providerID), modelID: String(model.id) }
+                            : null;
+                    }
+                    catch (error) {
+                        log("v2 import: could not read the session model", { error: String(error) });
+                        return null;
+                    }
+                },
+            });
+            await ctx.session.synthetic({ sessionID, text: report, resume: false });
+        },
+    }));
     await ctx.session.hook("prompt", async (event) => {
         const sessionID = event.sessionID;
         const text = event.prompt.text ?? "";

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "om-memory-system",
-  "version": "3.0.0",
+  "version": "3.1.0-next.4",
   "description": "Opinionated modular memory system for coding agents (OpenCode + Pi)",
   "type": "module",
   "main": "dist/plugin.js",
   "types": "dist/plugin.d.ts",
+  "bin": {
+    "om-memory-system": "dist/cli/index.js"
+  },
   "exports": {
     ".": {
       "types": "./dist/plugin.d.ts",
@@ -28,7 +31,7 @@
     }
   },
   "scripts": {
-    "build": "rm -rf dist && bunx tsc && bun run web:build",
+    "build": "rm -rf dist && bunx tsc && chmod +x dist/cli/index.js && bun run web:build",
     "web:dev": "cd web && bun run dev",
     "web:build": "cd web && bun run build",
     "dev": "tsc --watch",