Update app.py

app.py

@@ -16,7 +16,7 @@ class ChutesClient:
     """Client for interacting with Chutes API"""
     
     def __init__(self, api_key: str):
-        self.api_key = api_key
+        self.api_key = api_key or ""
         self.base_url = "https://llm.chutes.ai/v1"
         
     async def chat_completions_create(self, **kwargs) -> Dict:
@@ -58,8 +58,8 @@ class ChutesClient:
                                     chunk_json = json.loads(data)
                                     if "choices" in chunk_json and len(chunk_json["choices"]) > 0:
                                         delta = chunk_json["choices"][0].get("delta", {})
-                                        if "content" in delta:
-                                            content += delta["content"]
+                                        if "content" in delta and delta["content"]:
+                                            content += str(delta["content"])
                             except json.JSONDecodeError:
                                 continue
                     
@@ -97,14 +97,14 @@ class CreativeAgenticAI:
             chutes_api_key: Chutes API key
             model: Which model to use
         """
-        self.groq_api_key = groq_api_key or ""
-        self.chutes_api_key = chutes_api_key or ""
+        self.groq_api_key = str(groq_api_key) if groq_api_key else ""
+        self.chutes_api_key = str(chutes_api_key) if chutes_api_key else ""
         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":
             raise ValueError("No Chutes API key provided")
         
-        self.model = model
+        self.model = str(model) if model else "compound-beta"
         self.groq_client = Groq(api_key=self.groq_api_key) if self.groq_api_key else None
         self.chutes_client = ChutesClient(api_key=self.chutes_api_key) if self.chutes_api_key else None
         self.conversation_history = []
@@ -140,6 +140,11 @@ class CreativeAgenticAI:
         Returns:
             AI response with metadata
         """
+        # Safe string conversion
+        message = str(message) if message else ""
+        system_prompt = str(system_prompt) if system_prompt else ""
+        search_type = str(search_type) if search_type else "auto"
+        
         # Enhanced system prompt for better behavior
         if not system_prompt:
             if self.model == "openai/gpt-oss-20b":
@@ -158,9 +163,11 @@ IMPORTANT: When you search the web and find information, you MUST:
                 
                 domain_context = ""
                 if include_domains and self._supports_web_search():
-                    domain_context = f"\nYou are restricted to searching ONLY these domains: {', '.join(include_domains)}. Make sure to find and cite sources specifically from these domains."
+                    safe_domains = [str(d) for d in include_domains if d]
+                    domain_context = f"\nYou are restricted to searching ONLY these domains: {', '.join(safe_domains)}. Make sure to find and cite sources specifically from these domains."
                 elif exclude_domains and self._supports_web_search():
-                    domain_context = f"\nAvoid searching these domains: {', '.join(exclude_domains)}. Search everywhere else on the web."
+                    safe_domains = [str(d) for d in exclude_domains if d]
+                    domain_context = f"\nAvoid searching these domains: {', '.join(safe_domains)}. Search everywhere else on the web."
                 
                 search_instruction = ""
                 if search_type == "browser_search" and self._supports_browser_search():
@@ -192,10 +199,15 @@ IMPORTANT: When you search the web and find information, you MUST:
         if (include_domains or exclude_domains) and self._supports_web_search():
             filter_context = []
             if include_domains:
-                filter_context.append(f"ONLY search these domains: {', '.join(include_domains)}")
+                safe_domains = [str(d) for d in include_domains if d]
+                if safe_domains:
+                    filter_context.append(f"ONLY search these domains: {', '.join(safe_domains)}")
             if exclude_domains:
-                filter_context.append(f"EXCLUDE these domains: {', '.join(exclude_domains)}")
-            enhanced_message += f"\n\n[Domain Filtering: {' | '.join(filter_context)}]"
+                safe_domains = [str(d) for d in exclude_domains if d]
+                if safe_domains:
+                    filter_context.append(f"EXCLUDE these domains: {', '.join(safe_domains)}")
+            if filter_context:
+                enhanced_message += f"\n\n[Domain Filtering: {' | '.join(filter_context)}]"
         
         messages.append({"role": "user", "content": enhanced_message})
         
@@ -209,10 +221,14 @@ 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] 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()]
+            if include_domains:
+                safe_domains = [str(d).strip() for d in include_domains if d and str(d).strip()]
+                if safe_domains:
+                    params["include_domains"] = safe_domains
+            if exclude_domains:
+                safe_domains = [str(d).strip() for d in exclude_domains if d and str(d).strip()]
+                if safe_domains:
+                    params["exclude_domains"] = safe_domains
         
         # Add tools only for Groq models that support browser search
         tools = []
