@kalera/munin-openclaw 1.0.0 → 1.1.0

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> @kalera/munin-openclaw@1.0.0 build /home/runner/work/munin-for-agents/munin-for-agents/adapters/openclaw
+> @kalera/munin-openclaw@1.1.0 build /home/runner/work/munin-for-agents/munin-for-agents/adapters/openclaw
 > tsc -p tsconfig.json
 

package/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: "@kalera/munin-openclaw"
-description: "Munin - The $1.6/mo Persistent Memory for OpenClaw. Stop your agent from having Alzheimer's."
+description: "Munin - The Free (or $1.6/mo) Persistent Memory for OpenClaw. Stop your agent from having Alzheimer's."
 version: "1.0.0"
 metadata:
   clawdbot:
     type: "plugin"
     permissions:
-      env: ["MUNIN_BASE_URL", "MUNIN_PROJECT", "MUNIN_API_KEY"]
+      env: ["MUNIN_BASE_URL", "MUNIN_API_KEY"]
 ---
 
 # 🐦 Munin: Reliable Memory for Your OpenClaw Agent
@@ -15,15 +15,15 @@ Your agent forgets everything the moment you close the tab. You've seen the "pro
 
 We think that's insane. 
 
-**Munin (ContextKeep)** is the pragmatic alternative. It’s the "Reliable Friend" that sits on your agent’s shoulder and whispers: *"Hey, remember when pa Kal said he preferred Python over Node last week?"*
+**Munin** is the pragmatic alternative. It’s the "Reliable Friend" that sits on your agent’s shoulder and whispers: *"Hey, remember when pa Kal said he preferred Python over Node last week?"*
 
 ### 💰 Why Munin? (The "No-Brainer" Math)
 
 | Feature | Mem0 / Zep | **Munin** |
 | :--- | :--- | :--- |
-| **Monthly Cost** | $19.00 - $249.00 | **$1.60** |
+| **Monthly Cost** | $19.00 - $249.00 | **Free** (or $1.60 Pro) |
 | **MCP Support** | Mixed | **Native / First-class** |
-| **Self-Hostable** | OSS (Complex) | **Yes (Simple)** |
+| **Zero-Knowledge E2EE** | Optional / Complex | **Built-in (Client-side)** |
 | **Bullshit Factor** | High (Enterprise-synergy) | **Zero (Developer-first)** |
 
 **That’s a 10x - 150x price gap.** We aren't building "Enterprise Synergy Platforms". We're building a notebook for your AI.
@@ -33,14 +33,14 @@ We think that's insane.
 ## 🔒 Security & Privacy
 
 **Trust Statement:**
-Data stays where you tell it to stay. If you self-host, it never leaves your server. If you use our cloud, it's encrypted and isolated by project.
+Data stays where you tell it to stay. All data is encrypted locally (if E2EE is enabled) and isolated by your Context Core. We are completely blind to your plaintext.
 
 **External Endpoints:**
 Data is sent ONLY to your `MUNIN_BASE_URL`. We don't phone home. We don't sell your "memories" to train models.
 
-## 💎 Quantum E2EE (Elite Tier)
+## 💎 E2EE with GraphRAG (Elite Tier)
 
-If your Munin project has **Quantum E2EE** enabled, standard E2EE rules apply PLUS:
+If your Munin project has **E2EE with GraphRAG** enabled, standard E2EE rules apply PLUS:
 - You **MUST** generate a vector embedding of the plaintext content locally before encrypting.
 - You **MUST** include the embedding array in the `store` payload: `{ "content": "encrypted...", "embedding": [0.1, -0.02, ...], "encryptionMeta": {...} }`.
 - Munin will use this vector for zero-knowledge semantic search. It will reject the request if the embedding is missing.
@@ -49,13 +49,14 @@ If your Munin project has **Quantum E2EE** enabled, standard E2EE rules apply PL
 
 ## 🚀 Setup (Fast & Honest)
 
