Update app.py

app.py

@@ -71,8 +71,13 @@ 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", "")
+TOGETHER_API_KEY = os.environ.get("TOGETHER_API_KEY", "")
+GOOGLEAI_API_KEY = os.environ.get("GOOGLEAI_API_KEY", "")
+
+# Print application startup message with timestamp
+current_time = time.strftime("%Y-%m-%d %H:%M:%S")
+print(f"===== Application Startup at {current_time} =====\n")
 
 # ==========================================================
 # MODEL DEFINITIONS
@@ -83,7 +88,7 @@ HF_API_KEY = os.environ.get("HF_API_KEY", "")
 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),
@@ -164,7 +169,7 @@ OPENROUTER_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),
@@ -193,6 +198,31 @@ for category in OPENROUTER_MODELS:
         if model not in OPENROUTER_ALL_MODELS:  # Avoid duplicates
             OPENROUTER_ALL_MODELS.append(model)
 
+# VISION MODELS - For tracking which models support images
+VISION_MODELS = {
+    "OpenRouter": [model[0] for model in OPENROUTER_MODELS[-1]["models"]],  # Last category is Vision Models
+    "OpenAI": [
+        "gpt-4-vision-preview", "gpt-4o", "gpt-4o-mini", "gpt-4-turbo", 
+        "gpt-4-turbo-preview", "gpt-4-0125-preview", "gpt-4-1106-preview",
+        "o1-preview", "o1-mini"
+    ],
+    "HuggingFace": [
+        "Qwen/Qwen2.5-VL-7B-Instruct", "Qwen/qwen2.5-vl-3b-instruct", 
+        "Qwen/qwen2.5-vl-32b-instruct", "Qwen/qwen2.5-vl-72b-instruct"
+    ],
+    "Groq": ["llama-3.2-11b-vision", "llama-3.2-90b-vision"],
+    "Together": ["Llama-3.2-11B-Vision-Instruct", "Llama-3.2-90B-Vision-Instruct"],
+    "OVH": ["llava-next-mistral-7b", "qwen2.5-vl-72b-instruct"],
+    "Cerebras": [],
+    "GoogleAI": ["gemini-1.5-pro", "gemini-1.0-pro", "gemini-1.5-flash", "gemini-2.0-pro", "gemini-2.5-pro"]
+}
+
+# Add all models with "vl", "vision", "visual" in their name to HF vision models
+for model_name in list(HUGGINGFACE_MODELS.keys()):
+    if any(x in model_name.lower() for x in ["vl", "vision", "visual", "llava"]):
+        if model_name not in VISION_MODELS["HuggingFace"]:
+            VISION_MODELS["HuggingFace"].append(model_name)
+
 # OPENAI MODELS
 OPENAI_MODELS = {
     "gpt-3.5-turbo": 16385,
@@ -211,13 +241,8 @@ OPENAI_MODELS = {
     "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,
@@ -233,7 +258,6 @@ HUGGINGFACE_MODELS = {
     "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,
@@ -245,6 +269,10 @@ HUGGINGFACE_MODELS = {
     "Qwen/Qwen2.5-7B-Instruct": 131072,
     "tiiuae/falcon-7b-instruct": 8192,
     "Qwen/QwQ-32B-preview": 32768,
+    "Qwen/Qwen2.5-VL-7B-Instruct": 64000,
+    "Qwen/qwen2.5-vl-3b-instruct": 64000,
+    "Qwen/qwen2.5-vl-32b-instruct": 8192,
+    "Qwen/qwen2.5-vl-72b-instruct": 131072,
 }
 
 # GROQ MODELS - We'll populate this dynamically
@@ -264,6 +292,8 @@ DEFAULT_GROQ_MODELS = {
     "llama-3.1-70b-specdec": 131072,
     "llama-3.2-1b-preview": 131072,
     "llama-3.2-3b-preview": 131072,
+    "llama-3.2-11b-vision": 131072,
+    "llama-3.2-90b-vision": 131072,
 }
 
 # COHERE MODELS
@@ -282,18 +312,44 @@ COHERE_MODELS = {
     "c4ai-aya-expanse-32b": 131072,
 }
 
-# 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,
+# TOGETHER MODELS
+TOGETHER_MODELS = {
+    "meta-llama/Llama-3.1-70B-Instruct": 131072,
+    "meta-llama/Llama-3.1-8B-Instruct": 131072,
+    "meta-llama/Llama-3.3-70B-Instruct": 131072,
+    "deepseek-ai/deepseek-r1-distill-llama-70b": 8192,
+    "meta-llama/Llama-3.2-11B-Vision-Instruct": 131072,
+    "meta-llama/Llama-3.2-90B-Vision-Instruct": 131072,
+}
+
+# OVH MODELS - OVH AI Endpoints (free beta)
+OVH_MODELS = {
+    "ovh/codestral-mamba-7b-v0.1": 131072,
+    "ovh/deepseek-r1-distill-llama-70b": 8192,
+    "ovh/llama-3.1-70b-instruct": 131072,
+    "ovh/llama-3.1-8b-instruct": 131072,
+    "ovh/llama-3.3-70b-instruct": 131072,
+    "ovh/llava-next-mistral-7b": 8192,
+    "ovh/mistral-7b-instruct-v0.3": 32768,
+    "ovh/mistral-nemo-2407": 131072,
+    "ovh/mixtral-8x7b-instruct": 32768,
+    "ovh/qwen2.5-coder-32b-instruct": 32768,
+    "ovh/qwen2.5-vl-72b-instruct": 131072,
+}
+
+# CEREBRAS MODELS
+CEREBRAS_MODELS = {
+    "cerebras/llama-3.1-8b": 8192,
+    "cerebras/llama-3.3-70b": 8192,
+}
+
+# GOOGLE AI MODELS
+GOOGLEAI_MODELS = {
+    "gemini-1.0-pro": 32768,
+    "gemini-1.5-flash": 1000000,
+    "gemini-1.5-pro": 1000000,
+    "gemini-2.0-pro": 2000000,
+    "gemini-2.5-pro": 2000000,
 }
 
 # ==========================================================
@@ -323,6 +379,8 @@ def fetch_groq_models():
                 context_size = 32768
             elif "gemma" in model_id:
                 context_size = 8192
+            elif "vision" in model_id:
+                context_size = 131072
             else:
                 context_size = 8192  # Default assumption
                 
@@ -500,8 +558,14 @@ def filter_models(provider, search_term):
         all_models = list(GROQ_MODELS.keys())
     elif provider == "Cohere":
         all_models = list(COHERE_MODELS.keys())
-    elif provider == "GLHF":
-        all_models = list(GLHF_MODELS.keys())
+    elif provider == "Together":
+        all_models = list(TOGETHER_MODELS.keys())
+    elif provider == "OVH":
+        all_models = list(OVH_MODELS.keys())
+    elif provider == "Cerebras":
+        all_models = list(CEREBRAS_MODELS.keys())
+    elif provider == "GoogleAI":
+        all_models = list(GOOGLEAI_MODELS.keys())
     else:
         return [], None
         
@@ -533,9 +597,18 @@ def get_model_info(provider, 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]
+    elif provider == "Together":
+        if model_choice in TOGETHER_MODELS:
+            return model_choice, TOGETHER_MODELS[model_choice]
+    elif provider == "OVH":
+        if model_choice in OVH_MODELS:
+            return model_choice, OVH_MODELS[model_choice]
+    elif provider == "Cerebras":
+        if model_choice in CEREBRAS_MODELS:
+            return model_choice, CEREBRAS_MODELS[model_choice]
+    elif provider == "GoogleAI":
+        if model_choice in GOOGLEAI_MODELS:
+            return model_choice, GOOGLEAI_MODELS[model_choice]
     
     return None, 0
 
@@ -544,6 +617,18 @@ def update_context_display(provider, model_name):
     _, ctx_size = get_model_info(provider, model_name)
     return f"{ctx_size:,}" if ctx_size else "Unknown"
 
+def is_vision_model(provider, model_name):
+    """Check if a model supports vision/images"""
+    if provider in VISION_MODELS:
+        if model_name in VISION_MODELS[provider]:
+            return True
+            
+        # Also check for common vision indicators in model names
+        if any(x in model_name.lower() for x in ["vl", "vision", "visual", "llava", "gemini"]):
+            return True
+    
+    return False
+
 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)
@@ -551,22 +636,9 @@ def update_model_info(provider, model_name):
         return "<p>Model information not available</p>"
         
     # Check if this is a vision model
-    is_vision_model = False
+    is_vision = is_vision_model(provider, model_name)
     
-    # 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 ''
+    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 else ''
     
     # For OpenRouter, show the model ID
     model_id_html = f"<p><strong>Model ID:</strong> {model_id}</p>" if provider == "OpenRouter" else ""
@@ -581,7 +653,7 @@ def update_model_info(provider, model_name):
         {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 ''}
+        {f'<p><strong>Features:</strong> Supports image understanding</p>' if is_vision else ''}
     </div>
     """
 
@@ -802,29 +874,23 @@ def call_cohere_api(payload, api_key_override=None):
         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"""
+def call_together_api(payload, api_key_override=None):
+    """Make a call to Together API with error handling"""
     try:
         if not HAS_OPENAI:
-            raise ImportError("OpenAI package not installed (required for GLHF API)")
+            raise ImportError("OpenAI package not installed (required for Together API)")
             
-        api_key = api_key_override if api_key_override else GLHF_API_KEY
+        api_key = api_key_override if api_key_override else TOGETHER_API_KEY
         if not api_key:
-            raise ValueError("GLHF API key is required")
+            raise ValueError("Together API key is required")
             
         client = openai.OpenAI(
             api_key=api_key,
-            base_url="https://glhf.chat/api/openai/v1"
+            base_url="https://api.together.xyz/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
-            
+        model = payload.get("model", "meta-llama/Llama-3.1-8B-Instruct")
         messages = payload.get("messages", [])
         temperature = payload.get("temperature", 0.7)
         max_tokens = payload.get("max_tokens", 1000)
@@ -841,7 +907,156 @@ def call_glhf_api(payload, api_key_override=None):
         
         return response
     except Exception as e:
-        logger.error(f"GLHF API error: {str(e)}")
+        logger.error(f"Together API error: {str(e)}")
+        raise e
+
+def call_ovh_api(payload, api_key_override=None):
+    """Make a call to OVH AI Endpoints API with error handling"""
+    try:
+        # Use custom OpenAI client with the OVH endpoint
+        model = payload.get("model", "ovh/llama-3.1-8b-instruct")
+        messages = payload.get("messages", [])
+        temperature = payload.get("temperature", 0.7)
+        max_tokens = payload.get("max_tokens", 1000)
+                
+        headers = {
+            "Content-Type": "application/json"
+        }
+        
+        data = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens
+        }
+        
+        response = requests.post(
+            "https://endpoints.ai.cloud.ovh.net/v1/chat/completions",
+            headers=headers,
+            json=data
+        )
+        
+        if response.status_code != 200:
+            raise ValueError(f"OVH API returned status code {response.status_code}: {response.text}")
+            
+        return response.json()
+    except Exception as e:
+        logger.error(f"OVH API error: {str(e)}")
+        raise e
+
+def call_cerebras_api(payload, api_key_override=None):
+    """Make a call to Cerebras API with error handling"""
+    try:
+        # Use vanilla requests for this API
+        model = payload.get("model", "cerebras/llama-3.1-8b")
+        messages = payload.get("messages", [])
+        temperature = payload.get("temperature", 0.7)
+        max_tokens = payload.get("max_tokens", 1000)
+                
+        headers = {
+            "Content-Type": "application/json"
+        }
+        
+        data = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens
+        }
+        
+        response = requests.post(
+            "https://api.cloud.cerebras.ai/v1/chat/completions",
+            headers=headers,
+            json=data
+        )
+        
+        if response.status_code != 200:
+            raise ValueError(f"Cerebras API returned status code {response.status_code}: {response.text}")
+            
+        return response.json()
+    except Exception as e:
+        logger.error(f"Cerebras API error: {str(e)}")
+        raise e
+
+def call_googleai_api(payload, api_key_override=None):
+    """Make a call to Google AI (Gemini) API with error handling"""
+    try:
+        from google.generativeai import configure, GenerativeModel
+        
+        api_key = api_key_override if api_key_override else GOOGLEAI_API_KEY
+        if not api_key:
+            raise ValueError("Google AI API key is required")
+            
+        configure(api_key=api_key)
+        
+        # Extract parameters from payload
+        model_name = payload.get("model", "gemini-1.5-pro")
+        messages = payload.get("messages", [])
+        temperature = payload.get("temperature", 0.7)
+        
+        # Convert messages to Google AI format
+        google_messages = []
+        for msg in messages:
+            role = msg["role"]
+            content = msg["content"]
+            
+            # Skip system messages for now (Gemini doesn't support them directly)
+            if role == "system":
+                continue
+                
+            # Map user/assistant roles to Google's roles
+            gemini_role = "user" if role == "user" else "model"
+            
+            # Process content (text or multimodal)
+            if isinstance(content, list):
+                # Multimodal content handling for Gemini
+                parts = []
+                for item in content:
+                    if item["type"] == "text":
+                        parts.append({"text": item["text"]})
+                    elif item["type"] == "image_url":
+                        image_data = item["image_url"]["url"]
+                        if image_data.startswith("data:"):
+                            # Extract base64 data
+                            mime, base64_data = image_data.split(";base64,")
+                            mime_type = mime.split(":")[1]
+                            parts.append({
+                                "inline_data": {
+                                    "mime_type": mime_type,
+                                    "data": base64_data
+                                }
+                            })
+                google_messages.append({"role": gemini_role, "parts": parts})
+            else:
+                # Simple text content
+                google_messages.append({"role": gemini_role, "parts": [{"text": content}]})
+        
+        # Create Gemini model
+        model = GenerativeModel(model_name)
+        
+        # Generate content
+        response = model.generate_content(
+            google_messages,
+            generation_config={
+                "temperature": temperature,
+                "max_output_tokens": payload.get("max_tokens", 1000),
+                "top_p": payload.get("top_p", 0.95),
+            }
+        )
+        
+        # Convert response to standard format
+        return {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": response.text
+                    }
+                }
+            ]
+        }
+    except Exception as e:
+        logger.error(f"Google AI API error: {str(e)}")
         raise e
 
 def extract_ai_response(result, provider):
