Update app.py

app.py

@@ -856,28 +856,11 @@ def call_cohere_api(payload, api_key_override=None):
         temperature = payload.get("temperature", 0.7)
         max_tokens = payload.get("max_tokens", 1000)
         
-        # Transform messages to Cohere format - IMPORTANT 
-        # Cohere uses specific role names: USER, ASSISTANT, SYSTEM, TOOL
-        cohere_messages = []
-        for msg in messages:
-            role = msg["role"].upper()  # Cohere requires uppercase roles
-            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)
-                
-            cohere_messages.append({"role": role, "content": content})
-        
-        # Create chat completion
+        # Create chat completion - note the correct format for CohereLLM V2
+        # The ClientV2's chat method expects 'messages' parameter, not 'message'
         response = client.chat(
-            message=cohere_messages[-1]["content"] if cohere_messages else "",
-            chat_history=cohere_messages[:-1] if len(cohere_messages) > 1 else [],
             model=model,
+            messages=messages,  # This is directly passed as is
             temperature=temperature,
             max_tokens=max_tokens
         )
@@ -904,35 +887,23 @@ def call_together_api(payload, api_key_override=None):
         )
         
         # Extract parameters from payload
-        model = payload.get("model", "meta-llama/Llama-3.1-8B-Instruct")
+        model = payload.get("model", "meta-llama/Meta-Llama-3-8B-Instruct")
         
-        # Fix model name format - Together API expects this format
-        if not model.startswith("meta-llama/") and "llama" in model.lower():
-            # Convert model ID format from "llama-3.1-8b-instruct" to "meta-llama/Llama-3.1-8B-Instruct"
-            parts = model.split("-")
-            formatted_name = "meta-llama/L" + "".join([p.capitalize() for p in parts])
-            model = formatted_name
+        # Fix model name format - Together API uses a different format
+        # Check documentation for correct model names: https://api.together.ai/models
+        if "llama-3.1" in model.lower():
+            model = "meta-llama/Meta-Llama-3-8B-Instruct"
+        elif "llama-3.3" in model.lower():
+            model = "meta-llama/Meta-Llama-3.3-70B-Instruct"
             
-        # Clean up messages - remove any unexpected properties
-        messages = []
-        for msg in payload.get("messages", []):
-            clean_msg = {
-                "role": msg["role"],
-                "content": msg["content"]
-            }
-            messages.append(clean_msg)
-            
-        # Create payload
-        together_payload = {
-            "model": model,
-            "messages": 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(**together_payload)
+        response = client.chat.completions.create(
+            model=model,
+            messages=payload.get("messages", []),
+            temperature=payload.get("temperature", 0.7),
+            max_tokens=payload.get("max_tokens", 1000),
+            stream=payload.get("stream", False)
+        )
         
         return response
     except Exception as e:
@@ -952,33 +923,30 @@ def call_ovh_api(payload, api_key_override=None):
             "Content-Type": "application/json"
         }
         
-        # Clean up messages - remove any unexpected properties
-        clean_messages = []
-        for msg in messages:
-            clean_msg = {
-                "role": msg["role"],
-                "content": msg["content"]
-            }
-            clean_messages.append(clean_msg)
-        
         data = {
             "model": model,
-            "messages": clean_messages,
+            "messages": messages,
             "temperature": temperature,
             "max_tokens": max_tokens
         }
         
-        # Updated endpoint with correct path
-        response = requests.post(
-            "https://api.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}")
+        # Use a try-except to handle DNS resolution errors and provide a more helpful message
+        try:
+            # Correct endpoint URL based on documentation
+            response = requests.post(
+                "https://endpoints.ai.cloud.ovh.net/v1/chat/completions",  # Updated endpoint
+                headers=headers,
+                json=data,
+                timeout=10  # Add timeout to avoid hanging
+            )
+            
+            if response.status_code != 200:
+                raise ValueError(f"OVH API returned status code {response.status_code}: {response.text}")
+                
+            return response.json()
+        except requests.exceptions.ConnectionError as e:
+            raise ValueError(f"Connection error to OVH API. This may be due to network restrictions in the environment: {str(e)}")
             
-        return response.json()
     except Exception as e:
         logger.error(f"OVH API error: {str(e)}")
         raise e
@@ -988,38 +956,41 @@ def call_cerebras_api(payload, api_key_override=None):
     try:
         # Extract parameters from payload
         model = payload.get("model", "cerebras/llama-3.1-8b")
