Update app.py

app.py

@@ -78,7 +78,7 @@ class BrowserAgent:
             max_context_chars=2000  # Limit context size
         )
 
-    async def generate_tools_prompt(self):
+    def generate_tools_prompt(self):
         """Generate a detailed prompt section about available tools"""
         try:
             tools_prompt = "\n## 🛠️ AVAILABLE TOOLS\n"
@@ -124,7 +124,7 @@ Verify results before moving on
 Keep Browser Open
 Never close the session unless explicitly instructed
 Avoid Redundancy
-Don’t repeat actions (e.g., clicking) when data is already collected
+Don't repeat actions (e.g., clicking) when data is already collected
 ## 🚨 SESSION PERSISTENCE RULES
 - Browser stays open for the entire conversation
 - Each action builds on previous state
@@ -135,7 +135,7 @@ Don’t repeat actions (e.g., clicking) when data is already collected
             logger.error(f"Failed to generate tools prompt: {e}")
             return "\n## 🛠️ TOOLS\nBrowser automation tools available but not detailed.\n"
 
-    async def get_system_prompt_with_tools(self):
+    def get_system_prompt_with_tools(self):
         base = """🌐 Browser Agent — Persistent Session & Optimized Memory
 You are an intelligent browser automation agent (Playwright via MCP) tasked with keeping a lightweight, ongoing session:
 🎯 Mission
@@ -152,14 +152,14 @@ Snapshot → confirmation
 Next plan (if needed)
 💡 Best Practices
 Use text selectors and wait for content
-Pause 2 s between tool calls
+Pause 2 s between tool calls
 Be concise and focused on the current task it s important as soon as you have the information you came for return it
 If earlier context is needed, ask the user to clarify.
 """
-        tools_section = await self.generate_tools_prompt()
+        tools_section = self.generate_tools_prompt()
         return base + tools_section
 
-    async def initialize(self):
+    def initialize(self):
         """Initialize MCP client, model, session and agent"""
         try:
             logger.info("🚀 Initializing Browser Agent...")
@@ -172,11 +172,14 @@ If earlier context is needed, ask the user to clarify.
             self.model = ChatMistralAI(
                 model="devstral-small-latest", 
                 api_key=mistral_key,
-        
             )
             logger.info("✅ Mistral LLM initialized with optimized settings")
             
