@memorilabs/openclaw-memori 0.0.1-beta → 0.0.1

package/README.md

@@ -0,0 +1,126 @@
+[![Memori Labs](https://s3.us-east-1.amazonaws.com/images.memorilabs.ai/banner.png)](https://memorilabs.ai/)
+
+<p align="center">
+  <strong>The memory fabric for enterprise AI</strong>
+</p>
+
+<p align="center">
+  <i>By default, OpenClaw agents forget everything between sessions. This plugin fixes that. It watches conversations, extracts what matters, and brings it back when relevant—automatically.</i>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@memorilabs/openclaw-memori">
+    <img src="https://img.shields.io/npm/v/@memorilabs/openclaw-memori.svg" alt="NPM version">
+  </a>
+  <a href="https://www.npmjs.com/package/@memorilabs/openclaw-memori">
+    <img src="https://img.shields.io/npm/dm/@memorilabs/openclaw-memori.svg" alt="NPM Downloads">
+  </a>
+  <a href="https://opensource.org/license/apache-2-0">
+    <img src="https://img.shields.io/badge/license-Apache%202.0-blue" alt="License">
+  </a>
+  <a href="https://discord.gg/abD4eGym6v">
+    <img src="https://img.shields.io/discord/1042405378304004156?logo=discord" alt="Discord">
+  </a>
+</p>
+
+---
+
+## Key Features
+
+- **Auto-Recall:** Before the agent responds, the plugin searches Memori for memories that match the current context and injects them directly into the prompt.
+- **Auto-Capture:** After the agent responds, the plugin securely sends the exchange to Memori to extract new facts, update stale ones, and merge duplicates.
+- **Bulletproof Sanitization:** Automatically strips OpenClaw system metadata, internal timestamps, and thinking blocks to prevent context pollution and feedback loops.
+- **Stateless & Thread-Safe:** A completely stateless architecture ensures zero memory leaks and 100% thread safety for multi-agent OpenClaw gateways.
+
+## Getting Started
+
+Run the following commands in your terminal to install and enable the plugin:
+
+```bash
+# 1. Install the plugin from npm
+openclaw plugins install @memorilabs/openclaw-memori
+
+# 2. Enable it in your workspace
+openclaw plugins enable openclaw-memori
+
+# 3. Restart the OpenClaw gateway
+openclaw gateway restart
+```
+
+## Configuration
+
+The plugin needs your Memori API key and an Entity ID to function. You can configure this via the OpenClaw CLI, your `openclaw.json` file, or environment variables.
+
+### Option A: Via OpenClaw CLI (Recommended)
+
+```bash
+openclaw config set plugins.entries.openclaw-memori.config.apiKey "YOUR_MEMORI_API_KEY"
+openclaw config set plugins.entries.openclaw-memori.config.entityId "your-app-user-id"
+```
+
+### Option B: Via `openclaw.json`
+
+Add the following to your `~/.openclaw/openclaw.json` file:
+
+```json
+{
+  "plugins": {
+    "entries": {
+      "openclaw-memori": {
+        "enabled": true,
+        "config": {
+          "apiKey": "your-memori-api-key",
+          "entityId": "your-app-user-id"
+        }
+      }
+    }
+  }
+}
+```
+
+### Configuration Options
+
+| Option     | Type     | Required | Description                                                                                         |
+| ---------- | -------- | -------- | --------------------------------------------------------------------------------------------------- |
+| `apiKey`   | `string` | **Yes**  | Your Memori API key.                                                                                |
+| `entityId` | `string` | **Yes**  | The unique identifier for the entity (e.g., user, agent, or tenant) to attribute these memories to. |
+
+## How It Works (The Hook Lifecycle)
+
+This plugin integrates deeply with OpenClaw's event lifecycle to provide seamless memory without interfering with your agent's core logic:
+
+1. **`before_prompt_build` (Recall):** When a user sends a message, the plugin intercepts the event, queries the Memori API, and safely prepends relevant memories to the agent's system context.
+2. **`agent_end` (Capture):** Once the agent finishes generating its response, the plugin captures the final `user` and `assistant` messages, sanitizes them, and sends them to the Memori integration endpoint for long-term storage and entity mapping.
+
+## Contributing
+
+We welcome contributions from the community! Please see our [Contributing Guidelines](https://github.com/MemoriLabs/Memori/blob/main/CONTRIBUTING.md) for details on code style, standards, and submitting pull requests.
+
+To build from source:
+
+```bash
+# Clone the repository
+git clone https://github.com/memorilabs/openclaw-memori.git
+cd openclaw-memori
+
+# Install dependencies and build
+npm install
+npm run build
+
+# Run formatting, linting, and type checking
+npm run check
+```
+
+---
+
+## Support
+
+- **Documentation**: [https://memorilabs.ai/docs](https://memorilabs.ai/docs)
+- **Discord**: [https://discord.gg/abD4eGym6v](https://discord.gg/abD4eGym6v)
+- **Issues**: [GitHub Issues](https://github.com/memorilabs/openclaw-memori/issues)
+
+---
+
+## License
+
+Apache 2.0 - see [LICENSE](https://github.com/MemoriLabs/Memori/blob/main/LICENSE)

package/dist/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const PLUGIN_CONFIG: {
+    readonly ID: "openclaw-memori";
+    readonly NAME: "Memori System";
+    readonly LOG_PREFIX: "[Memori]";
+};
+export declare const RECALL_CONFIG: {
+    readonly MIN_PROMPT_LENGTH: 2;
+};
+export declare const AUGMENTATION_CONFIG: {
+    readonly MAX_CONTEXT_MESSAGES: 5;
+};

package/dist/constants.js

@@ -0,0 +1,11 @@
+export const PLUGIN_CONFIG = {
+    ID: 'openclaw-memori',
+    NAME: 'Memori System',
+    LOG_PREFIX: '[Memori]',
+};
+export const RECALL_CONFIG = {
+    MIN_PROMPT_LENGTH: 2,
+};
+export const AUGMENTATION_CONFIG = {
+    MAX_CONTEXT_MESSAGES: 5,
+};

package/dist/handlers/augmentation.d.ts

@@ -0,0 +1,3 @@
+import { OpenClawEvent, OpenClawContext, MemoriPluginConfig } from '../types.js';
+import { MemoriLogger } from '../utils/index.js';
+export declare function handleAugmentation(event: OpenClawEvent, ctx: OpenClawContext, config: MemoriPluginConfig, logger: MemoriLogger): Promise<void>;

package/dist/handlers/augmentation.js

@@ -0,0 +1,81 @@
+import { extractContext, initializeMemoriClient } from '../utils/index.js';
+import { cleanText, isSystemMessage } from '../sanitizer.js';
+import { AUGMENTATION_CONFIG } from '../constants.js';
+import { SDK_VERSION } from '../version.js';
+function extractLLMMetadata(event) {
+    const messages = event.messages || [];
+    const lastAssistant = messages.findLast((m) => m.role === 'assistant');
+    return {
+        provider: lastAssistant?.provider || null,
+        model: lastAssistant?.model || null,
+        sdkVersion: null,
+        integrationSdkVersion: SDK_VERSION,
+        platform: 'openclaw',
+    };
+}
+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');
+        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');
+            return;
+        }
+        if (isSystemMessage(lastUserMsg.content)) {
+            logger.info('User message is a system message. Skipping augmentation.');
+            logger.endSection('AUGMENTATION HOOK END');
+            return;
+        }
+        if (lastAiMsg.content === 'NO_REPLY' || lastAiMsg.content === 'SILENT_REPLY') {
+            logger.info('Assistant used tool-based messaging. Using synthetic response.');
+            lastAiMsg = {
+                role: 'assistant',
+                content: "Okay, I'll remember that for you.",
+            };
+        }
+        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!');
+    }
+    catch (err) {
+        logger.error(`Augmentation failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    finally {
+        logger.endSection('AUGMENTATION HOOK END');
+    }
+}

package/dist/handlers/recall.d.ts

@@ -0,0 +1,5 @@
+import { OpenClawEvent, OpenClawContext, MemoriPluginConfig } from '../types.js';
+import { MemoriLogger } from '../utils/index.js';
+export declare function handleRecall(event: OpenClawEvent, ctx: OpenClawContext, config: MemoriPluginConfig, logger: MemoriLogger): Promise<{
+    prependContext: string;
+} | undefined>;

package/dist/handlers/recall.js

@@ -0,0 +1,34 @@
+import { cleanText, isSystemMessage } from '../sanitizer.js';
+import { RECALL_CONFIG } from '../constants.js';
+import { extractContext, initializeMemoriClient } from '../utils/index.js';
+export async function handleRecall(event, ctx, config, logger) {
+    logger.section('RECALL HOOK START');
+    try {
+        const context = extractContext(event, ctx, config.entityId);
+        const promptText = cleanText(event.prompt);
+        if (!promptText ||
+            promptText.length < RECALL_CONFIG.MIN_PROMPT_LENGTH ||
+            isSystemMessage(promptText)) {
+            logger.info('Prompt too short or is a system message. Aborting recall.');
+            return undefined;
+        }
+        const memoriClient = initializeMemoriClient(config.apiKey, context);
+        logger.info('Executing SDK Recall...');
+        const recallText = await memoriClient.recall(promptText);
+        const hookReturn = recallText ? { prependContext: recallText } : undefined;
+        if (hookReturn) {
+            logger.info('Successfully injected memory context.');
+        }
+        else {
+            logger.info('No relevant memories found.');
+        }
+        return hookReturn;
+    }
+    catch (err) {
+        logger.error(`Recall failed: ${err instanceof Error ? err.message : String(err)}`);
+        return undefined;
+    }
+    finally {
+        logger.endSection('RECALL HOOK END');
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
+declare const memoriPlugin: {
+    id: "openclaw-memori";
+    name: "Memori System";
+    description: string;
+    register(api: OpenClawPluginApi): void;
+};
+export default memoriPlugin;

package/dist/index.js

@@ -0,0 +1,26 @@
+import { handleRecall } from './handlers/recall.js';
+import { handleAugmentation } from './handlers/augmentation.js';
+import { PLUGIN_CONFIG } from './constants.js';
+import { MemoriLogger } from './utils/index.js';
+const memoriPlugin = {
+    id: PLUGIN_CONFIG.ID,
+    name: PLUGIN_CONFIG.NAME,
+    description: 'Hosted memory backend',
+    register(api) {
+        const rawConfig = api.pluginConfig;
+        const config = {
+            apiKey: rawConfig?.apiKey,
+            entityId: rawConfig?.entityId,
+        };
+        if (!config.apiKey || !config.entityId) {
+            api.logger.warn(`${PLUGIN_CONFIG.LOG_PREFIX} Missing apiKey or entityId in config. Plugin disabled.`);
+            return;
+        }
+        const logger = new MemoriLogger(api);
+        logger.info(`\n=== ${PLUGIN_CONFIG.LOG_PREFIX} INITIALIZING PLUGIN ===`);
+        logger.info(`${PLUGIN_CONFIG.LOG_PREFIX} Tracking Entity ID: ${config.entityId}`);
+        api.on('before_prompt_build', (event, ctx) => handleRecall(event, ctx, config, logger));
+        api.on('agent_end', (event, ctx) => handleAugmentation(event, ctx, config, logger));
+    },
+};
+export default memoriPlugin;

package/dist/sanitizer.d.ts

@@ -0,0 +1,2 @@
+export declare function isSystemMessage(text: string): boolean;
+export declare function cleanText(rawContent: unknown): string;

package/dist/sanitizer.js

@@ -0,0 +1,59 @@
+const SYSTEM_MESSAGE_PATTERNS = [
+    'a new session was started',
+    '/new or /reset',
+    'session startup sequence',
+    'use persona',
+];
+const TIMESTAMP_PREFIX_REGEX = /^\[[A-Z][a-z]{2}\s+\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}\s+[A-Z]{2,4}\]\s*/;
+function isMessageBlockArray(value) {
+    return Array.isArray(value) && value.every((item) => item !== null && typeof item === 'object');
+}
+export function isSystemMessage(text) {
+    if (!text)
+        return true;
+    const lowerText = text.toLowerCase();
+    return SYSTEM_MESSAGE_PATTERNS.some((pattern) => lowerText.includes(pattern));
+}
+/**
+ * Extracts the actual user message from OpenClaw's formatted content.
+ *
+ * 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
+ */
+function extractRawUserMessage(content) {
+    let message = content;
+    if (message.includes('```')) {
+        const lastFenceIndex = message.lastIndexOf('```');
+        if (lastFenceIndex !== -1) {
+            message = message.substring(lastFenceIndex + 3).trim();
+        }
+    }
+    const timestampMatch = message.match(TIMESTAMP_PREFIX_REGEX);
+    if (timestampMatch) {
+        message = message.substring(timestampMatch[0].length).trim();
+    }
+    return message;
+}
+function extractMessageText(content) {
+    if (!content)
+        return '';
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (isMessageBlockArray(content)) {
+        return content
+            .filter((block) => (block.type === 'text' || typeof block.text === 'string') && block.text)
+            .map((block) => block.text)
+            .join('\n\n');
+    }
+    return '';
+}
+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/types.d.ts

@@ -0,0 +1,34 @@
+export interface MemoriPluginConfig {
+    apiKey: string;
+    entityId: string;
+}
+export interface OpenClawMessageBlock {
+    type?: string;
+    text?: string;
+    thinking?: string;
+    [key: string]: unknown;
+}
+export interface OpenClawMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string | OpenClawMessageBlock[];
+    timestamp?: number;
+    [key: string]: unknown;
+}
+export interface OpenClawEvent {
+    prompt?: string;
+    messages?: OpenClawMessage[];
+    completion?: string;
+    success?: boolean;
+    error?: string;
+    durationMs?: number;
+    userId?: string;
+    sessionId?: string;
+    messageProvider?: string;
+}
+export interface OpenClawContext {
+    agentId?: string;
+    sessionKey?: string;
+    sessionId?: string;
+    workspaceDir?: string;
+    messageProvider?: string;
+}

package/dist/types.js

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

package/dist/utils/context.d.ts

@@ -0,0 +1,20 @@
+import { OpenClawEvent, OpenClawContext } from '../types.js';
+/**
+ * Extracted context information from OpenClaw events
+ */
+export interface ExtractedContext {
+    entityId: string;
+    sessionId: string;
+    provider: string;
+}
+/**
+ * Extracts and normalizes context information from OpenClaw event and context objects.
+ * Throws an error if required context fields cannot be resolved.
+ *
+ * @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
+ * @throws Error If entityId, sessionId, or provider cannot be determined
+ */
+export declare function extractContext(event: OpenClawEvent, ctx: OpenClawContext, configuredEntityId: string): ExtractedContext;

package/dist/utils/context.js

@@ -0,0 +1,25 @@
+/**
+ * Extracts and normalizes context information from OpenClaw event and context objects.
+ * Throws an error if required context fields cannot be resolved.
+ *
+ * @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
+ * @throws Error If entityId, sessionId, or provider cannot be determined
+ */
+export function extractContext(event, ctx, configuredEntityId) {
+    const sessionId = ctx.sessionKey || event.sessionId;
+    const provider = ctx.messageProvider || event.messageProvider;
+    if (!sessionId) {
+        throw new Error('Failed to extract context: Missing sessionId in OpenClaw context and event.');
+    }
+    if (!provider) {
+        throw new Error('Failed to extract context: Missing message provider in OpenClaw context and event.');
+    }
+    return {
+        entityId: configuredEntityId,
+        sessionId,
+        provider,
+    };
+}

package/dist/utils/index.d.ts

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

package/dist/utils/index.js

@@ -0,0 +1,3 @@
+export { extractContext } from './context.js';
+export { MemoriLogger } from './logger.js';
+export { initializeMemoriClient } from './memori-client.js';

package/dist/utils/logger.d.ts

@@ -0,0 +1,11 @@
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
+export declare class MemoriLogger {
+    private api;
+    constructor(api: OpenClawPluginApi);
+    private prefix;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    section(title: string): void;
+    endSection(title: string): void;
+}

package/dist/utils/logger.js

@@ -0,0 +1,25 @@
+import { PLUGIN_CONFIG } from '../constants.js';
+export class MemoriLogger {
+    api;
+    constructor(api) {
+        this.api = api;
+    }
+    prefix(msg) {
+        return `${PLUGIN_CONFIG.LOG_PREFIX} ${msg}`;
+    }
+    info(message) {
+        this.api.logger.info(this.prefix(message));
+    }
+    warn(message) {
+        this.api.logger.warn(this.prefix(message));
+    }
+    error(message) {
+        this.api.logger.error(this.prefix(message));
+    }
+    section(title) {
+        this.api.logger.info(`\n=== ${this.prefix(title)} ===`);
+    }
+    endSection(title) {
+        this.api.logger.info(`=== ${this.prefix(title)} ===\n`);
+    }
+}

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

@@ -0,0 +1,10 @@
+import { OpenClawIntegration } from '@memorilabs/memori/integrations';
+import { ExtractedContext } from './context.js';
+/**
+ * Initializes and configures a Memori OpenClaw integration instance
+ *
+ * @param apiKey - Memori API key
+ * @param context - Extracted context information
+ * @returns Configured OpenClawIntegration instance
+ */
+export declare function initializeMemoriClient(apiKey: string, context: ExtractedContext): OpenClawIntegration;

package/dist/utils/memori-client.js

@@ -0,0 +1,17 @@
+import { Memori } from '@memorilabs/memori';
+import { OpenClawIntegration } from '@memorilabs/memori/integrations';
+/**
+ * Initializes and configures a Memori OpenClaw integration instance
+ *
+ * @param apiKey - Memori API key
+ * @param context - Extracted context information
+ * @returns Configured OpenClawIntegration instance
+ */
+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);
+    return openclaw;
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const SDK_VERSION = "0.0.1";

package/dist/version.js

@@ -0,0 +1 @@
+export const SDK_VERSION = '0.0.1';

package/openclaw.plugin.json

@@ -0,0 +1,37 @@
+{
+  "id": "openclaw-memori",
+  "name": "Memori System",
+  "version": "0.0.1-beta",
+  "description": "Hosted memory backend",
+  "kind": "memory",
+  "main": "dist/index.js",
+  "uiHints": {
+    "apiKey": {
+      "label": "Memori API Key",
+      "sensitive": true,
+      "placeholder": "Enter your Memori API key...",
+      "help": "API key from memorilabs.ai (or use MEMORI_API_KEY env var)"
+    },
+    "entityId": {
+      "label": "Entity ID",
+      "placeholder": "e.g., your-app-user-id",
+      "help": "Required. The unique identifier to attribute these memories to."
+    }
+  },
+  "configSchema": {
+    "type": "object",
+    "properties": {
+      "apiKey": {
+        "type": "string",
+        "title": "API Key",
+        "description": "Memori API Key"
+      },
+      "entityId": {
+        "type": "string",
+        "title": "Entity ID",
+        "description": "Required. Hardcode a specific Entity ID for memories."
+      }
+    },
+    "required": []
+  }
+}

package/package.json

@@ -1,7 +1,71 @@
 {
   "name": "@memorilabs/openclaw-memori",
-  "version": "0.0.1-beta",
-  "private": false,
-  "publishConfig": { "access": "public" }
+  "version": "0.0.1",
+  "description": "Official MemoriLabs.ai long-term memory plugin for OpenClaw",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "openclaw.plugin.json"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "build:dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "check": "npm run format:check && npm run lint && npm run typecheck",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  },
+  "peerDependencies": {
+    "openclaw": "^2026.3.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "@types/node": "^20.0.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^9.0.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-tsdoc": "^0.5.1",
+    "prettier": "^3.0.0",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.0.0",
+    "vitest": "^4.0.18"
+  },
+  "keywords": [
+    "openclaw",
+    "plugin",
+    "memory",
+    "memori",
+    "long-term-memory"
+  ],
+  "author": "Memori Labs",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MemoriLabs/Memori.git",
+    "directory": "integrations/openclaw"
+  },
+  "bugs": {
+    "url": "https://github.com/MemoriLabs/Memori/issues"
+  },
+  "homepage": "https://github.com/MemoriLabs/Memori",
+  "openclaw": {
+    "extensions": [
+      "./dist/index.js"
+    ]
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "dependencies": {
+    "@memorilabs/memori": "^0.0.5"
+  },
+  "overrides": {
+    "@hono/node-server": "^1.19.10"
+  }
 }
-