-        
-        # Clean up messages - remove any unexpected properties
-        messages = []
-        for msg in payload.get("messages", []):
-            clean_msg = {
-                "role": msg["role"],
-                "content": msg["content"]
-            }
-            messages.append(clean_msg)
+        # Strip 'cerebras/' prefix if present
+        if model.startswith("cerebras/"):
+            model = model[9:]
+            
+        messages = payload.get("messages", [])
+        temperature = payload.get("temperature", 0.7)
+        max_tokens = payload.get("max_tokens", 1000)
             
         data = {
             "model": model,
             "messages": messages,
-            "temperature": payload.get("temperature", 0.7),
-            "max_tokens": payload.get("max_tokens", 1000)
+            "temperature": temperature,
+            "max_tokens": max_tokens
         }
         
+        api_key = api_key_override if api_key_override else os.environ.get("CEREBRAS_API_KEY", "")
         headers = {
             "Content-Type": "application/json",
-            "Authorization": f"Bearer {api_key_override or os.environ.get('CEREBRAS_API_KEY', '')}"
+            "Authorization": f"Bearer {api_key}"
         }
         
-        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}")
+        try:
+            response = requests.post(
+                "https://api.cloud.cerebras.ai/v1/chat/completions",
+                headers=headers,
+                json=data,
+                timeout=10  # Add timeout to avoid hanging
+            )
             
-        return response.json()
+            if response.status_code != 200:
+                raise ValueError(f"Cerebras API returned status code {response.status_code}: {response.text}")
+                
+            return response.json()
+        except requests.exceptions.ConnectionError as e:
+            raise ValueError(f"Connection error to Cerebras API. This may be due to network restrictions in the environment: {str(e)}")
     except Exception as e:
         logger.error(f"Cerebras API error: {str(e)}")
         raise e
@@ -1027,80 +998,92 @@ def call_cerebras_api(payload, api_key_override=None):
 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)
+        # Use regular requests instead of the SDK since it might be missing
+        gemini_api_url = "https://generativelanguage.googleapis.com/v1/models/gemini-1.5-pro:generateContent"
         
         # Extract parameters from payload
-        model_name = payload.get("model", "gemini-1.5-pro")
         messages = payload.get("messages", [])
         temperature = payload.get("temperature", 0.7)
+        max_tokens = payload.get("max_tokens", 1000)
         
-        # Convert messages to Google AI format
-        google_messages = []
+        # Convert to Google's format
+        content_parts = []
+        
+        # Add all messages
         for msg in messages:
             role = msg["role"]
             content = msg["content"]
             
-            # Skip system messages for now (Gemini doesn't support them directly)
+            # Handle different roles
             if role == "system":
+                # For system messages, we add it as part of the first user message
                 continue
-                
-            # Map user/assistant roles to Google's roles
-            gemini_role = "user" if role == "user" else "model"
+            elif role == "user":
+                # For user messages, add as regular content
+                if isinstance(content, str):
+                    content_parts.append({"text": content})
+                else:
+                    # Handle multimodal content
+                    for item in content:
+                        if item["type"] == "text":
+                            content_parts.append({"text": item["text"]})
             
-            # 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={
+        # Form the request data
+        data = {
+            "contents": [{"parts": content_parts}],
+            "generationConfig": {
                 "temperature": temperature,
-                "max_output_tokens": payload.get("max_tokens", 1000),
-                "top_p": payload.get("top_p", 0.95),
+                "maxOutputTokens": max_tokens,
+                "topP": payload.get("top_p", 0.95),
             }
+        }
+        
+        headers = {
+            "Content-Type": "application/json",
+            "x-goog-api-key": api_key
+        }
+        
+        # Make the request
+        response = requests.post(
+            gemini_api_url,
+            headers=headers,
+            json=data,
+            timeout=30
         )
         
-        # Convert response to standard format
+        if response.status_code != 200:
+            error_msg = f"Google AI API error: {response.status_code} - {response.text}"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+            
+        # Parse response and convert to standard format
+        result = response.json()
+        text_content = ""
+        
+        # Extract text from response
+        if "candidates" in result and len(result["candidates"]) > 0:
+            candidate = result["candidates"][0]
+            if "content" in candidate and "parts" in candidate["content"]:
+                for part in candidate["content"]["parts"]:
+                    if "text" in part:
+                        text_content += part["text"]
+        
+        # Create a standardized response format
         return {
             "choices": [
                 {
                     "message": {
                         "role": "assistant",
-                        "content": response.text
+                        "content": text_content
                     }
                 }
             ]
         }
+        
     except Exception as e:
         logger.error(f"Google AI API error: {str(e)}")
         raise e