@t0ken.ai/memoryx-openclaw-plugin 1.0.1 → 1.0.3

package/README.md

@@ -0,0 +1,36 @@
+# MemoryX OpenClaw Plugin
+
+Real-time memory capture and recall plugin for OpenClaw.
+
+## Features
+
+- **Conversation Buffer**: Automatically buffers conversations with token counting
+- **Auto Registration**: Agents auto-register with machine fingerprint
+- **Memory Recall**: Semantic search for relevant memories
+- **Configurable API**: Custom API base URL support
+
+## Installation
+
+```bash
+npm install @t0ken.ai/memoryx-openclaw-plugin
+```
+
+## Configuration
+
+```json
+{
+  "apiBaseUrl": "https://t0ken.ai/api"
+}
+```
+
+## Usage
+
+The plugin automatically:
+1. Captures user and assistant messages
+2. Buffers conversations until threshold (2 rounds)
+3. Flushes to MemoryX API for memory extraction
+4. Recalls relevant memories before agent starts
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -1,14 +1,102 @@
 /**
- * MemoryX Real-time Plugin for OpenClaw
+ * MemoryX Realtime Plugin for OpenClaw - Phase 1
  *
  * Features:
- * 1. Real-time message capture to MemoryX
- * 2. Auto-recall memories before agent starts
- * 3. Compatible with memoryx-realtime-plugin (avoids duplication)
+ * - ConversationBuffer with token counting
+ * - Batch upload to /conversations/flush
+ * - Auto-register and quota handling
+ * - Sensitive data filtered on server
+ * - Configurable API base URL
+ * - Precise token counting with tiktoken
+ *
+ * Model Downloads (CDN):
+ * - INT8 Model (122MB, recommended): https://static.t0ken.ai/models/model_int8.onnx
+ * - FP32 Model (489MB): https://static.t0ken.ai/models/model.onnx
  */
+interface PluginConfig {
+    apiBaseUrl?: string;
+}
+interface Message {
+    role: string;
+    content: string;
+    tokens: number;
+    timestamp: number;
+}
+interface RecallResult {
+    memories: Array<{
+        id: string;
+        content: string;
+        category: string;
+        score: number;
+    }>;
+    isLimited: boolean;
+    remainingQuota: number;
+    upgradeHint?: string;
+}
+declare class ConversationBuffer {
+    private messages;
+    private tokenCount;
+    private roundCount;
+    private lastRole;
+    private conversationId;
+    private startedAt;
+    private lastActivityAt;
+    private encoder;
+    private readonly ROUND_THRESHOLD;
+    private readonly TIMEOUT_MS;
+    private readonly MAX_TOKENS_PER_MESSAGE;
+    constructor();
+    private generateId;
+    private countTokens;
+    addMessage(role: string, content: string): boolean;
+    shouldFlush(): boolean;
+    flush(): {
+        conversation_id: string;
+        messages: Message[];
+        total_tokens: number;
+    };
+    forceFlush(): {
+        conversation_id: string;
+        messages: Message[];
+        total_tokens: number;
+    } | null;
+    getStatus(): {
+        messageCount: number;
+        tokenCount: number;
+        conversationId: string;
+    };
+}
+declare class MemoryXPlugin {
+    private config;
+    private buffer;
+    private flushTimer;
+    private readonly FLUSH_CHECK_INTERVAL;
+    private pluginConfig;
+    constructor(pluginConfig?: PluginConfig);
+    private get apiBase();
+    private init;
+    private loadConfig;
+    private saveConfig;
+    private autoRegister;
+    private getMachineFingerprint;
+    private startFlushTimer;
+    private flushConversation;
+    onMessage(role: string, content: string): Promise<boolean>;
+    recall(query: string, limit?: number): Promise<RecallResult>;
+    endConversation(): Promise<void>;
+    getStatus(): {
+        initialized: boolean;
+        hasApiKey: boolean;
+        bufferStatus: {
+            messageCount: number;
+            tokenCount: number;
+        };
+    };
+}
 export declare function onMessage(message: string, context: Record<string, any>): Promise<{
     context: Record<string, any>;
 }>;
 export declare function onResponse(response: string, context: Record<string, any>): string;
