memory-search-plugin 0.8.0 → 1.1.0

package/gateway-client.ts

@@ -1,39 +1,26 @@
-/**
- * Memory Search Gateway HTTP 调用封装
- *
- * 封装与外部 Memory Search Gateway 服务的通信。
- * 请求/响应格式与后端 app/models.py 完全对齐。
- * Gateway 地址从 openclaw.json plugins.entries.memory-search-plugin.config.gatewayUrl 获取。
- */
-
 import type { Scene } from "./identity";
 
-// ── 类型定义（与后端 app/models.py 对齐）──────────────
-
-export type MemoryType = "owner" | "peer" | "group" | "knowledge";
+// ── Search ──
 
 export interface MemorySearchRequest {
+  owner_id: string;
+  sender_id: string;
   agent_id: string;
-  user_id: string;
   query: string;
   scene: Scene;
   group_id?: string | null;
-  release_name?: string;  // 用户隔离标识（如 user-xxx），owner/peer 搜索必须
-  limit?: number;       // 1-100, default 20
-  threshold?: number;   // 0.0-1.0, default 0.3
+  limit?: number;
+  threshold?: number;
 }
 
 export interface MemorySearchResult {
   id: string;
   content: string;
   score: number;
-  memory_type: MemoryType;
-  source_file?: string;
-  created_at?: string;
-  agent_id?: string;
-  peer_id?: string;
+  memory_type: "owner" | "group" | "knowledge";
   group_id?: string;
   kb_id?: string;
+  created_at?: string;
 }
 
 export interface MemorySearchResponse {
@@ -43,23 +30,34 @@ export interface MemorySearchResponse {
   steps: string[];
 }
 
+// ── Get (keyword search on memory_chat_logs) ──
+
 export interface MemoryGetRequest {
+  owner_id: string;
+  sender_id: string;
   agent_id: string;
-  user_id: string;
-  path: string;
-  scene?: Scene;
+  keyword: string;
+  scene: Scene;
   group_id?: string | null;
-  release_name?: string;  // 用户隔离标识（如 user-xxx），owner/peer 搜索必须
-  from?: number;
-  lines?: number;
+  message_type?: "owner" | "group";
+  limit?: number;
+  offset?: number;
+}
+
+export interface MemoryGetMessage {
+  id: string;
+  formatted_text: string;
+  message_type: "owner" | "group";
+  group_id?: string | null;
+  message_ts: string;
 }
 
 export interface MemoryGetResponse {
-  text: string;
-  path: string;
+  messages: MemoryGetMessage[];
+  total: number;
 }
 
-// ── Gateway Client ─────────────────────────────────────
+// ── Client ──
 
 export interface GatewayClientConfig {
   gatewayUrl: string;
@@ -73,43 +71,26 @@ export interface GatewayClient {
 
 export function createGatewayClient(config: GatewayClientConfig): GatewayClient {
   const baseUrl = config.gatewayUrl.replace(/\/+$/, "");
-  const token = config.gatewayToken || "";
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    ...(config.gatewayToken ? { Authorization: `Bearer ${config.gatewayToken}` } : {}),
+  };
 
-  const authHeaders = token
-    ? { Authorization: `Bearer ${token}` }
-    : {};
+  async function post<T>(path: string, body: unknown): Promise<T> {
+    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 resp.json() as Promise<T>;
+  }
 
   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() as Promise<MemorySearchResponse>;
-    },
-
-    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() as Promise<MemoryGetResponse>;
-    },
+    callGatewaySearch: (opts) => post("/api/memory/search", opts),
+    callGatewayGet: (opts) => post("/api/memory/get", opts),
   };
 }

package/identity.ts

@@ -1,119 +1,59 @@
 /**
- * 身份解析模块
+ * 身份解析模块 — 仅 owner/group/knowledge 三种场景
  *
- * 方案 4：从 LLM 传入的工具参数解析身份信息。
- * LLM 从 system prompt 中的 UntrustedContext 提取字段并填入工具参数。
+ * conversation_type = "group"  → scene = "group"
+ * conversation_type = "direct" → scene = "owner"
+ * knowledge 场景由特定工具调用或 LLM 判断触发
  *
- * owner 判断：通过环境变量 OPENCLAW_GATEWAY_TOKEN 获取 owner_id，
- * 与 sender_id 比对（与旧版逻辑一致）。
- *
- * 输出：
- *   - scene:    对应后端 SearchRequest.scene（private_own / private_other / group）
- *   - user_id:  当前对话用户的 ID
- *   - group_id: 群聊时的群 ID（仅 group 场景）
+ * owner_id 用于 SQL 数据隔离，替代 release_name。
+ * 不依赖任何环境变量兜底。
  */
 
-/** 后端 models.py 定义的五种场景 */
-export type Scene =
-  | "private_own"
-  | "private_other"
-  | "group"
-  | "knowledge"
-  | "admin";
+export type Scene = "owner" | "group" | "knowledge";
 
-/** 解析后的身份信息，与后端 SearchRequest 的 user_id / scene / group_id 对齐 */
 export interface ResolvedIdentity {
   scene: Scene;
-  user_id: string;
+  sender_id: string;
+  owner_id: string;
   group_id: string | null;
 }
 
-/** LLM 传入的身份相关参数（来自 UntrustedContext） */
 export interface IdentityParams {
   sender_id?: string;
-  conversation_type?: string;  // "direct" | "group"
+  owner_id?: string;
+  conversation_type?: string;
   group_id?: string;
 }
 
-/**
- * 从 LLM 工具参数解析身份 + 场景
- *
- * owner 判断逻辑与旧版一致：通过环境变量 OPENCLAW_GATEWAY_TOKEN 获取 owner_id，
- * 再与 sender_id 比对。
- *
- * 场景映射:
- *   conversation_type="group"                      → scene = "group"
- *   conversation_type="direct" + isOwner(sender_id) → scene = "private_own"
- *   conversation_type="direct" + !isOwner           → scene = "private_other"
- */
-export function resolveIdentityFromParams(params: IdentityParams): ResolvedIdentity {
-  // ── 测试模式：环境变量覆盖 ──────────────────────────
+export function resolveIdentity(params: IdentityParams): ResolvedIdentity {
   const testScene = process.env.MEMORY_GATEWAY_TEST_SCENE as Scene | undefined;
   if (testScene) {
-    const result: ResolvedIdentity = {
+    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();
+  const groupId = params.group_id?.trim() || null;
 
-  // 1. 群聊
-  if (convType === "group") {
-    return {
-      scene: "group",
-      user_id: userId,
-      group_id: params.group_id?.trim() || null,
-    };
-  }
-
-  // 2. 私聊：通过环境变量比对 owner_id 判断 owner/peer
-  if (isOwner(userId)) {
-    return { scene: "private_own", user_id: userId, group_id: 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."
+    );
   }
 
-  return { scene: "private_other", user_id: userId, group_id: null };
-}
-
-// ── 向后兼容：保留旧函数签名，sessionKey 仍可用时作为 fallback ──
-
-export function resolveIdentity(sessionKey: string | undefined): ResolvedIdentity {
-  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 };
+  if (convType === "group") {
+    if (!groupId) {
+      console.warn("[identity] group scene but group_id is empty");
     }
-    return { scene: "private_other", user_id: userId, group_id: null };
+    return { scene: "group", sender_id: senderId, owner_id: ownerId, group_id: groupId };
   }
 
-  return { scene: "private_other", user_id: "unknown", group_id: null };
-}
-
-function isOwner(userId: string): boolean {
-  const token = process.env.OPENCLAW_GATEWAY_TOKEN || "";
-  if (!token) return false;
-  const ownerUserId = token.split("-").pop() || "";
-  return ownerUserId !== "" && ownerUserId === userId;
-}
-
-export function extractAgentId(sessionKey: string | undefined): string {
-  const parts = (sessionKey || "").split(":");
-  return parts.length >= 2 ? parts[1] : "main";
+  return { scene: "owner", sender_id: senderId, owner_id: ownerId, group_id: null };
 }