@ztorchan/openclaw-mem0 0.3.3

package/dist/index.js

@@ -0,0 +1,1058 @@
+// index.ts
+import { Type } from "@sinclair/typebox";
+var PlatformProvider = class {
+  constructor(apiKey, orgId, projectId) {
+    this.apiKey = apiKey;
+    this.orgId = orgId;
+    this.projectId = projectId;
+  }
+  client;
+  // MemoryClient from mem0ai
+  initPromise = null;
+  async ensureClient() {
+    if (this.client) return;
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = this._init();
+    return this.initPromise;
+  }
+  async _init() {
+    const { default: MemoryClient } = await import("@ztorchan/mem0ai");
+    const opts = { apiKey: this.apiKey };
+    if (this.orgId) opts.org_id = this.orgId;
+    if (this.projectId) opts.project_id = this.projectId;
+    this.client = new MemoryClient(opts);
+  }
+  async add(messages, options) {
+    await this.ensureClient();
+    const opts = { user_id: options.user_id };
+    if (options.run_id) opts.run_id = options.run_id;
+    if (options.custom_instructions)
+      opts.custom_instructions = options.custom_instructions;
+    if (options.custom_categories)
+      opts.custom_categories = options.custom_categories;
+    if (options.enable_graph) opts.enable_graph = options.enable_graph;
+    if (options.output_format) opts.output_format = options.output_format;
+    if (options.source) opts.source = options.source;
+    const result = await this.client.add(messages, opts);
+    return normalizeAddResult(result);
+  }
+  async search(query, options) {
+    await this.ensureClient();
+    const filters = { user_id: options.user_id };
+    if (options.run_id) filters.run_id = options.run_id;
+    const opts = {
+      api_version: "v2",
+      filters
+    };
+    if (options.top_k != null) opts.top_k = options.top_k;
+    if (options.threshold != null) opts.threshold = options.threshold;
+    if (options.keyword_search != null) opts.keyword_search = options.keyword_search;
+    if (options.reranking != null) opts.rerank = options.reranking;
+    const results = await this.client.search(query, opts);
+    return normalizeSearchResults(results);
+  }
+  async get(memoryId) {
+    await this.ensureClient();
+    const result = await this.client.get(memoryId);
+    return normalizeMemoryItem(result);
+  }
+  async getAll(options) {
+    await this.ensureClient();
+    const opts = { user_id: options.user_id };
+    if (options.run_id) opts.run_id = options.run_id;
+    if (options.page_size != null) opts.page_size = options.page_size;
+    if (options.source) opts.source = options.source;
+    const results = await this.client.getAll(opts);
+    if (Array.isArray(results)) return results.map(normalizeMemoryItem);
+    if (results?.results && Array.isArray(results.results))
+      return results.results.map(normalizeMemoryItem);
+    return [];
+  }
+  async delete(memoryId) {
+    await this.ensureClient();
+    await this.client.delete(memoryId);
+  }
+};
+var OSSProvider = class {
+  constructor(ossConfig, customPrompt, resolvePath) {
+    this.ossConfig = ossConfig;
+    this.customPrompt = customPrompt;
+    this.resolvePath = resolvePath;
+  }
+  memory;
+  // Memory from mem0ai/oss
+  initPromise = null;
+  async ensureMemory() {
+    if (this.memory) return;
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = this._init();
+    return this.initPromise;
+  }
+  async _init() {
+    const { Memory } = await import("@ztorchan/mem0ai/oss");
+    const config = { version: "v1.1" };
+    if (this.ossConfig?.embedder) config.embedder = this.ossConfig.embedder;
+    if (this.ossConfig?.vectorStore)
+      config.vectorStore = this.ossConfig.vectorStore;
+    if (this.ossConfig?.llm) config.llm = this.ossConfig.llm;
+    if (this.ossConfig?.historyDbPath) {
+      const dbPath = this.resolvePath ? this.resolvePath(this.ossConfig.historyDbPath) : this.ossConfig.historyDbPath;
+      config.historyDbPath = dbPath;
+    }
+    if (this.customPrompt) config.customPrompt = this.customPrompt;
+    this.memory = new Memory(config);
+  }
+  async add(messages, options) {
+    await this.ensureMemory();
+    const addOpts = { userId: options.user_id };
+    if (options.run_id) addOpts.runId = options.run_id;
+    if (options.source) addOpts.source = options.source;
+    const result = await this.memory.add(messages, addOpts);
+    return normalizeAddResult(result);
+  }
+  async search(query, options) {
+    await this.ensureMemory();
+    const opts = { userId: options.user_id };
+    if (options.run_id) opts.runId = options.run_id;
+    if (options.limit != null) opts.limit = options.limit;
+    else if (options.top_k != null) opts.limit = options.top_k;
+    if (options.keyword_search != null) opts.keyword_search = options.keyword_search;
+    if (options.reranking != null) opts.reranking = options.reranking;
+    if (options.source) opts.source = options.source;
+    if (options.threshold != null) opts.threshold = options.threshold;
+    const results = await this.memory.search(query, opts);
+    const normalized = normalizeSearchResults(results);
+    if (options.threshold != null) {
+      return normalized.filter((item) => (item.score ?? 0) >= options.threshold);
+    }
+    return normalized;
+  }
+  async get(memoryId) {
+    await this.ensureMemory();
+    const result = await this.memory.get(memoryId);
+    return normalizeMemoryItem(result);
+  }
+  async getAll(options) {
+    await this.ensureMemory();
+    const getAllOpts = { userId: options.user_id };
+    if (options.run_id) getAllOpts.runId = options.run_id;
+    if (options.source) getAllOpts.source = options.source;
+    const results = await this.memory.getAll(getAllOpts);
+    if (Array.isArray(results)) return results.map(normalizeMemoryItem);
+    if (results?.results && Array.isArray(results.results))
+      return results.results.map(normalizeMemoryItem);
+    return [];
+  }
+  async delete(memoryId) {
+    await this.ensureMemory();
+    await this.memory.delete(memoryId);
+  }
+};
+function normalizeMemoryItem(raw) {
+  return {
+    id: raw.id ?? raw.memory_id ?? "",
+    memory: raw.memory ?? raw.text ?? raw.content ?? "",
+    // Handle both platform (user_id, created_at) and OSS (userId, createdAt) field names
+    user_id: raw.user_id ?? raw.userId,
+    score: raw.score,
+    categories: raw.categories,
+    metadata: raw.metadata,
+    created_at: raw.created_at ?? raw.createdAt,
+    updated_at: raw.updated_at ?? raw.updatedAt
+  };
+}
+function normalizeSearchResults(raw) {
+  if (Array.isArray(raw)) return raw.map(normalizeMemoryItem);
+  if (raw?.results && Array.isArray(raw.results))
+    return raw.results.map(normalizeMemoryItem);
+  return [];
+}
+function normalizeAddResult(raw) {
+  if (raw?.results && Array.isArray(raw.results)) {
+    return {
+      results: raw.results.map((r) => ({
+        id: r.id ?? r.memory_id ?? "",
+        memory: r.memory ?? r.text ?? "",
+        // Platform API may return PENDING status (async processing)
+        // OSS stores event in metadata.event
+        event: r.event ?? r.metadata?.event ?? (r.status === "PENDING" ? "ADD" : "ADD")
+      }))
+    };
+  }
+  if (Array.isArray(raw)) {
+    return {
+      results: raw.map((r) => ({
+        id: r.id ?? r.memory_id ?? "",
+        memory: r.memory ?? r.text ?? "",
+        event: r.event ?? r.metadata?.event ?? (r.status === "PENDING" ? "ADD" : "ADD")
+      }))
+    };
+  }
+  return { results: [] };
+}
+function resolveEnvVars(value) {
+  return value.replace(/\$\{([^}]+)\}/g, (_, envVar) => {
+    const envValue = process.env[envVar];
+    if (!envValue) {
+      throw new Error(`Environment variable ${envVar} is not set`);
+    }
+    return envValue;
+  });
+}
+function resolveEnvVarsDeep(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value === "string") {
+      result[key] = resolveEnvVars(value);
+    } else if (value && typeof value === "object" && !Array.isArray(value)) {
+      result[key] = resolveEnvVarsDeep(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+var DEFAULT_CUSTOM_INSTRUCTIONS = `Your Task: Extract and maintain a structured, evolving profile of the user from their conversations with an AI assistant. Capture information that would help the assistant provide personalized, context-aware responses in future interactions.
+
+Information to Extract:
+
+1. Identity & Demographics:
+   - Name, age, location, timezone, language preferences
+   - Occupation, employer, job role, industry
+   - Education background
+
+2. Preferences & Opinions:
+   - Communication style preferences (formal/casual, verbose/concise)
+   - Tool and technology preferences (languages, frameworks, editors, OS)
+   - Content preferences (topics of interest, learning style)
+   - Strong opinions or values they've expressed
+   - Likes and dislikes they've explicitly stated
+
+3. Goals & Projects:
+   - Current projects they're working on (name, description, status)
+   - Short-term and long-term goals
+   - Deadlines and milestones mentioned
+   - Problems they're actively trying to solve
+
+4. Technical Context:
+   - Tech stack and tools they use
+   - Skill level in different areas (beginner/intermediate/expert)
+   - Development environment and setup details
+   - Recurring technical challenges
+
+5. Relationships & People:
+   - Names and roles of people they mention (colleagues, family, friends)
+   - Team structure and dynamics
+   - Key contacts and their relevance
+
+6. Decisions & Lessons:
+   - Important decisions made and their reasoning
+   - Lessons learned from past experiences
+   - Strategies that worked or failed
+   - Changed opinions or updated beliefs
+
+7. Routines & Habits:
+   - Daily routines and schedules mentioned
+   - Work patterns (when they're productive, how they organize work)
+   - Health and wellness habits if voluntarily shared
+
+8. Life Events:
+   - Significant events (new job, moving, milestones)
+   - Upcoming events or plans
+   - Changes in circumstances
+
+Guidelines:
+- Store memories as clear, self-contained statements (each memory should make sense on its own)
+- Use third person: "User prefers..." not "I prefer..."
+- Include temporal context when relevant: "As of [date], user is working on..."
+- When information updates, UPDATE the existing memory rather than creating duplicates
+- Merge related facts into single coherent memories when possible
+- Preserve specificity: "User uses Next.js 14 with App Router" is better than "User uses React"
+- Capture the WHY behind preferences when stated: "User prefers Vim because of keyboard-driven workflow"
+
+Exclude:
+- Passwords, API keys, tokens, or any authentication credentials
+- Exact financial amounts (account balances, salaries) unless the user explicitly asks to remember them
+- Temporary or ephemeral information (one-time questions, debugging sessions with no lasting insight)
+- Generic small talk with no informational content
+- The assistant's own responses unless they contain a commitment or promise to the user
+- Raw code snippets (capture the intent/decision, not the code itself)
+- Information the user explicitly asks not to remember`;
+var DEFAULT_CUSTOM_CATEGORIES = {
+  identity: "Personal identity information: name, age, location, timezone, occupation, employer, education, demographics",
+  preferences: "Explicitly stated likes, dislikes, preferences, opinions, and values across any domain",
+  goals: "Current and future goals, aspirations, objectives, targets the user is working toward",
+  projects: "Specific projects, initiatives, or endeavors the user is working on, including status and details",
+  technical: "Technical skills, tools, tech stack, development environment, programming languages, frameworks",
+  decisions: "Important decisions made, reasoning behind choices, strategy changes, and their outcomes",
+  relationships: "People mentioned by the user: colleagues, family, friends, their roles and relevance",
+  routines: "Daily habits, work patterns, schedules, productivity routines, health and wellness habits",
+  life_events: "Significant life events, milestones, transitions, upcoming plans and changes",
+  lessons: "Lessons learned, insights gained, mistakes acknowledged, changed opinions or beliefs",
+  work: "Work-related context: job responsibilities, workplace dynamics, career progression, professional challenges",
+  health: "Health-related information voluntarily shared: conditions, medications, fitness, wellness goals"
+};
+var ALLOWED_KEYS = [
+  "mode",
+  "apiKey",
+  "userId",
+  "orgId",
+  "projectId",
+  "autoCapture",
+  "autoRecall",
+  "customInstructions",
+  "customCategories",
+  "customPrompt",
+  "enableGraph",
+  "searchThreshold",
+  "topK",
+  "oss"
+];
+function assertAllowedKeys(value, allowed, label) {
+  const unknown = Object.keys(value).filter((key) => !allowed.includes(key));
+  if (unknown.length === 0) return;
+  throw new Error(`${label} has unknown keys: ${unknown.join(", ")}`);
+}
+var mem0ConfigSchema = {
+  parse(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error("openclaw-mem0 config required");
+    }
+    const cfg = value;
+    assertAllowedKeys(cfg, ALLOWED_KEYS, "openclaw-mem0 config");
+    const mode = cfg.mode === "oss" || cfg.mode === "open-source" ? "open-source" : "platform";
+    if (mode === "platform") {
+      if (typeof cfg.apiKey !== "string" || !cfg.apiKey) {
+        throw new Error(
+          'apiKey is required for platform mode (set mode: "open-source" for self-hosted)'
+        );
+      }
+    }
+    let ossConfig;
+    if (cfg.oss && typeof cfg.oss === "object" && !Array.isArray(cfg.oss)) {
+      ossConfig = resolveEnvVarsDeep(
+        cfg.oss
+      );
+    }
+    return {
+      mode,
+      apiKey: typeof cfg.apiKey === "string" ? resolveEnvVars(cfg.apiKey) : void 0,
+      userId: typeof cfg.userId === "string" && cfg.userId ? cfg.userId : "default",
+      orgId: typeof cfg.orgId === "string" ? cfg.orgId : void 0,
+      projectId: typeof cfg.projectId === "string" ? cfg.projectId : void 0,
+      autoCapture: cfg.autoCapture !== false,
+      autoRecall: cfg.autoRecall !== false,
+      customInstructions: typeof cfg.customInstructions === "string" ? cfg.customInstructions : DEFAULT_CUSTOM_INSTRUCTIONS,
+      customCategories: cfg.customCategories && typeof cfg.customCategories === "object" && !Array.isArray(cfg.customCategories) ? cfg.customCategories : DEFAULT_CUSTOM_CATEGORIES,
+      customPrompt: typeof cfg.customPrompt === "string" ? cfg.customPrompt : DEFAULT_CUSTOM_INSTRUCTIONS,
+      enableGraph: cfg.enableGraph === true,
+      searchThreshold: typeof cfg.searchThreshold === "number" ? cfg.searchThreshold : 0.5,
+      topK: typeof cfg.topK === "number" ? cfg.topK : 5,
+      oss: ossConfig
+    };
+  }
+};
+function createProvider(cfg, api) {
+  if (cfg.mode === "open-source") {
+    return new OSSProvider(
+      cfg.oss,
+      cfg.customPrompt,
+      (p) => api.resolvePath(p)
+    );
+  }
+  return new PlatformProvider(cfg.apiKey, cfg.orgId, cfg.projectId);
+}
+function categoriesToArray(cats) {
+  return Object.entries(cats).map(([key, value]) => ({ [key]: value }));
+}
+function extractAgentId(sessionKey) {
+  if (!sessionKey) return void 0;
+  const match = sessionKey.match(/^agent:([^:]+):/);
+  const agentId = match?.[1];
+  if (!agentId || agentId === "main") return void 0;
+  return agentId;
+}
+function effectiveUserId(baseUserId, sessionKey) {
+  const agentId = extractAgentId(sessionKey);
+  return agentId ? `${baseUserId}:agent:${agentId}` : baseUserId;
+}
+function agentUserId(baseUserId, agentId) {
+  return `${baseUserId}:agent:${agentId}`;
+}
+function resolveUserId(baseUserId, opts, currentSessionId) {
+  if (opts.agentId) return agentUserId(baseUserId, opts.agentId);
+  if (opts.userId) return opts.userId;
+  return effectiveUserId(baseUserId, currentSessionId);
+}
+var memoryPlugin = {
+  id: "openclaw-mem0",
+  name: "Memory (Mem0)",
+  description: "Mem0 memory backend \u2014 Mem0 platform or self-hosted open-source",
+  kind: "memory",
+  configSchema: mem0ConfigSchema,
+  register(api) {
+    const cfg = mem0ConfigSchema.parse(api.pluginConfig);
+    const provider = createProvider(cfg, api);
+    let currentSessionId;
+    const _effectiveUserId = (sessionKey) => effectiveUserId(cfg.userId, sessionKey);
+    const _agentUserId = (id) => agentUserId(cfg.userId, id);
+    const _resolveUserId = (opts) => resolveUserId(cfg.userId, opts, currentSessionId);
+    api.logger.info(
+      `openclaw-mem0: registered (mode: ${cfg.mode}, user: ${cfg.userId}, graph: ${cfg.enableGraph}, autoRecall: ${cfg.autoRecall}, autoCapture: ${cfg.autoCapture})`
+    );
+    function buildAddOptions(userIdOverride, runId, sessionKey) {
+      const opts = {
+        user_id: userIdOverride || _effectiveUserId(sessionKey),
+        source: "OPENCLAW"
+      };
+      if (runId) opts.run_id = runId;
+      if (cfg.mode === "platform") {
+        opts.custom_instructions = cfg.customInstructions;
+        opts.custom_categories = categoriesToArray(cfg.customCategories);
+        opts.enable_graph = cfg.enableGraph;
+        opts.output_format = "v1.1";
+      }
+      return opts;
+    }
+    function buildSearchOptions(userIdOverride, limit, runId, sessionKey) {
+      const opts = {
+        user_id: userIdOverride || _effectiveUserId(sessionKey),
+        top_k: limit ?? cfg.topK,
+        limit: limit ?? cfg.topK,
+        threshold: cfg.searchThreshold,
+        keyword_search: true,
+        reranking: true,
+        source: "OPENCLAW"
+      };
+      if (runId) opts.run_id = runId;
+      return opts;
+    }
+    api.registerTool(
+      {
+        name: "memory_search",
+        label: "Memory Search",
+        description: "Search through long-term memories stored in Mem0. 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)"
+            })
+          ),
+          agentId: Type.Optional(
+            Type.String({
+              description: 'Agent ID to search memories for a specific agent (e.g. "researcher"). Overrides 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, agentId, scope = "all" } = params;
+          try {
+            let results = [];
+            const uid = _resolveUserId({ agentId, userId });
+            if (scope === "session") {
+              if (currentSessionId) {
+                results = await provider.search(
+                  query,
+                  buildSearchOptions(uid, limit, currentSessionId)
+                );
+              }
+            } else if (scope === "long-term") {
+              results = await provider.search(
+                query,
+                buildSearchOptions(uid, limit)
+              );
+            } else {
+              const longTermResults = await provider.search(
+                query,
+                buildSearchOptions(uid, limit)
+              );
+              let sessionResults = [];
+              if (currentSessionId) {
+                sessionResults = await provider.search(
+                  query,
+                  buildSearchOptions(uid, limit, currentSessionId)
+                );
+              }
+              const seen = new Set(longTermResults.map((r) => r.id));
+              results = [
+                ...longTermResults,
+                ...sessionResults.filter((r) => !seen.has(r.id))
+              ];
+            }
+            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.memory} (score: ${((r.score ?? 0) * 100).toFixed(0)}%, id: ${r.id})`
+            ).join("\n");
+            const sanitized = results.map((r) => ({
+              id: r.id,
+              memory: r.memory,
+              score: r.score,
+              categories: r.categories,
+              created_at: r.created_at
+            }));
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Found ${results.length} memories:
+
+${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 Mem0. 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"
+            })
+          ),
+          agentId: Type.Optional(
+            Type.String({
+              description: `Agent ID to store memory under a specific agent's namespace (e.g. "researcher"). Overrides userId.`
+            })
+          ),
+          metadata: Type.Optional(
+            Type.Record(Type.String(), Type.Unknown(), {
+              description: "Optional metadata to attach to this memory"
+            })
+          ),
+          longTerm: Type.Optional(
+            Type.Boolean({
+              description: "Store as long-term (user-scoped) memory. Default: true. Set to false for session-scoped memory."
+            })
+          )
+        }),
+        async execute(_toolCallId, params) {
+          const { text, userId, agentId, longTerm = true } = params;
+          try {
+            const uid = _resolveUserId({ agentId, userId });
+            const runId = !longTerm && currentSessionId ? currentSessionId : void 0;
+            const result = await provider.add(
+              [{ role: "user", content: text }],
+              buildAddOptions(uid, runId, currentSessionId)
+            );
+            const added = result.results?.filter((r) => r.event === "ADD") ?? [];
+            const updated = result.results?.filter((r) => r.event === "UPDATE") ?? [];
+            const summary = [];
+            if (added.length > 0)
+              summary.push(
+                `${added.length} new memor${added.length === 1 ? "y" : "ies"} added`
+              );
+            if (updated.length > 0)
+              summary.push(
+                `${updated.length} memor${updated.length === 1 ? "y" : "ies"} updated`
+              );
+            if (summary.length === 0)
+              summary.push("No new memories extracted");
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Stored: ${summary.join(", ")}. ${result.results?.map((r) => `[${r.event}] ${r.memory}`).join("; ") ?? ""}`
+                }
+              ],
+              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 Mem0.",
+        parameters: Type.Object({
+          memoryId: Type.String({ description: "The memory ID to retrieve" })
+        }),
+        async execute(_toolCallId, params) {
+          const { memoryId } = params;
+          try {
+            const memory = await provider.get(memoryId);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Memory ${memory.id}:
+${memory.memory}
+
+Created: ${memory.created_at ?? "unknown"}
+Updated: ${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 or agent. 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)"
+            })
+          ),
+          agentId: Type.Optional(
+            Type.String({
+              description: 'Agent ID to list memories for a specific agent (e.g. "researcher"). Overrides 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, agentId, scope = "all" } = params;
+          try {
+            let memories = [];
+            const uid = _resolveUserId({ agentId, userId });
+            if (scope === "session") {
+              if (currentSessionId) {
+                memories = await provider.getAll({
+                  user_id: uid,
+                  run_id: currentSessionId,
+                  source: "OPENCLAW"
+                });
+              }
+            } else if (scope === "long-term") {
+              memories = await provider.getAll({ user_id: uid, source: "OPENCLAW" });
+            } else {
+              const longTerm = await provider.getAll({ user_id: uid, source: "OPENCLAW" });
+              let session = [];
+              if (currentSessionId) {
+                session = await provider.getAll({
+                  user_id: uid,
+                  run_id: currentSessionId,
+                  source: "OPENCLAW"
+                });
+              }
+              const seen = new Set(longTerm.map((r) => r.id));
+              memories = [
+                ...longTerm,
+                ...session.filter((r) => !seen.has(r.id))
+              ];
+            }
+            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.memory} (id: ${r.id})`
+            ).join("\n");
+            const sanitized = memories.map((r) => ({
+              id: r.id,
+              memory: r.memory,
+              categories: r.categories,
+              created_at: r.created_at
+            }));
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `${memories.length} memories:
+
+${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 memories from Mem0. Provide a specific memoryId to delete directly, or a query to search and delete matching memories. Supports agent-scoped deletion. GDPR-compliant.",
+        parameters: Type.Object({
+          query: Type.Optional(
+            Type.String({
+              description: "Search query to find memory to delete"
+            })
+          ),
+          memoryId: Type.Optional(
+            Type.String({ description: "Specific memory ID to delete" })
+          ),
+          agentId: Type.Optional(
+            Type.String({
+              description: `Agent ID to scope deletion to a specific agent's memories (e.g. "researcher").`
+            })
+          )
+        }),
+        async execute(_toolCallId, params) {
+          const { query, memoryId, agentId } = params;
+          try {
+            if (memoryId) {
+              await provider.delete(memoryId);
+              return {
+                content: [
+                  { type: "text", text: `Memory ${memoryId} forgotten.` }
+                ],
+                details: { action: "deleted", id: memoryId }
+              };
+            }
+            if (query) {
+              const uid = _resolveUserId({ agentId });
+              const results = await provider.search(
+                query,
+                buildSearchOptions(uid, 5)
+              );
+              if (!results || results.length === 0) {
+                return {
+                  content: [
+                    { type: "text", text: "No matching memories found." }
+                  ],
+                  details: { found: 0 }
+                };
+              }
+              if (results.length === 1 || (results[0].score ?? 0) > 0.9) {
+                await provider.delete(results[0].id);
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: `Forgotten: "${results[0].memory}"`
+                    }
+                  ],
+                  details: { action: "deleted", id: results[0].id }
+                };
+              }
+              const list = results.map(
+                (r) => `- [${r.id}] ${r.memory.slice(0, 80)}${r.memory.length > 80 ? "..." : ""} (score: ${((r.score ?? 0) * 100).toFixed(0)}%)`
+              ).join("\n");
+              const candidates = results.map((r) => ({
+                id: r.id,
+                memory: r.memory,
+                score: r.score
+              }));
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Found ${results.length} candidates. Specify memoryId to delete:
+${list}`
+                  }
+                ],
+                details: { action: "candidates", candidates }
+              };
+            }
+            return {
+              content: [
+                { type: "text", text: "Provide a query or memoryId." }
+              ],
+              details: { error: "missing_param" }
+            };
+          } catch (err) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Memory forget failed: ${String(err)}`
+                }
+              ],
+              details: { error: String(err) }
+            };
+          }
+        }
+      },
+      { name: "memory_forget" }
+    );
+    api.registerCli(
+      ({ program }) => {
+        const mem0 = program.command("mem0").description("Mem0 memory plugin commands");
+        mem0.command("search").description("Search memories in Mem0").argument("<query>", "Search query").option("--limit <n>", "Max results", String(cfg.topK)).option("--scope <scope>", 'Memory scope: "session", "long-term", or "all"', "all").option("--agent <agentId>", "Search a specific agent's memory namespace").action(async (query, opts) => {
+          try {
+            const limit = parseInt(opts.limit, 10);
+            const scope = opts.scope;
+            const uid = opts.agent ? _agentUserId(opts.agent) : _effectiveUserId(currentSessionId);
+            let allResults = [];
+            if (scope === "session" || scope === "all") {
+              if (currentSessionId) {
+                const sessionResults = await provider.search(
+                  query,
+                  buildSearchOptions(uid, limit, currentSessionId)
+                );
+                if (sessionResults?.length) {
+                  allResults.push(...sessionResults.map((r) => ({ ...r, _scope: "session" })));
+                }
+              } else if (scope === "session") {
+                console.log("No active session ID available for session-scoped search.");
+                return;
+              }
+            }
+            if (scope === "long-term" || scope === "all") {
+              const longTermResults = await provider.search(
+                query,
+                buildSearchOptions(uid, limit)
+              );
+              if (longTermResults?.length) {
+                allResults.push(...longTermResults.map((r) => ({ ...r, _scope: "long-term" })));
+              }
+            }
+            if (scope === "all") {
+              const seen = /* @__PURE__ */ new Set();
+              allResults = allResults.filter((r) => {
+                if (seen.has(r.id)) return false;
+                seen.add(r.id);
+                return true;
+              });
+            }
+            if (!allResults.length) {
+              console.log("No memories found.");
+              return;
+            }
+            const output = allResults.map((r) => ({
+              id: r.id,
+              memory: r.memory,
+              score: r.score,
+              scope: r._scope,
+              categories: r.categories,
+              created_at: r.created_at
+            }));
+            console.log(JSON.stringify(output, null, 2));
+          } catch (err) {
+            console.error(`Search failed: ${String(err)}`);
+          }
+        });
+        mem0.command("stats").description("Show memory statistics from Mem0").option("--agent <agentId>", "Show stats for a specific agent").action(async (opts) => {
+          try {
+            const uid = opts.agent ? _agentUserId(opts.agent) : cfg.userId;
+            const memories = await provider.getAll({
+              user_id: uid,
+              source: "OPENCLAW"
+            });
+            console.log(`Mode: ${cfg.mode}`);
+            console.log(`User: ${uid}${opts.agent ? ` (agent: ${opts.agent})` : ""}`);
+            console.log(
+              `Total memories: ${Array.isArray(memories) ? memories.length : "unknown"}`
+            );
+            console.log(`Graph enabled: ${cfg.enableGraph}`);
+            console.log(
+              `Auto-recall: ${cfg.autoRecall}, Auto-capture: ${cfg.autoCapture}`
+            );
+          } catch (err) {
+            console.error(`Stats failed: ${String(err)}`);
+          }
+        });
+      },
+      { commands: ["mem0"] }
+    );
+    if (cfg.autoRecall) {
+      api.on("before_agent_start", async (event, ctx) => {
+        if (!event.prompt || event.prompt.length < 5) return;
+        const sessionId = ctx?.sessionKey ?? void 0;
+        if (sessionId) currentSessionId = sessionId;
+        try {
+          const longTermResults = await provider.search(
+            event.prompt,
+            buildSearchOptions(void 0, void 0, void 0, sessionId)
+          );
+          let sessionResults = [];
+          if (currentSessionId) {
+            sessionResults = await provider.search(
+              event.prompt,
+              buildSearchOptions(void 0, void 0, currentSessionId, sessionId)
+            );
+          }
+          const longTermIds = new Set(longTermResults.map((r) => r.id));
+          const uniqueSessionResults = sessionResults.filter(
+            (r) => !longTermIds.has(r.id)
+          );
+          if (longTermResults.length === 0 && uniqueSessionResults.length === 0) return;
+          let memoryContext = "";
+          if (longTermResults.length > 0) {
+            memoryContext += longTermResults.map(
+              (r) => `- ${r.memory}${r.categories?.length ? ` [${r.categories.join(", ")}]` : ""}`
+            ).join("\n");
+          }
+          if (uniqueSessionResults.length > 0) {
+            if (memoryContext) memoryContext += "\n";
+            memoryContext += "\nSession memories:\n";
+            memoryContext += uniqueSessionResults.map((r) => `- ${r.memory}`).join("\n");
+          }
+          const totalCount = longTermResults.length + uniqueSessionResults.length;
+          api.logger.info(
+            `openclaw-mem0: injecting ${totalCount} memories into context (${longTermResults.length} long-term, ${uniqueSessionResults.length} session)`
+          );
+          return {
+            prependContext: `<relevant-memories>
+The following memories may be relevant to this conversation:
+${memoryContext}
+</relevant-memories>`
+          };
+        } catch (err) {
+          api.logger.warn(`openclaw-mem0: recall failed: ${String(err)}`);
+        }
+      });
+    }
+    if (cfg.autoCapture) {
+      api.on("agent_end", async (event, ctx) => {
+        if (!event.success || !event.messages || event.messages.length === 0) {
+          return;
+        }
+        const sessionId = ctx?.sessionKey ?? void 0;
+        if (sessionId) currentSessionId = sessionId;
+        try {
+          const recentMessages = event.messages.slice(-10);
+          const formattedMessages = [];
+          for (const msg of recentMessages) {
+            if (!msg || typeof msg !== "object") continue;
+            const msgObj = msg;
+            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.text === "string") {
+                  textContent += (textContent ? "\n" : "") + block.text;
+                }
+              }
+            }
+            if (!textContent) continue;
+            if (textContent.includes("<relevant-memories>")) {
+              textContent = textContent.replace(/<relevant-memories>[\s\S]*?<\/relevant-memories>\s*/g, "").trim();
+              if (!textContent) continue;
+            }
+            formattedMessages.push({
+              role,
+              content: textContent
+            });
+          }
+          if (formattedMessages.length === 0) return;
+          const addOpts = buildAddOptions(void 0, currentSessionId, sessionId);
+          const result = await provider.add(
+            formattedMessages,
+            addOpts
+          );
+          const capturedCount = result.results?.length ?? 0;
+          if (capturedCount > 0) {
+            api.logger.info(
+              `openclaw-mem0: auto-captured ${capturedCount} memories`
+            );
+          }
+        } catch (err) {
+          api.logger.warn(`openclaw-mem0: capture failed: ${String(err)}`);
+        }
+      });
+    }
+    api.registerService({
+      id: "openclaw-mem0",
+      start: () => {
+        api.logger.info(
+          `openclaw-mem0: initialized (mode: ${cfg.mode}, user: ${cfg.userId}, autoRecall: ${cfg.autoRecall}, autoCapture: ${cfg.autoCapture})`
+        );
+      },
+      stop: () => {
+        api.logger.info("openclaw-mem0: stopped");
+      }
+    });
+  }
+};
+var index_default = memoryPlugin;
+export {
+  agentUserId,
+  index_default as default,
+  effectiveUserId,
+  extractAgentId,
+  resolveUserId
+};
+//# sourceMappingURL=index.js.map