memorylake-openclaw 0.0.0 → 0.0.3

package/.github/workflows/release.yml

@@ -0,0 +1,23 @@
+name: Publish Package to npmjs
+on:
+  # Trigger on tag push
+  push:
+    tags:
+      - 'v*.*.*'
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v5
+      # Setup .npmrc file to publish to npm
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '24.x'
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm i && npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Powerdrill Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/LICENSES/Apache-2.0.txt

@@ -0,0 +1,176 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction,
+and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by
+the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all
+other entities that control, are controlled by, or are under common
+control with that entity. For the purposes of this definition,
+"control" means (i) the power, direct or indirect, to cause the
+direction or management of such entity, whether by contract or
+otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity
+exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation
+source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical
+transformation or translation of a Source form, including but
+not limited to compiled object code, generated documentation,
+and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or
+Object form, made available under the License, as indicated by a
+copyright notice that is included in or attached to the work
+(an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object
+form, that is based on (or derived from) the Work and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship. For the purposes
+of this License, Derivative Works shall not include works that remain
+separable from, or merely link (or bind by name) to the interfaces of,
+the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including
+the original version of the Work and any modifications or additions
+to that Work or Derivative Works thereof, that is intentionally
+submitted to Licensor for inclusion in the Work by the copyright owner
+or by an individual or Legal Entity authorized to submit on behalf of
+the copyright owner. For the purposes of this definition, "submitted"
+means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems,
+and issue tracking systems that are managed by, or on behalf of, the
+Licensor for the purpose of discussing and improving the Work, but
+excluding communication that is conspicuously marked or otherwise
+designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity
+on behalf of whom a Contribution has been received by Licensor and
+subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the
+Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+(except as stated in this section) patent license to make, have made,
+use, offer to sell, sell, import, and otherwise transfer the Work,
+where such license applies only to those patent claims licensable
+by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s)
+with the Work to which such Contribution(s) was submitted. If You
+institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work
+or a Contribution incorporated within the Work constitutes direct
+or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate
+as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+Work or Derivative Works thereof in any medium, with or without
+modifications, and in Source or Object form, provided that You
+meet the following conditions:
+
+(a) You must give any other recipients of the Work or
+Derivative Works a copy of this License; and
+
+(b) You must cause any modified files to carry prominent notices
+stating that You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works
+that You distribute, all copyright, patent, trademark, and
+attribution notices from the Source form of the Work,
+excluding those notices that do not pertain to any part of
+the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its
+distribution, then any Derivative Works that You distribute must
+include a readable copy of the attribution notices contained
+within such NOTICE file, excluding those notices that do not
+pertain to any part of the Derivative Works, in at least one
+of the following places: within a NOTICE text file distributed
+as part of the Derivative Works; within the Source form or
+documentation, if provided along with the Derivative Works; or,
+within a display generated by the Derivative Works, if and
+wherever such third-party notices normally appear. The contents
+of the NOTICE file are for informational purposes only and
+do not modify the License. You may add Your own attribution
+notices within Derivative Works that You distribute, alongside
+or as an addendum to the NOTICE text from the Work, provided
+that such additional attribution notices cannot be construed
+as modifying the License.
+
+You may add Your own copyright statement to Your modifications and
+may provide additional or different license terms and conditions
+for use, reproduction, or distribution of Your modifications, or
+for any such Derivative Works as a whole, provided Your use,
+reproduction, and distribution of the Work otherwise complies with
+the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+any Contribution intentionally submitted for inclusion in the Work
+by You to the Licensor shall be under the terms and conditions of
+this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify
+the terms of any separate license agreement you may have executed
+with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+names, trademarks, service marks, or product names of the Licensor,
+except as required for reasonable and customary use in describing the
+origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+agreed to in writing, Licensor provides the Work (and each
+Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied, including, without limitation, any warranties or conditions
+of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any
+risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+whether in tort (including negligence), contract, or otherwise,
+unless required by applicable law (such as deliberate and grossly
+negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special,
+incidental, or consequential damages of any character arising as a
+result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill,
+work stoppage, computer failure or malfunction, or any and all
+other commercial damages or losses), even if such Contributor
+has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+the Work or Derivative Works thereof, You may choose to offer,
+and charge a fee for, acceptance of support, warranty, indemnity,
+or other liability obligations and/or rights consistent with this
+License. However, in accepting such obligations, You may act only
+on Your own behalf and on Your sole responsibility, not on behalf
+of any other Contributor, and only if You agree to indemnify,
+defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason
+of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

package/NOTICE

@@ -0,0 +1,30 @@
+MemoryLake
+Copyright (c) 2025-2026 MemoryLake Team
+
+This product includes software developed by third parties.
+
+We would like to express our sincere gratitude to all open-source projects and
+their contributors whose work has been incorporated into MemoryLake. Their
+excellent contributions have been instrumental in accelerating our development
+and building a better product for the community.
+
+================================================================================
+
+Portions of this software are derived from mem0 (https://github.com/mem0ai/mem0)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+The following files in this project contain code derived from mem0:
+- memorylake/mem0/**
+
+These files have been largely modified from their original versions.

package/README.md

@@ -0,0 +1,77 @@
+# memorylake-openclaw
+
+Long-term memory for [OpenClaw](https://github.com/openclaw/openclaw) agents, powered by [MemoryLake](https://app.memorylake.ai).
+
+Your agent forgets everything between sessions. This plugin fixes that. It watches conversations, extracts what matters, and brings it back when relevant — automatically.
+
+## How it works
+
+<!-- <p align="center">
+  <img src="../docs/images/openclaw-architecture.png" alt="Architecture" width="800" />
+</p> -->
+
+**Auto-Recall** — Before the agent responds, the plugin searches MemoryLake for memories that match the current message and injects them into context.
+
+**Auto-Capture** — After the agent responds, the plugin sends the exchange to MemoryLake. MemoryLake decides what's worth keeping — new facts get stored, stale ones updated, duplicates merged.
+
+Both run silently. No prompting, no configuration, no manual calls.
+
+## Setup
+
+```bash
+openclaw plugins install memorylake-openclaw
+```
+
+Get an API key from [app.memorylake.ai](https://app.memorylake.ai), then add to your `openclaw.json`:
+
+```json5
+// plugins.entries
+"memorylake-openclaw": {
+  "enabled": true,
+  "config": {
+    "apiKey": "${MEMORYLAKE_API_KEY}",
+    "projectId": "proj-...",
+    "userId": "your-user-id"
+  }
+}
+```
+
+## Agent tools
+
+The agent gets five tools it can call during conversations:
+
+| Tool | Description |
+|------|-------------|
+| `memory_search` | Search memories by natural language |
+| `memory_list` | List all stored memories for a user |
+| `memory_store` | Explicitly save a fact |
+| `memory_get` | Retrieve a memory by ID |
+| `memory_forget` | Delete a memory by ID |
+
+## CLI
+
+```bash
+# Search memories
+openclaw memorylake search "what languages does the user know"
+
+# Stats
+openclaw memorylake stats
+```
+
+## Options
+
+| Key | Type | Default | |
+|-----|------|---------|---|
+| `apiKey` | `string` | — | **Required.** MemoryLake API key (supports `${MEMORYLAKE_API_KEY}`) |
+| `projectId` | `string` | — | **Required.** MemoryLake project ID |
+| `host` | `string` | `https://app.memorylake.ai` | MemoryLake server endpoint URL |
+| `userId` | `string` | `"default"` | Scope memories per user |
+| `autoRecall` | `boolean` | `true` | Inject memories before each turn |
+| `autoCapture` | `boolean` | `true` | Store facts after each turn |
+| `topK` | `number` | `5` | Max memories per recall |
+| `searchThreshold` | `number` | `0.3` | Min similarity (0–1) |
+| `rerank` | `boolean` | `true` | Rerank search results |
+
+## License
+
+MIT

package/docs/openclaw.mdx

@@ -0,0 +1,98 @@
+---
+title: OpenClaw
+---
+
+Add long-term memory to [OpenClaw](https://github.com/openclaw/openclaw) agents with the `memorylake-openclaw` plugin. Your agent forgets everything between sessions — this plugin fixes that by automatically watching conversations, extracting what matters, and bringing it back when relevant.
+
+## Overview
+
+{/*<Frame>
+  <img src="/images/openclaw-architecture.png" alt="OpenClaw MemoryLake Architecture" />
+</Frame>*/}
+
+The plugin provides:
+1. **Auto-Recall** — Before the agent responds, memories matching the current message are injected into context
+2. **Auto-Capture** — After the agent responds, the exchange is sent to MemoryLake which decides what's worth keeping
+3. **Agent Tools** — Five tools for explicit memory operations during conversations
+
+Both auto-recall and auto-capture run silently with no manual configuration required.
+
+## Installation
+
+```bash
+openclaw plugins install memorylake-openclaw
+```
+
+## Setup and Configuration
+
+<Note>Get your API key and project ID from [app.memorylake.ai](https://app.memorylake.ai).</Note>
+
+Add to your `openclaw.json`:
+
+```json5
+// plugins.entries
+"memorylake-openclaw": {
+  "enabled": true,
+  "config": {
+    "apiKey": "${MEMORYLAKE_API_KEY}",
+    "projectId": "proj-...",
+    "userId": "your-user-id"
+  }
+}
+```
+
+## Agent Tools
+
+The agent gets five tools it can call during conversations:
+
+| Tool | Description |
+|------|-------------|
+| `memory_search` | Search memories by natural language |
+| `memory_list` | List all stored memories for a user |
+| `memory_store` | Explicitly save a fact |
+| `memory_get` | Retrieve a memory by ID |
+| `memory_forget` | Delete a memory by ID |
+
+## CLI Commands
+
+```bash
+# Search memories
+openclaw memorylake search "what languages does the user know"
+
+# View stats
+openclaw memorylake stats
+```
+
+## Configuration Options
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `apiKey` | `string` | — | **Required.** MemoryLake API key (supports `${MEMORYLAKE_API_KEY}`) |
+| `projectId` | `string` | — | **Required.** MemoryLake project ID |
+| `host` | `string` | `https://app.memorylake.ai` | MemoryLake server endpoint URL |
+| `userId` | `string` | `"default"` | Scope memories per user |
+| `autoRecall` | `boolean` | `true` | Inject memories before each turn |
+| `autoCapture` | `boolean` | `true` | Store facts after each turn |
+| `topK` | `number` | `5` | Max memories per recall |
+| `searchThreshold` | `number` | `0.3` | Min similarity (0–1) |
+| `rerank` | `boolean` | `true` | Rerank search results for better relevance |
+
+## Key Features
+
+1. **Zero Configuration** — Auto-recall and auto-capture work out of the box with no prompting required
+2. **Async Processing** — Memory extraction runs asynchronously via MemoryLake's API
+3. **Session Tracking** — Conversations are tagged with `chat_session_id` for traceability
+4. **Rich Tool Suite** — Five agent tools for explicit memory operations when needed
+
+## Conclusion
+
+The `memorylake-openclaw` plugin gives OpenClaw agents persistent memory with minimal setup. Your agents can remember user preferences, facts, and context across sessions automatically.
+
+{/*<CardGroup cols={2}>
+  <Card title="MemoryLake" icon="brain" href="https://app.memorylake.ai">
+    MemoryLake platform
+  </Card>
+  <Card title="OpenClaw" icon="robot" href="https://github.com/openclaw/openclaw">
+    OpenClaw agent framework
+  </Card>
+</CardGroup>*/}

package/index.ts

@@ -0,0 +1,832 @@
+/**
+ * OpenClaw Memory (MemoryLake) Plugin
+ *
+ * Long-term memory via MemoryLake platform.
+ *
+ * Features:
+ * - 5 tools: memory_search, memory_list, memory_store, memory_get, memory_forget
+ * - Auto-recall: injects relevant memories (both scopes) before each agent turn
+ * - Auto-capture: stores key facts scoped to the current session after each agent turn
+ * - CLI: openclaw memorylake search, openclaw memorylake stats
+ */
+
+import got from "got";
+import { Type } from "@sinclair/typebox";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+type MemoryLakeConfig = {
+  host: string;
+  apiKey: string;
+  projectId: string;
+  userId: string;
+  autoCapture: boolean;
+  autoRecall: boolean;
+  searchThreshold: number;
+  topK: number;
+  rerank: boolean;
+};
+
+// V2 API option types
+interface AddOptions {
+  user_id: string;
+  chat_session_id?: string;
+  metadata?: Record<string, unknown>;
+  infer?: boolean;
+}
+
+interface SearchOptions {
+  user_id: string;
+  top_k?: number;
+  threshold?: number;
+  rerank?: boolean;
+}
+
+interface ListOptions {
+  user_id?: string;
+  page?: number;
+  size?: number;
+}
+
+interface MemoryItem {
+  id: string;
+  content: string;
+  user_id?: string;
+  created_at?: string;
+  updated_at?: string;
+}
+
+interface AddResultItem {
+  event_id: string;
+  status: string;
+  message: string;
+}
+
+interface AddResult {
+  results: AddResultItem[];
+}
+
+// ============================================================================
+// Unified Provider Interface
+// ============================================================================
+
+interface MemoryLakeProvider {
+  add(
+    messages: Array<{ role: string; content: string }>,
+    options: AddOptions,
+  ): Promise<AddResult>;
+  search(query: string, options: SearchOptions): Promise<MemoryItem[]>;
+  get(memoryId: string): Promise<MemoryItem>;
+  getAll(options: ListOptions): Promise<MemoryItem[]>;
+  delete(memoryId: string): Promise<void>;
+}
+
+// ============================================================================
+// Platform Provider (MemoryLake Cloud)
+// ============================================================================
+
+interface ApiResponse<T = unknown> {
+  success: boolean;
+  message?: string;
+  data?: T;
+  error_code?: string;
+}
+
+class PlatformProvider implements MemoryLakeProvider {
+  private readonly http: ReturnType<typeof got.extend>;
+  private readonly basePath: string;
+
+  constructor(host: string, apiKey: string, projectId: string) {
+    this.basePath = `openapi/memorylake/api/v2/projects/${projectId}/memories`;
+    this.http = got.extend({
+      prefixUrl: host,
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+      },
+      responseType: "json",
+    });
+  }
+
+  async add(
+    messages: Array<{ role: string; content: string }>,
+    options: AddOptions,
+  ): Promise<AddResult> {
+    const body: Record<string, unknown> = {
+      messages,
+      user_id: options.user_id,
+      infer: options.infer ?? true,
+    };
+    if (options.chat_session_id) body.chat_session_id = options.chat_session_id;
+    if (options.metadata) body.metadata = options.metadata;
+
+    const resp = await this.http
+      .post(this.basePath, { json: body })
+      .json<ApiResponse>();
+    if (!resp.success) throw new Error(resp.message ?? "add failed");
+    return normalizeAddResult(resp.data);
+  }
+
+  async search(query: string, options: SearchOptions): Promise<MemoryItem[]> {
+    const body: Record<string, unknown> = {
+      query,
+      user_id: options.user_id,
+    };
+    if (options.top_k != null) body.top_k = options.top_k;
+    if (options.threshold != null) body.threshold = options.threshold;
+    if (options.rerank != null) body.rerank = options.rerank;
+
+    const resp = await this.http
+      .post(`${this.basePath}/search`, { json: body })
+      .json<ApiResponse>();
+    if (!resp.success) throw new Error(resp.message ?? "search failed");
+    return normalizeSearchResults(resp.data);
+  }
+
+  async get(memoryId: string): Promise<MemoryItem> {
+    const resp = await this.http
+      .get(`${this.basePath}/${memoryId}`)
+      .json<ApiResponse>();
+    if (!resp.success) throw new Error(resp.message ?? "get failed");
+    return normalizeMemoryItem(resp.data);
+  }
+
+  async getAll(options: ListOptions): Promise<MemoryItem[]> {
+    const searchParams: Record<string, string | number> = {};
+    if (options.user_id) searchParams.user_id = options.user_id;
+    if (options.page != null) searchParams.page = options.page;
+    if (options.size != null) searchParams.size = options.size;
+
+    const resp = await this.http
+      .get(this.basePath, { searchParams })
+      .json<ApiResponse>();
+    if (!resp.success) throw new Error(resp.message ?? "getAll failed");
+    const data = resp.data as any;
+    if (data?.items && Array.isArray(data.items))
+      return data.items.map(normalizeMemoryItem);
+    return [];
+  }
+
+  async delete(memoryId: string): Promise<void> {
+    const resp = await this.http
+      .delete(`${this.basePath}/${memoryId}`)
+      .json<ApiResponse>();
+    if (!resp.success) throw new Error(resp.message ?? "delete failed");
+  }
+}
+
+// ============================================================================
+// Result Normalizers
+// ============================================================================
+
+function normalizeMemoryItem(raw: any): MemoryItem {
+  return {
+    id: raw.id ?? "",
+    content: raw.content ?? "",
+    user_id: raw.user_id,
+    created_at: raw.created_at,
+    updated_at: raw.updated_at,
+  };
+}
+
+function normalizeSearchResults(raw: any): MemoryItem[] {
+  if (raw?.results && Array.isArray(raw.results))
+    return raw.results.map(normalizeMemoryItem);
+  if (Array.isArray(raw)) return raw.map(normalizeMemoryItem);
+  return [];
+}
+
+function normalizeAddResult(raw: any): AddResult {
+  const items = raw?.results ?? (Array.isArray(raw) ? raw : []);
+  return {
+    results: items.map((r: any) => ({
+      event_id: r.event_id ?? "",
+      status: r.status ?? "",
+      message: r.message ?? "",
+    })),
+  };
+}
+
+// ============================================================================
+// Config Parser
+// ============================================================================
+
+// ============================================================================
+// Config Schema
+// ============================================================================
+
+const ALLOWED_KEYS = [
+  "host",
+  "apiKey",
+  "projectId",
+  "userId",
+  "autoCapture",
+  "autoRecall",
+  "searchThreshold",
+  "topK",
+  "rerank",
+];
+
+function assertAllowedKeys(
+  value: Record<string, unknown>,
+  allowed: string[],
+  label: string,
+) {
+  const unknown = Object.keys(value).filter((key) => !allowed.includes(key));
+  if (unknown.length === 0) return;
+  throw new Error(`${label} has unknown keys: ${unknown.join(", ")}`);
+}
+
+const memoryLakeConfigSchema = {
+  parse(value: unknown): MemoryLakeConfig {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error("memorylake-openclaw config required");
+    }
+    const cfg = value as Record<string, unknown>;
+    assertAllowedKeys(cfg, ALLOWED_KEYS, "memorylake-openclaw config");
+
+    if (typeof cfg.apiKey !== "string" || !cfg.apiKey) {
+      throw new Error("apiKey is required");
+    }
+    if (typeof cfg.projectId !== "string" || !cfg.projectId) {
+      throw new Error("projectId is required");
+    }
+
+    return {
+      host:
+        typeof cfg.host === "string" && cfg.host
+          ? cfg.host
+          : "https://app.memorylake.ai",
+      apiKey: cfg.apiKey as string,
+      projectId: cfg.projectId as string,
+      userId:
+        typeof cfg.userId === "string" && cfg.userId ? cfg.userId : "default",
+      autoCapture: cfg.autoCapture !== false,
+      autoRecall: cfg.autoRecall !== false,
+      searchThreshold:
+        typeof cfg.searchThreshold === "number" ? cfg.searchThreshold : 0.3,
+      topK: typeof cfg.topK === "number" ? cfg.topK : 5,
+      rerank: cfg.rerank !== false,
+    };
+  },
+};
+
+// ============================================================================
+// Plugin Definition
+// ============================================================================
+
+const memoryPlugin = {
+  id: "memorylake-openclaw",
+  name: "Memory (MemoryLake)",
+  description: "MemoryLake memory backend for OpenClaw",
+  kind: "memory" as const,
+  configSchema: memoryLakeConfigSchema,
+
+  register(api: OpenClawPluginApi) {
+    const cfg = memoryLakeConfigSchema.parse(api.pluginConfig);
+    const provider: MemoryLakeProvider = new PlatformProvider(cfg.host, cfg.apiKey, cfg.projectId);
+
+    // Track current session ID for tool-level session scoping
+    let currentSessionId: string | undefined;
+
+    api.logger.info(
+      `memorylake-openclaw: registered (user: ${cfg.userId}, autoRecall: ${cfg.autoRecall}, autoCapture: ${cfg.autoCapture})`,
+    );
+
+    // Helper: build add options
+    function buildAddOptions(userIdOverride?: string, sessionId?: string): AddOptions {
+      const opts: AddOptions = {
+        user_id: userIdOverride || cfg.userId,
+        infer: true,
+        metadata: { source: "OPENCLAW" },
+      };
+      if (sessionId) opts.chat_session_id = sessionId;
+      return opts;
+    }
+
+    // Helper: build search options
+    function buildSearchOptions(
+      userIdOverride?: string,
+      limit?: number,
+    ): SearchOptions {
+      return {
+        user_id: userIdOverride || cfg.userId,
+        top_k: limit ?? cfg.topK,
+        threshold: cfg.searchThreshold,
+        rerank: cfg.rerank,
+      };
+    }
+
+    // ========================================================================
+    // Tools
+    // ========================================================================
+
+    api.registerTool(
+      {
+        name: "memory_search",
+        label: "Memory Search",
+        description:
+          "Search through long-term memories stored in MemoryLake. Use when you need context about user preferences, past decisions, or previously discussed topics.",
+        parameters: Type.Object({
+          query: Type.String({ description: "Search query" }),
+          limit: Type.Optional(
+            Type.Number({
+              description: `Max results (default: ${cfg.topK})`,
+            }),
+          ),
+          userId: Type.Optional(
+            Type.String({
+              description:
+                "User ID to scope search (default: configured userId)",
+            }),
+          ),
+          scope: Type.Optional(
+            Type.Union([
+              Type.Literal("session"),
+              Type.Literal("long-term"),
+              Type.Literal("all"),
+            ], {
+              description:
+                'Memory scope: "session" (current session only), "long-term" (user-scoped only), or "all" (both). Default: "all"',
+            }),
+          ),
+        }),
+        async execute(_toolCallId, params) {
+          const { query, limit, userId, scope = "all" } = params as {
+            query: string;
+            limit?: number;
+            userId?: string;
+            scope?: "session" | "long-term" | "all";
+          };
+
+          try {
+            const results = await provider.search(
+              query,
+              buildSearchOptions(userId, limit),
+            );
+
+            if (!results || results.length === 0) {
+              return {
+                content: [
+                  { type: "text", text: "No relevant memories found." },
+                ],
+                details: { count: 0 },
+              };
+            }
+
+            const text = results
+              .map(
+                (r, i) =>
+                  `${i + 1}. ${r.content} (id: ${r.id})`,
+              )
+              .join("\n");
+
+            const sanitized = results.map((r) => ({
+              id: r.id,
+              content: r.content,
+              created_at: r.created_at,
+            }));
+
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Found ${results.length} memories:\n\n${text}`,
+                },
+              ],
+              details: { count: results.length, memories: sanitized },
+            };
+          } catch (err) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Memory search failed: ${String(err)}`,
+                },
+              ],
+              details: { error: String(err) },
+            };
+          }
+        },
+      },
+      { name: "memory_search" },
+    );
+
+    api.registerTool(
+      {
+        name: "memory_store",
+        label: "Memory Store",
+        description:
+          "Save important information in long-term memory via MemoryLake. Use for preferences, facts, decisions, and anything worth remembering.",
+        parameters: Type.Object({
+          text: Type.String({ description: "Information to remember" }),
+          userId: Type.Optional(
+            Type.String({
+              description: "User ID to scope this memory",
+            }),
+          ),
+          metadata: Type.Optional(
+            Type.Record(Type.String(), Type.Unknown(), {
+              description: "Optional metadata to attach to this memory",
+            }),
+          ),
+        }),
+        async execute(_toolCallId, params) {
+          const { text, userId } = params as {
+            text: string;
+            userId?: string;
+            metadata?: Record<string, unknown>;
+          };
+
+          try {
+            const result = await provider.add(
+              [{ role: "user", content: text }],
+              buildAddOptions(userId, currentSessionId),
+            );
+
+            const count = result.results?.length ?? 0;
+
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: count > 0
+                    ? `Submitted ${count} memory task(s) for processing. ${result.results.map((r) => `[${r.status}] ${r.message}`).join("; ")}`
+                    : "No memories extracted.",
+                },
+              ],
+              details: {
+                action: "stored",
+                results: result.results,
+              },
+            };
+          } catch (err) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Memory store failed: ${String(err)}`,
+                },
+              ],
+              details: { error: String(err) },
+            };
+          }
+        },
+      },
+      { name: "memory_store" },
+    );
+
+    api.registerTool(
+      {
+        name: "memory_get",
+        label: "Memory Get",
+        description: "Retrieve a specific memory by its ID from MemoryLake.",
+        parameters: Type.Object({
+          memoryId: Type.String({ description: "The memory ID to retrieve" }),
+        }),
+        async execute(_toolCallId, params) {
+          const { memoryId } = params as { memoryId: string };
+
+          try {
+            const memory = await provider.get(memoryId);
+
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Memory ${memory.id}:\n${memory.content}\n\nCreated: ${memory.created_at ?? "unknown"}\nUpdated: ${memory.updated_at ?? "unknown"}`,
+                },
+              ],
+              details: { memory },
+            };
+          } catch (err) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Memory get failed: ${String(err)}`,
+                },
+              ],
+              details: { error: String(err) },
+            };
+          }
+        },
+      },
+      { name: "memory_get" },
+    );
+
+    api.registerTool(
+      {
+        name: "memory_list",
+        label: "Memory List",
+        description:
+          "List all stored memories for a user. Use this when you want to see everything that's been remembered, rather than searching for something specific.",
+        parameters: Type.Object({
+          userId: Type.Optional(
+            Type.String({
+              description:
+                "User ID to list memories for (default: configured userId)",
+            }),
+          ),
+          scope: Type.Optional(
+            Type.Union([
+              Type.Literal("session"),
+              Type.Literal("long-term"),
+              Type.Literal("all"),
+            ], {
+              description:
+                'Memory scope: "session" (current session only), "long-term" (user-scoped only), or "all" (both). Default: "all"',
+            }),
+          ),
+        }),
+        async execute(_toolCallId, params) {
+          const { userId, scope = "all" } = params as { userId?: string; scope?: "session" | "long-term" | "all" };
+
+          try {
+            const uid = userId || cfg.userId;
+            const memories = await provider.getAll({ user_id: uid });
+
+            if (!memories || memories.length === 0) {
+              return {
+                content: [
+                  { type: "text", text: "No memories stored yet." },
+                ],
+                details: { count: 0 },
+              };
+            }
+
+            const text = memories
+              .map(
+                (r, i) =>
+                  `${i + 1}. ${r.content} (id: ${r.id})`,
+              )
+              .join("\n");
+
+            const sanitized = memories.map((r) => ({
+              id: r.id,
+              content: r.content,
+              created_at: r.created_at,
+            }));
+
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `${memories.length} memories:\n\n${text}`,
+                },
+              ],
+              details: { count: memories.length, memories: sanitized },
+            };
+          } catch (err) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Memory list failed: ${String(err)}`,
+                },
+              ],
+              details: { error: String(err) },
+            };
+          }
+        },
+      },
+      { name: "memory_list" },
+    );
+
+    api.registerTool(
+      {
+        name: "memory_forget",
+        label: "Memory Forget",
+        description:
+          "Delete a specific memory by ID from MemoryLake.",
+        parameters: Type.Object({
+          memoryId: Type.String({ description: "Memory ID to delete" }),
+        }),
+        async execute(_toolCallId, params) {
+          const { memoryId } = params as { memoryId: string };
+
+          try {
+            await provider.delete(memoryId);
+            return {
+              content: [
+                { type: "text", text: `Memory ${memoryId} forgotten.` },
+              ],
+              details: { action: "deleted", id: memoryId },
+            };
+          } catch (err) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Memory forget failed: ${String(err)}`,
+                },
+              ],
+              details: { error: String(err) },
+            };
+          }
+        },
+      },
+      { name: "memory_forget" },
+    );
+
+    // ========================================================================
+    // CLI Commands
+    // ========================================================================
+
+    api.registerCli(
+      ({ program }) => {
+        const memorylake = program
+          .command("memorylake")
+          .description("MemoryLake memory plugin commands");
+
+        memorylake
+          .command("search")
+          .description("Search memories in MemoryLake")
+          .argument("<query>", "Search query")
+          .option("--limit <n>", "Max results", String(cfg.topK))
+          .action(async (query: string, opts: { limit: string }) => {
+            try {
+              const limit = parseInt(opts.limit, 10);
+              const results = await provider.search(
+                query,
+                buildSearchOptions(undefined, limit),
+              );
+
+              if (!results.length) {
+                console.log("No memories found.");
+                return;
+              }
+
+              const output = results.map((r) => ({
+                id: r.id,
+                content: r.content,
+                user_id: r.user_id,
+                created_at: r.created_at,
+              }));
+              console.log(JSON.stringify(output, null, 2));
+            } catch (err) {
+              console.error(`Search failed: ${String(err)}`);
+            }
+          });
+
+        memorylake
+          .command("stats")
+          .description("Show memory statistics from MemoryLake")
+          .action(async () => {
+            try {
+              const memories = await provider.getAll({
+                user_id: cfg.userId,
+              });
+              console.log(`User: ${cfg.userId}`);
+              console.log(
+                `Total memories: ${Array.isArray(memories) ? memories.length : "unknown"}`,
+              );
+              console.log(
+                `Auto-recall: ${cfg.autoRecall}, Auto-capture: ${cfg.autoCapture}`,
+              );
+            } catch (err) {
+              console.error(`Stats failed: ${String(err)}`);
+            }
+          });
+      },
+      { commands: ["memorylake"] },
+    );
+
+    // ========================================================================
+    // Lifecycle Hooks
+    // ========================================================================
+
+    // Auto-recall: inject relevant memories before agent starts
+    if (cfg.autoRecall) {
+      api.on("before_agent_start", async (event, ctx) => {
+        if (!event.prompt || event.prompt.length < 5) return;
+
+        // Track session ID
+        const sessionId = (ctx as any)?.sessionKey ?? undefined;
+        if (sessionId) currentSessionId = sessionId;
+
+        try {
+          const results = await provider.search(
+            event.prompt,
+            buildSearchOptions(),
+          );
+
+          if (results.length === 0) return;
+
+          const memoryContext = results
+            .map((r) => `- ${r.content}`)
+            .join("\n");
+
+          api.logger.info(
+            `memorylake-openclaw: injecting ${results.length} memories into context`,
+          );
+
+          return {
+            prependContext: `<relevant-memories>\nThe following memories may be relevant to this conversation:\n${memoryContext}\n</relevant-memories>`,
+          };
+        } catch (err) {
+          api.logger.warn(`memorylake-openclaw: recall failed: ${String(err)}`);
+        }
+      });
+    }
+
+    // Auto-capture: store conversation context after agent ends
+    if (cfg.autoCapture) {
+      api.on("agent_end", async (event, ctx) => {
+        if (!event.success || !event.messages || event.messages.length === 0) {
+          return;
+        }
+
+        // Track session ID
+        const sessionId = (ctx as any)?.sessionKey ?? undefined;
+        if (sessionId) currentSessionId = sessionId;
+
+        try {
+          // Extract messages, limiting to last 10
+          const recentMessages = event.messages.slice(-10);
+          const formattedMessages: Array<{
+            role: string;
+            content: string;
+          }> = [];
+
+          for (const msg of recentMessages) {
+            if (!msg || typeof msg !== "object") continue;
+            const msgObj = msg as Record<string, unknown>;
+
+            const role = msgObj.role;
+            if (role !== "user" && role !== "assistant") continue;
+
+            let textContent = "";
+            const content = msgObj.content;
+
+            if (typeof content === "string") {
+              textContent = content;
+            } else if (Array.isArray(content)) {
+              for (const block of content) {
+                if (
+                  block &&
+                  typeof block === "object" &&
+                  "text" in block &&
+                  typeof (block as Record<string, unknown>).text === "string"
+                ) {
+                  textContent +=
+                    (textContent ? "\n" : "") +
+                    ((block as Record<string, unknown>).text as string);
+                }
+              }
+            }
+
+            if (!textContent) continue;
+            // Strip injected memory context, keep the actual user text
+            if (textContent.includes("<relevant-memories>")) {
+              textContent = textContent.replace(/<relevant-memories>[\s\S]*?<\/relevant-memories>\s*/g, "").trim();
+              if (!textContent) continue;
+            }
+
+            formattedMessages.push({
+              role: role as string,
+              content: textContent,
+            });
+          }
+
+          if (formattedMessages.length === 0) return;
+
+          const addOpts = buildAddOptions(undefined, currentSessionId);
+          const result = await provider.add(
+            formattedMessages,
+            addOpts,
+          );
+
+          const capturedCount = result.results?.length ?? 0;
+          if (capturedCount > 0) {
+            api.logger.info(
+              `memorylake-openclaw: auto-captured ${capturedCount} memories`,
+            );
+          }
+        } catch (err) {
+          api.logger.warn(`memorylake-openclaw: capture failed: ${String(err)}`);
+        }
+      });
+    }
+
+    // ========================================================================
+    // Service
+    // ========================================================================
+
+    api.registerService({
+      id: "memorylake-openclaw",
+      start: () => {
+        api.logger.info(
+          `memorylake-openclaw: initialized (user: ${cfg.userId}, autoRecall: ${cfg.autoRecall}, autoCapture: ${cfg.autoCapture})`,
+        );
+      },
+      stop: () => {
+        api.logger.info("memorylake-openclaw: stopped");
+      },
+    });
+  },
+};
+
+export default memoryPlugin;

package/openclaw.plugin.json

@@ -0,0 +1,78 @@
+{
+  "id": "memorylake-openclaw",
+  "kind": "memory",
+  "uiHints": {
+    "apiKey": {
+      "label": "MemoryLake API Key",
+      "sensitive": true,
+      "placeholder": "sk-...",
+      "help": "API key from app.memorylake.ai (or use ${MEMORYLAKE_API_KEY})."
+    },
+    "projectId": {
+      "label": "Project ID",
+      "placeholder": "proj-...",
+      "help": "MemoryLake project ID. Required for all memory operations."
+    },
+    "userId": {
+      "label": "Default User ID",
+      "placeholder": "default",
+      "help": "User ID for scoping memories"
+    },
+    "autoCapture": {
+      "label": "Auto-Capture",
+      "help": "Automatically store conversation context after each agent turn"
+    },
+    "autoRecall": {
+      "label": "Auto-Recall",
+      "help": "Automatically inject relevant memories before each agent turn"
+    },
+    "searchThreshold": {
+      "label": "Search Threshold",
+      "placeholder": "0.3",
+      "help": "Minimum similarity score for search results (0-1). Default: 0.3"
+    },
+    "topK": {
+      "label": "Top K Results",
+      "placeholder": "5",
+      "help": "Maximum number of memories to retrieve"
+    },
+    "rerank": {
+      "label": "Rerank",
+      "help": "Rerank search results"
+    }
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "host": {
+        "type": "string"
+      },
+      "apiKey": {
+        "type": "string"
+      },
+      "projectId": {
+        "type": "string"
+      },
+      "userId": {
+        "type": "string"
+      },
+      "autoCapture": {
+        "type": "boolean"
+      },
+      "autoRecall": {
+        "type": "boolean"
+      },
+      "searchThreshold": {
+        "type": "number"
+      },
+      "topK": {
+        "type": "number"
+      },
+      "rerank": {
+        "type": "boolean"
+      }
+    },
+    "required": []
+  }
+}

package/package.json

@@ -1,12 +1,27 @@
 {
   "name": "memorylake-openclaw",
-  "version": "0.0.0",
-  "description": "",
+  "version": "0.0.3",
+  "type": "module",
+  "description": "MemoryLake memory backend for OpenClaw",
   "license": "MIT",
-  "author": "",
-  "type": "commonjs",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/memorylake-ai/memorylake-openclaw.git"
+  },
+  "keywords": [
+    "openclaw",
+    "plugin",
+    "memory",
+    "memorylake",
+    "long-term-memory"
+  ],
+  "dependencies": {
+    "@sinclair/typebox": "0.34.47",
+    "got": "^14.0.0"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ]
   }
 }