ARCHITECTURAL FIX: Use single UUID session identity everywhere - removed http_session_key hack

FRRONTEEEND/components/ChatInterface.tsx

@@ -210,6 +210,13 @@ export const ChatInterface: React.FC<{ onBack: () => void }> = ({ onBack }) => {
 
       const data = await response.json();
       
+      // CRITICAL: Store the actual session UUID returned from backend for SSE routing
+      if (data.session_id) {
+        console.log(`🔑 Session UUID from backend: ${data.session_id}`);
+        // Update the active session to use this UUID for SSE connection
+        setActiveSessionId(data.session_id);
+      }
+      
       let assistantContent = '';
       let reports: Array<{name: string, path: string}> = [];
       let plots: Array<{title: string, url: string, type?: 'image' | 'html'}> = [];

src/api/app.py

@@ -349,9 +349,9 @@ async def run_analysis(
         # Set progress callback on existing agent
         agent.progress_callback = progress_callback
         
-        # Set HTTP session key for SSE streaming (so orchestrator emits to correct stream)
-        agent.http_session_key = session_key
-        print(f"[SSE] SET agent.http_session_key = {session_key}")
+        # Get the agent's actual session UUID for SSE routing
+        actual_session_id = agent.session.session_id if hasattr(agent, 'session') and agent.session else "default"
+        print(f"[SSE] Using agent session UUID: {actual_session_id}")
         
         try:
             # Agent's session memory should resolve file_path from context
@@ -468,9 +468,9 @@ async def run_analysis(
         # Set progress callback on existing agent
         agent.progress_callback = progress_callback
         
-        # Set HTTP session key for SSE streaming (so orchestrator emits to correct stream)
-        agent.http_session_key = session_key
-        print(f"[SSE] SET agent.http_session_key = {session_key} (file upload)")
+        # Get the agent's actual session UUID for SSE routing
+        actual_session_id = agent.session.session_id if hasattr(agent, 'session') and agent.session else "default"
+        print(f"[SSE] Using agent session UUID: {actual_session_id}")
         
         # Call existing agent logic
         logger.info(f"Starting analysis with task: {task_description}")
@@ -484,8 +484,8 @@ async def run_analysis(
         
         logger.info(f"Analysis completed: {result.get('status')}")
         
-        # Send completion event via SSE
-        progress_manager.emit(session_key, {
+        # Send completion event via SSE using actual session UUID
+        progress_manager.emit(actual_session_id, {
             "type": "analysis_complete",
             "status": result.get("status"),
             "message": "✅ Analysis completed successfully!"
@@ -512,13 +512,13 @@ async def run_analysis(
         
         serializable_result = make_json_serializable(result)
         
-        # Return result with progress tracking
+        # Return result with progress tracking and ACTUAL session UUID for SSE
         return JSONResponse(
             content={
                 "success": result.get("status") == "success",
                 "result": serializable_result,
                 "progress": progress_store.get(session_key, []),
-                "session_id": session_key,
+                "session_id": actual_session_id,  # Return UUID for SSE connection
                 "metadata": {
                     "filename": file.filename,
                     "task": task_description,

src/orchestrator.py

@@ -2239,13 +2239,9 @@ You are a DOER. Complete workflows based on user intent."""
                             self.tokens_this_minute += tokens_used
                             print(f"📊 Tokens: {tokens_used} this call | {self.tokens_this_minute}/{self.tpm_limit} this minute")
                             
-                            # Emit token update for SSE streaming
-                            session_key_for_emit = getattr(self, 'http_session_key', None)
-                            if not session_key_for_emit and hasattr(self, 'session') and self.session:
-                                session_key_for_emit = self.session.session_id
-                            
-                            if session_key_for_emit:
-                                progress_manager.emit(session_key_for_emit, {
+                            # Emit token update for SSE streaming using session UUID
+                            if hasattr(self, 'session') and self.session:
+                                progress_manager.emit(self.session.session_id, {
                                     'type': 'token_update',
                                     'message': f"📊 Tokens: {tokens_used} this call | {self.tokens_this_minute}/{self.tpm_limit} this minute",
                                     'tokens_used': tokens_used,
@@ -2283,13 +2279,9 @@ You are a DOER. Complete workflows based on user intent."""
                             self.tokens_this_minute += tokens_used
                             print(f"📊 Tokens: {tokens_used} this call | {self.tokens_this_minute}/{self.tpm_limit} this minute")
                             
-                            # Emit token update for SSE streaming
-                            session_key_for_emit = getattr(self, 'http_session_key', None)
-                            if not session_key_for_emit and hasattr(self, 'session') and self.session:
-                                session_key_for_emit = self.session.session_id
-                            
-                            if session_key_for_emit:
-                                progress_manager.emit(session_key_for_emit, {
+                            # Emit token update for SSE streaming using session UUID
+                            if hasattr(self, 'session') and self.session:
+                                progress_manager.emit(self.session.session_id, {
                                     'type': 'token_update',
                                     'message': f"📊 Tokens: {tokens_used} this call | {self.tokens_this_minute}/{self.tpm_limit} this minute",
                                     'tokens_used': tokens_used,
@@ -2351,13 +2343,9 @@ You are a DOER. Complete workflows based on user intent."""
                                 self.tokens_this_minute += tokens_used
                                 print(f"📊 Tokens: {tokens_used} this call | {self.tokens_this_minute}/{self.tpm_limit} this minute")
                                 
-                                # Emit token update for SSE streaming
-                                session_key_for_emit = getattr(self, 'http_session_key', None)
-                                if not session_key_for_emit and hasattr(self, 'session') and self.session:
-                                    session_key_for_emit = self.session.session_id
-                                
-                                if session_key_for_emit:
-                                    progress_manager.emit(session_key_for_emit, {
+                                # Emit token update for SSE streaming using session UUID
+                                if hasattr(self, 'session') and self.session:
+                                    progress_manager.emit(self.session.session_id, {
                                         'type': 'token_update',
                                         'message': f"📊 Tokens: {tokens_used} this call | {self.tokens_this_minute}/{self.tpm_limit} this minute",
                                         'tokens_used': tokens_used,
@@ -3033,24 +3021,16 @@ You are a DOER. Complete workflows based on user intent."""
                     except:
                         print(f"   Arguments: {tool_args}")
                     
-                    # Emit progress event for SSE streaming
-                    # Use http_session_key if set (from app.py), otherwise use session UUID
-                    session_key_for_emit = getattr(self, 'http_session_key', None)
-                    if not session_key_for_emit and hasattr(self, 'session') and self.session:
-                        session_key_for_emit = self.session.session_id
-                    
-                    print(f"[SSE] DEBUG EMIT: http_session_key={getattr(self, 'http_session_key', 'NOT SET')}, session={hasattr(self, 'session')}, final_key={session_key_for_emit}")
-                    
-                    if session_key_for_emit:
-                        print(f"[SSE] EMITTING tool_executing for session: {session_key_for_emit}, tool: {tool_name}")
-                        progress_manager.emit(session_key_for_emit, {
+                    # Emit progress event for SSE streaming using session UUID
+                    if hasattr(self, 'session') and self.session:
+                        session_id = self.session.session_id
+                        print(f"[SSE] EMIT tool_executing: session={session_id}, tool={tool_name}")
+                        progress_manager.emit(session_id, {
                             'type': 'tool_executing',
                             'tool': tool_name,
                             'message': f"🔧 Executing: {tool_name}",
                             'arguments': tool_args
                         })
-                    else:
-                        print(f"[SSE] WARNING: SKIPPING EMIT: No session key available")
                     
                     # Execute tool
                     tool_result = self._execute_tool(tool_name, tool_args)
@@ -3064,12 +3044,8 @@ You are a DOER. Complete workflows based on user intent."""
                         print(f"   ⚠️  Error Message: {error_msg}")
                         
                         # Emit failure event for SSE streaming
-                        session_key_for_emit = getattr(self, 'http_session_key', None)
-                        if not session_key_for_emit and hasattr(self, 'session') and self.session:
-                            session_key_for_emit = self.session.session_id
-                        
-                        if session_key_for_emit:
-                            progress_manager.emit(session_key_for_emit, {
+                        if hasattr(self, 'session') and self.session:
+                            progress_manager.emit(self.session.session_id, {
                                 'type': 'tool_failed',
                                 'tool': tool_name,
                                 'message': f"❌ FAILED: {tool_name}",
@@ -3142,12 +3118,8 @@ You are a DOER. Complete workflows based on user intent."""
                         print(f"   ✓ Completed: {tool_name}")
                         
                         # Emit completion event for SSE streaming
-                        session_key_for_emit = getattr(self, 'http_session_key', None)
-                        if not session_key_for_emit and hasattr(self, 'session') and self.session:
-                            session_key_for_emit = self.session.session_id
-                        
-                        if session_key_for_emit:
-                            progress_manager.emit(session_key_for_emit, {
+                        if hasattr(self, 'session') and self.session:
+                            progress_manager.emit(self.session.session_id, {
                                 'type': 'tool_completed',
                                 'tool': tool_name,
                                 'message': f"✓ Completed: {tool_name}"