Implement hybrid session management system for Matrix chat

spencrmartin · spencrmartin · commit 7058ea76b6e6 · 2025-11-14T21:39:40.000-05:00
Core Implementation:
- Created SessionMappingService to manage Matrix room ID ↔ Goose session ID relationships
- Added automatic session mapping creation when joining/creating Matrix rooms
- Updated useChatEngine and useMessageStream to use mapped Goose session IDs for backend calls
- Matrix room IDs still used for Matrix operations, Goose session IDs for backend APIs

Key Features:
- Automatic Goose session ID generation (YYYYMMDD_HHMMSS format)
- Persistent mapping storage in localStorage with cleanup of old mappings
- Session mapping ensures backend compatibility for token counting and SSE streams
- Proper session persistence and reload functionality
- Comprehensive logging for debugging session ID mapping

Backend Integration:
- Session token fetching now uses mapped Goose session IDs
- SSE stream session handling uses mapped session IDs
- Matrix room operations continue using Matrix room IDs
- Eliminates 'Session not found' errors for Matrix collaborative sessions

This resolves the fundamental incompatibility between Matrix room IDs and Goose session IDs,
enabling full backend functionality while preserving Matrix collaborative features.
diff --git a/ui/desktop/src/hooks/useChatEngine.ts b/ui/desktop/src/hooks/useChatEngine.ts
@@ -16,6 +16,7 @@ import {
 import { ChatType } from '../types/chat';
 import { ChatState } from '../types/chatState';
 import { getSession } from '../api';
+import { sessionMappingService } from '../services/SessionMappingService';
 
 // Force rebuild timestamp: 2025-01-15T02:35:00Z - Fixed Matrix session token fetching
 
@@ -75,6 +76,15 @@ export const useChatEngine = ({
     }
   }, [powerSaveTimeoutId]);
 
