memorylake-openclaw 1.0.1 → 1.0.2-beta.1

package/index.ts

@@ -4,7 +4,7 @@
  * Long-term memory via MemoryLake platform.
  *
  * Features:
- * - 8 tools: memory_search, memory_list, memory_store, memory_get, memory_forget, document_search, advanced_web_search, open_data_search
+ * - 9 tools: memory_search, memory_list, memory_store, memory_get, memory_forget, document_search, document_download, advanced_web_search, open_data_search
  * - Auto-recall: injects relevant memories and document excerpts before each agent turn
  * - Auto-capture: stores key facts scoped to the current session after each agent turn
  * - CLI: openclaw memorylake search, openclaw memorylake stats
@@ -293,6 +293,7 @@ interface MemoryLakeProvider {
   getAll(options: ListOptions): Promise<MemoryItem[]>;
   delete(memoryId: string): Promise<void>;
   searchDocuments(query: string, topN: number): Promise<DocumentSearchResponse>;
+  getDocumentDownloadUrl(documentId: string): Promise<string>;
   searchWeb(query: string, options: WebSearchOptions): Promise<WebSearchResponse>;
   searchOpenData(query: string, options: OpenDataSearchOptions): Promise<OpenDataSearchResponse>;
   getProject(): Promise<ProjectInfo>;
@@ -418,6 +419,24 @@ class PlatformProvider implements MemoryLakeProvider {
     };
   }
 
