@memorilabs/openclaw-memori 0.0.5 → 0.0.6

package/dist/constants.d.ts

@@ -7,5 +7,16 @@ export declare const RECALL_CONFIG: {
     readonly MIN_PROMPT_LENGTH: 2;
 };
 export declare const AUGMENTATION_CONFIG: {
-    readonly MAX_CONTEXT_MESSAGES: 5;
+    readonly MAX_CONTEXT_MESSAGES: 20;
+};
+export declare const MESSAGE_CONSTANTS: {
+    readonly SILENT_REPLY: "SILENT_REPLY";
+    readonly NO_REPLY: "NO_REPLY";
+    readonly SYNTHETIC_RESPONSE: "Okay, I'll remember that for you.";
+};
+export declare const ROLE: {
+    readonly USER: "user";
+    readonly ASSISTANT: "assistant";
+    readonly TOOL_RESULT: "toolResult";
+    readonly SYSTEM: "system";
 };

package/dist/constants.js

@@ -7,5 +7,16 @@ export const RECALL_CONFIG = {
     MIN_PROMPT_LENGTH: 2,
 };
 export const AUGMENTATION_CONFIG = {
-    MAX_CONTEXT_MESSAGES: 5,
+    MAX_CONTEXT_MESSAGES: 20,
+};
+export const MESSAGE_CONSTANTS = {
+    SILENT_REPLY: 'SILENT_REPLY',
+    NO_REPLY: 'NO_REPLY',
+    SYNTHETIC_RESPONSE: "Okay, I'll remember that for you.",
+};
+export const ROLE = {
+    USER: 'user',
+    ASSISTANT: 'assistant',
+    TOOL_RESULT: 'toolResult',
+    SYSTEM: 'system',
 };

package/dist/handlers/augmentation.d.ts

@@ -1,3 +1,7 @@
 import { OpenClawEvent, OpenClawContext, MemoriPluginConfig } from '../types.js';
 import { MemoriLogger } from '../utils/index.js';
+/**
+ * Main handler for augmentation hook.
+ * Extracts the latest conversation turn and sends it to Memori backend.
+ */
 export declare function handleAugmentation(event: OpenClawEvent, ctx: OpenClawContext, config: MemoriPluginConfig, logger: MemoriLogger): Promise<void>;

package/dist/handlers/augmentation.js

@@ -1,10 +1,13 @@
 import { extractContext, initializeMemoriClient } from '../utils/index.js';
 import { cleanText, isSystemMessage } from '../sanitizer.js';
-import { AUGMENTATION_CONFIG } from '../constants.js';
+import { AUGMENTATION_CONFIG, MESSAGE_CONSTANTS, ROLE } from '../constants.js';
 import { SDK_VERSION } from '../version.js';
+/**
+ * Extracts metadata about the LLM provider and model used during the turn.
+ */
 function extractLLMMetadata(event) {
     const messages = event.messages || [];
-    const lastAssistant = messages.findLast((m) => m.role === 'assistant');
+    const lastAssistant = messages.findLast((m) => m.role === ROLE.ASSISTANT);
     return {
         provider: lastAssistant?.provider || null,
         model: lastAssistant?.model || null,
@@ -13,62 +16,157 @@ function extractLLMMetadata(event) {
         platform: 'openclaw',
     };
 }
+/**
+ * Extracts all tool results from messages and maps them by tool call ID.
+ */
+function extractToolResults(messages) {
+    const resultsMap = new Map();
+    for (const msg of messages) {
+        if (msg.role === ROLE.TOOL_RESULT && msg.toolCallId) {
+            resultsMap.set(msg.toolCallId, cleanText(msg.content));
+        }
+    }
+    return resultsMap;
+}
+/**
+ * Parses tool arguments from various formats into a structured object.
+ */
+function parseToolArguments(rawArgs) {
+    if (typeof rawArgs === 'string') {
+        try {
+            return JSON.parse(rawArgs);
+        }
+        catch {
+            return {};
+        }
+    }
+    if (typeof rawArgs === 'object' && rawArgs !== null) {
+        return rawArgs;
+    }
+    return {};
+}
+/**
+ * Extracts tool calls from an assistant message.
+ * Iterates backward through content blocks to match original extraction order.
+ */
+function extractToolCalls(msg, toolResults) {
+    if (!Array.isArray(msg.content)) {
+        return [];
+    }
+    const tools = [];
+    for (let i = msg.content.length - 1; i >= 0; i--) {
+        const block = msg.content[i];
+        if (block.type === 'toolCall' || block.type === 'tool_use') {
+            const rawArgs = block.arguments ?? block.input;
+            // Unshift to maintain chronological order within the message
+            tools.unshift({
+                name: block.name,
+                args: parseToolArguments(rawArgs),
+                result: toolResults.get(block.id) ?? null,
+            });
+        }
+    }
+    return tools;
+}
+/**
+ * Parses a user message, extracting the cleaned content.
+ */
+function parseUserMessage(msg) {
+    const cleanedContent = cleanText(msg.content);
+    return cleanedContent ? { role: msg.role, content: cleanedContent } : null;
+}
+/**
+ * Parses the most recent conversation turn from messages.
+ * Walks backward to find the last user message and assistant response.
+ * Collects all tool calls from assistant messages in the turn.
+ */
+function parseTurnFromMessages(messages) {
+    const tools = [];
+    const toolResults = extractToolResults(messages);
+    let userMessage = null;
+    let assistantMessage = null;
+    // Walk backwards to find the last complete turn
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role === ROLE.ASSISTANT) {
+            // Extract tool calls from ALL assistant messages in the turn
+            const extractedTools = extractToolCalls(msg, toolResults);
+            if (extractedTools.length > 0) {
+                // Prepend to maintain chronological order
+                tools.unshift(...extractedTools);
+            }
+            // Capture the text response from the FIRST (most recent) assistant message
+            if (!assistantMessage) {
+                const cleanedContent = cleanText(msg.content);
+                if (cleanedContent) {
+                    assistantMessage = {
+                        role: msg.role,
+                        content: cleanedContent.replace(/^\[\[.*?\]\]\s*/, ''),
+                    };
+                }
+                else if (extractedTools.length > 0) {
+                    assistantMessage = { role: msg.role, content: MESSAGE_CONSTANTS.SILENT_REPLY };
+                }
+            }
+        }
+        else if (msg.role === ROLE.USER) {
+            userMessage = parseUserMessage(msg);
+            break; // Found the user message that started this turn
+        }
+    }
+    return { userMessage, assistantMessage, tools };
+}
+/**
+ * Builds the augmentation payload to send to Memori backend.
+ */
+function buildAugmentationPayload(userMessage, agentResponse, tools, event) {
+    const payload = {
+        userMessage,
+        agentResponse,
+        metadata: extractLLMMetadata(event),
+    };
+    if (tools.length > 0) {
+        payload.trace = { tools };
+    }
+    return payload;
+}
+/**
+ * Helper to skip augmentation and log the reason.
+ */
+function skipAugmentation(logger, reason) {
+    logger.info(reason);
+    logger.endSection('AUGMENTATION HOOK END');
+}
+/**
+ * Main handler for augmentation hook.
+ * Extracts the latest conversation turn and sends it to Memori backend.
+ */
 export async function handleAugmentation(event, ctx, config, logger) {
     logger.section('AUGMENTATION HOOK START');
     if (!event.success || !event.messages || event.messages.length < 2) {
-        logger.info('No messages or unsuccessful event. Skipping augmentation.');
-        logger.endSection('AUGMENTATION HOOK END');
+        skipAugmentation(logger, 'No messages or unsuccessful event. Skipping augmentation.');
         return;
     }
     try {
         const recentMessages = event.messages.slice(-AUGMENTATION_CONFIG.MAX_CONTEXT_MESSAGES);
-        let lastUserMsg;
-        let lastAiMsg;
-        for (let i = recentMessages.length - 1; i >= 0; i--) {
-            const msg = recentMessages[i];
-            const role = msg.role;
-            if (role !== 'user' && role !== 'assistant')
-                continue;
-            const cleanedContent = cleanText(msg.content);
-            if (!cleanedContent)
-                continue;
-            let finalContent = cleanedContent;
-            if (role === 'assistant') {
-                finalContent = finalContent.replace(/^\[\[.*?\]\]\s*/, '');
-            }
-            if (role === 'assistant' && !lastAiMsg) {
-                lastAiMsg = { role, content: finalContent };
-            }
-            if (role === 'user' && !lastUserMsg) {
-                lastUserMsg = { role, content: finalContent };
-            }
-            if (lastUserMsg && lastAiMsg)
-                break;
-        }
-        if (!lastUserMsg || !lastAiMsg) {
-            logger.info('Missing user or assistant message. Skipping.');
-            logger.endSection('AUGMENTATION HOOK END');
+        const turn = parseTurnFromMessages(recentMessages);
+        if (!turn.userMessage || !turn.assistantMessage) {
+            skipAugmentation(logger, 'Missing user or assistant message. Skipping.');
             return;
         }
-        if (isSystemMessage(lastUserMsg.content)) {
-            logger.info('User message is a system message. Skipping augmentation.');
-            logger.endSection('AUGMENTATION HOOK END');
+        if (isSystemMessage(turn.userMessage.content)) {
+            skipAugmentation(logger, 'User message is a system message. Skipping augmentation.');
             return;
         }
-        if (lastAiMsg.content === 'NO_REPLY' || lastAiMsg.content === 'SILENT_REPLY') {
+        // Resolve synthetic responses for pure-tool executions
+        if (turn.assistantMessage.content === MESSAGE_CONSTANTS.SILENT_REPLY ||
+            turn.assistantMessage.content === MESSAGE_CONSTANTS.NO_REPLY) {
             logger.info('Assistant used tool-based messaging. Using synthetic response.');
-            lastAiMsg = {
-                role: 'assistant',
-                content: "Okay, I'll remember that for you.",
-            };
+            turn.assistantMessage.content = MESSAGE_CONSTANTS.SYNTHETIC_RESPONSE;
         }
+        const payload = buildAugmentationPayload(turn.userMessage.content, turn.assistantMessage.content, turn.tools, event);
         const context = extractContext(event, ctx, config.entityId);
         const memoriClient = initializeMemoriClient(config.apiKey, context);
-        const payload = {
-            userMessage: lastUserMsg.content,
-            agentResponse: lastAiMsg.content,
-            metadata: extractLLMMetadata(event),
-        };
         await memoriClient.augmentation(payload);
         logger.info('Augmentation successful!');
     }

package/dist/types.d.ts

@@ -6,12 +6,18 @@ export interface OpenClawMessageBlock {
     type?: string;
     text?: string;
     thinking?: string;
+    name?: string;
+    id?: string;
+    arguments?: unknown;
     [key: string]: unknown;
 }
 export interface OpenClawMessage {
-    role: 'user' | 'assistant' | 'system';
+    role: string;
     content: string | OpenClawMessageBlock[];
     timestamp?: number;
+    toolCallId?: string;
+    provider?: string;
+    model?: string;
     [key: string]: unknown;
 }
 export interface OpenClawEvent {
@@ -32,3 +38,19 @@ export interface OpenClawContext {
     workspaceDir?: string;
     messageProvider?: string;
 }
+export interface ExtractedToolCall {
+    name: string;
+    args: Record<string, unknown>;
+    result: unknown;
+}
+export interface ParsedTurn {
+    userMessage: {
+        role: string;
+        content: string;
+    } | null;
+    assistantMessage: {
+        role: string;
+        content: string;
+    } | null;
+    tools: ExtractedToolCall[];
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.0.5";
+export declare const SDK_VERSION = "0.0.6";

package/dist/version.js

@@ -1 +1 @@
-export const SDK_VERSION = '0.0.5';
+export const SDK_VERSION = '0.0.6';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memorilabs/openclaw-memori",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Official MemoriLabs.ai long-term memory plugin for OpenClaw",
   "type": "module",
   "main": "./dist/index.js",
@@ -66,6 +66,6 @@
     "@hono/node-server": "^1.19.10"
   },
   "dependencies": {
-    "@memorilabs/memori": "^0.0.6"
+    "@memorilabs/memori": "^0.0.8"
   }
 }