Update app.py

app.py

@@ -89,6 +89,20 @@ MODEL_CONTEXT_SIZES = {
         "llama-3.1-70b-specdec": 131072,
         "llama-3.2-1b-preview": 131072,
         "llama-3.2-3b-preview": 131072,
+    },
+    "Cohere API": {
+        "command-r-plus-08-2024": 131072,  # 128k
+        "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,
     }
 }
 
@@ -335,7 +349,9 @@ def build_prompts(snippets: List[str], prompt_instruction: str, custom_prompt: O
 
 def send_to_model(prompt, model_selection, hf_model_choice, hf_custom_model, hf_api_key,
                  groq_model_choice, groq_api_key, openai_api_key, openai_model_choice):
-    logging.info("send to model starting..")
+    """Wrapper function for send_to_model_impl with comprehensive error handling."""
+    
+    logging.info("send to model starting...")
     
     if not prompt or not prompt.strip():
         return "Error: No prompt provided", None
@@ -344,27 +360,69 @@ def send_to_model(prompt, model_selection, hf_model_choice, hf_custom_model, hf_
         logging.info("sending to model preparation.")
         
         # Basic input validation
-        if model_selection not in ["Clipboard only", "HuggingFace Inference", "Groq API", "OpenAI ChatGPT"]:
+        valid_selections = ["Clipboard only", "HuggingFace Inference", "Groq API", "OpenAI ChatGPT", "Cohere API"]
+        if model_selection not in valid_selections:
             return "Error: Invalid model selection", None
             
-        # Model-specific validation - remove HF key check
+        # Model-specific validation
         if model_selection == "Groq API" and not groq_api_key:
             return "Error: Groq API key required", None
         elif model_selection == "OpenAI ChatGPT" and not openai_api_key:
             return "Error: OpenAI API key required", None
+            
+        # Call implementation with error handling
+        try:
+            logging.info("calling send_to_model_impl.")
+            summary, download_file = send_to_model_impl(
+                prompt=prompt.strip(),
+                model_selection=model_selection,
+                hf_model_choice=hf_model_choice,
+                hf_custom_model=hf_custom_model,
+                hf_api_key=hf_api_key,
+                groq_model_choice=groq_model_choice,
+                groq_api_key=groq_api_key,
+                openai_api_key=openai_api_key,
+                openai_model_choice=openai_model_choice
+            )
+            logging.info("summary received:", summary)
+            
+            if summary is None or not isinstance(summary, str):
+                return "Error: No response from model", None
+                
+            return summary, download_file
+                
+        except Exception as impl_error:
+            error_msg = str(impl_error)
+            if not error_msg:
+                error_msg = "Unknown error occurred in model implementation"
+            logging.error(f"Model implementation error: {error_msg}")
+            return f"Error: {error_msg}", None
+            
+    except Exception as e:
+        error_msg = str(e)
+        if not error_msg:
+            error_msg = "Unknown error occurred"
+        logging.error(f"Error in send_to_model: {error_msg}")
+        return f"Error: {error_msg}", None
+    finally:
+        logging.info("send to model completed.")
 
 def send_to_model_impl(prompt, model_selection, hf_model_choice, hf_custom_model, hf_api_key,
                       groq_model_choice, groq_api_key, openai_api_key, openai_model_choice):
     """Implementation of model sending with improved error handling."""
     logging.info("send to model impl commencing...")
     
-    if model_selection == "Clipboard only":
-        return "Text copied to clipboard. Use paste for processing.", None
-
     try:
+        if model_selection == "Clipboard only":
+            return "Text copied to clipboard. Use paste for processing.", None
+
         if model_selection == "HuggingFace Inference":
+            # First try without API key
             model_id = hf_custom_model if hf_model_choice == "Custom Model" else model_registry.hf_models[hf_model_choice]
-            summary = send_to_hf_inference(prompt, model_id, hf_api_key)
+            summary = send_to_hf_inference(prompt, model_id)
+            if summary.startswith("Error"):
+                if hf_api_key:  # If first try failed and we have an API key, try with it
+                    summary = send_to_hf_inference(prompt, model_id, hf_api_key)
             
         elif model_selection == "Groq API":
             summary = send_to_groq(prompt, groq_model_choice, groq_api_key)
@@ -372,12 +430,13 @@ def send_to_model_impl(prompt, model_selection, hf_model_choice, hf_custom_model
         elif model_selection == "OpenAI ChatGPT":
             summary = send_to_openai(prompt, openai_api_key, model=openai_model_choice)
             
+        elif model_selection == "Cohere API":
+            summary = send_to_cohere(prompt)
+        
         else:
             return "Error: Invalid model selection", None
 
         # Validate response
-        logging.info("model told us:", summary)
-
         if not summary or not isinstance(summary, str):
             return "Error: Invalid response from model", None
             
@@ -391,12 +450,29 @@ def send_to_model_impl(prompt, model_selection, hf_model_choice, hf_custom_model
 
     except Exception as e:
         error_msg = str(e)
-        if not error_msg:  # Handle empty error messages
+        if not error_msg:
             error_msg = "Unknown error occurred"
         logging.error(f"Error in send_to_model_impl: {error_msg}")
         return f"Error: {error_msg}", None
-
+    
 def send_to_hf_inference(prompt: str, model_name: str, api_key: str = None) -> str:
+    """Send prompt to HuggingFace Inference API with optional authentication."""
+    try:
+        client = InferenceClient(token=api_key) if api_key else InferenceClient()
+        response = client.text_generation(
+            prompt,
+            model=model_name,
+            max_new_tokens=500,
+            temperature=0.7,
+            top_p=0.95,
+            repetition_penalty=1.1
+        )
+        return str(response)
+    except Exception as e:
+        logging.error(f"HuggingFace inference error: {e}")
+        return f"Error with HuggingFace inference: {str(e)}"  # Return error message instead of raising
+
+def send_to_hf_inference_old(prompt: str, model_name: str, api_key: str = None) -> str:
     """Send prompt to HuggingFace Inference API with optional authentication."""
     try:
         # First try without authentication
@@ -451,17 +527,13 @@ def send_to_groq(prompt: str, model_name: str, api_key: str) -> str:
         return response.choices[0].message.content
     except Exception as e:
         logging.error(f"Groq API error: {e}")
-        return f"Error with Groq API: {str(e)}"
+        raise  # Re-raise to be handled by caller
 
 def send_to_openai(prompt: str, api_key: str, model: str = "gpt-3.5-turbo") -> str:
-    """Send prompt to OpenAI API using the new v1.0+ client format."""
+    """Send prompt to OpenAI API."""
     try:
-        from openai import OpenAI  # Import the new client
-        
-        # Initialize the client with the API key
+        from openai import OpenAI
         client = OpenAI(api_key=api_key)
-        
-        # Create chat completion using new format
         response = client.chat.completions.create(
             model=model,
             messages=[
@@ -473,17 +545,37 @@ def send_to_openai(prompt: str, api_key: str, model: str = "gpt-3.5-turbo") -> s
             top_p=0.95
         )
         
-        # Extract the response content
         if response.choices and len(response.choices) > 0:
             return response.choices[0].message.content
         else:
-            return "Error: No response generated"
+            raise Exception("No response generated")
             
     except ImportError:
-        return "Error: Please install the latest version of openai package (pip install --upgrade openai)"
+        raise Exception("Please install the latest version of openai package (pip install --upgrade openai)")
     except Exception as e:
         logging.error(f"OpenAI API error: {e}")
-        return f"Error with OpenAI API: {str(e)}"
+        raise  # Re-raise to be handled by caller
+    
+def send_to_cohere(prompt: str, api_key: str = None) -> str:
+    """Send prompt to Cohere API with optional authentication."""
+    try:
+        import cohere
+        client = cohere.Client(api_key) if api_key else cohere.Client()
+        
+        response = client.chat(
+            message=prompt,
+            temperature=0.7,
+            max_tokens=500,
+        )
+        
+        if hasattr(response, 'text'):
+            return response.text
+        else:
+            return "Error: No response text from Cohere"
+            
+    except Exception as e:
+        logging.error(f"Cohere API error: {e}")
+        return f"Error with Cohere API: {str(e)}"  # Return error message instead of raising
 
 def copy_text_js(element_id: str) -> str:
     return f"""function() {{