@@ -880,9 +1095,21 @@ def extract_ai_response(result, provider):
             if hasattr(result, "text"):
                 return result.text
                 
-        elif provider == "GLHF":
+        elif provider == "Together":
             if hasattr(result, "choices") and len(result.choices) > 0:
                 return result.choices[0].message.content
+                
+        elif provider == "OVH":
+            if isinstance(result, dict) and "choices" in result and len(result["choices"]) > 0:
+                return result["choices"][0]["message"]["content"]
+                
+        elif provider == "Cerebras":
+            if isinstance(result, dict) and "choices" in result and len(result["choices"]) > 0:
+                return result["choices"][0]["message"]["content"]
+                
+        elif provider == "GoogleAI":
+            if isinstance(result, dict) and "choices" in result 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"
@@ -969,7 +1196,7 @@ def groq_streaming_handler(response, chatbot, message_idx, message):
         chatbot[-1][1] += f"\n\nError during streaming: {str(e)}"
         yield chatbot
 
-def glhf_streaming_handler(response, chatbot, message_idx, message):
+def together_streaming_handler(response, chatbot, message_idx, message):
     try:
         # First add the user message if needed
         if len(chatbot) == message_idx:
@@ -984,7 +1211,7 @@ def glhf_streaming_handler(response, chatbot, message_idx, message):
                 yield chatbot
                 
     except Exception as e:
-        logger.error(f"Error in GLHF streaming handler: {str(e)}")
+        logger.error(f"Error in Together streaming handler: {str(e)}")
         # Add error message to the current response
         chatbot[-1][1] += f"\n\nError during streaming: {str(e)}"
         yield chatbot
@@ -1279,28 +1506,28 @@ def ask_ai(message, history, provider, model_choice, temperature, max_tokens, to
                 chat_history.append([message, error_message])
                 return chat_history
                 
-        elif provider == "GLHF":
+        elif provider == "Together":
             # 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"
+                error_message = f"Error: Model '{model_choice}' not found in Together"
                 chat_history.append([message, error_message])
                 return chat_history
             
-            # Build GLHF payload
+            # Build Together payload
             payload = {
-                "model": model_id,  # The hf: prefix will be added in the API call
+                "model": model_id,
                 "messages": messages,
                 "temperature": temperature,
                 "max_tokens": max_tokens,
                 "stream": stream_output
             }
             
-            # Call GLHF API
-            logger.info(f"Sending request to GLHF model: {model_id}")
+            # Call Together API
+            logger.info(f"Sending request to Together model: {model_id}")
             
             try:
-                response = call_glhf_api(payload, api_key_override)
+                response = call_together_api(payload, api_key_override)
                 
                 # Handle streaming response
                 if stream_output:
@@ -1309,7 +1536,7 @@ def ask_ai(message, history, provider, model_choice, temperature, max_tokens, to
                     
                     # Set up generator for streaming updates
                     def streaming_generator():
-                        for updated_history in glhf_streaming_handler(response, chat_history, len(chat_history) - 1, message):
+                        for updated_history in together_streaming_handler(response, chat_history, len(chat_history) - 1, message):
                             yield updated_history
                     
                     return streaming_generator()
@@ -1320,7 +1547,104 @@ def ask_ai(message, history, provider, model_choice, temperature, max_tokens, to
                     chat_history.append([message, ai_response])
                     return chat_history
             except Exception as e:
-                error_message = f"GLHF API Error: {str(e)}"
+                error_message = f"Together API Error: {str(e)}"
+                logger.error(error_message)
+                chat_history.append([message, error_message])
+                return chat_history
+                
+        elif provider == "OVH":
+            # 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 OVH"
+                chat_history.append([message, error_message])
+                return chat_history
+            
+            # Build OVH payload
+            payload = {
+                "model": model_id,
+                "messages": messages,
+                "temperature": temperature,
+                "max_tokens": max_tokens
+            }
+            
+            # Call OVH API
+            logger.info(f"Sending request to OVH model: {model_id}")
+            
+            try:
+                response = call_ovh_api(payload)
+                
+                # 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"OVH API Error: {str(e)}"
+                logger.error(error_message)
+                chat_history.append([message, error_message])
+                return chat_history
+                
+        elif provider == "Cerebras":
+            # 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 Cerebras"
+                chat_history.append([message, error_message])
+                return chat_history
+            
+            # Build Cerebras payload
+            payload = {
+                "model": model_id,
+                "messages": messages,
+                "temperature": temperature,
+                "max_tokens": max_tokens
+            }
+            
+            # Call Cerebras API
+            logger.info(f"Sending request to Cerebras model: {model_id}")
+            
+            try:
+                response = call_cerebras_api(payload)
+                
+                # 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"Cerebras API Error: {str(e)}"
+                logger.error(error_message)
+                chat_history.append([message, error_message])
+                return chat_history
+                
+        elif provider == "GoogleAI":
+            # 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 GoogleAI"
+                chat_history.append([message, error_message])
+                return chat_history
+            
+            # Build GoogleAI payload
+            payload = {
+                "model": model_id,
+                "messages": messages,
+                "temperature": temperature,
+                "max_tokens": max_tokens,
+                "top_p": top_p
+            }
+            
+            # Call GoogleAI API
+            logger.info(f"Sending request to GoogleAI model: {model_id}")
+            
+            try:
+                response = call_googleai_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"GoogleAI API Error: {str(e)}"
                 logger.error(error_message)
                 chat_history.append([message, error_message])
                 return chat_history
@@ -1383,7 +1707,7 @@ def create_app():
         gr.Markdown("""
         # 🤖 Multi-Provider CrispChat
         
-        Chat with AI models from multiple providers: OpenRouter, OpenAI, HuggingFace, Groq, Cohere, and GLHF.
+        Chat with AI models from multiple providers: OpenRouter, OpenAI, HuggingFace, Groq, Cohere, Together, OVH, Cerebras, and Google AI.
         """)
         
         with gr.Row():
@@ -1394,7 +1718,6 @@ def create_app():
                     show_copy_button=True, 
                     show_label=False,
                     avatar_images=(None, "https://upload.wikimedia.org/wikipedia/commons/0/04/ChatGPT_logo.svg"),
-                    type="messages",
                     elem_id="chat-window"
                 )
                 
@@ -1414,7 +1737,8 @@ def create_app():
                     with gr.Column(scale=1):
                         clear_btn = gr.Button("Clear Chat", variant="secondary")
                 
-                with gr.Row():
+                # Container for conditionally showing image upload
+                with gr.Row(visible=True) as image_upload_container:
                     # Image upload
                     with gr.Accordion("Upload Images (for vision models)", open=False):
                         images = gr.File(
@@ -1443,7 +1767,7 @@ def create_app():
                     
                     # Provider selection
                     provider_choice = gr.Radio(
-                        choices=["OpenRouter", "OpenAI", "HuggingFace", "Groq", "Cohere", "GLHF"],
+                        choices=["OpenRouter", "OpenAI", "HuggingFace", "Groq", "Cohere", "Together", "OVH", "Cerebras", "GoogleAI"],
                         value="OpenRouter",
                         label="AI Provider"
                     )
@@ -1506,11 +1830,35 @@ def create_app():
                         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",
+                    together_model = gr.Dropdown(
+                        choices=list(TOGETHER_MODELS.keys()),
+                        value="meta-llama/Llama-3.1-8B-Instruct" if "meta-llama/Llama-3.1-8B-Instruct" in TOGETHER_MODELS else None,
+                        label="Together Model",
+                        elem_id="together-model-choice",
+                        visible=False
+                    )
+                    
+                    ovh_model = gr.Dropdown(
+                        choices=list(OVH_MODELS.keys()),
+                        value="ovh/llama-3.1-8b-instruct" if "ovh/llama-3.1-8b-instruct" in OVH_MODELS else None,
+                        label="OVH Model",
+                        elem_id="ovh-model-choice",
+                        visible=False
+                    )
+                    
+                    cerebras_model = gr.Dropdown(
+                        choices=list(CEREBRAS_MODELS.keys()),
+                        value="cerebras/llama-3.1-8b" if "cerebras/llama-3.1-8b" in CEREBRAS_MODELS else None,
+                        label="Cerebras Model",
+                        elem_id="cerebras-model-choice",
+                        visible=False
+                    )
+                    
+                    googleai_model = gr.Dropdown(
+                        choices=list(GOOGLEAI_MODELS.keys()),
+                        value="gemini-1.5-pro" if "gemini-1.5-pro" in GOOGLEAI_MODELS else None,
+                        label="Google AI Model",
+                        elem_id="googleai-model-choice",
                         visible=False
                     )
                     
@@ -1652,6 +2000,12 @@ def create_app():
                     model_info_display = gr.HTML(
                         value=update_model_info("OpenRouter", OPENROUTER_ALL_MODELS[0][0])
                     )
+                    
+                    is_vision_indicator = gr.Checkbox(
+                        label="Supports Images",
+                        value=is_vision_model("OpenRouter", OPENROUTER_ALL_MODELS[0][0]),
+                        interactive=False
+                    )
         
         # Add usage instructions
         with gr.Accordion("Usage Instructions", open=False):
@@ -1671,7 +2025,10 @@ def create_app():
             - **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
+            - **Together**: Access to high-quality open models, requires API key
+            - **OVH**: Free beta access to several models
+            - **Cerebras**: Free tier available with 8K context limit
+            - **GoogleAI**: Google's Gemini models, requires API key
             
             ## Advanced Parameters
             - **Temperature**: Controls randomness (higher = more creative, lower = more deterministic)
@@ -1683,23 +2040,26 @@ def create_app():
         # Add a footer with version info
         footer_md = gr.Markdown("""
         ---
-        ### Multi-Provider CrispChat v1.0
+        ### Multi-Provider CrispChat v1.1
         Built with ❤️ using Gradio and multiple AI provider APIs | Context sizes shown next to model names
         """)
         
         # Define event handlers
         def toggle_model_dropdowns(provider):
             """Show/hide model dropdowns based on provider selection"""
-            return [
-                gr.update(visible=(provider == "OpenRouter")),
-                gr.update(visible=(provider == "OpenAI")),
-                gr.update(visible=(provider == "HuggingFace")),
-                gr.update(visible=(provider == "Groq")),
-                gr.update(visible=(provider == "Cohere")),
-                gr.update(visible=(provider == "GLHF"))
-            ]
+            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")),
+                together_model: gr.update(visible=(provider == "Together")),
+                ovh_model: gr.update(visible=(provider == "OVH")),
+                cerebras_model: gr.update(visible=(provider == "Cerebras")),
+                googleai_model: gr.update(visible=(provider == "GoogleAI"))
+            }
             
-        def update_context_for_provider(provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, glhf_model):
+        def update_context_for_provider(provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, ovh_model, cerebras_model, googleai_model):
             """Update context display based on selected provider and model"""
             if provider == "OpenRouter":
                 return update_context_display(provider, openrouter_model)
@@ -1711,11 +2071,17 @@ def create_app():
                 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)
+            elif provider == "Together":
+                return update_context_display(provider, together_model)
+            elif provider == "OVH":
+                return update_context_display(provider, ovh_model)
+            elif provider == "Cerebras":
+                return update_context_display(provider, cerebras_model)
+            elif provider == "GoogleAI":
+                return update_context_display(provider, googleai_model)
             return "Unknown"
             
-        def update_model_info_for_provider(provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, glhf_model):
+        def update_model_info_for_provider(provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, ovh_model, cerebras_model, googleai_model):
             """Update model info based on selected provider and model"""
             if provider == "OpenRouter":
                 return update_model_info(provider, openrouter_model)
@@ -1727,79 +2093,165 @@ def create_app():
                 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)
