Update app.py

app.py

@@ -5,8 +5,12 @@ 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.llm_clients import initialize_all_clients, is_gemini_api_configured, is_hf_api_configured # Use getters
+initialize_all_clients() # CRITICAL: Call initialization first
+
+# Now get the status AFTER initialization
+GEMINI_API_READY = is_gemini_api_configured()
+HF_API_READY = is_hf_api_configured()
 
 from core.generation_engine import generate_initial_solutions
 from core.evaluation_engine import evaluate_solution_candidate, EvaluationResult # Class for typed results
@@ -16,43 +20,32 @@ from prompts.prompt_templates import format_code_test_analysis_user_prompt
 
 # --- Application Configuration (Models, Defaults) ---
 AVAILABLE_MODELS_CONFIG = {}
-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
+UI_DEFAULT_MODEL_KEY = None 
 
+# Define Gemini 1.5 model IDs (use the exact strings from Google's documentation)
+# These are common aliases; specific versioned IDs might also be available.
+GEMINI_1_5_PRO_LATEST_ID = "gemini-1.5-pro-latest"
+GEMINI_1_5_FLASH_LATEST_ID = "gemini-1.5-flash-latest"
 
 # Populate with Gemini models first if API is configured
-if GEMINI_API_CONFIGURED:
+if GEMINI_API_READY:
     AVAILABLE_MODELS_CONFIG.update({
-        # 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"},
+        f"Google Gemini 1.5 Pro (API - Recommended)": {"id": GEMINI_1_5_PRO_LATEST_ID, "type": "google_gemini"},
+        f"Google Gemini 1.5 Flash (API - Fast)": {"id": GEMINI_1_5_FLASH_LATEST_ID, "type": "google_gemini"},
+        # You can add older Gemini versions here if needed
         "Google Gemini 1.0 Pro (API - Legacy)": {"id": "gemini-1.0-pro-latest", "type": "google_gemini"},
     })
-    # 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)"
+    # Prioritize 1.5 Pro as default
+    UI_DEFAULT_MODEL_KEY = f"Google Gemini 1.5 Pro (API - Recommended)"
+    # Fallback to Flash if Pro key somehow isn't in dict (shouldn't happen with this logic)
+    if UI_DEFAULT_MODEL_KEY not in AVAILABLE_MODELS_CONFIG: # Should not be needed if Pro ID is valid
+        UI_DEFAULT_MODEL_KEY = f"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.")
+    print("WARNING: app.py - Gemini API not configured (checked via getter); Gemini models will be unavailable.")
 
-# Populate with Hugging Face models if API is configured (as alternatives/fallbacks)
-if HF_API_CONFIGURED:
+# Populate with Hugging Face models if API is configured
+if HF_API_READY:
     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"},
@@ -64,44 +57,45 @@ if HF_API_CONFIGURED:
     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.")
+    print("WARNING: app.py - Hugging Face API not configured (checked via getter); HF models will be unavailable.")
 
 # 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_error", "type": "none"}
-    UI_DEFAULT_MODEL_KEY = "No Models Available (Check API Keys)"
-elif not UI_DEFAULT_MODEL_KEY and AVAILABLE_MODELS_CONFIG: 
+    print("CRITICAL APP ERROR: No models could be configured. Check API keys in Space Secrets and restart Space.")
+    AVAILABLE_MODELS_CONFIG["No Models Available (Check API Keys & Restart)"] = {"id": "dummy_error", "type": "none"}
+    UI_DEFAULT_MODEL_KEY = "No Models Available (Check API Keys & Restart)"
+elif not UI_DEFAULT_MODEL_KEY and AVAILABLE_MODELS_CONFIG: # Should not happen if logic above is correct
+    # If somehow UI_DEFAULT_MODEL_KEY is still None, pick the first available model
     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)
+    progress=gr.Progress(track_tqdm=True) # Gradio progress tracker
 ):
     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."
+        error_msg = "CRITICAL INPUT ERROR: Problem Description is mandatory. Please describe the problem."
         log_entries.append(error_msg)
-        return error_msg, "", "", "\n".join(log_entries), ""
+        return error_msg, "", "", "\n".join(log_entries), "" # Return 5 values for outputs
 
     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}'). API keys might be missing or failed initialization. Please check Space Secrets & restart."
+        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."
         log_entries.append(error_msg)
         return error_msg, "", "", "\n".join(log_entries), ""
 
@@ -109,58 +103,72 @@ 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.05, desc="Stage 1: Genesis Engine - Generating...") # Adjusted progress start
+    # --- STAGE 1: GENESIS ---
+    progress(0.05, desc="Stage 1: Genesis Engine - Generating Solutions...")
     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 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]}...")
-
+    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"  Candidate {i+1} (Raw Snippet): {str(sol_text)[:120]}...") # str() for safety
 
