Merge pull request #19 from baryhuang/claude/issue-6-20250802-2142

feat: implement agent message history isolation

Author: baryhuang

backend/handlers/agentHistories.ts

@@ -14,6 +14,7 @@ export async function handleAgentHistoriesRequest(c: Context) {
   try {
     const { debugMode, runtime } = c.var.config;
     const encodedProjectName = c.req.param("encodedProjectName");
+    const agentId = c.req.query("agentId"); // Get agent ID from query parameter
 
     if (!encodedProjectName) {
       return c.json({ error: "Encoded project name is required" }, 400);
@@ -65,16 +66,45 @@ export async function handleAgentHistoriesRequest(c: Context) {
     }
 
     // Group conversations and remove duplicates
-    const conversations = groupConversations(conversationFiles);
+    const groupedConversations = groupConversations(conversationFiles);
+
+    // Filter conversations by agent ID if provided
+    let filteredConversations = groupedConversations;
+    if (agentId) {
+      filteredConversations = groupedConversations.filter(conversation => {
+        // Find the corresponding conversation file to check agent ID
+        const conversationFile = conversationFiles.find(file => 
+          file.sessionId === conversation.sessionId
+        );
+        return conversationFile?.agentId === agentId;
+      });
+
+      if (debugMode) {
+        console.debug(
+          `[DEBUG] Filtered to ${filteredConversations.length} conversations for agent: ${agentId}`,
+        );
+      }
+    }
+
+    // Add agent ID to the conversation summaries
+    const conversationsWithAgentId = filteredConversations.map(conversation => {
+      const conversationFile = conversationFiles.find(file => 
+        file.sessionId === conversation.sessionId
+      );
+      return {
+        ...conversation,
+        agentId: conversationFile?.agentId
+      };
+    });
 
     if (debugMode) {
       console.debug(
-        `[DEBUG] After grouping: ${conversations.length} unique agent conversations`,
+        `[DEBUG] After grouping and filtering: ${conversationsWithAgentId.length} unique agent conversations`,
       );
     }
 
     const response: HistoryListResponse = {
-      conversations,
+      conversations: conversationsWithAgentId,
     };
 
     return c.json(response);

backend/history/grouping.ts

@@ -64,6 +64,7 @@ function createConversationSummary(
     lastTime: conversationFile.lastTime,
     messageCount: conversationFile.messageCount,
     lastMessagePreview: conversationFile.lastMessagePreview,
+    agentId: conversationFile.agentId,
   };
 }
 

backend/history/parser.ts

@@ -22,6 +22,7 @@ export interface RawHistoryLine {
   cwd?: string;
   version?: string;
   requestId?: string;
+  agentId?: string; // Agent that created this conversation line
 }
 
 // Legacy interface maintained for transition period
@@ -35,6 +36,7 @@ export interface ConversationFile {
   lastTime: string;
   messageCount: number;
   lastMessagePreview: string;
+  agentId?: string; // Agent that created this conversation
 }
 
 /**
@@ -61,12 +63,18 @@ async function parseHistoryFile(
     let startTime = "";
     let lastTime = "";
     let lastMessagePreview = "";
+    let agentId: string | undefined;
 
     for (const line of lines) {
       try {
         const parsed = JSON.parse(line) as RawHistoryLine;
         messages.push(parsed);
 
+        // Extract agent ID from the first message that has one
+        if (!agentId && parsed.agentId) {
+          agentId = parsed.agentId;
+        }
+
         // Track message IDs from assistant messages
         if (parsed.message?.role === "assistant" && "id" in parsed.message && parsed.message.id) {
           messageIds.add(parsed.message.id);
@@ -114,6 +122,7 @@ async function parseHistoryFile(
       lastTime,
       messageCount: messages.length,
       lastMessagePreview: lastMessagePreview || "No preview available",
+      agentId,
     };
   } catch (error) {
     console.error(`Failed to read history file ${filePath}:`, error);

backend/history/timestampRestore.ts

@@ -66,6 +66,7 @@ export function calculateConversationMetadata(messages: RawHistoryLine[]): {
   startTime: string;
   endTime: string;
   messageCount: number;
+  agentId?: string;
 } {
   if (messages.length === 0) {
     const now = new Date().toISOString();
@@ -81,10 +82,14 @@ export function calculateConversationMetadata(messages: RawHistoryLine[]): {
   const startTime = sortedMessages[0].timestamp;
   const endTime = sortedMessages[sortedMessages.length - 1].timestamp;
 
+  // Extract agent ID from the first message that has one
+  const agentId = messages.find(msg => msg.agentId)?.agentId;
+
   return {
     startTime,
     endTime,
     messageCount: messages.length,
+    agentId,
   };
 }
 
@@ -101,6 +106,7 @@ export function processConversationMessages(
     startTime: string;
     endTime: string;
     messageCount: number;
+    agentId?: string;
   };
 } {
   // Restore timestamps

frontend/src/components/native/AgentDetailView.tsx

@@ -129,43 +129,17 @@ export function AgentDetailView({
       const agentProjects = await remoteHistory.fetchAgentProjects(agent.apiEndpoint);
       console.log(`📁 Found ${agentProjects.length} projects for agent ${agent.name}`);
 
-      // Filter projects to only those relevant to this agent
-      const relevantProjects = agentProjects.filter(project => {
-        // Filter by agent's working directory or related keywords
-        const agentWorkingDir = agent.workingDirectory.toLowerCase();
-        const projectPath = project.path.toLowerCase();
-        
-        // Extract keywords from agent working directory and description
-        const agentKeywords = [
-          ...agentWorkingDir.split(/[/\\-_\s]+/).filter(Boolean),
-          ...agent.description.toLowerCase().split(/[\s,.-]+/).filter(Boolean),
-          agent.id.toLowerCase()
-        ];
-        
-        // Check if project path contains any agent-specific keywords
-        const isRelevant = agentKeywords.some(keyword => 
-          keyword.length > 2 && projectPath.includes(keyword)
-        );
-        
-        console.log(`📂 Project: ${project.path}`);
-        console.log(`🔍 Agent keywords: ${agentKeywords.join(", ")}`);
-        console.log(`✅ Is relevant: ${isRelevant}`);
-        
-        return isRelevant;
-      });
-      
-      console.log(`🎯 Filtered to ${relevantProjects.length} relevant projects for agent ${agent.name}`);
-      console.log(`📋 Relevant projects: ${relevantProjects.map(p => p.path).join(", ")}`);
-      
-      // Collect all conversations from relevant projects only
+      // Collect all conversations from all projects for this agent
+      // Backend will filter by agent ID, so no need for fragile keyword matching
       const allAgentConversations: ConversationSummary[] = [];
 
-      for (const project of relevantProjects) {
+      for (const project of agentProjects) {
         try {
           console.log(`📖 Loading conversations from project: ${project.path}`);
           const projectHistories = await remoteHistory.fetchAgentHistories(
             agent.apiEndpoint, 
-            project.encodedName
+            project.encodedName,
+            agent.id // Pass agent ID for filtering
           );
           console.log(`💬 Found ${projectHistories.length} conversations in project ${project.path}`);
           allAgentConversations.push(...projectHistories);
@@ -197,32 +171,16 @@ export function AgentDetailView({
       setHistoryLoading(true);
       setHistoryError(null);
 
-      // Try to find the conversation in relevant projects only
+      // Try to find the conversation in all agent projects
       let foundProject = null;
 
       try {
         const agentProjects = await remoteHistory.fetchAgentProjects(agent.apiEndpoint);
 
-        // Filter to only relevant projects (same logic as loadAgentHistory)
-        const relevantProjects = agentProjects.filter(project => {
-          const agentWorkingDir = agent.workingDirectory.toLowerCase();
-          const projectPath = project.path.toLowerCase();
-          
-          const agentKeywords = [
-            ...agentWorkingDir.split(/[/\\-_\s]+/).filter(Boolean),
-            ...agent.description.toLowerCase().split(/[\s,.-]+/).filter(Boolean),
-            agent.id.toLowerCase()
-          ];
-          
-          return agentKeywords.some(keyword => 
-            keyword.length > 2 && projectPath.includes(keyword)
-          );
-        });
-        
-        console.log(`🔍 Searching for session ${sessionId} in ${relevantProjects.length} relevant projects`);
+        console.log(`🔍 Searching for session ${sessionId} in ${agentProjects.length} projects`);
 
-        // Try each relevant project until we find one with this session
-        for (const project of relevantProjects) {
+        // Try each project until we find one with this session
+        for (const project of agentProjects) {
           try {
             const conversation = await remoteHistory.fetchAgentConversation(
               agent.apiEndpoint,

frontend/src/config/api.ts

@@ -60,9 +60,13 @@ export const getAgentProjectsUrl = (agentEndpoint: string) => {
   return `${agentEndpoint}${API_CONFIG.ENDPOINTS.AGENT_PROJECTS}`;
 };
 
-export const getAgentHistoriesUrl = (agentEndpoint: string, projectPath: string) => {
+export const getAgentHistoriesUrl = (agentEndpoint: string, projectPath: string, agentId?: string) => {
   const encodedPath = encodeURIComponent(projectPath);
-  return `${agentEndpoint}${API_CONFIG.ENDPOINTS.AGENT_HISTORIES}/${encodedPath}`;
+  const baseUrl = `${agentEndpoint}${API_CONFIG.ENDPOINTS.AGENT_HISTORIES}/${encodedPath}`;
+  if (agentId) {
+    return `${baseUrl}?agentId=${encodeURIComponent(agentId)}`;
+  }
+  return baseUrl;
 };
 
 export const getAgentConversationUrl = (

frontend/src/hooks/useRemoteAgentHistory.ts

@@ -5,7 +5,7 @@ import { getAgentProjectsUrl, getAgentHistoriesUrl, getAgentConversationUrl } fr
 interface RemoteAgentHistoryCache {
   [agentEndpoint: string]: {
     projects?: ProjectInfo[];
-    histories?: { [projectId: string]: ConversationSummary[] };
+    histories?: { [key: string]: ConversationSummary[] }; // key: `${projectId}:${agentId || 'all'}`
     conversations?: { [key: string]: ConversationHistory }; // key: `${projectId}:${sessionId}`
     lastFetch?: number;
   };
@@ -63,17 +63,19 @@ export function useRemoteAgentHistory() {
 
   const fetchAgentHistories = useCallback(async (
     agentEndpoint: string, 
-    projectId: string
+    projectId: string,
+    agentId?: string
   ): Promise<ConversationSummary[]> => {
-    if (isCacheValid(agentEndpoint, 'histories') && cache[agentEndpoint].histories?.[projectId]) {
-      return cache[agentEndpoint].histories![projectId];
+    const cacheKey = `${projectId}:${agentId || 'all'}`;
+    if (isCacheValid(agentEndpoint, 'histories') && cache[agentEndpoint].histories?.[cacheKey]) {
+      return cache[agentEndpoint].histories![cacheKey];
     }
 
     try {
       setLoading(true);
       setError(null);
 
-      const response = await fetch(getAgentHistoriesUrl(agentEndpoint, projectId));
+      const response = await fetch(getAgentHistoriesUrl(agentEndpoint, projectId, agentId));
       if (!response.ok) {
         throw new Error(`Failed to fetch agent histories: ${response.statusText}`);
       }
@@ -86,7 +88,7 @@ export function useRemoteAgentHistory() {
           ...prev[agentEndpoint],
           histories: {
             ...prev[agentEndpoint]?.histories,
-            [projectId]: data.conversations,
+            [cacheKey]: data.conversations,
           },
           lastFetch: Date.now(),
         }
@@ -161,8 +163,9 @@ export function useRemoteAgentHistory() {
     return cache[agentEndpoint]?.projects;
   }, [cache]);
 
-  const getCachedHistories = useCallback((agentEndpoint: string, projectId: string): ConversationSummary[] | undefined => {
-    return cache[agentEndpoint]?.histories?.[projectId];
+  const getCachedHistories = useCallback((agentEndpoint: string, projectId: string, agentId?: string): ConversationSummary[] | undefined => {
+    const cacheKey = `${projectId}:${agentId || 'all'}`;
+    return cache[agentEndpoint]?.histories?.[cacheKey];
   }, [cache]);
 
   const getCachedConversation = useCallback((

shared/types.ts

@@ -40,6 +40,7 @@ export interface ConversationSummary {
   lastTime: string;
   messageCount: number;
   lastMessagePreview: string;
+  agentId?: string; // Agent that created this conversation
 }
 
 export interface HistoryListResponse {
@@ -67,6 +68,7 @@ export interface ConversationHistory {
     startTime: string;
     endTime: string;
     messageCount: number;
+    agentId?: string; // Agent that created this conversation
   };
 }