-            # MCP client
+            # Create event loop for MCP operations
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            
+            # MCP client setup (async operations in sync wrapper)
             self.client = MultiServerMCPClient({
                 "browser": {
                     "command": "npx",
@@ -186,13 +189,13 @@ If earlier context is needed, ask the user to clarify.
             })
             logger.info("✅ MCP client created")
 
-            # Start persistent session
+            # Start persistent session (run async operation in sync context)
             self.session_context = self.client.session("browser")
-            self.session = await self.session_context.__aenter__()
+            self.session = loop.run_until_complete(self.session_context.__aenter__())
             logger.info("✅ MCP session opened")
             
-            # Load tools
-            tools = await load_mcp_tools(self.session)
+            # Load tools (async operation)
+            tools = loop.run_until_complete(load_mcp_tools(self.session))
             tools.append(SleepTool(description="Wait 2 seconds between two calls"))
             logger.info(f"📥 Loaded {len(tools)} tools")
             self.available_tools = {t.name: t for t in tools}
@@ -201,13 +204,13 @@ If earlier context is needed, ask the user to clarify.
             install_tool = self.available_tools.get("browser_install")
             if install_tool:
                 try:
-                    result = await install_tool.arun({})
+                    result = loop.run_until_complete(install_tool.arun({}))
                     logger.info(f"📥 Browser install: {result}")
                 except Exception as e:
                     logger.warning(f"⚠️ Browser install failed: {e}, continuing.")
 
             # System prompt
-            self.system_prompt = await self.get_system_prompt_with_tools()
+            self.system_prompt = self.get_system_prompt_with_tools()
 
             # Create agent
             prompt = ChatPromptTemplate.from_messages([
@@ -238,10 +241,10 @@ If earlier context is needed, ask the user to clarify.
 
         except Exception as e:
             logger.error(f"❌ Initialization failed: {e}")
-            await self.cleanup()
+            self.cleanup()
             raise
 
-    async def process_query(self, query: str, chat_history: List[Tuple[str, str]]) -> str:
+    def process_query(self, query: str, chat_history: List[Tuple[str, str]]) -> str:
         if not self.initialized:
             return "❌ Agent not initialized. Please restart the application."
             
@@ -264,11 +267,12 @@ If earlier context is needed, ask the user to clarify.
             optimized_pairs = len(optimized_history)
             logger.info(f"💰 Token optimization: {original_pairs} → {optimized_pairs} history pairs")
             
-            # Execute with optimized history
-            resp = await self.agent_executor.ainvoke({
+            # Execute with optimized history (run async operation in sync context)
+            loop = asyncio.get_event_loop()
+            resp = loop.run_until_complete(self.agent_executor.ainvoke({
                 "input": enhanced_query,
                 "chat_history": history_messages
-            })
+            }))
             
             # Update session context with this interaction
             self.conversation_manager.update_session_context(
@@ -282,17 +286,19 @@ If earlier context is needed, ask the user to clarify.
             logger.error(f"Error processing query: {e}")
             return f"❌ Error: {e}\n💡 Ask for a screenshot to diagnose."
 
-    async def cleanup(self):
+    def cleanup(self):
         """Cleanup resources properly"""
         try:
             if self.session_context:
-                await self.session_context.__aexit__(None, None, None)
+                loop = asyncio.get_event_loop()
+                loop.run_until_complete(self.session_context.__aexit__(None, None, None))
                 logger.info("✅ MCP session closed")
                 self.session_context = None
                 self.session = None
                 
             if self.client:
-                await self.client.close()
+                loop = asyncio.get_event_loop()
+                loop.run_until_complete(self.client.close())
                 logger.info("✅ MCP client closed")
                 self.client = None
                 
@@ -325,10 +331,9 @@ If earlier context is needed, ask the user to clarify.
 
 # Global agent instance
 agent: Optional[BrowserAgent] = None
-event_loop: Optional[asyncio.AbstractEventLoop] = None
 
-async def initialize_agent_async(api_key: str) -> str:
-    """Initialize the agent asynchronously"""
+def initialize_agent(api_key: str) -> str:
+    """Initialize the agent"""
     global agent
     
     if not api_key.strip():
@@ -337,32 +342,32 @@ async def initialize_agent_async(api_key: str) -> str:
     try:
         # Cleanup existing agent
         if agent:
-            await agent.cleanup()
+            agent.cleanup()
             
         # Create new agent
         agent = BrowserAgent(api_key)
-        await agent.initialize()
+        agent.initialize()
         
-        info = await agent.get_system_prompt_with_tools()
+        info = agent.get_system_prompt_with_tools()
         return f"✅ Agent Initialized Successfully with Token Optimization!\n\n{info[:1000]}..."
         
     except Exception as e:
         logger.error(f"Initialization error: {e}")
         return f"❌ Failed to initialize agent: {e}"
 
-async def process_message_async(message: str, history: List[List[str]]) -> Tuple[str, List[List[str]]]:
-    """Process message asynchronously with token optimization"""
+def process_message(message: str, history: List[List[str]]) -> List[List[str]]:
+    """Process message and return updated history"""
     global agent
     
     if not agent or not agent.initialized:
         error_msg = "❌ Agent not initialized. Please initialize first with your API key."
         history.append([message, error_msg])
-        return "", history
+        return history
         
     if not message.strip():
         error_msg = "Please enter a message"
         history.append([message, error_msg])
-        return "", history
+        return history
         
     try:
         # Convert history format for the agent
@@ -372,7 +377,7 @@ async def process_message_async(message: str, history: List[List[str]]) -> Tuple
         stats = agent.get_token_usage_stats(agent_history)
         
         # Process the query with optimized history
-        response = await agent.process_query(message, agent_history)
+        response = agent.process_query(message, agent_history)
         
         # Add token savings info to response if significant savings
         if stats["savings_percentage"] > 50:
@@ -381,32 +386,15 @@ async def process_message_async(message: str, history: List[List[str]]) -> Tuple
         # Add to history
         history.append([message, response])
         
-        return "", history
+        return history
         
     except Exception as e:
         logger.error(f"Message processing error: {e}")
         error_msg = f"❌ Error: {e}\n💡 Try asking for a screenshot to diagnose."
         history.append([message, error_msg])
-        return "", history
-
-def run_in_event_loop(coro):
-    """Run coroutine in the event loop"""
-    global event_loop
-    if event_loop and not event_loop.is_closed():
-        return asyncio.run_coroutine_threadsafe(coro, event_loop).result()
-    else:
-        return asyncio.run(coro)
-
-# Sync wrappers for Gradio
-def initialize_agent_sync(api_key: str) -> str:
-    """Sync wrapper for agent initialization"""
-    return run_in_event_loop(initialize_agent_async(api_key))
-
-def process_message_sync(message: str, history: List[List[str]]) -> Tuple[str, List[List[str]]]:
-    """Sync wrapper for message processing"""
-    return run_in_event_loop(process_message_async(message, history))
+        return history
 
-def get_token_stats_sync(history: List[List[str]]) -> str:
+def get_token_stats(history: List[List[str]]) -> str:
     """Get token usage statistics"""
     global agent
     if not agent or not agent.initialized:
@@ -424,6 +412,10 @@ def get_token_stats_sync(history: List[List[str]]) -> str:
 • Estimated tokens saved: {stats['estimated_tokens_saved']:,}
 • Savings percentage: {stats['savings_percentage']:.1f}%"""
 
+def screenshot_quick(history: List[List[str]]) -> List[List[str]]:
+    """Quick screenshot function"""
+    return process_message("Take a screenshot of the current page", history)
+
 def create_interface():
     """Create the Gradio interface"""
     
@@ -509,21 +501,27 @@ def create_interface():
         
         # Event handlers
         init_button.click(
-            fn=initialize_agent_sync,
+            fn=initialize_agent,
             inputs=[api_key_input],
             outputs=[status_output]
         )
         
         send_button.click(
-            fn=process_message_sync,
+            fn=process_message,
             inputs=[message_input, chatbot],
-            outputs=[message_input, chatbot]
+            outputs=[chatbot]
+        ).then(
+            fn=lambda: "",
+            outputs=[message_input]
         )
         
         message_input.submit(
-            fn=process_message_sync,
+            fn=process_message,
             inputs=[message_input, chatbot],
-            outputs=[message_input, chatbot]
+            outputs=[chatbot]
+        ).then(
+            fn=lambda: "",
+            outputs=[message_input]
         )
         
         clear_button.click(
@@ -532,13 +530,13 @@ def create_interface():
         )
         
         screenshot_button.click(
-            fn=lambda history: process_message_sync("Take a screenshot of the current page", history),
+            fn=screenshot_quick,
             inputs=[chatbot],
-            outputs=[message_input, chatbot]
+            outputs=[chatbot]
         )
         
         token_stats_button.click(
-            fn=get_token_stats_sync,
+            fn=get_token_stats,
             inputs=[chatbot],
             outputs=[token_stats_output]
         )
@@ -584,32 +582,26 @@ def create_interface():
     
     return interface
 
-async def cleanup_agent():
+def cleanup_agent():
     """Cleanup agent resources"""
     global agent
     if agent:
-        await agent.cleanup()
+        agent.cleanup()
         logger.info("🧹 Agent cleaned up")
 
 def signal_handler(signum, frame):
     """Handle shutdown signals"""
     logger.info(f"📡 Received signal {signum}, cleaning up...")
-    global event_loop
-    if event_loop and not event_loop.is_closed():
-        event_loop.create_task(cleanup_agent())
+    cleanup_agent()
     sys.exit(0)
 
-async def main():
-    """Main async function to run everything"""
-    global event_loop
+def main():
+    """Main function to run everything"""
     
     # Set up signal handlers
     signal.signal(signal.SIGINT, signal_handler)
     signal.signal(signal.SIGTERM, signal_handler)
     
-    # Get the current event loop
-    event_loop = asyncio.get_event_loop()
-    
     try:
         logger.info("🚀 Starting MCP Browser Agent Application with Token Optimization...")
         
@@ -627,11 +619,11 @@ async def main():
     except Exception as e:
         logger.error(f"Application error: {e}")
     finally:
-        await cleanup_agent()
+        cleanup_agent()
 
 if __name__ == "__main__":
     try:
-        asyncio.run(main())
+        main()
     except KeyboardInterrupt:
         logger.info("🛑 Application stopped by user")
     except Exception as e: