Upload folder using huggingface_hub

app.py

@@ -116,36 +116,68 @@ class ChatInterface:
     ) -> Tuple[str, List[List[str]]]:
         """Process incoming chat message."""
         try:
+            # Validate input
+            if not message or not message.strip():
+                return "Please provide a message to process.", history
+
             # Check network before processing
             if not check_network():
                 return "Network connectivity issues detected. Some features may be limited.", history
                 
-            # Analyze message intent
-            intent = await self._analyze_intent(message)
-            
-            # Convert UnifiedResult to dict if needed
-            intent_type = getattr(intent, "type", None) or intent.get("type", "general")
-            
-            if intent_type == "query":
-                response = await self._handle_query(message)
-            elif intent_type == "objective":
-                response = await self._handle_objective(message)
-            elif intent_type == "status":
-                response = await self._handle_status_request(message)
-            else:
-                response = await self._handle_general_chat(message)
+            # Process the message
+            response = await self._handle_message(message)
             
             # Update chat history
+            if isinstance(response, tuple):
+                response = response[0]  # Extract message if tuple returned
             history.append([message, response])
             
             return response, history
             
         except Exception as e:
             logger.error(f"Error processing message: {str(e)}")
-            return f"I apologize, but I encountered an error. Please try again.", history
+            error_msg = "I apologize, but I encountered a temporary error. Please try again or rephrase your request."
+            history.append([message, error_msg])
+            return error_msg, history
+
+    async def _handle_message(self, message: str) -> str:
+        """Handle message processing with error recovery."""
+        try:
+            # Analyze message intent
+            intent = await self._analyze_intent(message)
+            intent_type = self._get_intent_type(intent)
+            
+            # Process based on intent
+            if intent_type == "query":
+                return await self._handle_query(message)
+            elif intent_type == "objective":
+                return await self._handle_objective(message)
+            elif intent_type == "status":
+                return await self._handle_status_request(message)
+            else:
+                return await self._handle_general_chat(message)
+                
+        except Exception as e:
+            logger.error(f"Error in message handler: {str(e)}")
+            raise
+
+    def _get_intent_type(self, intent) -> str:
+        """Safely extract intent type from various result formats."""
+        try:
+            if hasattr(intent, "type"):
+                return intent.type
+            elif hasattr(intent, "intent_type"):
+                return intent.intent_type
+            elif isinstance(intent, dict):
+                return intent.get("type") or intent.get("intent_type", "general")
+            else:
+                return "general"
+        except Exception as e:
+            logger.error(f"Error getting intent type: {str(e)}")
+            return "general"
 
     async def _analyze_intent(self, message: str) -> Dict[str, Any]:
-        """Analyze user message intent."""
+        """Analyze user message intent with error handling."""
         try:
             # Use reasoning engine to analyze intent
             result = await self.orchestrator.reasoning_engine.reason(
@@ -156,17 +188,19 @@ class ChatInterface:
                 }
             )
             
-            # Convert UnifiedResult to dict if needed
+            # Handle different result types
             if hasattr(result, "to_dict"):
                 return result.to_dict()
             elif hasattr(result, "__dict__"):
                 return result.__dict__
+            elif isinstance(result, dict):
+                return result
             else:
-                return {"type": "general"}
+                return {"type": "general", "confidence": 0.5}
                 
         except Exception as e:
             logger.error(f"Error analyzing intent: {str(e)}")
-            return {"type": "general"}
+            return {"type": "general", "confidence": 0.5}
 
     async def _handle_query(self, message: str) -> str:
         """Handle information queries."""
@@ -231,17 +265,28 @@ class ChatInterface:
         return self._format_status_response(system_status, team_status, objective_status)
 
     async def _handle_general_chat(self, message: str) -> str:
-        """Handle general chat interactions."""
-        # Use reasoning engine for response generation
-        response = await self.orchestrator.reasoning_engine.reason(
-            query=message,
-            context={
-                "chat_history": self.chat_history,
-                "system_state": await self.agentic_system.get_system_status()
-            }
-        )
-        
-        return response.get("response", "I'm not sure how to respond to that.")
+        """Handle general chat interactions with error recovery."""
+        try:
+            # Get responses from all teams
+            responses = []
+            for team_type in self.team_manager.teams:
+                try:
+                    response = await self._get_team_response(team_type, message)
+                    if response:
+                        responses.append(response)
+                except Exception as e:
+                    logger.error(f"Error getting response from team {team_type}: {str(e)}")
+                    continue
+            
+            if not responses:
+                return "I'm having trouble processing that request. Could you please rephrase it?"
+            
+            # Combine responses
+            return self._format_team_responses(responses)
+            
+        except Exception as e:
+            logger.error(f"Error in general chat handler: {str(e)}")
+            return "I apologize, but I'm having trouble understanding that. Could you try asking in a different way?"
 
     async def _get_team_response(self, team_type: TeamType, query: str) -> Dict[str, Any]:
         """Get response from a specific team."""