@@ -233,13 +249,23 @@ IMPORTANT: When you search the web and find information, you MUST:
                 params["stream"] = True
                 response = await self.chutes_client.chat_completions_create(**params)
                 # Handle Chutes response
-                content = response.get("choices", [{}])[0].get("message", {}).get("content", "No response content")
+                content = ""
+                if response and "choices" in response and response["choices"]:
+                    message_content = response["choices"][0].get("message", {}).get("content")
+                    content = str(message_content) if message_content else "No response content"
+                else:
+                    content = "No response received"
                 tool_calls = None
             else:
                 # 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 or ""
+                content = ""
+                if response and response.choices and response.choices[0].message:
+                    message_content = response.choices[0].message.content
+                    content = str(message_content) if message_content else "No response content"
+                else:
+                    content = "No response received"
                 tool_calls = response.choices[0].message.tool_calls if hasattr(response.choices[0].message, "tool_calls") else None
             
             # Extract tool usage information
@@ -302,18 +328,20 @@ IMPORTANT: When you search the web and find information, you MUST:
             if tools:
                 for tool in tools:
                     tool_dict = {
-                        "tool_type": getattr(tool, "type", "unknown"),
-                        "tool_name": getattr(tool, "name", "unknown"),
+                        "tool_type": str(getattr(tool, "type", "unknown")),
+                        "tool_name": str(getattr(tool, "name", "unknown")),
                     }
                     if hasattr(tool, "input"):
-                        tool_input = str(tool.input) if tool.input is not None else ""
-                        tool_dict["input"] = tool_input
+                        tool_input = getattr(tool, "input")
+                        tool_input_str = str(tool_input) if tool_input is not None else ""
+                        tool_dict["input"] = tool_input_str
                         if "search" in tool_dict["tool_name"].lower():
-                            tool_info["search_queries"].append(tool_input)
+                            tool_info["search_queries"].append(tool_input_str)
                     if hasattr(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_output = getattr(tool, "output")
+                        tool_output_str = str(tool_output) if tool_output is not None else ""
+                        tool_dict["output"] = tool_output_str
+                        urls = self._extract_urls(tool_output_str)
                         tool_info["sources_found"].extend(urls)
                     tool_info["tools_used"].append(tool_dict)
         
@@ -321,18 +349,25 @@ IMPORTANT: When you search the web and find information, you MUST:
         if tool_calls:
             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") if hasattr(tool_call, "function") else "browser_search",
-                    "tool_id": getattr(tool_call, "id", None)
+                    "tool_type": str(getattr(tool_call, "type", "browser_search")),
+                    "tool_name": "browser_search",
+                    "tool_id": str(getattr(tool_call, "id", "")) if getattr(tool_call, "id", None) else ""
                 }
-                if hasattr(tool_call, "function") and hasattr(tool_call.function, "arguments"):
-                    try:
-                        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(str(args["query"]))
-                    except:
-                        tool_dict["arguments"] = str(tool_call.function.arguments) if tool_call.function.arguments is not None else ""
+                if hasattr(tool_call, "function") and tool_call.function:
+                    tool_dict["tool_name"] = str(getattr(tool_call.function, "name", "browser_search"))
+                    if hasattr(tool_call.function, "arguments"):
+                        try:
+                            args_raw = tool_call.function.arguments
+                            if isinstance(args_raw, str):
+                                args = json.loads(args_raw)
+                            else:
+                                args = args_raw or {}
+                            tool_dict["arguments"] = args
+                            if "query" in args:
+                                tool_info["search_queries"].append(str(args["query"]))
+                        except:
+                            args_str = str(args_raw) if args_raw is not None else ""
+                            tool_dict["arguments"] = args_str
                 tool_info["tools_used"].append(tool_dict)
         
         return tool_info
@@ -341,39 +376,42 @@ IMPORTANT: When you search the web and find information, you MUST:
         """Extract URLs from text"""
         if not text:
             return []
+        text_str = str(text)
         url_pattern = r'https?://[^\s<>"]{2,}'
-        urls = re.findall(url_pattern, text)
+        urls = re.findall(url_pattern, text_str)
         return list(set(urls))
     
     def _enhance_citations(self, content: str, tool_info: Dict) -> str:
         """Enhance content with better citation formatting"""
         if not content:
             return ""
+        content_str = str(content)
         if not tool_info or not tool_info.get("sources_found"):
-            return content
+            return content_str
         