-1. **Get your Munin instance:** Self-host it or grab a cloud key at [munin.kalera.app](https://munin.kalera.app).
+1. **Get your Munin key:** Grab a **free** cloud key at [munin.kalera.dev](https://munin.kalera.dev).
 2. **Configure OpenClaw:** Add these to your `.env` or agent config:
    - `MUNIN_BASE_URL`: Where your Munin lives (e.g., `https://munin.kalera.dev`).
-   - `MUNIN_PROJECT`: Your project name (e.g., `research-agent`).
    - `MUNIN_API_KEY`: Your key to the kingdom.
 
+*(Note: Provide your agent with the `Context Core ID` in its system prompt so it knows which project to use when making tool calls).*
+
 3. **Profit:** Your agent now has long-term memory. No more repeating yourself.
 
 ---
-*Built with ❤️ by Kalera for the OpenClaw Ecosystem.*
+*Built with ❤️ by Kalera for the OpenClaw Ecosystem.*

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export declare function createOpenClawMuninAdapter(config: {
-    baseUrl: string;
-    apiKey?: string;
-    timeoutMs?: number;
-}): {
-    execute: (projectId: string, action: string, payload: Record<string, unknown>) => Promise<import("@kalera/munin-sdk").MuninResponse<unknown>>;
-    capabilities: () => Promise<import("@kalera/munin-sdk").MuninCapabilities>;
-};
+declare const _default: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: import("openclaw/plugin-sdk").OpenClawPluginConfigSchema;
+    register: NonNullable<import("openclaw/plugin-sdk/plugin-runtime").OpenClawPluginDefinition["register"]>;
+} & Pick<import("openclaw/plugin-sdk/plugin-runtime").OpenClawPluginDefinition, "kind">;
+export default _default;

package/dist/index.js

@@ -1,8 +1,101 @@
+import { definePluginEntry } from "openclaw/plugin-sdk/core";
 import { MuninClient } from "@kalera/munin-sdk";
-export function createOpenClawMuninAdapter(config) {
-    const client = new MuninClient(config);
-    return {
-        execute: (projectId, action, payload) => client.invoke(projectId, action, payload, { ensureCapability: true }),
-        capabilities: () => client.capabilities(),
-    };
-}
+import { Type } from "@sinclair/typebox";
+import { z } from "zod";
+export default definePluginEntry({
+    id: "munin-memory",
+    name: "Munin ContextKeep",
+    description: "Persistent memory tools for OpenClaw agents.",
+    kind: "memory",
+    configSchema: z.object({
+        baseUrl: z
+            .string()
+            .default("https://munin.kalera.dev")
+            .describe("The base URL for your Munin ContextKeep server."),
+        apiKey: z.string().describe("Your API key for Munin."),
+    }),
+    register(api) {
+        const baseUrl = api.pluginConfig?.baseUrl ||
+            process.env.MUNIN_BASE_URL ||
+            "https://munin.kalera.dev";
+        const apiKey = api.pluginConfig?.apiKey || process.env.MUNIN_API_KEY;
+        if (!apiKey) {
+            api.logger.warn("Munin API key is missing. ContextKeep tools will not be registered.");
+            return;
+        }
+        const client = new MuninClient({ baseUrl, apiKey });
+        api.registerTool({
+            name: "munin_store_memory",
+            label: "Store Munin Memory",
+            description: "Store a new memory or update an existing one in ContextKeep.",
+            parameters: Type.Object({
+                projectId: Type.String({
+                    description: "The Context Core ID for isolation.",
+                }),
+                key: Type.String({ description: "Unique identifier for the memory." }),
+                content: Type.String({ description: "The content of the memory." }),
+                tags: Type.Optional(Type.String({ description: "Comma-separated list of tags." })),
+                title: Type.Optional(Type.String({ description: "Human-readable title." })),
+            }),
+            async execute(_toolCallId, params) {
+                const { projectId, ...payload } = params;
+                const res = await client.invoke(projectId, "store", payload);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(res.data, null, 2),
+                        },
+                    ],
+                    details: res.data,
+                };
+            },
+        });
+        api.registerTool({
+            name: "munin_retrieve_memory",
+            label: "Retrieve Munin Memory",
+            description: "Retrieve a memory by its key from ContextKeep.",
+            parameters: Type.Object({
+                projectId: Type.String({ description: "The Context Core ID." }),
+                key: Type.String({
+                    description: "The unique identifier of the memory.",
+                }),
+            }),
+            async execute(_toolCallId, params) {
+                const { projectId, key } = params;
+                const res = await client.invoke(projectId, "retrieve", { key });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(res.data, null, 2),
+                        },
+                    ],
+                    details: res.data,
+                };
+            },
+        });
+        api.registerTool({
+            name: "munin_search_memories",
+            label: "Search Munin Memories",
+            description: "Search for memories by key, title, or content in ContextKeep.",
+            parameters: Type.Object({
+                projectId: Type.String({ description: "The Context Core ID." }),
+                query: Type.String({ description: "The search term." }),
+            }),
+            async execute(_toolCallId, params) {
+                const { projectId, query } = params;
+                const res = await client.invoke(projectId, "search", { query });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(res.data, null, 2),
+                        },
+                    ],
+                    details: res.data,
+                };
+            },
+        });
+    },
+});

