Fix Matrix chat history loading and backend compatibility

Enhanced Session Mapping Service:
- Modified getBackendSessionId to return null for Matrix sessions without mappings
- Added shouldMakeBackendCalls method to check if backend calls should be made
- Added ensureMappingExists method for creating mappings for existing Matrix rooms
- Prevents 404 errors when loading Matrix chat history without existing mappings

Updated Backend Integration:
- useChatEngine now skips session token fetching for Matrix sessions without mappings
- useMessageStream SSE handling skips session data fetching for unmapped Matrix sessions
- Proper null checking prevents backend API calls with Matrix room IDs
- Comprehensive logging for debugging session mapping decisions

Matrix Chat History Support:
- Matrix sessions loaded from history no longer cause backend 404 errors
- Sessions without mappings gracefully skip backend calls while maintaining Matrix functionality
- Future enhancement: can create mappings on-demand for existing Matrix rooms
- Maintains full compatibility with existing Goose sessions

This resolves the 'GET /sessions/!roomId 404 Not Found' errors when loading Matrix chat history
while preserving all Matrix collaborative features and backend compatibility for mapped sessions.

Author: spencrmartin

ui/desktop/src/hooks/useChatEngine.ts

@@ -78,11 +78,13 @@ export const useChatEngine = ({
 
   // Get the appropriate session ID for backend API calls
   const backendSessionId = sessionMappingService.getBackendSessionId(chat.sessionId);
+  const shouldMakeBackendCalls = sessionMappingService.shouldMakeBackendCalls(chat.sessionId);
 
   console.log('📋 useChatEngine: Session ID mapping:', {
     originalSessionId: chat.sessionId,
     backendSessionId,
     isMatrixSession: chat.sessionId.startsWith('!'),
+    shouldMakeBackendCalls,
   });
 
   const {
@@ -104,7 +106,7 @@ export const useChatEngine = ({
     id: chat.sessionId, // Keep original ID for frontend state management
     initialMessages: chat.messages,
     body: {
-      session_id: backendSessionId, // Use mapped session ID for backend
+      session_id: backendSessionId || chat.sessionId, // Use mapped session ID for backend, fallback to original
       session_working_dir: window.appConfig.get('GOOSE_WORKING_DIR'),
       ...(chat.recipeConfig?.title
         ? {
@@ -253,8 +255,15 @@ export const useChatEngine = ({
           originalSessionId: chat.sessionId,
           backendSessionId,
           isMatrixSession: chat.sessionId.startsWith('!'),
+          shouldMakeBackendCalls: sessionMappingService.shouldMakeBackendCalls(chat.sessionId),
         });
 
+        // Skip backend calls if no mapping exists for Matrix sessions
+        if (backendSessionId === null) {
+          console.log('📋 Skipping session token fetch - no mapping for Matrix session:', chat.sessionId);
+          return;
+        }
+        
         const response = await getSession<true>({
           path: { session_id: backendSessionId },
           throwOnError: true,

ui/desktop/src/hooks/useMessageStream.ts

@@ -353,8 +353,15 @@ export function useMessageStream({
                           originalSessionId: sessionId,
                           backendSessionId,
                           isMatrixSession: sessionId.startsWith('!'),
+                          shouldMakeBackendCalls: sessionMappingService.shouldMakeBackendCalls(sessionId),
                         });
 
+                        // Skip backend calls if no mapping exists for Matrix sessions
+                        if (backendSessionId === null) {
+                          console.log('📋 Skipping session data fetch in SSE Finish - no mapping for Matrix session:', sessionId);
+                          break;
+                        }
+                        
                         const sessionResponse = await getSession({
                           path: { session_id: backendSessionId },
                           throwOnError: true,

ui/desktop/src/services/SessionMappingService.ts

@@ -167,19 +167,46 @@ export class SessionMappingService {
    * Get the appropriate session ID for backend API calls
    * Returns the mapped Goose session ID if it's a Matrix room, otherwise returns the original ID
    */
-  public getBackendSessionId(sessionId: string): string {
+  public getBackendSessionId(sessionId: string): string | null {
     if (SessionMappingService.isMatrixRoomId(sessionId)) {
       const gooseSessionId = this.getGooseSessionId(sessionId);
       if (gooseSessionId) {
         return gooseSessionId;
       }
-      console.warn('📋 SessionMappingService: No mapping found for Matrix room ID:', sessionId);
-      // Return original ID as fallback (will likely cause backend errors, but better than crashing)
-      return sessionId;
+      console.warn('📋 SessionMappingService: No mapping found for Matrix room ID:', sessionId, '- skipping backend calls');
+      // Return null to indicate that backend calls should be skipped
+      return null;
     }
     return sessionId;
   }
 
+  /**
+   * Check if backend API calls should be made for this session ID
+   * Returns false for Matrix sessions without mappings
+   */
+  public shouldMakeBackendCalls(sessionId: string): boolean {
+    if (SessionMappingService.isMatrixRoomId(sessionId)) {
+      const gooseSessionId = this.getGooseSessionId(sessionId);
+      return gooseSessionId !== null;
+    }
+    return true; // Always make backend calls for regular Goose sessions
+  }
+
+  /**
+   * Create a mapping for an existing Matrix room if one doesn't exist
+   * This is useful for Matrix rooms loaded from history that don't have mappings yet
+   */
+  public ensureMappingExists(matrixRoomId: string, title?: string): SessionMapping {
+    const existingMapping = this.getMapping(matrixRoomId);
+    if (existingMapping) {
+      return existingMapping;
+    }
+
+    // Create a new mapping for this Matrix room
+    console.log('📋 SessionMappingService: Creating mapping for existing Matrix room:', matrixRoomId);
+    return this.createMapping(matrixRoomId, [], title || `Matrix Room ${matrixRoomId.substring(1, 8)}`);
+  }
+
   /**
    * Get all mappings (for debugging/management)
    */