@simbimbo/memory-ocmemog 0.1.20 → 0.1.21

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+## 0.1.21 — 2026-03-30
+
+OpenClaw memory-runtime compatibility release.
+
+### Highlights
+- fixed `memory-ocmemog` so it registers the primary OpenClaw memory runtime instead of exposing only tool surfaces
+- restored compatibility with current OpenClaw host status/runtime expectations, resolving the `Memory ... unavailable` state while keeping the ocmemog sidecar healthy on `127.0.0.1:17891`
+- kept the release intentionally minimal and scoped to the real host/plugin integration fix
+
 ## 0.1.20 — 2026-03-29
 
 Operational-artifact canonicalization, dead-lane retrieval hardening, and rehydratable-memory recall fixes.

package/index.ts

@@ -12,6 +12,41 @@ type PluginConfig = {
   token?: string;
 };
 
+type MemoryManagerStatus = {
+  backend: string;
+  provider: string;
+  model?: string;
+  requestedProvider?: string;
+  files?: number;
+  chunks?: number;
+  dirty?: boolean;
+  workspaceDir?: string;
+  dbPath?: string;
+  vector?: { enabled?: boolean; available?: boolean; error?: string };
+  fts?: { enabled?: boolean; available?: boolean; error?: string };
+  custom?: Record<string, unknown>;
+};
+
+type MemorySearchManager = {
+  search(query: string, opts?: Record<string, unknown>): Promise<unknown>;
+  readFile(params: { relPath?: string; path?: string; from?: number; lines?: number }): Promise<{ text: string; path: string }>;
+  status(): MemoryManagerStatus;
+  sync?(params?: Record<string, unknown>): Promise<void>;
+  probeEmbeddingAvailability?(): Promise<{ ok: boolean; error?: string }>;
+  probeVectorAvailability?(): Promise<boolean>;
+  close?(): Promise<void>;
+};
+
+type MemoryRuntime = {
+  getMemorySearchManager(params: Record<string, unknown>): Promise<{ manager: MemorySearchManager | null; error?: string }>;
+  resolveMemoryBackendConfig(params: Record<string, unknown>): Record<string, unknown>;
+  closeAllMemorySearchManagers(): Promise<void>;
+};
+
+type OpenClawPluginApiCompat = OpenClawPluginApi & {
+  registerMemoryRuntime?: (runtime: MemoryRuntime) => void;
+};
+
 const DURABLE_OUTBOX_ENABLED = !["0", "false", "no"].includes(
   String(process.env.OCMEMOG_DURABLE_OUTBOX ?? "true").trim().toLowerCase(),
 );
@@ -56,6 +91,16 @@ type RecentResponse = {
   error?: string;
 };
 
+type SidecarHealthResponse = {
+  ok?: boolean;
+  version?: string;
+  service?: string;
+  vector_provider?: string;
+  vector_available?: boolean;
+  database_path?: string;
+  [key: string]: unknown;
+};
+
 type ConversationHydrateResponse = {
   ok: boolean;
   recent_turns?: Array<Record<string, unknown>>;
@@ -719,6 +764,122 @@ function registerAutomaticContinuityHooks(api: OpenClawPluginApi, config: Plugin
   });
 }
 
+async function getSidecarHealth(config: PluginConfig): Promise<SidecarHealthResponse> {
+  return await getJson<SidecarHealthResponse>(config, "/healthz");
+}
+
+function normalizeReadPath(params: { relPath?: string; path?: string }): string {
+  const value = String(params.relPath ?? params.path ?? "").trim();
+  return value;
+}
+
+function createOcmemogSearchManager(api: OpenClawPluginApi, config: PluginConfig): MemorySearchManager {
+  let closed = false;
+
+  return {
+    async search(query: string, opts?: Record<string, unknown>): Promise<unknown> {
+      if (closed) throw new Error("memory manager closed");
+      const payload = await postJson<SearchResponse>(config, "/memory/search", {
+        query,
+        limit: opts?.limit,
+        categories: opts?.categories,
+        metadata_filters: opts?.metadataFilters,
+        lane: opts?.lane,
+      });
+      return payload;
+    },
+    async readFile(params: { relPath?: string; path?: string; from?: number; lines?: number }): Promise<{ text: string; path: string }> {
+      if (closed) throw new Error("memory manager closed");
+      const relPath = normalizeReadPath(params);
+      if (!relPath) throw new Error("path required");
+      if (!relPath.endsWith('.md')) throw new Error('path required');
+      const absPath = path.resolve(api.workspaceDir ?? process.cwd(), relPath);
+      let text = "";
+      try {
+        text = await fs.readFile(absPath, "utf8");
+      } catch (error) {
+        const code = (error as NodeJS.ErrnoException)?.code;
+        if (code === "ENOENT") return { text: "", path: relPath };
+        throw error;
+      }
+      if (params.from !== undefined || params.lines !== undefined) {
+        const lines = text.split("\n");
+        const start = Math.max(1, Number(params.from ?? 1));
+        const count = Math.max(1, Number(params.lines ?? lines.length));
+        text = lines.slice(start - 1, start - 1 + count).join("\n");
+      }
+      return { text, path: relPath };
+    },
+    status(): MemoryManagerStatus {
+      return {
+        backend: "ocmemog",
+        provider: "ocmemog",
+        model: "ocmemog",
+        requestedProvider: "ocmemog",
+        dirty: false,
+        workspaceDir: api.workspaceDir,
+        vector: {
+          enabled: true,
+          available: true,
+        },
+        fts: {
+          enabled: true,
+          available: true,
+        },
+        custom: {
+          endpoint: config.endpoint,
+          runtime: "ocmemog-sidecar-adapter",
+          sidecar: "ocmemog",
+        },
+      };
+    },
+    async probeEmbeddingAvailability(): Promise<{ ok: boolean; error?: string }> {
+      try {
+        const health = await getSidecarHealth(config);
+        return { ok: Boolean(health.ok ?? true) };
+      } catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+      }
+    },
+    async probeVectorAvailability(): Promise<boolean> {
+      try {
+        const health = await getSidecarHealth(config);
+        return Boolean(health.vector_available ?? true);
+      } catch {
+        return false;
+      }
+    },
+    async close(): Promise<void> {
+      closed = true;
+    },
+  };
+}
+
+function createOcmemogMemoryRuntime(api: OpenClawPluginApi, config: PluginConfig): MemoryRuntime {
+  let manager: MemorySearchManager | null = null;
+  return {
+    async getMemorySearchManager(_params: Record<string, unknown>): Promise<{ manager: MemorySearchManager | null; error?: string }> {
+      try {
+        manager ??= createOcmemogSearchManager(api, config);
+        return { manager };
+      } catch (error) {
+        return { manager: null, error: error instanceof Error ? error.message : String(error) };
+      }
+    },
+    resolveMemoryBackendConfig(_params: Record<string, unknown>): Record<string, unknown> {
+      return {
+        backend: "ocmemog",
+        endpoint: config.endpoint,
+        timeoutMs: config.timeoutMs,
+      };
+    },
+    async closeAllMemorySearchManagers(): Promise<void> {
+      await manager?.close?.();
+      manager = null;
+    },
+  };
+}
+
 const ocmemogPlugin = {
   id: "memory-ocmemog",
   name: "Memory (OCMemog)",
@@ -726,6 +887,14 @@ const ocmemogPlugin = {
   kind: "memory",
   register(api: OpenClawPluginApi) {
     const config = readConfig(api.pluginConfig);
+    const apiCompat = api as OpenClawPluginApiCompat;
+
+    if (typeof apiCompat.registerMemoryRuntime === "function") {
+      apiCompat.registerMemoryRuntime(createOcmemogMemoryRuntime(api, config));
+      api.logger.info(`ocmemog registered primary memory runtime via sidecar adapter (${config.endpoint})`);
+    } else {
+      api.logger.info("ocmemog host API does not expose registerMemoryRuntime; continuing in legacy tool-only compatibility mode");
+    }
 
     registerAutomaticContinuityHooks(api, config);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simbimbo/memory-ocmemog",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "description": "Advanced OpenClaw memory plugin with durable recall, transcript-backed continuity, and sidecar APIs",
   "license": "MIT",
   "repository": {