Update app.py

app.py

@@ -1,49 +1,21 @@
+# algoforge_prime/app.py
 import gradio as gr
-from huggingface_hub import InferenceClient # Still needed for HF fallbacks
-import google.generativeai as genai # For Google Gemini API
 import os
-import random
-
-# --- ALGOFORGE PRIME™ CONFIGURATION & SECRETS ---
-
-# Google API Key - ESSENTIAL for Google Gemini Pro/Flash models via their API
-GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
-GEMINI_API_CONFIGURED = False
-if GOOGLE_API_KEY:
-    try:
-        genai.configure(api_key=GOOGLE_API_KEY)
-        GEMINI_API_CONFIGURED = True
-        print("INFO: Google Gemini API configured successfully.")
-    except Exception as e:
-        print(f"ERROR: Failed to configure Google Gemini API with provided key: {e}. Gemini models will be unavailable.")
-        # GOOGLE_API_KEY = None # Effectively disables it if config fails
-else:
-    print("WARNING: GOOGLE_API_KEY not found in Space Secrets. Google Gemini API models will be disabled.")
 
-# Hugging Face Token - For Hugging Face hosted models (fallbacks or alternatives)
-HF_TOKEN = os.getenv("HF_TOKEN")
-HF_API_CONFIGURED = False
-if not HF_TOKEN:
-    print("WARNING: HF_TOKEN not found in Space Secrets. Calls to Hugging Face hosted models will be disabled.")
-else:
-    HF_API_CONFIGURED = True
-    print("INFO: HF_TOKEN detected. Hugging Face hosted models can be used.")
+# Initialize core components first (important for loading API keys etc.)
+# This needs to happen before other core modules try to use the status
+from core.llm_clients import initialize_clients, GEMINI_API_CONFIGURED, HF_API_CONFIGURED 
+initialize_clients() # Explicitly initialize
 
-# Initialize Hugging Face Inference Client (conditionally)
-hf_inference_client = None
-if HF_API_CONFIGURED:
-    try:
-        hf_inference_client = InferenceClient(token=HF_TOKEN)
-        print("INFO: Hugging Face InferenceClient initialized successfully.")
-    except Exception as e:
-        print(f"ERROR: Failed to initialize Hugging Face InferenceClient: {e}. HF models will be unavailable.")
-        HF_API_CONFIGURED = False # Mark as not configured if client init fails
-
-# --- MODEL DEFINITIONS ---
+from core.generation_engine import generate_initial_solutions
+from core.evaluation_engine import evaluate_solution_candidate, EvaluationResult
+from core.evolution_engine import evolve_solution
+# from prompts.system_prompts import get_system_prompt # Might not be needed directly here if core modules handle it
+
+# --- MODEL DEFINITIONS (can also be moved to a config file/module later) ---
 AVAILABLE_MODELS = {}
 DEFAULT_MODEL_KEY = None
 
-# Populate with Gemini models if API is configured
 if GEMINI_API_CONFIGURED:
     AVAILABLE_MODELS.update({
         "Google Gemini 1.5 Flash (API - Fast, Recommended)": {"id": "gemini-1.5-flash-latest", "type": "google_gemini"},
@@ -51,364 +23,282 @@ if GEMINI_API_CONFIGURED:
     })
     DEFAULT_MODEL_KEY = "Google Gemini 1.5 Flash (API - Fast, Recommended)"
 
-# Populate with Hugging Face models if API is configured (as alternatives/fallbacks)
 if HF_API_CONFIGURED:
     AVAILABLE_MODELS.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"},
     })
-    if not DEFAULT_MODEL_KEY: # If Gemini isn't configured, default to an HF model
+    if not DEFAULT_MODEL_KEY: 
         DEFAULT_MODEL_KEY = "Google Gemma 2B (HF - Quick Test)"
 
-# Absolute fallback if no models could be configured
 if not AVAILABLE_MODELS:
-    print("CRITICAL ERROR: No models could be configured. Neither Google API Key nor HF Token seem to be working or present.")
-    # Add a dummy entry to prevent crashes, though the app will be non-functional
     AVAILABLE_MODELS["No Models Available"] = {"id": "dummy", "type": "none"}
     DEFAULT_MODEL_KEY = "No Models Available"
-elif not DEFAULT_MODEL_KEY: # If somehow DEFAULT_MODEL_KEY is still None but AVAILABLE_MODELS is not empty
+elif not DEFAULT_MODEL_KEY: 
     DEFAULT_MODEL_KEY = list(AVAILABLE_MODELS.keys())[0]
 
 