-export declare function register(api: any): void;
+export declare function register(api: any, pluginConfig?: PluginConfig): void;
+export { MemoryXPlugin, ConversationBuffer };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA6GH,wBAAsB,SAAS,CAC7B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC3B,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,CAAC,CAmB3C;AAED,wBAAgB,UAAU,CACxB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC3B,MAAM,CAER;AAGD,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,QA0ChC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAWH,UAAU,YAAY;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAUD,UAAU,OAAO;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,UAAU,YAAY;IAClB,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,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,cAAM,kBAAkB;IACpB,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAc;IAC9B,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,cAAc,CAAsB;IAC5C,OAAO,CAAC,OAAO,CAAW;IAE1B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAK;IACrC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkB;IAC7C,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAQ;;IAO/C,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,WAAW;IAInB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO;IA6BlD,WAAW,IAAI,OAAO;IAiBtB,KAAK,IAAI;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,EAAE,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE;IAkB/E,UAAU,IAAI;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,EAAE,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAO3F,SAAS,IAAI;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAE;CAOpF;AAED,cAAM,aAAa;IACf,OAAO,CAAC,MAAM,CAMZ;IAEF,OAAO,CAAC,MAAM,CAAgD;IAC9D,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAS;IAC9C,OAAO,CAAC,YAAY,CAA6B;gBAErC,YAAY,CAAC,EAAE,YAAY;IAQvC,OAAO,KAAK,OAAO,GAElB;YAEa,IAAI;YAWJ,UAAU;IAgBxB,OAAO,CAAC,UAAU;YAQJ,YAAY;YAgCZ,qBAAqB;IAkBnC,OAAO,CAAC,eAAe;YAQT,iBAAiB;IAqClB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAyB1D,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,GAAE,MAAU,GAAG,OAAO,CAAC,YAAY,CAAC;IAoD/D,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtC,SAAS,IAAI;QAChB,WAAW,EAAE,OAAO,CAAC;QACrB,SAAS,EAAE,OAAO,CAAC;QACnB,YAAY,EAAE;YAAE,YAAY,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAA;SAAE,CAAA;KAC7D;CAOJ;AAID,wBAAsB,SAAS,CAC3B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC7B,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,CAAC,CAK3C;AAED,wBAAgB,UAAU,CACtB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC7B,MAAM,CAER;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,YAAY,CAAC,EAAE,YAAY,GAAG,IAAI,CA4DpE;AAED,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/index.js

@@ -1,164 +1,383 @@
 /**
- * MemoryX Real-time Plugin for OpenClaw
+ * MemoryX Realtime Plugin for OpenClaw - Phase 1
  *
  * Features:
- * 1. Real-time message capture to MemoryX
- * 2. Auto-recall memories before agent starts
- * 3. Compatible with memoryx-realtime-plugin (avoids duplication)
+ * - ConversationBuffer with token counting
+ * - Batch upload to /conversations/flush
+ * - Auto-register and quota handling
+ * - Sensitive data filtered on server
+ * - Configurable API base URL
+ * - Precise token counting with tiktoken
+ *
+ * Model Downloads (CDN):
+ * - INT8 Model (122MB, recommended): https://static.t0ken.ai/models/model_int8.onnx
+ * - FP32 Model (489MB): https://static.t0ken.ai/models/model.onnx
  */
-// MemoryX API configuration
-const MEMORYX_API_BASE = "http://t0ken.ai/api";
-// Check if memoryx-realtime-plugin is installed
-function isPluginInstalled() {
-    try {
-        const { execSync } = require("child_process");
-        const result = execSync("openclaw plugins list", {
-            encoding: "utf8",
-            timeout: 5000,
-        });
-        return (result.includes("memoryx-realtime") && result.includes("loaded"));
-    }
-    catch (e) {
-        return false;
+import { getEncoding } from "js-tiktoken";
+const DEFAULT_API_BASE = "https://t0ken.ai/api";
+class ConversationBuffer {
+    messages = [];
+    tokenCount = 0;
+    roundCount = 0;
+    lastRole = "";
+    conversationId = "";
+    startedAt = Date.now();
+    lastActivityAt = Date.now();
+    encoder;
+    ROUND_THRESHOLD = 2;
+    TIMEOUT_MS = 30 * 60 * 1000;
+    MAX_TOKENS_PER_MESSAGE = 8000;
+    constructor() {
+        this.conversationId = this.generateId();
+        this.encoder = getEncoding("cl100k_base");
     }
-}
-// Store message to MemoryX
-async function storeToMemoryX(content, category = "semantic", metadata = {}) {
-    try {
-        const response = await fetch(`${MEMORYX_API_BASE}/memories`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                content,
-                category,
-                project_id: "default",
-                metadata: {
-                    ...metadata,
-                    source: "openclaw-realtime-plugin",
-                    timestamp: new Date().toISOString(),
-                },
-            }),
-        });
-        return response.ok;
+    generateId() {
+        return `conv_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    countTokens(text) {
+        return this.encoder.encode(text).length;
+    }
+    addMessage(role, content) {
+        if (!content || content.length < 2) {
+            return false;
+        }
+        const tokens = this.countTokens(content);
+        if (tokens > this.MAX_TOKENS_PER_MESSAGE) {
+            return false;
+        }
+        const message = {
+            role,
+            content,
+            tokens,
+            timestamp: Date.now()
+        };
+        this.messages.push(message);
+        this.tokenCount += tokens;
+        this.lastActivityAt = Date.now();
+        if (role === "assistant" && this.lastRole === "user") {
+            this.roundCount++;
+        }
+        this.lastRole = role;
+        return this.roundCount >= this.ROUND_THRESHOLD;
     }
-    catch (error) {
+    shouldFlush() {
+        if (this.messages.length === 0) {
+            return false;
+        }
+        if (this.roundCount >= this.ROUND_THRESHOLD) {
+            return true;
+        }
+        const elapsed = Date.now() - this.lastActivityAt;
+        if (elapsed > this.TIMEOUT_MS) {
+            return true;
+        }
         return false;
     }
-}
-// Search MemoryX
-async function searchMemoryX(query, limit = 3) {
-    try {
-        const response = await fetch(`${MEMORYX_API_BASE}/memories/search`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                query,
-                limit,
-                project_id: "default",
-            }),
-        });
-        if (!response.ok)
-            return [];
-        const data = (await response.json());
-        return data.data || [];
-    }
-    catch (error) {
-        return [];
+    flush() {
+        const data = {
+            conversation_id: this.conversationId,
+            messages: [...this.messages],
+            total_tokens: this.tokenCount
+        };
+        this.messages = [];
+        this.tokenCount = 0;
+        this.roundCount = 0;
+        this.lastRole = "";
+        this.conversationId = this.generateId();
+        this.startedAt = Date.now();
+        this.lastActivityAt = Date.now();
+        return data;
+    }
+    forceFlush() {
+        if (this.messages.length === 0) {
+            return null;
+        }
+        return this.flush();
+    }
+    getStatus() {
+        return {
+            messageCount: this.messages.length,
+            tokenCount: this.tokenCount,
+            conversationId: this.conversationId
+        };
     }
 }
-// Check if content should be captured
-function shouldCapture(text) {
-    if (!text || text.length < 5 || text.length > 500)
-        return false;
-    const skipPatterns = [
-        /^[好的ok谢谢嗯啊哈哈你好hihello拜拜再见]{1,3}$/i,
-        /^[？?！!。,，\s]{1,5}$/,
-    ];
-    for (const pattern of skipPatterns) {
-        if (pattern.test(text.trim()))
+class MemoryXPlugin {
+    config = {
+        apiKey: null,
+        projectId: "default",
+        userId: null,
+        initialized: false,
+        apiBaseUrl: DEFAULT_API_BASE
+    };
+    buffer = new ConversationBuffer();
+    flushTimer = null;
+    FLUSH_CHECK_INTERVAL = 30000;
+    pluginConfig = null;
+    constructor(pluginConfig) {
+        this.pluginConfig = pluginConfig || null;
+        if (pluginConfig?.apiBaseUrl) {
+            this.config.apiBaseUrl = pluginConfig.apiBaseUrl;
+        }
+        this.init();
+    }
+    get apiBase() {
+        return this.config.apiBaseUrl || DEFAULT_API_BASE;
+    }
+    async init() {
+        await this.loadConfig();
+        if (!this.config.apiKey) {
+            await this.autoRegister();
+        }
+        this.startFlushTimer();
+        this.config.initialized = true;
+    }
+    async loadConfig() {
+        try {
+            const stored = localStorage.getItem("memoryx_config");
+            if (stored) {
+                const storedConfig = JSON.parse(stored);
+                this.config = {
+                    ...this.config,
+                    ...storedConfig,
+                    apiBaseUrl: storedConfig.apiBaseUrl || this.config.apiBaseUrl
+                };
+            }
+        }
+        catch (e) {
+            console.warn("[MemoryX] Failed to load config:", e);
+        }
+    }
+    saveConfig() {
+        try {
+            localStorage.setItem("memoryx_config", JSON.stringify(this.config));
+        }
+        catch (e) {
+            console.warn("[MemoryX] Failed to save config:", e);
+        }
+    }
+    async autoRegister() {
+        try {
+            const fingerprint = await this.getMachineFingerprint();
+            const response = await fetch(`${this.apiBase}/agents/auto-register`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    machine_fingerprint: fingerprint,
+                    agent_type: "openclaw",
+                    agent_name: "openclaw-agent",
+                    platform: navigator.platform,
+                    platform_version: navigator.userAgent
+                })
+            });
+            if (!response.ok) {
+                throw new Error(`Auto-register failed: ${response.status}`);
+            }
+            const data = await response.json();
+            this.config.apiKey = data.api_key;
+            this.config.projectId = String(data.project_id);
+            this.config.userId = data.agent_id;
+            this.saveConfig();
+            console.log("[MemoryX] Auto-registered successfully");
+        }
+        catch (e) {
+            console.error("[MemoryX] Auto-register failed:", e);
+        }
+    }
+    async getMachineFingerprint() {
+        const components = [
+            navigator.platform,
+            navigator.language,
+            navigator.hardwareConcurrency || 0,
+            screen.width,
+            screen.height,
+            new Date().getTimezoneOffset()
+        ];
+        const raw = components.join("|");
+        const encoder = new TextEncoder();
+        const data = encoder.encode(raw);
+        const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        return hashArray.slice(0, 32).map(b => b.toString(16).padStart(2, "0")).join("");
+    }
+    startFlushTimer() {
+        this.flushTimer = setInterval(() => {
+            if (this.buffer.shouldFlush()) {
+                this.flushConversation();
+            }
+        }, this.FLUSH_CHECK_INTERVAL);
+    }
+    async flushConversation() {
+        if (!this.config.apiKey) {
+            return;
+        }
+        const data = this.buffer.forceFlush();
+        if (!data || data.messages.length === 0) {
+            return;
+        }
+        try {
+            const response = await fetch(`${this.apiBase}/v1/conversations/flush`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "X-API-Key": this.config.apiKey
+                },
+                body: JSON.stringify(data)
+            });
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                if (response.status === 402) {
+                    console.warn("[MemoryX] Quota exceeded:", errorData.detail);
+                }
+                else {
+                    console.error("[MemoryX] Flush failed:", errorData);
+                }
+            }
+            else {
+                const result = await response.json();
+                console.log(`[MemoryX] Flushed ${data.messages.length} messages, extracted ${result.extracted_count} memories`);
+            }
+        }
+        catch (e) {
+            console.error("[MemoryX] Flush error:", e);
+        }
+    }
+    async onMessage(role, content) {
+        if (!content || content.length < 2) {
             return false;
+        }
+        const skipPatterns = [
+            /^[好的ok谢谢嗯啊哈哈你好hihello拜拜再见]{1,5}$/i,
+            /^[？?！!。,，\s]{1,10}$/
+        ];
+        for (const pattern of skipPatterns) {
+            if (pattern.test(content.trim())) {
+                return false;
+            }
+        }
+        const shouldFlush = this.buffer.addMessage(role, content);
+        if (shouldFlush) {
+            await this.flushConversation();
+        }
+        return true;
+    }
+    async recall(query, limit = 5) {
+        if (!this.config.apiKey || !query || query.length < 2) {
+            return { memories: [], isLimited: false, remainingQuota: 0 };
+        }
+        try {
+            const response = await fetch(`${this.apiBase}/v1/memories/search`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "X-API-Key": this.config.apiKey
+                },
+                body: JSON.stringify({
+                    query,
+                    project_id: this.config.projectId,
+                    limit
+                })
+            });
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                if (response.status === 402 || response.status === 429) {
+                    return {
+                        memories: [],
+                        isLimited: true,
+                        remainingQuota: 0,
+                        upgradeHint: errorData.detail || "云端查询配额已用尽，请升级到付费版"
+                    };
+                }
+                throw new Error(`Search failed: ${response.status}`);
+            }
+            const data = await response.json();
+            return {
+                memories: (data.data || []).map((m) => ({
+                    id: m.id,
+                    content: m.content,
+                    category: m.category || "other",
+                    score: m.score || 0.5
+                })),
+                isLimited: false,
+                remainingQuota: data.remaining_quota ?? -1
+            };
+        }
+        catch (e) {
+            console.error("[MemoryX] Recall failed:", e);
+            return { memories: [], isLimited: false, remainingQuota: 0 };
+        }
+    }
+    async endConversation() {
+        await this.flushConversation();
+        console.log("[MemoryX] Conversation ended, buffer flushed");
+    }
+    getStatus() {
+        return {
+            initialized: this.config.initialized,
+            hasApiKey: !!this.config.apiKey,
+            bufferStatus: this.buffer.getStatus()
+        };
     }
-    const triggers = [
-        /记住|记一下|别忘了|save|remember/i,
-        /我喜欢|我讨厌|我习惯|我偏好|prefer|like|hate/i,
-        /我是|我在|我来自|i am|i work/i,
-        /纠正|更正|应该是|correct|actually/i,
-        /计划|打算|目标|plan|goal|will/i,
-    ];
-    return triggers.some((pattern) => pattern.test(text));
-}
-// Detect category
-function detectCategory(text) {
-    const lower = text.toLowerCase();
-    if (/prefer|like|hate|习惯|偏好|喜欢|讨厌/.test(lower))
-        return "preference";
-    if (/correct|纠正|更正/.test(lower))
-        return "correction";
-    if (/plan|goal|计划|打算/.test(lower))
-        return "plan";
-    return "semantic";
 }
-// OpenClaw Hook handlers
+let plugin;
 export async function onMessage(message, context) {
-    // Skip if memoryx-realtime-plugin is installed (avoid duplication)
-    if (isPluginInstalled()) {
-        return { context };
-    }
-    if (!shouldCapture(message)) {
-        return { context };
-    }
-    const category = detectCategory(message);
-    // Async store (non-blocking)
-    storeToMemoryX(message, category, {
-        from: context?.from,
-        channel: context?.channelId,
-    }).catch(() => { });
+    if (message && plugin) {
+        await plugin.onMessage("user", message);
+    }
     return { context };
 }
 export function onResponse(response, context) {
     return response;
 }
-// Lifecycle hooks for OpenClaw Extension
-export function register(api) {
-    api.logger.info("[MemoryX Realtime] Plugin registering...");
-    // 1. Message capture
+export function register(api, pluginConfig) {
+    api.logger.info("[MemoryX] Plugin registering (Phase 1 - Cloud with Buffer)...");
+    if (pluginConfig?.apiBaseUrl) {
+        api.logger.info(`[MemoryX] Using custom API base URL: ${pluginConfig.apiBaseUrl}`);
+    }
+    plugin = new MemoryXPlugin(pluginConfig);
     api.on("message_received", async (event, ctx) => {
-        if (isPluginInstalled())
-            return;
         const { content, from, timestamp } = event;
-        if (!shouldCapture(content))
-            return;
-        const category = detectCategory(content);
-        await storeToMemoryX(content, category, {
-            from,
-            channel: ctx.channelId,
-            timestamp,
-        });
+        if (content && plugin) {
+            await plugin.onMessage("user", content);
+        }
+    });
+    api.on("assistant_response", async (event, ctx) => {
+        const { content } = event;
+        if (content && plugin) {
+            await plugin.onMessage("assistant", content);
+        }
     });
-    // 2. Auto-recall before agent starts
     api.on("before_agent_start", async (event, ctx) => {
         const { prompt } = event;
-        if (!prompt || prompt.length < 5)
+        if (!prompt || prompt.length < 2 || !plugin)
             return;
         try {
-            const results = await searchMemoryX(prompt, 3);
-            if (results.length === 0)
+            const result = await plugin.recall(prompt, 5);
+            if (result.isLimited) {
+                api.logger.warn(`[MemoryX] ${result.upgradeHint}`);
+                return {
+                    prependContext: `[系统提示] ${result.upgradeHint}\n`
+                };
+            }
+            if (result.memories.length === 0)
                 return;
-            const memories = results
-                .map((r) => `- [${r.category}] ${r.content}`)
+            const memories = result.memories
+                .map(m => `- [${m.category}] ${m.content}`)
                 .join("\n");
-            api.logger.info(`[MemoryX] Recalled ${results.length} memories`);
+            api.logger.info(`[MemoryX] Recalled ${result.memories.length} memories from cloud`);
             return {
-                prependContext: `[相关记忆]\n${memories}\n[End of memories]`,
+                prependContext: `[相关记忆]\n${memories}\n[End of memories]\n`
             };
         }
         catch (error) {
             api.logger.warn(`[MemoryX] Recall failed: ${error}`);
         }
     });
-    api.logger.info("[MemoryX Realtime] Plugin registered successfully");
+    api.on("conversation_end", async (event, ctx) => {
+        if (plugin) {
+            await plugin.endConversation();
+        }
+    });
+    api.logger.info("[MemoryX] Plugin registered successfully");
 }
+export { MemoryXPlugin, ConversationBuffer };

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
-  "id": "memoryx-realtime-plugin",
+  "id": "@t0ken.ai/memoryx-openclaw-plugin",
   "name": "MemoryX Real-time Plugin",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "Real-time memory capture and recall for OpenClaw",
   "entry": "./dist/index.js",
   "kind": "memory",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@t0ken.ai/memoryx-openclaw-plugin",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "MemoryX real-time memory capture and recall plugin for OpenClaw",
   "type": "module",
   "main": "dist/index.js",
@@ -14,7 +14,12 @@
     "build": "tsc",
     "prepare": "npm run build"
   },
-  "keywords": ["openclaw", "memoryx", "memory", "plugin"],
+  "keywords": [
+    "openclaw",
+    "memoryx",
+    "memory",
+    "plugin"
+  ],
   "author": "MemoryX Team",
   "license": "MIT",
   "repository": {
@@ -23,10 +28,18 @@
     "directory": "plugins/memoryx-realtime-plugin"
   },
   "openclaw": {
-    "extensions": ["./dist/index.js"]
+    "extensions": [
+      "./dist/index.js"
+    ]
   },
   "devDependencies": {
-    "typescript": "^5.0.0",
-    "@types/node": "^20.0.0"
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@huggingface/transformers": "^3.8.1",
+    "js-tiktoken": "^1.0.21",
+    "onnxruntime-node": "^1.24.1",
+    "onnxruntime-web": "^1.24.1"
   }
-}
+}