fix: update chat interface

- Fixed event handlers to return tuples instead of lists
- Added chat state initialization
- Fixed process_message to handle history correctly
- Simplified response handling

app.py

@@ -39,53 +39,35 @@ from api.venture_api import VentureAPI
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Configure network settings
-TIMEOUT = int(os.getenv('REQUESTS_TIMEOUT', '30'))
-MAX_RETRIES = 5
-RETRY_BACKOFF = 1
-
 def setup_requests_session():
-    """Configure requests session with retries."""
+    """Set up requests session with retries."""
     session = requests.Session()
-    retry_strategy = Retry(
-        total=MAX_RETRIES,
-        backoff_factor=RETRY_BACKOFF,
-        status_forcelist=[408, 429, 500, 502, 503, 504],
-        allowed_methods=["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"]
+    retries = Retry(
+        total=5,
+        backoff_factor=0.1,
+        status_forcelist=[500, 502, 503, 504]
     )
-    adapter = HTTPAdapter(max_retries=retry_strategy)
-    session.mount("https://", adapter)
-    session.mount("http://", adapter)
+    session.mount('http://', HTTPAdapter(max_retries=retries))
+    session.mount('https://', HTTPAdapter(max_retries=retries))
     return session
 
-def check_network(max_attempts=3):
-    """Check network connectivity with retries."""
-    session = setup_requests_session()
+def check_network():
+    """Check network connectivity."""
+    try:
+        # Try DNS resolution first
+        socket.gethostbyname('huggingface.co')
+        return True
+    except socket.gaierror:
+        logger.warning("DNS resolution failed")
     
-    for attempt in range(max_attempts):
-        try:
-            # Try multiple DNS servers
-            for dns in ['8.8.8.8', '8.8.4.4', '1.1.1.1']:
-                try:
-                    socket.gethostbyname('huggingface.co')
-                    break
-                except socket.gaierror:
-                    continue
-            
-            # Test connection to Hugging Face
-            response = session.get('https://huggingface.co/api/health', 
-                                 timeout=TIMEOUT)
-            if response.status_code == 200:
-                return True
-                
-        except (requests.RequestException, socket.gaierror) as e:
-            logger.warning(f"Network check attempt {attempt + 1} failed: {e}")
-            if attempt < max_attempts - 1:
-                time.sleep(RETRY_BACKOFF * (attempt + 1))
-            continue
-            
-    logger.error("Network connectivity check failed after all attempts")
-    return False
+    try:
+        # Try HTTP request as backup
+        session = setup_requests_session()
+        response = session.get('https://huggingface.co', timeout=5)
+        return response.status_code == 200
+    except (requests.RequestException, socket.gaierror) as e:
+        logger.warning(f"Network connectivity check failed: {e}")
+        return False
 
 class ChatInterface:
     """Chat interface for interacting with the agentic system."""
@@ -109,6 +91,10 @@ class ChatInterface:
             }
         }
         
+        # Initialize chat state
+        self.chat_history = []
+        self.active_objectives = {}
+        
         # Initialize components
         self.orchestrator = AgentOrchestrator(config)
         self.team_manager = TeamManager(self.orchestrator)
@@ -267,7 +253,7 @@ class ChatInterface:
                 try:
                     # Convert history to the format expected by process_message
                     history_list = [[x, y] for x, y in history] if history else []
-                    response, history_list = await self.process_message(message, history_list)
+                    response = await self.process_message(message, history_list)
                     
                     # Update history
                     if history is None:
@@ -292,39 +278,39 @@ class ChatInterface:
                 history = history[:-1]  # Remove last exchange
                 return await respond(last_user_msg, history)
 
+            # Submit handlers
             msg.submit(
                 respond,
                 [msg, chatbot],
-                [msg, chatbot],
-                api_name="chat"
+                [msg, chatbot]
             ).then(
-                lambda: gr.update(interactive=True),
+                lambda: (gr.update(value="", interactive=True), gr.update(interactive=True)),
                 None,
-                [msg, submit],
-                queue=False
+                [msg, submit]
             )
 
             submit.click(
                 respond,
                 [msg, chatbot],
-                [msg, chatbot],
-                api_name="submit"
+                [msg, chatbot]
             ).then(
-                lambda: gr.update(interactive=True),
+                lambda: (gr.update(value="", interactive=True), gr.update(interactive=True)),
                 None,
-                [msg, submit],
-                queue=False
+                [msg, submit]
             )
 
             retry.click(
                 retry_last,
                 [chatbot],
-                [chatbot],
-                api_name="retry"
+                [chatbot]
             )
 
             # Event handlers for better UX
