@t0ken.ai/memoryx-openclaw-plugin 2.2.59 → 2.2.61

package/dist/tools.js

@@ -0,0 +1,348 @@
+export function registerTools(api, plugin) {
+    api.registerTool({
+        name: "memoryx_recall",
+        label: "MemoryX Recall",
+        description: "Search long-term memories. Direct results = vector DB; related = graph DB (entities: file, command, search, decision, error). Use before answering about preferences/history. Time: use absolute dates in time_filter (YYYY-MM-DD). For graph-focused search (memories related to an entity), pass entity_name. Returned id is used for memoryx_forget.",
+        parameters: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Search intent (keywords or natural language)" },
+                limit: { type: "number", description: "Max results (default: 5)" },
+                time_filter: { type: "object", description: "Optional. start/end in YYYY-MM-DD or YYYY-MM-DD HH:mm:ss (absolute dates only)" },
+                categories: { type: "array", items: { type: "string" }, description: "Optional. Filter by category (semantic/episodic/procedural/emotional/reflective)" },
+                tags: { type: "array", items: { type: "string" }, description: "Optional. Filter by tags" },
+                entity_name: { type: "string", description: "Optional. Expand graph from this entity (e.g. file path, command name); same convention as server extraction" },
+            },
+            required: ["query"],
+        },
+        async execute(_toolCallId, params) {
+            const { query, limit = 5, time_filter, categories, tags, entity_name } = params;
+            if (!plugin) {
+                return { content: [{ type: "text", text: "MemoryX plugin not initialized." }], details: { error: "not_initialized" } };
+            }
+            try {
+                const result = await plugin.recall(query, limit, { time_filter, categories, tags, entity_name });
+                if (result.isLimited) {
+                    return {
+                        content: [{ type: "text", text: result.upgradeHint || "Quota exceeded" }],
+                        details: { error: "quota_exceeded", hint: result.upgradeHint },
+                    };
+                }
+                if (result.memories.length === 0 && result.relatedMemories.length === 0) {
+                    return { content: [{ type: "text", text: "No relevant memories found." }], details: { count: 0 } };
+                }
+                const lines = [];
+                const total = result.memories.length + result.relatedMemories.length;
+                if (result.memories.length > 0) {
+                    lines.push(`Found ${result.memories.length} direct memories:`);
+                    result.memories.forEach((m, i) => lines.push(`${i + 1}. [${m.category}] ${m.content} (${Math.round(m.score * 100)}%)`));
+                }
+                if (result.relatedMemories.length > 0) {
+                    if (lines.length > 0)
+                        lines.push("");
+                    lines.push(`Found ${result.relatedMemories.length} related memories:`);
+                    result.relatedMemories.forEach((m, i) => lines.push(`${i + 1}. [${m.category}] ${m.content}`));
+                }
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                    details: {
+                        count: total,
+                        direct_count: result.memories.length,
+                        related_count: result.relatedMemories.length,
+                        remaining_quota: result.remainingQuota,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `Memory search failed: ${error.message}` }],
+                    details: { error: error.message },
+                };
+            }
+        },
+    }, { name: "memoryx_recall" });
+    api.registerTool({
+        name: "memoryx_graph_search",
+        label: "MemoryX Graph Search",
+        description: "Search memories by graph entity (file path, command, search query, decision, error). Use when user asks 'what did we do with X', 'memories about file Y', or 'recall related to command Z'. Same entity types as server: file, command, search_query, decision, error. Returns direct + related memories. Time_filter uses absolute dates (YYYY-MM-DD).",
+        parameters: {
+            type: "object",
+            properties: {
+                entity_name: { type: "string", description: "Entity to expand (e.g. file path, command, search term, decision summary)" },
+                query: { type: "string", description: "Optional. Extra keywords; if empty, entity_name is used as query" },
+                limit: { type: "number", description: "Max results (default: 5)" },
+                time_filter: { type: "object", description: "Optional. start/end YYYY-MM-DD" },
+            },
+            required: ["entity_name"],
+        },
+        async execute(_toolCallId, params) {
+            const { entity_name, query, limit = 5, time_filter } = params;
+            if (!plugin) {
+                return { content: [{ type: "text", text: "MemoryX plugin not initialized." }], details: { error: "not_initialized" } };
+            }
+            if (!entity_name || String(entity_name).trim().length === 0) {
+                return {
+                    content: [{ type: "text", text: "entity_name is required for graph search." }],
+                    details: { error: "missing_entity_name" },
+                };
+            }
+            try {
+                const searchQuery = (query && String(query).trim()) ? String(query).trim() : String(entity_name).trim();
+                const result = await plugin.recall(searchQuery, limit, { time_filter, entity_name: String(entity_name).trim() });
+                if (result.isLimited) {
+                    return {
+                        content: [{ type: "text", text: result.upgradeHint || "Quota exceeded" }],
+                        details: { error: "quota_exceeded", hint: result.upgradeHint },
+                    };
+                }
+                if (result.memories.length === 0 && result.relatedMemories.length === 0) {
+                    return {
+                        content: [{ type: "text", text: `No memories found for entity "${entity_name}".` }],
+                        details: { count: 0, entity_name },
+                    };
+                }
+                const lines = [];
+                if (result.memories.length > 0) {
+                    lines.push(`Direct (${result.memories.length}):`);
+                    result.memories.forEach((m, i) => lines.push(`${i + 1}. [${m.category}] ${m.content} (${Math.round(m.score * 100)}%)`));
+                }
+                if (result.relatedMemories.length > 0) {
+                    if (lines.length > 0)
+                        lines.push("");
+                    lines.push(`Related by graph (${result.relatedMemories.length}):`);
+                    result.relatedMemories.forEach((m, i) => lines.push(`${i + 1}. [${m.category}] ${m.content}`));
+                }
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                    details: {
+                        count: result.memories.length + result.relatedMemories.length,
+                        direct_count: result.memories.length,
+                        related_count: result.relatedMemories.length,
+                        entity_name: String(entity_name).trim(),
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `Graph search failed: ${error.message}` }],
+                    details: { error: error.message },
+                };
+            }
+        },
+    }, { name: "memoryx_graph_search" });
+    api.registerTool({
+        name: "memoryx_forget",
+        label: "MemoryX Forget",
+        description: "Delete a memory. memory_id MUST be the id returned by memoryx_recall or memoryx_list—do not use any other value.",
+        parameters: {
+            type: "object",
+            properties: { memory_id: { type: "string", description: "Id from memoryx_recall or memoryx_list result (required)" } },
+            required: ["memory_id"],
+        },
+        async execute(_toolCallId, params) {
+            const { memory_id } = params;
+            if (!plugin) {
+                return { content: [{ type: "text", text: "MemoryX plugin not initialized." }], details: { error: "not_initialized" } };
+            }
+            try {
+                const success = await plugin.forget(memory_id);
+                if (success) {
+                    return { content: [{ type: "text", text: `Memory ${memory_id} has been forgotten.` }], details: { action: "deleted", id: memory_id } };
+                }
+                return {
+                    content: [{ type: "text", text: `Memory ${memory_id} not found or could not be deleted.` }],
+                    details: { action: "failed", id: memory_id },
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `Failed to forget memory: ${error.message}` }],
+                    details: { error: error.message },
+                };
+            }
+        },
+    }, { name: "memoryx_forget" });
+    api.registerTool({
+        name: "memoryx_store",
+        label: "MemoryX Store",
+        description: "Save one atomic fact to long-term memory. RULES YOU MUST FOLLOW: (1) ONE fact per call—do not merge multiple facts. (2) DATES: Use ONLY absolute dates (YYYY-MM-DD or ISO 8601). NEVER use 'yesterday', 'last week', 'recently', or any relative time. (3) CONTEXT COMPLETION (mandatory): If content has 'it'/'this'/'that'/'the project'—MUST rewrite with explicit referents so the fact is self-contained. Example: 'it broke' → '[Device] MacBook Pro 2023 screen damaged'. Content that is not self-contained will be stored incorrectly. (4) metadata.category MUST be one of: semantic | episodic | procedural | emotional | reflective. (5) Call when: user says 'remember this', design/code decisions, task completion, or end-of-session summary (≤100 words).",
+        parameters: {
+            type: "object",
+            properties: {
+                content: {
+                    type: "string",
+                    description: "REQUIRED. One atomic fact, self-contained. MUST use absolute dates (YYYY-MM-DD). MUST resolve any 'it'/'this'/'that' to explicit nouns. Session summary: max 100 words.",
+                },
+                metadata: {
+                    type: "object",
+                    description: "category (required): semantic|episodic|procedural|emotional|reflective. tags (optional): string array.",
+                },
+            },
+            required: ["content"],
+        },
+        async execute(_toolCallId, params) {
+            const { content, metadata } = params;
+            if (!plugin) {
+                return { content: [{ type: "text", text: "MemoryX plugin not initialized." }], details: { error: "not_initialized" } };
+            }
+            if (!content || content.trim().length < 5) {
+                return {
+                    content: [{ type: "text", text: "Content too short. Please provide more meaningful information to remember." }],
+                    details: { error: "content_too_short" },
+                };
+            }
+            try {
+                const result = await plugin.store(content.trim(), metadata);
+                if (result.success) {
+                    return {
+                        content: [{ type: "text", text: `Stored: "${content.slice(0, 100)}${content.length > 100 ? "..." : ""}"` }],
+                        details: { action: "stored", task_id: result.task_id },
+                    };
+                }
+                return {
+                    content: [{ type: "text", text: "Failed to store memory. Please try again." }],
+                    details: { error: "store_failed" },
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `Failed to store memory: ${error.message}` }],
+                    details: { error: error.message },
+                };
+            }
+        },
+    }, { name: "memoryx_store" });
+    api.registerTool({
+        name: "memoryx_list",
+        label: "MemoryX List",
+        description: "List recent memories by creation time (newest first). No search—time-ordered only. To delete one, use memoryx_recall to get id then memoryx_forget. Returned id = memory_id for forget.",
+        parameters: {
+            type: "object",
+            properties: {
+                limit: { type: "number", description: "Max items (default: 10)" },
+                offset: { type: "number", description: "Pagination offset (default: 0)" },
+                time_filter: { type: "object", description: "Optional. start/end YYYY-MM-DD HH:mm:ss" },
+                categories: { type: "array", items: { type: "string" }, description: "Optional. Filter by category" },
+                tags: { type: "array", items: { type: "string" }, description: "Optional. Filter by tags" },
+            },
+        },
+        async execute(_toolCallId, params) {
+            const { limit = 10, offset = 0, time_filter, categories, tags } = params;
+            if (!plugin) {
+                return { content: [{ type: "text", text: "MemoryX plugin not initialized." }], details: { error: "not_initialized" } };
+            }
+            try {
+                const memories = await plugin.list(limit, offset, { time_filter, categories, tags });
+                if (memories.length === 0) {
+                    return { content: [{ type: "text", text: "No memories stored yet." }], details: { count: 0 } };
+                }
+                const lines = [`Here are the ${memories.length} most recent memories:`];
+                memories.forEach((m, i) => lines.push(`${i + 1}. [${m.category || "general"}] ${m.content || m.memory}`));
+                return { content: [{ type: "text", text: lines.join("\n") }], details: { count: memories.length } };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `Failed to list memories: ${error.message}` }],
+                    details: { error: error.message },
+                };
+            }
+        },
+    }, { name: "memoryx_list" });
+    api.registerTool({
+        name: "memoryx_account_info",
+        label: "MemoryX Account Info",
+        description: "Get MemoryX account information including API Key, Project ID, User ID, and API Base URL. Use when user asks about their MemoryX account, API key, project settings, or account status. Returns all stored account configuration from local database.",
+        parameters: { type: "object", properties: {} },
+        async execute(_toolCallId, params) {
+            if (!plugin) {
+                return { content: [{ type: "text", text: "MemoryX plugin not initialized." }], details: { error: "not_initialized" } };
+            }
+            try {
+                const accountInfo = await plugin.getAccountInfo();
+                if (!accountInfo) {
+                    return {
+                        content: [{ type: "text", text: "No account information found. The plugin may not be registered yet." }],
+                        details: { error: "no_account" },
+                    };
+                }
+                const lines = [
+                    "📊 MemoryX account info:",
+                    `API Key: ${accountInfo.apiKey || "not set"}`,
+                    `Agent ID: ${accountInfo.agentId || "not set"}`,
+                    `Agent Type: ${accountInfo.agentType || "not set"}`,
+                    `Status: ${accountInfo.initialized ? "✅ initialized" : "❌ not initialized"}`,
+                ];
+                if (accountInfo.quota) {
+                    const quota = accountInfo.quota;
+                    if (quota.search_count !== undefined) {
+                        const limit = quota.search_limit || "unlimited";
+                        lines.push(`Search count: ${quota.search_count}/${limit}`);
+                    }
+                }
+                if (accountInfo.apiKey) {
+                    lines.push("");
+                    lines.push("💡 Open Portal to manage your memories:");
+                    lines.push(`   https://t0ken.ai/portal?api_key=${accountInfo.apiKey}`);
+                }
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                    details: { apiKey: accountInfo.apiKey, agentId: accountInfo.agentId, agentType: accountInfo.agentType, quota: accountInfo.quota },
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `Failed to get account info: ${error.message}` }],
+                    details: { error: error.message },
+                };
+            }
+        },
+    }, { name: "memoryx_account_info" });
+    api.registerTool({
+        name: "memoryx_queue_status",
+        label: "MemoryX Queue Status",
+        description: "Get Celery queue status: current backlog count and estimated wait time. Use when diagnosing memory processing delay or when the user asks why memories are not processed yet, memory processing status, or queue status.",
+        parameters: { type: "object", properties: {} },
+        async execute(_toolCallId, params) {
+            if (!plugin) {
+                return { content: [{ type: "text", text: "MemoryX plugin not initialized." }], details: { error: "not_initialized" } };
+            }
+            try {
+                const result = await plugin.getQueueStatus();
+                if (!result.success) {
+                    return {
+                        content: [{ type: "text", text: `Failed to get queue status: ${result.error || "unknown error"}` }],
+                        details: { error: result.error },
+                    };
+                }
+                const data = result.data;
+                const statusEmoji = { normal: "✅", backlogged: "⚠️", severely_backlogged: "🔴" };
+                const emoji = statusEmoji[String(data.status)] ?? "❓";
+                const lines = [
+                    `${emoji} MemoryX queue status:`,
+                    `Queue name: ${data.queue_name}`,
+                    `Tier: ${data.tier}`,
+                    `Backlog: ${data.queue_length} tasks`,
+                    `Free queue: ${data.memory_free_queue}`,
+                    `Pro queue: ${data.memory_pro_queue}`,
+                    `Estimated wait: ${data.estimated_wait_time}`,
+                    `Status: ${data.message}`,
+                ];
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                    details: {
+                        queue_name: data.queue_name,
+                        queue_length: data.queue_length,
+                        status: data.status,
+                        estimated_wait_time: data.estimated_wait_time,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `Failed to get queue status: ${error.message}` }],
+                    details: { error: error.message },
+                };
+            }
+        },
+    }, { name: "memoryx_queue_status" });
+}

