Update app.py

app.py

@@ -23,12 +23,21 @@ from model_suggestions import add_suggestion, get_suggestions_html
 from release_notes import get_release_notes_html
 
 
-# Initialize logging for errors and info
+# Update the logging format to redact URLs
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s'
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    filters=[lambda s: s.replace(config.API_URL, '[REDACTED]') if config.API_URL in s else s]
 )
 logger = logging.getLogger(__name__)
+# Add this at the top with other imports
+class RedactURLsFilter(logging.Filter):
+    def filter(self, record):
+        record.msg = record.msg.replace(config.NEXTCLOUD_URL, '[CLOUD_STORAGE]')
+        return super().filter(record)
+
+# Apply the filter to all loggers
+logging.getLogger().addFilter(RedactURLsFilter())
 
 # Start the backup thread
 start_backup_thread()
@@ -56,7 +65,7 @@ def call_ollama_api(model, prompt):
     )
     
     try:
-        logger.info(f"Starting API call for model {model}")
+        logger.info("Starting API call")
         response = client.chat.completions.create(
             model=model,
             messages=[
@@ -71,40 +80,56 @@ def call_ollama_api(model, prompt):
             ],
             timeout=180
         )
-        logger.info(f"Received response from model {model}")
+        logger.info("Received response")
         
         if not response or not response.choices:
-            logger.error(f"Empty response received from model {model}")
-            return f"Error: Empty response from the model"
+            logger.error("Empty response received")
+            return [
+                {"role": "user", "content": prompt},
+                {"role": "assistant", "content": "Error: Empty response from the model"}
+            ]
             
         content = response.choices[0].message.content
         if not content:
-            logger.error(f"Empty content received from model {model}")
-            return f"Error: Empty content from the model"
-        
-        # Log the raw content for debugging
-        logger.info(f"Raw content from {model}: {content[:200]}...")  # Log first 200 chars
+            logger.error("Empty content received")
+            return [
+                {"role": "user", "content": prompt},
+                {"role": "assistant", "content": "Error: Empty content from the model"}
+            ]
         
-        # Remove thinking tags and their content
+        # Extract thinking part and main content using regex
         import re
-        content = re.sub(r'<thinking>.*?</thinking>', '', content, flags=re.DOTALL)
-        
-        # Clean up any double newlines that might be left
-        content = re.sub(r'\n\s*\n', '\n', content.strip())
+        thinking_match = re.search(r'<think>(.*?)</think>', content, flags=re.DOTALL)
         
-        if not content.strip():
-            logger.error(f"Content empty after removing thinking tags for model {model}")
-            return f"Error: Empty content after processing from the model"
+        if thinking_match:
+            thinking_content = thinking_match.group(1).strip()
+            main_content = re.sub(r'<think>.*?</think>', '', content, flags=re.DOTALL).strip()
             
-        logger.info(f"Successfully processed response from model {model}")
-        return content
+            logger.info("Found thinking content, creating structured response")
+            return [
+                {"role": "user", "content": prompt},
+                {"role": "assistant", "content": f"{main_content}\n\n<details><summary>🤔 View thinking process</summary>\n\n{thinking_content}\n\n</details>"}
+            ]
+        
+        # If no thinking tags, return normal content
+        logger.info("No thinking tags found, returning normal content")
+        return [
+            {"role": "user", "content": prompt},
+            {"role": "assistant", "content": content.strip()}
+        ]
         
     except requests.exceptions.Timeout:
-        logger.error(f"Timeout error for model {model} after 180 seconds")
-        return f"Error: Model response timed out after 180 seconds"
+        logger.error("Timeout error after 180 seconds")
+        return [
+            {"role": "user", "content": prompt},
+            {"role": "assistant", "content": "Error: Model response timed out after 180 seconds"}
+        ]
     except Exception as e:
-        logger.error(f"Error calling Ollama API for model {model}: {str(e)}", exc_info=True)
-        return f"Error: Unable to get response from the model. Error: {str(e)}"
+        logger.error(f"Error calling Ollama API: {str(e)}", exc_info=True)
+        return [
+            {"role": "user", "content": prompt},
+            {"role": "assistant", "content": f"Error: Unable to get response from the model. Error: {str(e)}"}
+        ]
 
 # Generate responses using two randomly selected models
 def get_battle_counts():
@@ -117,7 +142,13 @@ def get_battle_counts():
 def generate_responses(prompt):
     available_models = get_available_models()
     if len(available_models) < 2:
-        return "Error: Not enough models available", "Error: Not enough models available", None, None
+        return [
+            {"role": "user", "content": prompt},
+            {"role": "assistant", "content": "Error: Not enough models available"}
+        ], [
+            {"role": "user", "content": prompt},
+            {"role": "assistant", "content": "Error: Not enough models available"}
+        ], None, None
     
     battle_counts = get_battle_counts()
     
@@ -142,16 +173,20 @@ def generate_responses(prompt):
     # Update recent opponents
     update_recent_opponents(model_a, model_b)
     
-    model_a_response = call_ollama_api(model_a, prompt)
-    model_b_response = call_ollama_api(model_b, prompt)
+    # Get responses from both models
+    response_a = call_ollama_api(model_a, prompt)
+    response_b = call_ollama_api(model_b, prompt)
     
-    return model_a_response, model_b_response, model_a, model_b
+    # Return responses directly (already formatted correctly)
+    return response_a, response_b, model_a, model_b
 
 def battle_arena(prompt):
     response_a, response_b, model_a, model_b = generate_responses(prompt)
     
     # Check for API errors in responses
-    if "Error: Unable to get response from the model" in response_a or "Error: Unable to get response from the model" in response_b:
+    if any("Error: Unable to get response from the model" in msg["content"] 
+           for msg in response_a + response_b 
+           if msg["role"] == "assistant"):
         return (
             [], [], None, None,
             gr.update(value=[]),
@@ -168,21 +203,12 @@ def battle_arena(prompt):
     nickname_a = random.choice(config.model_nicknames)
     nickname_b = random.choice(config.model_nicknames)
     
-    # Format responses for gr.Chatbot, including the user's prompt
-    response_a_formatted = [
-        {"role": "user", "content": prompt},
-        {"role": "assistant", "content": response_a}
-    ]
-    response_b_formatted = [
-        {"role": "user", "content": prompt},
-        {"role": "assistant", "content": response_b}
-    ]
-    
+    # The responses are already in the correct format, no need to reformat
     if random.choice([True, False]):
         return (
-            response_a_formatted, response_b_formatted, model_a, model_b,
-            gr.update(label=nickname_a, value=response_a_formatted),
-            gr.update(label=nickname_b, value=response_b_formatted),
+            response_a, response_b, model_a, model_b,
+            gr.update(label=nickname_a, value=response_a),
+            gr.update(label=nickname_b, value=response_b),
             gr.update(interactive=True, value=f"Vote for {nickname_a}"),
             gr.update(interactive=True, value=f"Vote for {nickname_b}"),
             gr.update(interactive=True, visible=True),
@@ -193,9 +219,9 @@ def battle_arena(prompt):
         )
     else:
         return (
-            response_b_formatted, response_a_formatted, model_b, model_a,
-            gr.update(label=nickname_a, value=response_b_formatted),
-            gr.update(label=nickname_b, value=response_a_formatted),
+            response_b, response_a, model_b, model_a,
+            gr.update(label=nickname_a, value=response_b),
+            gr.update(label=nickname_b, value=response_a),
             gr.update(interactive=True, value=f"Vote for {nickname_a}"),
             gr.update(interactive=True, value=f"Vote for {nickname_b}"),
             gr.update(interactive=True, visible=True),