package/openclaw.plugin.json

@@ -0,0 +1,23 @@
+{
+  "id": "munin-memory",
+  "name": "Munin ContextKeep",
+  "description": "Persistent memory and Context Core for OpenClaw agents.",
+  "kind": "memory",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "baseUrl": {
+        "type": "string",
+        "default": "https://munin.kalera.dev",
+        "description": "The base URL for your Munin ContextKeep server."
+      },
+      "apiKey": {
+        "type": "string",
+        "description": "Your API key for Munin."
+      }
+    },
+    "required": ["apiKey"]
+  },
+  "skills": ["."]
+}

package/package.json

@@ -1,27 +1,27 @@
 {
   "name": "@kalera/munin-openclaw",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "type": "module",
   "openclaw": {
     "extensions": [
-      "./dist/cli.js"
+      "./dist/index.js"
     ],
     "requires": {
       "env": [
         "MUNIN_BASE_URL",
-        "MUNIN_PROJECT"
+        "MUNIN_API_KEY"
       ]
     }
   },
-  "bin": {
-    "munin-openclaw": "dist/cli.js"
-  },
   "dependencies": {
-    "@kalera/munin-runtime": "1.0.0",
-    "@kalera/munin-sdk": "1.0.0"
+    "@kalera/munin-sdk": "1.0.0",
+    "@kalera/munin-runtime": "1.0.0"
   },
   "devDependencies": {
-    "typescript": "^5.9.2"
+    "@sinclair/typebox": "^0.34.49",
+    "openclaw": "^2026.3.28",
+    "typescript": "^5.9.2",
+    "zod": "^4.3.6"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",

package/src/index.ts

@@ -1,16 +1,115 @@
+import { definePluginEntry } from "openclaw/plugin-sdk/core";
 import { MuninClient } from "@kalera/munin-sdk";
+import { Type } from "@sinclair/typebox";
+import { z } from "zod";
 
-export function createOpenClawMuninAdapter(config: {
-  baseUrl: string;
-  apiKey?: string;
-  
-  timeoutMs?: number;
-}) {
-  const client = new MuninClient(config);
+export default definePluginEntry({
+  id: "munin-memory",
+  name: "Munin ContextKeep",
+  description: "Persistent memory tools for OpenClaw agents.",
+  kind: "memory",
+  configSchema: z.object({
+    baseUrl: z
+      .string()
+      .default("https://munin.kalera.dev")
+      .describe("The base URL for your Munin ContextKeep server."),
+    apiKey: z.string().describe("Your API key for Munin."),
+  }) as any,
+  register(api) {
+    const baseUrl =
+      (api.pluginConfig?.baseUrl as string) ||
+      process.env.MUNIN_BASE_URL ||
+      "https://munin.kalera.dev";
+    const apiKey =
+      (api.pluginConfig?.apiKey as string) || process.env.MUNIN_API_KEY;
 
-  return {
-    execute: (projectId: string, action: string, payload: Record<string, unknown>) =>
-      client.invoke(projectId, action as any, payload, { ensureCapability: true }),
-    capabilities: () => client.capabilities(),
-  };
-}
+    if (!apiKey) {
+      api.logger.warn(
+        "Munin API key is missing. ContextKeep tools will not be registered.",
+      );
+      return;
+    }
+
+    const client = new MuninClient({ baseUrl, apiKey });
+
+    api.registerTool({
+      name: "munin_store_memory",
+      label: "Store Munin Memory",
+      description: "Store a new memory or update an existing one in ContextKeep.",
+      parameters: Type.Object({
+        projectId: Type.String({
+          description: "The Context Core ID for isolation.",
+        }),
+        key: Type.String({ description: "Unique identifier for the memory." }),
+        content: Type.String({ description: "The content of the memory." }),
+        tags: Type.Optional(
+          Type.String({ description: "Comma-separated list of tags." }),
+        ),
+        title: Type.Optional(
+          Type.String({ description: "Human-readable title." }),
+        ),
+      }),
+      async execute(_toolCallId: string, params: any) {
+        const { projectId, ...payload } = params;
+        const res = await client.invoke(projectId, "store", payload);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(res.data, null, 2),
+            },
+          ],
+          details: res.data,
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "munin_retrieve_memory",
+      label: "Retrieve Munin Memory",
+      description: "Retrieve a memory by its key from ContextKeep.",
+      parameters: Type.Object({
+        projectId: Type.String({ description: "The Context Core ID." }),
+        key: Type.String({
+          description: "The unique identifier of the memory.",
+        }),
+      }),
+      async execute(_toolCallId: string, params: any) {
+        const { projectId, key } = params;
+        const res = await client.invoke(projectId, "retrieve", { key });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(res.data, null, 2),
+            },
+          ],
+          details: res.data,
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "munin_search_memories",
+      label: "Search Munin Memories",
+      description: "Search for memories by key, title, or content in ContextKeep.",
+      parameters: Type.Object({
+        projectId: Type.String({ description: "The Context Core ID." }),
+        query: Type.String({ description: "The search term." }),
+      }),
+      async execute(_toolCallId: string, params: any) {
+        const { projectId, query } = params;
+        const res = await client.invoke(projectId, "search", { query });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(res.data, null, 2),
+            },
+          ],
+          details: res.data,
+        };
+      },
+    });
+  },
+});

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -1,34 +0,0 @@
-import { executeWithRetry, loadCliEnv, parseCliArgs, safeError, startMcpServer, } from "@kalera/munin-runtime";
-import { createOpenClawMuninAdapter } from "./index.js";
-async function main() {
-    try {
-        const args = process.argv.slice(2);
-        // If no arguments, or 'mcp' is passed, start as MCP server
-        if (args.length === 0 || args[0] === 'mcp') {
-            await startMcpServer();
-            return;
-        }
-        const { action, payload } = parseCliArgs(args, "Usage: munin-openclaw <action> [payload-json] OR munin-openclaw mcp");
-        const env = loadCliEnv();
-        const adapter = createOpenClawMuninAdapter({
-            baseUrl: env.baseUrl,
-            apiKey: env.apiKey,
-            timeoutMs: env.timeoutMs,
-        });
-        const result = await executeWithRetry(async () => {
-            if (action === "capabilities") {
-                return { ok: true, data: await adapter.capabilities() };
-            }
-            const { projectId, ...p } = payload;
-            if (!projectId)
-                throw new Error("projectId required in payload");
-            return adapter.execute(projectId, action, p);
-        }, env.retries, env.backoffMs);
-        console.log(JSON.stringify(result, null, 2));
-    }
-    catch (error) {
-        console.error(JSON.stringify({ ok: false, error: safeError(error) }));
-        process.exitCode = 1;
-    }
-}
-void main();

