memory-search-plugin 0.5.0 → 0.6.0

package/gateway-client.ts

@@ -57,31 +57,6 @@ export interface MemoryGetResponse {
   path: string;
 }
 
-export interface MemoryRawSnapshotsRequest {
-  release_name: string;
-  start_time: string;   // ISO 8601
-  end_time: string;      // ISO 8601
-  path_prefix?: string;  // e.g. "memory/"
-  page?: number;
-  page_size?: number;
-}
-
-export interface MemoryRawSnapshot {
-  id: string;
-  path: string;
-  content: string;
-  release_name: string;
-  synced_at: string;
-  [key: string]: unknown;
-}
-
-export interface MemoryRawSnapshotsResponse {
-  records: MemoryRawSnapshot[];
-  total: number;
-  page: number;
-  page_size: number;
-}
-
 // ── Gateway Client ─────────────────────────────────────
 
 export interface GatewayClientConfig {
@@ -92,7 +67,6 @@ export interface GatewayClientConfig {
 export interface GatewayClient {
   callGatewaySearch(options: MemorySearchRequest): Promise<MemorySearchResponse>;
   callGatewayGet(options: MemoryGetRequest): Promise<MemoryGetResponse>;
-  callGatewayRawSnapshots(options: MemoryRawSnapshotsRequest): Promise<MemoryRawSnapshotsResponse>;
 }
 
 export function createGatewayClient(config: GatewayClientConfig): GatewayClient {
@@ -135,21 +109,5 @@ export function createGatewayClient(config: GatewayClientConfig): GatewayClient
       }
       return response.json() as Promise<MemoryGetResponse>;
     },
-
-    async callGatewayRawSnapshots(options) {
-      const url = `${baseUrl}/api/memory/raw_snapshots`;
-      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 raw_snapshots failed: ${response.status} ${response.statusText} ${errorBody}`
-        );
-      }
-      return response.json() as Promise<MemoryRawSnapshotsResponse>;
-    },
   };
 }

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/index.ts

@@ -28,7 +28,7 @@ import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import { createGatewayClient } from "./gateway-client";
 import { resolveIdentityFromParams, resolveIdentity, extractAgentId } from "./identity";
 import type { IdentityParams } from "./identity";
-import type { MemorySearchResult, MemoryRawSnapshot } from "./gateway-client";
+import type { MemorySearchResult } from "./gateway-client";
 
 // ── Prompt Section ──────────────────────────────────────
 // 告诉 LLM 如何使用 memory 工具（和 memory-core 的逻辑一致）
@@ -136,23 +136,6 @@ function formatSearchResults(results: MemorySearchResult[]): string {
     .join("\n\n");
 }
 
-/**
- * 将 raw_snapshots 查询结果格式化为可读文本
- * 包含 path、synced_at、release_name 和内容摘要
- */
-function formatRawSnapshots(records: MemoryRawSnapshot[]): string {
-  if (records.length === 0) {
-    return "No matching raw snapshot records found.";
-  }
-
-  return records
-    .map((r, i) => {
-      const header = `[${i + 1}] path: ${r.path} | release: ${r.release_name} | synced_at: ${r.synced_at}`;
-      return `${header}\n${r.content}`;
-    })
-    .join("\n\n");
-}
-
 // ── 插件定义 ────────────────────────────────────────────
 
 export default definePluginEntry({
@@ -482,115 +465,7 @@ export default definePluginEntry({
     );
 
     // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 4. 注册 memory_raw_snapshots_query → 查询 memory_raw_snapshots 表
-    //    按 synced_at 时间段 + path 为 memory/xxx + release_name 过滤
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    api.registerTool(
-      (_ctx: any) => {
-        return {
-          name: "memory_raw_snapshots_query",
-          description:
-            "Query raw memory snapshot records from the memory_raw_snapshots table. " +
-            "Filters by synced_at time range, release_name, and only returns records whose path starts with 'memory/' " +
-            "(excluding MEMORY.md, USER.md, etc.).",
-          parameters: {
-            type: "object" as const,
-            properties: {
-              release_name: {
-                type: "string" as const,
-                description: "The release_name to filter by (e.g. 'lobster_xxx')",
-              },
-              start_time: {
-                type: "string" as const,
-                description: "Start time in ISO 8601 format (e.g. '2025-05-01T00:00:00Z')",
-              },
-              end_time: {
-                type: "string" as const,
-                description: "End time in ISO 8601 format (e.g. '2025-05-07T23:59:59Z')",
-              },
-              page: {
-                type: "number" as const,
-                description: "Page number for pagination (default 1)",
-              },
-              page_size: {
-                type: "number" as const,
-                description: "Number of records per page (default 50, max 200)",
-              },
-            },
-            required: ["release_name", "start_time", "end_time"],
-          },
-
-          async execute(
-            _toolCallId: string,
-            params: {
-              release_name?: string;
-              start_time?: string;
-              end_time?: string;
-              page?: number;
-              page_size?: number;
-            }
-          ) {
-            const releaseName = params.release_name?.trim() || "";
-            const startTime = params.start_time?.trim() || "";
-            const endTime = params.end_time?.trim() || "";
-
-            if (!releaseName || !startTime || !endTime) {
-              return {
-                content: [
-                  {
-                    type: "text" as const,
-                    text: "Missing required parameters: release_name, start_time, and end_time are all required.",
-                  },
-                ],
-              };
-            }
-
-            console.log(
-              `[memory-search-plugin] raw_snapshots_query: release_name=${releaseName} ` +
-              `start_time=${startTime} end_time=${endTime} page=${params.page || 1} page_size=${params.page_size || 50}`
-            );
-
-            try {
-              const data = await gateway.callGatewayRawSnapshots({
-                release_name: releaseName,
-                start_time: startTime,
-                end_time: endTime,
-                path_prefix: "memory/",
-                page: params.page || 1,
-                page_size: params.page_size || 50,
-              });
-
-              const text = formatRawSnapshots(data.records);
-              const summary = `Found ${data.total} record(s) (page ${data.page}, page_size ${data.page_size}).\n\n${text}`;
-
-              return {
-                content: [{ type: "text" as const, text: summary }],
-                details: {
-                  records: data.records,
-                  total: data.total,
-                  page: data.page,
-                  page_size: data.page_size,
-                },
-              };
-            } catch (err: any) {
-              console.error("[memory-search-plugin] raw_snapshots_query failed:", err.message);
-              return {
-                content: [
-                  {
-                    type: "text" as const,
-                    text: `Raw snapshots query failed: ${err.message}`,
-                  },
-                ],
-              };
-            }
-          },
-        };
-      },
-      { names: ["memory_raw_snapshots_query"] }
-    );
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 5. 保留 CLI 命令（和 memory-core 一致）
+    // 4. 保留 CLI 命令（和 memory-core 一致）
     // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
     api.registerCli(
       ({ program }: any) => {

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.5.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"
     ]
   }
 }