-# --- CORE AI ENGINEERING: LLM INTERACTION FUNCTIONS ---
-
-def call_huggingface_llm_api(prompt_text, model_id, temperature=0.7, max_new_tokens=350, system_prompt=None):
-    if not HF_API_CONFIGURED or not hf_inference_client:
-        return "ERROR: Hugging Face API is not configured (HF_TOKEN missing or client init failed)."
-
-    if system_prompt:
-        full_prompt = f"<s>[INST] <<SYS>>\n{system_prompt}\n<</SYS>>\n\n{prompt_text} [/INST]"
-    else:
-        full_prompt = prompt_text
-    try:
-        use_sample = temperature > 0.0
-        response_text = hf_inference_client.text_generation(
-            full_prompt, model=model_id, max_new_tokens=max_new_tokens,
-            temperature=temperature if use_sample else None,
-            do_sample=use_sample, stream=False
-        )
-        return response_text
-    except Exception as e:
-        error_details = f"Error Type: {type(e).__name__}, Message: {str(e)}"
-        print(f"Hugging Face LLM API Call Error ({model_id}): {error_details}")
-        return f"LLM API Error (Hugging Face Model: {model_id}). Details: {error_details}. Check Space logs."
-
-def call_google_gemini_api(prompt_text, model_id, temperature=0.7, max_new_tokens=400, system_prompt=None):
-    if not GEMINI_API_CONFIGURED:
-        return "ERROR: Google Gemini API is not configured (GOOGLE_API_KEY missing or config failed)."
-
-    try:
-        # For gemini-1.5-flash and newer, system_instruction is the preferred way.
-        # For older gemini-1.0-pro, you might need to structure the 'contents' array.
-        model_instance = genai.GenerativeModel(model_name=model_id, system_instruction=system_prompt if system_prompt else None)
-        
-        generation_config = genai.types.GenerationConfig(
-            temperature=temperature,
-            max_output_tokens=max_new_tokens
-        )
-        # Simple user prompt if system_instruction is handled by GenerativeModel
-        response = model_instance.generate_content(
-            prompt_text, # Just the user prompt
-            generation_config=generation_config,
-            stream=False
-        )
-
-        # Robust check for response content and safety blocks
-        if response.prompt_feedback and response.prompt_feedback.block_reason:
-            block_reason_msg = response.prompt_feedback.block_reason_message or response.prompt_feedback.block_reason
-            print(f"Google Gemini API: Prompt blocked. Reason: {block_reason_msg}")
-            return f"Google Gemini API Error: Your prompt was blocked. Reason: {block_reason_msg}. Try rephrasing."
-
-        if not response.candidates or not response.candidates[0].content.parts:
-             # Check if any candidate has content
-            candidate_had_content = any(cand.content and cand.content.parts for cand in response.candidates)
-            if not candidate_had_content:
-                finish_reason = response.candidates[0].finish_reason if response.candidates else "Unknown"
-                # Specific check for safety if that's the finish reason
-                if str(finish_reason).upper() == "SAFETY":
-                     print(f"Google Gemini API: Response generation stopped due to safety settings. Finish Reason: {finish_reason}")
-                     return f"Google Gemini API Error: Response generation stopped due to safety settings. Finish Reason: {finish_reason}. Try a different prompt or adjust safety settings in your Google AI Studio if possible."
-                else:
-                    print(f"Google Gemini API: Empty response or no content parts. Finish Reason: {finish_reason}")
-                    return f"Google Gemini API Error: Empty response or no content generated. Finish Reason: {finish_reason}. The model might not have had anything to say or the request was malformed."
-        
-        # Assuming the first candidate has the primary response
-        return response.candidates[0].content.parts[0].text
-
-    except Exception as e:
-        error_details = f"Error Type: {type(e).__name__}, Message: {str(e)}"
-        print(f"Google Gemini API Call Error ({model_id}): {error_details}")
-        # Provide more specific feedback for common errors if possible
-        if "API key not valid" in str(e) or "PERMISSION_DENIED" in str(e):
-            return f"LLM API Error (Google Gemini Model: {model_id}). Details: API key invalid or permission denied. Please check your GOOGLE_API_KEY and ensure the Gemini API is enabled for your project. Original error: {error_details}"
-        elif "Could not find model" in str(e):
-            return f"LLM API Error (Google Gemini Model: {model_id}). Details: Model ID '{model_id}' not found or not accessible with your key. Original error: {error_details}"
-        return f"LLM API Error (Google Gemini Model: {model_id}). Details: {error_details}. Check Space logs."
-
-
-# --- ALGOFORGE PRIME™ - THE GRAND ORCHESTRATOR ---
-# (This function remains largely the same as the previous "full rewrite",
-#  as the dispatch_llm_call logic handles routing to the correct API call function.
-#  I will include it for completeness but highlight any minor adjustments if needed.)
-
+# --- Main Orchestration Logic ---
 def run_algoforge_simulation(
-    problem_type, problem_description, initial_hints,
+    problem_type, problem_description, initial_hints, user_tests_string, # New input: user_tests_string
     num_initial_solutions, selected_model_key,
     gen_temp, gen_max_tokens,
     eval_temp, eval_max_tokens,
-    evolve_temp, evolve_max_tokens
+    evolve_temp, evolve_max_tokens,
+    progress=gr.Progress(track_tqdm=True) # Gradio progress bar
 ):
+    progress(0, desc="Initializing AlgoForge Prime™...")
+    log_entries = [f"**AlgoForge Prime™ Cycle Starting...**"]
+
     if not problem_description:
-        return "ERROR: Problem Description is the lifeblood of innovation! Please provide it.", "", "", ""
+        return "ERROR: Problem Description is mandatory.", "", "", "", ""
 