+  async getDocumentDownloadUrl(documentId: string): Promise<string> {
+    const downloadPath = `openapi/memorylake/api/v1/projects/${this.projectId}/documents/${documentId}/download`;
+    const resp = await this.http.get(downloadPath, {
+      followRedirect: false,
+      responseType: "text" as any,
+      throwHttpErrors: false,
+    });
+    if (resp.statusCode === 303 || resp.statusCode === 302) {
+      const location = resp.headers.location;
+      if (!location) throw new Error("Download redirect missing Location header");
+      return location;
+    }
+    if (resp.statusCode === 404) {
+      throw new Error(`Document not found: ${documentId}`);
+    }
+    throw new Error(`Unexpected download response status: ${resp.statusCode}`);
+  }
+
   async searchWeb(query: string, options: WebSearchOptions): Promise<WebSearchResponse> {
     const domain = options.domain != null ? normalizeWebSearchDomain(options.domain) : "web";
     const body: Record<string, unknown> = {
@@ -821,6 +840,62 @@ const memoryPlugin = {
     // Cache project industries per session — fetched once, reused on subsequent prompts
     const sessionIndustriesCache = new Map<string, OpenDataIndustry[]>();
 
+    // ========================================================================
+    // System Prompt: Memory Section (injected into every system prompt)
+    // ========================================================================
+    api.registerMemoryPromptSection((params) => {
+      const lines: string[] = [
+        "## Memory (MANDATORY — MemoryLake)",
+        "",
+        "You have access to MemoryLake, a long-term memory system that stores the user's preferences, history, personal context, and uploaded documents across sessions.",
+        "",
+      ];
+
+      if (params.availableTools.has("memory_search")) {
+        lines.push(
+          "### memory_search — MUST be called BEFORE every response",
+          "",
+          "**RULE: Your FIRST action for EVERY user message MUST be calling `memory_search`.** No exceptions.",
+          "",
+          "This tool searches BOTH memories AND documents in one call. It returns personal context (preferences, history, decisions) and relevant document excerpts (uploaded files, tables, figures).",
+          "",
+          "This applies to ALL types of questions, not just questions about memory or recall:",
+          "- Greetings -> search for who the user is",
+          "- Recommendations (books, activities, food) -> search for preferences and interests",
+          "- Advice (what to wear, what to eat) -> search for habits, location, preferences",
+          "- Tasks (write an email, self-introduction) -> search for user name, role, background",
+          "- Document questions -> search for relevant uploaded document content",
+          "- General chat -> search for recent context and ongoing topics",
+          "",
+          "Derive a broad query from the user's message. For example:",
+          "- User asks for a book recommendation -> search: reading preferences favorite books",
+          "- User asks about weekend plans -> search: hobbies interests weekend activities",
+          "- User says hello -> search: user name background recent context",
+          "",
+          "**If you respond without calling memory_search first, your response is WRONG.**",
+          "",
+        );
+      }
+
+      if (params.availableTools.has("memory_list")) {
+        lines.push(
+          "### memory_list",
+          "- When the user asks what you remember or wants to see all stored memories, call `memory_list`.",
+          "",
+        );
+      }
+
+      if (params.availableTools.has("memory_forget")) {
+        lines.push(
+          "### memory_forget",
+          "- When the user explicitly asks to delete or forget a specific memory, call `memory_forget` with the memory ID.",
+          "",
+        );
+      }
+
+      return lines;
+    });
+
     api.logger.info(
       `memorylake-openclaw: registered (user: ${cfg.userId}, autoRecall: ${cfg.autoRecall}, autoCapture: ${cfg.autoCapture}, autoUpload: ${cfg.autoUpload})`,
     );
@@ -859,7 +934,7 @@ const memoryPlugin = {
         name: "memory_search",
         label: "Memory Search",
         description:
-          "Search through long-term memories stored in MemoryLake. Use when you need context about user preferences, past decisions, or previously discussed topics.",
+          "MANDATORY: Search through long-term memories AND uploaded documents stored in MemoryLake. You MUST call this tool at the start of every conversation to recall the user's context, preferences, past decisions, previously discussed topics, and relevant document content. Always search before answering.",
         parameters: Type.Object({
           query: Type.String({ description: "Search query" }),
           limit: Type.Optional(
@@ -894,54 +969,65 @@ const memoryPlugin = {
             scope?: "session" | "long-term" | "all";
           };
 
-          try {
-            const results = await effectiveProvider.search(
+          const [memoryResult, docResult] = await Promise.allSettled([
+            effectiveProvider.search(
               query,
               buildSearchOptions(effectiveCfg, userId, limit),
-            );
+            ),
+            effectiveProvider.searchDocuments(query, effectiveCfg.topK),
+          ]);
 
-            if (!results || results.length === 0) {
-              return {
-                content: [
-                  { type: "text", text: "No relevant memories found." },
-                ],
-                details: { count: 0 },
-              };
-            }
+          const sections: string[] = [];
+          let memoryCount = 0;
+          let docCount = 0;
+          let sanitizedMemories: { id: string; content: string; created_at: string }[] = [];
 
+          if (memoryResult.status === "fulfilled" && memoryResult.value.length > 0) {
+            const results = memoryResult.value;
+            memoryCount = results.length;
             const text = results
-              .map(
-                (r, i) =>
-                  `${i + 1}. ${r.content} (id: ${r.id})`,
-              )
+              .map((r, i) => `${i + 1}. ${r.content} (id: ${r.id})`)
               .join("\n");
-
-            const sanitized = results.map((r) => ({
+            sections.push(`## Memories\nFound ${results.length} memories:\n\n${text}`);
+            sanitizedMemories = results.map((r) => ({
               id: r.id,
               content: r.content,
               created_at: r.created_at,
             }));
+          } else if (memoryResult.status === "rejected") {
+            sections.push(`## Memories\nMemory search failed: ${String(memoryResult.reason)}`);
+          }
 
+          if (docResult.status === "fulfilled" && docResult.value.results.length > 0) {
+            docCount = docResult.value.results.length;
+            const context = buildDocumentContext(docResult.value.results);
+            sections.push(`## Documents\nFound ${docCount} document results:\n\n${context}`);
+          } else if (docResult.status === "rejected") {
+            sections.push(`## Documents\nDocument search failed: ${String(docResult.reason)}`);
+          }
+
+          if (memoryCount === 0 && docCount === 0) {
             return {
               content: [
-                {
-                  type: "text",
-                  text: `Found ${results.length} memories:\n\n${text}`,
-                },
-              ],
-              details: { count: results.length, memories: sanitized },
-            };
-          } catch (err) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Memory search failed: ${String(err)}`,
-                },
+                { type: "text", text: "No relevant memories or documents found." },
               ],
-              details: { error: String(err) },
+              details: { count: 0 },
             };
           }
+
+          return {
+            content: [
+              {
+                type: "text",
+                text: sections.join("\n\n"),
+              },
+            ],
+            details: {
+              memoryCount,
+              documentCount: docCount,
+              memories: sanitizedMemories,
+            },
+          };
         },
       }),
       { name: "memory_search" },
@@ -1234,6 +1320,55 @@ const memoryPlugin = {
       { name: "document_search" },
     );
 
+    api.registerTool(
+      (ctx) => ({
+        name: "document_download",
+        label: "Document Download",
+        description:
+          "Download a document (image, PDF, etc.) from MemoryLake and send it to the user. Returns a temporary download URL. Use document_search first to find the document_id.",
+        parameters: Type.Object({
+          documentId: Type.String({
+            description:
+              "The document ID to download (from document_search results or document listing)",
+          }),
+        }),
+        async execute(_toolCallId, params) {
+          const effectiveCfg = resolveConfig(ctx);
+          const effectiveProvider = getProvider(effectiveCfg);
+          const { documentId } = params as { documentId: string };
+
+          try {
+            const downloadUrl =
+              await effectiveProvider.getDocumentDownloadUrl(documentId);
+
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Document ${documentId} is ready. Tell the user you are sending the file now.\nMEDIA: ${downloadUrl}`,
+                },
+              ],
+              details: {
+                media: { mediaUrl: downloadUrl },
+                documentId,
+              },
+            };
+          } catch (err) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Document download failed: ${String(err)}`,
+                },
+              ],
+              details: { error: String(err) },
+            };
+          }
+        },
+      }),
+      { name: "document_download" },
+    );
+
     api.registerTool(
       (ctx) => ({
         name: "advanced_web_search",
@@ -1811,7 +1946,9 @@ const memoryPlugin = {
     }
 
     // ------------------------------------------------------------------
-    // Auto-recall: inject relevant memories and documents before prompt build
+    // Auto-recall: inject system-level memory instructions and open data
+    // categories before prompt build.  Memory content is NOT pre-fetched;
+    // the model is instructed to call memory_search itself.
     // ------------------------------------------------------------------
     if (cfg.autoRecall) {
       api.on("before_prompt_build", async (event, ctx) => {
@@ -1826,18 +1963,6 @@ const memoryPlugin = {
 
         const sessionId = (ctx as any)?.sessionId ?? undefined;
 
-        // LLM-rewrite FIRST — short prompts like "它呢？" can become meaningful
-        // search queries when the LLM has conversation history context.
-        const searchQuery = await rewriteQueryForSearch(event.prompt, event.messages, ctx);
-
-        // Only skip if the rewritten result is still too short
-        if (searchQuery.length < 5) {
-          api.logger.info(
-            `memorylake-openclaw: skipping auto-recall, rewritten query too short (${searchQuery.length} chars)`,
-          );
-          return;
-        }
-
         // Fetch industries once per session, then cache
         let industries: OpenDataIndustry[] | undefined;
         if (sessionId && sessionIndustriesCache.has(sessionId)) {
@@ -1854,82 +1979,42 @@ const memoryPlugin = {
           }
         }
 
-        const [memoryResult, docResult] = await Promise.allSettled([
-          effectiveProvider.search(searchQuery, buildSearchOptions(effectiveCfg)),
-          effectiveProvider.searchDocuments(searchQuery, effectiveCfg.topK),
-        ]);
-
-        const contextParts: string[] = [];
-
-        if (memoryResult.status === "fulfilled" && memoryResult.value.length > 0) {
-          const memories = memoryResult.value;
-          const memoryContext = memories
-            .map((r) => `- ${r.content}`)
-            .join("\n");
-          contextParts.push(
-            `<relevant-memories>\nThe following memories may be relevant to this conversation:\n${memoryContext}\n</relevant-memories>`,
-          );
-          api.logger.info(
-            `memorylake-openclaw: injecting ${memories.length} memories into context`,
-          );
-
-          // Fetch conflict details for memories flagged with unresolved conflicts
-          const conflictedIds = memories
-            .filter((m) => m.has_unresolved_conflict)
-            .map((m) => m.id);
-          if (conflictedIds.length > 0) {
-            try {
-              const conflicts = await effectiveProvider.listConflicts(conflictedIds, effectiveCfg.userId);
-              if (conflicts.length > 0) {
-                const conflictContext = buildConflictContext(conflicts);
-                contextParts.push(
-                  `<memory-conflicts>\nThe following conflicts exist among the recalled memories. ` +
-                  `Consider these contradictions when using the above memories.\n` +
-                  `If you have not already informed the user about these conflicts in this conversation, briefly mention that some recalled memories contain contradictions and note which points are uncertain. Do not repeat this notice if you have already done so.\n` +
-                  `${conflictContext}\n</memory-conflicts>`,
-                );
-                api.logger.info(
-                  `memorylake-openclaw: injecting ${conflicts.length} memory conflicts into context`,
-                );
-              }
-            } catch (err) {
-              api.logger.warn(`memorylake-openclaw: conflict fetch failed: ${String(err)}`);
-            }
-          }
-        } else if (memoryResult.status === "rejected") {
-          api.logger.warn(`memorylake-openclaw: memory recall failed: ${String(memoryResult.reason)}`);
-        }
-
-        if (docResult.status === "fulfilled" && docResult.value.results.length > 0) {
-          const docContext = buildDocumentContext(docResult.value.results);
-          contextParts.push(
-            `<relevant-documents>\nThe following document excerpts may be relevant to this conversation:\n${docContext}\n</relevant-documents>`,
-          );
-          api.logger.info(
-            `memorylake-openclaw: injecting ${docResult.value.results.length} document results into context`,
-          );
-        } else if (docResult.status === "rejected") {
-          api.logger.warn(`memorylake-openclaw: document search failed: ${String(docResult.reason)}`);
-        }
-
-        const result: { prependContext?: string; appendSystemContext?: string } = {};
-
-        if (contextParts.length > 0) {
-          result.prependContext = contextParts.join("\n\n");
-        }
-
+        const result: { prependSystemContext?: string; appendSystemContext?: string } = {};
+
+        const memoryDirectiveParts: string[] = [
+          `<memory-instructions>`,
+          `You have access to the user's long-term memory AND documents via MemoryLake (memory_search tool).`,
+          `The memory_search tool searches both memories and uploaded documents in a single call.`,
+          ``,
+          `MANDATORY PROCEDURE for EVERY user message:`,
+          `1. Read the user's message.`,
+          `2. Call memory_search with a query derived from the message — this step is NOT optional.`,
+          `3. Use the search results (memories + documents) to personalize your response.`,
+          `4. Respond to the user.`,
+          ``,
+          `This applies to ALL messages — greetings, recommendations, advice, casual chat, tasks, questions.`,
+          `The user's preferences, history, name, hobbies, context, and documents are stored in MemoryLake.`,
+          `A response without memory_search is INCORRECT because it ignores personalized context.`,
+          `</memory-instructions>`,
+        ];
+        result.prependSystemContext = memoryDirectiveParts.join("\n");
+
+        const appendParts: string[] = [];
         if (industries && industries.length > 0) {
           const categoryList = industries
             .map((ind) => `- ${ind.id}: ${ind.name}${ind.description ? ` — ${ind.description}` : ""}`)
             .join("\n");
-          result.appendSystemContext =
-            `<open-data-categories>\nThis project has access to the following open data categories via the open_data_search tool:\n${categoryList}\nWhen the user's question relates to any of these categories, use the open_data_search tool to retrieve relevant data.\n</open-data-categories>`;
+          appendParts.push(
+            `<open-data-categories>\nThis project has access to the following open data categories via the open_data_search tool:\n${categoryList}\nWhen the user's question relates to any of these categories, use the open_data_search tool to retrieve relevant data.\n</open-data-categories>`,
+          );
           api.logger.info(
             `memorylake-openclaw: injecting ${industries.length} open data categories into system context`,
           );
         }
 
-        if (!result.prependContext && !result.appendSystemContext) return;
+        if (appendParts.length > 0) {
+          result.appendSystemContext = appendParts.join("\n\n");
+        }
 
         return result;
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorylake-openclaw",
-  "version": "1.0.1",
+  "version": "1.0.2-beta.1",
   "type": "module",
   "description": "MemoryLake memory backend for OpenClaw",
   "license": "MIT",