package/src/cli.ts

@@ -1,47 +0,0 @@
-import {
-  executeWithRetry,
-  loadCliEnv,
-  parseCliArgs,
-  safeError,
-  startMcpServer,
-} from "@kalera/munin-runtime";
-import { createOpenClawMuninAdapter } from "./index.js";
-
-async function main() {
-  try {
-    const args = process.argv.slice(2);
-    
-    // If no arguments, or 'mcp' is passed, start as MCP server
-    if (args.length === 0 || args[0] === 'mcp') {
-      await startMcpServer();
-      return;
-    }
-
-    const { action, payload } = parseCliArgs(
-      args,
-      "Usage: munin-openclaw <action> [payload-json] OR munin-openclaw mcp",
-    );
-    const env = loadCliEnv();
-
-    const adapter = createOpenClawMuninAdapter({
-      baseUrl: env.baseUrl,
-      apiKey: env.apiKey,
-      
-      timeoutMs: env.timeoutMs,
-    });
-
-    const result = await executeWithRetry(async () => {
-      if (action === "capabilities") {
-        return { ok: true, data: await adapter.capabilities() };
-      }
-      const { projectId, ...p } = payload; if (!projectId) throw new Error("projectId required in payload"); return adapter.execute(projectId as string, action, p);
-    }, env.retries, env.backoffMs);
-
-    console.log(JSON.stringify(result, null, 2));
-  } catch (error) {
-    console.error(JSON.stringify({ ok: false, error: safeError(error) }));
-    process.exitCode = 1;
-  }
-}
-
-void main();