-    model_info = AVAILABLE_MODELS.get(selected_model_key)
-    if not model_info or model_info["type"] == "none":
-        return f"ERROR: No valid model selected or available. Please check API key configurations. Selected: '{selected_model_key}'", "", "", ""
+    model_config = AVAILABLE_MODELS.get(selected_model_key)
+    if not model_config or model_config["type"] == "none":
+        return f"ERROR: No valid model selected ('{selected_model_key}'). Check API key configs.", "", "", "", ""
     
-    model_id = model_info["id"]
-    model_type = model_info["type"]
+    log_entries.append(f"Selected Model: {selected_model_key} (Type: {model_config['type']}, ID: {model_config['id']})")
+    log_entries.append(f"Problem Type: {problem_type}, User Tests Provided: {'Yes' if user_tests_string else 'No'}")
+
+    # --- STAGE 1: GENESIS ---
+    progress(0.1, desc="Stage 1: Genesis Engine - Generating Solutions...")
+    log_entries.append("\n**Stage 1: Genesis Engine**")
     
-    log_entries = [f"**AlgoForge Prime™ Initializing...**\nSelected Model Core: {model_id} ({selected_model_key} - Type: {model_type})\nProblem Type: {problem_type}"]
-
-    def dispatch_llm_call(prompt, system_p, temp, max_tok, stage_name=""):
-        log_entries.append(f"  Dispatching to {model_type.upper()} API for {stage_name} (Model: {model_id}):\n  Prompt (snippet): {prompt[:100]}...")
-        if system_p: log_entries[-1] += f"\n  System Prompt (snippet): {system_p[:100]}..."
-
-        if model_type == "hf":
-            if not HF_API_CONFIGURED: return "ERROR: HF_TOKEN not configured or InferenceClient failed."
-            result = call_huggingface_llm_api(prompt, model_id, temp, max_tok, system_p)
-        elif model_type == "google_gemini":
-            if not GEMINI_API_CONFIGURED: return "ERROR: GOOGLE_API_KEY not configured or Gemini API setup failed."
-            result = call_google_gemini_api(prompt, model_id, temp, max_tok, system_p)
-        else:
-            result = f"ERROR: Unknown model type '{model_type}' for selected model."
-        
-        log_entries.append(f"  {model_type.upper()} API Response ({stage_name} - Snippet): {str(result)[:150]}...")
-        return result
-
-    # STAGE 1: GENESIS
-    log_entries.append("\n**Stage 1: Genesis Engine - Generating Initial Solution Candidates...**")
-    generated_solutions_raw = []
-    system_prompt_generate = f"You are an expert {problem_type.lower().replace(' ', '_')} algorithm designer. Your goal is to brainstorm multiple diverse solutions to the user's problem."
-    for i in range(num_initial_solutions):
-        user_prompt_generate = (
-            f"Problem Description: \"{problem_description}\"\n"
-            f"Consider these initial thoughts/constraints: \"{initial_hints if initial_hints else 'None'}\"\n"
-            f"Please provide one distinct and complete solution/algorithm for this problem. "
-            f"This is solution attempt #{i+1} of {num_initial_solutions}. Try a different approach if possible."
-        )
-        solution_text = dispatch_llm_call(user_prompt_generate, system_prompt_generate, gen_temp, gen_max_tokens, f"Genesis Attempt {i+1}")
-        generated_solutions_raw.append(solution_text)
-
-    if not any(sol and not str(sol).startswith("ERROR:") and not str(sol).startswith("LLM API Error") for sol in generated_solutions_raw):
-        log_entries.append("  Genesis Engine failed to produce viable candidates or all calls resulted in errors.")
-        initial_sol_output = "No valid solutions generated by the Genesis Engine. All attempts failed or returned errors."
-        if generated_solutions_raw:
-            initial_sol_output += "\n\nErrors Encountered:\n" + "\n".join([f"- {str(s)}" for s in generated_solutions_raw if str(s).startswith("ERROR") or str(s).startswith("LLM API Error")])
-        return initial_sol_output, "", "", "\n".join(log_entries)
+    llm_gen_config = {"type": model_config["type"], "model_id": model_config["id"], "temp": gen_temp, "max_tokens": gen_max_tokens}
+    initial_solution_texts = generate_initial_solutions(
+        problem_description, initial_hints, problem_type,
+        num_initial_solutions, llm_gen_config
+    )
+    log_entries.append(f"Generated {len(initial_solution_texts)} raw solution candidates.")
+    for i, sol_text in enumerate(initial_solution_texts):
+        log_entries.append(f"  Candidate {i+1} (Snippet): {str(sol_text)[:100]}...")
+
+
+    valid_initial_solutions = [s for s in initial_solution_texts if s and not s.startswith("ERROR")]
+    if not valid_initial_solutions:
+        error_summary = "\n".join(set(s for s in initial_solution_texts if s and s.startswith("ERROR")))
+        return f"No valid solutions generated by Genesis Engine. Errors:\n{error_summary}", "", "", "\n".join(log_entries), ""
+
+    # --- STAGE 2: CRITIQUE & EVALUATION ---
+    progress(0.3, desc="Stage 2: Critique Crucible - Evaluating Candidates...")
+    log_entries.append("\n**Stage 2: Critique Crucible & Automated Evaluation**")
     
