@memorilabs/openclaw-memori 0.0.6 → 0.0.7-beta

package/dist/sanitizer.js

@@ -19,7 +19,7 @@ export function isSystemMessage(text) {
  *
  * OpenClaw wraps metadata in markdown code fences (triple tick).
  * The actual message is always after the LAST closing fence.
- * The message might aslo contain a timestamp prefix like: [Day YYYY-MM-DD HH:MM TZ], that will need to be removed
+ * The message might also contain a timestamp prefix like: [Day YYYY-MM-DD HH:MM TZ], that will need to be removed
  */
 function extractRawUserMessage(content) {
     let message = content;
@@ -49,11 +49,19 @@ function extractMessageText(content) {
     }
     return '';
 }
+export function extractContentType(rawContent) {
+    if (typeof rawContent === 'string' || !rawContent)
+        return 'text';
+    if (isMessageBlockArray(rawContent)) {
+        const primary = rawContent.find((block) => (block.type === 'text' || typeof block.text === 'string') && block.text);
+        return primary?.type ?? 'text';
+    }
+    return 'text';
+}
 export function cleanText(rawContent) {
     let text = extractMessageText(rawContent);
     if (!text)
         return '';
     text = extractRawUserMessage(text);
-    text = text.replace(/<memori_context>[\s\S]*?<\/memori_context>\s*/g, '');
     return text.trim();
 }

package/dist/tools/index.d.ts

@@ -0,0 +1,4 @@
+import type { ToolDeps } from './types.js';
+export declare function registerUtilityTools(deps: ToolDeps): void;
+export declare function registerAuthenticatedTools(deps: ToolDeps): void;
+export type { ToolDeps };

package/dist/tools/index.js

@@ -0,0 +1,16 @@
+import { createMemoriSignupTool } from './memori-signup.js';
+import { createMemoriQuotaTool } from './memori-quota.js';
+import { createMemoriRecallTool } from './memori-recall.js';
+import { createMemoriRecallSummaryTool } from './memori-recall-summary.js';
+import { createMemoriFeedbackTool } from './memori-feedback.js';
+import { createMemoriCompactionTool } from './memori-compaction.js';
+export function registerUtilityTools(deps) {
+    deps.api.registerTool(createMemoriSignupTool(deps));
+}
+export function registerAuthenticatedTools(deps) {
+    deps.api.registerTool(createMemoriRecallTool(deps));
+    deps.api.registerTool(createMemoriRecallSummaryTool(deps));
+    deps.api.registerTool(createMemoriFeedbackTool(deps));
+    deps.api.registerTool(createMemoriQuotaTool(deps));
+    deps.api.registerTool(createMemoriCompactionTool(deps));
+}

package/dist/tools/memori-compaction.d.ts

@@ -0,0 +1,35 @@
+import type { ToolDeps } from './types.js';
+export declare function createMemoriCompactionTool(deps: ToolDeps): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: string;
+        required: string[];
+        properties: {
+            projectId: {
+                type: string;
+                description: string;
+            };
+            sessionId: {
+                type: string;
+                description: string;
+            };
+            numMessages: {
+                type: string;
+                description: string;
+            };
+        };
+    };
+    execute(_toolCallId: string, params: {
+        projectId?: string;
+        sessionId?: string;
+        numMessages?: number;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: null;
+    }>;
+};

package/dist/tools/memori-compaction.js