package/dist/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared types for the MemoryX OpenClaw plugin.
+ */
+export interface PluginConfig {
+    apiBaseUrl?: string;
+    /** Enable debug mode: intercept all requests and log to plugin.log */
+    debugProvider?: boolean;
+}
+export interface RecallResult {
+    memories: Array<{
+        id: string;
+        content: string;
+        category: string;
+        score: number;
+    }>;
+    relatedMemories: Array<{
+        id: string;
+        content: string;
+        category: string;
+        score: number;
+    }>;
+    isLimited: boolean;
+    remainingQuota: number;
+    upgradeHint?: string;
+}
+export interface ProviderCredentials {
+    baseUrl: string;
+    apiKey: string;
+    models?: Array<{
+        id: string;
+        name?: string;
+    }>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,YAAY;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,YAAY;IACzB,QAAQ,EAAE,KAAK,CAAC;QACZ,EAAE,EAAE,MAAM,CAAC;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;IACH,eAAe,EAAE,KAAK,CAAC;QACnB,EAAE,EAAE,MAAM,CAAC;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;IACH,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,mBAAmB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACjD"}

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Shared types for the MemoryX OpenClaw plugin.
+ */
+export {};

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "memoryx-openclaw-plugin",
   "name": "MemoryX Real-time Plugin",
-  "version": "2.2.59",
+  "version": "2.2.60",
   "description": "Real-time memory capture and recall for OpenClaw",
   "kind": "memory",
   "main": "./dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@t0ken.ai/memoryx-openclaw-plugin",
-  "version": "2.2.59",
+  "version": "2.2.61",
   "description": "MemoryX real-time memory capture and recall plugin for OpenClaw (powered by @t0ken.ai/memoryx-sdk)",
   "type": "module",
   "author": "MemoryX Team",
@@ -13,7 +13,9 @@
   ],
   "scripts": {
     "prebuild": "node scripts/update-version.cjs",
-    "build": "tsc"
+    "build": "tsc",
+    "test:recall": "node scripts/test-recall-capture.mjs",
+    "reset-proxy-usage": "node scripts/reset-memoryx-proxy-usage.mjs"
   },
   "keywords": [
     "openclaw",
@@ -36,6 +38,6 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "@t0ken.ai/memoryx-sdk": "^1.5.1"
+    "@t0ken.ai/memoryx-sdk": "^1.5.3"
   }
 }