Update app.py

app.py

@@ -7,8 +7,6 @@ import threading
 from datetime import datetime
 import html
 import re
-import base64
-import io
 
 class ReasoningOrchestra:
     def __init__(self):
@@ -22,6 +20,7 @@ class ReasoningOrchestra:
         
         try:
             self.client = Groq(api_key=api_key.strip())
+            # Test the connection with a simple request
             test_completion = self.client.chat.completions.create(
                 model="qwen/qwen3-32b",
                 messages=[{"role": "user", "content": "Hello"}],
@@ -34,31 +33,30 @@ class ReasoningOrchestra:
             return f"❌ API key validation failed: {str(e)}"
     
     def format_text_to_html(self, text: str) -> str:
-        """Convert text to HTML with enhanced formatting for clarity"""
+        """Convert text to HTML with proper formatting"""
         if not text or text.strip() == "" or text == "No response generated":
-            return """
-            <div style='color: #6b7280; font-style: italic; font-size: 16px; padding: 15px; background-color: #f3f4f6; border-radius: 8px;'>
-                No content was generated. This might be due to API limitations or model availability issues.
-            </div>
-            """
+            return "<p style='color: #666; font-style: italic;'>No content was generated. This might be due to API limitations or model availability issues.</p>"
         
-        # Escape HTML characters
+        # Escape HTML characters first
         text = html.escape(text)
         
         # Convert markdown-style formatting to HTML
-        text = re.sub(r'^### (.*$)', r'<h3 style="font-size: 20px; color: #1f2937; margin: 20px 0 10px;">\1</h3>', text, flags=re.MULTILINE)
-        text = re.sub(r'^## (.*$)', r'<h2 style="font-size: 24px; color: #1f2937; margin: 24px 0 12px;">\1</h2>', text, flags=re.MULTILINE)
-        text = re.sub(r'^# (.*$)', r'<h1 style="font-size: 28px; color: #1f2937; margin: 28px 0 14px;">\1</h1>', text, flags=re.MULTILINE)
+        # Headers
+        text = re.sub(r'^### (.*$)', r'<h3>\1</h3>', text, flags=re.MULTILINE)
+        text = re.sub(r'^## (.*$)', r'<h2>\1</h2>', text, flags=re.MULTILINE)
+        text = re.sub(r'^# (.*$)', r'<h1>\1</h1>', text, flags=re.MULTILINE)
+        
+        # Bold text
+        text = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', text)
         
-        # Bold and italic text
-        text = re.sub(r'\*\*(.*?)\*\*', r'<strong style="font-weight: 700;">\1</strong>', text)
-        text = re.sub(r'\*(.*?)\*', r'<em style="font-style: italic;">\1</em>', text)
+        # Italic text
+        text = re.sub(r'\*(.*?)\*', r'<em>\1</em>', text)
         
-        # Code blocks with enhanced styling
-        text = re.sub(r'```(.*?)```', r'<pre style="background-color: #f8f9fa; padding: 15px; border-radius: 8px; border: 1px solid #e5e7eb; overflow-x: auto;"><code style="font-family: Consolas, monospace; font-size: 14px; color: #1f2937;">\1</code></pre>', text, flags=re.DOTALL)
-        text = re.sub(r'`(.*?)`', r'<code style="font-family: Consolas, monospace; font-size: 14px; background-color: #f3f4f6; padding: 2px 6px; border-radius: 4px;">\1</code>', text)
+        # Code blocks
+        text = re.sub(r'```(.*?)```', r'<pre><code>\1</code></pre>', text, flags=re.DOTALL)
+        text = re.sub(r'`(.*?)`', r'<code>\1</code>', text)
         
-        # Lists with better spacing
+        # Lists
         lines = text.split('\n')
         in_list = False
         formatted_lines = []
@@ -67,20 +65,20 @@ class ReasoningOrchestra:
             stripped = line.strip()
             if stripped.startswith('- ') or stripped.startswith('* '):
                 if not in_list:
-                    formatted_lines.append('<ul style="list-style-type: disc; margin: 15px 0; padding-left: 30px;">')
+                    formatted_lines.append('<ul>')
                     in_list = True
-                formatted_lines.append(f'<li style="margin-bottom: 8px; font-size: 16px;">{stripped[2:]}</li>')
+                formatted_lines.append(f'<li>{stripped[2:]}</li>')
             elif stripped.startswith(('1. ', '2. ', '3. ', '4. ', '5. ', '6. ', '7. ', '8. ', '9. ')):
                 if not in_list:
-                    formatted_lines.append('<ol style="list-style-type: decimal; margin: 15px 0; padding-left: 30px;">')
+                    formatted_lines.append('<ol>')
                     in_list = True
-                formatted_lines.append(f'<li style="margin-bottom: 8px; font-size: 16px;">{stripped[3:]}</li>')
+                formatted_lines.append(f'<li>{stripped[3:]}</li>')
             else:
                 if in_list:
                     formatted_lines.append('</ul>' if any('<li>' in line for line in formatted_lines[-5:]) else '</ol>')
                     in_list = False
                 if stripped:
-                    formatted_lines.append(f'<p style="font-size: 16px; line-height: 1.6; margin: 12px 0; color: #1f2937;">{line}</p>')
+                    formatted_lines.append(f'<p>{line}</p>')
                 else:
                     formatted_lines.append('<br>')
         
@@ -177,342 +175,6 @@ Please conduct a thorough investigation including:
 4. Historical context or precedents
 5. Comprehensive pros and cons
 6. Hidden connections or implications
-Be extremely thorough and leave no stone unturned. Provide detailed evidence and reasoning for your conclusions."""
-
-        try:
-            completion = self.client.chat.completions.create(
-                model="qwen-qwq-32b",
-                messages=[{"role": "user", "content": prompt}],
-                temperature=0.7,
-                top_p=0.9,
-                max_completion_tokens=8192
-            )
-            
-            response_content = completion.choices[0].message.content
-            if not response_content or response_content.strip() == "":
-                fallback_prompt = f"Analyze this problem in detail: {problem}"
-                fallback_completion = self.client.chat.completions.create(
-                    model="qwen-qwq-32b",
-                    messages=[{"role": "user", "content": fallback_prompt}],
-                    temperature=0.5,
-                    max_completion_tokens=8192
-                )
-                response_content = fallback_completion.choices[0].message.content
-                
-                if not response_content or response_content.strip() == "":
-                    response_content = "The QwQ model encountered an issue generating content. This could be due to the complexity of the prompt, content filtering, or temporary model availability issues. The model may work better with simpler, more direct questions."
-            
-            return {
-                "model": "QwQ 32B (Detail Detective)",
-                "role": "🔍 The Meticulous Investigator",
-                "reasoning": response_content,
-                "timestamp": datetime.now().strftime("%H:%M:%S"),
-                "tokens_used": getattr(completion.usage, 'total_tokens', 'N/A') if hasattr(completion, 'usage') and completion.usage else "N/A"
-            }
-        except Exception as e:
-            error_msg = f"Detail Detective error: {str(e)}"
-            if "model" in str(e).lower() or "not found" in str(e).lower():
-                error_msg += "\n\nNote: The QwQ model may not be available in your region or may have usage restrictions. You can still use the other models in the orchestra."
-            return {"error": error_msg}
-    
-    def synthesize_orchestra(self, deep_result: Dict, strategic_result: Dict, detective_result: Dict, original_problem: str) -> str:
-        """Synthesize all three perspectives into a final orchestrated solution using Llama 3.3 70B"""
-        if not self.is_api_key_set:
-            return "API key not set"
-        
-        def extract_reasoning(result: Dict, model_name: str) -> str:
-            if result.get('error'):
-                return f"**{model_name} encountered an issue:** {result['error']}"
-            reasoning = result.get('reasoning', '')
-            if not reasoning or reasoning.strip() == "" or reasoning == "No response generated":
-                return f"**{model_name}** did not provide analysis (this may be due to model limitations or API issues)."
-            return reasoning
-        
-        deep_reasoning = extract_reasoning(deep_result, "Deep Thinker")
-        strategic_reasoning = extract_reasoning(strategic_result, "Quick Strategist")
-        detective_reasoning = extract_reasoning(detective_result, "Detail Detective")
-        
-        synthesis_prompt = f"""You are the Orchestra Conductor using Llama 3.3 70B Versatile model. You have received analytical perspectives from three different AI reasoning specialists on the same problem. Your job is to synthesize these into a comprehensive, unified solution.
-ORIGINAL PROBLEM: {original_problem}
-DEEP THINKER ANALYSIS (🎭 DeepSeek R1):
-{deep_reasoning}
-STRATEGIC ANALYSIS (🚀 Qwen3 32B):
-{strategic_reasoning}
-DETECTIVE INVESTIGATION (🔍 QwQ 32B):
-{detective_reasoning}
-As the Orchestra Conductor, please create a unified synthesis that:
-1. Combines the best insights from all available analyses
-2. Addresses any gaps where models didn't provide input
-3. Resolves any contradictions between the analyses
-4. Provides a comprehensive final recommendation
-5. Highlights where the different reasoning styles complement each other
-6. Gives a clear, actionable conclusion
-If some models didn't provide analysis, work with what's available and note any limitations.
-Format your response as a well-structured final solution that leverages all available reasoning approaches. Use clear sections and bullet points where appropriate for maximum clarity."""
-
-        try:
-            completion = self.client.chat.completions.create(
-                model="llama-3.3-70b-versatile",
-                messages=[{"role": "user", "content": synthesis_prompt}],
-                temperature=0.7,
-                max_completion_tokens=8192,
-                top_p=0.9
-            )
-            
-            synthesis_content = completion.choices[0].message.content
-            if not synthesis_content or synthesis_content.strip() == "":
-                return "The synthesis could not be generated. This may be due to API limitations or the complexity of combining the different analyses."
-            
-            return synthesis_content
-        except Exception as e:
-            return f"Synthesis error: {str(e)}"
-
-# Initialize the orchestra
-orchestra = ReasoningOrchestra()
-
-def validate_api_key(api_key: str) -> str:
-    """Validate the API key and return status"""
-    return orchestra.set_api_key(api_key)
-
-def create_download_file(html_content: str, filename: str) -> gr.File:
-    """Create a downloadable HTML file from content"""
-    html_wrapper = f"""
-    <!DOCTYPE html>
-    <html lang="en">
-    <head>
-        <meta charset="UTF-8">
-        <meta name="viewport" content="width=device-width, initial-scale=1.0">
-        <title>{filename}</title>
-        <style>
-            body {{
-                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
-                line-height: 1.6;
-                color: #1f2937;
-                max-width: 800px;
-                margin: 40px auto;
-                padding: 0 20px;
-            }}
-            h1, h2, h3 {{
-                color: #1f2937;
-            }}
-            pre {{
-                background-color: #f8f9fa;
-                padding: 15px;
-                border-radius: 8px;
-                border: 1px solid #e5e7eb;
-                overflow-x: auto;
-            }}
-            code {{
-                font-family: Consolas, monospace;
-                font-size: 14px;
-            }}
-            p, li {{
-                font-size: 16px;
-                margin: 12px 0;
-            }}
-            ul, ol {{
-                margin: 15px 0;
-                padding-left: 30px;
-            }}
-            .error {{
-                color: #dc3545;
-                padding: 15px;
-                background-color: #ffe6e6;
-                border-radius: 8px;
-            }}
-        </style>
-    </head>
-    <body>
-        {html_content}
-    </body>
-    </html>
-    """
-    buffer = io.BytesIO(html_wrapper.encode('utf-8'))
-    return gr.File(value=buffer, file_name=f"{filename}.html", label=f"Download {filename}")
-
-def run_single_model(problem: str, model_choice: str, context: str = "") -> Tuple[str, Optional[gr.File]]:
-    """Run a single model analysis with downloadable HTML"""
-    if not orchestra.is_api_key_set:
-        return ("""
-        <div style="color: #dc3545; padding: 20px; border: 2px solid #dc3545; border-radius: 10px; background-color: #ffe6e6;">
-            <h3>❌ API Key Required</h3>
-            <p>Please set your Groq API key first in the API Configuration section above.</p>
-        </div>
-        """, None)
-    
-    if not problem.strip():
-        return ("""
-        <div style="color: #fd7e14; padding: 20px; border: 2px solid #fd7e14; border-radius: 10px; background-color: #fff3e6;">
-            <h3>⚠️ Problem Required</h3>
-            <p>Please enter a problem to analyze.</p>
-        </div>
-        """, None)
-    
-    start_time = time.time()
-    
-    if model_choice == "Deep Thinker (DeepSeek R1)":
-        result = orchestra.deep_thinker_analyze(problem, context)
-        filename = "deep_thinker_analysis"
-    elif model_choice == "Quick Strategist (Qwen3 32B)":
-        result = orchestra.quick_strategist_analyze(problem, context)
-        filename = "quick_strategist_analysis"
-    elif model_choice == "Detail Detective (QwQ 32B)":
-        result = orchestra.detail_detective_analyze(problem, context)
-        filename = "detail_detective_analysis"
-    else:
-        return ("""
-        <div style="color: #dc3545; padding: 20px; border: 2px solid #dc3545; border-radius: 10px; background-color: #ffe6e6;">
-            <h3>❌ Invalid Model Selection</h3>
-            <p>Please select a valid model from the dropdown.</p>
-        </div>
-        """, None)
-    
-    elapsed_time = time.time() - start_time
-    
-    if "error" in result:
-        return (f"""
-        <div style="color: #dc3545; padding: 20px; border: 2px solid #dc3545; border-radius: 10px; background-color: #ffe6e6;">
-            <h3>❌ Error</h3>
-            <p>{result['error']}</p>
-        </div>
-        """, None)
-    
-    reasoning_html = orchestra.format_text_to_html(result['reasoning'])
-    
-    formatted_output = f"""
-    <div style="border: 2px solid #28a745; border-radius: 15px; padding: 25px; margin: 15px 0; background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%);">
-        <div style="display: flex; align-items: center; margin-bottom: 20px; padding-bottom: 15px; border-bottom: 2px solid #28a745;">
-            <h2 style="margin: 0; color: #28a745; font-size: 24px;">{result['role']}</h2>
-        </div>
-        
-        <div style="background-color: white; padding: 15px; border-radius: 10px; margin-bottom: 20px;">
-            <div style="display: flex; flex-wrap: wrap; gap: 20px; font-size: 14px; color: #6b7280;">
-                <span><strong>Model:</strong> {result['model']}</span>
-                <span><strong>Analysis Time:</strong> {elapsed_time:.2f} seconds</span>
-                <span><strong>Timestamp:</strong> {result['timestamp']}</span>
-                <span><strong>Tokens:</strong> {result['tokens_used']}</span>
-            </div>
-        </div>
-        
-        <div style="background-color: white; padding: 20px; border-radius: 10px; line-height: 1.6; font-size: 16px;">
-            {reasoning_html}
-        </div>
-    </div>
-    """
-    
-    return formatted_output, create_download_file(formatted_output, filename)
-
-def run_full_orchestra(problem: str, context: str = "") -> Tuple[str, str, str, str, Optional[gr.File], Optional[gr.File], Optional[gr.File], Optional[gr.File]]:
-    """Run the full collaborative reasoning orchestra with downloadable HTML"""
-    if not orchestra.is_api_key_set:
-        error_msg = """
-        <div style="color: #dc3545; padding: 20px; border: 2px solid #dc3545; border-radius: 10px; background-color: #ffe6e6;">
-            <h3>❌ API Key Required</h3>
-            <p>Please set your Groq API key first in the API Configuration section above.</p>
-        </div>
-        """
-        return error_msg, error_msg, error_msg, error_msg, None, None, None, None
-    
-    if not problem.strip():
-        error_msg = """
-        <div style="color: #fd7e14; padding: 20px; border: 2px solid #fd7e14; border-radius: 10px; background-color: #fff3e6;">
-            <h3>⚠️ Problem Required</h3>
-            <p>Please enter a problem to analyze.</p>
-        </div>
-        """
-        return error_msg, error_msg, error_msg, error_msg, None, None, None, None
-    
-    deep_result = orchestra.deep_thinker_analyze(problem, context)
-    strategic_result = orchestra.quick_strategist_analyze(problem, context)
-    detective_result = orchestra.detail_detective_analyze(problem, context)
-    synthesis = orchestra.synthesize_orchestra(deep_result, strategic_result, detective_result, problem)
-    
-    def format_result_html(result: Dict, color: str, icon: str, filename: str) -> Tuple[str, Optional[gr.File]]:
-        if "error" in result:
-            html_content = f"""
-            <div style="color: #dc3545; padding: 20px; border: 2px solid #dc3545; border-radius: 10px; background-color: #ffe6e6;">
-                <h3>❌ Model Error</h3>
-                <p>{result['error']}</p>
-                <p style="font-size: 12px; color: #6 Methodical in your approach."""
-
-        try:
-            completion = self.client.chat.completions.create(
-                model="deepseek-r1-distill-llama-70b",
-                messages=[{"role": "user", "content": prompt}],
-                temperature=0.6,
-                max_completion_tokens=8192,
-                top_p=0.95,
-                reasoning_format="raw"
-            )
-            
-            response_content = completion.choices[0].message.content
-            if not response_content or response_content.strip() == "":
-                response_content = "The model did not generate a response. This could be due to content filtering, model limitations, or API issues."
-            
-            return {
-                "model": "DeepSeek R1 (Deep Thinker)",
-                "role": "🎭 The Philosopher & Deep Analyzer",
-                "reasoning": response_content,
-                "timestamp": datetime.now().strftime("%H:%M:%S"),
-                "tokens_used": getattr(completion.usage, 'total_tokens', 'N/A') if hasattr(completion, 'usage') and completion.usage else "N/A"
-            }
-        except Exception as e:
-            return {"error": f"Deep Thinker error: {str(e)}"}
-    
-    def quick_strategist_analyze(self, problem: str, context: str = "") -> Dict:
-        """Qwen3 32B - The Quick Strategist"""
-        if not self.is_api_key_set:
-            return {"error": "API key not set"}
-        
-        prompt = f"""You are the Quick Strategist in a collaborative reasoning system. Your role is to provide fast, efficient strategic analysis with clear action plans.
-Problem: {problem}
-{f"Additional Context: {context}" if context else"Additional Context: {context}" if context else ""}
-Please provide a strategic analysis with:
-1. Key insights and patterns
-2. Practical solutions
-3. Implementation priorities
-4. Risk assessment
-5. Clear next steps
-Be decisive and solution-focused. Provide concrete, actionable recommendations."""
-
-        try:
-            completion = self.client.chat.completions.create(
-                model="qwen/qwen3-32b",
-                messages=[{"role": "user", "content": prompt}],
-                temperature=0.6,
-                top_p=0.95,
-                max_completion_tokens=8192
-            )
-            
-            response_content = completion.choices[0].message.content
-            if not response_content or response_content.strip() == "":
-                response_content = "The model did not generate a response. This could be due to content filtering, model limitations, or API issues."
-            
-            return {
-                "model": "Qwen3 32B (Quick Strategist)",
-                "role": "🚀 The Strategic Decision Maker",
-                "reasoning": response_content,
-                "timestamp": datetime.now().strftime("%H:%M:%S"),
-                "tokens_used": getattr(completion.usage, 'total_tokens', 'N/A') if hasattr(completion, 'usage') and completion.usage else "N/A"
-            }
-        except Exception as e:
-            return {"error": f"Quick Strategist error: {str(e)}"}
-    
-    def detail_detective_analyze(self, problem: str, context: str = "") -> Dict:
-        """QwQ 32B - The Detail Detective"""
-        if not self.is_api_key_set:
-            return {"error": "API key not set"}
-        
-        prompt = f"""You are the Detail Detective in a collaborative reasoning system. Your role is to provide meticulous investigation and comprehensive fact-checking.
-Problem: {problem}
-{f"Additional Context: {context}" if context else ""}
-Please conduct a thorough investigation including:
-1. Detailed analysis of all aspects
-2. Potential edge cases and considerations
-3. Verification of assumptions
-4. Historical context or precedents
-5. Comprehensive pros and cons
-6. Hidden connections or implications
 Be extremely thorough and leave no stone unturned. Provide detailed evidence and reasoning for your conclusions."""
 
         try:
@@ -588,7 +250,7 @@ As the Orchestra Conductor, please create a unified synthesis that:
 5. Highlights where the different reasoning styles complement each other
 6. Gives a clear, actionable conclusion
 If some models didn't provide analysis, work with what's available and note any limitations.
-Format your response as a well-structured final solution that leverages all available reasoning approaches. Use clear sects and bullet points where appropriate for maximum clarity."""
+Format your response as a well-structured final solution that leverages all available reasoning approaches. Use clear sections and bullet points where appropriate for maximum clarity."""
 
         try:
             completion = self.client.chat.completions.create(
@@ -795,9 +457,6 @@ custom_css = """
     padding: 10px;
     background-color: #fafafa;
 }
-.download-btn {
-    margin-top: 10px;
-}
 """
 
 # Build the Gradio interface
@@ -839,7 +498,7 @@ with gr.Blocks(css=custom_css, title="Reasoning Orchestra") as app:
         
         # Single Model Tab
         with gr.TabItem("🎯 Single Model Analysis"):
-            gr.Markdown("### Test individual reasoning models with beautiful HTML output and download option")
+            gr.Markdown("### Test individual reasoning models with beautiful HTML output")
             
             with gr.Row():
                 with gr.Column(scale=1):
@@ -866,17 +525,16 @@ with gr.Blocks(css=custom_css, title="Reasoning Orchestra") as app:
                 
                 with gr.Column(scale=2):
                     single_output = gr.HTML(label="Analysis Result", elem_classes=["html-content"])
-                    single_download = gr.File(label="Download Analysis as HTML")
             
             single_analyze_btn.click(
                 fn=run_single_model,
                 inputs=[single_problem, model_choice, single_context],
-                outputs=[single_output, single_download]
+                outputs=[single_output]
             )
         
         # Full Orchestra Tab  
         with gr.TabItem("🎼 Full Orchestra Collaboration"):
-            gr.Markdown("### Run all three models collaboratively with Llama 3.3 70B as Orchestra Conductor and stunning HTML-formatted output with download options")
+            gr.Markdown("### Run all three models collaboratively with Llama 3.3 70B as Orchestra Conductor and stunning HTML-formatted output")
             
             with gr.Column():
                 with gr.Row():
@@ -895,23 +553,15 @@ with gr.Blocks(css=custom_css, title="Reasoning Orchestra") as app:
                 
                 # Orchestra Results
                 with gr.Column():
-                    with gr.Row():
-                        deep_output = gr.HTML(label="🎭 Deep Thinker Analysis", elem_classes=["html-content"])
-                        deep_download = gr.File(label="Download Deep Thinker Analysis")
-                    with gr.Row():
-                        strategic_output = gr.HTML(label="🚀 Quick Strategist Analysis", elem_classes=["html-content"])
-                        strategic_download = gr.File(label="Download Quick Strategist Analysis")
-                    with gr.Row():
-                        detective_output = gr.HTML(label="🔍 Detail Detective Analysis", elem_classes=["html-content"])
-                        detective_download = gr.File(label="Download Detail Detective Analysis")
-                    with gr.Row():
-                        synthesis_output = gr.HTML(label="🎼 Final Orchestrated Solution (Llama 3.3 70B)", elem_classes=["html-content"])
-                        synthesis_download = gr.File(label="Download Final Synthesis")
+                    deep_output = gr.HTML(label="🎭 Deep Thinker Analysis", elem_classes=["html-content"])
+                    strategic_output = gr.HTML(label="🚀 Quick Strategist Analysis", elem_classes=["html-content"])
+                    detective_output = gr.HTML(label="🔍 Detail Detective Analysis", elem_classes=["html-content"])
+                    synthesis_output = gr.HTML(label="🎼 Final Orchestrated Solution (Llama 3.3 70B)", elem_classes=["html-content"])
             
             orchestra_analyze_btn.click(
                 fn=run_full_orchestra,
                 inputs=[orchestra_problem, orchestra_context],
-                outputs=[deep_output, strategic_output, detective_output, synthesis_output, deep_download, strategic_download, detective_download, synthesis_download]
+                outputs=[deep_output, strategic_output, detective_output, synthesis_output]
             )
         
         # Examples Tab