Update app.py

app.py

@@ -5,6 +5,7 @@ import json
 import base64
 import logging
 import io
+import time
 from typing import List, Dict, Any, Union, Tuple, Optional
 
 # Configure logging
@@ -14,37 +15,71 @@ logger = logging.getLogger(__name__)
 # Gracefully import libraries with fallbacks
 try:
     from PIL import Image
+    HAS_PIL = True
 except ImportError:
     logger.warning("PIL not installed. Image processing will be limited.")
-    Image = None
+    HAS_PIL = False
 
 try:
     import PyPDF2
+    HAS_PYPDF2 = True
 except ImportError:
     logger.warning("PyPDF2 not installed. PDF processing will be limited.")
-    PyPDF2 = None
+    HAS_PYPDF2 = False
 
 try:
     import markdown
+    HAS_MARKDOWN = True
 except ImportError:
     logger.warning("Markdown not installed. Markdown processing will be limited.")
-    markdown = None
+    HAS_MARKDOWN = False
 
-# API key
+try:
+    import openai
+    HAS_OPENAI = True
+except ImportError:
+    logger.warning("OpenAI package not installed. OpenAI models will be unavailable.")
+    HAS_OPENAI = False
+
+try:
+    from groq import Groq
+    HAS_GROQ = True
+except ImportError:
+    logger.warning("Groq client not installed. Groq API will be unavailable.")
+    HAS_GROQ = False
+
+try:
+    import cohere
+    HAS_COHERE = True
+except ImportError:
+    logger.warning("Cohere package not installed. Cohere models will be unavailable.")
+    HAS_COHERE = False
+
+try:
+    from huggingface_hub import InferenceClient
+    HAS_HF = True
+except ImportError:
+    logger.warning("HuggingFace hub not installed. HuggingFace models will be limited.")
+    HAS_HF = False
+
+# API keys from environment
 OPENROUTER_API_KEY = os.environ.get("OPENROUTER_API_KEY", "")
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
+GROQ_API_KEY = os.environ.get("GROQ_API_KEY", "")
+COHERE_API_KEY = os.environ.get("COHERE_API_KEY", "")
+GLHF_API_KEY = os.environ.get("GLHF_API_KEY", "")
+HF_API_KEY = os.environ.get("HF_API_KEY", "")
 
-# Log API key status (masked for security)
-if OPENROUTER_API_KEY:
-    masked_key = OPENROUTER_API_KEY[:4] + "..." + OPENROUTER_API_KEY[-4:] if len(OPENROUTER_API_KEY) > 8 else "***"
-    logger.info(f"Using API key: {masked_key}")
-else:
-    logger.warning("No API key provided!")
+# ==========================================================
+# MODEL DEFINITIONS
+# ==========================================================
 
