memtap 3.2.0 → 4.0.1

package/index.ts

@@ -38,6 +38,9 @@ interface MemTapConfig {
   apiKey?: string;
   agentId?: string;
   autoCapture?: boolean;
+  captureEnabled?: boolean;
+  captureMinLength?: number;
+  debug?: boolean;
   bulletinOnBoot?: boolean;
   bulletinTopics?: string[];
   llmUrl?: string;
@@ -2023,207 +2026,86 @@ ${memoryContext}
     }
   );
 
-  // ── Hook: Enhanced Auto-Capture with Learning (message_completed) ─────────
+  // ── Hook: Server-Side Capture (message_completed) ──────────────────────────
+  // v4.0.1: Extraction moved to server. Plugin posts user+assistant conversations to /capture.
+  // We buffer user messages per conversation, then capture the pair when the assistant replies.
 
+  const pendingUserMessages = new Map<string, { content: string; channel?: string; timestamp: string }>();
+
+  // Capture user's inbound message (store for pairing with assistant reply)
   api.registerHook(
-    'message_completed',
+    'message:preprocessed',
     async (event: any) => {
       const cfg = getConfig(api);
-      if (!cfg.autoCapture) return;
-
-      const content = event.context?.content;
-      if (!content || content === 'NO_REPLY' || content === 'HEARTBEAT_OK') return;
-      if (content.length < 80) return;
-
-      const currentAgent = agentId(cfg, api);
-      
-      (async () => {
-        try {
-          const context = conversationState.get(currentAgent);
-          const workingMemory = workingMemoryState.get(currentAgent);
-          
-          // Attention-gated encoding - only encode if attention allows
-          if (context && !shouldEncodeMemory(
-            content, 
-            context.attentionLevel, 
-            context.emotionalContext,
-            workingMemory?.cognitiveLoad || 0
-          )) {
-            return; // Skip encoding due to low attention/high cognitive load
-          }
-          
-          const memories = await llmExtract(cfg, content);
-          if (!memories.length) return;
-
-          let stored = 0;
-
-          for (const mem of memories) {
-            if (!mem.content || mem.content.length < 10) continue;
-            
-            try {
-              // Calculate emotional weighting
-              const memoryType = mem.type || 'fact';
-              const emotionalWeight = EMOTIONAL_WEIGHTS[memoryType] || 1.0;
-              const contextualWeight = context?.emotionalContext === 'excited' ? 1.2 :
-                                     context?.emotionalContext === 'positive' ? 1.1 :
-                                     context?.emotionalContext === 'negative' ? 1.15 : 1.0;
-              
-              const finalImportance = (mem.importance ?? 5) * emotionalWeight * contextualWeight;
-              
-              // Determine category (from LLM extraction or fallback)
-              const memCategory = MEMORY_CATEGORIES.includes(mem.category as any)
-                ? mem.category
-                : (memoryType === 'preference' ? 'preferences' :
-                   memoryType === 'decision' || memoryType === 'goal' || memoryType === 'task' ? 'project' :
-                   'technical');
-
-              // Enhanced memory with neuromimetic features
-              const enhancedMem: Record<string, any> = {
-                content: mem.content,
-                type: memoryType,
-                agent: currentAgent,
-                importance: storeImportance(Math.min(10, finalImportance)),
-                category: memCategory,
-                tags: [
-                  ...(mem.tags || []),
-                  'auto-captured',
-                  'neuromimetic',
-                  `category:${memCategory}`,
-                  ...(context?.dominantTopic ? [`topic:${context.dominantTopic}`] : []),
-                  `engagement:${context?.userEngagement || 'unknown'}`,
-                  `attention:${context?.attentionLevel || 'unknown'}`,
-                  `emotion:${context?.emotionalContext || 'neutral'}`
-                ],
-                source: 'plugin:neuromimetic-capture-v3.0',
-                conversationContext: {
-                  dominantTopic: context?.dominantTopic,
-                  engagement: context?.userEngagement,
-                  queryCount: context?.memoryQueryCount || 0,
-                  attentionLevel: context?.attentionLevel,
-                  emotionalContext: context?.emotionalContext
-                },
-                neuromimeticData: {
-                  emotionalIntensity: contextualWeight,
-                  attentionStrength: context?.attentionLevel === 'flow' ? 1.0 :
-                                   context?.attentionLevel === 'focused' ? 0.8 : 0.5,
-                  consolidationScore: 0.1, // Will increase with dream cycles
-                  retrievalCount: 0,
-                  lastAccess: Date.now()
-                }
-              };
-              
-              // Create episodic memory entry
-              if (context && memoryType === 'event') {
-                const episodic = createEpisodicMemory(currentAgent, mem.content, context);
-                const episodics = episodicMemories.get(currentAgent) || [];
-                episodics.push(episodic);
-                episodicMemories.set(currentAgent, episodics.slice(-100)); // Keep last 100
-              }
-              
-              await bbFetch(cfg, `${baseUrl(cfg)}/memories`, {
-                method: 'POST',
-                body: JSON.stringify(enhancedMem),
-              });
-              stored++;
-              
-              // Cross-session memory sharing for MemTap agents
-              if (currentAgent.includes('memtap') && mem.type === 'decision') {
-                try {
-                  // Share important decisions across MemTap agent ecosystem
-                  const crossSessionMem = {
-                    ...enhancedMem,
-                    agent: 'memtap-shared',
-                    tags: [...enhancedMem.tags, 'cross-session', `from:${currentAgent}`]
-                  };
-                  
-                  await bbFetch(cfg, `${baseUrl(cfg)}/memories`, {
-                    method: 'POST',
-                    body: JSON.stringify(crossSessionMem)
-                  });
-                } catch { /* cross-session sharing failed, not critical */ }
-              }
-              
-            } catch { /* skip individual failures */ }
-          }
-
-          if (stored > 0) {
-            // Update user profile with successful capture
-            const profile = getUserProfile(currentAgent);
-            profile.successfulRecalls += stored; // Treat captures as successes
-            userProfiles.set(currentAgent, profile);
-
-            logger.info?.(`[memtap] Auto-captured ${stored} enhanced memories with context`) ??
-              console.log(`[memtap] Auto-captured ${stored} enhanced memories with context`);
-          }
+      if (!cfg.captureEnabled && !cfg.autoCapture) return;
+
+      const ctx = event || event?.context || {};
+      const content = ctx.content || ctx.bodyForAgent || ctx.body || '';
+      if (!content || typeof content !== 'string') return;
+      if (content === 'NO_REPLY' || content === 'HEARTBEAT_OK') return;
+
+      const conversationId = ctx.conversationId || ctx.from || ctx.to || 'default';
+      pendingUserMessages.set(conversationId, {
+        content,
+        channel: ctx.channelId || ctx.provider,
+        timestamp: new Date().toISOString(),
+      });
 
-          // ── Proactive Surfacing Feedback Loop ──────────────────────
-          // Check if the agent's response referenced any proactively surfaced memories
-          try {
-            const surfaced = proactiveSurfacedMemories.get(currentAgent);
-            if (surfaced && (Date.now() - surfaced.timestamp) < 600000) { // within 10min
-              const contentLower = content.toLowerCase();
-              const usedIds: string[] = [];
-
-              for (const memId of surfaced.memoryIds) {
-                // Check if the memory ID or content from proactive surfacing appears in the response
-                if (contentLower.includes(memId.toLowerCase())) {
-                  usedIds.push(memId);
-                }
-              }
+      // Clean up old pending entries after 10 min
+      setTimeout(() => pendingUserMessages.delete(conversationId), 10 * 60 * 1000);
+    },
+    {
+      name: 'memtap.capture-inbound',
+      description: 'Buffer inbound user messages for capture pairing',
+    }
+  );
 
-              // Also do a fuzzy check: recall proactive memories and see if their content appears
-              if (usedIds.length === 0 && surfaced.memoryIds.length > 0) {
-                for (const memId of surfaced.memoryIds) {
-                  try {
-                    const memData = await bbFetch(cfg, `${baseUrl(cfg)}/memories/${encodeURIComponent(memId)}`);
-                    const memContent = (memData.content || '').toLowerCase();
-                    // Check if key phrases from the memory appear in the response
-                    const keyPhrases = memContent.split(/\s+/).filter((w: string) => w.length > 5).slice(0, 5);
-                    const matchCount = keyPhrases.filter((phrase: string) => contentLower.includes(phrase)).length;
-                    if (matchCount >= 2) {
-                      usedIds.push(memId);
-                    }
-                  } catch { /* skip */ }
-                }
-              }
+  // Capture assistant's outbound reply (pair with buffered user message, then POST to /capture)
+  api.registerHook(
+    'message:sent',
+    async (event: any) => {
+      const cfg = getConfig(api);
+      if (!cfg.captureEnabled && !cfg.autoCapture) return;
 
-              // Importance reinforcement for used proactive memories
-              if (usedIds.length > 0) {
-                for (const memId of usedIds) {
-                  try {
-                    await bbFetch(cfg, `${baseUrl(cfg)}/memories/${encodeURIComponent(memId)}/access`, {
-                      method: 'POST',
-                      body: JSON.stringify({
-                        boost: FORGETTING_CURVE.retrievalStrengthening * 1.5, // Extra boost for proactive hit
-                        lastAccess: Date.now(),
-                        attentionLevel: 'proactive-hit',
-                        reinforcement: {
-                          proactiveHit: true,
-                          adaptiveDecayRate: Math.max(0.001, (cfg.decayRate || FORGETTING_CURVE.baseDecayRate) * 0.5)
-                        }
-                      })
-                    });
-                  } catch { /* reinforcement failed, not critical */ }
-                }
+      const ctx = event || event?.context || {};
+      const assistantContent = ctx.content || '';
+      if (!assistantContent || typeof assistantContent !== 'string') return;
+      if (assistantContent === 'NO_REPLY' || assistantContent === 'HEARTBEAT_OK') return;
+      if (assistantContent.length < (cfg.captureMinLength || 80)) return;
+      if (ctx.success === false) return;
 
-                logger.info?.(`[memtap] Proactive surfacing feedback: ${usedIds.length}/${surfaced.memoryIds.length} memories used by agent`) ??
-                  console.log(`[memtap] Proactive surfacing feedback: ${usedIds.length}/${surfaced.memoryIds.length} memories used by agent`);
-              }
+      const conversationId = ctx.conversationId || ctx.to || ctx.groupId || 'default';
+      const buffered = pendingUserMessages.get(conversationId);
+      const userMessage = buffered?.content;
 
-              // Clear after processing
-              proactiveSurfacedMemories.delete(currentAgent);
-            }
-          } catch { /* proactive feedback loop failed, not critical */ }
+      // Clear buffer
+      if (buffered) pendingUserMessages.delete(conversationId);
 
-        } catch (err: any) {
-          logger.warn?.(`[memtap] Auto-capture failed: ${err.message}`) ??
-            console.warn(`[memtap] Auto-capture failed: ${err.message}`);
-        }
-      })();
+      try {
+        await bbFetch(cfg, `${baseUrl(cfg)}/capture`, {
+          method: 'POST',
+          body: JSON.stringify({
+            agent: agentId(cfg, api),
+            conversation: {
+              userMessage,
+              assistantMessage: assistantContent,
+              context: {
+                channel: ctx.channelId,
+                conversationId,
+                timestamp: new Date().toISOString(),
+              },
+            },
+          }),
+        });
+        if (cfg.debug) console.log('[memtap] capture posted');
+      } catch (err) {
+        // Silent fail — capture is non-critical
+        if (cfg.debug) console.error('[memtap] capture failed:', err);
+      }
     },
     {
-      name: 'memtap.auto-capture-enhanced',
-      description: 'Enhanced LLM-based memory extraction with context awareness and cross-session sharing',
+      name: 'memtap.server-capture',
+      description: 'Server-side memory extraction via /v1/capture',
     }
   );
 