-            msg.change(lambda x: gr.update(interactive=bool(x.strip())), [msg], [submit])
+            msg.change(
+                lambda x: (gr.update(interactive=bool(x.strip())), gr.update(interactive=bool(x.strip()))),
+                [msg],
+                [msg, submit]
+            )
             
             # Add example inputs
             gr.Examples(
@@ -343,54 +329,35 @@ class ChatInterface:
     async def process_message(
         self,
         message: str,
-        history: List[List[str]]
-    ) -> Tuple[str, List[List[str]]]:
-        """Process incoming chat message."""
+        history: List[List[str]] = None
+    ) -> str:
+        """Process a user message."""
         try:
+            # Initialize history if None
+            if history is None:
+                history = []
+            
             # Update chat history
             self.chat_history = history
-
-            # Process message
-            response = await self._handle_message(message)
-            
-            # Update history
-            if response:
-                history.append([message, response])
             
-            return response, history
-            
-        except Exception as e:
-            logger.error(f"Error processing message: {str(e)}")
-            error_msg = "I apologize, but I encountered an error. Please try again."
-            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 intent
+            # Analyze message intent
             intent = await self._analyze_intent(message)
-            intent_type = self._get_intent_type(intent)
             
-            # Route to appropriate handler
-            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)
+            # Process based on intent
+            if intent.get('type') == 'objective':
+                response = await self._handle_objective(message, intent)
+            elif intent.get('type') == 'status':
+                response = await self._get_status()
+            elif intent.get('type') == 'chat':
+                response = await self._handle_chat(message)
             else:
-                return await self._handle_general_chat(message)
-                
+                response = await self._handle_chat(message)  # Default to chat handler
+            
+            return response
+            
         except Exception as e:
-            logger.error(f"Error in message handling: {str(e)}")
-            return "I apologize, but I encountered an error processing your message. Please try again."
-
-    def _get_intent_type(self, intent) -> str:
-        """Safely extract intent type from various result formats."""
-        if isinstance(intent, dict):
-            return intent.get("type", "general")
-        return "general"
+            logger.error(f"Error processing message: {str(e)}")
+            return "I encountered an error processing your message. Please try again."
 
     async def _analyze_intent(self, message: str) -> Dict[str, Any]:
         """Analyze user message intent with error handling."""
@@ -404,77 +371,35 @@ class ChatInterface:
                 }
             )
             
-            return {
-                "type": analysis.get("intent_type", "general"),
-                "confidence": analysis.get("confidence", 0.5),
-                "entities": analysis.get("entities", []),
-                "action_required": analysis.get("action_required", False)
-            }
-        except Exception as e:
-            logger.error(f"Error analyzing intent: {str(e)}")
-            return {"type": "general", "confidence": 0.5}
-
-    async def _handle_query(self, message: str) -> str:
-        """Handle information queries."""
-        try:
-            # Get relevant teams for the query
-            recommended_teams = await self.team_manager.get_team_recommendations(message)
-            
-            # Get responses from relevant teams
-            responses = []
-            for team_type in recommended_teams:
-                response = await self._get_team_response(team_type, message)
-                if response:
-                    responses.append(response)
-            
-            if not responses:
-                return "I apologize, but I couldn't find a relevant answer to your query."
-            
-            # Combine and format responses
-            return self._format_team_responses(responses)
+            return analysis
             
         except Exception as e:
-            logger.error(f"Error handling query: {str(e)}")
-            return "I apologize, but I encountered an error processing your query. Please try again."
-
-    async def _handle_objective(self, message: str) -> str:
-        """Handle new objective creation."""
-        try:
-            # Create new objective
-            objective_id = await self.team_manager.create_objective(message)
-            if not objective_id:
-                return "I apologize, but I couldn't create the objective. Please try again."
-            
-            # Format and return response
-            return self._format_objective_creation(objective_id)
-            
-        except Exception as e:
-            logger.error(f"Error creating objective: {str(e)}")
-            return "I apologize, but I encountered an error creating the objective. Please try again."
+            logger.error(f"Error analyzing intent: {str(e)}")
+            return {"type": "unknown", "error": str(e)}
 
-    async def _handle_status_request(self, message: str) -> str:
-        """Handle status check requests."""
+    async def _handle_objective(self, message: str, intent: Dict[str, Any]) -> str:
+        """Handle objective creation and management."""
         try:
-            # Get system status
-            system_status = await self.agentic_system.get_system_status()
+            # Extract objective details
+            objective = intent.get('objective', {})
+            
+            # Create objective
+            objective_id = await self.team_manager.create_cross_team_objective(
+                objective=objective.get('description', message),
+                required_teams=objective.get('teams', []),
+                priority=objective.get('priority', 'MEDIUM')
+            )
             
-            # Get team status
-            team_status = {}
-            for team_id, team in self.team_manager.teams.items():
-                team_status[team.name] = await self.team_manager.monitor_objective_progress(team_id)
+            # Monitor progress
+            status = await self.team_manager.monitor_objective_progress(objective_id)
             
-            # Get objective status
-            objective_status = {}
-            for obj_id, obj in self.active_objectives.items():
-                objective_status[obj_id] = await self.team_manager.monitor_objective_progress(obj_id)
-            
-            return self._format_status_response(system_status, team_status, objective_status)
+            return f"Created objective {objective_id}. Current status: {status}"
             
         except Exception as e:
-            logger.error(f"Error getting status: {str(e)}")
-            return "I apologize, but I encountered an error getting the status. Please try again."
+            logger.error(f"Error handling objective: {str(e)}")
+            return "Failed to create objective. Please try again."
 
-    async def _handle_general_chat(self, message: str) -> str:
+    async def _handle_chat(self, message: str) -> str:
         """Handle general chat interactions with error recovery."""
         try:
             # Use reasoning engine for response generation
@@ -482,149 +407,43 @@ class ChatInterface:
                 query=message,
                 context={
                     "chat_history": self.chat_history,
-                    "system_state": await self.agentic_system.get_system_status()
+                    "active_objectives": self.active_objectives
                 }
             )
             
-            if not response or not response.get("response"):
-                return "I apologize, but I couldn't generate a meaningful response. Please try again."
-            
-            return response["response"]
-            
-        except Exception as e:
-            logger.error(f"Error in general chat: {str(e)}")
-            return "I apologize, but I encountered an error processing your message. Please try again."
-
-    async def _get_team_response(self, team_type: TeamType, query: str) -> Dict[str, Any]:
-        """Get response from a specific team."""
-        try:
-            team = self.team_manager.teams.get(team_type.value)
-            if not team:
-                return None
-            
-            # Get response from team's agents
-            responses = []
-            for agent in team.agents:
-                response = await agent.process_query(query)
-                if response:
-                    responses.append(response)
-            
-            if not responses:
-                return None
-            
-            # Return best response
-            return self._combine_agent_responses(responses)
+            return response.get('response', "I'm not sure how to respond to that.")
             
         except Exception as e:
-            logger.error(f"Error getting team response: {str(e)}")
-            return None
+            logger.error(f"Error in chat response: {str(e)}")
+            return "I encountered an error generating a response. Please try again."
 
-    def _combine_agent_responses(self, responses: List[Dict[str, Any]]) -> Dict[str, Any]:
-        """Combine multiple agent responses into a coherent response."""
+    async def _get_status(self) -> str:
+        """Get system status information."""
         try:
-            # Sort by confidence
-            valid_responses = [
-                r for r in responses 
-                if r.get("success", False) and r.get("response")
-            ]
-            
-            if not valid_responses:
-                return None
-                
-            sorted_responses = sorted(
-                valid_responses,
-                key=lambda x: x.get("confidence", 0),
-                reverse=True
-            )
-            
-            # Take the highest confidence response
-            return sorted_responses[0]
-            
-        except Exception as e:
-            logger.error(f"Error combining responses: {str(e)}")
-            return None
-
-    def _format_team_responses(self, responses: List[Dict[str, Any]]) -> str:
-        """Format team responses into a readable message."""
-        try:
-            if not responses:
-                return "No team responses available."
-            
-            formatted = []
-            for resp in responses:
-                if resp and resp.get("response"):
-                    team_name = resp.get("team_name", "Unknown Team")
-                    confidence = resp.get("confidence", 0)
-                    formatted.append(
-                        f"\n{team_name} (Confidence: {confidence:.2%}):\n{resp['response']}"
-                    )
-            
-            if not formatted:
-                return "No valid team responses available."
-                
-            return "\n".join(formatted)
-            
-        except Exception as e:
-            logger.error(f"Error formatting responses: {str(e)}")
-            return "Error formatting team responses."
-
-    def _format_objective_creation(self, objective_id: str) -> str:
-        """Format objective creation response."""
-        try:
-            obj = self.active_objectives.get(objective_id)
-            if not obj:
-                return "Objective created but details not available."
+            # Get team status
+            team_status = await self.team_manager.get_team_status()
             
-            return "\n".join([
-                "New Objective Created:",
-                f"Description: {obj['description']}",
-                f"Status: {obj['status']}",
-                f"Assigned Teams: {', '.join(t.value for t in obj['teams'])}"
-            ])
+            # Get objective status
+            objective_status = await self.team_manager.get_objective_status()
             
-        except Exception as e:
-            logger.error(f"Error formatting objective: {str(e)}")
-            return "Error formatting objective details."
-
-    def _format_status_response(
-        self,
-        system_status: Dict[str, Any],
-        team_status: Dict[str, Any],
-        objective_status: Dict[str, Any]
-    ) -> str:
-        """Format status response."""
-        try:
-            # Format system status
-            status = [
-                "System Status:",
-                f"- State: {system_status['state']}",
-                f"- Active Agents: {system_status['agent_count']}",
-                f"- Active Tasks: {system_status['active_tasks']}",
-                "\nTeam Status:"
-            ]
+            # Format status information
+            status = "Current System Status:\n\n"
             
-            # Add team status
-            for team_name, team_info in team_status.items():
-                status.extend([
-                    f"\n{team_name}:",
-                    f"- Active Agents: {team_info['active_agents']}",
-                    f"- Completion Rate: {team_info['completion_rate']:.2%}",
-                    f"- Collaboration Score: {team_info['collaboration_score']:.2f}"
-                ])
+            # Add team information
+            status += "Teams:\n"
+            for team, info in team_status.items():
+                status += f"- {team}: {info['status']}\n"
+                status += f"  Active Projects: {info['active_projects']}\n"
+                status += f"  Success Rate: {info['success_rate']}%\n\n"
             
-            # Add objective status
-            if objective_status:
-                status.append("\nActive Objectives:")
-                for obj_id, obj_info in objective_status.items():
-                    obj = self.active_objectives[obj_id]
-                    status.extend([
-                        f"\n{obj['description']}:",
-                        f"- Status: {obj['status']}",
-                        f"- Teams: {', '.join(t.value for t in obj['teams'])}",
-                        f"- Progress: {sum(t['completion_rate'] for t in obj_info.values())/len(obj_info):.2%}"
-                    ])
+            # Add objective information
+            status += "\nActive Objectives:\n"
+            for obj, info in objective_status.items():
+                status += f"- {obj}: {info['status']}\n"
+                status += f"  Progress: {info['progress']}%\n"
+                status += f"  Teams: {', '.join(info['teams'])}\n\n"
             
-            return "\n".join(status)
+            return status
             
         except Exception as e:
             logger.error(f"Error formatting status: {str(e)}")
@@ -637,8 +456,8 @@ def create_chat_interface() -> gr.Blocks:
 
 # Initialize FastAPI
 app = FastAPI(
-    title="Advanced Agentic System",
-    description="Venture Strategy Optimizer with OpenAI-compatible API",
+    title="Advanced Agentic System API",
+    description="API for interacting with the autonomous agent teams",
     version="1.0.0"
 )