memory-search-plugin 0.4.0 → 0.6.0

package/index.js

@@ -0,0 +1,413 @@
+// 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) {
+  const testScene = process.env.MEMORY_GATEWAY_TEST_SCENE;
+  if (testScene) {
+    const result = {
+      scene: testScene,
+      user_id: process.env.MEMORY_GATEWAY_TEST_USER_ID || "owner_A",
+      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 convType = (params.conversation_type || "direct").trim().toLowerCase();
+  if (convType === "group") {
+    return {
+      scene: "group",
+      user_id: userId,
+      group_id: params.group_id?.trim() || null
+    };
+  }
+  if (isOwner(userId)) {
+    return { scene: "private_own", user_id: userId, group_id: null };
+  }
+  return { scene: "private_other", user_id: userId, 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 };
+    }
+    return { scene: "private_other", user_id: userId, group_id: null };
+  }
+  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";
+}
+
+// index.ts
+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 on MEMORY.md + memory/*.md; then use memory_get to pull only the needed lines. 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("");
+  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",
+  kind: "memory",
+  register(api) {
+    const gatewayUrl = api.pluginConfig?.gatewayUrl || "http://localhost:18790";
+    const gatewayToken = api.pluginConfig?.gatewayToken || "";
+    console.log("[memory-search-plugin] gatewayUrl:", gatewayUrl);
+    const gateway = createGatewayClient({ gatewayUrl, gatewayToken });
+    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.",
+          parameters: {
+            type: "object",
+            properties: {
+              query: {
+                type: "string",
+                description: "The search query"
+              },
+              agent_id: {
+                type: "string",
+                description: "The agent_id from UntrustedContext (e.g. 'main' or 'lobster_xxx')"
+              },
+              sender_id: {
+                type: "string",
+                description: "The sender_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)"
+              },
+              maxResults: {
+                type: "number",
+                description: "Maximum number of results to return"
+              },
+              minScore: {
+                type: "number",
+                description: "Minimum similarity score threshold"
+              }
+            },
+            required: ["query"]
+          },
+          async execute(toolCallId, params) {
+            const query = params.query || "";
+            if (!query) {
+              return {
+                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({
+              sender_id: params.sender_id,
+              conversation_type: params.conversation_type,
+              group_id: params.group_id
+            }) : fallbackIdentity || resolveIdentityFromParams({});
+            console.log(
+              `[memory-search-plugin] search: agent_id=${agentId} scene=${identity.scene} user_id=${identity.user_id} group_id=${identity.group_id} (source=${params.sender_id ? "llm_params" : "fallback"})`
+            );
+            try {
+              const data = await gateway.callGatewaySearch({
+                agent_id: agentId,
+                user_id: identity.user_id,
+                query,
+                scene: identity.scene,
+                group_id: identity.group_id,
+                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
+                }
+              };
+            } 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 {
+              }
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: "Memory search temporarily unavailable."
+                  }
+                ]
+              };
+            }
+          }
+        };
+      },
+      { 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.",
+          parameters: {
+            type: "object",
+            properties: {
+              path: {
+                type: "string",
+                description: "Relative path to the file (e.g. MEMORY.md, memory/notes.md, SOUL.md)"
+              },
+              agent_id: {
+                type: "string",
+                description: "The agent_id from UntrustedContext (e.g. 'main' or 'lobster_xxx')"
+              },
+              sender_id: {
+                type: "string",
+                description: "The sender_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)"
+              },
+              from: {
+                type: "number",
+                description: "Starting line number (1-indexed)"
+              },
+              lines: {
+                type: "number",
+                description: "Number of lines to read"
+              }
+            },
+            required: ["path"]
+          },
+          async execute(toolCallId, params) {
+            const path = params.path || "";
+            if (!path) {
+              return {
+                content: [{ type: "text", text: "No path provided." }]
+              };
+            }
+            let originalGetTool = null;
+            try {
+              originalGetTool = api.runtime?.tools?.createMemoryGetTool({
+                config: ctx.config,
+                agentSessionKey: ctx.sessionKey
+              });
+            } 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} (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,
+                  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 });
+                }
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: `Failed to read ${path}: Gateway unavailable.`
+                    }
+                  ],
+                  details: { path, text: "", error: err.message }
+                };
+              }
+            } else {
+              if (originalGetTool) {
+                return await originalGetTool.execute(toolCallId, { path, from: params.from, lines: params.lines });
+              }
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Cannot read ${path}: memory_get backend not available.`
+                  }
+                ]
+              };
+            }
+          }
+        };
+      },
+      { names: ["memory_get"] }
+    );
+    api.registerCli(
+      ({ program }) => {
+        try {
+          api.runtime?.tools?.registerMemoryCli(program);
+        } catch {
+        }
+      },
+      { commands: ["memory"] }
+    );
+  }
+});
+export {
+  index_default as default
+};

package/openclaw.plugin.json

@@ -3,7 +3,7 @@
   "name": "Memory Search Plugin",
   "description": "Routes memory_search to external Memory Search Gateway with ACL, memory_get with path routing",
   "kind": "memory",
-  "version": "0.1.0",
+  "version": "0.5.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "memory-search-plugin",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "type": "module",
-  "main": "index.ts",
+  "main": "index.js",
   "files": [
+    "*.js",
     "*.ts",
     "openclaw.plugin.json",
     "!*.test.ts"
@@ -14,7 +15,7 @@
   },
   "openclaw": {
     "extensions": [
-      "./index.ts"
+      "./index.js"
     ]
   }
 }