-    # STAGE 2: CRITIQUE & AUTOMATED EVALUATION
-    progress(0.25, desc="Stage 2: Critique Crucible - Evaluating...") # Adjusted progress
+    # --- STAGE 2: CRITIQUE & AUTOMATED EVALUATION ---
+    progress(0.25, desc="Stage 2: Critique Crucible - Evaluating Candidates...")
     log_entries.append("\n**------ STAGE 2: CRITIQUE CRUCIBLE & AUTOMATED EVALUATION ------**")
-    evaluated_candidates_list = []
+    
+    evaluated_candidates_list = [] # Stores dicts: {"id": ..., "solution_text": ..., "evaluation_result": EvaluationResult}
+
     for i, candidate_solution_text in enumerate(initial_raw_solutions):
-        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}...")
+        current_progress = 0.25 + ( (i + 1) / num_initial_solutions_to_gen ) * 0.4 # Progress for evaluation stage
+        progress(current_progress, desc=f"Evaluating Candidate {i+1} of {num_initial_solutions_to_gen}...")
         log_entries.append(f"\n--- Evaluating Candidate {i+1} ---")
-        evaluation_obj = evaluate_solution_candidate(
-            candidate_solution_text, problem_description_text, problem_type_selected,
+        
+        evaluation_obj = evaluate_solution_candidate( # type: EvaluationResult
+            str(candidate_solution_text), # Ensure it's a string before passing
+            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": str(candidate_solution_text), 
+            "evaluation_result": evaluation_obj
+        })
 
-
+    # Format display for initial solutions & evaluations
     initial_solutions_display_markdown = []
-    for data in evaluated_candidates_list: # Format display for initial solutions
+    for data in evaluated_candidates_list:
         initial_solutions_display_markdown.append(
-            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---"
+            f"**Candidate {data['id']}:**\n"
+            # Assuming python for display, adjust if problem_type varies widely in output format
+            f"```python\n{data['solution_text']}\n```\n\n" 
+            f"**Evaluation Verdict (Combined Score: {data['evaluation_result'].score}/10):**\n"
+            f"{data['evaluation_result'].critique_text}\n---"
         )
-
-    # STAGE 3: SELECTION OF CHAMPION
-    progress(0.7, desc="Stage 3: Selecting Champion...")
+    
+    # --- STAGE 3: SELECTION OF CHAMPION ---
+    progress(0.7, desc="Stage 3: Selecting Champion Candidate...")
     log_entries.append("\n**------ STAGE 3: CHAMPION SELECTION ------**")
+    
     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 str(cand["solution_text"]).startswith("ERROR") # Ensure solution_text is str
+           cand["solution_text"] and not str(cand["solution_text"]).startswith("ERROR")
     ]
+
     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}")
@@ -168,61 +176,75 @@ 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: {str(champion_candidate_data['solution_text'])[:60]}...) " # str() for safety
+                       f"(Solution Snippet: {str(champion_candidate_data['solution_text'])[:60]}...) "
                        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{champion_candidate_data['evaluation_result'].critique_text}"
+        f"**Original Comprehensive Evaluation for this Champion:**\n"
+        f"{champion_candidate_data['evaluation_result'].critique_text}"
     )
 
-    # STAGE 4: EVOLUTIONARY FORGE
-    progress(0.75, desc="Stage 4: Evolutionary Forge - Refining...")
+    # --- STAGE 4: EVOLUTIONARY FORGE ---
+    progress(0.75, desc="Stage 4: Evolutionary Forge - Refining Champion...")
     log_entries.append("\n**------ STAGE 4: EVOLUTIONARY FORGE ------**")
