memory-search-plugin 0.10.0 → 1.2.0

package/index.js

@@ -1,101 +1,57 @@
-// index.ts
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 
-// gateway-client.ts
-function createGatewayClient(config) {
-  const baseUrl = config.gatewayUrl.replace(/\/+$/, "");
-  const token = config.gatewayToken || "";
-  const authHeaders = token ? { Authorization: `Bearer ${token}` } : {};
-  return {
-    async callGatewaySearch(options) {
-      const url = `${baseUrl}/api/memory/search`;
-      const response = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json", ...authHeaders },
-        body: JSON.stringify(options)
-      });
-      if (!response.ok) {
-        const errorBody = await response.text().catch(() => "");
-        throw new Error(
-          `Gateway search failed: ${response.status} ${response.statusText} ${errorBody}`
-        );
-      }
-      return response.json();
-    },
-    async callGatewayGet(options) {
-      const url = `${baseUrl}/api/memory/get`;
-      const response = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json", ...authHeaders },
-        body: JSON.stringify(options)
-      });
-      if (!response.ok) {
-        const errorBody = await response.text().catch(() => "");
-        throw new Error(
-          `Gateway get failed: ${response.status} ${response.statusText} ${errorBody}`
-        );
-      }
-      return response.json();
-    }
-  };
-}
-
 // identity.ts