-    # STAGE 2: CRITIQUE
-    log_entries.append("\n**Stage 2: Critique Crucible - Evaluating Candidates...**")
-    evaluated_solutions_display = []
-    evaluated_sols_data = []
-    system_prompt_evaluate = "You are a highly critical and insightful AI algorithm evaluator. Assess the provided solution based on clarity, potential correctness, and perceived efficiency. Provide a concise critique and a numerical score from 1 (poor) to 10 (excellent). CRITICALLY: You MUST include the score in the format 'Score: X/10' where X is an integer."
-
-    for i, sol_text_candidate in enumerate(generated_solutions_raw):
-        sol_text = str(sol_text_candidate)
-        critique_text = f"Critique for Candidate {i+1}" # Placeholder
-        score = 0
-
-        if sol_text.startswith("ERROR:") or sol_text.startswith("LLM API Error"):
-            critique_text = f"Candidate {i+1} could not be properly generated due to an earlier API error: {sol_text}"
-            score = 0
+    evaluated_candidates_data = []
+    llm_eval_config = {"type": model_config["type"], "model_id": model_config["id"], "temp": eval_temp, "max_tokens": eval_max_tokens}
+
+    for i, sol_text in enumerate(initial_solution_texts): # Evaluate all, even errors, to show the error
+        progress(0.3 + (i / num_initial_solutions) * 0.4, desc=f"Evaluating Candidate {i+1}...")
+        log_entries.append(f"\nEvaluating Candidate {i+1}:")
+        if sol_text.startswith("ERROR"):
+            eval_res = EvaluationResult(score=0, critique=f"Candidate was an error from Genesis: {sol_text}")
+            log_entries.append(f"  Skipping detailed evaluation for error: {sol_text}")
         else:
-            user_prompt_evaluate = (
-                f"Problem Reference (for context only, do not repeat in output): \"{problem_description[:150]}...\"\n\n"
-                f"Now, evaluate the following proposed solution:\n```\n{sol_text}\n```\n"
-                f"Provide your critique and ensure you output a score in the format 'Score: X/10'."
+            eval_res = evaluate_solution_candidate(
+                sol_text, problem_description, problem_type, user_tests_string, llm_eval_config
             )
-            evaluation_text = str(dispatch_llm_call(user_prompt_evaluate, system_prompt_evaluate, eval_temp, eval_max_tokens, f"Critique Candidate {i+1}"))
-            
-            critique_text = evaluation_text # Default to full response
-            if evaluation_text.startswith("ERROR:") or evaluation_text.startswith("LLM API Error"):
-                 critique_text = f"Error during evaluation of Candidate {i+1}: {evaluation_text}"
-                 score = 0
-            else:
-                # Try to parse score
-                score_match_found = False
-                if "Score:" in evaluation_text:
-                    try:
-                        # More robust parsing for "Score: X/10" or "Score: X"
-                        score_part_full = evaluation_text.split("Score:")[1].strip()
-                        score_num_str = score_part_full.split("/")[0].split()[0].strip() # Get number before / or space
-                        parsed_score_val = int(score_num_str)
-                        score = max(1, min(parsed_score_val, 10)) # Clamp score
-                        score_match_found = True
-                    except (ValueError, IndexError, TypeError):
-                        log_entries.append(f"    Warning: Could not parse score accurately from: '{evaluation_text}' despite 'Score:' marker.")
-                
-                if not score_match_found: # Fallback if parsing fails or marker missing
-                    log_entries.append(f"    Warning: 'Score:' marker missing or unparsable in evaluation: '{evaluation_text}'. Assigning random score.")
-                    score = random.randint(3, 7) 
+            log_entries.append(f"  LLM Critique & Test Score: {eval_res.score}/10")
+            log_entries.append(f"  Test Results: {eval_res.passed_tests}/{eval_res.total_tests} passed.")
+            if eval_res.execution_error: log_entries.append(f"  Execution Error: {eval_res.execution_error}")
+            log_entries.append(f"  Full Critique (Snippet): {str(eval_res.critique)[:150]}...")
         
-        evaluated_solutions_display.append(f"**Candidate {i+1}:**\n```text\n{sol_text}\n```\n**Crucible Verdict (Score: {score}/10):**\n{critique_text}\n---")
-        evaluated_sols_data.append({"id": i+1, "solution": sol_text, "score": score, "critique": critique_text})
-
-    if not evaluated_sols_data or all(s['score'] == 0 for s in evaluated_sols_data):
-        log_entries.append("  Critique Crucible yielded no valid evaluations or all solutions had errors.")
-        current_output = "\n\n".join(evaluated_solutions_display) if evaluated_solutions_display else "Generation might be OK, but evaluation failed for all candidates."
-        return current_output, "", "", "\n".join(log_entries)
-
-    # STAGE 3: SELECTION
-    evaluated_sols_data.sort(key=lambda x: x["score"], reverse=True)
-    best_initial_solution_data = evaluated_sols_data[0]
-    log_entries.append(f"\n**Stage 3: Champion Selected - Candidate {best_initial_solution_data['id']} (Score: {best_initial_solution_data['score']}) chosen for evolution.**")
-    if best_initial_solution_data['solution'].startswith("ERROR:") or best_initial_solution_data['solution'].startswith("LLM API Error"):
-        log_entries.append("   ERROR: Selected champion solution itself is an error message. Cannot evolve.")
-        return "\n\n".join(evaluated_solutions_display), f"Selected champion was an error: {best_initial_solution_data['solution']}", "Cannot evolve an error.", "\n".join(log_entries)
-
-    # STAGE 4: EVOLUTION
-    log_entries.append("\n**Stage 4: Evolutionary Forge - Refining the Champion...**")
-    system_prompt_evolve = f"You are an elite AI algorithm optimizer and refiner. Your task is to take the provided solution and make it significantly better. Focus on {problem_type.lower()} best practices, improve efficiency or clarity, fix any potential errors, and expand on it if appropriate. Explain the key improvements you've made clearly."
-    user_prompt_evolve = (
-        f"Original Problem (for context): \"{problem_description}\"\n\n"
-        f"The current leading solution (which had a score of {best_initial_solution_data['score']}/10) is:\n```\n{best_initial_solution_data['solution']}\n```\n"
-        f"The original critique for this solution was: \"{best_initial_solution_data['critique']}\"\n\n"
-        f"Your mission: Evolve this solution. Make it demonstrably superior. If the original solution was just a sketch, flesh it out. If it had flaws, fix them. If it was good, make it great. Explain the key improvements you've made as part of your response."
-    )
-    evolved_solution_text = str(dispatch_llm_call(user_prompt_evolve, system_prompt_evolve, evolve_temp, evolve_max_tokens, "Evolution"))
+        evaluated_candidates_data.append({
+            "id": i + 1,
+            "solution_text": sol_text,
+            "evaluation": eval_res
+        })
+
+    # Format display for initial solutions
+    initial_solutions_display_md = []
+    for data in evaluated_candidates_data:
+        initial_solutions_display_md.append(
+            f"**Candidate {data['id']}:**\n```python\n{data['solution_text']}\n```\n"
+            f"**Evaluation Verdict (Score: {data['evaluation'].score}/10):**\n{data['evaluation'].critique}\n---"
+        )
     
-    if evolved_solution_text.startswith("ERROR:") or evolved_solution_text.startswith("LLM API Error"):
-         log_entries.append("   ERROR: Evolution step resulted in an API error.")
-         evolved_solution_output_md = f"**Evolution Failed:**\n{evolved_solution_text}"
-    else:
-        evolved_solution_output_md = f"**✨ AlgoForge Prime™ Evolved Artifact ✨:**\n```text\n{evolved_solution_text}\n```"
-
-    # FINAL OUTPUT ASSEMBLY
-    initial_solutions_output_md = "\n\n".join(evaluated_solutions_display)
-    best_solution_output_md = (
-        f"**Champion Candidate {best_initial_solution_data['id']} (Original Score: {best_initial_solution_data['score']}/10):**\n"
-        f"```text\n{best_initial_solution_data['solution']}\n```\n"
-        f"**Original Crucible Verdict:**\n{best_initial_solution_data['critique']}"
+    # --- STAGE 3: SELECTION ---
+    progress(0.75, desc="Stage 3: Selecting Champion...")
+    # Filter out candidates that were errors from genesis before sorting by score
+    valid_evaluated_candidates = [cand for cand in evaluated_candidates_data if not cand['solution_text'].startswith("ERROR")]
+    if not valid_evaluated_candidates:
+         return "\n\n".join(initial_solutions_display_md), "No valid candidates to select from after evaluation.", "", "\n".join(log_entries), ""
+
+    valid_evaluated_candidates.sort(key=lambda x: x["evaluation"].score, reverse=True)
+    best_candidate_data = valid_evaluated_candidates[0]
+    log_entries.append(f"\n**Stage 3: Champion Selected**\nCandidate {best_candidate_data['id']} chosen with score {best_candidate_data['evaluation'].score}/10.")
+
+    best_solution_display_md = (
+        f"**Champion Candidate {best_candidate_data['id']} (Original Score: {best_candidate_data['evaluation'].score}/10):**\n"
+        f"```python\n{best_candidate_data['solution_text']}\n```\n"
+        f"**Original Comprehensive Evaluation:**\n{best_candidate_data['evaluation'].critique}"
     )
+
+    # --- STAGE 4: EVOLUTION ---
+    progress(0.8, desc="Stage 4: Evolutionary Forge - Refining Champion...")
+    log_entries.append("\n**Stage 4: Evolutionary Forge**")
+    llm_evolve_config = {"type": model_config["type"], "model_id": model_config["id"], "temp": evolve_temp, "max_tokens": evolve_max_tokens}
     
+    evolved_solution_text = evolve_solution(
+        best_candidate_data["solution_text"],
+        str(best_candidate_data["evaluation"].critique), # Pass the full critique including test results
+        best_candidate_data["evaluation"].score,
+        problem_description,
+        problem_type,
+        llm_evolve_config
+    )
+    log_entries.append(f"Evolved solution text (Snippet): {str(evolved_solution_text)[:150]}...")
+
+    evolved_solution_display_md = ""
+    final_thoughts_md = "" # For LLM explanation of unit test results if needed
+
+    if evolved_solution_text.startswith("ERROR"):
+        evolved_solution_display_md = f"**Evolution Failed:**\n{evolved_solution_text}"
+    else:
+        evolved_solution_display_md = f"**✨ AlgoForge Prime™ Evolved Artifact ✨:**\n```python\n{evolved_solution_text}\n```"
+        # Optionally, re-evaluate the evolved solution with unit tests if provided
+        if "python" in problem_type.lower() and user_tests_string:
+            progress(0.9, desc="Re-evaluating Evolved Solution with Tests...")
+            log_entries.append("\n**Post-Evolution Sanity Check (Re-running Tests on Evolved Code)**")
+            # Using a neutral LLM config for this, or could be separate
+            # This evaluation is primarily for the test results, not another LLM critique of the evolved code
+            evolved_eval_res = evaluate_solution_candidate(
+                 evolved_solution_text, problem_description, problem_type, user_tests_string,
+                 {"type": model_config["type"], "model_id": model_config["id"], "temp": 0.1, "max_tokens": eval_max_tokens} # Low temp for focused test eval
+            )
+            evolved_solution_display_md += (
+                f"\n\n**Post-Evolution Test Results (Simulated):**\n"
+                f"Passed: {evolved_eval_res.passed_tests}/{evolved_eval_res.total_tests}\n"
+            )
+            if evolved_eval_res.execution_error:
+                 evolved_solution_display_md += f"Execution Output/Error: {evolved_eval_res.execution_error}\n"
+            log_entries.append(f"  Evolved Code Test Results: {evolved_eval_res.passed_tests}/{evolved_eval_res.total_tests} passed.")
+
+            # Get LLM to explain the test results of the evolved code
+            # progress(0.95, desc="Explaining Evolved Code Test Results...")
+            # explain_prompt = f"The following Python code was generated: \n```python\n{evolved_solution_text}\n```\nIt was tested against these assertions:\n```python\n{user_tests_string}\n```\nThe test outcome was: {evolved_eval_res.passed_tests}/{evolved_eval_res.total_tests} passed. \nExecution/Error details: {evolved_eval_res.execution_error}\n\nProvide a brief analysis of these test results for the given code."
+            # explain_sys_prompt = get_system_prompt("code_execution_explainer")
+            # explanation_response = dispatch_llm_call_simplified(explain_prompt, explain_sys_prompt, llm_evolve_config) # Need a simplified dispatcher or use the full one
+            # final_thoughts_md = f"**AI Analysis of Evolved Code's Test Results:**\n{explanation_response}"
+
+
     log_entries.append("\n**AlgoForge Prime™ Cycle Complete.**")
-    final_log_output = "\n".join(log_entries)
+    progress(1.0, desc="Cycle Complete!")
+    return "\n\n".join(initial_solutions_display_md), best_solution_display_md, evolved_solution_display_md, "\n".join(log_entries), final_thoughts_md
 
-    return initial_solutions_output_md, best_solution_output_md, evolved_solution_output_md, final_log_output
 
-# --- GRADIO UI ---
+# --- GRADIO UI (largely similar, but with a new input for user tests) ---
 intro_markdown = """
-# ✨ AlgoForge Prime™ ✨: Conceptual Algorithmic Evolution (Gemini Focused)
-Welcome! This system demonstrates AI-assisted algorithm discovery and refinement, with a primary focus on **Google Gemini API models**.
-Hugging Face hosted models are available as alternatives if configured.
-**This is a conceptual demo, not AlphaEvolve itself.**
+# ✨ AlgoForge Prime™ ✨: Modular Algorithmic Evolution
+This enhanced version demonstrates a more structured approach to AI-assisted algorithm discovery, 
+featuring basic (simulated) unit testing for Python code.
 
 **API Keys Required in Space Secrets:**
-- `GOOGLE_API_KEY` (Primary): For Google Gemini API models (e.g., Gemini 1.5 Flash, Gemini 1.0 Pro).
-- `HF_TOKEN` (Secondary): For Hugging Face hosted models (e.g., Gemma on HF, Mistral).
-If a key is missing, corresponding models will be unusable or limited.
+- `GOOGLE_API_KEY` (Primary): For Google Gemini API models.
+- `HF_TOKEN` (Secondary): For Hugging Face hosted models.
 """
-
 token_status_md = ""
 if not GEMINI_API_CONFIGURED and not HF_API_CONFIGURED:
-    token_status_md = "<p style='color:red;'>⚠️ CRITICAL: NEITHER GOOGLE_API_KEY NOR HF_TOKEN are configured or working. The application will not function.</p>"
+    token_status_md = "<p style='color:red;'>⚠️ CRITICAL: NEITHER API IS CONFIGURED. APP WILL NOT FUNCTION.</p>"
 else:
-    if GEMINI_API_CONFIGURED:
-        token_status_md += "<p style='color:green;'>✅ Google Gemini API Key detected and configured.</p>"
-    else:
-        token_status_md += "<p style='color:orange;'>⚠️ GOOGLE_API_KEY missing or failed to configure. Gemini API models disabled.</p>"
-    
-    if HF_API_CONFIGURED:
-        token_status_md += "<p style='color:green;'>✅ Hugging Face API Token detected and client initialized.</p>"
-    else:
-        token_status_md += "<p style='color:orange;'>⚠️ HF_TOKEN missing or client failed to initialize. Hugging Face models disabled.</p>"
+    if GEMINI_API_CONFIGURED: token_status_md += "<p style='color:green;'>✅ Google Gemini API Key detected.</p>"
+    else: token_status_md += "<p style='color:orange;'>⚠️ GOOGLE_API_KEY missing/failed. Gemini models disabled.</p>"
+    if HF_API_CONFIGURED: token_status_md += "<p style='color:green;'>✅ Hugging Face API Token detected.</p>"
+    else: token_status_md += "<p style='color:orange;'>⚠️ HF_TOKEN missing/failed. Hugging Face models disabled.</p>"
 
 
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"), title="AlgoForge Prime™ (Gemini)") as demo: # Changed theme
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="cyan"), title="AlgoForge Prime™ Modular") as demo:
     gr.Markdown(intro_markdown)
