@t0ken.ai/memoryx-openclaw-plugin 1.1.14 → 1.1.16

package/dist/index.d.ts

@@ -23,12 +23,6 @@
 interface PluginConfig {
     apiBaseUrl?: string;
 }
-interface Message {
-    role: string;
-    content: string;
-    tokens: number;
-    timestamp: number;
-}
 interface RecallResult {
     memories: Array<{
         id: string;
@@ -36,44 +30,41 @@ interface RecallResult {
         category: string;
         score: number;
     }>;
+    relatedMemories: Array<{
+        id: string;
+        content: string;
+        category: string;
+        score: number;
+    }>;
     isLimited: boolean;
     remainingQuota: number;
     upgradeHint?: string;
 }
-declare class ConversationBuffer {
-    private messages;
-    private roundCount;
-    private lastRole;
-    private conversationId;
-    private startedAt;
+declare class ConversationManager {
+    private currentConversationId;
+    private conversationCreatedAt;
     private lastActivityAt;
     private readonly ROUND_THRESHOLD;
     private readonly TIMEOUT_MS;
     constructor();
     private generateId;
     getConversationId(): string;
-    addMessage(role: string, content: string): boolean;
-    shouldFlush(): boolean;
-    flush(): {
-        conversation_id: string;
-        messages: Message[];
-    };
-    forceFlush(): {
-        conversation_id: string;
-        messages: Message[];
-    } | null;
-    getStatus(): {
+    addMessage(role: string, content: string): Promise<boolean>;
+    shouldFlush(): Promise<boolean>;
+    startNewConversation(): void;
+    getStatus(): Promise<{
         messageCount: number;
         conversationId: string;
-    };
+        rounds: number;
+    }>;
 }
 declare class MemoryXPlugin {
     private config;
-    private buffer;
+    private conversationManager;
     private flushTimer;
-    private pendingRetryTimer;
+    private sendQueueTimer;
     private readonly FLUSH_CHECK_INTERVAL;
-    private readonly PENDING_RETRY_INTERVAL;
+    private readonly SEND_QUEUE_INTERVAL;
     private readonly MAX_RETRY_COUNT;
     private pluginConfig;
     private initialized;
@@ -85,20 +76,22 @@ declare class MemoryXPlugin {
     private autoRegister;
     private getMachineFingerprint;
     private startFlushTimer;
-    private startPendingRetryTimer;
-    private retryPendingMessages;
-    private flushConversation;
+    private startSendQueueTimer;
+    private processSendQueue;
     onMessage(role: string, content: string): Promise<boolean>;
     recall(query: string, limit?: number): Promise<RecallResult>;
     endConversation(): Promise<void>;
-    getStatus(): {
+    forget(memoryId: string): Promise<boolean>;
+    list(limit?: number): Promise<any[]>;
+    getStatus(): Promise<{
         initialized: boolean;
         hasApiKey: boolean;
-        bufferStatus: {
+        conversationStatus: {
             messageCount: number;
             conversationId: string;
+            rounds: number;
         };
-    };
+    }>;
 }
 declare const _default: {
     id: string;
@@ -108,5 +101,5 @@ declare const _default: {
     register(api: any, pluginConfig?: PluginConfig): void;
 };
 export default _default;
-export { MemoryXPlugin, ConversationBuffer };
+export { MemoryXPlugin, ConversationManager };
 //# 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;;;;;;;;;;;;;;;;;;;;;GAqBG;AAoCH,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;AAyJD,cAAM,kBAAkB;IACpB,OAAO,CAAC,QAAQ,CAAiB;IACjC,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;IAE5C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAK;IACrC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkB;;IAM7C,OAAO,CAAC,UAAU;IAIlB,iBAAiB,IAAI,MAAM;IAI3B,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO;IAuBlD,WAAW,IAAI,OAAO;IAiBtB,KAAK,IAAI;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,EAAE,CAAA;KAAE;IAgBzD,UAAU,IAAI;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,EAAE,CAAA;KAAE,GAAG,IAAI;IAOrE,SAAS,IAAI;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAE;CAMhE;AAED,cAAM,aAAa;IACf,OAAO,CAAC,MAAM,CAMZ;IAEF,OAAO,CAAC,MAAM,CAAgD;IAC9D,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,iBAAiB,CAAa;IACtC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAS;IAC9C,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IAChD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAK;IACrC,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,WAAW,CAAkB;gBAEzB,YAAY,CAAC,EAAE,YAAY;IAQvC,IAAI,IAAI,IAAI;IAkBZ,OAAO,KAAK,OAAO,GAElB;YAEa,UAAU;YAWV,UAAU;YAIV,YAAY;IA+B1B,OAAO,CAAC,qBAAqB;IAa7B,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,sBAAsB;YAMhB,oBAAoB;YAmDpB,iBAAiB;IAsDlB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA6B1D,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,GAAE,MAAU,GAAG,OAAO,CAAC,YAAY,CAAC;IAsD/D,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAMtC,SAAS,IAAI;QAChB,WAAW,EAAE,OAAO,CAAC;QACrB,SAAS,EAAE,OAAO,CAAC;QACnB,YAAY,EAAE;YAAE,YAAY,EAAE,MAAM,CAAC;YAAC,cAAc,EAAE,MAAM,CAAA;SAAE,CAAA;KACjE;CAOJ;;;;;;kBAUiB,GAAG,iBAAiB,YAAY,GAAG,IAAI;;AANzD,wBAmEE;AAEF,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -24,10 +24,26 @@ import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
 import * as crypto from "crypto";
+import { getEncoding } from "js-tiktoken";
 const DEFAULT_API_BASE = "https://t0ken.ai/api";
 const PLUGIN_DIR = path.join(os.homedir(), ".openclaw", "extensions", "memoryx-openclaw-plugin");
 let logStream = null;
 let logStreamReady = false;
+let tokenizer = null;
+function getTokenizer() {
+    if (!tokenizer) {
+        tokenizer = getEncoding("cl100k_base");
+    }
+    return tokenizer;
+}
+function countTokens(text) {
+    try {
+        return getTokenizer().encode(text).length;
+    }
+    catch {
+        return Math.ceil(text.length / 4);
+    }
+}
 function ensureDir() {
     if (!fs.existsSync(PLUGIN_DIR)) {
         fs.mkdirSync(PLUGIN_DIR, { recursive: true });
@@ -50,6 +66,7 @@ function log(message) {
     });
 }
 let dbPromise = null;
+let isSending = false;
 async function getDb() {
     if (dbPromise)
         return dbPromise;
@@ -64,29 +81,18 @@ async function getDb() {
                 value TEXT
             );
             
-            CREATE TABLE IF NOT EXISTS pending_messages (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                conversation_id TEXT NOT NULL,
-                role TEXT NOT NULL,
-                content TEXT NOT NULL,
-                timestamp INTEGER NOT NULL,
-                retry_count INTEGER DEFAULT 0,
-                created_at INTEGER DEFAULT (strftime('%s', 'now'))
-            );
-            
-            CREATE INDEX IF NOT EXISTS idx_pending_conversation ON pending_messages(conversation_id);
-            CREATE INDEX IF NOT EXISTS idx_pending_created ON pending_messages(created_at);
-            
-            CREATE TABLE IF NOT EXISTS temp_messages (
+            CREATE TABLE IF NOT EXISTS send_queue (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
                 conversation_id TEXT NOT NULL,
+                conversation_created_at INTEGER NOT NULL,
                 role TEXT NOT NULL,
                 content TEXT NOT NULL,
                 timestamp INTEGER NOT NULL,
-                created_at INTEGER DEFAULT (strftime('%s', 'now'))
+                retry_count INTEGER DEFAULT 0
             );
             
-            CREATE INDEX IF NOT EXISTS idx_temp_conversation ON temp_messages(conversation_id);
+            CREATE INDEX IF NOT EXISTS idx_send_queue_created ON send_queue(conversation_created_at);
+            CREATE INDEX IF NOT EXISTS idx_send_queue_conversation ON send_queue(conversation_id);
         `);
         return db;
     })();
@@ -115,108 +121,109 @@ class SQLiteStorage {
             log(`Failed to save config: ${e}`);
         }
     }
-    static async addPendingMessage(conversationId, role, content) {
-        const db = await getDb();
-        const result = db.prepare(`
-            INSERT INTO pending_messages (conversation_id, role, content, timestamp)
-            VALUES (?, ?, ?, ?)
-        `).run(conversationId, role, content, Date.now());
-        return result.lastInsertRowid;
-    }
-    static async getPendingMessages(limit = 100) {
+    static async addConversationToQueue(conversationId, conversationCreatedAt, messages) {
         const db = await getDb();
-        return db.prepare(`
-            SELECT * FROM pending_messages 
-            ORDER BY created_at ASC 
-            LIMIT ?
-        `).all(limit);
-    }
-    static async deletePendingMessage(id) {
-        const db = await getDb();
-        db.prepare("DELETE FROM pending_messages WHERE id = ?").run(id);
+        const stmt = db.prepare(`
+            INSERT INTO send_queue (conversation_id, conversation_created_at, role, content, timestamp)
+            VALUES (?, ?, ?, ?, ?)
+        `);
+        for (const msg of messages) {
+            stmt.run(conversationId, conversationCreatedAt, msg.role, msg.content, msg.timestamp);
+        }
     }
-    static async incrementRetryCount(id) {
+    static async getNextConversation() {
         const db = await getDb();
-        db.prepare("UPDATE pending_messages SET retry_count = retry_count + 1 WHERE id = ?").run(id);
+        const row = db.prepare(`
+            SELECT conversation_id, MIN(conversation_created_at) as conversation_created_at
+            FROM send_queue
+            GROUP BY conversation_id
+            ORDER BY MIN(conversation_created_at) ASC
+            LIMIT 1
+        `).get();
+        if (!row)
+            return null;
+        const messages = db.prepare(`
+            SELECT id, conversation_id, conversation_created_at, role, content, timestamp, retry_count
+            FROM send_queue
+            WHERE conversation_id = ?
+            ORDER BY id ASC
+        `).all(row.conversation_id);
+        return {
+            conversationId: row.conversation_id,
+            conversationCreatedAt: row.conversation_created_at,
+            messages
+        };
     }
-    static async clearOldPendingMessages(maxAge = 7 * 24 * 60 * 60) {
+    static async deleteConversation(conversationId) {
         const db = await getDb();
-        const cutoff = Math.floor(Date.now() / 1000) - maxAge;
-        db.prepare("DELETE FROM pending_messages WHERE created_at < ?").run(cutoff);
+        db.prepare("DELETE FROM send_queue WHERE conversation_id = ?").run(conversationId);
     }
-    static async addTempMessage(conversationId, role, content) {
+    static async incrementRetryByConversation(conversationId) {
         const db = await getDb();
-        const result = db.prepare(`
-            INSERT INTO temp_messages (conversation_id, role, content, timestamp)
-            VALUES (?, ?, ?, ?)
-        `).run(conversationId, role, content, Date.now());
-        return result.lastInsertRowid;
+        db.prepare("UPDATE send_queue SET retry_count = retry_count + 1 WHERE conversation_id = ?").run(conversationId);
     }
-    static async getTempMessages(conversationId) {
+    static async getQueueStats(conversationId) {
         const db = await getDb();
         const rows = db.prepare(`
-            SELECT role, content, timestamp FROM temp_messages 
+            SELECT role FROM send_queue 
             WHERE conversation_id = ? 
-            ORDER BY timestamp ASC
+            ORDER BY id ASC
         `).all(conversationId);
-        return rows.map((r) => ({
-            role: r.role,
-            content: r.content,
-            tokens: 0,
-            timestamp: r.timestamp
-        }));
-    }
-    static async clearTempMessages(conversationId) {
-        const db = await getDb();
-        db.prepare("DELETE FROM temp_messages WHERE conversation_id = ?").run(conversationId);
+        let rounds = 0;
+        let lastRole = "";
+        for (const row of rows) {
+            if (row.role === "assistant" && lastRole === "user") {
+                rounds++;
+            }
+            lastRole = row.role;
+        }
+        return { count: rows.length, rounds };
     }
-    static async clearOldTempMessages(maxAge = 24 * 60 * 60) {
+    static async clearOldConversations(maxAge = 7 * 24 * 60 * 60) {
         const db = await getDb();
         const cutoff = Math.floor(Date.now() / 1000) - maxAge;
-        db.prepare("DELETE FROM temp_messages WHERE created_at < ?").run(cutoff);
+        db.prepare("DELETE FROM send_queue WHERE conversation_created_at < ?").run(cutoff);
+    }
+    static async getQueueLength() {
+        const db = await getDb();
+        const row = db.prepare("SELECT COUNT(DISTINCT conversation_id) as count FROM send_queue").get();
+        return row?.count || 0;
     }
 }
-class ConversationBuffer {
-    messages = [];
-    roundCount = 0;
-    lastRole = "";
-    conversationId = "";
-    startedAt = Date.now();
+class ConversationManager {
+    currentConversationId = "";
+    conversationCreatedAt = Math.floor(Date.now() / 1000);
     lastActivityAt = Date.now();
     ROUND_THRESHOLD = 2;
     TIMEOUT_MS = 30 * 60 * 1000;
     constructor() {
-        this.conversationId = this.generateId();
+        this.currentConversationId = this.generateId();
     }
     generateId() {
         return `conv_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
     }
     getConversationId() {
-        return this.conversationId;
+        return this.currentConversationId;
     }
-    addMessage(role, content) {
+    async addMessage(role, content) {
         if (!content || content.length < 2) {
             return false;
         }
-        const message = {
-            role,
-            content,
-            tokens: 0,
-            timestamp: Date.now()
-        };
-        this.messages.push(message);
+        const db = await getDb();
+        db.prepare(`
+            INSERT INTO send_queue (conversation_id, conversation_created_at, role, content, timestamp)
+            VALUES (?, ?, ?, ?, ?)
+        `).run(this.currentConversationId, this.conversationCreatedAt, role, content, Date.now());
         this.lastActivityAt = Date.now();
-        if (role === "assistant" && this.lastRole === "user") {
-            this.roundCount++;
-        }
-        this.lastRole = role;
-        return this.roundCount >= this.ROUND_THRESHOLD;
+        const stats = await SQLiteStorage.getQueueStats(this.currentConversationId);
+        return stats.rounds >= this.ROUND_THRESHOLD;
     }
-    shouldFlush() {
-        if (this.messages.length === 0) {
+    async shouldFlush() {
+        const stats = await SQLiteStorage.getQueueStats(this.currentConversationId);
+        if (stats.count === 0) {
             return false;
         }
-        if (this.roundCount >= this.ROUND_THRESHOLD) {
+        if (stats.rounds >= this.ROUND_THRESHOLD) {
             return true;
         }
         const elapsed = Date.now() - this.lastActivityAt;
@@ -225,29 +232,17 @@ class ConversationBuffer {
         }
         return false;
     }
-    flush() {
-        const data = {
-            conversation_id: this.conversationId,
-            messages: [...this.messages]
-        };
-        this.messages = [];
-        this.roundCount = 0;
-        this.lastRole = "";
-        this.conversationId = this.generateId();
-        this.startedAt = Date.now();
+    startNewConversation() {
+        this.currentConversationId = this.generateId();
+        this.conversationCreatedAt = Math.floor(Date.now() / 1000);
         this.lastActivityAt = Date.now();
-        return data;
-    }
-    forceFlush() {
-        if (this.messages.length === 0) {
-            return null;
-        }
-        return this.flush();
     }
-    getStatus() {
+    async getStatus() {
+        const stats = await SQLiteStorage.getQueueStats(this.currentConversationId);
         return {
-            messageCount: this.messages.length,
-            conversationId: this.conversationId
+            messageCount: stats.count,
+            conversationId: this.currentConversationId,
+            rounds: stats.rounds
         };
     }
 }
@@ -259,11 +254,11 @@ class MemoryXPlugin {
         initialized: false,
         apiBaseUrl: DEFAULT_API_BASE
     };
-    buffer = new ConversationBuffer();
+    conversationManager = new ConversationManager();
     flushTimer = null;
-    pendingRetryTimer = null;
+    sendQueueTimer = null;
     FLUSH_CHECK_INTERVAL = 30000;
-    PENDING_RETRY_INTERVAL = 60000;
+    SEND_QUEUE_INTERVAL = 5000;
     MAX_RETRY_COUNT = 5;
     pluginConfig = null;
     initialized = false;
@@ -282,8 +277,9 @@ class MemoryXPlugin {
         this.loadConfig().then(() => {
             log(`Config loaded, apiKey: ${this.config.apiKey ? 'present' : 'missing'}`);
             this.startFlushTimer();
-            this.startPendingRetryTimer();
-            this.retryPendingMessages();
+            this.startSendQueueTimer();
+            SQLiteStorage.clearOldConversations().catch(() => { });
+            this.processSendQueue();
             if (!this.config.apiKey) {
                 log("Starting auto-register");
                 this.autoRegister().catch(e => log(`Auto-register failed: ${e}`));
@@ -346,116 +342,76 @@ class MemoryXPlugin {
         return crypto.createHash("sha256").update(raw).digest("hex").slice(0, 32);
     }
     startFlushTimer() {
-        this.flushTimer = setInterval(() => {
-            if (this.buffer.shouldFlush()) {
-                this.flushConversation();
+        this.flushTimer = setInterval(async () => {
+            if (await this.conversationManager.shouldFlush()) {
+                this.conversationManager.startNewConversation();
             }
         }, this.FLUSH_CHECK_INTERVAL);
     }
-    startPendingRetryTimer() {
-        this.pendingRetryTimer = setInterval(() => {
-            this.retryPendingMessages();
-        }, this.PENDING_RETRY_INTERVAL);
+    startSendQueueTimer() {
+        this.sendQueueTimer = setInterval(() => {
+            this.processSendQueue();
+        }, this.SEND_QUEUE_INTERVAL);
     }
-    async retryPendingMessages() {
+    async processSendQueue() {
+        if (isSending)
+            return;
         if (!this.config.apiKey)
             return;
+        isSending = true;
         try {
-            const pending = await SQLiteStorage.getPendingMessages(50);
-            if (pending.length === 0)
+            await SQLiteStorage.clearOldConversations();
+            const conversation = await SQLiteStorage.getNextConversation();
+            if (!conversation) {
+                isSending = false;
                 return;
-            log(`Retrying ${pending.length} pending messages`);
-            for (const msg of pending) {
-                if (msg.retry_count >= this.MAX_RETRY_COUNT) {
-                    log(`Deleting message ${msg.id}: max retries exceeded`);
-                    await SQLiteStorage.deletePendingMessage(msg.id);
-                    continue;
-                }
-                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({
-                            conversation_id: msg.conversation_id,
-                            messages: [{
-                                    role: msg.role,
-                                    content: msg.content,
-                                    timestamp: msg.timestamp,
-                                    tokens: 0
-                                }]
-                        })
-                    });
-                    if (response.ok) {
-                        await SQLiteStorage.deletePendingMessage(msg.id);
-                        log(`Sent pending message ${msg.id}`);
-                    }
-                    else {
-                        await SQLiteStorage.incrementRetryCount(msg.id);
-                        log(`Failed to send pending message ${msg.id}: ${response.status}`);
-                    }
-                }
-                catch (e) {
-                    await SQLiteStorage.incrementRetryCount(msg.id);
-                    log(`Error sending pending message ${msg.id}: ${e}`);
-                }
             }
-        }
-        catch (e) {
-            log(`Retry pending messages failed: ${e}`);
-        }
-    }
-    async flushConversation() {
-        if (!this.config.apiKey) {
-            const data = this.buffer.forceFlush();
-            if (data) {
-                for (const msg of data.messages) {
-                    await SQLiteStorage.addPendingMessage(data.conversation_id, msg.role, msg.content);
-                }
-                log(`Cached ${data.messages.length} messages (no API key)`);
+            const { conversationId, messages } = conversation;
+            const maxRetry = Math.max(...messages.map(m => m.retry_count));
+            if (maxRetry >= this.MAX_RETRY_COUNT) {
+                log(`Deleting conversation ${conversationId}: max retries exceeded`);
+                await SQLiteStorage.deleteConversation(conversationId);
+                isSending = false;
+                return;
             }
-            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) {
-                    log(`Quota exceeded: ${errorData.detail}`);
+            log(`Sending conversation ${conversationId} (${messages.length} messages)`);
+            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({
+                        conversation_id: conversationId,
+                        messages: messages.map(m => ({
+                            role: m.role,
+                            content: m.content,
+                            timestamp: m.timestamp,
+                            tokens: countTokens(m.content)
+                        }))
+                    })
+                });
+                if (response.ok) {
+                    await SQLiteStorage.deleteConversation(conversationId);
+                    const result = await response.json();
+                    log(`Sent conversation ${conversationId}, extracted ${result.extracted_count || 0} memories`);
                 }
                 else {
-                    log(`Flush failed: ${JSON.stringify(errorData)}`);
-                }
-                for (const msg of data.messages) {
-                    await SQLiteStorage.addPendingMessage(data.conversation_id, msg.role, msg.content);
+                    await SQLiteStorage.incrementRetryByConversation(conversationId);
+                    const errorData = await response.json().catch(() => ({}));
+                    log(`Failed to send conversation ${conversationId}: ${response.status} ${JSON.stringify(errorData)}`);
                 }
-                log(`Cached ${data.messages.length} messages (API error)`);
             }
-            else {
-                const result = await response.json();
-                log(`Flushed ${data.messages.length} messages, extracted ${result.extracted_count} memories`);
+            catch (e) {
+                await SQLiteStorage.incrementRetryByConversation(conversationId);
+                log(`Error sending conversation ${conversationId}: ${e}`);
             }
         }
         catch (e) {
-            log(`Flush error: ${e}`);
-            for (const msg of data.messages) {
-                await SQLiteStorage.addPendingMessage(data.conversation_id, msg.role, msg.content);
-            }
-            log(`Cached ${data.messages.length} messages (network error)`);
+            log(`Process send queue failed: ${e}`);
         }
+        isSending = false;
     }
     async onMessage(role, content) {
         this.init();
@@ -471,17 +427,16 @@ class MemoryXPlugin {
                 return false;
             }
         }
-        await SQLiteStorage.addTempMessage(this.buffer.getConversationId(), role, content);
-        const shouldFlush = this.buffer.addMessage(role, content);
+        const shouldFlush = await this.conversationManager.addMessage(role, content);
         if (shouldFlush) {
-            await this.flushConversation();
+            this.conversationManager.startNewConversation();
         }
         return true;
     }
     async recall(query, limit = 5) {
         this.init();
         if (!this.config.apiKey || !query || query.length < 2) {
-            return { memories: [], isLimited: false, remainingQuota: 0 };
+            return { memories: [], relatedMemories: [], isLimited: false, remainingQuota: 0 };
         }
         try {
             const response = await fetch(`${this.apiBase}/v1/memories/search`, {
@@ -501,6 +456,7 @@ class MemoryXPlugin {
                 if (response.status === 402 || response.status === 429) {
                     return {
                         memories: [],
+                        relatedMemories: [],
                         isLimited: true,
                         remainingQuota: 0,
                         upgradeHint: errorData.detail || "云端查询配额已用尽，请升级到付费版"
@@ -512,29 +468,95 @@ class MemoryXPlugin {
             return {
                 memories: (data.data || []).map((m) => ({
                     id: m.id,
-                    content: m.content,
+                    content: m.memory || m.content,
                     category: m.category || "other",
                     score: m.score || 0.5
                 })),
+                relatedMemories: (data.related_memories || []).map((m) => ({
+                    id: m.id,
+                    content: m.memory || m.content,
+                    category: m.category || "other",
+                    score: m.score || 0
+                })),
                 isLimited: false,
                 remainingQuota: data.remaining_quota ?? -1
             };
         }
         catch (e) {
             log(`Recall failed: ${e}`);
-            return { memories: [], isLimited: false, remainingQuota: 0 };
+            return { memories: [], relatedMemories: [], isLimited: false, remainingQuota: 0 };
         }
     }
     async endConversation() {
-        await this.flushConversation();
-        await SQLiteStorage.clearTempMessages(this.buffer.getConversationId());
-        log("Conversation ended, buffer flushed");
+        this.conversationManager.startNewConversation();
+        log("Conversation ended, starting new conversation");
+    }
+    async forget(memoryId) {
+        this.init();
+        if (!this.config.apiKey) {
+            log("Forget failed: no API key");
+            return false;
+        }
+        try {
+            const response = await fetch(`${this.apiBase}/v1/memories/${memoryId}`, {
+                method: "DELETE",
+                headers: {
+                    "X-API-Key": this.config.apiKey
+                }
+            });
+            if (response.ok) {
+                log(`Forgot memory ${memoryId}`);
+                return true;
+            }
+            log(`Forget failed: ${response.status}`);
+            return false;
+        }
+        catch (e) {
+            log(`Forget failed: ${e}`);
+            return false;
+        }
     }
-    getStatus() {
+    async list(limit = 10) {
+        this.init();
+        if (!this.config.apiKey) {
+            log("List failed: no API key");
+            return [];
+        }
+        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) {
+                log(`List failed: ${response.status}`);
+                return [];
+            }
+            const data = await response.json();
+            return (data.data || []).map((m) => ({
+                id: m.id,
+                content: m.memory || m.content,
+                category: m.category || "other"
+            }));
+        }
+        catch (e) {
+            log(`List failed: ${e}`);
+            return [];
+        }
+    }
+    async getStatus() {
+        const status = await this.conversationManager.getStatus();
         return {
             initialized: this.config.initialized,
             hasApiKey: !!this.config.apiKey,
-            bufferStatus: this.buffer.getStatus()
+            conversationStatus: status
         };
     }
 }
@@ -542,7 +564,7 @@ let plugin;
 export default {
     id: "memoryx-openclaw-plugin",
     name: "MemoryX Realtime Plugin",
-    version: "1.2.0",
+    version: "1.1.16",
     description: "Real-time memory capture and recall for OpenClaw",
     register(api, pluginConfig) {
         api.logger.info("[MemoryX] Plugin registering...");
@@ -550,6 +572,171 @@ export default {
             api.logger.info(`[MemoryX] API Base: \`${pluginConfig.apiBaseUrl}\``);
         }
         plugin = new MemoryXPlugin(pluginConfig);
+        api.registerTool({
+            name: "memoryx_recall",
+            label: "MemoryX Recall",
+            description: "Search through long-term memories. Use when you need context about user preferences, past decisions, or previously discussed topics.",
+            parameters: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Search query to find relevant memories"
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Maximum number of results to return (default: 5)"
+                    }
+                },
+                required: ["query"]
+            },
+            async execute(_toolCallId, params) {
+                const { query, limit = 5 } = params;
+                if (!plugin) {
+                    return {
+                        content: [{ type: "text", text: "MemoryX plugin not initialized." }],
+                        details: { error: "not_initialized" }
+                    };
+                }
+                try {
+                    const result = await plugin.recall(query, limit);
+                    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_forget",
+            label: "MemoryX Forget",
+            description: "Delete specific memories. Use when user explicitly asks to forget or remove something from memory.",
+            parameters: {
+                type: "object",
+                properties: {
+                    memory_id: {
+                        type: "string",
+                        description: "The ID of the memory to delete"
+                    }
+                },
+                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 }
+                        };
+                    }
+                    else {
+                        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_list",
+            label: "MemoryX List",
+            description: "List all stored memories. Use when user asks what you remember about them.",
+            parameters: {
+                type: "object",
+                properties: {
+                    limit: {
+                        type: "number",
+                        description: "Maximum number of memories to list (default: 10)"
+                    }
+                }
+            },
+            async execute(_toolCallId, params) {
+                const { limit = 10 } = params;
+                if (!plugin) {
+                    return {
+                        content: [{ type: "text", text: "MemoryX plugin not initialized." }],
+                        details: { error: "not_initialized" }
+                    };
+                }
+                try {
+                    const memories = await plugin.list(limit);
+                    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.on("message_received", async (event, ctx) => {
             const { content } = event;
             if (content && plugin) {
@@ -571,17 +758,24 @@ export default {
                 if (result.isLimited) {
                     api.logger.warn(`[MemoryX] ${result.upgradeHint}`);
                     return {
-                        prependContext: `[系统提示] ${result.upgradeHint}\n`
+                        prependContext: `[System] ${result.upgradeHint}\n`
                     };
                 }
-                if (result.memories.length === 0)
+                if (result.memories.length === 0 && result.relatedMemories.length === 0)
                     return;
-                const memories = result.memories
-                    .map(m => `- [${m.category}] ${m.content}`)
-                    .join("\n");
-                api.logger.info(`[MemoryX] Recalled ${result.memories.length} memories from cloud`);
+                let context = "MemoryX by t0ken.ai found the following memories:\n";
+                if (result.memories.length > 0) {
+                    context += "\n[Direct Memories]\n";
+                    context += result.memories.map(m => `- ${m.content}`).join("\n");
+                }
+                if (result.relatedMemories.length > 0) {
+                    context += "\n\n[Related Memories]\n";
+                    context += result.relatedMemories.map(m => `- ${m.content}`).join("\n");
+                }
+                context += "\n";
+                api.logger.info(`[MemoryX] Recalled ${result.memories.length} direct + ${result.relatedMemories.length} related memories`);
                 return {
-                    prependContext: `[相关记忆]\n${memories}\n[End of memories]\n`
+                    prependContext: context
                 };
             }
             catch (error) {
@@ -596,4 +790,4 @@ export default {
         api.logger.info("[MemoryX] Plugin registered successfully");
     }
 };
-export { MemoryXPlugin, ConversationBuffer };
+export { MemoryXPlugin, ConversationManager };

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "memoryx-openclaw-plugin",
   "name": "MemoryX Real-time Plugin",
-  "version": "1.1.1",
+  "version": "1.1.15",
   "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": "1.1.14",
+  "version": "1.1.16",
   "description": "MemoryX real-time memory capture and recall plugin for OpenClaw",
   "type": "module",
   "author": "MemoryX Team",
@@ -36,6 +36,7 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "better-sqlite3": "^11.0.0"
+    "better-sqlite3": "^11.0.0",
+    "js-tiktoken": "^1.0.21"
   }
 }