Update app.py

app.py

@@ -3,69 +3,105 @@ import gradio as gr
 import os
 import time # For progress updates
 
+# --- Core Logic Imports ---
+# Initialize clients first to ensure API keys are loaded before other modules use them.
 from core.llm_clients import initialize_all_clients, GEMINI_API_CONFIGURED, HF_API_CONFIGURED
+initialize_all_clients() # Call initialization once when the app starts
+
 from core.generation_engine import generate_initial_solutions
-from core.evaluation_engine import evaluate_solution_candidate, EvaluationResult
+from core.evaluation_engine import evaluate_solution_candidate, EvaluationResult # Class for typed results
 from core.evolution_engine import evolve_solution
 from prompts.system_prompts import get_system_prompt
 from prompts.prompt_templates import format_code_test_analysis_user_prompt
 
 # --- Application Configuration (Models, Defaults) ---
 AVAILABLE_MODELS_CONFIG = {}
-UI_DEFAULT_MODEL_KEY = None
+UI_DEFAULT_MODEL_KEY = None # Will be set based on configured APIs
+
+# --- Placeholder for the actual API model ID string ---
+# You need to find the correct string from Google's documentation or AI Studio for this model.
+# It might be something like "models/gemini-2.5-pro-preview-0506" or similar.
+GEMINI_2_5_PRO_PREVIEW_MODEL_ID = "YOUR_GEMINI_2.5_PRO_PREVIEW_0506_MODEL_ID_STRING_HERE" 
+# Example: "gemini-experimental" or a more specific preview ID if available via API.
+# For now, if you don't have the exact ID, you can use a known working one like "gemini-1.5-pro-latest"
+# and then update this when you get the 2.5 Pro Preview ID.
+# If GEMINI_2_5_PRO_PREVIEW_MODEL_ID remains the placeholder, that model won't work.
+# Let's use a known one for now if the placeholder isn't replaced.
+if GEMINI_2_5_PRO_PREVIEW_MODEL_ID == "YOUR_GEMINI_2.5_PRO_PREVIEW_0506_MODEL_ID_STRING_HERE":
+    print(f"WARNING: app.py - GEMINI_2_5_PRO_PREVIEW_MODEL_ID is a placeholder. Using 'gemini-1.5-pro-latest' as a stand-in for Gemini 2.5 Pro Preview.")
+    SAFE_GEMINI_PRO_ID = "gemini-1.5-pro-latest" # A known recent Pro model
+else:
+    SAFE_GEMINI_PRO_ID = GEMINI_2_5_PRO_PREVIEW_MODEL_ID
+
 
-# Populate with Gemini models if API is configured
+# Populate with Gemini models first if API is configured
 if GEMINI_API_CONFIGURED:
     AVAILABLE_MODELS_CONFIG.update({
-        "Google Gemini 1.5 Flash (API - Fast, Recommended)": {"id": "gemini-1.5-flash-latest", "type": "google_gemini"},
-        "Google Gemini 1.0 Pro (API)": {"id": "gemini-1.0-pro-latest", "type": "google_gemini"},
+        # Update this line with the correct display name and ID once known
+        "Google Gemini 2.5 Pro Preview (API)": {"id": SAFE_GEMINI_PRO_ID, "type": "google_gemini"},
+        "Google Gemini 1.5 Flash (API - Fast)": {"id": "gemini-1.5-flash-latest", "type": "google_gemini"},
+        "Google Gemini 1.0 Pro (API - Legacy)": {"id": "gemini-1.0-pro-latest", "type": "google_gemini"},
     })
-    UI_DEFAULT_MODEL_KEY = "Google Gemini 1.5 Flash (API - Fast, Recommended)"
+    # Prioritize the newest Pro model as default if its ID is not the placeholder
+    if SAFE_GEMINI_PRO_ID != "gemini-1.5-pro-latest" or GEMINI_2_5_PRO_PREVIEW_MODEL_ID != "YOUR_GEMINI_2.5_PRO_PREVIEW_0506_MODEL_ID_STRING_HERE":
+        UI_DEFAULT_MODEL_KEY = "Google Gemini 2.5 Pro Preview (API)"
+    else: # Fallback to Flash if 2.5 Pro ID is still placeholder
+        UI_DEFAULT_MODEL_KEY = "Google Gemini 1.5 Flash (API - Fast)"
+    print(f"INFO: app.py - Gemini models populated. Default set to: {UI_DEFAULT_MODEL_KEY}")
+else:
+    print("WARNING: app.py - Gemini API not configured; Gemini models will be unavailable.")
 