-    gr.HTML(token_status_md) 
+    gr.HTML(token_status_md)
 
     if not AVAILABLE_MODELS or DEFAULT_MODEL_KEY == "No Models Available":
-         gr.Markdown("<h2 style='color:red;'>No models are available. Please check your API key configurations in Space Secrets and restart the Space.</h2>")
+         gr.Markdown("<h2 style='color:red;'>No models are available. Check API keys and restart.</h2>")
     else:
         with gr.Row():
-            with gr.Column(scale=1):
+            with gr.Column(scale=2): # Made input column wider
                 gr.Markdown("## 💡 1. Define the Challenge")
                 problem_type_dd = gr.Dropdown(
-                    ["Python Algorithm", "Data Structure Logic", "Mathematical Optimization", "Conceptual System Design", "Pseudocode Refinement", "Verilog Snippet Idea", "General Brainstorming"],
-                    label="Type of Problem/Algorithm", value="Python Algorithm"
+                    ["Python Algorithm with Tests", "Python Algorithm (Critique Only)", "General Algorithm Idea", "Conceptual System Design"],
+                    label="Type of Problem/Algorithm", value="Python Algorithm with Tests"
                 )
                 problem_desc_tb = gr.Textbox(
-                    lines=5, label="Problem Description / Desired Outcome",
-                    placeholder="e.g., 'Efficient Python function for Fibonacci sequence using memoization.'"
+                    lines=4, label="Problem Description / Desired Outcome",
+                    placeholder="e.g., 'Python function `is_palindrome(s: str) -> bool` that checks if a string is a palindrome, ignoring case and non-alphanumeric chars.'"
                 )
                 initial_hints_tb = gr.Textbox(
-                    lines=3, label="Initial Thoughts / Constraints / Seed Ideas (Optional)",
-                    placeholder="e.g., 'Focus on clarity and correctness.' OR 'Target O(n) complexity.'"
+                    lines=2, label="Initial Thoughts / Constraints (Optional)",
+                    placeholder="e.g., 'Iterative approach preferred.' or 'Handle empty strings.'"
+                )
+                # NEW INPUT for User Tests
+                user_tests_tb = gr.Textbox(
+                    lines=5, label="Python Unit Tests (Optional, one `assert` per line)",
+                    placeholder="assert is_palindrome('Racecar!') == True\nassert is_palindrome('hello') == False\nassert is_palindrome('') == True",
+                    info="For 'Python Algorithm with Tests' type. Ignored otherwise."
                 )
                 
                 gr.Markdown("## ⚙️ 2. Configure The Forge")
                 model_select_dd = gr.Dropdown(
                     choices=list(AVAILABLE_MODELS.keys()),
-                    value=DEFAULT_MODEL_KEY if DEFAULT_MODEL_KEY in AVAILABLE_MODELS else (list(AVAILABLE_MODELS.keys())[0] if AVAILABLE_MODELS else None), # Ensure default is valid
+                    value=DEFAULT_MODEL_KEY if DEFAULT_MODEL_KEY in AVAILABLE_MODELS else (list(AVAILABLE_MODELS.keys())[0] if AVAILABLE_MODELS else None),
                     label="Select LLM Core Model"
                 )
