refactor: remove MemoryEventBus and integrate logging for memory operations + prompt changes

Author: keshav1sharma

src/lib/agent/BrowserAgent.prompt.ts

@@ -54,19 +54,37 @@ ${toolDescriptions}
 ## 🔌 MCP SERVER INTEGRATION
 You have access to MCP (Model Context Protocol) servers that provide direct API access to external services.
 
-### CRITICAL: Three-Step Process (NEVER SKIP STEPS)
-When users ask about emails, videos, documents, calendars, repositories, or other external services:
-
+### CRITICAL: MEMORY FIRST, MCP SECOND
+**ALWAYS check memory_tool FIRST when user asks about personal/saved data**
+**ONLY use MCP when user explicitly mentions these EXACT services:**
+
+### 🎯 MCP ACTIVATION TRIGGERS (Must Be Explicit):
+**Use MCP ONLY when user specifically mentions:**
+- **Gmail/Email**: "check my Gmail", "my emails", "inbox", "send email"
+- **YouTube**: "my YouTube videos", "YouTube channel", "upload to YouTube" 
+- **GitHub**: "my GitHub repos", "GitHub repository", "commit to GitHub"
+- **Slack**: "Slack messages", "Slack channels", "post to Slack"
+- **Google Calendar**: "my calendar", "Google Calendar", "schedule meeting"
+- **Google Drive**: "my Google Drive", "Drive files", "upload to Drive"
+- **Notion**: "my Notion pages", "Notion workspace", "create Notion page"
+- **Linear**: "Linear issues", "Linear tickets", "create Linear issue"
+
+### 🚫 DO NOT USE MCP FOR:
+- Generic terms: "books", "documents", "files", "videos", "music"
+- "My saved [anything]" → This is ALWAYS memory, never MCP
+- "Suggest from my [anything]" → This is ALWAYS memory, never MCP
+- "My preferences" → This is ALWAYS memory, never MCP
+- User mentions platforms but doesn't want live data (e.g., "like the book I saved from Goodreads")
+
+### CRITICAL: Three-Step Process for MCP Integration (ONLY after explicit service mention)
 **🔴 STEP 1: MANDATORY - Check Installed MCP Servers**
 - Use: mcp_tool with action: 'getUserInstances'
 - Returns: List of installed servers with their instance IDs
-- Example response: { instances: [{ id: 'a146178c-e0c8-416c-96cd-6fbe809e0cf8', name: 'Gmail', authenticated: true }] }
 - SAVE the instance ID for next steps
 
 **🔴 STEP 2: MANDATORY - Get Available Tools (NEVER SKIP THIS)**
 - Use: mcp_tool with action: 'listTools', instanceId: [EXACT ID from step 1]
 - Returns: List of available tools for that server
-- Example response: { tools: [{ name: 'gmail_search', description: 'Search emails' }, { name: 'gmail_send', description: 'Send email' }] }
 - DO NOT GUESS TOOL NAMES - you MUST get them from listTools
 
 **🔴 STEP 3: Call the Tool**

src/lib/memory/MemoryEventBus.ts

@@ -1,7 +1,7 @@
 import { MemoryEntry, MemoryMetadata, MemorySearchParams, MemorySearchResult, MemoryOperationResult, MemoryConfig, MemoryStats, MemoryCategory, TaskContext, AgentMemoryContext } from './types';
 import { Mem0ClientWrapper } from './Mem0ClientWrapper';
-import { MemoryEventBus } from './MemoryEventBus';
 import { v4 as uuidv4 } from 'uuid';
