Update chat_handler.py

chat_handler.py

@@ -1,9 +1,10 @@
 """
-Chat handling logic for Universal MCP Client - Updated with ChatMessage support
+Chat handling logic for Universal MCP Client - Enhanced with Inference Provider Support
 """
 import re
 import logging
 import traceback
+import asyncio
 from datetime import datetime
 from typing import Dict, Any, List, Tuple, Optional
 import gradio as gr
@@ -16,16 +17,26 @@ from mcp_client import UniversalMCPClient
 logger = logging.getLogger(__name__)
 
 class ChatHandler:
-    """Handles chat interactions with Claude and MCP servers using ChatMessage dataclass"""
+    """Handles chat interactions with multiple LLM backends and MCP servers using ChatMessage dataclass"""
     
     def __init__(self, mcp_client: UniversalMCPClient):
         self.mcp_client = mcp_client
     
     def process_multimodal_message(self, message: Dict[str, Any], history: List) -> Tuple[List[ChatMessage], Dict[str, Any]]:
-        """Enhanced MCP chat function with multimodal input support and ChatMessage formatting"""
+        """Enhanced MCP chat function with multimodal input support and multiple LLM backends"""
         
-        if not self.mcp_client.anthropic_client:
-            error_msg = "❌ Anthropic API key not configured. Please set ANTHROPIC_API_KEY environment variable."
+        # Check if any LLM backend is configured
+        backend_configured = False
+        
+        if self.mcp_client.anthropic_client and AppConfig.ANTHROPIC_API_KEY:
+            backend_configured = True
+            backend_type = "anthropic"
+        elif self.mcp_client.hf_client and self.mcp_client.current_provider:
+            backend_configured = True
+            backend_type = "hf_inference"
+        
+        if not backend_configured:
+            error_msg = "❌ No LLM backend configured. Please configure either Anthropic API key or HuggingFace Inference Provider."
             history.append(ChatMessage(role="user", content=error_msg))
             history.append(ChatMessage(role="assistant", content=error_msg))
             return history, gr.MultimodalTextbox(value=None, interactive=False)
@@ -44,7 +55,7 @@ class ChatHandler:
                 user_text = message
                 user_files = []
             
-            logger.info(f"💬 Processing multimodal message:")
+            logger.info(f"💬 Processing multimodal message with {backend_type} backend:")
             logger.info(f"  📝 Text: {user_text}")
             logger.info(f"  📁 Files: {len(user_files)} files uploaded")
             logger.info(f"  📋 History type: {type(history)}, length: {len(history)}")
@@ -86,11 +97,14 @@ class ChatHandler:
             if not user_text.strip() and not user_files:
                 return history, gr.MultimodalTextbox(value=None, interactive=False)
             
-            # Create messages for Claude API 
-            messages = self._prepare_claude_messages(history)
+            # Create messages for LLM API 
+            messages = self._prepare_llm_messages(history)
             
-            # Process the chat and get structured responses
-            response_messages = self._call_claude_api(messages, user_files)
+            # Process the chat based on backend type
+            if backend_type == "anthropic":
+                response_messages = self._call_anthropic_api(messages, user_files)
+            else:  # hf_inference
+                response_messages = self._call_hf_inference_api(messages, user_files)
             
             # Add all response messages to history
             history.extend(response_messages)
@@ -112,11 +126,11 @@ class ChatHandler:
             history.append(ChatMessage(role="assistant", content=error_msg))
             return history, gr.MultimodalTextbox(value=None, interactive=False)
     
-    def _prepare_claude_messages(self, history: List) -> List[Dict[str, Any]]:
-        """Convert history (ChatMessage or dict) to Claude API format"""
+    def _prepare_llm_messages(self, history: List) -> List[Dict[str, Any]]:
+        """Convert history (ChatMessage or dict) to LLM API format"""
         messages = []
         
-        # Convert history to Claude API format (text only for context)
+        # Convert history to LLM API format (text only for context)
         recent_history = history[-16:] if len(history) > 16 else history
         for msg in recent_history:
             # Handle both ChatMessage objects and dictionary format for backward compatibility
@@ -160,8 +174,8 @@ class ChatHandler:
         
         return messages
     
-    def _call_claude_api(self, messages: List[Dict[str, Any]], user_files: List[str]) -> List[ChatMessage]:
-        """Call Claude API and return structured ChatMessage responses"""
+    def _call_anthropic_api(self, messages: List[Dict[str, Any]], user_files: List[str]) -> List[ChatMessage]:
+        """Call Anthropic API (existing implementation)"""
         
         # Check if we have MCP servers to use
         if not self.mcp_client.servers:
@@ -169,6 +183,26 @@ class ChatHandler:
         else:
             return self._call_claude_with_mcp(messages, user_files)
     
+    def _call_hf_inference_api(self, messages: List[Dict[str, Any]], user_files: List[str]) -> List[ChatMessage]:
+        """Call HuggingFace Inference API with custom MCP implementation"""
+        
+        # Run async call in sync context
+        def run_async():
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                return loop.run_until_complete(
+                    self.mcp_client.call_llm_with_mcp(messages, user_files)
+                )
+            finally:
+                loop.close()
+        
+        try:
+            return run_async()
+        except Exception as e:
+            logger.error(f"HF Inference API error: {e}")
+            return [ChatMessage(role="assistant", content=f"❌ Error with HF Inference: {str(e)}")]
+    
     def _call_claude_without_mcp(self, messages: List[Dict[str, Any]]) -> List[ChatMessage]:
         """Call Claude API without MCP servers"""
         logger.info("💬 No MCP servers available, using regular Claude chat")
@@ -501,26 +535,8 @@ IMPORTANT - For uploaded images:
 - **Image Editing/Enhancement**: Use MCP image processing tools
 - **Image Generation**: Use MCP image generation tools
 
-IMPORTANT - File URL Conversion for MCP Tools:
-When using MCP tools that require file inputs, you need to be aware that uploaded files have local paths that remote MCP servers cannot access. 
-
-For uploaded files in MCP tool calls:
-- If an MCP tool fails with "Invalid file data format" or similar errors about file paths
-- The issue is that remote MCP servers cannot access local file paths like '/tmp/gradio/...'
-- In such cases, inform the user that the MCP server requires files to be accessible via public URLs
-- Suggest that they need a "File Upload" MCP server or that the specific MCP server may need configuration for file handling
-
-Current uploaded files that may need URL conversion:
-{uploaded_files_context}
-
 IMPORTANT - GRADIO MEDIA DISPLAY:
 When MCP tools return media, end your response with "MEDIA_GENERATED: [URL]" where [URL] is the actual media URL.
 
-Examples:
-- User uploads image + "What's in this image?" → Use NATIVE vision (no MCP needed)
-- User uploads image + "Make this vintage" → Use MCP image editing tool  
-- User says "Generate a sunset image" → Use MCP image generation tool
-- User uploads audio + "Transcribe this" → Use MCP transcription tool
-
 Current time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
 Available MCP servers: {list(self.mcp_client.servers.keys())}"""