+            elif provider == "Together":
+                return update_model_info(provider, together_model)
+            elif provider == "OVH":
+                return update_model_info(provider, ovh_model)
+            elif provider == "Cerebras":
+                return update_model_info(provider, cerebras_model)
+            elif provider == "GoogleAI":
+                return update_model_info(provider, googleai_model)
             return "<p>Model information not available</p>"
+            
+        def update_vision_indicator(provider, model_choice):
+            """Update the vision capability indicator"""
+            return is_vision_model(provider, model_choice)
+            
+        def update_image_upload_visibility(provider, model_choice):
+            """Show/hide image upload based on model vision capabilities"""
+            is_vision = is_vision_model(provider, model_choice)
+            return gr.update(visible=is_vision)
         
-    # Handling model search function - Fixed compared to previous implementation
-        def search_models(provider, search_term):
-            """Filter models for the selected provider based on search term"""
-            filtered_models = []
+        # Search model function - FIXED FUNCTION
+        def search_openrouter_models(search_term):
+            """Filter OpenRouter models based on search term"""
+            all_models = [model[0] for model in OPENROUTER_ALL_MODELS]
+            if not search_term:
+                return gr.update(choices=all_models, value=all_models[0] if all_models else None)
+                
+            filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
             
-            if provider == "OpenRouter":
-                all_models = [model[0] for model in OPENROUTER_ALL_MODELS]
-                if search_term:
-                    filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
-                else:
-                    filtered_models = all_models
+            if filtered_models:
+                return gr.update(choices=filtered_models, value=filtered_models[0])
+            else:
+                return gr.update(choices=all_models, value=all_models[0] if all_models else None)
                 
-                return gr.update(choices=filtered_models, value=filtered_models[0] if filtered_models else None)
+        def search_openai_models(search_term):
+            """Filter OpenAI models based on search term"""
+            all_models = list(OPENAI_MODELS.keys())
+            if not search_term:
+                return gr.update(choices=all_models, value="gpt-3.5-turbo" if "gpt-3.5-turbo" in all_models else all_models[0] if all_models else None)
                 
-            elif provider == "OpenAI":
-                all_models = list(OPENAI_MODELS.keys())
-                if search_term:
-                    filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
-                else:
-                    filtered_models = all_models
+            filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
+            
+            if filtered_models:
+                return gr.update(choices=filtered_models, value=filtered_models[0])
+            else:
+                return gr.update(choices=all_models, value="gpt-3.5-turbo" if "gpt-3.5-turbo" in all_models else all_models[0] if all_models else None)
                 
-                return gr.update(choices=filtered_models, value=filtered_models[0] if filtered_models else None)
+        def search_hf_models(search_term):
+            """Filter HuggingFace models based on search term"""
+            all_models = list(HUGGINGFACE_MODELS.keys())
+            if not search_term:
+                default_model = "mistralai/Mistral-7B-Instruct-v0.3" if "mistralai/Mistral-7B-Instruct-v0.3" in all_models else all_models[0] if all_models else None
+                return gr.update(choices=all_models, value=default_model)
                 