-# Keep the existing model lists
-MODELS = [
+# OPENROUTER MODELS
+# These are the original models from the provided code
+OPENROUTER_MODELS = [
     # 1M+ Context Models
     {"category": "1M+ Context", "models": [
-        ("Google: Gemini Pro 2.0 Experimental", "google/gemini-2.0-pro-exp-02-05:free", 2000000),
+        #("Google: Gemini Pro 2.0 Experimental", "google/gemini-2.0-pro-exp-02-05:free", 2000000),
         ("Google: Gemini 2.0 Flash Thinking Experimental 01-21", "google/gemini-2.0-flash-thinking-exp:free", 1048576),
         ("Google: Gemini Flash 2.0 Experimental", "google/gemini-2.0-flash-exp:free", 1048576),
         ("Google: Gemini Pro 2.5 Experimental", "google/gemini-2.5-pro-exp-03-25:free", 1000000),
@@ -125,7 +160,7 @@ MODELS = [
 
     # Vision-capable Models
     {"category": "Vision Models", "models": [
-        ("Google: Gemini Pro 2.0 Experimental", "google/gemini-2.0-pro-exp-02-05:free", 2000000),
+        #("Google: Gemini Pro 2.0 Experimental", "google/gemini-2.0-pro-exp-02-05:free", 2000000),
         ("Google: Gemini 2.0 Flash Thinking Experimental 01-21", "google/gemini-2.0-flash-thinking-exp:free", 1048576),
         ("Google: Gemini Flash 2.0 Experimental", "google/gemini-2.0-flash-exp:free", 1048576),
         ("Google: Gemini Pro 2.5 Experimental", "google/gemini-2.5-pro-exp-03-25:free", 1000000),
@@ -147,89 +182,159 @@ MODELS = [
     ]},
 ]
 
-# Flatten model list for easy searching
-ALL_MODELS = []
-for category in MODELS:
+# Flatten OpenRouter model list for easier access
+OPENROUTER_ALL_MODELS = []
+for category in OPENROUTER_MODELS:
     for model in category["models"]:
-        if model not in ALL_MODELS:  # Avoid duplicates
-            ALL_MODELS.append(model)
+        if model not in OPENROUTER_ALL_MODELS:  # Avoid duplicates
+            OPENROUTER_ALL_MODELS.append(model)
 
-# Helper functions moved to the top to avoid undefined references
-def filter_models(search_term):
-    """Filter models based on search term"""
-    if not search_term:
-        return [model[0] for model in ALL_MODELS], ALL_MODELS[0][0]
-    
-    filtered_models = [model[0] for model in ALL_MODELS if search_term.lower() in model[0].lower()]
-    
-    if filtered_models:
-        return filtered_models, filtered_models[0]
-    else:
-        return [model[0] for model in ALL_MODELS], ALL_MODELS[0][0]
+# OPENAI MODELS
+OPENAI_MODELS = {
+    "gpt-3.5-turbo": 16385,
+    "gpt-3.5-turbo-0125": 16385,
+    "gpt-3.5-turbo-1106": 16385,
+    "gpt-3.5-turbo-instruct": 4096,
+    "gpt-4": 8192,
+    "gpt-4-0314": 8192,
+    "gpt-4-0613": 8192,
+    "gpt-4-turbo": 128000,
+    "gpt-4-turbo-2024-04-09": 128000,
+    "gpt-4-turbo-preview": 128000,
+    "gpt-4-0125-preview": 128000,
+    "gpt-4-1106-preview": 128000,
+    "gpt-4o": 128000,
+    "gpt-4o-2024-11-20": 128000,
+    "gpt-4o-2024-08-06": 128000,
+    "gpt-4o-2024-05-13": 128000,
+    "chatgpt-4o-latest": 128000,
+    "gpt-4o-mini": 128000,
+    "gpt-4o-mini-2024-07-18": 128000,
+    "gpt-4o-realtime-preview": 128000,
+    "gpt-4o-realtime-preview-2024-10-01": 128000,
+    "gpt-4o-audio-preview": 128000,
+    "gpt-4o-audio-preview-2024-10-01": 128000,
+    "o1-preview": 128000,
+    "o1-preview-2024-09-12": 128000,
+    "o1-mini": 128000,
+    "o1-mini-2024-09-12": 128000,
+}
 
-def update_context_display(model_name):
-    """Update context size display for the selected model"""
-    for model in ALL_MODELS:
-        if model[0] == model_name:
-            _, _, context_size = model
-            context_formatted = f"{context_size:,}"
-            return f"{context_formatted} tokens"
-    return "Unknown"
+# HUGGINGFACE MODELS
+HUGGINGFACE_MODELS = {
+    "microsoft/phi-3-mini-4k-instruct": 4096,
+    "microsoft/Phi-3-mini-128k-instruct": 131072,
+    "HuggingFaceH4/zephyr-7b-beta": 8192,
+    "deepseek-ai/DeepSeek-Coder-V2-Instruct": 8192,
+    "mistralai/Mistral-7B-Instruct-v0.3": 32768,
+    "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO": 32768,
+    "microsoft/Phi-3.5-mini-instruct": 4096,
+    "HuggingFaceTB/SmolLM2-1.7B-Instruct": 2048,
+    "google/gemma-2-2b-it": 2048,
+    "openai-community/gpt2": 1024,
+    "microsoft/phi-2": 2048,
+    "TinyLlama/TinyLlama-1.1B-Chat-v1.0": 2048,
+    "VAGOsolutions/Llama-3-SauerkrautLM-8b-Instruct": 2048,
+    "VAGOsolutions/Llama-3.1-SauerkrautLM-8b-Instruct": 4096,
+    "VAGOsolutions/SauerkrautLM-Nemo-12b-Instruct": 4096,
+    "openGPT-X/Teuken-7B-instruct-research-v0.4": 4096,
+    "Qwen/Qwen2.5-7B-Instruct": 131072,
+    "tiiuae/falcon-7b-instruct": 8192,
+    "Qwen/QwQ-32B-preview": 32768,
+}
 
-def update_model_info(model_name):
-    """Generate HTML info display for the selected model"""
-    for model in ALL_MODELS:
-        if model[0] == model_name:
-            name, model_id, context_size = model
-            
-            # Check if this is a vision model
-            is_vision_model = False
-            for cat in MODELS:
-                if cat["category"] == "Vision Models":
-                    if any(m[0] == model_name for m in cat["models"]):
-                        is_vision_model = True
-                        break
-            
-            vision_badge = '<span style="background-color: #4CAF50; color: white; padding: 3px 6px; border-radius: 3px; font-size: 0.8em; margin-left: 5px;">Vision</span>' if is_vision_model else ''
-            
-            return f"""
-            <div class="model-info">
-                <h3>{name} {vision_badge}</h3>
-                <p><strong>Model ID:</strong> {model_id}</p>
-                <p><strong>Context Size:</strong> {context_size:,} tokens</p>
-                <p><strong>Provider:</strong> {model_id.split('/')[0]}</p>
-                {f'<p><strong>Features:</strong> Supports image understanding</p>' if is_vision_model else ''}
-            </div>
-            """
-    return "<p>Model information not available</p>"
+# GROQ MODELS - We'll populate this dynamically
+DEFAULT_GROQ_MODELS = {
+    "gemma2-9b-it": 8192,
+    "gemma-7b-it": 8192,
+    "llama-3.3-70b-versatile": 131072,
+    "llama-3.1-70b-versatile": 131072,
+    "llama-3.1-8b-instant": 131072,
+    "llama-guard-3-8b": 8192,
+    "llama3-70b-8192": 8192,
+    "llama3-8b-8192": 8192,
+    "mixtral-8x7b-32768": 32768,
+    "llama3-groq-70b-8192-tool-use-preview": 8192,
+    "llama3-groq-8b-8192-tool-use-preview": 8192,
+    "llama-3.3-70b-specdec": 131072,
+    "llama-3.1-70b-specdec": 131072,
+    "llama-3.2-1b-preview": 131072,
+    "llama-3.2-3b-preview": 131072,
+}
 
-def update_category_dropdown(category):
-    """Update the category model dropdown when a category is selected"""
-    models = get_models_for_category(category)
-    if not models:
-        return [], None
-    return models, models[0]
+# COHERE MODELS
+COHERE_MODELS = {
+    "command-r-plus-08-2024": 131072,
+    "command-r-plus-04-2024": 131072,
+    "command-r-plus": 131072,
+    "command-r-08-2024": 131072,
+    "command-r-03-2024": 131072,
+    "command-r": 131072,
+    "command": 4096,
+    "command-nightly": 131072,
+    "command-light": 4096,
+    "command-light-nightly": 4096,
+    "c4ai-aya-expanse-8b": 8192,
+    "c4ai-aya-expanse-32b": 131072,
+}
 
-def update_category_models_ui(category):
-    """Completely regenerate the models dropdown based on selected category"""
-    for cat in MODELS:
-        if cat["category"] == category:
-            model_names = [model[0] for model in cat["models"]]
-            if model_names:
-                # Return a completely new dropdown component
-                return gr.Dropdown(
-                    choices=model_names,
-                    value=model_names[0],
-                    label="Models in Category",
-                    allow_custom_value=True
-                )
-    # Return empty dropdown if no models found
-    return gr.Dropdown(
-        choices=[],
-        value=None,
-        label="Models in Category",
-        allow_custom_value=True
-    )
+# GLHF MODELS
+GLHF_MODELS = {
+    "mistralai/Mixtral-8x7B-Instruct-v0.1": 32768,
+    "01-ai/Yi-34B-Chat": 32768,
+    "mistralai/Mistral-7B-Instruct-v0.3": 32768,
+    "microsoft/phi-3-mini-4k-instruct": 4096,
+    "microsoft/Phi-3.5-mini-instruct": 4096,
+    "microsoft/Phi-3-mini-128k-instruct": 131072,
+    "HuggingFaceH4/zephyr-7b-beta": 8192,
+    "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO": 32768,
+    "google/gemma-2-2b-it": 2048,
+    "microsoft/phi-2": 2048,
+}
+
+# ==========================================================
+# HELPER FUNCTIONS
+# ==========================================================
+
+def fetch_groq_models():
+    """Fetch available Groq models with proper error handling"""
+    try:
+        if not HAS_GROQ or not GROQ_API_KEY:
+            logger.warning("Groq client not available or no API key. Using default model list.")
+            return DEFAULT_GROQ_MODELS
+
+        client = Groq(api_key=GROQ_API_KEY)
+        models = client.models.list()
+        
+        # Create dictionary of model_id -> context size
+        model_dict = {}
+        for model in models.data:
+            model_id = model.id
+            # Map known context sizes or use a default
+            if "llama-3" in model_id and "70b" in model_id:
+                context_size = 131072
+            elif "llama-3" in model_id and "8b" in model_id:
+                context_size = 131072
+            elif "mixtral" in model_id:
+                context_size = 32768
+            elif "gemma" in model_id:
+                context_size = 8192
+            else:
+                context_size = 8192  # Default assumption
+                
+            model_dict[model_id] = context_size
+            
+        # Ensure we have models by combining with defaults
+        if not model_dict:
+            return DEFAULT_GROQ_MODELS
+        return {**DEFAULT_GROQ_MODELS, **model_dict}
+        
+    except Exception as e:
+        logger.error(f"Error fetching Groq models: {e}")
+        return DEFAULT_GROQ_MODELS
+
+# Initialize Groq models
+GROQ_MODELS = fetch_groq_models()
 
 def encode_image_to_base64(image_path):
     """Encode an image file to base64 string"""
@@ -271,7 +376,7 @@ def extract_text_from_file(file_path):
         file_extension = file_path.split('.')[-1].lower()
         
         if file_extension == 'pdf':
-            if PyPDF2 is not None:
+            if HAS_PYPDF2:
                 text = ""
                 with open(file_path, 'rb') as file:
                     pdf_reader = PyPDF2.PdfReader(file)
@@ -379,74 +484,419 @@ def process_uploaded_images(files):
             file_paths.append(file.name)
     return file_paths
 
-def get_model_info(model_choice):
-    """Get model ID and context size from model name"""
-    for name, model_id_value, ctx_size in ALL_MODELS:
-        if name == model_choice:
-            return model_id_value, ctx_size
+def filter_models(provider, search_term):
+    """Filter models based on search term and provider"""
+    if provider == "OpenRouter":
+        all_models = [model[0] for model in OPENROUTER_ALL_MODELS]
+    elif provider == "OpenAI":
+        all_models = list(OPENAI_MODELS.keys())
+    elif provider == "HuggingFace":
+        all_models = list(HUGGINGFACE_MODELS.keys())
+    elif provider == "Groq":
+        all_models = list(GROQ_MODELS.keys())
+    elif provider == "Cohere":
+        all_models = list(COHERE_MODELS.keys())
+    elif provider == "GLHF":
+        all_models = list(GLHF_MODELS.keys())
+    else:
+        return [], None
+        
+    if not search_term:
+        return all_models, all_models[0] if all_models else None
+        
+    filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
+    
+    if filtered_models:
+        return filtered_models, filtered_models[0]
+    else:
+        return
+    
+    return all_models, all_models[0] if all_models else None
+
+def get_model_info(provider, model_choice):
+    """Get model ID and context size based on provider and model name"""
+    if provider == "OpenRouter":
+        for name, model_id, ctx_size in OPENROUTER_ALL_MODELS:
+            if name == model_choice:
+                return model_id, ctx_size
+    elif provider == "OpenAI":
+        if model_choice in OPENAI_MODELS:
+            return model_choice, OPENAI_MODELS[model_choice]
+    elif provider == "HuggingFace":
+        if model_choice in HUGGINGFACE_MODELS:
+            return model_choice, HUGGINGFACE_MODELS[model_choice]
+    elif provider == "Groq":
+        if model_choice in GROQ_MODELS:
+            return model_choice, GROQ_MODELS[model_choice]
+    elif provider == "Cohere":
+        if model_choice in COHERE_MODELS:
+            return model_choice, COHERE_MODELS[model_choice]
+    elif provider == "GLHF":
+        if model_choice in GLHF_MODELS:
+            return model_choice, GLHF_MODELS[model_choice]
+    
     return None, 0
 
-def get_models_for_category(category):
-    """Get model list for a specific category"""
-    for cat in MODELS:
-        if cat["category"] == category:
-            return [model[0] for model in cat["models"]]
-    return []
+def update_context_display(provider, model_name):
+    """Update context size display for the selected model"""
+    _, ctx_size = get_model_info(provider, model_name)
+    return f"{ctx_size:,}" if ctx_size else "Unknown"
 
-def call_openrouter_api(payload):
+def update_model_info(provider, model_name):
+    """Generate HTML info display for the selected model"""
+    model_id, ctx_size = get_model_info(provider, model_name)
+    if not model_id:
+        return "<p>Model information not available</p>"
+        
+    # Check if this is a vision model
+    is_vision_model = False
+    
+    # For OpenRouter, check the vision models category
+    if provider == "OpenRouter":
+        for cat in OPENROUTER_MODELS:
+            if cat["category"] == "Vision Models":
+                if any(m[0] == model_name for m in cat["models"]):
+                    is_vision_model = True
+                    break
+    # For other providers, use heuristics
+    elif provider == "OpenAI" and any(x in model_name.lower() for x in ["gpt-4", "gpt-4o"]):
+        is_vision_model = True
+    elif provider == "HuggingFace" and any(x in model_name.lower() for x in ["vl", "vision"]):
+        is_vision_model = True
+    
+    vision_badge = '<span style="background-color: #4CAF50; color: white; padding: 3px 6px; border-radius: 3px; font-size: 0.8em; margin-left: 5px;">Vision</span>' if is_vision_model else ''
+    
+    # For OpenRouter, show the model ID
+    model_id_html = f"<p><strong>Model ID:</strong> {model_id}</p>" if provider == "OpenRouter" else ""
+    
+    # For others, the ID is the same as the name
+    if provider != "OpenRouter":
+        model_id_html = ""
+    
+    return f"""
+    <div class="model-info">
+        <h3>{model_name} {vision_badge}</h3>
+        {model_id_html}
+        <p><strong>Context Size:</strong> {ctx_size:,} tokens</p>
+        <p><strong>Provider:</strong> {provider}</p>
+        {f'<p><strong>Features:</strong> Supports image understanding</p>' if is_vision_model else ''}
+    </div>
+    """
+
+# ==========================================================
+# API HANDLERS
+# ==========================================================
+
+def call_openrouter_api(payload, api_key_override=None):
     """Make a call to OpenRouter API with error handling"""
     try:
+        api_key = api_key_override if api_key_override else OPENROUTER_API_KEY
+        if not api_key:
+            raise ValueError("OpenRouter API key is required")
+            
         response = requests.post(
             "https://openrouter.ai/api/v1/chat/completions",
             headers={
                 "Content-Type": "application/json",
-                "Authorization": f"Bearer {OPENROUTER_API_KEY}",
-                "HTTP-Referer": "https://huggingface.co/spaces/cstr/CrispChat"
+                "Authorization": f"Bearer {api_key}",
+                "HTTP-Referer": "https://huggingface.co/spaces/user/MultiProviderCrispChat"
             },
             json=payload,
             timeout=180  # Longer timeout for document processing
         )
         return response
     except requests.RequestException as e:
-        logger.error(f"API request error: {str(e)}")
+        logger.error(f"OpenRouter API request error: {str(e)}")
         raise e
 
-def extract_ai_response(result):
-    """Extract AI response from OpenRouter API result"""
+def call_openai_api(payload, api_key_override=None):
+    """Make a call to OpenAI API with error handling"""
     try:
-        if "choices" in result and len(result["choices"]) > 0:
-            if "message" in result["choices"][0]:
-                # Handle reasoning field if available
-                message = result["choices"][0]["message"]
-                if message.get("reasoning") and not message.get("content"):
-                    # Extract response from reasoning if there's no content
-                    reasoning = message.get("reasoning")
-                    # If reasoning contains the actual response, find it
-                    lines = reasoning.strip().split('\n')
-                    for line in lines:
-                        if line and not line.startswith('I should') and not line.startswith('Let me'):
-                            return line.strip()
-                    # If no clear response found, return the first non-empty line
-                    for line in lines:
-                        if line.strip():
-                            return line.strip()
-                return message.get("content", "")
-            elif "delta" in result["choices"][0]:
-                return result["choices"][0]["delta"].get("content", "")
+        if not HAS_OPENAI:
+            raise ImportError("OpenAI package not installed")
+            
+        api_key = api_key_override if api_key_override else OPENAI_API_KEY
+        if not api_key:
+            raise ValueError("OpenAI API key is required")
+            
+        client = openai.OpenAI(api_key=api_key)
         
-        logger.error(f"Unexpected response structure: {result}")
-        return "Error: Could not extract response from API result"
+        # Extract parameters from payload
+        model = payload.get("model", "gpt-3.5-turbo")
+        messages = payload.get("messages", [])
+        temperature = payload.get("temperature", 0.7)
+        max_tokens = payload.get("max_tokens", 1000)
+        stream = payload.get("stream", False)
+        top_p = payload.get("top_p", 0.9)
+        presence_penalty = payload.get("presence_penalty", 0)
+        frequency_penalty = payload.get("frequency_penalty", 0)
+        
+        # Handle response format if specified
+        response_format = None
+        if payload.get("response_format") == "json_object":
+            response_format = {"type": "json_object"}
+            
+        # Create completion
+        response = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            stream=stream,
+            top_p=top_p,
+            presence_penalty=presence_penalty,
+            frequency_penalty=frequency_penalty,
+            response_format=response_format
+        )
+        
+        return response
+    except Exception as e:
+        logger.error(f"OpenAI API error: {str(e)}")
+        raise e
+
+def call_huggingface_api(payload, api_key_override=None):
+    """Make a call to HuggingFace API with error handling"""
+    try:
+        if not HAS_HF:
+            raise ImportError("HuggingFace hub not installed")
+            
+        api_key = api_key_override if api_key_override else HF_API_KEY
+        
+        # Extract parameters from payload
+        model_id = payload.get("model", "mistralai/Mistral-7B-Instruct-v0.3")
+        messages = payload.get("messages", [])
+        temperature = payload.get("temperature", 0.7)
+        max_tokens = payload.get("max_tokens", 500)
+        
+        # Create a prompt from messages
+        prompt = ""
+        for msg in messages:
+            role = msg["role"].upper()
+            content = msg["content"]
+            
+            # Handle multimodal content
+            if isinstance(content, list):
+                text_parts = []
+                for item in content:
+                    if item["type"] == "text":
+                        text_parts.append(item["text"])
+                content = "\n".join(text_parts)
+                
+            prompt += f"{role}: {content}\n"
+            
+        prompt += "ASSISTANT: "
+        
+        # Create client with or without API key
+        client = InferenceClient(token=api_key) if api_key else InferenceClient()
+        
+        # Generate response
+        response = client.text_generation(
+            prompt,
+            model=model_id,
+            max_new_tokens=max_tokens,
+            temperature=temperature,
+            repetition_penalty=1.1
+        )
+        
+        return {"generated_text": str(response)}
+    except Exception as e:
+        logger.error(f"HuggingFace API error: {str(e)}")
+        raise e
+
+def call_groq_api(payload, api_key_override=None):
+    """Make a call to Groq API with error handling"""
+    try:
+        if not HAS_GROQ:
+            raise ImportError("Groq client not installed")
+            
+        api_key = api_key_override if api_key_override else GROQ_API_KEY
+        if not api_key:
+            raise ValueError("Groq API key is required")
+            
+        client = Groq(api_key=api_key)
+        
+        # Extract parameters from payload
+        model = payload.get("model", "llama-3.1-8b-instant")
+        messages = payload.get("messages", [])
+        temperature = payload.get("temperature", 0.7)
+        max_tokens = payload.get("max_tokens", 1000)
+        stream = payload.get("stream", False)
+        top_p = payload.get("top_p", 0.9)
+        
+        # Create completion
+        response = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            stream=stream,
+            top_p=top_p
+        )
+        
+        return response
+    except Exception as e:
+        logger.error(f"Groq API error: {str(e)}")
+        raise e
+
+def call_cohere_api(payload, api_key_override=None):
+    """Make a call to Cohere API with error handling"""
+    try:
+        if not HAS_COHERE:
+            raise ImportError("Cohere package not installed")
+            
+        api_key = api_key_override if api_key_override else COHERE_API_KEY
+        if not api_key:
+            raise ValueError("Cohere API key is required")
+            
+        client = cohere.Client(api_key=api_key)
+        
+        # Extract parameters from payload
+        model = payload.get("model", "command-r-plus")
+        messages = payload.get("messages", [])
+        temperature = payload.get("temperature", 0.7)
+        max_tokens = payload.get("max_tokens", 1000)
+        
+        # Format messages for Cohere
+        chat_history = []
+        user_message = ""
+        
+        for msg in messages:
+            if msg["role"] == "system":
+                # For system message, we'll prepend to the user's first message
+                system_content = msg["content"]
+                if isinstance(system_content, list):  # Handle multimodal content
+                    system_parts = []
+                    for item in system_content:
+                        if item["type"] == "text":
+                            system_parts.append(item["text"])
+                    system_content = "\n".join(system_parts)
+                user_message = f"System: {system_content}\n\n" + user_message
+            elif msg["role"] == "user":
+                content = msg["content"]
+                # Handle multimodal content
+                if isinstance(content, list):
+                    text_parts = []
+                    for item in content:
+                        if item["type"] == "text":
+                            text_parts.append(item["text"])
+                    content = "\n".join(text_parts)
+                user_message = content
+            elif msg["role"] == "assistant":
+                content = msg["content"]
+                if content:
+                    chat_history.append({"role": "ASSISTANT", "message": content})
+        
+        # Create chat completion
+        response = client.chat(
+            message=user_message,
+            chat_history=chat_history,
+            model=model,
+            temperature=temperature,
+            max_tokens=max_tokens
+        )
+        
+        return response
+    except Exception as e:
+        logger.error(f"Cohere API error: {str(e)}")
+        raise e
+
+def call_glhf_api(payload, api_key_override=None):
+    """Make a call to GLHF API with error handling"""
+    try:
+        if not HAS_OPENAI:
+            raise ImportError("OpenAI package not installed (required for GLHF API)")
+            
+        api_key = api_key_override if api_key_override else GLHF_API_KEY
+        if not api_key:
+            raise ValueError("GLHF API key is required")
+            
+        client = openai.OpenAI(
+            api_key=api_key,
+            base_url="https://glhf.chat/api/openai/v1"
+        )
+        
+        # Extract parameters from payload
+        model_name = payload.get("model", "mistralai/Mistral-7B-Instruct-v0.3")
+        # Add "hf:" prefix if not already there
+        if not model_name.startswith("hf:"):
+            model = f"hf:{model_name}"
+        else:
+            model = model_name
+            
+        messages = payload.get("messages", [])
+        temperature = payload.get("temperature", 0.7)
+        max_tokens = payload.get("max_tokens", 1000)
+        stream = payload.get("stream", False)
+        
+        # Create completion
+        response = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            stream=stream
+        )
+        
+        return response
+    except Exception as e:
+        logger.error(f"GLHF API error: {str(e)}")
+        raise e
+
+def extract_ai_response(result, provider):
+    """Extract AI response based on provider format"""
+    try:
+        if provider == "OpenRouter":
+            if isinstance(result, dict):
+                if "choices" in result and len(result["choices"]) > 0:
+                    if "message" in result["choices"][0]:
+                        message = result["choices"][0]["message"]
+                        if message.get("reasoning") and not message.get("content"):
+                            reasoning = message.get("reasoning")
+                            lines = reasoning.strip().split('\n')
+                            for line in lines:
+                                if line and not line.startswith('I should') and not line.startswith('Let me'):
+                                    return line.strip()
+                            for line in lines:
+                                if line.strip():
+                                    return line.strip()
+                        return message.get("content", "")
+                    elif "delta" in result["choices"][0]:
+                        return result["choices"][0]["delta"].get("content", "")
+                    
+        elif provider == "OpenAI":
+            if hasattr(result, "choices") and len(result.choices) > 0:
+                return result.choices[0].message.content
+                
+        elif provider == "HuggingFace":
+            return result.get("generated_text", "")
+                
+        elif provider == "Groq":
+            if hasattr(result, "choices") and len(result.choices) > 0:
+                return result.choices[0].message.content
+                
+        elif provider == "Cohere":
+            if hasattr(result, "text"):
+                return result.text
+                
+        elif provider == "GLHF":
+            if hasattr(result, "choices") and len(result.choices) > 0:
+                return result.choices[0].message.content
+            
+        logger.error(f"Unexpected response structure from {provider}: {result}")
+        return f"Error: Could not extract response from {provider} API result"
     except Exception as e:
         logger.error(f"Error extracting AI response: {str(e)}")
         return f"Error: {str(e)}"
 
-# streaming code:
-def streaming_handler(response, chatbot, message_idx, message):
+# ==========================================================
+# STREAMING HANDLERS
+# ==========================================================
+
+def openrouter_streaming_handler(response, chatbot, message_idx, message):
     try:
         # First add the user message if needed
         if len(chatbot) == message_idx:
-            chatbot.append({"role": "user", "content": message})
-            chatbot.append({"role": "assistant", "content": ""})
+            chatbot.append([message, ""])
             
         for line in response.iter_lines():
             if not line:
@@ -465,8 +915,8 @@ def streaming_handler(response, chatbot, message_idx, message):
                 if "choices" in chunk and len(chunk["choices"]) > 0:
                     delta = chunk["choices"][0].get("delta", {})
                     if "content" in delta and delta["content"]:
-                        # Update the last message content
-                        chatbot[-1]["content"] += delta["content"]
+                        # Update the current response
+                        chatbot[-1][1] += delta["content"]
                         yield chatbot
             except json.JSONDecodeError:
                 logger.error(f"Failed to parse JSON from chunk: {data}")
@@ -474,25 +924,82 @@ def streaming_handler(response, chatbot, message_idx, message):
         logger.error(f"Error in streaming handler: {str(e)}")
         # Add error message to the current response
         if len(chatbot) > message_idx:
-            chatbot[-1]["content"] += f"\n\nError during streaming: {str(e)}"
+            chatbot[-1][1] += f"\n\nError during streaming: {str(e)}"
             yield chatbot
 
-def ask_ai(message, history, model_choice, temperature, max_tokens, top_p, 
-           frequency_penalty, presence_penalty, repetition_penalty, top_k, 
-           min_p, seed, top_a, stream_output, response_format, 
-           images, documents, reasoning_effort, system_message, transforms):
-    """Redesigned AI query function with proper error handling for Gradio 4.44.1"""
+def openai_streaming_handler(response, chatbot, message_idx, message):
+    try:
+        # First add the user message if needed
+        if len(chatbot) == message_idx:
+            chatbot.append([message, ""])
+            
+        full_response = ""
+        for chunk in response:
+            if hasattr(chunk.choices[0].delta, "content") and chunk.choices[0].delta.content is not None:
+                content = chunk.choices[0].delta.content
+                full_response += content
+                chatbot[-1][1] = full_response
+                yield chatbot
+                
+    except Exception as e:
+        logger.error(f"Error in OpenAI streaming handler: {str(e)}")
+        # Add error message to the current response
+        chatbot[-1][1] += f"\n\nError during streaming: {str(e)}"
+        yield chatbot
+
+def groq_streaming_handler(response, chatbot, message_idx, message):
+    try:
+        # First add the user message if needed
+        if len(chatbot) == message_idx:
+            chatbot.append([message, ""])
+            
+        full_response = ""
+        for chunk in response:
+            if hasattr(chunk.choices[0].delta, "content") and chunk.choices[0].delta.content is not None:
+                content = chunk.choices[0].delta.content
+                full_response += content
+                chatbot[-1][1] = full_response
+                yield chatbot
+                
+    except Exception as e:
+        logger.error(f"Error in Groq streaming handler: {str(e)}")
+        # Add error message to the current response
+        chatbot[-1][1] += f"\n\nError during streaming: {str(e)}"
+        yield chatbot
+
+def glhf_streaming_handler(response, chatbot, message_idx, message):
+    try:
+        # First add the user message if needed
+        if len(chatbot) == message_idx:
+            chatbot.append([message, ""])
+            
+        full_response = ""
+        for chunk in response:
+            if hasattr(chunk.choices[0].delta, "content") and chunk.choices[0].delta.content is not None:
+                content = chunk.choices[0].delta.content
+                full_response += content
+                chatbot[-1][1] = full_response
+                yield chatbot
+                
+    except Exception as e:
+        logger.error(f"Error in GLHF streaming handler: {str(e)}")
+        # Add error message to the current response
+        chatbot[-1][1] += f"\n\nError during streaming: {str(e)}"
+        yield chatbot
+
+# ==========================================================
+# MAIN FUNCTION TO ASK AI
+# ==========================================================
+
+def ask_ai(message, history, provider, model_choice, temperature, max_tokens, top_p, 
+           frequency_penalty, presence_penalty, repetition_penalty, top_k, min_p, 
+           seed, top_a, stream_output, response_format, images, documents, 
+           reasoning_effort, system_message, transforms, api_key_override=None):
+    """Enhanced AI query function with support for multiple providers"""
     # Validate input
     if not message.strip() and not images and not documents:
         return history
     
-    # Get model information
-    model_id, context_size = get_model_info(model_choice)
-    if not model_id:
-        logger.error(f"Model not found: {model_choice}")
-        history.append((message, f"Error: Model '{model_choice}' not found"))
-        return history
-    
     # Copy history to new list to avoid modifying the original
     chat_history = list(history)
     
@@ -512,10 +1019,8 @@ def ask_ai(message, history, model_choice, temperature, max_tokens, top_p,
     # Add current message
     messages.append({"role": "user", "content": content})
     
-    # Build the payload with all parameters
-    payload = {
-        "model": model_id,
-        "messages": messages,
+    # Common parameters for all providers
+    common_params = {
         "temperature": temperature,
         "max_tokens": max_tokens,
         "top_p": top_p,
@@ -524,84 +1029,302 @@ def ask_ai(message, history, model_choice, temperature, max_tokens, top_p,
         "stream": stream_output
     }
     
-    # Add optional parameters if set
-    if repetition_penalty != 1.0:
-        payload["repetition_penalty"] = repetition_penalty
-    
-    if top_k > 0:
-        payload["top_k"] = top_k
-    
-    if min_p > 0:
-        payload["min_p"] = min_p
-    
-    if seed > 0:
-        payload["seed"] = seed
-    
-    if top_a > 0:
-        payload["top_a"] = top_a
-    
-    # Add response format if JSON is requested
-    if response_format == "json_object":
-        payload["response_format"] = {"type": "json_object"}
-    
-    # Add reasoning if selected
-    if reasoning_effort != "none":
-        payload["reasoning"] = {
-            "effort": reasoning_effort
-        }
-    
-    # Add transforms if selected
-    if transforms:
-        payload["transforms"] = transforms
-    
-    # Log the request
-    logger.info(f"Sending request to model: {model_id}")
-    logger.info(f"Request payload: {json.dumps(payload, default=str)}")
-    
     try:
-        # Call OpenRouter API
-        response = call_openrouter_api(payload)
-        logger.info(f"Response status: {response.status_code}")
-        
-        # Handle streaming response
-        if stream_output and response.status_code == 200:
-            # Add empty response slot to history
-            chat_history.append([message, ""])
+        # Process based on provider
+        if provider == "OpenRouter":
+            # Get model ID from registry
+            model_id, _ = get_model_info(provider, model_choice)
+            if not model_id:
+                error_message = f"Error: Model '{model_choice}' not found in OpenRouter"
+                chat_history.append([message, error_message])
+                return chat_history
+                
+            # Build OpenRouter payload
+            payload = {
+                "model": model_id,
+                "messages": messages,
+                **common_params
+            }
             
-            # Set up generator for streaming updates
-            def streaming_generator():
-                for updated_history in streaming_handler(response, chat_history, len(chat_history) - 1, message):
-                    yield updated_history
+            # Add optional parameters if set
+            if repetition_penalty != 1.0:
+                payload["repetition_penalty"] = repetition_penalty
             
-            return streaming_generator()
-        
-        # Handle normal response
-        elif response.status_code == 200:
-            result = response.json()
-            logger.info(f"Response content: {result}")
+            if top_k > 0:
+                payload["top_k"] = top_k
             
-            # Extract AI response
-            ai_response = extract_ai_response(result)
+            if min_p > 0:
+                payload["min_p"] = min_p
             
-            # Log token usage if available
-            if "usage" in result:
-                logger.info(f"Token usage: {result['usage']}")
+            if seed > 0:
+                payload["seed"] = seed
+            
+            if top_a > 0:
+                payload["top_a"] = top_a
+            
+            # Add response format if JSON is requested
+            if response_format == "json_object":
+                payload["response_format"] = {"type": "json_object"}
+            
+            # Add reasoning if selected
+            if reasoning_effort != "none":
+                payload["reasoning"] = {
+                    "effort": reasoning_effort
+                }
+            
+            # Add transforms if selected
+            if transforms:
+                payload["transforms"] = transforms
+                
+            # Call OpenRouter API
+            logger.info(f"Sending request to OpenRouter model: {model_id}")
+            
+            response = call_openrouter_api(payload, api_key_override)
+            
+            # Handle streaming response
+            if stream_output and response.status_code == 200:
+                # Add empty response slot to history
+                chat_history.append([message, ""])
+                
+                # Set up generator for streaming updates
+                def streaming_generator():
+                    for updated_history in openrouter_streaming_handler(response, chat_history, len(chat_history) - 1, message):
+                        yield updated_history
+                
+                return streaming_generator()
+            
+            # Handle normal response
+            elif response.status_code == 200:
+                result = response.json()
+                logger.info(f"Response content: {result}")
+                
+                # Extract AI response
+                ai_response = extract_ai_response(result, provider)
+                
+                # Add response to history
+                chat_history.append([message, ai_response])
+                return chat_history
+            
+            # Handle error response
+            else:
+                error_message = f"Error: Status code {response.status_code}"
+                try:
+                    response_data = response.json()
+                    error_message += f"\n\nDetails: {json.dumps(response_data, indent=2)}"
+                except:
+                    error_message += f"\n\nResponse: {response.text}"
+                
+                logger.error(error_message)
+                chat_history.append([message, error_message])
+                return chat_history
+                
+        elif provider == "OpenAI":
+            # Get model ID from registry
+            model_id, _ = get_model_info(provider, model_choice)
+            if not model_id:
+                error_message = f"Error: Model '{model_choice}' not found in OpenAI"
+                chat_history.append([message, error_message])
+                return chat_history
+                
+            # Build OpenAI payload
+            payload = {
+                "model": model_id,
+                "messages": messages,
+                **common_params
+            }
+            
+            # Add response format if JSON is requested
+            if response_format == "json_object":
+                payload["response_format"] = {"type": "json_object"}
+            
+            # Call OpenAI API
+            logger.info(f"Sending request to OpenAI model: {model_id}")
+            
+            try:
+                response = call_openai_api(payload, api_key_override)
+                
+                # Handle streaming response
+                if stream_output:
+                    # Add empty response slot to history
+                    chat_history.append([message, ""])
+                    
+                    # Set up generator for streaming updates
+                    def streaming_generator():
+                        for updated_history in openai_streaming_handler(response, chat_history, len(chat_history) - 1, message):
+                            yield updated_history
+                    
+                    return streaming_generator()
+                
+                # Handle normal response
+                else:
+                    ai_response = extract_ai_response(response, provider)
+                    chat_history.append([message, ai_response])
+                    return chat_history
+            except Exception as e:
+                error_message = f"OpenAI API Error: {str(e)}"
+                logger.error(error_message)
+                chat_history.append([message, error_message])
+                return chat_history
+                
+        elif provider == "HuggingFace":
+            # Get model ID from registry
+            model_id, _ = get_model_info(provider, model_choice)
+            if not model_id:
+                error_message = f"Error: Model '{model_choice}' not found in HuggingFace"
+                chat_history.append([message, error_message])
+                return chat_history
+                
+            # Build HuggingFace payload
+            payload = {
+                "model": model_id,
+                "messages": messages,
+                "temperature": temperature,
+                "max_tokens": max_tokens
+            }
+            
+            # Call HuggingFace API
+            logger.info(f"Sending request to HuggingFace model: {model_id}")
             
-            # Add response to history
-            chat_history.append({"role": "user", "content": message})
-            chat_history.append({"role": "assistant", "content": ai_response})
-            return chat_history
-        
-        # Handle error response
-        else:
-            error_message = f"Error: Status code {response.status_code}"
             try:
-                response_data = response.json()
-                error_message += f"\n\nDetails: {json.dumps(response_data, indent=2)}"
-            except:
-                error_message += f"\n\nResponse: {response.text}"
+                response = call_huggingface_api(payload, api_key_override)
+                
+                # Extract response
+                ai_response = extract_ai_response(response, provider)
+                chat_history.append([message, ai_response])
+                return chat_history
+            except Exception as e:
+                error_message = f"HuggingFace API Error: {str(e)}"
+                logger.error(error_message)
+                chat_history.append([message, error_message])
+                return chat_history
+                
+        elif provider == "Groq":
+            # Get model ID from registry
+            model_id, _ = get_model_info(provider, model_choice)
+            if not model_id:
+                error_message = f"Error: Model '{model_choice}' not found in Groq"
+                chat_history.append([message, error_message])
+                return chat_history
+                
+            # Build Groq payload
+            payload = {
+                "model": model_id,
+                "messages": messages,
+                "temperature": temperature,
+                "max_tokens": max_tokens,
+                "top_p": top_p,
+                "stream": stream_output
+            }
+            
+            # Call Groq API
+            logger.info(f"Sending request to Groq model: {model_id}")
+            
+            try:
+                response = call_groq_api(payload, api_key_override)
+                
+                # Handle streaming response
+                if stream_output:
+                    # Add empty response slot to history
+                    chat_history.append([message, ""])
+                    
+                    # Set up generator for streaming updates
+                    def streaming_generator():
+                        for updated_history in groq_streaming_handler(response, chat_history, len(chat_history) - 1, message):
+                            yield updated_history
+                    
+                    return streaming_generator()
+                
+                # Handle normal response
+                else:
+                    ai_response = extract_ai_response(response, provider)
+                    chat_history.append([message, ai_response])
+                    return chat_history
+            except Exception as e:
+                error_message = f"Groq API Error: {str(e)}"
+                logger.error(error_message)
+                chat_history.append([message, error_message])
+                return chat_history
+                
+        elif provider == "Cohere":
+            # Get model ID from registry
+            model_id, _ = get_model_info(provider, model_choice)
+            if not model_id:
+                error_message = f"Error: Model '{model_choice}' not found in Cohere"
+                chat_history.append([message, error_message])
+                return chat_history
+                
+            # Build Cohere payload (doesn't support streaming the same way)
+            payload = {
+                "model": model_id,
+                "messages": messages,
+                "temperature": temperature,
+                "max_tokens": max_tokens
+            }
+            
+            # Call Cohere API
+            logger.info(f"Sending request to Cohere model: {model_id}")
+            
+            try:
+                response = call_cohere_api(payload, api_key_override)
+                
+                # Extract response
+                ai_response = extract_ai_response(response, provider)
+                chat_history.append([message, ai_response])
+                return chat_history
+            except Exception as e:
+                error_message = f"Cohere API Error: {str(e)}"
+                logger.error(error_message)
+                chat_history.append([message, error_message])
+                return chat_history
+                
+        elif provider == "GLHF":
+            # Get model ID from registry
+            model_id, _ = get_model_info(provider, model_choice)
+            if not model_id:
+                error_message = f"Error: Model '{model_choice}' not found in GLHF"
+                chat_history.append([message, error_message])
+                return chat_history
+            
+            # Build GLHF payload
+            payload = {
+                "model": model_id,  # The hf: prefix will be added in the API call
+                "messages": messages,
+                "temperature": temperature,
+                "max_tokens": max_tokens,
+                "stream": stream_output
+            }
             
-            logger.error(error_message)
+            # Call GLHF API
+            logger.info(f"Sending request to GLHF model: {model_id}")
+            
+            try:
+                response = call_glhf_api(payload, api_key_override)
+                
+                # Handle streaming response
+                if stream_output:
+                    # Add empty response slot to history
+                    chat_history.append([message, ""])
+                    
+                    # Set up generator for streaming updates
+                    def streaming_generator():
+                        for updated_history in glhf_streaming_handler(response, chat_history, len(chat_history) - 1, message):
+                            yield updated_history
+                    
+                    return streaming_generator()
+                
+                # Handle normal response
+                else:
+                    ai_response = extract_ai_response(response, provider)
+                    chat_history.append([message, ai_response])
+                    return chat_history
+            except Exception as e:
+                error_message = f"GLHF API Error: {str(e)}"
+                logger.error(error_message)
+                chat_history.append([message, error_message])
+                return chat_history
+            
+        else:
+            error_message = f"Error: Unsupported provider '{provider}'"
             chat_history.append([message, error_message])
             return chat_history
             
@@ -615,10 +1338,14 @@ def clear_chat():
     """Reset all inputs"""
     return [], "", [], [], 0.7, 1000, 0.8, 0.0, 0.0, 1.0, 40, 0.1, 0, 0.0, False, "default", "none", "", []
 
+# ==========================================================
+# UI CREATION
+# ==========================================================
+
 def create_app():
-    """Create the Gradio application with improved UI and response handling"""
+    """Create the Multi-Provider CrispChat Gradio application"""
     with gr.Blocks(
-        title="CrispChat - AI Assistant",
+        title="Multi-Provider CrispChat",
         css="""
             .context-size { 
                 font-size: 0.9em;
@@ -643,30 +1370,30 @@ def create_app():
                 font-size: 0.8em;
                 margin-left: 5px;
             }
+            .provider-selection {
+                margin-bottom: 10px;
+                padding: 10px;
+                border-radius: 5px;
+                background-color: #f5f5f5;
+            }
         """
     ) as demo:
         gr.Markdown("""
-        # CrispChat AI Assistant
+        # 🤖 Multi-Provider CrispChat
         
-        Chat with various AI models from OpenRouter with support for images and documents.
+        Chat with AI models from multiple providers: OpenRouter, OpenAI, HuggingFace, Groq, Cohere, and GLHF.
         """)
         
         with gr.Row():
             with gr.Column(scale=2):
-                # Chatbot interface - properly configured for Gradio 4.44.1
+                # Chatbot interface
                 chatbot = gr.Chatbot(
                     height=500, 
                     show_copy_button=True, 
                     show_label=False,
                     avatar_images=(None, "https://upload.wikimedia.org/wikipedia/commons/0/04/ChatGPT_logo.svg"),
-                    type="messages",  # Explicitly set the type to messages
-                    elem_id="chat-window"  # Add elem_id for debugging
-                )
-                
-                # Debug output for development
-                debug_output = gr.JSON(
-                    label="Debug Output (Hidden in Production)",
-                    visible=False
+                    type="messages",
+                    elem_id="chat-window"
                 )
                 
                 with gr.Row():
@@ -674,7 +1401,7 @@ def create_app():
                         placeholder="Type your message here...",
                         label="Message",
                         lines=2,
-                        elem_id="message-input",  # Add elem_id for debugging
+                        elem_id="message-input",
                         scale=4
                     )
                 
@@ -709,6 +1436,23 @@ def create_app():
                         )
             
             with gr.Column(scale=1):
+                with gr.Group(elem_classes="provider-selection"):
+                    gr.Markdown("### Provider Selection")
+                    
+                    # Provider selection
+                    provider_choice = gr.Radio(
+                        choices=["OpenRouter", "OpenAI", "HuggingFace", "Groq", "Cohere", "GLHF"],
+                        value="OpenRouter",
+                        label="AI Provider"
+                    )
+                    
+                    # API key input
+                    api_key_override = gr.Textbox(
+                        placeholder="Override API key (leave empty to use environment variable)",
+                        label="API Key Override",
+                        type="password"
+                    )
+                
                 with gr.Group():
                     gr.Markdown("### Model Selection")
                     
@@ -719,39 +1463,61 @@ def create_app():
                             show_label=False
                         )
                     
-                    with gr.Row(elem_classes="model-selection-row"):
-                        
-                        # Main model dropdown
-                        model_choice = gr.Dropdown(
-                            [model[0] for model in ALL_MODELS],
-                            value=ALL_MODELS[0][0],
-                            label="Model",
-                            elem_id="model-choice",
-                            allow_custom_value=True
-                        )
-
-                        context_display = gr.Textbox(
-                            value=update_context_display(ALL_MODELS[0][0]),
-                            label="Context",
-                            interactive=False,
-                            elem_classes="context-size"
-                        )
+                    # Provider-specific model dropdowns
+                    openrouter_model = gr.Dropdown(
+                        choices=[model[0] for model in OPENROUTER_ALL_MODELS],
+                        value=OPENROUTER_ALL_MODELS[0][0] if OPENROUTER_ALL_MODELS else None,
+                        label="OpenRouter Model",
+                        elem_id="openrouter-model-choice",
+                        visible=True
+                    )
                     
-                    # Model category selection
-                    with gr.Accordion("Browse by Category", open=False):
-                        model_categories = gr.Dropdown(
-                            [model["category"] for model in MODELS],
-                            label="Categories",
-                            value=MODELS[0]["category"]
-                        )
-                        
-                        # Models in category dropdown
-                        category_models = gr.Dropdown(
-                            get_models_for_category(MODELS[0]["category"]),
-                            label="Models in Category",
-                            value=get_models_for_category(MODELS[0]["category"])[0] if get_models_for_category(MODELS[0]["category"]) else None,
-                            allow_custom_value=True
-                        )
+                    openai_model = gr.Dropdown(
+                        choices=list(OPENAI_MODELS.keys()),
+                        value="gpt-3.5-turbo" if "gpt-3.5-turbo" in OPENAI_MODELS else None,
+                        label="OpenAI Model",
+                        elem_id="openai-model-choice",
+                        visible=False
+                    )
+                    
+                    hf_model = gr.Dropdown(
+                        choices=list(HUGGINGFACE_MODELS.keys()),
+                        value="mistralai/Mistral-7B-Instruct-v0.3" if "mistralai/Mistral-7B-Instruct-v0.3" in HUGGINGFACE_MODELS else None,
+                        label="HuggingFace Model",
+                        elem_id="hf-model-choice",
+                        visible=False
+                    )
+                    
+                    groq_model = gr.Dropdown(
+                        choices=list(GROQ_MODELS.keys()),
+                        value="llama-3.1-8b-instant" if "llama-3.1-8b-instant" in GROQ_MODELS else None,
+                        label="Groq Model",
+                        elem_id="groq-model-choice",
+                        visible=False
+                    )
+                    
+                    cohere_model = gr.Dropdown(
+                        choices=list(COHERE_MODELS.keys()),
+                        value="command-r-plus" if "command-r-plus" in COHERE_MODELS else None,
+                        label="Cohere Model",
+                        elem_id="cohere-model-choice",
+                        visible=False
+                    )
+                    
+                    glhf_model = gr.Dropdown(
+                        choices=list(GLHF_MODELS.keys()),
+                        value="mistralai/Mistral-7B-Instruct-v0.3" if "mistralai/Mistral-7B-Instruct-v0.3" in GLHF_MODELS else None,
+                        label="GLHF Model",
+                        elem_id="glhf-model-choice",
+                        visible=False
+                    )
+                    
+                    context_display = gr.Textbox(
+                        value=update_context_display("OpenRouter", OPENROUTER_ALL_MODELS[0][0]),
+                        label="Context Size",
+                        interactive=False,
+                        elem_classes="context-size"
+                    )
                 
                 with gr.Accordion("Generation Parameters", open=False):
                     with gr.Group(elem_classes="parameter-grid"):
@@ -798,7 +1564,7 @@ def create_app():
                         reasoning_effort = gr.Radio(
                             ["none", "low", "medium", "high"],
                             value="none",
-                            label="Reasoning Effort"
+                            label="Reasoning Effort (OpenRouter)"
                         )
                 
                 with gr.Accordion("Advanced Options", open=False):
@@ -857,7 +1623,7 @@ def create_app():
                         
                         gr.Markdown("""
                         * **json_object**: Forces the model to respond with valid JSON only.
-                        * Only available on certain models - check model support on OpenRouter.
+                        * Only available on certain models - check model support.
                         """)
                 
                 # Custom instructing options
@@ -882,7 +1648,7 @@ def create_app():
                 # Add a model information section
                 with gr.Accordion("About Selected Model", open=False):
                     model_info_display = gr.HTML(
-                        value=update_model_info(ALL_MODELS[0][0])
+                        value=update_model_info("OpenRouter", OPENROUTER_ALL_MODELS[0][0])
                     )
         
         # Add usage instructions
@@ -890,88 +1656,270 @@ def create_app():
             gr.Markdown("""
             ## Basic Usage
             1. Type your message in the input box
-            2. Select a model from the dropdown
+            2. Select a provider and model
             3. Click "Send" or press Enter
             
             ## Working with Files
             - **Images**: Upload images to use with vision-capable models
             - **Documents**: Upload PDF, Markdown, or text files to analyze their content
             
+            ## Provider Information
+            - **OpenRouter**: Free access to various models with context window sizes up to 2M tokens
+            - **OpenAI**: Requires an API key, includes GPT-3.5 and GPT-4 models
+            - **HuggingFace**: Direct access to open models, some models require API key
+            - **Groq**: High-performance inference, requires API key
+            - **Cohere**: Specialized in language understanding, requires API key
+            - **GLHF**: Access to HuggingFace models, requires API key
+            
             ## Advanced Parameters
             - **Temperature**: Controls randomness (higher = more creative, lower = more deterministic)
             - **Max Tokens**: Maximum length of the response
             - **Top P**: Nucleus sampling threshold (higher = consider more tokens)
-            - **Reasoning Effort**: Some models can show their reasoning process
-            
-            ## Tips
-            - For code generation, use models like Qwen Coder
-            - For visual tasks, choose vision-capable models
-            - For long context, check the context window size next to the model name
+            - **Reasoning Effort**: Some models can show their reasoning process (OpenRouter only)
             """)
         
         # Add a footer with version info
         footer_md = gr.Markdown("""
         ---
-        ### CrispChat v1.1
-        Built with ❤️ using Gradio 4.44.1 and OpenRouter API | Context sizes shown next to model names
+        ### Multi-Provider CrispChat v1.0
+        Built with ❤️ using Gradio and multiple AI provider APIs | Context sizes shown next to model names
         """)
         
-        # Define a test function for debugging
-        def test_chatbot(test_message):
-            """Simple test function to verify chatbot updates work"""
-            logger.info(f"Test function called with: {test_message}")
-            return [[test_message, "This is a test response to verify the chatbot is working"]]
+        # Define event handlers
+        def toggle_model_dropdowns(provider):
+            """Show/hide model dropdowns based on provider selection"""
+            return {
+                openrouter_model: gr.update(visible=(provider == "OpenRouter")),
+                openai_model: gr.update(visible=(provider == "OpenAI")),
+                hf_model: gr.update(visible=(provider == "HuggingFace")),
+                groq_model: gr.update(visible=(provider == "Groq")),
+                cohere_model: gr.update(visible=(provider == "Cohere")),
+                glhf_model: gr.update(visible=(provider == "GLHF"))
+            }
+            
+        def update_context_for_provider(provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, glhf_model):
+            """Update context display based on selected provider and model"""
+            if provider == "OpenRouter":
+                return update_context_display(provider, openrouter_model)
+            elif provider == "OpenAI":
+                return update_context_display(provider, openai_model)
+            elif provider == "HuggingFace":
+                return update_context_display(provider, hf_model)
+            elif provider == "Groq":
+                return update_context_display(provider, groq_model)
+            elif provider == "Cohere":
+                return update_context_display(provider, cohere_model)
+            elif provider == "GLHF":
+                return update_context_display(provider, glhf_model)
+            return "Unknown"
+            
+        def update_model_info_for_provider(provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, glhf_model):
+            """Update model info based on selected provider and model"""
+            if provider == "OpenRouter":
+                return update_model_info(provider, openrouter_model)
+            elif provider == "OpenAI":
+                return update_model_info(provider, openai_model)
+            elif provider == "HuggingFace":
+                return update_model_info(provider, hf_model)
+            elif provider == "Groq":
+                return update_model_info(provider, groq_model)
+            elif provider == "Cohere":
+                return update_model_info(provider, cohere_model)
+            elif provider == "GLHF":
+                return update_model_info(provider, glhf_model)
+            return "<p>Model information not available</p>"
+            
+        def filter_provider_models(provider, search_term):
+            """Filter models for the selected provider"""
+            if provider == "OpenRouter":
+                all_models = [model[0] for model in OPENROUTER_ALL_MODELS]
+            elif provider == "OpenAI":
+                all_models = list(OPENAI_MODELS.keys())
+            elif provider == "HuggingFace":
+                all_models = list(HUGGINGFACE_MODELS.keys())
+            elif provider == "Groq":
+                all_models = list(GROQ_MODELS.keys())
+            elif provider == "Cohere":
+                all_models = list(COHERE_MODELS.keys())
+            elif provider == "GLHF":
+                all_models = list(GLHF_MODELS.keys())
+            else:
+                return [], None
+                
+            if not search_term:
+                return all_models, all_models[0] if all_models else None
+                
+            filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
+            
+            if filtered_models:
+                return filtered_models, filtered_models[0]
+            else:
+                return all_models, all_models[0] if all_models else None
+            
+        def refresh_groq_models_list():
+            """Refresh the list of Groq models"""
+            global GROQ_MODELS
+            GROQ_MODELS = fetch_groq_models()
+            return gr.update(choices=list(GROQ_MODELS.keys()))
+            
+        def get_current_model(provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, glhf_model):
+            """Get the currently selected model based on provider"""
+            if provider == "OpenRouter":
+                return openrouter_model
+            elif provider == "OpenAI":
+                return openai_model
+            elif provider == "HuggingFace":
+                return hf_model
+            elif provider == "Groq":
+                return groq_model
+            elif provider == "Cohere":
+                return cohere_model
+            elif provider == "GLHF":
+                return glhf_model
+            return None
         
-        # Connect model search to dropdown filter
+        # Process uploaded images
+        image_upload_btn.upload(
+            fn=lambda files: files,
+            inputs=image_upload_btn,
+            outputs=images
+        )
+        
+        # Set up provider selection event
+        provider_choice.change(
+            fn=toggle_model_dropdowns,
+            inputs=provider_choice,
+            outputs=[openrouter_model, openai_model, hf_model, groq_model, cohere_model, glhf_model]
+        ).then(
+            fn=update_context_for_provider,
+            inputs=[provider_choice, openrouter_model, openai_model, hf_model, groq_model, cohere_model, glhf_model],
+            outputs=context_display
+        ).then(
+            fn=update_model_info_for_provider,
+            inputs=[provider_choice, openrouter_model, openai_model, hf_model, groq_model, cohere_model, glhf_model],
+            outputs=model_info_display
+        )
+        
+        # Set up model search event
         model_search.change(
-            fn=filter_models,
-            inputs=model_search,
-            outputs=[model_choice, model_choice]
+            fn=lambda provider, search: filter_provider_models(provider, search),
+            inputs=[provider_choice, model_search],
+            outputs=[
+                gr.update(choices=None, value=None), 
+                gr.update(choices=None, value=None)
+            ]
         )
         
-        # Update context display when model changes
-        model_choice.change(
-            fn=update_context_display,
-            inputs=model_choice,
+        # Set up model change events
+        openrouter_model.change(
+            fn=lambda model: update_context_display("OpenRouter", model),
+            inputs=openrouter_model,
             outputs=context_display
+        ).then(
+            fn=lambda model: update_model_info("OpenRouter", model),
+            inputs=openrouter_model,
+            outputs=model_info_display
         )
         
-        # Update model info when model changes
-        model_choice.change(
-            fn=update_model_info,
-            inputs=model_choice,
+        openai_model.change(
+            fn=lambda model: update_context_display("OpenAI", model),
+            inputs=openai_model,
+            outputs=context_display
+        ).then(
+            fn=lambda model: update_model_info("OpenAI", model),
+            inputs=openai_model,
             outputs=model_info_display
         )
         
-        # Update model list when category changes
-        model_categories.change(
-        fn=update_category_models_ui,
-        inputs=model_categories,
-        outputs=category_models
-    )
+        hf_model.change(
+            fn=lambda model: update_context_display("HuggingFace", model),
+            inputs=hf_model,
+            outputs=context_display
+        ).then(
+            fn=lambda model: update_model_info("HuggingFace", model),
+            inputs=hf_model,
+            outputs=model_info_display
+        )
         
-        # Update main model choice when category model is selected
-        category_models.change(
-            fn=lambda x: x,
-            inputs=category_models,
-            outputs=model_choice
+        groq_model.change(
+            fn=lambda model: update_context_display("Groq", model),
+            inputs=groq_model,
+            outputs=context_display
+        ).then(
+            fn=lambda model: update_model_info("Groq", model),
+            inputs=groq_model,
+            outputs=model_info_display
         )
-
-        # Process uploaded images
-        image_upload_btn.upload(
-            fn=lambda files: files,
-            inputs=image_upload_btn,
-            outputs=images
+        
+        cohere_model.change(
+            fn=lambda model: update_context_display("Cohere", model),
+            inputs=cohere_model,
+            outputs=context_display
+        ).then(
+            fn=lambda model: update_model_info("Cohere", model),
+            inputs=cohere_model,
+            outputs=model_info_display
+        )
+        
+        glhf_model.change(
+            fn=lambda model: update_context_display("GLHF", model),
+            inputs=glhf_model,
+            outputs=context_display
+        ).then(
+            fn=lambda model: update_model_info("GLHF", model),
+            inputs=glhf_model,
+            outputs=model_info_display
         )
         
-        # Set up events for the submit button
+        # Set up submission event
+        def submit_message(message, history, provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, glhf_model, 
+                          temperature, max_tokens, top_p, frequency_penalty, presence_penalty, repetition_penalty, 
+                          top_k, min_p, seed, top_a, stream_output, response_format,
+                          images, documents, reasoning_effort, system_message, transforms, api_key_override):
+            """Submit message to selected provider and model"""
+            # Get the currently selected model
+            model_choice = get_current_model(provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, glhf_model)
+            
+            # Check if model is selected
+            if not model_choice:
+                history.append([message, f"Error: No model selected for provider {provider}"])
+                return history
+                
+            # Call the ask_ai function with the appropriate parameters
+            return ask_ai(
+                message=message,
+                history=history,
+                provider=provider,
+                model_choice=model_choice,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                top_p=top_p,
+                frequency_penalty=frequency_penalty,
+                presence_penalty=presence_penalty,
+                repetition_penalty=repetition_penalty,
+                top_k=top_k,
+                min_p=min_p,
+                seed=seed,
+                top_a=top_a,
+                stream_output=stream_output,
+                response_format=response_format,
+                images=images,
+                documents=documents,
+                reasoning_effort=reasoning_effort,
+                system_message=system_message,
+                transforms=transforms,
+                api_key_override=api_key_override
+            )
+        
+        # Submit button click event
         submit_btn.click(
-            fn=ask_ai,
+            fn=submit_message,
             inputs=[
-                message, chatbot, model_choice, temperature, max_tokens, 
-                top_p, frequency_penalty, presence_penalty, repetition_penalty, 
+                message, chatbot, provider_choice, 
+                openrouter_model, openai_model, hf_model, groq_model, cohere_model, glhf_model,
+                temperature, max_tokens, top_p, frequency_penalty, presence_penalty, repetition_penalty, 
                 top_k, min_p, seed, top_a, stream_output, response_format,
-                images, documents, reasoning_effort, system_message, transforms
+                images, documents, reasoning_effort, system_message, transforms, api_key_override
             ],
             outputs=chatbot,
             show_progress="minimal",
@@ -981,14 +1929,15 @@ def create_app():
             outputs=message
         )
         
-        # Set up events for message submission (pressing Enter)
+        # Also submit on Enter key
         message.submit(
-            fn=ask_ai,
+            fn=submit_message,
             inputs=[
-                message, chatbot, model_choice, temperature, max_tokens, 
-                top_p, frequency_penalty, presence_penalty, repetition_penalty, 
+                message, chatbot, provider_choice, 
+                openrouter_model, openai_model, hf_model, groq_model, cohere_model, glhf_model,
+                temperature, max_tokens, top_p, frequency_penalty, presence_penalty, repetition_penalty, 
                 top_k, min_p, seed, top_a, stream_output, response_format,
-                images, documents, reasoning_effort, system_message, transforms
+                images, documents, reasoning_effort, system_message, transforms, api_key_override
             ],
             outputs=chatbot,
             show_progress="minimal",
@@ -998,7 +1947,7 @@ def create_app():
             outputs=message
         )
         
-        # Set up events for the clear button
+        # Clear chat button
         clear_btn.click(
             fn=clear_chat,
             inputs=[],
@@ -1010,28 +1959,14 @@ def create_app():
             ]
         )
         
-        # Debug button (hidden in production)
-        debug_btn = gr.Button("Debug Chatbot", visible=False)
-        debug_btn.click(
-            fn=test_chatbot,
-            inputs=[message],
-            outputs=[chatbot]
-        )
-        
-        # Enable debugging for key components
-        # gr.debug(chatbot)
-        
         return demo
 
-
-
-
 # Launch the app
 if __name__ == "__main__":
-    # Check API key before starting
+    # Check API keys before starting
     if not OPENROUTER_API_KEY:
         logger.warning("WARNING: OPENROUTER_API_KEY environment variable is not set")
-        print("WARNING: OpenRouter API key not found. Set OPENROUTER_API_KEY environment variable.")
+        print("WARNING: OpenRouter API key not found. Set OPENROUTER_API_KEY environment variable to access free models.")
     
     demo = create_app()
     demo.launch(