Update app.py

app.py

@@ -335,61 +335,23 @@ 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):
-    """Wrapper function for send_to_model_impl with proper error handling."""
-    
     logging.info("send to model starting..")
     
     if not prompt or not prompt.strip():
         return "Error: No prompt provided", None
         
     try:
-            logging.info("sending to model preparation.")
-            
-            # Basic input validation
-            if model_selection not in ["Clipboard only", "HuggingFace Inference", "Groq API", "OpenAI ChatGPT"]:
-                return "Error: Invalid model selection", None
-                
-            # Model-specific validation
-            if model_selection == "HuggingFace Inference" and not hf_api_key:
-                return "Error: HuggingFace API key required", None
-            elif 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 e:
-                error_msg = str(e)
-                if not error_msg:  # Handle empty error messages
-                    error_msg = "Unknown error occurred"
-                return f"Error: {error_msg}", None
+        logging.info("sending to model preparation.")
+        
+        # Basic input validation
+        if model_selection not in ["Clipboard only", "HuggingFace Inference", "Groq API", "OpenAI ChatGPT"]:
+            return "Error: Invalid model selection", None
             
-    except Exception as e:
-        error_msg = str(e)
-        if not error_msg:  # Handle empty error messages
-            error_msg = "Unknown error occurred"
-        logging.error(f"Error in send_to_model: {error_msg}")
-        return f"Error: {error_msg}", None
+        # Model-specific validation - remove HF key check
+        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
 
 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):
@@ -434,19 +396,40 @@ def send_to_model_impl(prompt, model_selection, hf_model_choice, hf_custom_model
         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) -> str:
-    """Send prompt to HuggingFace Inference API with better error handling."""
+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)
-        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)
+        # First try without authentication
+        try:
+            client = InferenceClient()  # No token
+            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 public_error:
+            logging.info(f"Public inference failed: {public_error}")
+            
+            # If that fails and we have an API key, try with authentication
+            if api_key:
+                client = InferenceClient(token=api_key)
+                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)
+            else:
+                # If we don't have an API key, inform the user they need one
+                return "Error: This model requires authentication. Please enter your HuggingFace API key."
+                
     except Exception as e:
         logging.error(f"HuggingFace inference error: {e}")
         return f"Error with HuggingFace inference: {str(e)}"