+  // Get the appropriate session ID for backend API calls
+  const backendSessionId = sessionMappingService.getBackendSessionId(chat.sessionId);
+  
+  console.log('📋 useChatEngine: Session ID mapping:', {
+    originalSessionId: chat.sessionId,
+    backendSessionId,
+    isMatrixSession: chat.sessionId.startsWith('!'),
+  });
+
   const {
     messages,
     append: originalAppend,
@@ -91,10 +101,10 @@ export const useChatEngine = ({
     setError,
   } = useMessageStream({
     api: getApiUrl('/reply'),
-    id: chat.sessionId,
+    id: chat.sessionId, // Keep original ID for frontend state management
     initialMessages: chat.messages,
     body: {
-      session_id: chat.sessionId,
+      session_id: backendSessionId, // Use mapped session ID for backend
       session_working_dir: window.appConfig.get('GOOSE_WORKING_DIR'),
       ...(chat.recipeConfig?.title
         ? {
@@ -236,8 +246,17 @@ export const useChatEngine = ({
   useEffect(() => {
     const fetchSessionTokens = async () => {
       try {
+        // Use session mapping service to get the appropriate backend session ID
+        const backendSessionId = sessionMappingService.getBackendSessionId(chat.sessionId);
+        
+        console.log('📋 Fetching session tokens:', {
+          originalSessionId: chat.sessionId,
+          backendSessionId,
+          isMatrixSession: chat.sessionId.startsWith('!'),
+        });
+        
         const response = await getSession<true>({
-          path: { session_id: chat.sessionId },
+          path: { session_id: backendSessionId },
           throwOnError: true,
         });
         const sessionDetails = response.data;
@@ -249,13 +268,8 @@ export const useChatEngine = ({
       }
     };
     
-    // Skip session token fetching for Matrix sessions (room IDs start with '!')
-    // Matrix sessions don't have traditional Goose session data on the backend
-    const isMatrixSession = chat.sessionId && chat.sessionId.startsWith('!');
-    
     // Only fetch session tokens when chat state is idle to avoid resetting during streaming
-    // and when it's not a Matrix session
-    if (chat.sessionId && chatState === ChatState.Idle && !isMatrixSession) {
+    if (chat.sessionId && chatState === ChatState.Idle) {
       fetchSessionTokens();
     }
   }, [chat.sessionId, messages, chatState]);
diff --git a/ui/desktop/src/hooks/useMessageStream.ts b/ui/desktop/src/hooks/useMessageStream.ts
@@ -3,6 +3,7 @@ import useSWR from 'swr';
 import { createUserMessage, hasCompletedToolCalls, Message, Role } from '../types/message';
 import { getSession, Session } from '../api';
 import { ChatState } from '../types/chatState';
+import { sessionMappingService } from '../services/SessionMappingService';
 
 // Force rebuild timestamp: 2025-01-15T02:35:00Z - Fixed Matrix session SSE stream error
 
@@ -343,14 +344,19 @@ export function useMessageStream({
                     const sessionId = (extraMetadataRef.current.body as Record<string, unknown>)
                       ?.session_id as string;
                     
-                    // Skip session fetching for Matrix sessions (room IDs start with '!')
-                    // Matrix sessions don't have traditional Goose session data on the backend
-                    const isMatrixSession = sessionId && sessionId.startsWith('!');
-                    
-                    if (sessionId && !isMatrixSession) {
+                    if (sessionId) {
                       try {
+                        // Use session mapping service to get the appropriate backend session ID
+                        const backendSessionId = sessionMappingService.getBackendSessionId(sessionId);
+                        
+                        console.log('📋 Fetching session data in SSE Finish:', {
+                          originalSessionId: sessionId,
+                          backendSessionId,
+                          isMatrixSession: sessionId.startsWith('!'),
+                        });
+                        
                         const sessionResponse = await getSession({
-                          path: { session_id: sessionId },
+                          path: { session_id: backendSessionId },
                           throwOnError: true,
                         });
 
@@ -359,7 +365,7 @@ export function useMessageStream({
                         }
                       } catch (err) {
                         console.error('Error fetching session data:', err);
-                        // Don't throw here, just log the error for Matrix sessions
+                        // Don't throw here, just log the error
                       }
                     }
                     break;
diff --git a/ui/desktop/src/services/MatrixService.ts b/ui/desktop/src/services/MatrixService.ts
@@ -1,5 +1,6 @@
 import * as sdk from 'matrix-js-sdk';
 import { EventEmitter } from 'events';
+import { sessionMappingService, SessionMappingService } from './SessionMappingService';
 
 export interface MatrixUser {
   userId: string;
@@ -783,6 +784,17 @@ export class MatrixService extends EventEmitter {
       // We'll use regular message types instead of custom ones
     });
 
+    // Create session mapping for this Matrix room
+    const participants = [this.config.userId!, ...inviteUserIds];
+    const mapping = sessionMappingService.createMapping(room.room_id, participants, name);
+    
+    console.log('📋 Created AI session with mapping:', {
+      matrixRoomId: room.room_id,
+      gooseSessionId: mapping.gooseSessionId,
+      participants: participants.length,
+      name,
+    });
+
     return room.room_id;
   }
 
@@ -812,6 +824,9 @@ export class MatrixService extends EventEmitter {
       const existingRoom = this.client.getRoom(roomId);
       if (existingRoom && existingRoom.getMyMembership() === 'join') {
         console.log('✅ Already joined room:', roomId);
+        
+        // Still ensure session mapping exists for this room
+        this.ensureSessionMapping(roomId, existingRoom);
         return;
       }
 
@@ -823,6 +838,12 @@ export class MatrixService extends EventEmitter {
       this.cachedRooms = null;
       this.cachedFriends = null;
       
+      // Get the room after joining to create session mapping
+      const joinedRoom = this.client.getRoom(roomId);
+      if (joinedRoom) {
+        this.ensureSessionMapping(roomId, joinedRoom);
+      }
+      
       // Emit join event
       this.emit('roomJoined', { roomId });
       
@@ -856,6 +877,35 @@ export class MatrixService extends EventEmitter {
     }
   }
 
+  /**
+   * Ensure a session mapping exists for a Matrix room
+   */
+  private ensureSessionMapping(roomId: string, room: any): void {
+    // Check if mapping already exists
+    const existingMapping = sessionMappingService.getMapping(roomId);
+    if (existingMapping) {
+      console.log('📋 Session mapping already exists for room:', roomId, '→', existingMapping.gooseSessionId);
+      
+      // Update participants if needed
+      const currentParticipants = room.getMembers().map((member: any) => member.userId);
+      sessionMappingService.updateParticipants(roomId, currentParticipants);
+      return;
+    }
+
+    // Create new mapping if none exists
+    const participants = room.getMembers().map((member: any) => member.userId);
+    const roomName = room.name || `Matrix Room ${roomId.substring(1, 8)}`;
+    
+    const mapping = sessionMappingService.createMapping(roomId, participants, roomName);
+    
+    console.log('📋 Created session mapping for joined room:', {
+      matrixRoomId: roomId,
+      gooseSessionId: mapping.gooseSessionId,
+      participants: participants.length,
+      roomName,
+    });
+  }
+
   /**
    * Get all rooms the user is in
    */
diff --git a/ui/desktop/src/services/SessionMappingService.ts b/ui/desktop/src/services/SessionMappingService.ts
