refactor: update chat interface initialization

- Moved async initialization to background tasks
- Fixed event loop issues
- Integrated FastAPI routes into ChatInterface
- Removed duplicate VentureUI class
- Improved error handling and logging

app.py

@@ -88,35 +88,250 @@ def check_network(max_attempts=3):
     return False
 
 class ChatInterface:
+    """Chat interface for interacting with the agentic system."""
+    
     def __init__(self):
+        """Initialize the chat interface."""
         # Check network connectivity
         if not check_network():
-            logger.warning("Network connectivity issues detected - continuing with degraded functionality")
-            
-        # Initialize core components with consistent configuration
-        config = {
-            "min_confidence": 0.7,
-            "parallel_threshold": 3,
-            "learning_rate": 0.1,
-            "strategy_weights": {
-                "LOCAL_LLM": 0.8,
-                "CHAIN_OF_THOUGHT": 0.6,
-                "TREE_OF_THOUGHTS": 0.5,
-                "META_LEARNING": 0.4
-            }
-        }
-        
-        self.orchestrator = AgentOrchestrator(config)
-        self.agentic_system = AgenticSystem(config)
+            raise ConnectionError("No network connectivity. Please check your connection.")
+            
+        # Initialize core components
+        self.orchestrator = AgentOrchestrator()
         self.team_manager = TeamManager(self.orchestrator)
-        self.chat_history = []
-        self.active_objectives = {}
         
-        # Set up network session
-        self.session = setup_requests_session()
+        # Initialize reasoning engine
+        self.reasoning_engine = UnifiedReasoningEngine()
+        
+        # Set up the agentic system
+        self.agentic_system = AgenticSystem(
+            orchestrator=self.orchestrator,
+            team_manager=self.team_manager,
+            reasoning_engine=self.reasoning_engine
+        )
+        
+        # Initialize FastAPI app
+        self.app = FastAPI()
+        self.setup_cors()
+        self.setup_routes()
+        
+        # Create Gradio interface
+        self.interface = self.create_interface()
+        
+        # Launch background tasks
+        self.background_tasks = []
+        self.launch_background_tasks()
+        
+    async def initialize(self):
+        """Initialize async components."""
+        await self.team_manager.initialize_team_agents()
         