@@ -0,0 +1,119 @@
+import { QuotaExceededError } from '@memorilabs/memori';
+import { createRecallClient } from '../utils/memori-client.js';
+export function createMemoriCompactionTool(deps) {
+    const { config, logger } = deps;
+    return {
+        name: 'memori_compaction',
+        label: 'Compact Agent Memory',
+        description: `Use this tool to restore working state after context compaction. Returns a structured snapshot of the agent's long-term memory to enable continuation without replaying the full prior session.
+
+WHEN TO USE:
+- The agent resumes after compaction
+- A long-running workflow has lost conversational detail
+- The agent needs to continue operational work without replaying the full prior session
+- The agent needs durable state, standing instructions, environment details, open loops, or the next expected action
+
+WHEN NOT TO USE:
+- Do NOT call this on every turn — it costs 100 memory credits per execution
+- Do NOT use this for targeted memory search — use memori_recall for that instead
+- Do NOT call this if the agent is starting a brand-new task with no prior context
+- Compaction is not a replacement for precise memory retrieval
+
+The compaction result returns:
+- **environment**: environment variable context captured during prior sessions
+- **standing_orders**: persistent instructions the agent must continue to follow
+- **state**: active_tasks (work in progress), open_loops (unresolved threads), pending_results
+- **timeline**: a chronological narrative of agent activity (when available)
+- **workspace_changes**: recent file or system changes made by the agent
+- **continuation**: last_action (what the agent did last) and next_expected_action (what it should do next)
+- **messages**: a tail of recent conversation messages for continuity
+
+HOW TO USE THE RESULT:
+Treat the compaction result as the agent's resume state — use it to understand what environment the agent was operating in, which standing orders must continue to be followed, which tasks are active, what happened across the prior session window, and what the agent should do next.
+
+The compaction result should guide continuation, not override explicit user instructions. Before acting on operational details, verify any state that may have changed since compaction.
+
+Pay special attention to:
+- Standing orders
+- Hard constraints
+- Alerting rules
+- Expected response formats
+- Open loops
+- Staleness warnings
+- Next expected action
+
+If the compaction result contains a required output format, follow it exactly unless the user gives a newer instruction.`,
+        parameters: {
+            type: 'object',
+            required: ['projectId'],
+            properties: {
+                projectId: {
+                    type: 'string',
+                    description: 'The project to compact. REQUIRED — always pass the configured project ID. This scopes the compaction to the correct workspace.',
+                },
+                sessionId: {
+                    type: 'string',
+                    description: 'Scope the compaction to a specific agent session. Leave empty to compact across all sessions in the project. Cannot be used without projectId.',
+                },
+                numMessages: {
+                    type: 'number',
+                    description: 'Number of recent conversation messages to include in the result. Defaults to 5. Increase (up to ~20) only if the user explicitly asks for more conversation context.',
+                },
+            },
+        },
+        async execute(_toolCallId, params) {
+            try {
+                // Config projectId is the fallback; an explicit LLM-provided value overrides it.
+                const finalParams = { projectId: config.projectId, ...params };
+                if (!finalParams.projectId) {
+                    const errorResult = { error: 'projectId is required but was not configured' };
+                    logger.warn(`memori_compaction rejected: ${JSON.stringify(errorResult)}`);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                        details: null,
+                    };
+                }
+                if (finalParams.sessionId && !finalParams.projectId) {
+                    const errorResult = { error: 'sessionId cannot be provided without projectId' };
+                    logger.warn(`memori_compaction rejected: ${JSON.stringify(errorResult)}`);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                        details: null,
+                    };
+                }
+                logger.info(`memori_compaction params: ${JSON.stringify(finalParams)}`);
+                const client = createRecallClient(config.apiKey, config.entityId);
+                const result = await client.agentCompaction(finalParams);
+                if (result === null) {
+                    const errorResult = { error: 'Compaction failed' };
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                        details: null,
+                    };
+                }
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                    details: null,
+                };
+            }
+            catch (e) {
+                if (e instanceof QuotaExceededError) {
+                    logger.warn('memori_compaction quota exceeded');
+                    const errorResult = {
+                        error: 'Quota exceeded: compaction costs 100 memory credits and your organization has exhausted its Recall Execution quota.',
+                    };
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                        details: null,
+                    };
+                }
+                logger.warn(`memori_compaction failed: ${String(e)}`);
+                const errorResult = { error: 'Compaction failed' };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                    details: null,
+                };
+            }
+        },
+    };
+}

package/dist/tools/memori-feedback.d.ts

@@ -0,0 +1,25 @@
+import type { ToolDeps } from './types.js';
+export declare function createMemoriFeedbackTool(deps: ToolDeps): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            content: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(_toolCallId: string, params: {
+        content: string;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: null;
+    }>;
+};

package/dist/tools/memori-feedback.js

@@ -0,0 +1,40 @@
+import { createRecallClient } from '../utils/memori-client.js';
+export function createMemoriFeedbackTool(deps) {
+    const { config, logger } = deps;
+    return {
+        name: 'memori_feedback',
+        label: 'Memori Feedback',
+        description: 'CRITICAL: You MUST use this tool immediately whenever the user asks you to send feedback, report a bug, suggest a feature, or complain about Memori. Send feedback directly to the Memori team (positive or negative).',
+        parameters: {
+            type: 'object',
+            properties: {
+                content: {
+                    type: 'string',
+                    description: 'REQUIRED: The feedback message to send.',
+                },
+            },
+            required: ['content'],
+        },
+        async execute(_toolCallId, params) {
+            try {
+                logger.info(`memori_feedback sending: ${params.content}`);
+                const client = createRecallClient(config.apiKey, config.entityId);
+                await client.agentFeedback(params.content);
+                const result = { success: true, message: 'Feedback sent successfully.' };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                    details: null,
+                };
+            }
+            catch (e) {
+                logger.warn(`memori_feedback failed: ${String(e)}`);
+                const errorResult = { error: 'Feedback failed to send.' };
+                logger.info(`memori_feedback error result: ${JSON.stringify(errorResult)}`);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                    details: null,
+                };
+            }
+        },
+    };
+}

package/dist/tools/memori-quota.d.ts

@@ -0,0 +1,17 @@
+import type { ToolDeps } from './types.js';
+export declare function createMemoriQuotaTool(deps: ToolDeps): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {};
+    };
+    execute(_toolCallId: string): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: null;
+    }>;
+};

package/dist/tools/memori-quota.js

@@ -0,0 +1,55 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as os from 'os';
+import * as path from 'path';
+const execAsync = promisify(exec);
+export function createMemoriQuotaTool(deps) {
+    const { logger } = deps;
+    return {
+        name: 'memori_quota',
+        label: 'Memori Quota',
+        description: 'Retrieves the current memory usage and maximum allowed quota for the user. Use this when the user asks about their limits, storage, or how many memories they have left — or when you encounter errors suggesting memory limits have been reached and want to confirm before degrading behavior.',
+        parameters: {
+            type: 'object',
+            properties: {},
+        },
+        async execute(_toolCallId) {
+            try {
+                logger.info('memori_quota checking usage...');
+                const tmpDir = os.tmpdir();
+                await execAsync(`npm install --prefix ${tmpDir} --no-save @memorilabs/memori@0.1.12-beta`);
+                const binPath = path.join(tmpDir, 'node_modules', '.bin', 'memori');
+                const { stdout } = await execAsync(`${binPath} quota`);
+                const result = {
+                    success: true,
+                    message: stdout.trim(),
+                };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                    details: null,
+                };
+            }
+            catch (e) {
+                logger.warn(`memori_quota CLI failed: ${String(e)}`);
+                let output = 'An unexpected error occurred while trying to fetch quota via the CLI.';
+                if (typeof e === 'object' && e !== null) {
+                    const errObj = e;
+                    const stdout = typeof errObj.stdout === 'string' ? errObj.stdout.trim() : '';
+                    const stderr = typeof errObj.stderr === 'string' ? errObj.stderr.trim() : '';
+                    const msg = typeof errObj.message === 'string' ? errObj.message : '';
+                    output = stdout || stderr || msg || output;
+                }
+                else if (typeof e === 'string') {
+                    output = e;
+                }
+                const errorResult = {
+                    error: output,
+                };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                    details: null,
+                };
+            }
+        },
+    };
+}

package/dist/tools/memori-recall-summary.d.ts

@@ -0,0 +1,39 @@
+import type { ToolDeps } from './types.js';
+export declare function createMemoriRecallSummaryTool(deps: ToolDeps): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            dateStart: {
+                type: string;
+                description: string;
+            };
+            dateEnd: {
+                type: string;
+                description: string;
+            };
+            projectId: {
+                type: string;
+                description: string;
+            };
+            sessionId: {
+                type: string;
+                description: string;
+            };
+        };
+    };
+    execute(_toolCallId: string, params: {
+        dateStart?: string;
+        dateEnd?: string;
+        projectId?: string;
+        sessionId?: string;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: null;
+    }>;
+};

package/dist/tools/memori-recall-summary.js

@@ -0,0 +1,58 @@
+import { createRecallClient } from '../utils/memori-client.js';
+export function createMemoriRecallSummaryTool(deps) {
+    const { config, logger } = deps;
+    return {
+        name: 'memori_recall_summary',
+        label: 'Recall Memory Summary',
+        description: 'CRITICAL: You MUST use this tool BEFORE answering any requests for a summary, status update, daily brief, or high-level overview of a project or past sessions. Fetch summarized views of stored memories from Memori within a specific date range. If no date range is provided, the result defaults to the last 24 hours.',
+        parameters: {
+            type: 'object',
+            properties: {
+                dateStart: {
+                    type: 'string',
+                    description: 'ISO 8601 (MUST be UTC) date string to filter summaries created on or after this time',
+                },
+                dateEnd: {
+                    type: 'string',
+                    description: 'ISO 8601 (MUST be UTC) date string to filter summaries created on or before this time',
+                },
+                projectId: {
+                    type: 'string',
+                    description: 'CRITICAL: Leave this EMPTY to use the configured default project. ONLY provide a value if the user explicitly asks to search a different project by name.',
+                },
+                sessionId: {
+                    type: 'string',
+                    description: 'Filter to a specific session. Cannot be used without projectId.',
+                },
+            },
+        },
+        async execute(_toolCallId, params) {
+            try {
+                const finalParams = { projectId: config.projectId, ...params };
+                if (finalParams.sessionId && !finalParams.projectId) {
+                    const errorResult = { error: 'sessionId cannot be provided without projectId' };
+                    logger.warn(`memori_recall_summary rejected: ${JSON.stringify(errorResult)}`);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                        details: null,
+                    };
+                }
+                logger.info(`memori_recall_summary params: ${JSON.stringify(finalParams)}`);
+                const client = createRecallClient(config.apiKey, config.entityId);
+                const result = await client.agentRecallSummary(finalParams);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                    details: null,
+                };
+            }
+            catch (e) {
+                logger.warn(`memori_recall_summary failed: ${String(e)}`);
+                const errorResult = { error: 'Recall summary failed' };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                    details: null,
+                };
+            }
+        },
+    };
+}

package/dist/tools/memori-recall.d.ts

@@ -0,0 +1,51 @@
+import type { ToolDeps } from './types.js';
+export declare function createMemoriRecallTool(deps: ToolDeps): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            dateStart: {
+                type: string;
+                description: string;
+            };
+            dateEnd: {
+                type: string;
+                description: string;
+            };
+            projectId: {
+                type: string;
+                description: string;
+            };
+            sessionId: {
+                type: string;
+                description: string;
+            };
+            signal: {
+                type: string;
+                description: string;
+                enum: string[];
+            };
+            source: {
+                type: string;
+                description: string;
+                enum: string[];
+            };
+        };
+    };
+    execute(_toolCallId: string, params: {
+        dateStart?: string;
+        dateEnd?: string;
+        projectId?: string;
+        sessionId?: string;
+        signal?: string;
+        source?: string;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: null;
+    }>;
+};

package/dist/tools/memori-recall.js