-# Populate with Hugging Face models if API is configured
+# Populate with Hugging Face models if API is configured (as alternatives/fallbacks)
 if HF_API_CONFIGURED:
     AVAILABLE_MODELS_CONFIG.update({
         "Google Gemma 2B (HF - Quick Test)": {"id": "google/gemma-2b-it", "type": "hf"},
         "Mistral 7B Instruct (HF)": {"id": "mistralai/Mistral-7B-Instruct-v0.2", "type": "hf"},
-        "CodeLlama 7B Instruct (HF)": {"id": "codellama/CodeLlama-7b-Instruct-hf", "type": "hf"}, # Smaller CodeLlama
+        "CodeLlama 7B Instruct (HF)": {"id": "codellama/CodeLlama-7b-Instruct-hf", "type": "hf"},
     })
-    if not UI_DEFAULT_MODEL_KEY: # If Gemini isn't configured, default to an HF model
+    if not UI_DEFAULT_MODEL_KEY: # If Gemini wasn't configured, default to an HF model
         UI_DEFAULT_MODEL_KEY = "Google Gemma 2B (HF - Quick Test)"
+        print("INFO: app.py - HF models populated; default set to an HF model as Gemini was not available.")
+    else:
+        print("INFO: app.py - HF models also populated as alternatives.")
+else:
+    print("WARNING: app.py - Hugging Face API not configured; HF models will be unavailable.")
 
-# Absolute fallback if no models could be configured
+# Absolute fallback if no models could be configured at all
 if not AVAILABLE_MODELS_CONFIG:
     print("CRITICAL APP ERROR: No models could be configured. Check API keys in Space Secrets.")
-    AVAILABLE_MODELS_CONFIG["No Models Available (Check API Keys)"] = {"id": "dummy", "type": "none"}
+    AVAILABLE_MODELS_CONFIG["No Models Available (Check API Keys)"] = {"id": "dummy_error", "type": "none"}
     UI_DEFAULT_MODEL_KEY = "No Models Available (Check API Keys)"
 elif not UI_DEFAULT_MODEL_KEY and AVAILABLE_MODELS_CONFIG: 
-    UI_DEFAULT_MODEL_KEY = list(AVAILABLE_MODELS_CONFIG.keys())[0] # Pick first available if default somehow not set
+    UI_DEFAULT_MODEL_KEY = list(AVAILABLE_MODELS_CONFIG.keys())[0]
+    print(f"WARNING: app.py - UI_DEFAULT_MODEL_KEY was not set by primary logic, falling back to first available: {UI_DEFAULT_MODEL_KEY}")
+
 
 # --- Main Orchestration Logic for Gradio ---
+# This function remains the same as in the previous "full rewrite" that included all files.
 def run_algoforge_simulation_orchestrator(
-    problem_type_selected: str, 
-    problem_description_text: str, 
-    initial_hints_text: str, 
+    problem_type_selected: str,
+    problem_description_text: str,
+    initial_hints_text: str,
     user_provided_tests_code: str,
-    num_initial_solutions_to_gen: int, 
+    num_initial_solutions_to_gen: int,
     selected_model_ui_key: str,
     genesis_temp: float, genesis_max_tokens: int,
     critique_temp: float, critique_max_tokens: int,
     evolution_temp: float, evolution_max_tokens: int,
-    progress=gr.Progress(track_tqdm=True) # Gradio progress tracker
+    progress=gr.Progress(track_tqdm=True)
 ):
     progress(0, desc="Initializing AlgoForge Prime™...")
     log_entries = [f"**AlgoForge Prime™ Cycle Starting at {time.strftime('%Y-%m-%d %H:%M:%S')}**"]
     start_time = time.time()
 
-    # Basic input validation
     if not problem_description_text.strip():
-        error_msg = "CRITICAL INPUT ERROR: Problem Description is mandatory. Please describe the problem."
+        error_msg = "CRITICAL INPUT ERROR: Problem Description is mandatory."
         log_entries.append(error_msg)
-        return error_msg, "", "", "\n".join(log_entries), "" # Return 5 values for outputs
+        return error_msg, "", "", "\n".join(log_entries), ""
 
     current_model_config = AVAILABLE_MODELS_CONFIG.get(selected_model_ui_key)
     if not current_model_config or current_model_config["type"] == "none":
-        error_msg = f"CRITICAL CONFIG ERROR: No valid LLM selected ('{selected_model_ui_key}'). This usually means API keys are missing or failed to initialize. Check Space Secrets and restart."
+        error_msg = f"CRITICAL CONFIG ERROR: No valid LLM selected ('{selected_model_ui_key}'). API keys might be missing or failed initialization. Please check Space Secrets & restart."
         log_entries.append(error_msg)
         return error_msg, "", "", "\n".join(log_entries), ""
 
