Update mcp_client.py

mcp_client.py

@@ -1,85 +1,75 @@
 """
-MCP Client implementation for Universal MCP Client
-Enhanced with HuggingFace Inference Provider support
+MCP Client implementation for Universal MCP Client - Fixed Version
 """
 import asyncio
 import json
 import re
-import base64
-from typing import Dict, Optional, Tuple, List, Any
-import anthropic
 import logging
 import traceback
+from typing import Dict, Optional, Tuple, List, Any
+from openai import OpenAI
 
 # Import the proper MCP client components
 from mcp import ClientSession
 from mcp.client.sse import sse_client
 
-from config import MCPServerConfig, AppConfig, HTTPX_AVAILABLE, HF_INFERENCE_AVAILABLE
+from config import MCPServerConfig, AppConfig, HTTPX_AVAILABLE
 
 logger = logging.getLogger(__name__)
 
-if HF_INFERENCE_AVAILABLE:
-    from huggingface_hub import InferenceClient
-
 class UniversalMCPClient:
-    """Universal MCP Client for connecting to various MCP servers with multiple LLM backends"""
+    """Universal MCP Client using HuggingFace Inference Providers instead of Anthropic"""
     
     def __init__(self):
         self.servers: Dict[str, MCPServerConfig] = {}
-        self.anthropic_client = None
+        self.enabled_servers: Dict[str, bool] = {}  # Track enabled/disabled servers
         self.hf_client = None
         self.current_provider = None
         self.current_model = None
+        self.server_tools = {}  # Cache for server tools
         