@@ -0,0 +1,123 @@
+import { createRecallClient } from '../utils/memori-client.js';
+export function createMemoriRecallTool(deps) {
+    const { config, logger } = deps;
+    return {
+        name: 'memori_recall',
+        label: 'Recall Memory',
+        description: 'CRITICAL: You MUST use this tool to search for past context BEFORE claiming you do not know the user, their preferences, or past events. Explicitly fetch relevant memories from Memori using filters...',
+        parameters: {
+            type: 'object',
+            properties: {
+                dateStart: {
+                    type: 'string',
+                    description: 'ISO 8601 (MUST be UTC) date string to filter memories created on or after this time',
+                },
+                dateEnd: {
+                    type: 'string',
+                    description: 'ISO 8601 (MUST be UTC) date string to filter memories created on or before this time',
+                },
+                projectId: {
+                    type: 'string',
+                    description: 'CRITICAL: Leave this EMPTY to use the configured default project. ONLY provide a value if the user explicitly asks to search a different project by name.',
+                },
+                sessionId: {
+                    type: 'string',
+                    description: 'Filter to a specific session. Cannot be used without projectId.',
+                },
+                signal: {
+                    type: 'string',
+                    description: 'Filter by how the memory was derived. MUST be set together with `source` using one of the allowed (source, signal) pairs — never set independently. Valid pairs: (constraint, discovery), (decision, commit), (fact, verification), (execution, failure), (instruction, discovery), (insight, inference), (status, update), (strategy, pattern), (task, result).',
+                    enum: [
+                        'commit',
+                        'discovery',
+                        'failure',
+                        'inference',
+                        'pattern',
+                        'result',
+                        'update',
+                        'verification',
+                    ],
+                },
+                source: {
+                    type: 'string',
+                    description: 'Filter by memory type. MUST be set together with `signal` using one of the allowed (source, signal) pairs — never set independently. Valid pairs: (constraint, discovery), (decision, commit), (fact, verification), (execution, failure), (instruction, discovery), (insight, inference), (status, update), (strategy, pattern), (task, result).',
+                    enum: [
+                        'constraint',
+                        'decision',
+                        'execution',
+                        'fact',
+                        'insight',
+                        'instruction',
+                        'status',
+                        'strategy',
+                        'task',
+                    ],
+                },
+            },
+        },
+        async execute(_toolCallId, params) {
+            try {
+                // If params.projectId is undefined, it falls back to config.projectId.
+                // If the LLM intentionally provides one, it overwrites the config.
+                const finalParams = { projectId: config.projectId, ...params };
+                if (finalParams.sessionId && !finalParams.projectId) {
+                    const errorResult = { error: 'sessionId cannot be provided without projectId' };
+                    logger.warn(`memori_recall rejected: ${JSON.stringify(errorResult)}`);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                        details: null,
+                    };
+                }
+                const hasSource = finalParams.source != null;
+                const hasSignal = finalParams.signal != null;
+                if (hasSource !== hasSignal) {
+                    const errorResult = {
+                        error: 'source and signal must be provided together or both omitted',
+                    };
+                    logger.warn(`memori_recall rejected: ${JSON.stringify(errorResult)}`);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                        details: null,
+                    };
+                }
+                const VALID_PAIRS = {
+                    constraint: 'discovery',
+                    decision: 'commit',
+                    fact: 'verification',
+                    execution: 'failure',
+                    instruction: 'discovery',
+                    insight: 'inference',
+                    status: 'update',
+                    strategy: 'pattern',
+                    task: 'result',
+                };
+                const source = finalParams.source;
+                if (hasSource && source != null && VALID_PAIRS[source] !== finalParams.signal) {
+                    const errorResult = {
+                        error: `Invalid (source, signal) pair: (${source}, ${finalParams.signal}). Expected signal for source "${source}" is "${VALID_PAIRS[source]}".`,
+                    };
+                    logger.warn(`memori_recall rejected: ${JSON.stringify(errorResult)}`);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                        details: null,
+                    };
+                }
+                logger.info(`memori_recall params: ${JSON.stringify(finalParams)}`);
+                const client = createRecallClient(config.apiKey, config.entityId);
+                const result = await client.agentRecall(finalParams);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                    details: null,
+                };
+            }
+            catch (e) {
+                logger.warn(`memori_recall failed: ${String(e)}`);
+                const errorResult = { error: 'Recall failed' };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                    details: null,
+                };
+            }
+        },
+    };
+}

package/dist/tools/memori-signup.d.ts

@@ -0,0 +1,25 @@
+import type { ToolDeps } from './types.js';
+export declare function createMemoriSignupTool(deps: ToolDeps): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            email: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(_toolCallId: string, params: {
+        email: string;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: null;
+    }>;
+};