@@ -73,73 +109,58 @@ def run_algoforge_simulation_orchestrator(
     log_entries.append(f"Problem Type: {problem_type_selected}")
     log_entries.append(f"User Unit Tests Provided: {'Yes' if user_provided_tests_code.strip() else 'No'}")
 
-    # Prepare LLM configurations for each stage
     llm_config_genesis = {"type": current_model_config["type"], "model_id": current_model_config["id"], "temp": genesis_temp, "max_tokens": genesis_max_tokens}
     llm_config_critique = {"type": current_model_config["type"], "model_id": current_model_config["id"], "temp": critique_temp, "max_tokens": critique_max_tokens}
     llm_config_evolution = {"type": current_model_config["type"], "model_id": current_model_config["id"], "temp": evolution_temp, "max_tokens": evolution_max_tokens}
 
-    # --- STAGE 1: GENESIS ---
-    progress(0.1, desc="Stage 1: Genesis Engine - Generating Initial Solutions...")
+    # STAGE 1: GENESIS
+    progress(0.05, desc="Stage 1: Genesis Engine - Generating...") # Adjusted progress start
     log_entries.append("\n**------ STAGE 1: GENESIS ENGINE ------**")
-    
     initial_raw_solutions = generate_initial_solutions(
         problem_description_text, initial_hints_text, problem_type_selected,
         num_initial_solutions_to_gen, llm_config_genesis
     )
-    log_entries.append(f"Genesis Engine produced {len(initial_raw_solutions)} raw solution candidate(s).")
-    for i, sol_text in enumerate(initial_raw_solutions):
+    log_entries.append(f"Genesis Engine produced {len(initial_raw_solutions)} raw candidate(s).")
+    for i, sol_text in enumerate(initial_raw_solutions): # Log snippets
         log_entries.append(f"  Candidate {i+1} (Raw Snippet): {str(sol_text)[:120]}...")
 
-    # --- STAGE 2: CRITIQUE & AUTOMATED EVALUATION ---
-    progress(0.3, desc="Stage 2: Critique Crucible - Evaluating Candidates...")
-    log_entries.append("\n**------ STAGE 2: CRITIQUE CRUCIBLE & AUTOMATED EVALUATION ------**")
-    
-    evaluated_candidates_list = [] # Stores dicts: {"id": ..., "solution_text": ..., "evaluation_result": EvaluationResult}
 
+    # STAGE 2: CRITIQUE & AUTOMATED EVALUATION
+    progress(0.25, desc="Stage 2: Critique Crucible - Evaluating...") # Adjusted progress
+    log_entries.append("\n**------ STAGE 2: CRITIQUE CRUCIBLE & AUTOMATED EVALUATION ------**")
+    evaluated_candidates_list = []
     for i, candidate_solution_text in enumerate(initial_raw_solutions):
-        current_progress = 0.3 + ( (i + 1) / num_initial_solutions_to_gen ) * 0.35 # Progress for evaluation stage
-        progress(current_progress, desc=f"Evaluating Candidate {i+1} of {num_initial_solutions_to_gen}...")
+        current_progress = 0.25 + ((i + 1) / num_initial_solutions_to_gen) * 0.4 # Progress for evaluation
+        progress(current_progress, desc=f"Evaluating Candidate {i+1}...")
         log_entries.append(f"\n--- Evaluating Candidate {i+1} ---")
-        
-        # The evaluation_engine handles if candidate_solution_text itself is an error string
-        evaluation_obj = evaluate_solution_candidate( # type: EvaluationResult
-            candidate_solution_text, problem_description_text, problem_type_selected, 
+        evaluation_obj = evaluate_solution_candidate(
+            candidate_solution_text, problem_description_text, problem_type_selected,
             user_provided_tests_code, llm_config_critique
         )
-        
+        evaluated_candidates_list.append({
+            "id": i + 1, "solution_text": candidate_solution_text, "evaluation_result": evaluation_obj
+        })
         log_entries.append(f"  Final Combined Score: {evaluation_obj.score}/10")
         log_entries.append(f"  Automated Tests: {evaluation_obj.passed_tests}/{evaluation_obj.total_tests} passed.")
         if evaluation_obj.execution_summary: log_entries.append(f"  Execution Summary: {evaluation_obj.execution_summary}")
         log_entries.append(f"  LLM Critique (Snippet): {str(evaluation_obj.critique_text)[:150]}...")
-        
-        evaluated_candidates_list.append({
-            "id": i + 1,
-            "solution_text": candidate_solution_text, # Store original text, even if it was an error from genesis
-            "evaluation_result": evaluation_obj
-        })
 
-    # Format display for initial solutions & evaluations
+
     initial_solutions_display_markdown = []
-    for data in evaluated_candidates_list:
+    for data in evaluated_candidates_list: # Format display for initial solutions
         initial_solutions_display_markdown.append(
-            f"**Candidate {data['id']}:**\n"
-            f"```python\n{data['solution_text']}\n```\n\n" # Assuming python for display, adjust if problem_type varies widely
-            f"**Evaluation Verdict (Combined Score: {data['evaluation_result'].score}/10):**\n"
-            f"{data['evaluation_result'].critique_text}\n---"
+            f"**Candidate {data['id']}:**\n```python\n{data['solution_text']}\n```\n\n"
+            f"**Evaluation Verdict (Combined Score: {data['evaluation_result'].score}/10):**\n{data['evaluation_result'].critique_text}\n---"
         )
-    
-    # --- STAGE 3: SELECTION OF CHAMPION ---
-    progress(0.7, desc="Stage 3: Selecting Champion Candidate...")
+
+    # STAGE 3: SELECTION OF CHAMPION
+    progress(0.7, desc="Stage 3: Selecting Champion...")
     log_entries.append("\n**------ STAGE 3: CHAMPION SELECTION ------**")
-    
-    # Filter out candidates that were errors from genesis OR had very low evaluation scores (e.g., score of 0 from evaluation)
-    # We want to select a champion that is actually a piece of code/algorithm, not an error message.
     potentially_viable_candidates = [
-        cand for cand in evaluated_candidates_list 
+        cand for cand in evaluated_candidates_list
         if cand["evaluation_result"] and cand["evaluation_result"].score > 0 and \
-           cand["solution_text"] and not cand["solution_text"].startswith("ERROR")
+           cand["solution_text"] and not str(cand["solution_text"]).startswith("ERROR") # Ensure solution_text is str
     ]
-
     if not potentially_viable_candidates:
         final_error_msg = "No viable candidate solutions found after generation and evaluation. All attempts may have failed or scored too low."
         log_entries.append(f"  CRITICAL: {final_error_msg}")
@@ -147,55 +168,41 @@ def run_algoforge_simulation_orchestrator(
 
     potentially_viable_candidates.sort(key=lambda x: x["evaluation_result"].score, reverse=True)
     champion_candidate_data = potentially_viable_candidates[0]
-    
     log_entries.append(f"Champion Selected: Candidate {champion_candidate_data['id']} "
-                       f"(Solution Snippet: {champion_candidate_data['solution_text'][:60]}...) "
+                       f"(Solution Snippet: {str(champion_candidate_data['solution_text'])[:60]}...) " # str() for safety
                        f"with evaluation score {champion_candidate_data['evaluation_result'].score}/10.")
-
     champion_display_markdown = (
         f"**Champion Candidate ID: {champion_candidate_data['id']} "
         f"(Original Combined Score: {champion_candidate_data['evaluation_result'].score}/10):**\n"
         f"```python\n{champion_candidate_data['solution_text']}\n```\n\n"
-        f"**Original Comprehensive Evaluation for this Champion:**\n"
-        f"{champion_candidate_data['evaluation_result'].critique_text}"
+        f"**Original Comprehensive Evaluation for this Champion:**\n{champion_candidate_data['evaluation_result'].critique_text}"
     )
 
-    # --- STAGE 4: EVOLUTIONARY FORGE ---
-    progress(0.75, desc="Stage 4: Evolutionary Forge - Refining Champion...")
+    # STAGE 4: EVOLUTIONARY FORGE
+    progress(0.75, desc="Stage 4: Evolutionary Forge - Refining...")
     log_entries.append("\n**------ STAGE 4: EVOLUTIONARY FORGE ------**")
-    
     evolved_solution_code = evolve_solution(
-        champion_candidate_data["solution_text"],
-        champion_candidate_data["evaluation_result"].critique_text, # Pass the full critique
+        str(champion_candidate_data["solution_text"]), # str() for safety
+        str(champion_candidate_data["evaluation_result"].critique_text),
         champion_candidate_data["evaluation_result"].score,
-        problem_description_text,
-        problem_type_selected,
-        llm_config_evolution
+        problem_description_text, problem_type_selected, llm_config_evolution
     )
     log_entries.append(f"Raw Evolved Solution Text (Snippet): {str(evolved_solution_code)[:150]}...")
-
     evolved_solution_display_markdown = ""
-    ai_test_analysis_markdown = "" # For LLM explanation of unit test results of evolved code
+    ai_test_analysis_markdown = ""
 
-    if evolved_solution_code.startswith("ERROR"):
+    if str(evolved_solution_code).startswith("ERROR"): # str() for safety
         evolved_solution_display_markdown = f"**Evolution Stage Failed:**\n{evolved_solution_code}"
     else:
         evolved_solution_display_markdown = f"**✨ AlgoForge Prime™ Evolved Artifact ✨:**\n```python\n{evolved_solution_code}\n```"
-        
-        # Optionally, re-evaluate the evolved solution with unit tests if provided and applicable
         if "python" in problem_type_selected.lower() and user_provided_tests_code.strip():
-            progress(0.9, desc="Post-Evolution: Re-running Automated Tests on Evolved Code...")
+            progress(0.9, desc="Post-Evolution: Testing Evolved Code...")
             log_entries.append("\n--- Post-Evolution Sanity Check (Automated Tests on Evolved Code) ---")
-            
-            # Use a low temperature for this critique to focus on test results rather than creative critique
-            # The critique part here is mostly for consistency, primary goal is test execution.
             evolved_critique_config = {"type": current_model_config["type"], "model_id": current_model_config["id"], "temp": 0.2, "max_tokens": critique_max_tokens}
-            
-            evolved_code_eval_result = evaluate_solution_candidate( # type: EvaluationResult
-                 evolved_solution_code, problem_description_text, problem_type_selected, 
+            evolved_code_eval_result = evaluate_solution_candidate(
+                 str(evolved_solution_code), problem_description_text, problem_type_selected,
                  user_provided_tests_code, evolved_critique_config
             )
-            
             evolved_solution_display_markdown += (
                 f"\n\n**Post-Evolution Automated Test Results (Simulated):**\n"
                 f"{evolved_code_eval_result.execution_summary}\n"
@@ -204,23 +211,18 @@ def run_algoforge_simulation_orchestrator(
             log_entries.append(f"  Evolved Code Test Results: {evolved_code_eval_result.passed_tests}/{evolved_code_eval_result.total_tests} passed. "
                                f"Summary: {evolved_code_eval_result.execution_summary}")
 
-            # Get LLM to explain the test results of the evolved code
-            if evolved_code_eval_result.total_tests > 0 : # Only if tests were run
+            if evolved_code_eval_result.total_tests > 0 :
                 progress(0.95, desc="Post-Evolution: AI Analyzing Test Results...")
                 log_entries.append("\n--- AI Analysis of Evolved Code's Test Results ---")
                 analysis_user_prompt = format_code_test_analysis_user_prompt(
-                    evolved_solution_code, 
-                    user_provided_tests_code, 
-                    evolved_code_eval_result.execution_summary # Pass the summary string
+                    str(evolved_solution_code), user_provided_tests_code,
+                    str(evolved_code_eval_result.execution_summary)
                 )
                 analysis_system_prompt = get_system_prompt("code_execution_explainer")
+                llm_analysis_config = {"type": current_model_config["type"], "model_id": current_model_config["id"],
+                                       "temp": 0.3, "max_tokens": critique_max_tokens + 150} # Ensure enough tokens for analysis
                 
-                # Use a config for analysis - can be same as critique or specialized
-                llm_analysis_config = {"type": current_model_config["type"], "model_id": current_model_config["id"], 
-                                       "temp": 0.3, "max_tokens": critique_max_tokens + 100} # A bit more tokens for explanation
-
-                from core.llm_clients import call_huggingface_api, call_gemini_api # Re-import for clarity or use a dispatcher
-                
+                from core.llm_clients import call_huggingface_api, call_gemini_api # Direct import for clarity
                 explanation_response_obj = None
                 if llm_analysis_config["type"] == "hf":
                     explanation_response_obj = call_huggingface_api(analysis_user_prompt, llm_analysis_config["model_id"], llm_analysis_config["temp"], llm_analysis_config["max_tokens"], analysis_system_prompt)
@@ -229,12 +231,11 @@ def run_algoforge_simulation_orchestrator(
 
                 if explanation_response_obj and explanation_response_obj.success:
                     ai_test_analysis_markdown = f"**AI Analysis of Evolved Code's Test Performance:**\n{explanation_response_obj.text}"
-                    log_entries.append(f"  AI Test Analysis (Snippet): {explanation_response_obj.text[:100]}...")
+                    log_entries.append(f"  AI Test Analysis (Snippet): {str(explanation_response_obj.text)[:100]}...")
                 elif explanation_response_obj:
                     ai_test_analysis_markdown = f"**AI Analysis of Test Performance Failed:**\n{explanation_response_obj.error}"
                     log_entries.append(f"  AI Test Analysis Error: {explanation_response_obj.error}")
 
-
     total_time = time.time() - start_time
     log_entries.append(f"\n**AlgoForge Prime™ Cycle Complete. Total time: {total_time:.2f} seconds.**")
     progress(1.0, desc="Cycle Complete!")
@@ -243,102 +244,81 @@ def run_algoforge_simulation_orchestrator(
 
 
 # --- Gradio UI Definition ---
-# (This section is largely similar to the previous app.py, with updated input/output connections)
-
 intro_markdown = """
-# ✨ AlgoForge Prime™ ✨: Modular Algorithmic Evolution (v2)
-This enhanced version uses a modular codebase and demonstrates a conceptual workflow for AI-assisted algorithm discovery, 
+# ✨ AlgoForge Prime™ ✨: Modular Algorithmic Evolution (v2.5 Gemini Focus)
+This version prioritizes the latest Google Gemini models and demonstrates a conceptual workflow for AI-assisted algorithm discovery, 
 featuring (simulated) unit testing for Python code if provided.
 
-**API Keys Required in Space Secrets:**
+**API Keys Required in Space Secrets (should be working):**
 - `GOOGLE_API_KEY` (Primary): For Google Gemini API models. Ensure the "Generative Language API" (or similar) is enabled for your project.
 - `HF_TOKEN` (Secondary): For Hugging Face hosted models.
-If keys are missing or invalid, corresponding models will be unavailable.
 """
 
-# Determine API status for UI message
-ui_token_status_md = ""
+ui_token_status_md = "" 
 if not GEMINI_API_CONFIGURED and not HF_API_CONFIGURED:
     ui_token_status_md = "<p style='color:red;'>⚠️ **CRITICAL: NEITHER GOOGLE_API_KEY NOR HF_TOKEN are configured or working correctly.** The application will not be able to call any LLMs.</p>"
 else:
-    if GEMINI_API_CONFIGURED:
-        ui_token_status_md += "<p style='color:green;'>✅ Google Gemini API Key detected and configured.</p>"
-    else:
-        ui_token_status_md += "<p style='color:orange;'>⚠️ **GOOGLE_API_KEY missing or failed to configure.** Gemini API models will be disabled.</p>"
-    
-    if HF_API_CONFIGURED:
-        ui_token_status_md += "<p style='color:green;'>✅ Hugging Face API Token detected and client initialized.</p>"
-    else:
-        ui_token_status_md += "<p style='color:orange;'>⚠️ **HF_TOKEN missing or client failed to initialize.** Hugging Face models will be disabled.</p>"
+    if GEMINI_API_CONFIGURED: ui_token_status_md += "<p style='color:green;'>✅ Google Gemini API Key detected and configured.</p>"
+    else: ui_token_status_md += "<p style='color:orange;'>⚠️ **GOOGLE_API_KEY missing or failed to configure.** Gemini API models will be disabled.</p>"
+    if HF_API_CONFIGURED: ui_token_status_md += "<p style='color:green;'>✅ Hugging Face API Token detected and client initialized.</p>"
+    else: ui_token_status_md += "<p style='color:orange;'>⚠️ **HF_TOKEN missing or client failed to initialize.** Hugging Face models will be disabled.</p>"
 
 
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="indigo", secondary_hue="purple"), title="AlgoForge Prime™ Modular v2") as app_demo:
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"), title="AlgoForge Prime™ v2.5") as app_demo: # Updated theme
     gr.Markdown(intro_markdown)
     gr.HTML(ui_token_status_md)
 
-    if not AVAILABLE_MODELS_CONFIG or UI_DEFAULT_MODEL_KEY == "No Models Available (Check API Keys)":
-         gr.Markdown("<h2 style='color:red;'>No LLM models are available. Please check your API key configurations in this Space's Secrets and restart the Space. The application cannot function without at least one working API configuration.</h2>")
+    if not AVAILABLE_MODELS_CONFIG or UI_DEFAULT_MODEL_KEY == "No Models Available (Check API Keys)" or (UI_DEFAULT_MODEL_KEY and AVAILABLE_MODELS_CONFIG[UI_DEFAULT_MODEL_KEY]["type"] == "none"):
+         gr.Markdown("<h2 style='color:red;'>No LLM models are available. Please ensure API keys are correctly set in Space Secrets and that the Space has been restarted.</h2>")
     else:
         with gr.Row():
-            # Input Column
-            with gr.Column(scale=2): # Input column slightly wider
+            with gr.Column(scale=2):
                 gr.Markdown("## 💡 1. Define the Challenge")
                 problem_type_dropdown = gr.Dropdown(
                     choices=["Python Algorithm with Tests", "Python Algorithm (Critique Only)", "General Algorithm Idea", "Conceptual System Design", "Pseudocode Refinement"],
                     label="Type of Problem / Algorithm", value="Python Algorithm with Tests",
-                    info="Select '...with Tests' to enable (simulated) unit testing if you provide tests below."
-                )
-                problem_description_textbox = gr.Textbox(
-                    lines=5, label="Problem Description / Desired Outcome",
-                    placeholder="Example for 'Python Algorithm with Tests':\n`def calculate_factorial(n: int) -> int:`\nCalculates factorial of n. Should handle n=0 (returns 1) and raise ValueError for n<0."
-                )
-                initial_hints_textbox = gr.Textbox(
-                    lines=3, label="Initial Thoughts / Constraints / Seed Ideas (Optional)",
-                    placeholder="E.g., 'Prefer an iterative solution over recursive for factorial.' or 'Consider time complexity.'"
-                )
-                user_tests_textbox = gr.Textbox(
-                    lines=6, label="Python Unit Tests (Optional, one `assert` per line)",
-                    placeholder="assert calculate_factorial(0) == 1\nassert calculate_factorial(5) == 120\n# try: calculate_factorial(-1); assert False # Expected ValueError\n# except ValueError: assert True",
-                    info="For 'Python Algorithm with Tests'. Ensure function names match your problem description."
+                    info="Select '...with Tests' to enable (simulated) unit testing."
                 )
+                problem_description_textbox = gr.Textbox(lines=5, label="Problem Description / Desired Outcome", placeholder="Describe the algorithmic task clearly.")
+                initial_hints_textbox = gr.Textbox(lines=3, label="Initial Thoughts / Constraints (Optional)", placeholder="Any specific approaches or limitations.")
+                user_tests_textbox = gr.Textbox(lines=6, label="Python Unit Tests (Optional, one `assert` per line)", placeholder="assert function_name(input) == expected_output")
                 
                 gr.Markdown("## ⚙️ 2. Configure The Forge")
                 model_selection_dropdown = gr.Dropdown(
                     choices=list(AVAILABLE_MODELS_CONFIG.keys()),
-                    value=UI_DEFAULT_MODEL_KEY if UI_DEFAULT_MODEL_KEY in AVAILABLE_MODELS_CONFIG else (list(AVAILABLE_MODELS_CONFIG.keys())[0] if AVAILABLE_MODELS_CONFIG else None),
+                    value=UI_DEFAULT_MODEL_KEY,
                     label="Select LLM Core Model",
-                    info="Ensure the corresponding API key (Google or HF) is configured in secrets."
+                    info="Ensure the corresponding API key is working."
                 )
-                num_initial_solutions_slider = gr.Slider(minimum=1, maximum=4, value=2, step=1, label="Number of Initial Solutions (Genesis Engine)")
+                num_initial_solutions_slider = gr.Slider(minimum=1, maximum=3, value=2, step=1, label="Number of Initial Solutions") # Max 3 for faster iterations
 
                 with gr.Accordion("Advanced LLM Parameters (Expert Users)", open=False):
                     with gr.Row():
-                        genesis_temp_slider = gr.Slider(minimum=0.0, maximum=1.0, value=0.7, step=0.05, label="Genesis Temp", info="Higher = more creative, Lower = more deterministic.") # Gemini range often 0-1
-                        genesis_max_tokens_slider = gr.Slider(minimum=200, maximum=2048, value=768, step=64, label="Genesis Max Output Tokens")
+                        genesis_temp_slider = gr.Slider(minimum=0.0, maximum=1.0, value=0.7, step=0.05, label="Genesis Temp")
+                        genesis_max_tokens_slider = gr.Slider(minimum=256, maximum=4096, value=1024, step=128, label="Genesis Max Tokens") # Increased range
                     with gr.Row():
                         critique_temp_slider = gr.Slider(minimum=0.0, maximum=1.0, value=0.4, step=0.05, label="Critique Temp")
-                        critique_max_tokens_slider = gr.Slider(minimum=150, maximum=1024, value=512, step=64, label="Critique Max Output Tokens")
+                        critique_max_tokens_slider = gr.Slider(minimum=150, maximum=2048, value=512, step=64, label="Critique Max Tokens")
                     with gr.Row():
                         evolution_temp_slider = gr.Slider(minimum=0.0, maximum=1.0, value=0.75, step=0.05, label="Evolution Temp")
-                        evolution_max_tokens_slider = gr.Slider(minimum=200, maximum=2048, value=1024, step=64, label="Evolution Max Output Tokens")
+                        evolution_max_tokens_slider = gr.Slider(minimum=256, maximum=4096, value=1536, step=128, label="Evolution Max Tokens")
+
 
-                engage_button = gr.Button("🚀 ENGAGE ALGOFORGE PRIME™ 🚀", variant="primary", size="lg", elem_id="engage_button_elem")
+                engage_button = gr.Button("🚀 ENGAGE ALGOFORGE PRIME™ 🚀", variant="primary", size="lg")
 
-            # Output Column
-            with gr.Column(scale=3): # Output column wider
+            with gr.Column(scale=3):
                 gr.Markdown("## 🔥 3. The Forge's Output")
-                with gr.Tabs(elem_id="output_tabs_elem"):
-                    with gr.TabItem("📜 Initial Candidates & Evaluations", id="tab_initial_evals"):
-                        output_initial_solutions_markdown = gr.Markdown(label="Generated Solutions & Combined Evaluations")
-                    with gr.TabItem("🏆 Champion Candidate (Pre-Evolution)", id="tab_champion"):
-                        output_champion_markdown = gr.Markdown(label="Top Pick for Refinement")
-                    with gr.TabItem("🌟 Evolved Artifact & Test Analysis", id="tab_evolved"):
-                        output_evolved_markdown = gr.Markdown(label="Refined Solution from Evolutionary Forge")
-                        output_ai_test_analysis_markdown = gr.Markdown(label="AI Analysis of Evolved Code's Test Performance")
-                    with gr.TabItem("🛠️ Interaction Log (Developer View)", id="tab_log"):
-                        output_interaction_log_markdown = gr.Markdown(label="Detailed Log of LLM Prompts & Responses")
+                with gr.Tabs():
+                    with gr.TabItem("📜 Initial Candidates & Evaluations"):
+                        output_initial_solutions_markdown = gr.Markdown()
+                    with gr.TabItem("🏆 Champion Candidate"):
+                        output_champion_markdown = gr.Markdown()
+                    with gr.TabItem("🌟 Evolved Artifact & Test Analysis"):
+                        output_evolved_markdown = gr.Markdown()
+                        output_ai_test_analysis_markdown = gr.Markdown()
+                    with gr.TabItem("🛠️ Interaction Log"):
+                        output_interaction_log_markdown = gr.Markdown()
         
-        # Connect button to the orchestration function
         engage_button.click(
             fn=run_algoforge_simulation_orchestrator,
             inputs=[
@@ -354,29 +334,20 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="indigo", secondary_hue="purple"
                 output_ai_test_analysis_markdown
             ]
         )
-    
     gr.Markdown("---")
     gr.Markdown(
-        "**Disclaimer:** This is a conceptual, educational demonstration. "
-        "The (simulated) unit testing feature is for illustrative purposes. "
-        "**NEVER run LLM-generated code from an untrusted source in an unrestricted environment.** "
-        "Implementing robust and secure code sandboxing is complex and absolutely critical for safety in real-world applications. "
-        "LLM outputs always require careful human review and verification."
+        "**Disclaimer:** Conceptual demo. (Simulated) unit testing is illustrative. **NEVER run LLM-generated code from an untrusted source in an unrestricted environment.** Real sandboxing is critical for safety."
     )
 
 # --- Entry Point for Running the Gradio App ---
 if __name__ == "__main__":
     print("="*80)
-    print("AlgoForge Prime™ (Modular Version v2 with Simulated Testing) - Launching...")
-    
+    print("AlgoForge Prime™ (Modular Version v2.5 Gemini Focus) - Launching...")
     print(f"  Google Gemini API Configured: {GEMINI_API_CONFIGURED}")
     print(f"  Hugging Face API Configured: {HF_API_CONFIGURED}")
-    
     if not GEMINI_API_CONFIGURED and not HF_API_CONFIGURED:
-        print("  CRITICAL WARNING: No API keys seem to be configured. The application will likely be non-functional.")
-    
+        print("  CRITICAL WARNING: No API keys seem to be configured. App will be non-functional.")
     print(f"  UI Default Model Key: {UI_DEFAULT_MODEL_KEY}")
     print(f"  Available models for UI: {list(AVAILABLE_MODELS_CONFIG.keys())}")
     print("="*80)
-    
-    app_demo.launch(debug=True, server_name="0.0.0.0") # server_name="0.0.0.0" is often needed for Docker/Spaces
+    app_demo.launch(debug=True, server_name="0.0.0.0") # server_name="0.0.0.0" for Docker/Spaces