+import { Logging } from '@/lib/utils/Logging'
 
 /**
  * MemoryManager - Central orchestrator for the memory system
@@ -11,27 +11,15 @@ import { v4 as uuidv4 } from 'uuid';
  */
 export class MemoryManager {
   private mem0Client: Mem0ClientWrapper;
-  private eventBus: MemoryEventBus;
   private config: MemoryConfig;
   private agentId: string;
   private sessionId: string;
 
   constructor(apiKey?: string, config: Partial<MemoryConfig> = {}, agentId: string = 'default') {
     this.mem0Client = new Mem0ClientWrapper(apiKey);
-    this.eventBus = new MemoryEventBus();
     this.agentId = agentId;
     this.sessionId = uuidv4();
 
-    this.eventBus.subscribe((event) => {
-      console.log('🧠 Memory Event:', {
-        type: event.type,
-        agentId: event.data.agentId,
-        category: event.data.category,
-        tabId: event.data.tabId,
-        timestamp: event.data.timestamp.toISOString()
-      });
-    });
-
     // Merge with default config
     this.config = {
       enabled: true,
@@ -89,13 +77,7 @@ export class MemoryManager {
           updatedAt: new Date()
         };
 
-        this.eventBus.emit('memory_added', {
-          entryId: memoryEntry.id,
-          category: fullMetadata.category,
-          agentId: this.agentId,
-          tabId: fullMetadata.tabId,
-          timestamp: new Date()
-        });
+        Logging.log('MemoryManager', `Memory added successfully: ${memoryEntry.id}`);
 
         return {
           success: true,
@@ -131,16 +113,11 @@ export class MemoryManager {
 
       const result = await this.mem0Client.searchMemories(searchParams);
 
-      this.eventBus.emit('memory_searched', {
-        category: searchParams.category,
-        agentId: this.agentId,
-        tabId: searchParams.tabId,
-        timestamp: new Date()
-      });
+      Logging.log('MemoryManager', `Memory search completed: ${searchParams.query}`);
 
       return result;
     } catch (error) {
-      console.error('Memory search failed:', error);
+      Logging.log('MemoryManager', `Memory search failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
       return { entries: [], total: 0, hasMore: false };
     }
   }
@@ -320,18 +297,12 @@ export class MemoryManager {
     return this.agentId;
   }
 
-  /**
-   * Subscribe to memory events
-   */
-  onMemoryEvent(callback: (event: any) => void): void {
-    this.eventBus.subscribe(callback);
-  }
 
   /**
    * Cleanup old memories based on retention policy
    */
   async cleanup(): Promise<void> {
-    if (!this.config.autoCleanup) {
+        if (!this.config.autoCleanup) {
       return;
     }
 

src/lib/memory/MemoryManager.ts

@@ -8,13 +8,13 @@
 // Core components
 export { MemoryManager } from './MemoryManager';
 export { Mem0ClientWrapper } from './Mem0ClientWrapper';
-export { MemoryEventBus } from './MemoryEventBus';
+import { Logging } from '@/lib/utils/Logging'
 
 // Import for factory functions
 import { MemoryManager } from './MemoryManager';
 
 // Types and schemas
-export type { MemoryEntry, MemoryMetadata, MemorySearchParams, MemorySearchResult, MemoryOperationResult, MemoryConfig, MemoryStats, TaskContext, AgentMemoryContext, MemoryEvent } from './types';
+export type { MemoryEntry, MemoryMetadata, MemorySearchParams, MemorySearchResult, MemoryOperationResult, MemoryConfig, MemoryStats, TaskContext, AgentMemoryContext } from './types';
 
 export { MemoryCategory, MemoryEntrySchema, MemoryMetadataSchema, MemorySearchParamsSchema, MemoryStatsSchema, MemoryConfigSchema } from './types';
 
@@ -61,7 +61,7 @@ export async function initializeMemorySystem(apiKey?: string, agentId?: string):
     await memoryManager.initialize();
     return memoryManager;
   } catch (error) {
-    console.warn('Failed to initialize memory system:', error);
+    Logging.log('MemorySystem', `Failed to initialize memory system: ${error instanceof Error ? error.message : 'Unknown error'}`);
     return null;
   }
 }

src/lib/memory/index.ts

@@ -132,18 +132,3 @@ export interface AgentMemoryContext {
   }>;
 }
 
-// Memory events for coordination
-export interface MemoryEvent {
-  type:
-    | "memory_added"
-    | "memory_updated"
-    | "memory_deleted"
-    | "memory_searched";
-  data: {
-    entryId?: string;
-    category?: MemoryCategory;
-    agentId: string;
-    tabId?: number;
-    timestamp: Date;
-  };
-}

src/lib/memory/types.ts

@@ -102,7 +102,7 @@ You have access to a persistent memory system for task continuity and learning a
 ### 🎯 MEMORY ACTIVATION TRIGGERS:
 **AUTOMATIC TRIGGERS** - Use memory tool when you encounter these patterns:
 - User says: "save", "store", "remember", "recall", "what did I", "my preferences", "last time", "before", "previously"
-- User asks: "continue where I left off", "use my usual settings", "what was that thing I searched for"
+- User asks: "continue where I left off", "use my usual settings", "what was that thing I searched for", "show me my saved items", "what you know about me", etc.
 - User mentions: "bookmark this", "keep this for later", "I need this information again"
 - Tasks involving: user preferences, repeated patterns, multi-step workflows, cross-tab context
 - When you find: important information that could be useful later, user-specific details, successful patterns