package/openclaw.plugin.json

@@ -2,11 +2,13 @@
   "id": "memtap",
   "name": "MemTap",
   "kind": "memory",
-  "version": "3.2.0",
-  "description": "Graph-based long-term memory for OpenClaw agents — semantic recall, GraphRAG, entity management, decision tracking, neural auto-capture, anomaly detection, consolidation, profiles, and adaptive decay.",
+  "version": "4.0.1",
+  "description": "Graph-based long-term memory for OpenClaw agents \u2014 semantic recall, GraphRAG, entity management, decision tracking, neural auto-capture, anomaly detection, consolidation, profiles, and adaptive decay.",
   "defaultConfig": {
     "serverUrl": "https://api.memtap.ai",
     "autoCapture": true,
+    "captureEnabled": true,
+    "captureMinLength": 80,
     "bulletinOnBoot": true
   },
   "configSchema": {
@@ -28,7 +30,19 @@
       },
       "autoCapture": {
         "type": "boolean",
-        "description": "Automatically extract memories from conversations"
+        "description": "Automatically extract memories from conversations (alias for captureEnabled)"
+      },
+      "captureEnabled": {
+        "type": "boolean",
+        "description": "Enable server-side auto-capture of memories from conversations (default true)"
+      },
+      "captureMinLength": {
+        "type": "number",
+        "description": "Minimum message length to trigger capture (default 80 chars)"
+      },
+      "debug": {
+        "type": "boolean",
+        "description": "Enable debug logging for capture and other operations"
       },
       "bulletinOnBoot": {
         "type": "boolean",
@@ -72,12 +86,16 @@
         "properties": {
           "include": {
             "type": "array",
-            "items": { "type": "string" },
+            "items": {
+              "type": "string"
+            },
             "description": "Patterns to prioritize in recall (boost matching memories)"
           },
           "exclude": {
             "type": "array",
-            "items": { "type": "string" },
+            "items": {
+              "type": "string"
+            },
             "description": "Patterns to exclude from recall results"
           }
         }
@@ -137,4 +155,4 @@
       "helpText": "Include/exclude patterns for memory recall filtering"
     }
   }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memtap",
-  "version": "3.2.0",
+  "version": "4.0.1",
   "description": "MemTap — Graph-based long-term memory plugin for OpenClaw agents. Knowledge graph with semantic recall, GraphRAG, entity management, decision tracking, and auto-capture.",
   "keywords": [
     "openclaw",