-            elif provider == "HuggingFace":
-                all_models = list(HUGGINGFACE_MODELS.keys())
-                if search_term:
-                    filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
-                else:
-                    filtered_models = all_models
+            filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
+            
+            if filtered_models:
+                return gr.update(choices=filtered_models, value=filtered_models[0])
+            else:
+                default_model = "mistralai/Mistral-7B-Instruct-v0.3" if "mistralai/Mistral-7B-Instruct-v0.3" in all_models else all_models[0] if all_models else None
+                return gr.update(choices=all_models, value=default_model)
                 
-                return gr.update(choices=filtered_models, value=filtered_models[0] if filtered_models else None)
+        def search_groq_models(search_term):
+            """Filter Groq models based on search term"""
+            all_models = list(GROQ_MODELS.keys())
+            if not search_term:
+                default_model = "llama-3.1-8b-instant" if "llama-3.1-8b-instant" in all_models else all_models[0] if all_models else None
+                return gr.update(choices=all_models, value=default_model)
                 
-            elif provider == "Groq":
-                all_models = list(GROQ_MODELS.keys())
-                if search_term:
-                    filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
-                else:
-                    filtered_models = all_models
+            filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
+            
+            if filtered_models:
+                return gr.update(choices=filtered_models, value=filtered_models[0])
+            else:
+                default_model = "llama-3.1-8b-instant" if "llama-3.1-8b-instant" in all_models else all_models[0] if all_models else None
+                return gr.update(choices=all_models, value=default_model)
                 
-                return gr.update(choices=filtered_models, value=filtered_models[0] if filtered_models else None)
+        def search_cohere_models(search_term):
+            """Filter Cohere models based on search term"""
+            all_models = list(COHERE_MODELS.keys())
+            if not search_term:
+                default_model = "command-r-plus" if "command-r-plus" in all_models else all_models[0] if all_models else None
+                return gr.update(choices=all_models, value=default_model)
                 
-            elif provider == "Cohere":
-                all_models = list(COHERE_MODELS.keys())
-                if search_term:
-                    filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
-                else:
-                    filtered_models = all_models
+            filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
+            
+            if filtered_models:
+                return gr.update(choices=filtered_models, value=filtered_models[0])
+            else:
+                default_model = "command-r-plus" if "command-r-plus" in all_models else all_models[0] if all_models else None
+                return gr.update(choices=all_models, value=default_model)
                 
-                return gr.update(choices=filtered_models, value=filtered_models[0] if filtered_models else None)
+        def search_together_models(search_term):
+            """Filter Together models based on search term"""
+            all_models = list(TOGETHER_MODELS.keys())
+            if not search_term:
+                default_model = "meta-llama/Llama-3.1-8B-Instruct" if "meta-llama/Llama-3.1-8B-Instruct" in all_models else all_models[0] if all_models else None
+                return gr.update(choices=all_models, value=default_model)
                 
-            elif provider == "GLHF":
-                all_models = list(GLHF_MODELS.keys())
-                if search_term:
-                    filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
-                else:
-                    filtered_models = all_models
+            filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
+            
+            if filtered_models:
+                return gr.update(choices=filtered_models, value=filtered_models[0])
+            else:
+                default_model = "meta-llama/Llama-3.1-8B-Instruct" if "meta-llama/Llama-3.1-8B-Instruct" in all_models else all_models[0] if all_models else None
+                return gr.update(choices=all_models, value=default_model)
                 
-                return gr.update(choices=filtered_models, value=filtered_models[0] if filtered_models else None)
+        def search_ovh_models(search_term):
+            """Filter OVH models based on search term"""
+            all_models = list(OVH_MODELS.keys())
+            if not search_term:
+                default_model = "ovh/llama-3.1-8b-instruct" if "ovh/llama-3.1-8b-instruct" in all_models else all_models[0] if all_models else None
+                return gr.update(choices=all_models, value=default_model)
                 
-            # Default return in case of unknown provider
-            return gr.update(choices=[], value=None)
+            filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
+            
+            if filtered_models:
+                return gr.update(choices=filtered_models, value=filtered_models[0])
+            else:
+                default_model = "ovh/llama-3.1-8b-instruct" if "ovh/llama-3.1-8b-instruct" in all_models else all_models[0] if all_models else None
+                return gr.update(choices=all_models, value=default_model)
+                
+        def search_cerebras_models(search_term):
+            """Filter Cerebras models based on search term"""
+            all_models = list(CEREBRAS_MODELS.keys())
+            if not search_term:
+                default_model = "cerebras/llama-3.1-8b" if "cerebras/llama-3.1-8b" in all_models else all_models[0] if all_models else None
+                return gr.update(choices=all_models, value=default_model)
+                
+            filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
+            
+            if filtered_models:
+                return gr.update(choices=filtered_models, value=filtered_models[0])
+            else:
+                default_model = "cerebras/llama-3.1-8b" if "cerebras/llama-3.1-8b" in all_models else all_models[0] if all_models else None
+                return gr.update(choices=all_models, value=default_model)
+                
+        def search_googleai_models(search_term):
+            """Filter GoogleAI models based on search term"""
+            all_models = list(GOOGLEAI_MODELS.keys())
+            if not search_term:
+                default_model = "gemini-1.5-pro" if "gemini-1.5-pro" in all_models else all_models[0] if all_models else None
+                return gr.update(choices=all_models, value=default_model)
+                
+            filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
+            
+            if filtered_models:
+                return gr.update(choices=filtered_models, value=filtered_models[0])
+            else:
+                default_model = "gemini-1.5-pro" if "gemini-1.5-pro" in all_models else all_models[0] if all_models else None
+                return gr.update(choices=all_models, value=default_model)
+
             
         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):
+        
+        def get_current_model(provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, ovh_model, cerebras_model, googleai_model):
             """Get the currently selected model based on provider"""
             if provider == "OpenRouter":
                 return openrouter_model
@@ -1811,8 +2263,14 @@ def create_app():
                 return groq_model
             elif provider == "Cohere":
                 return cohere_model
-            elif provider == "GLHF":
-                return glhf_model
+            elif provider == "Together":
+                return together_model
+            elif provider == "OVH":
+                return ovh_model
+            elif provider == "Cerebras":
+                return cerebras_model
+            elif provider == "GoogleAI":
+                return googleai_model
             return None
         
         # Process uploaded images
@@ -1826,26 +2284,63 @@ def create_app():
         provider_choice.change(
             fn=toggle_model_dropdowns,
             inputs=provider_choice,
-            outputs=[openrouter_model, openai_model, hf_model, groq_model, cohere_model, glhf_model]
+            outputs={
+                openrouter_model: None,
+                openai_model: None,
+                hf_model: None,
+                groq_model: None,
+                cohere_model: None,
+                together_model: None,
+                ovh_model: None,
+                cerebras_model: None,
+                googleai_model: None
+            }
         ).then(
             fn=update_context_for_provider,
-            inputs=[provider_choice, openrouter_model, openai_model, hf_model, groq_model, cohere_model, glhf_model],
+            inputs=[provider_choice, openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, ovh_model, cerebras_model, googleai_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],
+            inputs=[provider_choice, openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, ovh_model, cerebras_model, googleai_model],
             outputs=model_info_display
+        ).then(
+            fn=lambda provider, model: update_vision_indicator(
+                provider, 
+                get_current_model(provider, model, None, None, None, None, None, None, None, None)
+            ),
+            inputs=[provider_choice, openrouter_model],
+            outputs=is_vision_indicator
+        ).then(
+            fn=lambda provider, model: update_image_upload_visibility(
+                provider, 
+                get_current_model(provider, model, None, None, None, None, None, None, None, None)
+            ),
+            inputs=[provider_choice, openrouter_model],
+            outputs=image_upload_container
         )
         
         # Set up model search event - FIXED VERSION
-        # Important: We need to return a proper Gradio component update for each dropdown
+        # We'll now have the correct function that returns model dropdown updates
         model_search.change(
-            fn=search_models,
+            fn=lambda provider, search: {
+                "OpenRouter": search_openrouter_models(search),
+                "OpenAI": search_openai_models(search),
+                "HuggingFace": search_hf_models(search),
+                "Groq": search_groq_models(search),
+                "Cohere": search_cohere_models(search),
+                "Together": search_together_models(search),
+                "OVH": search_ovh_models(search),
+                "Cerebras": search_cerebras_models(search),
+                "GoogleAI": search_googleai_models(search)
+            }[provider],
             inputs=[provider_choice, model_search],
-            outputs=[openrouter_model]  # This will be handled by the JS forwarding logic
+            outputs=[
+                openrouter_model, openai_model, hf_model, groq_model, 
+                cohere_model, together_model, ovh_model, cerebras_model, googleai_model
+            ]
         )
         
-        # Set up model change events
+        # Set up model change events to update context display and model info
         openrouter_model.change(
             fn=lambda model: update_context_display("OpenRouter", model),
             inputs=openrouter_model,
@@ -1854,6 +2349,14 @@ def create_app():
             fn=lambda model: update_model_info("OpenRouter", model),
             inputs=openrouter_model,
             outputs=model_info_display
+        ).then(
+            fn=lambda model: update_vision_indicator("OpenRouter", model),
+            inputs=openrouter_model,
+            outputs=is_vision_indicator
+        ).then(
+            fn=lambda model: update_image_upload_visibility("OpenRouter", model),
+            inputs=openrouter_model,
+            outputs=image_upload_container
         )
         
         openai_model.change(
@@ -1864,6 +2367,14 @@ def create_app():
             fn=lambda model: update_model_info("OpenAI", model),
             inputs=openai_model,
             outputs=model_info_display
+        ).then(
+            fn=lambda model: update_vision_indicator("OpenAI", model),
+            inputs=openai_model,
+            outputs=is_vision_indicator
+        ).then(
+            fn=lambda model: update_image_upload_visibility("OpenAI", model),
+            inputs=openai_model,
+            outputs=image_upload_container
         )
         
         hf_model.change(
@@ -1874,6 +2385,14 @@ def create_app():
             fn=lambda model: update_model_info("HuggingFace", model),
             inputs=hf_model,
             outputs=model_info_display
+        ).then(
+            fn=lambda model: update_vision_indicator("HuggingFace", model),
+            inputs=hf_model,
+            outputs=is_vision_indicator
+        ).then(
+            fn=lambda model: update_image_upload_visibility("HuggingFace", model),
+            inputs=hf_model,
+            outputs=image_upload_container
         )
         
         groq_model.change(
@@ -1884,6 +2403,14 @@ def create_app():
             fn=lambda model: update_model_info("Groq", model),
             inputs=groq_model,
             outputs=model_info_display
+        ).then(
+            fn=lambda model: update_vision_indicator("Groq", model),
+            inputs=groq_model,
+            outputs=is_vision_indicator
+        ).then(
+            fn=lambda model: update_image_upload_visibility("Groq", model),
+            inputs=groq_model,
+            outputs=image_upload_container
         )
         
         cohere_model.change(
@@ -1894,50 +2421,102 @@ def create_app():
             fn=lambda model: update_model_info("Cohere", model),
             inputs=cohere_model,
             outputs=model_info_display
+        ).then(
+            fn=lambda model: update_vision_indicator("Cohere", model),
+            inputs=cohere_model,
+            outputs=is_vision_indicator
+        ).then(
+            fn=lambda model: update_image_upload_visibility("Cohere", model),
+            inputs=cohere_model,
+            outputs=image_upload_container
         )
         
-        glhf_model.change(
-            fn=lambda model: update_context_display("GLHF", model),
-            inputs=glhf_model,
+        together_model.change(
+            fn=lambda model: update_context_display("Together", model),
+            inputs=together_model,
             outputs=context_display
         ).then(
-            fn=lambda model: update_model_info("GLHF", model),
-            inputs=glhf_model,
+            fn=lambda model: update_model_info("Together", model),
+            inputs=together_model,
             outputs=model_info_display
+        ).then(
+            fn=lambda model: update_vision_indicator("Together", model),
+            inputs=together_model,
+            outputs=is_vision_indicator
+        ).then(
+            fn=lambda model: update_image_upload_visibility("Together", model),
+            inputs=together_model,
+            outputs=image_upload_container
         )
         
-        # Add custom JavaScript for routing model search to visible dropdown
-        gr.HTML("""
-        <script>
-            // To be triggered after page load
-            document.addEventListener('DOMContentLoaded', function() {
-                // Find dropdowns
-                const providerRadio = document.querySelector('input[name="provider_choice"]');
-                const searchInput = document.getElementById('model_search');
-                
-                if (providerRadio && searchInput) {
-                    // When provider changes, clear the search
-                    providerRadio.addEventListener('change', function() {
-                        searchInput.value = '';
-                    });
-                }
-            });
-        </script>
-        """)
+        ovh_model.change(
+            fn=lambda model: update_context_display("OVH", model),
+            inputs=ovh_model,
+            outputs=context_display
+        ).then(
+            fn=lambda model: update_model_info("OVH", model),
+            inputs=ovh_model,
+            outputs=model_info_display
+        ).then(
+            fn=lambda model: update_vision_indicator("OVH", model),
+            inputs=ovh_model,
+            outputs=is_vision_indicator
+        ).then(
+            fn=lambda model: update_image_upload_visibility("OVH", model),
+            inputs=ovh_model,
+            outputs=image_upload_container
+        )
+        
+        cerebras_model.change(
+            fn=lambda model: update_context_display("Cerebras", model),
+            inputs=cerebras_model,
+            outputs=context_display
+        ).then(
+            fn=lambda model: update_model_info("Cerebras", model),
+            inputs=cerebras_model,
+            outputs=model_info_display
+        ).then(
+            fn=lambda model: update_vision_indicator("Cerebras", model),
+            inputs=cerebras_model,
+            outputs=is_vision_indicator
+        ).then(
+            fn=lambda model: update_image_upload_visibility("Cerebras", model),
+            inputs=cerebras_model,
+            outputs=image_upload_container
+        )
+        
+        googleai_model.change(
+            fn=lambda model: update_context_display("GoogleAI", model),
+            inputs=googleai_model,
+            outputs=context_display
+        ).then(
+            fn=lambda model: update_model_info("GoogleAI", model),
+            inputs=googleai_model,
+            outputs=model_info_display
+        ).then(
+            fn=lambda model: update_vision_indicator("GoogleAI", model),
+            inputs=googleai_model,
+            outputs=is_vision_indicator
+        ).then(
+            fn=lambda model: update_image_upload_visibility("GoogleAI", model),
+            inputs=googleai_model,
+            outputs=image_upload_container
+        )
         
         # Set up submission event
-        def submit_message(message, history, provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, glhf_model, 
+        def submit_message(message, history, provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, ovh_model, cerebras_model, googleai_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)
+            model_choice = get_current_model(provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, ovh_model, cerebras_model, googleai_model)
             
             # Check if model is selected
             if not model_choice:
-                history.append([message, f"Error: No model selected for provider {provider}"])
-                return history
+                new_history = history.copy()
+                new_history.append([message, f"Error: No model selected for provider {provider}"])
+                return new_history
                 
             # Call the ask_ai function with the appropriate parameters
             return ask_ai(
@@ -1970,7 +2549,7 @@ def create_app():
             fn=submit_message,
             inputs=[
                 message, chatbot, provider_choice, 
-                openrouter_model, openai_model, hf_model, groq_model, cohere_model, glhf_model,
+                openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, ovh_model, cerebras_model, googleai_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
@@ -1988,7 +2567,7 @@ def create_app():
             fn=submit_message,
             inputs=[
                 message, chatbot, provider_choice, 
-                openrouter_model, openai_model, hf_model, groq_model, cohere_model, glhf_model,
+                openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, ovh_model, cerebras_model, googleai_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
@@ -2036,9 +2615,13 @@ if __name__ == "__main__":
         logger.warning("WARNING: COHERE_API_KEY environment variable is not set")
         missing_keys.append("Cohere")
         
-    if not GLHF_API_KEY:
-        logger.warning("WARNING: GLHF_API_KEY environment variable is not set")
-        missing_keys.append("GLHF")
+    if not TOGETHER_API_KEY:
+        logger.warning("WARNING: TOGETHER_API_KEY environment variable is not set")
+        missing_keys.append("Together")
+        
+    if not GOOGLEAI_API_KEY:
+        logger.warning("WARNING: GOOGLEAI_API_KEY environment variable is not set")
+        missing_keys.append("GoogleAI")
         
     if missing_keys:
         print("Missing API keys for the following providers:")
@@ -2049,6 +2632,9 @@ if __name__ == "__main__":
         
         if "OpenRouter" in missing_keys:
             print("\nNote: OpenRouter offers free tier access to many models!")
+        
+        if "OVH" not in missing_keys and "Cerebras" not in missing_keys:
+            print("\nNote: OVH AI Endpoints (beta) and Cerebras offer free usage tiers!")
             
     print("\nStarting Multi-Provider CrispChat application...")
     demo = create_app()