-                num_solutions_slider = gr.Slider(1, 4, value=2, step=1, label="Number of Initial Solutions (Genesis Engine)")
+                num_solutions_slider = gr.Slider(1, 3, value=2, step=1, label="Number of Initial Solutions (Genesis Engine)") # Max 3 for faster runs
 
                 with gr.Accordion("Advanced LLM Parameters", open=False):
+                    # ... (temp and max_tokens sliders - same as before) ...
                     with gr.Row():
-                        gen_temp_slider = gr.Slider(0.0, 1.0, value=0.7, step=0.05, label="Genesis Temp") # Gemini often uses 0-1 range
-                        gen_max_tokens_slider = gr.Slider(100, 2048, value=512, step=64, label="Genesis Max Tokens")
+                        gen_temp_slider = gr.Slider(0.0, 1.0, value=0.7, step=0.05, label="Genesis Temp")
+                        gen_max_tokens_slider = gr.Slider(200, 2048, value=768, step=64, label="Genesis Max Tokens")
                     with gr.Row():
                         eval_temp_slider = gr.Slider(0.0, 1.0, value=0.4, step=0.05, label="Crucible Temp")
-                        eval_max_tokens_slider = gr.Slider(100, 1024, value=300, step=64, label="Crucible Max Tokens")
+                        eval_max_tokens_slider = gr.Slider(150, 1024, value=512, step=64, label="Crucible Max Tokens")
                     with gr.Row():
                         evolve_temp_slider = gr.Slider(0.0, 1.0, value=0.75, step=0.05, label="Evolution Temp")
