@memorilabs/openclaw-memori 0.0.8 → 0.0.10

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,61 @@
+import type { ToolDeps } from './types.js';
+export declare function createMemoriRecallTool(deps: ToolDeps): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            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[];
+            };
+        };
+        required: string[];
+    };
+    execute(_toolCallId: string, params: {
+        query: string;
+        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,99 @@
+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: {
+                query: {
+                    type: 'string',
+                    description: 'REQUIRED: The natural language search query to find specific facts (e.g., "What database did we decide to use?", "Ryan\'s dogs"). DO NOT use wildcards like "*" or regex. This is a semantic search, so use real words.',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of memories to return (default: 10)',
+                },
+                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 to a specific fact signal. MUST be one of the allowed enum values.',
+                    enum: [
+                        'commit',
+                        'discovery',
+                        'failure',
+                        'inference',
+                        'pattern',
+                        'result',
+                        'update',
+                        'verification',
+                    ],
+                },
+                source: {
+                    type: 'string',
+                    description: 'Filter to a specific source origin. MUST be one of the allowed enum values.',
+                    enum: [
+                        'constraint',
+                        'decision',
+                        'execution',
+                        'fact',
+                        'insight',
+                        'instruction',
+                        'status',
+                        'strategy',
+                        'task',
+                    ],
+                },
+            },
+            // Force the LLM to ALWAYS provide a search query
+            required: ['query'],
+        },
+        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,
+                    };
+                }
+                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;
+    }>;
+};

package/dist/tools/memori-signup.js

@@ -0,0 +1,72 @@
+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 createMemoriSignupTool(deps) {
+    const { logger } = deps;
+    return {
+        name: 'memori_signup',
+        label: 'Memori Sign Up',
+        description: 'CRITICAL: You MUST use this tool when the user asks to sign up, create an account, or get an API key for Memori — or when you encounter a missing MEMORI_API_KEY error and the user provides their email. If the user has not provided an email address, ask for it first. Do not guess or hallucinate an email.',
+        parameters: {
+            type: 'object',
+            properties: {
+                email: {
+                    type: 'string',
+                    description: 'The email address to send the Memori API key to.',
+                },
+            },
+            required: ['email'],
+        },
+        async execute(_toolCallId, params) {
+            try {
+                const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+                if (!emailRegex.test(params.email)) {
+                    const errorResult = {
+                        error: `The email you provided "${params.email}" is not valid. Please provide a standard email address.`,
+                    };
+                    logger.warn(`memori_signup rejected email format: ${params.email}`);
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(errorResult) }],
+                        details: null,
+                    };
+                }
+                logger.info(`memori_signup attempting to sign up: ${params.email}`);
+                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} sign-up ${params.email}`);
+                const result = {
+                    success: true,
+                    message: stdout.trim(),
+                };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                    details: null,
+                };
+            }
+            catch (e) {
+                logger.warn(`memori_signup CLI failed: ${String(e)}`);
+                let output = 'An unexpected error occurred while trying to sign up 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/types.d.ts

@@ -0,0 +1,8 @@
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
+import type { MemoriPluginConfig } from '../types.js';
+import type { MemoriLogger } from '../utils/logger.js';
+export interface ToolDeps {
+    api: OpenClawPluginApi;
+    config: MemoriPluginConfig;
+    logger: MemoriLogger;
+}

package/dist/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/types.d.ts

@@ -1,6 +1,8 @@
+import { IntegrationMessage } from '@memorilabs/memori/integrations';
 export interface MemoriPluginConfig {
     apiKey: string;
     entityId: string;
+    projectId: string;
 }
 export interface OpenClawMessageBlock {
     type?: string;
@@ -44,13 +46,7 @@ export interface ExtractedToolCall {
     result: unknown;
 }
 export interface ParsedTurn {
-    userMessage: {
-        role: string;
-        content: string;
-    } | null;
-    assistantMessage: {
-        role: string;
-        content: string;
-    } | null;
+    userMessage: IntegrationMessage | null;
+    assistantMessage: IntegrationMessage | null;
     tools: ExtractedToolCall[];
 }

package/dist/utils/context.d.ts

@@ -6,6 +6,7 @@ export interface ExtractedContext {
     entityId: string;
     sessionId: string;
     provider: string;
+    projectId: string;
 }
 /**
  * Extracts and normalizes context information from OpenClaw event and context objects.
@@ -14,7 +15,8 @@ export interface ExtractedContext {
  * @param event - OpenClaw event object
  * @param ctx - OpenClaw context object
  * @param configuredEntityId - Hardcoded entity ID from plugin config
- * @returns Normalized context with entityId, sessionId, and provider
+ * @param configuredProjectId - Project ID from plugin config
+ * @returns Normalized context with entityId, sessionId, provider, and projectId
  * @throws Error If entityId, sessionId, or provider cannot be determined
  */
-export declare function extractContext(event: OpenClawEvent, ctx: OpenClawContext, configuredEntityId: string): ExtractedContext;
+export declare function extractContext(event: OpenClawEvent, ctx: OpenClawContext, configuredEntityId: string, configuredProjectId: string): ExtractedContext;

package/dist/utils/context.js

@@ -5,10 +5,11 @@
  * @param event - OpenClaw event object
  * @param ctx - OpenClaw context object
  * @param configuredEntityId - Hardcoded entity ID from plugin config
- * @returns Normalized context with entityId, sessionId, and provider
+ * @param configuredProjectId - Project ID from plugin config
+ * @returns Normalized context with entityId, sessionId, provider, and projectId
  * @throws Error If entityId, sessionId, or provider cannot be determined
  */
-export function extractContext(event, ctx, configuredEntityId) {
+export function extractContext(event, ctx, configuredEntityId, configuredProjectId) {
     const sessionId = ctx.sessionKey || event.sessionId;
     const provider = ctx.messageProvider || event.messageProvider;
     if (!sessionId) {
@@ -21,5 +22,6 @@ export function extractContext(event, ctx, configuredEntityId) {
         entityId: configuredEntityId,
         sessionId,
         provider,
+        projectId: configuredProjectId,
     };
 }

package/dist/utils/index.d.ts

@@ -1,3 +1,4 @@
 export { extractContext, type ExtractedContext } from './context.js';
 export { MemoriLogger } from './logger.js';
-export { initializeMemoriClient } from './memori-client.js';
+export { initializeMemoriClient, createRecallClient } from './memori-client.js';
+export { loadSkillsContent } from './skills-loader.js';

package/dist/utils/index.js

@@ -1,3 +1,4 @@
 export { extractContext } from './context.js';
 export { MemoriLogger } from './logger.js';
-export { initializeMemoriClient } from './memori-client.js';
+export { initializeMemoriClient, createRecallClient } from './memori-client.js';
+export { loadSkillsContent } from './skills-loader.js';

package/dist/utils/memori-client.d.ts

@@ -8,3 +8,14 @@ import { ExtractedContext } from './context.js';
  * @returns Configured OpenClawIntegration instance
  */
 export declare function initializeMemoriClient(apiKey: string, context: ExtractedContext): OpenClawIntegration;
+/**
+ * Creates a minimal Memori client scoped only to an entity, with no session or project
+ * context pre-set. Intended for use in tool execute handlers where OpenClaw does not
+ * reliably provide session context — callers supply projectId/sessionId as explicit
+ * parameters instead.
+ *
+ * @param apiKey - Memori API key
+ * @param entityId - Entity ID for attribution
+ * @returns Configured OpenClawIntegration instance
+ */
+export declare function createRecallClient(apiKey: string, entityId: string): OpenClawIntegration;

package/dist/utils/memori-client.js

@@ -11,7 +11,25 @@ export function initializeMemoriClient(apiKey, context) {
     const memori = new Memori();
     memori.config.apiKey = apiKey;
     const openclaw = memori.integrate(OpenClawIntegration);
-    openclaw.setAttribution(context.entityId, context.provider);
-    openclaw.setSession(context.sessionId);
+    openclaw
+        .scope(context.sessionId, context.projectId)
+        .attribution(context.entityId, context.provider);
+    return openclaw;
+}
+/**
+ * Creates a minimal Memori client scoped only to an entity, with no session or project
+ * context pre-set. Intended for use in tool execute handlers where OpenClaw does not
+ * reliably provide session context — callers supply projectId/sessionId as explicit
+ * parameters instead.
+ *
+ * @param apiKey - Memori API key
+ * @param entityId - Entity ID for attribution
+ * @returns Configured OpenClawIntegration instance
+ */
+export function createRecallClient(apiKey, entityId) {
+    const memori = new Memori();
+    memori.config.apiKey = apiKey;
+    const openclaw = memori.integrate(OpenClawIntegration);
+    openclaw.attribution(entityId);
     return openclaw;
 }

package/dist/utils/skills-loader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Loads the Memori skills document at plugin registration time.
+ * Returns an empty string if the file cannot be read so the plugin
+ * degrades gracefully rather than failing to register.
+ */
+export declare function loadSkillsContent(resolvePath: (input: string) => string): string;

package/dist/utils/skills-loader.js

@@ -0,0 +1,14 @@
+import { readFileSync } from 'fs';
+/**
+ * Loads the Memori skills document at plugin registration time.
+ * Returns an empty string if the file cannot be read so the plugin
+ * degrades gracefully rather than failing to register.
+ */
+export function loadSkillsContent(resolvePath) {
+    try {
+        return readFileSync(resolvePath('skills/memori/SKILL.md'), 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.0.8";
+export declare const SDK_VERSION = "0.0.10";

package/dist/version.js

@@ -1 +1 @@
-export const SDK_VERSION = '0.0.8';
+export const SDK_VERSION = '0.0.10';