-        if "Sources Used:" not in content and "sources:" not in content.lower():
+        if "Sources Used:" not in content_str and "sources:" not in content_str.lower():
             sources_section = "\n\n---\n\n### Sources Used:\n"
             for i, url in enumerate(tool_info["sources_found"][:10], 1):
-                domain = self._extract_domain(url)
+                domain = self._extract_domain(str(url))
                 sources_section += f"{i}. [{domain}]({url})\n"
-            content += sources_section
+            content_str += sources_section
         
-        return content
+        return content_str
     
     def _extract_domain(self, url: str) -> str:
         """Extract domain name from URL for display"""
         if not url:
             return ""
+        url_str = str(url)
         try:
-            if url.startswith(('http://', 'https://')):
-                domain = url.split('/')[2]
+            if url_str.startswith(('http://', 'https://')):
+                domain = url_str.split('/')[2]
                 if domain.startswith('www.'):
                     domain = domain[4:]
                 return domain
-            return url
+            return url_str
         except:
-            return url
+            return url_str
     
     def get_model_info(self) -> Dict:
         """Get information about current model capabilities"""
@@ -401,15 +439,16 @@ 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 ""
+    # Handle None values and convert to strings
+    groq_api_key = str(groq_api_key) if groq_api_key else ""
+    chutes_api_key = str(chutes_api_key) if chutes_api_key else ""
+    model = str(model) if model else "compound-beta"
     
-    if model == "openai/gpt-oss-20b" and not chutes_api_key:
+    if model == "openai/gpt-oss-20b" and not chutes_api_key.strip():
         api_key_status = "Invalid ❌"
         return "❌ Please enter a valid Chutes API key for the selected model"
     
-    if model in ["compound-beta", "compound-beta-mini"] and not groq_api_key:
+    if model in ["compound-beta", "compound-beta-mini"] and not groq_api_key.strip():
         api_key_status = "Invalid ❌"
         return "❌ Please enter a valid Groq API key for the selected model"
     
@@ -452,6 +491,8 @@ def update_model(model: str) -> str:
     """Update the model selection"""
     global ai_instance
     
+    model = str(model) if model else "compound-beta"
+    
     if ai_instance:
         ai_instance.model = model
         model_info = ai_instance.get_model_info()
@@ -471,6 +512,7 @@ def get_search_options(model: str) -> gr.update:
     if not ai_instance:
         return gr.update(choices=["none"], value="none")
     
+    model = str(model) if model else "compound-beta"
     model_info = ai_instance.available_models.get(model, {})
     options = ["none"]
     
@@ -497,16 +539,18 @@ async def chat_with_ai(message: str,
     
     if not ai_instance:
         error_msg = "⚠️ Please set your API keys first!"
-        history.append([message, error_msg])
+        history.append([str(message) if message else "", error_msg])
         return history, ""
     
-    if not message or not message.strip():
-        return history, ""
+    # Convert all inputs to strings and handle None values
+    message = str(message) if message else ""
+    include_domains = str(include_domains) if include_domains else ""
+    exclude_domains = str(exclude_domains) if exclude_domains else ""
+    system_prompt = str(system_prompt) if system_prompt else ""
+    search_type = str(search_type) if search_type else "auto"
     
-    # Handle None values and empty strings
-    include_domains = include_domains or ""
-    exclude_domains = exclude_domains or ""
-    system_prompt = system_prompt or ""
+    if not message.strip():
+        return history, ""
     
     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 []
@@ -523,7 +567,7 @@ async def chat_with_ai(message: str,
             force_search=force_search
         )
         
-        ai_response = response["content"] or "No response received"
+        ai_response = str(response.get("content", "No response received"))
         
         # Add tool usage info for Groq models
         if response.get("tool_usage") and ai_instance.model != "openai/gpt-oss-20b":
@@ -537,7 +581,7 @@ async def chat_with_ai(message: str,
                 tool_summary.append(f"📄 Sources found: {len(tool_info['sources_found'])}")
             
             if tool_info.get("tools_used"):
-                tool_types = [tool.get("tool_type", "unknown") for tool in tool_info["tools_used"]]
+                tool_types = [str(tool.get("tool_type", "unknown")) for tool in tool_info["tools_used"]]
                 unique_types = list(set(tool_types))
                 tool_summary.append(f"🔧 Tools used: {', '.join(unique_types)}")
             
@@ -546,7 +590,7 @@ async def chat_with_ai(message: str,
         
         # Add search settings info
         search_info = []
-        if response.get("search_type_used") and response["search_type_used"] != "none":
+        if response.get("search_type_used") and str(response["search_type_used"]) != "none":
             search_info.append(f"🔍 Search type: {response['search_type_used']}")
         
         if force_search: