@memorilabs/openclaw-memori 0.0.5 → 0.0.6-beta

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;
+    }>;
+};

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,17 +1,25 @@
+import { IntegrationMessage } from '@memorilabs/memori/integrations';
 export interface MemoriPluginConfig {
     apiKey: string;
     entityId: string;
+    projectId: string;
 }
 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 +40,13 @@ export interface OpenClawContext {
     workspaceDir?: string;
     messageProvider?: string;
 }
+export interface ExtractedToolCall {
+    name: string;
+    args: Record<string, unknown>;
+    result: unknown;
+}
+export interface ParsedTurn {
+    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.5";
+export declare const SDK_VERSION = "0.0.6-beta";

package/dist/version.js

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

package/openclaw.plugin.json

@@ -1,10 +1,20 @@
 {
   "id": "openclaw-memori",
   "name": "Memori System",
-  "version": "0.0.2",
+  "version": "0.0.13",
   "description": "Hosted memory backend",
   "kind": "memory",
   "main": "dist/index.js",
+  "contracts": {
+    "tools": [
+      "memori_recall",
+      "memori_recall_summary",
+      "memori_compaction",
+      "memori_feedback",
+      "memori_signup",
+      "memori_quota"
+    ]
+  },
   "uiHints": {
     "apiKey": {
       "label": "Memori API Key",
@@ -16,6 +26,11 @@
       "label": "Entity ID",
       "placeholder": "e.g., your-app-user-id",
       "help": "Required. The unique identifier to attribute these memories to."
+    },
+    "projectId": {
+      "label": "Project ID",
+      "placeholder": "e.g., my-project",
+      "help": "Required. Scopes all memories to this project."
     }
   },
   "configSchema": {
@@ -29,7 +44,12 @@
       "entityId": {
         "type": "string",
         "title": "Entity ID",
-        "description": "Required. Hardcode a specific Entity ID for memories."
+        "description": "Required. The unique identifier to attribute these memories to."
+      },
+      "projectId": {
+        "type": "string",
+        "title": "Project ID",
+        "description": "Required. Scopes all memories to this project."
       }
     },
     "required": []

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@memorilabs/openclaw-memori",
-  "version": "0.0.5",
+  "version": "0.0.6-beta",
   "description": "Official MemoriLabs.ai long-term memory plugin for OpenClaw",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
     "dist",
+    "skills",
     "openclaw.plugin.json"
   ],
   "scripts": {
@@ -66,6 +67,6 @@
     "@hono/node-server": "^1.19.10"
   },
   "dependencies": {
-    "@memorilabs/memori": "^0.0.6"
+    "@memorilabs/memori": "^0.1.22-beta"
   }
 }