-                        evolve_max_tokens_slider = gr.Slider(100, 2048, value=768, step=64, label="Evolution Max Tokens")
+                        evolve_max_tokens_slider = gr.Slider(200, 2048, value=1024, step=64, label="Evolution Max Tokens")
+
 
                 submit_btn = gr.Button("🚀 ENGAGE ALGOFORGE PRIME™ 🚀", variant="primary", size="lg")
 
-            with gr.Column(scale=2):
+            with gr.Column(scale=3): # Made output column wider
                 gr.Markdown("## 🔥 3. The Forge's Output")
                 with gr.Tabs():
-                    with gr.TabItem("📜 Genesis Candidates & Crucible Verdicts"):
-                        output_initial_solutions_md = gr.Markdown(label="LLM-Generated Initial Solutions & Evaluations")
+                    with gr.TabItem("📜 Genesis Candidates & Evaluations"):
+                        output_initial_solutions_md = gr.Markdown(label="Generated Solutions & Combined Evaluations")
                     with gr.TabItem("🏆 Champion Candidate (Pre-Evolution)"):
-                        output_best_solution_md = gr.Markdown(label="Evaluator's Top Pick")
-                    with gr.TabItem("🌟 Evolved Artifact"):
-                        output_evolved_solution_md = gr.Markdown(label="Refined Solution from the Evolutionary Forge")
+                        output_best_solution_md = gr.Markdown(label="Top Pick for Refinement")
+                    with gr.TabItem("🌟 Evolved Artifact (& Test Analysis)"):
+                        output_evolved_solution_md = gr.Markdown(label="Refined Solution from Evolutionary Forge")
+                        # output_final_thoughts_md = gr.Markdown(label="AI Analysis of Evolved Code's Tests") # Optional separate output
                     with gr.TabItem("🛠️ Interaction Log (Dev View)"):
                         output_interaction_log_md = gr.Markdown(label="Detailed Log of LLM Prompts & Responses")
+        
+        outputs_list = [
+            output_initial_solutions_md, output_best_solution_md,
+            output_evolved_solution_md, output_interaction_log_md,
+            gr.Markdown() # Placeholder for final_thoughts_md if you add it as a separate component
+        ]
 
         submit_btn.click(
             fn=run_algoforge_simulation,
             inputs=[
-                problem_type_dd, problem_desc_tb, initial_hints_tb,
+                problem_type_dd, problem_desc_tb, initial_hints_tb, user_tests_tb, # Added user_tests_tb
                 num_solutions_slider, model_select_dd,
                 gen_temp_slider, gen_max_tokens_slider,
                 eval_temp_slider, eval_max_tokens_slider,
                 evolve_temp_slider, evolve_max_tokens_slider
             ],
-            outputs=[
-                output_initial_solutions_md, output_best_solution_md,
-                output_evolved_solution_md, output_interaction_log_md
-            ]
+            outputs=outputs_list
         )
     gr.Markdown("---")
     gr.Markdown(
-        "**Disclaimer:** This is a conceptual demo. LLM outputs require rigorous human oversight. Use for inspiration and exploration."
-        "\n*Powered by Gradio, Google Gemini API, Hugging Face Inference API, and innovation.*"
+        "**Disclaimer:** Modular demo. (Simulated) unit testing is illustrative. **NEVER run LLM-generated code from an untrusted source in an unrestricted environment.** "
+        "Real sandboxing is complex and critical for safety."
     )
 
+# --- Entry Point ---
 if __name__ == "__main__":
     print("="*80)
-    print("AlgoForge Prime™ (Gemini Focused) Starting...")
-    if not GEMINI_API_CONFIGURED: print("REMINDER: GOOGLE_API_KEY missing or config failed. Gemini API models disabled.")
-    if not HF_API_CONFIGURED: print("REMINDER: HF_TOKEN missing or client init failed. Hugging Face models disabled.")
-    if not GEMINI_API_CONFIGURED and not HF_API_CONFIGURED: print("CRITICAL: NEITHER API IS CONFIGURED. APP WILL NOT FUNCTION.")
-    print(f"UI will attempt to default to model key: {DEFAULT_MODEL_KEY}")
+    print("AlgoForge Prime™ (Modular Version) Starting...")
+    # ... (startup print messages for API key status - same as before) ...
+    print(f"UI default model key: {DEFAULT_MODEL_KEY}")
     print(f"Available models for UI: {list(AVAILABLE_MODELS.keys())}")
     print("="*80)
     demo.launch(debug=True, server_name="0.0.0.0")