-        # Initialize Anthropic client if API key is available
-        if AppConfig.ANTHROPIC_API_KEY:
-            self.anthropic_client = anthropic.Anthropic(
-                api_key=AppConfig.ANTHROPIC_API_KEY
+        # Initialize HF Inference Client if token is available
+        if AppConfig.HF_TOKEN:
+            self.hf_client = OpenAI(
+                base_url="https://router.huggingface.co/v1",
+                api_key=AppConfig.HF_TOKEN
             )
-            logger.info("✅ Anthropic client initialized")
-        else:
-            logger.warning("⚠️ ANTHROPIC_API_KEY not found")
-        
-        # Initialize HuggingFace client if available
-        if HF_INFERENCE_AVAILABLE and AppConfig.HF_TOKEN:
-            logger.info("✅ HuggingFace Hub available")
+            logger.info("✅ HuggingFace Inference client initialized")
         else:
-            logger.warning("⚠️ HF_TOKEN not found or huggingface_hub not available")
+            logger.warning("⚠️ HF_TOKEN not found")
     
-    def configure_inference_provider(self, provider: str, model: str) -> bool:
-        """Configure the inference provider and model"""
-        try:
-            if not HF_INFERENCE_AVAILABLE:
-                logger.error("HuggingFace Hub not available")
-                return False
-            
-            if not AppConfig.HF_TOKEN:
-                logger.error("HF_TOKEN not configured")
-                return False
-            
-            self.hf_client = InferenceClient(
-                provider=provider,
-                api_key=AppConfig.HF_TOKEN
-            )
-            self.current_provider = provider
-            self.current_model = model
-            
-            logger.info(f"✅ Configured inference provider: {provider} with model: {model}")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Failed to configure inference provider: {e}")
-            return False
+    def enable_server(self, server_name: str, enabled: bool = True):
+        """Enable or disable a server"""
+        if server_name in self.servers:
+            self.enabled_servers[server_name] = enabled
+            logger.info(f"🔧 Server {server_name} {'enabled' if enabled else 'disabled'}")
     
-    def get_current_llm_backend(self) -> str:
-        """Get the currently configured LLM backend"""
-        if self.current_provider and self.hf_client:
-            return f"HF Inference Provider: {self.current_provider}"
-        elif self.anthropic_client:
-            return "Anthropic Claude Sonnet 4"
-        else:
-            return "No LLM backend configured"
+    def get_enabled_servers(self) -> Dict[str, MCPServerConfig]:
+        """Get only enabled servers"""
+        return {name: config for name, config in self.servers.items() 
+                if self.enabled_servers.get(name, True)}
+    
+    def remove_all_servers(self):
+        """Remove all servers"""
+        count = len(self.servers)
+        self.servers.clear()
+        self.enabled_servers.clear()
+        self.server_tools.clear()
+        logger.info(f"🗑️ Removed all {count} servers")
+        return count
+    
+    def set_model_and_provider(self, provider_id: str, model_id: str):
+        """Set the current provider and model"""
+        self.current_provider = provider_id
+        self.current_model = model_id
+        logger.info(f"🔧 Set provider: {provider_id}, model: {model_id}")
+    
+    def get_model_endpoint(self) -> str:
+        """Get the current model endpoint for API calls"""
+        if not self.current_provider or not self.current_model:
+            raise ValueError("Provider and model must be set before making API calls")
+        
+        return AppConfig.get_model_endpoint(self.current_model, self.current_provider)
     
     async def add_server_async(self, config: MCPServerConfig) -> Tuple[bool, str]:
         """Add an MCP server using pure MCP protocol"""
@@ -121,11 +111,12 @@ class UniversalMCPClient:
             # Update config with proper MCP URL
             config.url = mcp_url
             
-            # Test MCP connection
+            # Test MCP connection and cache tools
             success, message = await self._test_mcp_connection(config)
             
             if success:
                 self.servers[config.name] = config
+                self.enabled_servers[config.name] = True  # Enable by default
                 logger.info(f"✅ MCP Server {config.name} added successfully")
                 return True, f"✅ Successfully added MCP server: {config.name}\n{message}"
             else:
@@ -139,11 +130,11 @@ class UniversalMCPClient:
             return False, f"❌ {error_msg}"
     
     async def _test_mcp_connection(self, config: MCPServerConfig) -> Tuple[bool, str]:
-        """Test MCP server connection with detailed debugging"""
+        """Test MCP server connection with detailed debugging and tool caching"""
         try:
             logger.info(f"🔍 Testing MCP connection to {config.url}")
             
-            async with sse_client(config.url, timeout=AppConfig.MCP_TIMEOUT_SECONDS) as (read_stream, write_stream):
+            async with sse_client(config.url, timeout=20.0) as (read_stream, write_stream):
                 async with ClientSession(read_stream, write_stream) as session:
                     # Initialize MCP session
                     logger.info("🔧 Initializing MCP session...")
@@ -153,14 +144,24 @@ class UniversalMCPClient:
                     logger.info("📋 Listing available tools...")
                     tools = await session.list_tools()
                     
+                    # Cache tools for this server
+                    server_tools = {}
                     tool_info = []
+                    
                     for tool in tools.tools:
+                        server_tools[tool.name] = {
+                            'description': tool.description,
+                            'schema': tool.inputSchema if hasattr(tool, 'inputSchema') else None
+                        }
                         tool_info.append(f"  - {tool.name}: {tool.description}")
                         logger.info(f"  📍 Tool: {tool.name}")
                         logger.info(f"    Description: {tool.description}")
                         if hasattr(tool, 'inputSchema') and tool.inputSchema:
                             logger.info(f"    Input Schema: {tool.inputSchema}")
                     
+                    # Cache tools for this server
+                    self.server_tools[config.name] = server_tools
+                    
                     if len(tools.tools) == 0:
                         return False, "No tools found on MCP server"
                     
@@ -174,453 +175,450 @@ class UniversalMCPClient:
             logger.error(traceback.format_exc())
             return False, f"Connection failed: {str(e)}"
     
-    async def call_llm_with_mcp(self, messages: List[Dict[str, Any]], user_files: List[str]) -> List[Any]:
-        """Call LLM with MCP servers - handles both Anthropic and HF providers"""
-        if self.current_provider and self.hf_client:
-            # Use HuggingFace Inference Provider with custom MCP implementation
-            return await self._call_hf_with_custom_mcp(messages, user_files)
-        elif self.anthropic_client:
-            # Use Anthropic's native MCP support
-            return self._call_anthropic_with_native_mcp(messages, user_files)
-        else:
-            raise ValueError("No LLM backend configured")
-    
-    def _call_anthropic_with_native_mcp(self, messages: List[Dict[str, Any]], user_files: List[str]) -> List[Any]:
-        """Call Anthropic API with native MCP support (existing implementation)"""
-        if not self.servers:
-            return self._call_claude_without_mcp(messages)
-        
-        mcp_servers = []
-        for server_name, config in self.servers.items():
-            mcp_servers.append({
-                "type": "url",
-                "url": config.url,
-                "name": server_name.replace(" ", "_").lower()
-            })
-        
-        # Enhanced system prompt with multimodal and MCP instructions
-        system_prompt = self._get_anthropic_mcp_system_prompt(user_files)
-        
-        # Debug logging
-        logger.info(f"📤 Sending {len(messages)} messages to Claude API")
-        logger.info(f"🔧 Using {len(mcp_servers)} MCP servers")
-        
-        start_time = time.time()
-        
-        # Call Claude with MCP connector using the correct beta API
-        response = self.anthropic_client.beta.messages.create(
-            model=AppConfig.CLAUDE_MODEL,
-            max_tokens=AppConfig.MAX_TOKENS,
-            system=system_prompt,
-            messages=messages,
-            mcp_servers=mcp_servers,
-            betas=[AppConfig.MCP_BETA_VERSION]
-        )
-        
-        return self._process_mcp_response(response, start_time)
-    
-    async def _call_hf_with_custom_mcp(self, messages: List[Dict[str, Any]], user_files: List[str]) -> List[Any]:
-        """Call HuggingFace Inference Provider with custom MCP implementation"""
-        from gradio import ChatMessage
-        import time
+    async def call_mcp_tool_async(self, server_name: str, tool_name: str, arguments: dict) -> Tuple[bool, str]:
+        """Call a tool on a specific MCP server"""
+        logger.info(f"🔧 MCP Tool Call - Server: {server_name}, Tool: {tool_name}")
+        logger.info(f"🔧 Arguments: {arguments}")
         
-        # Get available tools from MCP servers
-        available_tools = await self._get_mcp_tools()
+        if server_name not in self.servers:
+            error_msg = f"Server {server_name} not found. Available servers: {list(self.servers.keys())}"
+            logger.error(f"❌ {error_msg}")
+            return False, error_msg
         
-        if not available_tools:
-            # No MCP tools available, use regular chat completion
-            return await self._call_hf_without_mcp(messages)
+        config = self.servers[server_name]
+        logger.info(f"🔧 Using server config: {config.url}")
         
-        # Enhanced system prompt for HF providers with MCP
-        system_prompt = self._get_hf_mcp_system_prompt(user_files, available_tools)
+        try:
+            logger.info(f"🔗 Connecting to MCP server at {config.url}")
+            async with sse_client(config.url, timeout=30.0) as (read_stream, write_stream):
+                async with ClientSession(read_stream, write_stream) as session:
+                    # Initialize MCP session
+                    logger.info("🔧 Initializing MCP session...")
+                    await session.initialize()
+                    
+                    # Call the tool
+                    logger.info(f"🔧 Calling tool {tool_name} with arguments: {arguments}")
+                    result = await session.call_tool(tool_name, arguments)
+                    
+                    # Extract result content
+                    if result.content:
+                        result_text = result.content[0].text if hasattr(result.content[0], 'text') else str(result.content[0])
+                        logger.info(f"✅ Tool call successful, result length: {len(result_text)}")
+                        logger.info(f"📋 Result preview: {result_text[:200]}...")
+                        return True, result_text
+                    else:
+                        error_msg = "No content returned from tool"
+                        logger.error(f"❌ {error_msg}")
+                        return False, error_msg
+                        
+        except asyncio.TimeoutError:
+            error_msg = f"Tool call timeout for {tool_name} on {server_name}"
+            logger.error(f"❌ {error_msg}")
+            return False, error_msg
+        except Exception as e:
+            error_msg = f"Tool call failed: {str(e)}"
+            logger.error(f"❌ MCP tool call failed: {e}")
+            logger.error(traceback.format_exc())
+            return False, error_msg
+    
+    def generate_chat_completion(self, messages: List[Dict[str, Any]], **kwargs) -> Dict[str, Any]:
+        """Generate chat completion using HuggingFace Inference Providers"""
+        if not self.hf_client:
+            raise ValueError("HuggingFace client not initialized. Please set HF_TOKEN.")
+        
+        if not self.current_provider or not self.current_model:
+            raise ValueError("Provider and model must be set before making API calls")
+        
+        # Get the model endpoint
+        model_endpoint = self.get_model_endpoint()
+        
+        # Set up default parameters for GPT OSS models with higher limits
+        params = {
+            "model": model_endpoint,
+            "messages": messages,
+            "max_tokens": kwargs.pop("max_tokens", 8192),  # Use pop to avoid conflicts
+            "temperature": kwargs.get("temperature", 0.3),
+            "stream": kwargs.get("stream", False)
+        }
+        
+        # Add any remaining kwargs
+        params.update(kwargs)
+        
+        # Add reasoning effort if specified (GPT OSS feature)
+        reasoning_effort = kwargs.pop("reasoning_effort", AppConfig.DEFAULT_REASONING_EFFORT)
+        if reasoning_effort:
+            # For GPT OSS models, we can set reasoning in system prompt
+            system_message = None
+            for msg in messages:
+                if msg.get("role") == "system":
+                    system_message = msg
+                    break
+            
+            if system_message:
+                system_message["content"] += f"\n\nReasoning: {reasoning_effort}"
+            else:
+                messages.insert(0, {
+                    "role": "system", 
+                    "content": f"You are a helpful AI assistant. Reasoning: {reasoning_effort}"
+                })
         
-        # Add system message if not present
-        if not messages or messages[0].get("role") != "system":
-            messages.insert(0, {"role": "system", "content": system_prompt})
+        try:
+            logger.info(f"🤖 Calling {model_endpoint} via {self.current_provider}")
+            response = self.hf_client.chat.completions.create(**params)
+            return response
+        except Exception as e:
+            logger.error(f"HF Inference API call failed: {e}")
+            raise
+    
+    def generate_chat_completion_with_mcp_tools(self, messages: List[Dict[str, Any]], **kwargs) -> Dict[str, Any]:
+        """Generate chat completion with MCP tool support"""
+        enabled_servers = self.get_enabled_servers()
+        if not enabled_servers:
+            # No enabled MCP servers available, use regular completion
+            logger.info("🤖 No enabled MCP servers available, using regular chat completion")
+            return self.generate_chat_completion(messages, **kwargs)
+        
+        logger.info(f"🔧 Processing chat with {len(enabled_servers)} enabled MCP servers available")
+        
+        # Add system message about available tools with exact tool names
+        tool_descriptions = []
+        server_names = []
+        exact_tool_mappings = []
+        
+        for server_name, config in enabled_servers.items():
+            tool_descriptions.append(f"- **{server_name}**: {config.description}")
+            server_names.append(server_name)
+            
+            # Add exact tool names if we have them cached
+            if server_name in self.server_tools:
+                for tool_name, tool_info in self.server_tools[server_name].items():
+                    exact_tool_mappings.append(f"  * Server '{server_name}' has tool '{tool_name}': {tool_info['description']}")
+        
+        # Get the actual server name (not the space ID)
+        server_list = ", ".join([f'"{name}"' for name in server_names])
+        
+        tools_system_msg = f"""
+You have access to the following MCP tools:
+{chr(10).join(tool_descriptions)}
+EXACT TOOL MAPPINGS:
+{chr(10).join(exact_tool_mappings) if exact_tool_mappings else "Loading tool mappings..."}
+IMPORTANT SERVER NAMES: {server_list}
+When you need to use a tool, respond with ONLY a JSON object in this EXACT format:
+{{"use_tool": true, "server": "exact_server_name", "tool": "exact_tool_name", "arguments": {{"param": "value"}}}}
+CRITICAL INSTRUCTIONS:
+- Use ONLY the exact server names from this list: {server_list}
+- Use the exact tool names as shown in the mappings above
+- Always include all required parameters in the arguments
+- Do not include any other text before or after the JSON
+- Make sure the JSON is complete and properly formatted
+If you don't need to use a tool, respond normally without any JSON.
+"""
+        
+        # Add tools system message with increased context
+        enhanced_messages = messages.copy()
+        if enhanced_messages and enhanced_messages[0].get("role") == "system":
+            enhanced_messages[0]["content"] += "\n\n" + tools_system_msg
         else:
-            messages[0]["content"] = system_prompt
+            enhanced_messages.insert(0, {"role": "system", "content": tools_system_msg})
+        
+        # Get initial response with higher token limit
+        logger.info("🤖 Getting initial response from LLM...")
+        response = self.generate_chat_completion(enhanced_messages, **{"max_tokens": 8192})
+        response_text = response.choices[0].message.content
         
-        chat_messages = []
-        max_iterations = 5  # Prevent infinite loops
-        iteration = 0
+        logger.info(f"🤖 LLM Response (length: {len(response_text)}): {response_text}")
         
-        while iteration < max_iterations:
-            iteration += 1
-            logger.info(f"🔄 HF+MCP Iteration {iteration}")
+        # Check if the response indicates tool usage
+        if '"use_tool": true' in response_text:
+            logger.info("🔧 Tool usage detected, parsing JSON...")
             
-            # Call HuggingFace model
-            try:
-                completion = self.hf_client.chat.completions.create(
-                    model=self.current_model,
-                    messages=messages,
-                    max_tokens=AppConfig.MAX_TOKENS,
-                    temperature=0.7
-                )
-                
-                response_content = completion.choices[0].message.content
-                logger.info(f"📝 HF Response: {response_content[:200]}...")
-                
-                # Check if model wants to use tools
-                tool_calls = self._extract_tool_calls_from_response(response_content)
+            # Extract and parse JSON more robustly
+            tool_request = self._extract_tool_json(response_text)
+            
+            if not tool_request:
+                # Fallback: try to extract tool info manually
+                logger.info("🔧 JSON parsing failed, trying manual extraction...")
+                tool_request = self._manual_tool_extraction(response_text)
+            
+            if tool_request:
+                server_name = tool_request.get("server")
+                tool_name = tool_request.get("tool")
+                arguments = tool_request.get("arguments", {})
+
+                # Replace any local file paths in arguments with uploaded URLs
+                if hasattr(self, 'chat_handler_file_mapping'):
+                    for arg_key, arg_value in arguments.items():
+                        if isinstance(arg_value, str) and arg_value.startswith('/tmp/gradio/'):
+                            # Check if we have an uploaded URL for this local path
+                            for local_path, uploaded_url in self.chat_handler_file_mapping.items():
+                                if local_path in arg_value or arg_value in local_path:
+                                    logger.info(f"🔄 Replacing local path {arg_value} with uploaded URL {uploaded_url}")
+                                    arguments[arg_key] = uploaded_url
+                                    break
                 
-                if not tool_calls:
-                    # No tool calls, return final response
-                    chat_messages.append(ChatMessage(
-                        role="assistant",
-                        content=response_content
-                    ))
-                    break
+                logger.info(f"🔧 Tool request - Server: {server_name}, Tool: {tool_name}, Args: {arguments}")
                 
-                # Execute tool calls
-                for tool_call in tool_calls:
-                    tool_name = tool_call.get("name")
-                    tool_args = tool_call.get("arguments", {})
+                if server_name not in self.servers:
+                    available_servers = list(self.servers.keys())
+                    logger.error(f"❌ Server '{server_name}' not found. Available servers: {available_servers}")
+                    # Try to find a matching server by space_id or similar name
+                    matching_server = None
+                    for srv_name, srv_config in self.servers.items():
+                        if (srv_config.space_id and server_name in srv_config.space_id) or server_name in srv_name:
+                            matching_server = srv_name
+                            logger.info(f"🔧 Found matching server: {matching_server}")
+                            break
                     
-                    # Add thinking message for tool usage
-                    chat_messages.append(ChatMessage(
-                        role="assistant",
-                        content="",
-                        metadata={
-                            "title": f"🔧 Using {tool_name}",
-                            "id": f"tool_{iteration}",
-                            "status": "pending",
-                            "log": f"Calling MCP tool: {tool_name}"
+                    if matching_server and self.enabled_servers.get(matching_server, True):
+                        server_name = matching_server
+                        logger.info(f"🔧 Using corrected server name: {server_name}")
+                    else:
+                        # Return error response with server name correction
+                        error_msg = f"Server '{server_name}' not found or disabled. Available enabled servers: {[name for name, enabled in self.enabled_servers.items() if enabled]}"
+                        response._tool_execution = {
+                            "server": server_name,
+                            "tool": tool_name,
+                            "result": error_msg,
+                            "success": False
                         }
-                    ))
+                        return response
+                elif not self.enabled_servers.get(server_name, True):
+                    logger.error(f"❌ Server '{server_name}' is disabled")
+                    response._tool_execution = {
+                        "server": server_name,
+                        "tool": tool_name,
+                        "result": f"Server '{server_name}' is currently disabled",
+                        "success": False
+                    }
+                    return response
+                # Validate tool name exists for this server
+                if server_name in self.server_tools and tool_name not in self.server_tools[server_name]:
+                    available_tools = list(self.server_tools[server_name].keys())
+                    logger.warning(f"⚠️ Tool '{tool_name}' not found for server '{server_name}'. Available tools: {available_tools}")
                     
-                    # Execute tool via MCP
-                    tool_result = await self._execute_mcp_tool(tool_name, tool_args)
+                    # Try to find the correct tool name
+                    if available_tools:
+                        # Use the first available tool if there's only one
+                        if len(available_tools) == 1:
+                            tool_name = available_tools[0]
+                            logger.info(f"🔧 Using only available tool: {tool_name}")
+                        # Or try to find a similar tool name
+                        else:
+                            for available_tool in available_tools:
+                                if tool_name.lower() in available_tool.lower() or available_tool.lower() in tool_name.lower():
+                                    tool_name = available_tool
+                                    logger.info(f"🔧 Found similar tool name: {tool_name}")
+                                    break
+                
+                # Call the MCP tool
+                def run_mcp_tool():
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    try:
+                        return loop.run_until_complete(
+                            self.call_mcp_tool_async(server_name, tool_name, arguments)
+                        )
+                    finally:
+                        loop.close()
+                
+                success, result = run_mcp_tool()
+                
+                if success:
+                    logger.info(f"✅ Tool call successful, result length: {len(str(result))}")
                     
-                    # Update tool status
-                    for msg in chat_messages:
-                        if (msg.metadata and 
-                            msg.metadata.get("id") == f"tool_{iteration}" and 
-                            msg.metadata.get("status") == "pending"):
-                            msg.metadata["status"] = "done"
-                            break
+                    # Add tool result to conversation and get final response with better prompting
+                    enhanced_messages.append({"role": "assistant", "content": response_text})
+                    enhanced_messages.append({"role": "user", "content": f"Tool '{tool_name}' from server '{server_name}' completed successfully. Result: {result}\n\nPlease provide a helpful response based on this tool result. If the result contains media URLs, present them appropriately."})
                     
-                    # Add tool result
-                    chat_messages.append(ChatMessage(
-                        role="assistant",
-                        content=tool_result,
-                        metadata={
-                            "title": "📋 Tool Result",
-                            "parent_id": f"tool_{iteration}",
-                            "status": "done"
-                        }
-                    ))
+                    # Remove the tool instruction from the system message for the final response
+                    final_messages = enhanced_messages.copy()
+                    if final_messages[0].get("role") == "system":
+                        final_messages[0]["content"] = final_messages[0]["content"].split("You have access to the following MCP tools:")[0].strip()
                     
-                    # Add tool result to conversation context
-                    messages.append({
-                        "role": "assistant", 
-                        "content": f"I used the tool {tool_name} and got this result: {tool_result}"
-                    })
+                    logger.info("🤖 Getting final response with tool result...")
+                    final_response = self.generate_chat_completion(final_messages, **{"max_tokens": 4096})
                     
-                    # Check for media in tool result
-                    media_url = self._extract_media_from_tool_result(tool_result)
-                    if media_url:
-                        chat_messages.append(ChatMessage(
-                            role="assistant",
-                            content={"path": media_url}
-                        ))
-                
-                # Continue conversation with tool results
-                messages.append({
-                    "role": "user",
-                    "content": "Please provide a summary of the results and help with the user's original request."
-                })
-                
-            except Exception as e:
-                logger.error(f"Error in HF+MCP iteration {iteration}: {e}")
-                chat_messages.append(ChatMessage(
-                    role="assistant",
-                    content=f"❌ Error during tool execution: {str(e)}"
-                ))
-                break
-        
-        if not chat_messages:
-            chat_messages.append(ChatMessage(
-                role="assistant",
-                content="I understand your request and I'm here to help."
-            ))
-        
-        return chat_messages
-    
-    async def _get_mcp_tools(self) -> List[Dict[str, Any]]:
-        """Get available tools from all MCP servers"""
-        tools = []
-        for server_name, config in self.servers.items():
-            try:
-                async with sse_client(config.url, timeout=AppConfig.MCP_TIMEOUT_SECONDS) as (read_stream, write_stream):
-                    async with ClientSession(read_stream, write_stream) as session:
-                        await session.initialize()
-                        server_tools = await session.list_tools()
-                        
-                        for tool in server_tools.tools:
-                            tools.append({
-                                "name": tool.name,
-                                "description": tool.description,
-                                "server": server_name,
-                                "schema": tool.inputSchema if hasattr(tool, 'inputSchema') else {}
-                            })
-                            
-            except Exception as e:
-                logger.error(f"Failed to get tools from {server_name}: {e}")
+                    # Store tool execution info for the chat handler
+                    final_response._tool_execution = {
+                        "server": server_name,
+                        "tool": tool_name,
+                        "result": result,
+                        "success": True
+                    }
+                    
+                    return final_response
+                else:
+                    logger.error(f"❌ Tool call failed: {result}")
+                    # Return original response with error info
+                    response._tool_execution = {
+                        "server": server_name,
+                        "tool": tool_name,
+                        "result": result,
+                        "success": False
+                    }
+                    return response
+            else:
+                logger.warning("⚠️ Failed to parse tool request JSON")
+        else:
+            logger.info("💬 No tool usage detected, returning normal response")
         
-        return tools
+        # Return original response if no tool usage or tool call failed
+        return response
     
-    def _extract_tool_calls_from_response(self, response: str) -> List[Dict[str, Any]]:
-        """Extract tool calls from LLM response text"""
-        # Look for tool call patterns in the response
-        # This is a simple implementation - you might want to make this more robust
+    def _extract_tool_json(self, text: str) -> Optional[Dict[str, Any]]:
+        """Extract JSON from LLM response more robustly"""
+        import json
         import re
         
-        tool_calls = []
-        
-        # Pattern to match tool calls like: CALL_TOOL: tool_name(arg1="value1", arg2="value2")
-        pattern = r'CALL_TOOL:\s*(\w+)\((.*?)\)'
-        matches = re.findall(pattern, response)
+        logger.info(f"🔍 Full LLM response text: {text}")
         
-        for match in matches:
-            tool_name = match[0]
-            args_str = match[1]
-            
-            # Simple argument parsing (you might want to improve this)
-            args = {}
-            if args_str:
-                arg_pairs = args_str.split(',')
-                for pair in arg_pairs:
-                    if '=' in pair:
-                        key, value = pair.split('=', 1)
-                        key = key.strip().strip('"').strip("'")
-                        value = value.strip().strip('"').strip("'")
-                        args[key] = value
-            
-            tool_calls.append({
-                "name": tool_name,
-                "arguments": args
-            })
+        # Try multiple strategies to extract JSON
+        strategies = [
+            # Strategy 1: Find complete JSON between outer braces
+            lambda t: re.search(r'\{[^{}]*"use_tool"[^{}]*"arguments"[^{}]*\{[^{}]*\}[^{}]*\}', t),
+            # Strategy 2: Find JSON that starts with {"use_tool" and reconstruct if needed
+            lambda t: self._reconstruct_json_from_start(t),
+            # Strategy 3: Find any complete JSON object
+            lambda t: re.search(r'\{(?:[^{}]|\{[^{}]*\})*\}', t),
+        ]
         
-        return tool_calls
-    
-    async def _execute_mcp_tool(self, tool_name: str, arguments: Dict[str, Any]) -> str:
-        """Execute a tool via MCP servers"""
-        for server_name, config in self.servers.items():
+        for i, strategy in enumerate(strategies, 1):
             try:
-                async with sse_client(config.url, timeout=AppConfig.MCP_TIMEOUT_SECONDS) as (read_stream, write_stream):
-                    async with ClientSession(read_stream, write_stream) as session:
-                        await session.initialize()
-                        
-                        # Check if this server has the tool
-                        tools = await session.list_tools()
-                        tool_found = False
-                        for tool in tools.tools:
-                            if tool.name == tool_name:
-                                tool_found = True
-                                break
-                        
-                        if not tool_found:
-                            continue
-                        
-                        # Call the tool
-                        result = await session.call_tool(tool_name, arguments)
+                if i == 2:
+                    # Strategy 2 returns a string directly
+                    json_str = strategy(text)
+                    if not json_str:
+                        continue
+                else:
+                    match = strategy(text)
+                    if not match:
+                        continue
+                    json_str = match.group(0)
+                
+                logger.info(f"🔍 JSON extraction strategy {i} found: {json_str}")
+                
+                # Clean up the JSON string
+                json_str = json_str.strip()
+                
+                # Try to parse
+                parsed = json.loads(json_str)
+                
+                # Validate it's a tool request
+                if parsed.get("use_tool") is True:
+                    logger.info(f"✅ Valid tool request parsed: {parsed}")
+                    return parsed
                         
-                        if result.content:
-                            return result.content[0].text if hasattr(result.content[0], 'text') else str(result.content[0])
-                        else:
-                            return "Tool executed successfully but returned no content"
-                            
+            except json.JSONDecodeError as e:
+                logger.warning(f"⚠️ JSON parse error with strategy {i}: {e}")
+                logger.warning(f"⚠️ Problematic JSON: {json_str if 'json_str' in locals() else 'N/A'}")
+                continue
             except Exception as e:
-                logger.error(f"Failed to execute tool {tool_name} on {server_name}: {e}")
+                logger.warning(f"⚠️ Strategy {i} failed: {e}")
+                continue
         
-        return f"❌ Failed to execute tool: {tool_name}"
+        logger.error("❌ Failed to extract valid JSON from response")
+        return None
     
-    def _extract_media_from_tool_result(self, result: str) -> Optional[str]:
-        """Extract media URL from tool result"""
-        # Use existing media extraction logic
-        if not self.servers:
-            return None
+    def _manual_tool_extraction(self, text: str) -> Optional[Dict[str, Any]]:
+        """Manually extract tool information as fallback"""
+        import re
         
-        # Use the first server's config for media extraction
-        config = next(iter(self.servers.values()))
-        return self._extract_media_from_mcp_response(result, config)
-    
-    async def _call_hf_without_mcp(self, messages: List[Dict[str, Any]]) -> List[Any]:
-        """Call HuggingFace provider without MCP"""
-        from gradio import ChatMessage
+        logger.info("🔧 Attempting manual tool extraction...")
         
         try:
-            completion = self.hf_client.chat.completions.create(
-                model=self.current_model,
-                messages=messages,
-                max_tokens=AppConfig.MAX_TOKENS,
-                temperature=0.7
-            )
+            # Extract server name
+            server_match = re.search(r'"server":\s*"([^"]+)"', text)
+            tool_match = re.search(r'"tool":\s*"([^"]+)"', text)
             
-            response_content = completion.choices[0].message.content
+            if not server_match or not tool_match:
+                logger.warning("⚠️ Could not find server or tool in manual extraction")
+                return None
             
-            return [ChatMessage(role="assistant", content=response_content)]
+            server_name = server_match.group(1)
+            tool_name = tool_match.group(1)
+            
+            # Try to extract arguments
+            args_match = re.search(r'"arguments":\s*\{([^}]+)\}', text)
+            arguments = {}
+            
+            if args_match:
+                args_content = args_match.group(1)
+                # Simple extraction of key-value pairs
+                pairs = re.findall(r'"([^"]+)":\s*"([^"]+)"', args_content)
+                arguments = dict(pairs)
+            
+            manual_request = {
+                "use_tool": True,
+                "server": server_name,
+                "tool": tool_name,
+                "arguments": arguments
+            }
+            
+            logger.info(f"🔧 Manual extraction successful: {manual_request}")
+            return manual_request
             
         except Exception as e:
-            logger.error(f"HF inference error: {e}")
-            return [ChatMessage(role="assistant", content=f"❌ Error: {str(e)}")]
+            logger.error(f"❌ Manual extraction failed: {e}")
+            return None
     
-    def _call_claude_without_mcp(self, messages: List[Dict[str, Any]]) -> List[Any]:
-        """Call Claude API without MCP servers (existing implementation)"""
-        from gradio import ChatMessage
-        import time
-        
-        logger.info("💬 No MCP servers available, using regular Claude chat")
+    def _reconstruct_json_from_start(self, text: str) -> Optional[str]:
+        """Try to reconstruct JSON if it's truncated"""
+        import re
         
-        system_prompt = self._get_native_system_prompt()
+        # Find start of JSON
+        match = re.search(r'\{"use_tool":\s*true[^}]*', text)
+        if not match:
+            return None
         
-        # Use regular messages API
-        response = self.anthropic_client.messages.create(
-            model=AppConfig.CLAUDE_MODEL,
-            max_tokens=AppConfig.MAX_TOKENS,
-            system=system_prompt,
-            messages=messages
-        )
+        json_start = match.start()
+        json_part = text[json_start:]
         
-        response_text = ""
-        for content in response.content:
-            if content.type == "text":
-                response_text += content.text
+        logger.info(f"🔧 Reconstructing JSON from: {json_part[:200]}...")
         
-        if not response_text:
-            response_text = "I understand your request and I'm here to help."
+        # Try to find the end or reconstruct
+        brace_count = 0
+        end_pos = 0
+        in_string = False
+        escape_next = False
         
-        return [ChatMessage(role="assistant", content=response_text)]
-    
-    def _get_native_system_prompt(self) -> str:
-        """Get system prompt for Claude without MCP servers"""
-        from datetime import datetime
-        
-        return f"""You are Claude Sonnet 4, a helpful AI assistant with native multimodal capabilities. You can have conversations, answer questions, help with various tasks, and provide information on a wide range of topics.
-
-YOUR NATIVE CAPABILITIES (Available right now):
-- **Image Understanding**: You can directly see and describe images, analyze their content, read text in images, identify objects, people, scenes, etc.
-- **Text Processing**: You can analyze, summarize, translate, and process text directly
-- **General Knowledge**: You can answer questions, explain concepts, and have conversations
-- **Code Analysis**: You can read, analyze, and explain code
-
-Current time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-
-IMPORTANT: You DO NOT need MCP servers for:
-- Describing or analyzing uploaded images
-- Reading text in images
-- Identifying objects, people, or scenes in images
-- General conversation and knowledge questions
-
-You DO need MCP servers for:
-- Creating new images, audio, or video
-- Editing or transforming existing media files
-- Transcribing audio files
-- Processing non-image files (audio, video, documents)
-
-If users upload images and ask you to describe or analyze them, use your native vision capabilities immediately. Only mention MCP servers if they ask for creation or editing tasks."""
-    
-    def _get_anthropic_mcp_system_prompt(self, user_files: List[str]) -> str:
-        """Get system prompt for Claude with MCP servers (existing implementation)"""
-        from datetime import datetime
-        
-        uploaded_files_context = ""
-        if user_files:
-            uploaded_files_context = f"\n\nFILES UPLOADED BY USER:\n"
-            for i, file_path in enumerate(user_files, 1):
-                file_name = file_path.split('/')[-1] if '/' in file_path else file_path
-                if AppConfig.is_image_file(file_path):
-                    file_type = "Image"
-                elif AppConfig.is_audio_file(file_path):
-                    file_type = "Audio"
-                elif AppConfig.is_video_file(file_path):
-                    file_type = "Video"
-                else:
-                    file_type = "File"
-                uploaded_files_context += f"{i}. {file_type}: {file_name} (path: {file_path})\n"
+        for i, char in enumerate(json_part):
+            if escape_next:
+                escape_next = False
+                continue
+                
+            if char == '\\':
+                escape_next = True
+                continue
+                
+            if char == '"' and not escape_next:
+                in_string = not in_string
+                continue
+                
+            if not in_string:
+                if char == '{':
+                    brace_count += 1
+                elif char == '}':
+                    brace_count -= 1
+                    if brace_count == 0:
+                        end_pos = i + 1
+                        break
         
-        return f"""You are Claude Sonnet 4, a helpful AI assistant with both native multimodal capabilities and access to various MCP tools.
-
-YOUR NATIVE CAPABILITIES (No MCP tools needed):
-- **Image Understanding**: You can directly see and describe images, analyze their content, read text in images, etc.
-- **Text Processing**: You can analyze, summarize, translate, and process text directly
-- **General Knowledge**: You can answer questions, explain concepts, and have conversations
-- **Code Analysis**: You can read, analyze, and explain code
-
-WHEN TO USE MCP TOOLS:
-- **Image Generation**: Creating new images from text prompts
-- **Image Editing**: Modifying, enhancing, or transforming existing images  
-- **Audio Processing**: Transcribing audio, generating speech, audio enhancement
-- **Video Processing**: Creating or editing videos
-- **Specialized Analysis**: Tasks requiring specific models or APIs
-
-UPLOADED FILES HANDLING:
-{uploaded_files_context}
-
-IMPORTANT - For uploaded images:
-- **Image Description/Analysis**: Use your NATIVE vision capabilities - you can see and describe images directly
-- **Image Editing/Enhancement**: Use MCP image processing tools
-- **Image Generation**: Use MCP image generation tools
-
-IMPORTANT - GRADIO MEDIA DISPLAY:
-When MCP tools return media, end your response with "MEDIA_GENERATED: [URL]" where [URL] is the actual media URL.
-
-Current time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-Available MCP servers: {list(self.servers.keys())}"""
-    
-    def _get_hf_mcp_system_prompt(self, user_files: List[str], available_tools: List[Dict[str, Any]]) -> str:
-        """Get system prompt for HuggingFace providers with MCP"""
-        from datetime import datetime
-        
-        uploaded_files_context = ""
-        if user_files:
-            uploaded_files_context = f"\n\nFILES UPLOADED BY USER:\n"
-            for i, file_path in enumerate(user_files, 1):
-                file_name = file_path.split('/')[-1] if '/' in file_path else file_path
-                if AppConfig.is_image_file(file_path):
-                    file_type = "Image"
-                elif AppConfig.is_audio_file(file_path):
-                    file_type = "Audio"
-                elif AppConfig.is_video_file(file_path):
-                    file_type = "Video"
-                else:
-                    file_type = "File"
-                uploaded_files_context += f"{i}. {file_type}: {file_name} (path: {file_path})\n"
-        
-        tools_context = ""
-        if available_tools:
-            tools_context = f"\n\nAVAILABLE MCP TOOLS:\n"
-            for tool in available_tools:
-                tools_context += f"- {tool['name']}: {tool['description']} (server: {tool['server']})\n"
-            
-            tools_context += f"\nTo use a tool, respond with: CALL_TOOL: tool_name(arg1=\"value1\", arg2=\"value2\")\n"
+        if end_pos > 0:
+            reconstructed = json_part[:end_pos]
+            logger.info(f"🔧 Reconstructed JSON: {reconstructed}")
+            return reconstructed
+        else:
+            # Try to add missing closing braces
+            missing_braces = json_part.count('{') - json_part.count('}')
+            if missing_braces > 0:
+                reconstructed = json_part + '}' * missing_braces
+                logger.info(f"🔧 Added {missing_braces} closing braces: {reconstructed}")
+                return reconstructed
         
-        return f"""You are an AI assistant using {self.current_provider} inference with {self.current_model}. You have access to external tools via MCP (Model Context Protocol).
-
-YOUR CAPABILITIES:
-- **Text Processing**: You can analyze, summarize, translate, and process text directly
-- **General Knowledge**: You can answer questions, explain concepts, and have conversations  
-- **Code Analysis**: You can read, analyze, and explain code
-- **Tool Usage**: You can call external tools to extend your capabilities
-
-UPLOADED FILES HANDLING:
-{uploaded_files_context}
-
-{tools_context}
-
-IMPORTANT INSTRUCTIONS:
-- For complex tasks requiring specialized capabilities, use the available MCP tools
-- When you need to use a tool, clearly indicate it with the CALL_TOOL format
-- After using tools, provide a clear summary of the results to the user
-- If a tool returns media (images, audio, video), describe what was generated/processed
-
-Current time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-Current LLM: {self.current_provider}/{self.current_model}
-Available MCP servers: {list(self.servers.keys())}"""
+        return None
     
-    # Include existing helper methods from original implementation
     def _extract_media_from_mcp_response(self, result_text: str, config: MCPServerConfig) -> Optional[str]:
-        """Enhanced media extraction from MCP responses (existing implementation)"""
+        """Enhanced media extraction from MCP responses with better URL resolution"""
         if not isinstance(result_text, str):
             logger.info(f"🔍 Non-string result: {type(result_text)}")
             return None
@@ -647,13 +645,13 @@ Available MCP servers: {list(self.servers.keys())}"""
                             if media_type in item and isinstance(item[media_type], dict):
                                 media_data = item[media_type]
                                 if 'url' in media_data:
-                                    url = media_data['url']
+                                    url = media_data['url'].strip('\'"')  # Clean quotes
                                     logger.info(f"🎯 Found {media_type} URL: {url}")
                                     return self._resolve_media_url(url, base_url)
                         
                         # Check for direct URL
                         if 'url' in item:
-                            url = item['url']
+                            url = item['url'].strip('\'"')  # Clean quotes
                             logger.info(f"🎯 Found direct URL: {url}")
                             return self._resolve_media_url(url, base_url)
                 
@@ -666,13 +664,13 @@ Available MCP servers: {list(self.servers.keys())}"""
                         if media_type in data and isinstance(data[media_type], dict):
                             media_data = data[media_type]
                             if 'url' in media_data:
-                                url = media_data['url']
+                                url = media_data['url'].strip('\'"')  # Clean quotes
                                 logger.info(f"🎯 Found {media_type} URL: {url}")
                                 return self._resolve_media_url(url, base_url)
                     
                     # Check for direct URL
                     if 'url' in data:
-                        url = data['url']
+                        url = data['url'].strip('\'"')  # Clean quotes
                         logger.info(f"🎯 Found direct URL: {url}")
                         return self._resolve_media_url(url, base_url)
                 
@@ -681,17 +679,36 @@ Available MCP servers: {list(self.servers.keys())}"""
         except Exception as e:
             logger.warning(f"🔍 JSON parsing error: {e}")
         
-        # 2. Check for data URLs (base64 encoded media)
+        # 2. Check for Gradio file URLs (common pattern) with better cleaning
+        gradio_file_patterns = [
+            r'https://[^/]+\.hf\.space/gradio_api/file=/[^/]+/[^/]+/[^"\s\',]+',
+            r'https://[^/]+\.hf\.space/file=[^"\s\',]+',
+            r'/gradio_api/file=/[^"\s\',]+'
+        ]
+        
+        for pattern in gradio_file_patterns:
+            match = re.search(pattern, result_text)
+            if match:
+                url = match.group(0).rstrip('\'",:;')  # Remove trailing punctuation
+                logger.info(f"🎯 Found Gradio file URL: {url}")
+                if url.startswith('/'):
+                    url = f"{base_url}{url}"
+                return url
+        
+        # 3. Check for simple HTTP URLs in the text
+        http_url_pattern = r'https?://[^\s"<>]+'
+        matches = re.findall(http_url_pattern, result_text)
+        for url in matches:
+            if AppConfig.is_media_file(url):
+                logger.info(f"🎯 Found HTTP media URL: {url}")
+                return url
+        
+        # 4. Check for data URLs (base64 encoded media)
         if result_text.startswith('data:'):
             logger.info("🎯 Found data URL")
             return result_text
         
-        # 3. Check for base64 image patterns
-        if any(result_text.startswith(pattern) for pattern in ['iVBORw0KGgoAAAANSUhEU', '/9j/', 'UklGR']):
-            logger.info("🎯 Found base64 image data")
-            return f"data:image/png;base64,{result_text}"
-        
-        # 4. Check for file paths and convert to URLs
+        # 5. For simple file paths, create proper Gradio URLs
         if AppConfig.is_media_file(result_text):
             # Extract just the filename if it's a path
             if '/' in result_text:
@@ -699,246 +716,29 @@ Available MCP servers: {list(self.servers.keys())}"""
             else:
                 filename = result_text.strip()
             
-            # Create Gradio file URL
-            if filename.startswith('http'):
-                media_url = filename
-            else:
-                media_url = f"{base_url}/file={filename}"
-            
-            logger.info(f"🎯 Found media file: {media_url}")
+            # Create proper Gradio file URL
+            media_url = f"{base_url}/file={filename}"
+            logger.info(f"🎯 Created media URL from filename: {media_url}")
             return media_url
         
-        # 5. Check for HTTP URLs that look like media
-        if result_text.startswith('http') and AppConfig.is_media_file(result_text):
-            logger.info(f"🎯 Found HTTP media URL: {result_text}")
-            return result_text
-        
         logger.info("❌ No media detected in result")
         return None
     
     def _resolve_media_url(self, url: str, base_url: str) -> str:
-        """Resolve relative URLs to absolute URLs"""
+        """Resolve relative URLs to absolute URLs with better handling"""
         if url.startswith('http') or url.startswith('data:'):
             return url
+        elif url.startswith('/gradio_api/file='):
+            return f"{base_url}{url}"
+        elif url.startswith('/file='):
+            return f"{base_url}/gradio_api{url}"
+        elif url.startswith('file='):
+            return f"{base_url}/gradio_api/{url}"
         elif url.startswith('/'):
             return f"{base_url}/file={url}"
         else:
             return f"{base_url}/file={url}"
     
-    def _process_mcp_response(self, response, start_time: float) -> List[Any]:
-        """Process Claude's response with MCP tool calls into structured ChatMessage objects (existing implementation)"""
-        from gradio import ChatMessage
-        import time
-        
-        chat_messages = []
-        current_tool_id = None
-        current_server_name = None
-        tool_start_time = None
-        text_segments = []  # Collect text segments separately
-        
-        # Process Claude's response
-        for content in response.content:
-            if content.type == "text":
-                # Collect text segments but don't combine them yet
-                text_content = content.text
-                # Check if Claude indicated media was generated
-                if "MEDIA_GENERATED:" in text_content:
-                    media_match = re.search(r"MEDIA_GENERATED:\s*([^\s]+)", text_content)
-                    if media_match:
-                        media_url = media_match.group(1)
-                        # Clean up the response text
-                        text_content = re.sub(r"MEDIA_GENERATED:\s*[^\s]+", "", text_content).strip()
-                        logger.info(f"🎯 Claude indicated media generated: {media_url}")
-                        # Add media as separate message
-                        chat_messages.append(ChatMessage(
-                            role="assistant", 
-                            content={"path": media_url}
-                        ))
-                
-                if text_content.strip():
-                    text_segments.append(text_content.strip())
-            
-            elif hasattr(content, 'type') and content.type == "mcp_tool_use":
-                # Add any accumulated text before tool use
-                if text_segments:
-                    combined_text = " ".join(text_segments)
-                    if combined_text.strip():
-                        chat_messages.append(ChatMessage(
-                            role="assistant",
-                            content=combined_text.strip()
-                        ))
-                    text_segments = []  # Reset
-                
-                tool_name = content.name
-                server_name = content.server_name
-                current_tool_id = getattr(content, 'id', 'unknown')
-                current_server_name = server_name
-                tool_start_time = time.time()
-                
-                logger.info(f"🔧 Claude used MCP tool: {tool_name} on server: {server_name}")
-                
-                # Create a "thinking" message for tool usage
-                chat_messages.append(ChatMessage(
-                    role="assistant",
-                    content="",
-                    metadata={
-                        "title": f"🔧 Using {tool_name}",
-                        "id": current_tool_id,
-                        "status": "pending",
-                        "log": f"Server: {server_name}"
-                    }
-                ))
-                
-            elif hasattr(content, 'type') and content.type == "mcp_tool_result":
-                tool_use_id = getattr(content, 'tool_use_id', 'unknown')
-                duration = time.time() - tool_start_time if tool_start_time else None
-                
-                logger.info(f"📝 Processing MCP tool result (tool_use_id: {tool_use_id})")
-                
-                # Update the pending tool message to completed
-                for msg in chat_messages:
-                    if (msg.metadata and 
-                        msg.metadata.get("id") == current_tool_id and 
-                        msg.metadata.get("status") == "pending"):
-                        msg.metadata["status"] = "done"
-                        if duration:
-                            msg.metadata["duration"] = round(duration, 2)
-                        break
-                
-                media_url = None
-                if content.content:
-                    result_content = content.content[0]
-                    result_text = result_content.text if hasattr(result_content, 'text') else str(result_content)
-                    
-                    logger.info(f"📝 MCP tool result: {result_text[:200]}...")
-                    
-                    # Try to extract media URL from the result
-                    if current_server_name and current_server_name in self.servers:
-                        config = self.servers[current_server_name]
-                        extracted_media = self._extract_media_from_mcp_response(result_text, config)
-                        if extracted_media:
-                            media_url = extracted_media
-                            logger.info(f"🎯 Extracted media from MCP result: {media_url}")
-                    else:
-                        # Fallback: try all servers to find media
-                        for server_name, config in self.servers.items():
-                            extracted_media = self._extract_media_from_mcp_response(result_text, config)
-                            if extracted_media:
-                                media_url = extracted_media
-                                logger.info(f"🎯 Extracted media from MCP result (fallback): {media_url}")
-                                break
-                    
-                    # Always show the full tool result
-                    chat_messages.append(ChatMessage(
-                        role="assistant",
-                        content=result_text,
-                        metadata={
-                            "title": "📋 Tool Result",
-                            "parent_id": current_tool_id,
-                            "status": "done"
-                        }
-                    ))
-                    
-                    # Only add separate media display if the tool result does NOT contain 
-                    # any Gradio file data structures that would be auto-rendered
-                    if media_url and not self._contains_gradio_file_structure(result_text):
-                        logger.info(f"🎯 Adding separate media display for: {media_url}")
-                        chat_messages.append(ChatMessage(
-                            role="assistant", 
-                            content={"path": media_url}
-                        ))
-                    else:
-                        if media_url:
-                            logger.info(f"🚫 Skipping separate media - tool result contains Gradio file structure")
-                        else:
-                            logger.info(f"🚫 No media URL extracted")
-                        
-                else:
-                    # Add error message for failed tool call
-                    chat_messages.append(ChatMessage(
-                        role="assistant",
-                        content="Tool call failed: No content returned",
-                        metadata={
-                            "title": "❌ Tool Error",
-                            "parent_id": current_tool_id,
-                            "status": "done"
-                        }
-                    ))
-        
-        # Add any remaining text segments after all processing
-        if text_segments:
-            combined_text = " ".join(text_segments)
-            if combined_text.strip():
-                chat_messages.append(ChatMessage(
-                    role="assistant",
-                    content=combined_text.strip()
-                ))
-        
-        # Fallback if no content was processed
-        if not chat_messages:
-            chat_messages.append(ChatMessage(
-                role="assistant",
-                content="I understand your request and I'm here to help."
-            ))
-        
-        return chat_messages
-    
-    def _contains_gradio_file_structure(self, text: str) -> bool:
-        """Check if the text contains ANY Gradio file data structures that would be auto-rendered (existing implementation)"""
-        
-        # Check for key indicators of Gradio file structures
-        gradio_indicators = [
-            # Gradio FileData type indicators
-            "'_type': 'gradio.FileData'",
-            '"_type": "gradio.FileData"',
-            'gradio.FileData',
-            
-            # File structure patterns
-            "'path':",
-            '"path":',
-            "'url':",
-            '"url":',
-            "'orig_name':",
-            '"orig_name":',
-            "'mime_type':",
-            '"mime_type":',
-            'is_stream',
-            'meta_type',
-            
-            # Common file result patterns
-            "{'image':",
-            '{"image":',
-            "{'audio':",
-            '{"audio":',
-            "{'video':",
-            '{"video":',
-            "{'file':",
-            '{"file":',
-            
-            # List patterns that typically contain file objects
-            "[{'image'",
-            '[{"image"',
-            "[{'audio'",
-            '[{"audio"',
-            "[{'video'",
-            '[{"video"',
-            "[{'file'",
-            '[{"file"'
-        ]
-        
-        # If we find multiple indicators, it's likely a Gradio file structure
-        indicator_count = sum(1 for indicator in gradio_indicators if indicator in text)
-        
-        # Also check for simple URL patterns (for audio case)
-        is_simple_url = (text.strip().startswith('http') and 
-                        len(text.strip().split()) == 1 and 
-                        any(ext in text.lower() for ext in ['.wav', '.mp3', '.mp4', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webm', '.ogg']))
-        
-        result = indicator_count >= 2 or is_simple_url
-        logger.debug(f"📋 File structure check: {indicator_count} indicators, simple_url: {is_simple_url}, result: {result}")
-        
-        return result
-    
     def get_server_status(self) -> Dict[str, str]:
         """Get status of all configured servers"""
         status = {}
@@ -956,4 +756,4 @@ Available MCP servers: {list(self.servers.keys())}"""
         elif "localhost" in config.url or "127.0.0.1" in config.url:
             return "🟢 Local server (file access available)"
         else:
-            return "🔴 Remote server (may need public URLs)"
+            return "🔴 Remote server (may need public URLs)"