Update app.py

app.py

@@ -97,8 +97,8 @@ class CreativeAgenticAI:
             chutes_api_key: Chutes API key
             model: Which model to use
         """
-        self.groq_api_key = groq_api_key
-        self.chutes_api_key = chutes_api_key
+        self.groq_api_key = groq_api_key or ""
+        self.chutes_api_key = chutes_api_key or ""
         if not self.groq_api_key and model != "openai/gpt-oss-20b":
             raise ValueError("No Groq API key provided")
         if not self.chutes_api_key and model == "openai/gpt-oss-20b":
@@ -209,10 +209,10 @@ IMPORTANT: When you search the web and find information, you MUST:
         
         # Add domain filtering for compound models (Groq only)
         if self._supports_web_search():
-            if include_domains and include_domains[0].strip():
-                params["include_domains"] = [domain.strip() for domain in include_domains if domain.strip()]
-            if exclude_domains and exclude_domains[0].strip():
-                params["exclude_domains"] = [domain.strip() for domain in exclude_domains if domain.strip()]
+            if include_domains and include_domains[0] and include_domains[0].strip():
+                params["include_domains"] = [domain.strip() for domain in include_domains if domain and domain.strip()]
+            if exclude_domains and exclude_domains[0] and exclude_domains[0].strip():
+                params["exclude_domains"] = [domain.strip() for domain in exclude_domains if domain and domain.strip()]
         
         # Add tools only for Groq models that support browser search
         tools = []
@@ -239,7 +239,7 @@ IMPORTANT: When you search the web and find information, you MUST:
                 # Groq API call
                 params["max_completion_tokens"] = params.pop("max_tokens", None)
                 response = self.groq_client.chat.completions.create(**params)
-                content = response.choices[0].message.content
+                content = response.choices[0].message.content or ""
                 tool_calls = response.choices[0].message.tool_calls if hasattr(response.choices[0].message, "tool_calls") else None
             
             # Extract tool usage information
@@ -306,12 +306,12 @@ IMPORTANT: When you search the web and find information, you MUST:
                         "tool_name": getattr(tool, "name", "unknown"),
                     }
                     if hasattr(tool, "input"):
-                        tool_input = str(tool.input)
+                        tool_input = str(tool.input) if tool.input is not None else ""
                         tool_dict["input"] = tool_input
                         if "search" in tool_dict["tool_name"].lower():
                             tool_info["search_queries"].append(tool_input)
                     if hasattr(tool, "output"):
-                        tool_output = str(tool.output)
+                        tool_output = str(tool.output) if tool.output is not None else ""
                         tool_dict["output"] = tool_output
                         urls = self._extract_urls(tool_output)
                         tool_info["sources_found"].extend(urls)
@@ -322,7 +322,7 @@ IMPORTANT: When you search the web and find information, you MUST:
             for tool_call in tool_calls:
                 tool_dict = {
                     "tool_type": getattr(tool_call, "type", "browser_search"),
-                    "tool_name": getattr(tool_call, "function", {}).get("name", "browser_search"),
+                    "tool_name": getattr(tool_call, "function", {}).get("name", "browser_search") if hasattr(tool_call, "function") else "browser_search",
                     "tool_id": getattr(tool_call, "id", None)
                 }
                 if hasattr(tool_call, "function") and hasattr(tool_call.function, "arguments"):
@@ -330,21 +330,25 @@ IMPORTANT: When you search the web and find information, you MUST:
                         args = json.loads(tool_call.function.arguments) if isinstance(tool_call.function.arguments, str) else tool_call.function.arguments
                         tool_dict["arguments"] = args
                         if "query" in args:
-                            tool_info["search_queries"].append(args["query"])
+                            tool_info["search_queries"].append(str(args["query"]))
                     except:
-                        tool_dict["arguments"] = str(tool_call.function.arguments)
+                        tool_dict["arguments"] = str(tool_call.function.arguments) if tool_call.function.arguments is not None else ""
                 tool_info["tools_used"].append(tool_dict)
         
         return tool_info
     
     def _extract_urls(self, text: str) -> List[str]:
         """Extract URLs from text"""
+        if not text:
+            return []
         url_pattern = r'https?://[^\s<>"]{2,}'
         urls = re.findall(url_pattern, text)
         return list(set(urls))
     
     def _enhance_citations(self, content: str, tool_info: Dict) -> str:
         """Enhance content with better citation formatting"""
+        if not content:
+            return ""
         if not tool_info or not tool_info.get("sources_found"):
             return content
         
@@ -359,6 +363,8 @@ IMPORTANT: When you search the web and find information, you MUST:
     
     def _extract_domain(self, url: str) -> str:
         """Extract domain name from URL for display"""
+        if not url:
+            return ""
         try:
             if url.startswith(('http://', 'https://')):
                 domain = url.split('/')[2]
@@ -395,6 +401,10 @@ async def validate_api_keys(groq_api_key: str, chutes_api_key: str, model: str)
     """Validate both Groq and Chutes API keys and initialize AI instance"""
     global ai_instance, api_key_status
     
+    # Handle None values
+    groq_api_key = groq_api_key or ""
+    chutes_api_key = chutes_api_key or ""
+    
     if model == "openai/gpt-oss-20b" and not chutes_api_key:
         api_key_status = "Invalid ❌"
         return "❌ Please enter a valid Chutes API key for the selected model"
@@ -490,11 +500,16 @@ async def chat_with_ai(message: str,
         history.append([message, error_msg])
         return history, ""
     
-    if not message.strip():
+    if not message or not message.strip():
         return history, ""
     
-    include_list = [d.strip() for d in include_domains.split(",")] if include_domains.strip() else []
-    exclude_list = [d.strip() for d in exclude_domains.split(",")] if exclude_domains.strip() else []
+    # Handle None values and empty strings
+    include_domains = include_domains or ""
+    exclude_domains = exclude_domains or ""
+    system_prompt = system_prompt or ""
+    
+    include_list = [d.strip() for d in include_domains.split(",") if d.strip()] if include_domains.strip() else []
+    exclude_list = [d.strip() for d in exclude_domains.split(",") if d.strip()] if exclude_domains.strip() else []
     
     try:
         response = await ai_instance.chat(
@@ -508,7 +523,7 @@ async def chat_with_ai(message: str,
             force_search=force_search
         )
         
-        ai_response = response["content"]
+        ai_response = response["content"] or "No response received"
         
         # Add tool usage info for Groq models
         if response.get("tool_usage") and ai_instance.model != "openai/gpt-oss-20b":
@@ -971,7 +986,5 @@ def create_gradio_app():
 if __name__ == "__main__":
     app = create_gradio_app()
     app.launch(
-        share=True,
-        server_name="0.0.0.0",
-        server_port=7860
+        share=True
     )