+    
     evolved_solution_code = evolve_solution(
-        str(champion_candidate_data["solution_text"]), # str() for safety
-        str(champion_candidate_data["evaluation_result"].critique_text),
+        str(champion_candidate_data["solution_text"]),
+        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 = ""
+    ai_test_analysis_markdown = "" 
 
-    if str(evolved_solution_code).startswith("ERROR"): # str() for safety
+    if str(evolved_solution_code).startswith("ERROR"):
         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```"
+        
         if "python" in problem_type_selected.lower() and user_provided_tests_code.strip():
-            progress(0.9, desc="Post-Evolution: Testing Evolved Code...")
+            progress(0.9, desc="Post-Evolution: Re-running Automated Tests on Evolved Code...")
             log_entries.append("\n--- Post-Evolution Sanity Check (Automated Tests on Evolved Code) ---")
+            
             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(
-                 str(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"
+                f"{evolved_code_eval_result.execution_summary}\n" # This now comes from EvaluationResult
                 f"Passed: {evolved_code_eval_result.passed_tests}/{evolved_code_eval_result.total_tests}\n"
             )
             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}")
 
-            if evolved_code_eval_result.total_tests > 0 :
+            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(
-                    str(evolved_solution_code), user_provided_tests_code,
-                    str(evolved_code_eval_result.execution_summary)
+                    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
                 
-                from core.llm_clients import call_huggingface_api, call_gemini_api # Direct import for clarity
+                llm_analysis_config = {"type": current_model_config["type"], "model_id": current_model_config["id"], 
+                                       "temp": 0.3, "max_tokens": critique_max_tokens + 150} 
+                
+                from core.llm_clients import call_huggingface_api, call_gemini_api 
+                
                 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)
@@ -245,8 +267,8 @@ def run_algoforge_simulation_orchestrator(
 
 # --- Gradio UI Definition ---
 intro_markdown = """
-# ✨ 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, 
+# ✨ AlgoForge Prime™ ✨: Modular Algorithmic Evolution (v1.5 Gemini Focus)
+This version prioritizes Google Gemini 1.5 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 (should be working):**
@@ -255,70 +277,88 @@ featuring (simulated) unit testing for Python code if provided.
 """
 
 ui_token_status_md = "" 
-if not GEMINI_API_CONFIGURED and not HF_API_CONFIGURED:
+if not GEMINI_API_READY and not HF_API_READY: # Use status from getters
     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>"
+    if GEMINI_API_READY: 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>"
+    if HF_API_READY: 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="blue", secondary_hue="sky"), title="AlgoForge Prime™ v2.5") as app_demo: # Updated theme
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="green", secondary_hue="lime"), title="AlgoForge Prime™ (1.5 Focus)") as app_demo:
     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)" 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>")
+    # Check if any models are actually usable based on API readiness
+    usable_models_available = any(
+        AVAILABLE_MODELS_CONFIG.get(key, {}).get("type") != "none" 
+        for key in AVAILABLE_MODELS_CONFIG
+    )
+
+    if not usable_models_available:
+         gr.Markdown("<h2 style='color:red;'>No LLM models are available for use. Please ensure at least one API key (Google or Hugging Face) is correctly set in this Space's Secrets and that the Space has been restarted.</h2>")
     else:
         with gr.Row():
-            with gr.Column(scale=2):
+            # Input Column
+            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."
+                    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 (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# For expected errors (advanced, not fully simulated here):\n# try:\n#   calculate_factorial(-1)\n#   assert False, \"ValueError not raised\"\n# except ValueError:\n#   assert True",
+                    info="For 'Python Algorithm with Tests'. Ensure function names match your problem description."
                 )
-                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,
+                    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),
                     label="Select LLM Core Model",
-                    info="Ensure the corresponding API key is working."
+                    info="Ensure the corresponding API key (Google or HF) is configured and working."
                 )
-                num_initial_solutions_slider = gr.Slider(minimum=1, maximum=3, value=2, step=1, label="Number of Initial Solutions") # Max 3 for faster iterations
+                num_initial_solutions_slider = gr.Slider(minimum=1, maximum=3, value=2, step=1, label="Number of Initial Solutions (Genesis Engine)") # Max 3 for faster runs
 
                 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")
-                        genesis_max_tokens_slider = gr.Slider(minimum=256, maximum=4096, value=1024, step=128, label="Genesis Max Tokens") # Increased range
+                        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.")
+                        genesis_max_tokens_slider = gr.Slider(minimum=256, maximum=4096, value=1024, step=128, label="Genesis Max Output Tokens")
                     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=2048, value=512, step=64, label="Critique Max Tokens")
+                        critique_max_tokens_slider = gr.Slider(minimum=150, maximum=2048, value=512, step=64, label="Critique Max Output 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=256, maximum=4096, value=1536, step=128, label="Evolution Max Tokens")
+                        evolution_max_tokens_slider = gr.Slider(minimum=256, maximum=4096, value=1536, step=128, label="Evolution Max Output 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")
-
-            with gr.Column(scale=3):
+            # Output Column
+            with gr.Column(scale=3): 
                 gr.Markdown("## 🔥 3. The Forge's Output")
-                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()
+                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")
         
+        # Connect button to the orchestration function
         engage_button.click(
             fn=run_algoforge_simulation_orchestrator,
             inputs=[
@@ -331,23 +371,29 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"), ti
             outputs=[
                 output_initial_solutions_markdown, output_champion_markdown,
                 output_evolved_markdown, output_interaction_log_markdown,
-                output_ai_test_analysis_markdown
+                output_ai_test_analysis_markdown # Matched to the 5 outputs of orchestrator
             ]
         )
+    
     gr.Markdown("---")
     gr.Markdown(
-        "**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."
+        "**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."
     )
 
 # --- Entry Point for Running the Gradio App ---
 if __name__ == "__main__":
     print("="*80)
-    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. App will be non-functional.")
+    print("AlgoForge Prime™ (Modular Version - Gemini 1.5 Focus) - Launching...")
+    # Print status based on the variables set after calling initialize_all_clients()
+    print(f"  Google Gemini API Configured: {GEMINI_API_READY}")
+    print(f"  Hugging Face API Configured: {HF_API_READY}")
+    if not GEMINI_API_READY and not HF_API_READY:
+        print("  CRITICAL WARNING: No API keys seem to be configured correctly. The application will likely 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" for Docker/Spaces
+    app_demo.launch(debug=True, server_name="0.0.0.0")