Update app.py

app.py

@@ -153,7 +153,7 @@ class ModelRegistry:
    def __init__(self):
        # HuggingFace Models
        self.hf_models = {
-            "Mixtral 7B": "mistralai/Mistral-7B-Instruct-v0.3",  # works well
+            "Mistral 7B": "mistralai/Mistral-7B-Instruct-v0.3",  # works well
             "Nous-Hermes": "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO",  # works well
             "Zephyr 7B": "HuggingFaceH4/zephyr-7b-beta",  # works
             "Phi-3.5 Mini": "microsoft/Phi-3.5-mini-instruct",  # works but poor results
@@ -400,16 +400,16 @@ def send_to_model(prompt, model_selection, hf_model_choice, hf_custom_model, hf_
     logging.info("send to model starting...")
     
     if not prompt or not prompt.strip():
-        return "Error: No prompt provided", None
+        return gr.HTML(""), "Error: No prompt provided", None
         
     try:
         logging.info("sending to model preparation.")
         
         # Basic input validation
         valid_selections = ["Clipboard only", "HuggingFace Inference", "Groq API", 
-                          "OpenAI ChatGPT", "Cohere API", "GLHF API"]
+                            "OpenAI ChatGPT", "Cohere API", "GLHF API"]
         if model_selection not in valid_selections:
-            return "Error: Invalid model selection", None
+            return gr.HTML(""), "Error: Invalid model selection", None
 
         # Check environment API keys
         env_api_keys = {
@@ -425,71 +425,45 @@ def send_to_model(prompt, model_selection, hf_model_choice, hf_custom_model, hf_
             
         # Model-specific validation - check only required keys
         if model_selection == "Groq API" and not groq_api_key:
-            if env_api_keys["GROQ_API_KEY"]:
-                groq_api_key = env_api_keys["GROQ_API_KEY"]
-            else:
-                return "Error: Groq API key required", None
+            groq_api_key = env_api_keys.get("GROQ_API_KEY")
+            if not groq_api_key:
+                return gr.HTML(""), "Error: Groq API key required", None
                 
         elif model_selection == "OpenAI ChatGPT" and not openai_api_key:
-            if env_api_keys["OPENAI_API_KEY"]:
-                openai_api_key = env_api_keys["OPENAI_API_KEY"]
-            else:
-                return "Error: OpenAI API key required", None
+            openai_api_key = env_api_keys.get("OPENAI_API_KEY")
+            if not openai_api_key:
+                return gr.HTML(""), "Error: OpenAI API key required", None
                 
         elif model_selection == "GLHF API" and not glhf_api_key:
-            if env_api_keys["GLHF_API_KEY"]:
-                glhf_api_key = env_api_keys["GLHF_API_KEY"]
-            else:
-                return "Error: GLHF API key required", None
-            
-        # Try implementation
-        try:
-            logging.info("calling send_to_model_impl.")
-            
-            # Use rate limits only with environment API keys
-            use_rate_limits = {
-                "Groq API": groq_api_key == env_api_keys["GROQ_API_KEY"],
-                "OpenAI ChatGPT": openai_api_key == env_api_keys["OPENAI_API_KEY"],
-                "Cohere API": cohere_api_key == env_api_keys["COHERE_API_KEY"],
-                "GLHF API": glhf_api_key == env_api_keys["GLHF_API_KEY"]
-            }.get(model_selection, False)
-            
-            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,
-                cohere_api_key=cohere_api_key or env_api_keys["COHERE_API_KEY"],
-                cohere_model=cohere_model,
-                glhf_api_key=glhf_api_key,
-                glhf_model=glhf_model,
-                glhf_custom_model=glhf_custom_model,
-                use_rate_limits=use_rate_limits
-            )
+            glhf_api_key = env_api_keys.get("GLHF_API_KEY")
+            if not glhf_api_key:
+                return gr.HTML(""), "Error: GLHF API key required", None
             
-            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
+        # Call the implementation function
+        clipboard_status, 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,
+            cohere_api_key=cohere_api_key or env_api_keys.get("COHERE_API_KEY"),
+            cohere_model=cohere_model,
+            glhf_api_key=glhf_api_key,
+            glhf_model=glhf_model,
+            glhf_custom_model=glhf_custom_model,
+            use_rate_limits=False  # Adjust based on your needs
+        )
+        
+        return clipboard_status, summary, download_file
             
     except Exception as e:
-        error_msg = str(e)
-        if not error_msg:
-            error_msg = "Unknown error occurred"
+        error_msg = str(e) or "Unknown error occurred"
         logging.error(f"Error in send_to_model: {error_msg}")
-        return f"Error: {error_msg}", None
+        return gr.HTML(f"Error: {error_msg}"), f"Error: {error_msg}", None
     finally:
         logging.info("send to model completed.")
 
@@ -604,7 +578,7 @@ def send_to_model_impl(prompt, model_selection, hf_model_choice, hf_custom_model
                 f.write(summary)
                 return summary, f.name
                 
-        return summary, None
+        return gr.HTML(""), summary, download_file
 
     except Exception as e:
         error_msg = str(e)
@@ -986,7 +960,8 @@ with gr.Blocks(css="""
                     hf_model = gr.Dropdown(
                         choices=list(model_registry.hf_models.keys()),
                         label="🔧 HuggingFace Model",
-                        value="Phi-3 Mini 4K"
+                        value="Mistral 7B",
+                        allow_custom_value=True
                     )
                     hf_custom_model = gr.Textbox(  # This needs to be defined before being used
                         label="Custom Model ID",
@@ -1230,7 +1205,7 @@ with gr.Blocks(css="""
                     gr.update(visible=False),  # cohere_options
                     gr.update(visible=False),  # glhf_options
                     gr.update(value=ctx_size), # context_size
-                    gr.Dropdown(choices=model_choices, value="Mixtral 7B")  # Update default value
+                    gr.Dropdown(choices=model_choices, value="Mistral 7B")  # Update default value
                 ]
             elif choice == "Groq API":
                 model_choices = list(model_registry.groq_models.keys())
@@ -1446,9 +1421,9 @@ with gr.Blocks(css="""
             glhf_custom_model
         ],
         outputs=[
-            clipboard_status,  # status display for clipboard operations
-            summary_output,
-            download_summary
+            clipboard_status,  # HTML component for clipboard status
+            summary_output,    # Textbox for summary
+            download_summary   # File component for download
         ]
     )