memorylake-openclaw 0.0.14 → 0.0.15-beta.2

package/index.ts

@@ -68,6 +68,52 @@ interface MemoryItem {
   user_id?: string;
   created_at?: string;
   updated_at?: string;
+  has_unresolved_conflict?: boolean;
+}
+
+interface ConflictMemorySnapshot {
+  memory_id: string;
+  memory_history_id?: string;
+  memory_text: string;
+}
+
+interface ConflictFileChunk {
+  chunk: { type?: string; text: string; range?: string };
+  document_id?: string;
+  document_name?: string;
+}
+
+interface ConflictResolve {
+  id: string;
+  strategy: string;
+  keep_memory_id?: string;
+  forgotten_memory_ids?: string[];
+  resolved_by?: string;
+  created_at?: string;
+}
+
+interface ConflictItem {
+  id: string;
+  name: string;
+  description: string;
+  category: "m2m" | "m2d";
+  conflict_type: "logical" | "knowledge";
+  memory_ids: string[];
+  memory_snapshots: ConflictMemorySnapshot[];
+  file_chunks: ConflictFileChunk[];
+  resolved: boolean;
+  resolve?: ConflictResolve;
+  stale?: boolean;
+  event_id?: string;
+  created_at?: string;
+  updated_at?: string;
+}
+
+interface ConflictListResponse {
+  items: ConflictItem[];
+  page: number;
+  total: number;
+  page_size: number;
 }
 
 interface AddResultItem {
@@ -250,6 +296,7 @@ interface MemoryLakeProvider {
   searchWeb(query: string, options: WebSearchOptions): Promise<WebSearchResponse>;
   searchOpenData(query: string, options: OpenDataSearchOptions): Promise<OpenDataSearchResponse>;
   getProject(): Promise<ProjectInfo>;
+  listConflicts(memoryIds: string[], userId: string): Promise<ConflictItem[]>;
 }
 
 // ============================================================================
@@ -270,14 +317,17 @@ class PlatformProvider implements MemoryLakeProvider {
   private readonly webSearchPath: string;
   private readonly openDataSearchPath: string;
   private readonly projectPath: string;
-
+  private readonly conflictsPath: string;
+  private readonly projectId: string;
 
   constructor(host: string, apiKey: string, projectId: string) {
+    this.projectId = projectId;
     this.basePath = `openapi/memorylake/api/v2/projects/${projectId}/memories`;
     this.docSearchPath = `openapi/memorylake/api/v1/projects/${projectId}/documents/search`;
     this.webSearchPath = "openapi/memorylake/api/v1/search";
     this.openDataSearchPath = "openapi/memorylake/api/v1/search/opendata";
     this.projectPath = `openapi/memorylake/api/v1/projects/${projectId}`;
+    this.conflictsPath = `openapi/memorylake/api/v2/projects/${projectId}/memories/conflicts`;
     this.http = got.extend({
       prefixUrl: host,
       headers: {
@@ -310,6 +360,7 @@ class PlatformProvider implements MemoryLakeProvider {
     const body: Record<string, unknown> = {
       query,
       user_id: options.user_id,
+      with_conflicts: true,
     };
     if (options.top_k != null) body.top_k = options.top_k;
     if (options.threshold != null) body.threshold = options.threshold;
@@ -422,6 +473,23 @@ class PlatformProvider implements MemoryLakeProvider {
     return info;
   }
 
+  async listConflicts(memoryIds: string[], userId: string): Promise<ConflictItem[]> {
+    if (memoryIds.length === 0) return [];
+    const searchParams: Record<string, string> = {
+      resolved: "false",
+      memory_ids: memoryIds.join(","),
+    };
+    const resp = await this.http
+      .get(this.conflictsPath, {
+        searchParams,
+        headers: { "X-User-ID": userId },
+      })
+      .json<ApiResponse<ConflictListResponse>>();
+    if (!resp.success) throw new Error(resp.message ?? "list conflicts failed");
+    const data = resp.data;
+    return Array.isArray(data?.items) ? data.items : [];
+  }
+
 }
 
 // ============================================================================
@@ -435,6 +503,7 @@ function normalizeMemoryItem(raw: any): MemoryItem {
     user_id: raw.user_id,
     created_at: raw.created_at,
     updated_at: raw.updated_at,
+    has_unresolved_conflict: raw.has_unresolved_conflict ?? false,
   };
 }
 
@@ -548,6 +617,24 @@ function buildWebSearchContext(results: WebSearchResult[]): string {
     .join("\n\n");
 }
 
+function buildConflictContext(conflicts: ConflictItem[], maxChunkLength = 200): string {
+  return conflicts
+    .map((c) => {
+      const parts: string[] = [
+        `- [${c.conflict_type}] ${c.description}`,
+      ];
+      for (const snap of c.memory_snapshots ?? []) {
+        parts.push(`  Memory(${snap.memory_id}): ${snap.memory_text.slice(0, maxChunkLength)}`);
+      }
+      for (const fc of c.file_chunks ?? []) {
+        const docLabel = fc.document_name ?? fc.document_id ?? "unknown";
+        parts.push(`  Document(${docLabel}): ${fc.chunk.text.slice(0, maxChunkLength)}`);
+      }
+      return parts.join("\n");
+    })
+    .join("\n");
+}
+
 function buildOpenDataContext(results: OpenDataSearchResult[]): string {
   const filtered = results.map((r) => {
     const item: Record<string, unknown> = {};
@@ -1774,15 +1861,40 @@ const memoryPlugin = {
         const contextParts: string[] = [];
 
         if (memoryResult.status === "fulfilled" && memoryResult.value.length > 0) {
-          const memoryContext = memoryResult.value
+          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 ${memoryResult.value.length} memories into context`,
+            `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)}`);
         }
@@ -1880,6 +1992,9 @@ const memoryPlugin = {
             if (textContent.includes("<relevant-memories>")) {
               textContent = textContent.replace(/<relevant-memories>[\s\S]*?<\/relevant-memories>\s*/g, "").trim();
             }
+            if (textContent.includes("<memory-conflicts>")) {
+              textContent = textContent.replace(/<memory-conflicts>[\s\S]*?<\/memory-conflicts>\s*/g, "").trim();
+            }
             if (textContent.includes("<relevant-documents>")) {
               textContent = textContent.replace(/<relevant-documents>[\s\S]*?<\/relevant-documents>\s*/g, "").trim();
             }

package/package.json

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