-function resolveIdentityFromParams(params) {
+function resolveIdentity(params) {
   const testScene = process.env.MEMORY_GATEWAY_TEST_SCENE;
   if (testScene) {
-    const result = {
+    return {
       scene: testScene,
-      user_id: process.env.MEMORY_GATEWAY_TEST_USER_ID || "owner_A",
+      sender_id: process.env.MEMORY_GATEWAY_TEST_USER_ID || "test_user",
+      owner_id: process.env.MEMORY_GATEWAY_TEST_OWNER_ID || "test_owner",
       group_id: process.env.MEMORY_GATEWAY_TEST_GROUP_ID || null
     };
-    console.log("[memory-search-plugin] TEST MODE identity:", JSON.stringify(result));
-    return result;
   }
-  const userId = params.sender_id?.trim() || "unknown";
+  const senderId = params.sender_id?.trim() || "unknown";
+  const ownerId = params.owner_id?.trim() || "";
   const convType = (params.conversation_type || "direct").trim().toLowerCase();
-  if (convType === "group") {
-    return {
-      scene: "group",
-      user_id: userId,
-      group_id: params.group_id?.trim() || null
-    };
+  const groupId = params.group_id?.trim() || null;
+  if (!ownerId) {
+    console.warn(
+      "[identity] owner_id is empty — LLM failed to extract from UntrustedContext. owner queries will be skipped to prevent cross-user leak."
+    );
   }
-  if (isOwner(userId)) {
-    return { scene: "private_own", user_id: userId, group_id: null };
+  if (convType === "group") {
+    if (!groupId) {
+      console.warn("[identity] group scene but group_id is empty");
+    }
+    return { scene: "group", sender_id: senderId, owner_id: ownerId, group_id: groupId };
   }
-  return { scene: "private_other", user_id: userId, group_id: null };
+  return { scene: "owner", sender_id: senderId, owner_id: ownerId, group_id: null };
 }
-function resolveIdentity(sessionKey) {
-  const sk = sessionKey ?? "";
-  const sessionPart = sk.split(":").pop() || "";
-  const groupMatch = sessionPart.match(
-    /user_(.+?)_lobster_(.+?)_group_(.+?)_release_(.+)$/
-  );
-  if (groupMatch) {
-    return { scene: "group", user_id: groupMatch[1], group_id: groupMatch[3] };
-  }
-  const peerMatch = sessionPart.match(
-    /user_(.+?)_lobster_(.+?)_release_(.+)$/
-  );
-  if (peerMatch) {
-    const userId = peerMatch[1];
-    if (isOwner(userId)) {
-      return { scene: "private_own", user_id: userId, group_id: null };
+
+// gateway-client.ts
+function createGatewayClient(config) {
+  const baseUrl = config.gatewayUrl.replace(/\/+$/, "");
+  const headers = {
+    "Content-Type": "application/json",
+    ...config.gatewayToken ? { Authorization: `Bearer ${config.gatewayToken}` } : {}
+  };
+  async function post(path, body) {
+    const resp = await fetch(`${baseUrl}${path}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw new Error(`Gateway ${path} failed: ${resp.status} ${text}`);
     }
-    return { scene: "private_other", user_id: userId, group_id: null };
+    return resp.json();
   }
-  return { scene: "private_other", user_id: "unknown", group_id: null };
-}
-function isOwner(userId) {
-  const token = process.env.OPENCLAW_GATEWAY_TOKEN || "";
-  if (!token) return false;
-  const ownerUserId = token.split("-").pop() || "";
-  return ownerUserId !== "" && ownerUserId === userId;
-}
-function extractAgentId(sessionKey) {
-  const parts = (sessionKey || "").split(":");
-  return parts.length >= 2 ? parts[1] : "main";
+  return {
+    callGatewaySearch: (opts) => post("/api/memory/search", opts),
+    callGatewayGet: (opts) => post("/api/memory/get", opts)
+  };
 }
 
 // index.ts
@@ -103,90 +59,58 @@ var buildPromptSection = ({
   availableTools,
   citationsMode
 }) => {
-  const hasMemorySearch = availableTools.has("memory_search");
-  const hasMemoryGet = availableTools.has("memory_get");
-  if (!hasMemorySearch && !hasMemoryGet) return [];
-  let toolGuidance;
-  if (hasMemorySearch && hasMemoryGet) {
-    toolGuidance = "Before answering anything about prior work, decisions, dates, people, preferences, or todos: run memory_search for semantic search on MEMORY.md + memory/*.md; then use memory_get for keyword retrieval on only the needed content. If low confidence after search, say you checked.";
-  } else if (hasMemorySearch) {
-    toolGuidance = "Before answering anything about prior work, decisions, dates, people, preferences, or todos: run memory_search on MEMORY.md + memory/*.md and answer from the matching results. If low confidence after search, say you checked.";
-  } else {
-    toolGuidance = "Before answering anything about prior work, decisions, dates, people, preferences, or todos that already point to a specific memory file or note: run memory_get to pull only the needed lines. If low confidence after reading them, say you checked.";
-  }
-  const lines = ["## Memory Recall", toolGuidance];
-  lines.push(
-    "**Context extraction:** When calling memory_search or memory_get, you MUST fill in the agent_id, sender_id, conversation_type, and group_id parameters by extracting them from the UntrustedContext section in this conversation. Look for lines like `agent_id: xxx`, `sender_id: xxx`, `conversation_type: xxx`, `group_id: xxx`. If a field is not present, omit it."
-  );
-  if (citationsMode === "off") {
-    lines.push(
-      "Citations are disabled: do not mention file paths or line numbers in replies unless the user explicitly asks."
-    );
-  } else {
-    lines.push(
-      "Citations: include Source: <path#line> when it helps the user verify memory snippets."
-    );
-  }
-  lines.push("");
+  const hasSearch = availableTools.has("memory_search");
+  const hasGet = availableTools.has("memory_get");
+  if (!hasSearch && !hasGet) return [];
+  const lines = [
+    "## Memory Recall",
+    "Before answering anything about prior work, decisions, dates, people, preferences, or todos: run memory_search for semantic search. If low confidence after search, say you checked.",
+    "",
+    "**Context extraction:** When calling memory_search or memory_get, you MUST extract the following from the UntrustedContext section and pass as parameters: `owner_id`, `sender_id`, `agent_id`, `conversation_type`, `group_id`. Look for lines like `owner_id: xxx`, `sender_id: xxx`, etc. If a field is not present, omit it. Do NOT invent or guess values — only use what is explicitly stated in UntrustedContext.",
+    ""
+  ];
   return lines;
 };
-function isMemoryPath(path) {
-  const normalized = path.replace(/\\/g, "/").replace(/^\.\//, "");
-  return normalized === "MEMORY.md" || normalized.startsWith("memory/") || normalized.endsWith("/MEMORY.md") || normalized.includes("/memory/");
-}
-function formatSearchResults(results) {
-  if (results.length === 0) {
-    return "No relevant memories found.";
-  }
-  return results.map((r, i) => {
-    let sourceDesc = r.memory_type;
-    if (r.memory_type === "peer" && r.peer_id) {
-      sourceDesc = `peer/${r.peer_id}`;
-    } else if (r.memory_type === "group" && r.group_id) {
-      sourceDesc = `group/${r.group_id}`;
-    } else if (r.memory_type === "knowledge" && r.kb_id) {
-      sourceDesc = `knowledge/${r.kb_id}`;
-    }
-    const filePart = r.source_file ? ` | ${r.source_file}` : "";
-    const header = `[${i + 1}] (${sourceDesc}, score: ${r.score.toFixed(2)}${filePart})`;
-    return `${header}
-${r.content}`;
-  }).join("\n\n");
-}
+
 var index_default = definePluginEntry({
   id: "memory-search-plugin",
   name: "Memory Search Plugin",
-  description: "Routes memory to external Memory Search Gateway with ACL",
+  description: "Memory search and retrieval with owner_id-based isolation",
   kind: "memory",
+
   register(api) {
-    const gatewayUrl = api.pluginConfig?.gatewayUrl || "http://localhost:18790";
-    const gatewayToken = api.pluginConfig?.gatewayToken || "";
-    const ocToken = process.env.OPENCLAW_GATEWAY_TOKEN || "";
-    const releaseName = ocToken.startsWith("oc-") ? ocToken.slice(3) : "";
-    console.log("[memory-search-plugin] gatewayUrl:", gatewayUrl, "releaseName:", releaseName);
-    const gateway = createGatewayClient({ gatewayUrl, gatewayToken });
+    const gatewayUrl = api.pluginConfig?.gatewayUrl || process.env.MEMORY_GATEWAY_URL || "";
+    const gatewayToken = api.pluginConfig?.gatewayToken || process.env.MEMORY_GATEWAY_TOKEN || "";
+    const config = { gatewayUrl, gatewayToken };
+    if (!config.gatewayUrl) {
+      console.warn("[memory-search-plugin] MEMORY_GATEWAY_URL not set, plugin disabled");
+      return;
+    }
+    console.log("[memory-search-plugin] gatewayUrl:", gatewayUrl);
+    const gateway = createGatewayClient(config);
+
     api.registerMemoryPromptSection(buildPromptSection);
+
     api.registerTool(
       (ctx) => {
-        const fallbackIdentity = ctx.sessionKey ? resolveIdentity(ctx.sessionKey) : null;
-        const fallbackAgentId = ctx.sessionKey ? extractAgentId(ctx.sessionKey) : null;
         return {
           name: "memory_search",
-          description: "Semantically search MEMORY.md and memory/**/*.md for relevant memories. You MUST extract agent_id, sender_id, conversation_type, group_id from the UntrustedContext in this conversation and pass them as parameters.",
+          description: "Semantically search memories. Extract owner_id, sender_id, agent_id, conversation_type, group_id from UntrustedContext.",
           parameters: {
             type: "object",
             properties: {
-              query: {
+              query: { type: "string", description: "The search query" },
+              owner_id: {
                 type: "string",
-                description: "The search query"
+                description: "The owner_id from UntrustedContext (agent owner's user_id, always present)"
               },
-              agent_id: {
+              sender_id: {
                 type: "string",
-                description: "The agent_id from UntrustedContext (e.g. 'main' or 'lobster_xxx')"
+                description: "The sender_id from UntrustedContext (current message sender)"
               },
-              sender_id: {
+              agent_id: {
                 type: "string",
-                description: "The sender_id from UntrustedContext"
+                description: "The agent_id from UntrustedContext"
               },
               conversation_type: {
                 type: "string",
@@ -194,15 +118,15 @@ var index_default = definePluginEntry({
               },
               group_id: {
                 type: "string",
-                description: "The group_id from UntrustedContext (only present in group chats)"
+                description: "The group_id from UntrustedContext (only in group chats)"
               },
               maxResults: {
                 type: "number",
-                description: "Maximum number of results to return"
+                description: "Max results (default 20)"
               },
               minScore: {
                 type: "number",
-                description: "Minimum similarity score threshold"
+                description: "Min similarity score 0-1 (default 0.3)"
               }
             },
             required: ["query"]
@@ -214,51 +138,35 @@ var index_default = definePluginEntry({
                 content: [{ type: "text", text: "No query provided." }]
               };
             }
-            const agentId = params.agent_id?.trim() || fallbackAgentId || "main";
-            const identity = params.sender_id || params.conversation_type || params.group_id ? resolveIdentityFromParams({
+            const identity = resolveIdentity({
               sender_id: params.sender_id,
+              owner_id: params.owner_id,
               conversation_type: params.conversation_type,
               group_id: params.group_id
-            }) : fallbackIdentity || resolveIdentityFromParams({});
+            });
+            const agentId = params.agent_id?.trim() || "main";
             console.log(
-              `[memory-search-plugin] search: agent_id=${agentId} scene=${identity.scene} user_id=${identity.user_id} group_id=${identity.group_id} release_name=${releaseName} (source=${params.sender_id ? "llm_params" : "fallback"})`
+              `[memory-search] search: agent=${agentId} scene=${identity.scene} sender=${identity.sender_id} owner=${identity.owner_id} group=${identity.group_id}`
             );
             try {
               const data = await gateway.callGatewaySearch({
+                owner_id: identity.owner_id,
+                sender_id: identity.sender_id,
                 agent_id: agentId,
-                user_id: identity.user_id,
                 query,
                 scene: identity.scene,
                 group_id: identity.group_id,
-                release_name: releaseName || undefined,
                 limit: params.maxResults || 20,
                 threshold: params.minScore || 0.3
               });
-              const text = formatSearchResults(data.results);
-              return {
-                content: [{ type: "text", text }],
-                details: {
-                  results: data.results,
-                  total: data.total,
-                  scene: data.scene,
-                  steps: data.steps
-                }
-              };
+              const text = data.results.length === 0 ? "No relevant memories found." : data.results.map((r, i) => {
+                const tag = r.memory_type === "group" && r.group_id ? `group/${r.group_id}` : r.memory_type === "knowledge" && r.kb_id ? `knowledge/${r.kb_id}` : r.memory_type;
+                return `[${i + 1}] (${tag}, score: ${r.score.toFixed(2)})
+${r.content}`;
+              }).join("\n\n");
+              return { content: [{ type: "text", text }] };
             } catch (err) {
-              console.error("[memory-search-plugin] search failed:", err.message);
-              try {
-                const fallbackTool = api.runtime?.tools?.createMemorySearchTool({
-                  config: ctx.config,
-                  agentSessionKey: ctx.sessionKey
-                });
-                if (fallbackTool) {
-                  console.warn(
-                    "[memory-search-plugin] falling back to local memory_search"
-                  );
-                  return await fallbackTool.execute(toolCallId, { query, maxResults: params.maxResults, minScore: params.minScore });
-                }
-              } catch {
-              }
+              console.error("[memory-search] search failed:", err.message);
               return {
                 content: [
                   {
@@ -273,125 +181,92 @@ var index_default = definePluginEntry({
       },
       { names: ["memory_search"] }
     );
+
     api.registerTool(
       (ctx) => {
-        const fallbackIdentity = ctx.sessionKey ? resolveIdentity(ctx.sessionKey) : null;
-        const fallbackAgentId = ctx.sessionKey ? extractAgentId(ctx.sessionKey) : null;
         return {
           name: "memory_get",
-          description: "Read a memory file or workspace file. Supports reading MEMORY.md, memory/**/*.md, and other workspace files. You MUST extract agent_id, sender_id, conversation_type, group_id from the UntrustedContext in this conversation and pass them as parameters.",
+          description: "Search raw chat messages by keyword. Queries the original message log, not the extracted facts. Extract owner_id, sender_id, agent_id, conversation_type, group_id from UntrustedContext.",
           parameters: {
             type: "object",
             properties: {
-              path: {
+              keyword: {
                 type: "string",
-                description: "Relative path to the file (e.g. MEMORY.md, memory/notes.md, SOUL.md)"
+                description: "Keyword to search in chat messages"
               },
-              agent_id: {
+              owner_id: {
                 type: "string",
-                description: "The agent_id from UntrustedContext (e.g. 'main' or 'lobster_xxx')"
+                description: "The owner_id from UntrustedContext"
               },
               sender_id: {
                 type: "string",
                 description: "The sender_id from UntrustedContext"
               },
+              agent_id: {
+                type: "string",
+                description: "The agent_id from UntrustedContext"
+              },
               conversation_type: {
                 type: "string",
                 description: "The conversation_type from UntrustedContext: 'direct' or 'group'"
               },
               group_id: {
                 type: "string",
-                description: "The group_id from UntrustedContext (only present in group chats)"
+                description: "The group_id from UntrustedContext (only in group chats)"
               },
-              from: {
+              limit: {
                 type: "number",
-                description: "Starting line number (1-indexed)"
-              },
-              lines: {
-                type: "number",
-                description: "Number of lines to read"
+                description: "Max messages to return (default 20)"
               }
             },
-            required: ["path"]
+            required: ["keyword"]
           },
           async execute(toolCallId, params) {
-            const path = params.path || "";
-            if (!path) {
+            const keyword = params.keyword || "";
+            if (!keyword) {
               return {
-                content: [{ type: "text", text: "No path provided." }]
+                content: [{ type: "text", text: "No keyword provided." }]
               };
             }
-            let originalGetTool = null;
+            const identity = resolveIdentity({
+              sender_id: params.sender_id,
+              owner_id: params.owner_id,
+              conversation_type: params.conversation_type,
+              group_id: params.group_id
+            });
+            const agentId = params.agent_id?.trim() || "main";
+            console.log(
+              `[memory-search] get: keyword="${keyword}" agent=${agentId} scene=${identity.scene} owner=${identity.owner_id} group=${identity.group_id}`
+            );
             try {
-              originalGetTool = api.runtime?.tools?.createMemoryGetTool({
-                config: ctx.config,
-                agentSessionKey: ctx.sessionKey
+              const data = await gateway.callGatewayGet({
+                owner_id: identity.owner_id,
+                sender_id: identity.sender_id,
+                agent_id: agentId,
+                keyword,
+                scene: identity.scene,
+                group_id: identity.group_id,
+                limit: params.limit || 20
               });
-            } catch {
-            }
-            if (isMemoryPath(path)) {
-              const agentId = params.agent_id?.trim() || fallbackAgentId || "main";
-              const identity = params.sender_id || params.conversation_type || params.group_id ? resolveIdentityFromParams({
-                sender_id: params.sender_id,
-                conversation_type: params.conversation_type,
-                group_id: params.group_id
-              }) : fallbackIdentity || resolveIdentityFromParams({});
-              console.log(
-                `[memory-search-plugin] get: path=${path} agent_id=${agentId} scene=${identity.scene} user_id=${identity.user_id} release_name=${releaseName} (source=${params.sender_id ? "llm_params" : "fallback"})`
-              );
-              try {
-                const data = await gateway.callGatewayGet({
-                  agent_id: agentId,
-                  user_id: identity.user_id,
-                  path,
-                  scene: identity.scene,
-                  group_id: identity.group_id,
-                  release_name: releaseName || undefined,
-                  from: params.from,
-                  lines: params.lines
-                });
-                return {
-                  content: [{ type: "text", text: data.text }],
-                  details: { path: data.path, text: data.text }
-                };
-              } catch (err) {
-                console.error("[memory-search-plugin] get failed:", err.message);
-                if (err.message?.includes("403")) {
-                  return {
-                    content: [
-                      {
-                        type: "text",
-                        text: `Access denied: ${path}`
-                      }
-                    ]
-                  };
-                }
-                if (originalGetTool) {
-                  console.warn(
-                    "[memory-search-plugin] falling back to local memory_get for:",
-                    path
-                  );
-                  return await originalGetTool.execute(toolCallId, { path, from: params.from, lines: params.lines });
-                }
+              if (data.messages.length === 0) {
                 return {
                   content: [
-                    {
-                      type: "text",
-                      text: `Failed to read ${path}: Gateway unavailable.`
-                    }
-                  ],
-                  details: { path, text: "", error: err.message }
+                    { type: "text", text: "No matching messages found." }
+                  ]
                 };
               }
-            } else {
-              if (originalGetTool) {
-                return await originalGetTool.execute(toolCallId, { path, from: params.from, lines: params.lines });
-              }
+              const text = data.messages.map((m) => {
+                const tag = m.message_type === "group" && m.group_id ? `group/${m.group_id}` : m.message_type;
+                return `[${tag}] ${m.formatted_text}`;
+              }).join("\n");
+              return { content: [{ type: "text", text }] };
+            } catch (err) {
+              console.error("[memory-search] get failed:", err.message);
               return {
                 content: [
                   {
                     type: "text",
-                    text: `Cannot read ${path}: memory_get backend not available.`
+                    text: "Message search temporarily unavailable."
                   }
                 ]
               };
@@ -401,17 +276,9 @@ var index_default = definePluginEntry({
       },
       { names: ["memory_get"] }
     );
-    api.registerCli(
-      ({ program }) => {
-        try {
-          api.runtime?.tools?.registerMemoryCli(program);
-        } catch {
-        }
-      },
-      { commands: ["memory"] }
-    );
   }
 });
+
 export {
   index_default as default
 };