-        # Initialize teams
-        asyncio.run(self.team_manager.initialize_team_agents())
+    def launch_background_tasks(self):
+        """Launch background tasks."""
+        loop = asyncio.get_event_loop()
+        self.background_tasks.append(
+            loop.create_task(self.initialize())
+        )
+
+    def setup_cors(self):
+        """Set up CORS middleware."""
+        self.app.add_middleware(
+            CORSMiddleware,
+            allow_origins=["*"],
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+
+    def setup_routes(self):
+        """Set up API routes."""
+        # Include OpenAI-compatible routes
+        openai_api = OpenAICompatibleAPI(self.reasoning_engine)
+        self.app.include_router(openai_api.router, tags=["OpenAI Compatible"])
+
+        # Original API routes
+        @self.app.get("/api/health")
+        async def health_check():
+            """Health check endpoint."""
+            return {
+                "status": "healthy",
+                "version": "1.0.0",
+                "endpoints": {
+                    "openai_compatible": "/v1/chat/completions",
+                    "venture": "/api/venture",
+                    "ui": "/"
+                }
+            }
+
+        @self.app.post("/api/reason")
+        async def reason(query: str, context: Optional[Dict[str, Any]] = None):
+            """Reasoning endpoint."""
+            try:
+                result = await self.reasoning_engine.reason(query, context or {})
+                return result
+            except Exception as e:
+                logger.error(f"Reasoning error: {e}")
+                raise HTTPException(status_code=500, detail=str(e))
+
+        @self.app.post("/api/venture/analyze")
+        async def analyze_venture(
+            venture_type: str,
+            description: str,
+            metrics: Optional[Dict[str, Any]] = None
+        ):
+            """Venture analysis endpoint."""
+            try:
+                result = await VentureAPI(self.reasoning_engine).analyze_venture(
+                    venture_type=venture_type,
+                    description=description,
+                    metrics=metrics or {}
+                )
+                return result
+            except Exception as e:
+                logger.error(f"Analysis error: {e}")
+                raise HTTPException(status_code=500, detail=str(e))
+
+        @self.app.get("/api/venture/types")
+        async def get_venture_types():
+            """Get available venture types."""
+            return VentureAPI(self.reasoning_engine).get_venture_types()
+
+    def create_interface(self):
+        """Create the Gradio interface."""
+        with gr.Blocks(
+            theme=gr.themes.Soft(),
+            analytics_enabled=False,
+            title="Advanced Agentic System"
+        ) as interface:
+            # Verify Gradio version
+            gr.Markdown(f"""
+            # Advanced Agentic System Chat Interface v{gr.__version__}
+            
+            Chat with our autonomous agent teams:
+            - Team A: Coders (App/Software Developers)
+            - Team B: Business (Entrepreneurs)
+            - Team C: Research (Deep Online Research)
+            - Team D: Crypto & Sports Trading
+            
+            You can:
+            1. Ask questions
+            2. Create new objectives
+            3. Check status of teams and objectives
+            4. Get insights and recommendations
+            """)
+            
+            chatbot = gr.Chatbot(
+                label="Chat History",
+                height=400,
+                bubble_full_width=False,
+                show_copy_button=True,
+                render_markdown=True
+            )
+            
+            with gr.Row():
+                msg = gr.Textbox(
+                    label="Message",
+                    placeholder="Chat with the Agentic System...",
+                    lines=2,
+                    scale=9,
+                    autofocus=True,
+                    container=True
+                )
+                submit = gr.Button(
+                    "Send",
+                    scale=1,
+                    variant="primary"
+                )
+            
+            with gr.Row():
+                clear = gr.ClearButton(
+                    [msg, chatbot],
+                    value="Clear Chat",
+                    variant="secondary",
+                    scale=1
+                )
+                retry = gr.Button(
+                    "Retry Last",
+                    variant="secondary",
+                    scale=1
+                )
+
+            async def respond(message, history):
+                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)
+                    
+                    # Update history
+                    if history is None:
+                        history = []
+                    history.append((message, response))
+                    
+                    return "", history
+                except Exception as e:
+                    logger.error(f"Error in chat response: {str(e)}")
+                    error_msg = "I apologize, but I encountered an error. Please try again."
+                    
+                    if history is None:
+                        history = []
+                    history.append((message, error_msg))
+                    
+                    return "", history
+
+            async def retry_last(history):
+                if not history:
+                    return history
+                last_user_msg = history[-1][0]
+                history = history[:-1]  # Remove last exchange
+                return await respond(last_user_msg, history)
+
+            msg.submit(
+                respond,
+                [msg, chatbot],
+                [msg, chatbot],
+                api_name="chat"
+            ).then(
+                lambda: gr.update(interactive=True),
+                None,
+                [msg, submit],
+                queue=False
+            )
+
+            submit.click(
+                respond,
+                [msg, chatbot],
+                [msg, chatbot],
+                api_name="submit"
+            ).then(
+                lambda: gr.update(interactive=True),
+                None,
+                [msg, submit],
+                queue=False
+            )
+
+            retry.click(
+                retry_last,
+                [chatbot],
+                [chatbot],
+                api_name="retry"
+            )
+
+            # Event handlers for better UX
+            msg.change(lambda x: gr.update(interactive=bool(x.strip())), [msg], [submit])
+            
+            # Add example inputs
+            gr.Examples(
+                examples=[
+                    "What can Team A (Coders) help me with?",
+                    "Create a new objective: Analyze market trends",
+                    "What's the status of all teams?",
+                    "Give me insights about recent developments"
+                ],
+                inputs=msg,
+                label="Example Queries"
+            )
+
+        return interface
 
     async def process_message(
         self,
@@ -174,7 +389,7 @@ class ChatInterface:
         """Analyze user message intent with error handling."""
         try:
             # Use reasoning engine to analyze intent
-            analysis = await self.orchestrator.reasoning_engine.reason(
+            analysis = await self.reasoning_engine.reason(
                 query=message,
                 context={
                     "chat_history": self.chat_history,
@@ -256,7 +471,7 @@ class ChatInterface:
         """Handle general chat interactions with error recovery."""
         try:
             # Use reasoning engine for response generation
-            response = await self.orchestrator.reasoning_engine.reason(
+            response = await self.reasoning_engine.reason(
                 query=message,
                 context={
                     "chat_history": self.chat_history,
@@ -408,152 +623,10 @@ class ChatInterface:
             logger.error(f"Error formatting status: {str(e)}")
             return "Error formatting status information."
 
-class VentureUI:
-    def __init__(self, app):
-        self.app = app
-
-    def create_interface(self):
-        """Create the Gradio interface."""
-        with gr.Blocks(
-            theme=gr.themes.Soft(),
-            analytics_enabled=False,
-            title="Advanced Agentic System"
-        ) as interface:
-            # Verify Gradio version
-            gr.Markdown(f"""
-            # Advanced Agentic System Chat Interface v{gr.__version__}
-            
-            Chat with our autonomous agent teams:
-            - Team A: Coders (App/Software Developers)
-            - Team B: Business (Entrepreneurs)
-            - Team C: Research (Deep Online Research)
-            - Team D: Crypto & Sports Trading
-            
-            You can:
-            1. Ask questions
-            2. Create new objectives
-            3. Check status of teams and objectives
-            4. Get insights and recommendations
-            """)
-            
-            chatbot = gr.Chatbot(
-                label="Chat History",
-                height=400,
-                bubble_full_width=False,
-                show_copy_button=True,
-                render_markdown=True
-            )
-            
-            with gr.Row():
-                msg = gr.Textbox(
-                    label="Message",
-                    placeholder="Chat with the Agentic System...",
-                    lines=2,
-                    scale=9,
-                    autofocus=True,
-                    container=True
-                )
-                submit = gr.Button(
-                    "Send",
-                    scale=1,
-                    variant="primary"
-                )
-            
-            with gr.Row():
-                clear = gr.ClearButton(
-                    [msg, chatbot],
-                    value="Clear Chat",
-                    variant="secondary",
-                    scale=1
-                )
-                retry = gr.Button(
-                    "Retry Last",
-                    variant="secondary",
-                    scale=1
-                )
-
-            async def respond(message, history):
-                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.app(message, history_list)
-                    
-                    # Update history
-                    if history is None:
-                        history = []
-                    history.append((message, response))
-                    
-                    return "", history
-                except Exception as e:
-                    logger.error(f"Error in chat response: {str(e)}")
-                    error_msg = "I apologize, but I encountered an error. Please try again."
-                    
-                    if history is None:
-                        history = []
-                    history.append((message, error_msg))
-                    
-                    return "", history
-
-            async def retry_last(history):
-                if not history:
-                    return history
-                last_user_msg = history[-1][0]
-                history = history[:-1]  # Remove last exchange
-                return await respond(last_user_msg, history)
-
-            msg.submit(
-                respond,
-                [msg, chatbot],
-                [msg, chatbot],
-                api_name="chat"
-            ).then(
-                lambda: gr.update(interactive=True),
-                None,
-                [msg, submit],
-                queue=False
-            )
-
-            submit.click(
-                respond,
-                [msg, chatbot],
-                [msg, chatbot],
-                api_name="submit"
-            ).then(
-                lambda: gr.update(interactive=True),
-                None,
-                [msg, submit],
-                queue=False
-            )
-
-            retry.click(
-                retry_last,
-                [chatbot],
-                [chatbot],
-                api_name="retry"
-            )
-
-            # Event handlers for better UX
-            msg.change(lambda x: gr.update(interactive=bool(x.strip())), [msg], [submit])
-            
-            # Add example inputs
-            gr.Examples(
-                examples=[
-                    "What can Team A (Coders) help me with?",
-                    "Create a new objective: Analyze market trends",
-                    "What's the status of all teams?",
-                    "Give me insights about recent developments"
-                ],
-                inputs=msg,
-                label="Example Queries"
-            )
-
-        return interface
-
 def create_chat_interface() -> gr.Blocks:
     """Create Gradio chat interface."""
     chat = ChatInterface()
-    ui = VentureUI(chat.process_message)
-    return ui.create_interface()
+    return chat.interface
 
 # Initialize FastAPI
 app = FastAPI(
@@ -562,68 +635,6 @@ app = FastAPI(
     version="1.0.0"
 )
 
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Include OpenAI-compatible routes
-from api.openai_compatible import OpenAICompatibleAPI
-reasoning_engine = UnifiedReasoningEngine()
-openai_api = OpenAICompatibleAPI(reasoning_engine)
-app.include_router(openai_api.router, tags=["OpenAI Compatible"])
-
-# Original API routes
-@app.get("/api/health")
-async def health_check():
-    """Health check endpoint."""
-    return {
-        "status": "healthy",
-        "version": "1.0.0",
-        "endpoints": {
-            "openai_compatible": "/v1/chat/completions",
-            "venture": "/api/venture",
-            "ui": "/"
-        }
-    }
-
-@app.post("/api/reason")
-async def reason(query: str, context: Optional[Dict[str, Any]] = None):
-    """Reasoning endpoint."""
-    try:
-        result = await reasoning_engine.reason(query, context or {})
-        return result
-    except Exception as e:
-        logger.error(f"Reasoning error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/api/venture/analyze")
-async def analyze_venture(
-    venture_type: str,
-    description: str,
-    metrics: Optional[Dict[str, Any]] = None
-):
-    """Venture analysis endpoint."""
-    try:
-        result = await VentureAPI(reasoning_engine).analyze_venture(
-            venture_type=venture_type,
-            description=description,
-            metrics=metrics or {}
-        )
-        return result
-    except Exception as e:
-        logger.error(f"Analysis error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/api/venture/types")
-async def get_venture_types():
-    """Get available venture types."""
-    return VentureAPI(reasoning_engine).get_venture_types()
-
 # Create Gradio interface
 interface = create_chat_interface()