Update app.py

app.py

@@ -1,230 +1,277 @@
 import gradio as gr
-from transformers import pipeline # Placeholder for your chosen LLM integration strategy
-import os # For potential API keys
+from huggingface_hub import InferenceClient
+import os
+import random # For a bit of mock variety if needed
 
-# --- KAIZEN'S CORE CONFIGURATION ---
-# Esteemed colleagues, this is where you'd integrate the Cognitive Core (LLM).
-# For this demonstration, we use illustrative placeholders.
-# The true EvoForge Prime would connect to a distributed network of specialized AI agents.
+# --- ALGOFORGE PRIME™ CONFIGURATION & SECRETS ---
+# THE SACRED HF_TOKEN - ENSURE THIS IS IN YOUR SPACE SECRETS
+HF_TOKEN = os.getenv("HF_TOKEN")
 
-# Option 1: Local Pipeline (Requires powerful hardware or smaller models in HF Space)
-# COGNITIVE_CORE_PIPELINE = pipeline("text-generation", model="mistralai/Mistral-7B-Instruct-v0.2", device_map="auto")
+if not HF_TOKEN:
+    print("WARNING: HF_TOKEN not found. LLM calls will fail. Please add HF_TOKEN to your Space Secrets!")
+    # You might want to raise an error or display a persistent warning in the UI
 
-# Option 2: Hugging Face Inference API (More scalable for public Spaces)
-# HF_TOKEN = os.getenv("HF_TOKEN") # Ensure HF_TOKEN is in Space Secrets
-# from huggingface_hub import InferenceClient
-# COGNITIVE_CORE_CLIENT = InferenceClient(token=HF_TOKEN)
-# DEFAULT_MODEL_ID = "mistralai/Mistral-7B-Instruct-v0.2" # Or your preferred model
+# Initialize the Inference Client - The Conduit to a Universe of Models!
+client = InferenceClient(token=HF_TOKEN)
 
-def invoke_cognitive_core(prompt_text, task_description="generation", num_sequences=1, model_id=None):
-    """
-    A centralized function to interact with our LLM.
-    This is where the magic of actual LLM interaction would happen.
-    Replace this with your chosen LLM interaction method.
-    """
-    print(f"\n[KAIZEN LOG] Task: {task_description}")
-    print(f"[KAIZEN LOG] Invoking Cognitive Core with Prompt:\n{prompt_text[:300]}...\n") # Log a snippet
-
-    # --- !!! ACTUAL LLM INTEGRATION POINT !!! ---
-    # This section needs to be replaced with real LLM calls.
-    # Example using a placeholder for now:
-    if task_description == "initial_solution_generation":
-        responses = [f"// EvoForge Candidate Solution {i+1} (Simulated)\n// Problem: {prompt_text[:50]}...\n// Approach: Employing principle of {['recursion', 'iteration', 'divide and conquer', 'dynamic programming'][i%4]}." for i in range(num_sequences)]
-        return responses
-    elif task_description == "solution_evaluation":
-        # In reality, you'd parse score and detailed critique
-        score = len(prompt_text) % 10 + 1 # Dummy score
-        critique = f"EvoForge Analysis: Candidate exhibits potential. Clarity: {score-1}/10. Perceived Efficiency: {score}/10. Novelty: {(score+1)%10}/10. Overall Score: {score}/10."
-        return critique, score
-    elif task_description == "solution_refinement":
-        return f"// EvoForge Synthesized Advancement (Simulated)\n// Original concept: {prompt_text[:60]}...\n// Refinement: Optimized data structures and streamlined control flow for enhanced performance and elegance."
-    else:
-        return [f"Cognitive Core Response to: {prompt_text[:70]}... (Simulation)"]
-    # --- END LLM INTEGRATION POINT ---
-
-
-# --- EVOFORGE PRIME - CORE LOGIC MODULE ---
-def orchestrate_evolutionary_cycle(problem_domain, problem_statement, cognitive_catalysts, divergence_factor):
-    if not problem_statement:
-        return "A problem statement is the seed of innovation. Please provide one.", "", "", "", ""
-
-    master_log = f"## EvoForge Prime - Cycle Report ##\n\n"
-    master_log += f"**Domain:** {problem_domain}\n"
-    master_log += f"**Problem Statement:** {problem_statement}\n"
-    master_log += f"**Cognitive Catalysts (Hints):** {cognitive_catalysts if cognitive_catalysts else 'None provided'}\n"
-    master_log += f"**Initial Solution Divergence Factor:** {divergence_factor}\n\n"
-
-    # STAGE 1: Algorithmic Genesis - Generating Diverse Solution Candidates
-    master_log += "### Stage 1: Algorithmic Genesis ###\n"
-    genesis_prompt = f"""
-    As an advanced AI algorithm designer, address the following problem:
-    Problem Domain: {problem_domain}
-    Problem Statement: "{problem_statement}"
-    Consider these initial thoughts/constraints: "{cognitive_catalysts if cognitive_catalysts else 'N/A'}"
-
-    Generate {divergence_factor} distinct and innovative algorithmic solutions or high-level approaches.
-    For each, provide a conceptual outline or pseudo-code.
+# Curated List of Models for Different Tasks (User Selectable!)
+# You can expand this list. Ensure they are text-generation or instruct models.
+AVAILABLE_MODELS = {
+    "General & Logic (Balanced)": "mistralai/Mistral-7B-Instruct-v0.2",
+    "Code Generation (Strong)": "codellama/CodeLlama-34b-Instruct-hf", # Might be slow, consider smaller CodeLlama
+    "Creative & Versatile (Fast)": "google/gemma-7b-it",
+    "Compact & Quick (Good for CPU tests)": "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
+}
+DEFAULT_MODEL = "mistralai/Mistral-7B-Instruct-v0.2"
+
+# --- CORE AI ENGINEERING: LLM INTERACTION FUNCTIONS ---
+
+def call_llm_via_api(prompt_text, model_id, temperature=0.7, max_new_tokens=350, system_prompt=None):
     """
-    initial_candidates_raw = invoke_cognitive_core(genesis_prompt, "initial_solution_generation", num_sequences=divergence_factor)
-    master_log += f"Invoked Cognitive Core for {divergence_factor} initial candidates.\n"
-    
-    if not initial_candidates_raw:
-        return master_log + "Error: Cognitive Core failed to generate initial candidates.", "", "", ""
-
-    # STAGE 2: Heuristic Evaluation Matrix - Assessing Candidate Viability
-    master_log += "\n### Stage 2: Heuristic Evaluation Matrix ###\n"
-    evaluated_candidates_display = []
-    evaluated_candidates_data = []
-
-    for idx, candidate_code in enumerate(initial_candidates_raw):
-        evaluation_prompt = f"""
-        Critically evaluate the following algorithmic solution candidate for the problem: "{problem_statement}".
-        Solution Candidate {idx+1}:
-        ```
-        {candidate_code}
-        ```
-        Assess its potential correctness, efficiency, clarity, and novelty. Provide a structured critique and assign an overall viability score from 1 (low) to 10 (high).
-        Format:
-        Critique: [Your detailed analysis]
-        Score: [Score_Value]
-        """
-        critique, score = invoke_cognitive_core(evaluation_prompt, "solution_evaluation")
-        evaluated_candidates_display.append(f"**Candidate {idx+1} (Score: {score}/10):**\n```\n{candidate_code}\n```\n**EvoForge Analysis:** {critique}\n---\n")
-        evaluated_candidates_data.append({"solution": candidate_code, "score": score, "critique": critique, "id": idx+1})
-        master_log += f"Evaluated Candidate {idx+1}. Score: {score}/10.\n"
-
-    if not evaluated_candidates_data:
-        return master_log + "\n".join(evaluated_candidates_display), "Error: No candidates available for evaluation.", "", ""
-
-    # STAGE 3: Apex Selection - Identifying the Most Promising Evolutionary Path
-    master_log += "\n### Stage 3: Apex Selection ###\n"
-    evaluated_candidates_data.sort(key=lambda x: x["score"], reverse=True)
-    apex_candidate_data = evaluated_candidates_data[0]
-    apex_candidate_solution = apex_candidate_data["solution"]
-    apex_candidate_critique = apex_candidate_data["critique"]
-    apex_candidate_score = apex_candidate_data["score"]
-    master_log += f"Apex Candidate (ID: {apex_candidate_data['id']}) selected with score {apex_candidate_score}/10.\n"
-
-    # STAGE 4: Algorithmic Refinement - Synthesizing an Advanced Iteration
-    master_log += "\n### Stage 4: Algorithmic Refinement ###\n"
-    refinement_prompt = f"""
-    Given the problem: "{problem_statement}"
-    And the current leading solution candidate (Score: {apex_candidate_score}/10):
-    ```
-    {apex_candidate_solution}
-    ```
-    And its evaluation: "{apex_candidate_critique}"
-
-    Refine this solution. Enhance its efficiency, elegance, robustness, or explore a novel optimization.
-    Explain the key improvements made in the refined version.
+    Centralized function to call the Hugging Face Inference API.
+    As an SRE, I like centralized, observable points of failure/success!
     """
-    refined_solution_text = invoke_cognitive_core(refinement_prompt, "solution_refinement")
-    master_log += "Invoked Cognitive Core for solution refinement.\n"
+    if not HF_TOKEN:
+        return "ERROR: HF_TOKEN is not configured. Cannot contact the LLM Oracle."
+
+    full_prompt = prompt_text
+    if system_prompt: # Some models use system prompts differently, this is a basic way
+        full_prompt = f"<s>[INST] <<SYS>>\n{system_prompt}\n<</SYS>>\n\n{prompt_text} [/INST]"
+
+
+    try:
+        response_stream = client.text_generation(
+            full_prompt,
+            model=model_id,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature if temperature > 0 else None, # API expects None for temp 0
+            stream=False # Keep it simple for this demo; stream=True for real-time
+        )
+        # The response structure might vary slightly based on the model/client version.
+        # Typically, it's just the generated string.
+        # If it returns a dict: response_stream.get("generated_text", response_stream)
+        return response_stream
+    except Exception as e:
+        print(f"LLM API Call Error ({model_id}): {e}")
+        return f"LLM API Error: Could not connect or process request with {model_id}. Details: {str(e)}"
 
-    # Prepare outputs for Gradio Interface
-    initial_solutions_output_md = "## Stage 1 & 2: Generated Candidates & Evaluations\n" + "\n".join(evaluated_candidates_display)
-    apex_solution_output_md = f"## Stage 3: Apex Candidate Selection\n**Selected Candidate (ID: {apex_candidate_data['id']}, Score: {apex_candidate_score}/10):**\n```\n{apex_candidate_solution}\n```\n**Original EvoForge Analysis:** {apex_candidate_critique}"
-    refined_solution_output_md = f"## Stage 4: Synthesized Advancement\n**EvoForge Refined Solution:**\n```\n{refined_solution_text}\n```"
+# --- ALGOFORGE PRIME™ - THE GRAND ORCHESTRATOR ---
+
+def run_algoforge_simulation(
+    problem_type, problem_description, initial_hints,
+    num_initial_solutions, selected_model_key,
+    gen_temp, gen_max_tokens,
+    eval_temp, eval_max_tokens,
+    evolve_temp, evolve_max_tokens
+):
+    if not problem_description:
+        return "ERROR: Problem Description is the lifeblood of innovation! Please provide it.", "", "", "", ""
+
+    if not HF_TOKEN:
+        # This message will appear in the output fields if the token is missing
+        no_token_msg = "CRITICAL ERROR: HF_TOKEN is missing. AlgoForge Prime™ cannot access its cognitive core. Please configure HF_TOKEN in Space Secrets."
+        return no_token_msg, no_token_msg, no_token_msg, no_token_msg
+
+    model_id = AVAILABLE_MODELS.get(selected_model_key, DEFAULT_MODEL)
+    log_entries = [f"**AlgoForge Prime™ Initializing...**\nSelected Model Core: {model_id} ({selected_model_key})\nProblem Type: {problem_type}"]
+
+    # --- STAGE 1: GENESIS ENGINE - MULTIVERSE SOLUTION GENERATION ---
+    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."
+    for i in range(num_initial_solutions):
+        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."
+        )
+        log_entries.append(f"  Sending to Genesis Engine (Attempt {i+1}):\n  Model: {model_id}\n  Prompt (snippet): {prompt_generate[:150]}...")
+        solution_text = call_llm_via_api(prompt_generate, model_id, gen_temp, gen_max_tokens, system_prompt_generate)
+        generated_solutions_raw.append(solution_text)
+        log_entries.append(f"  Genesis Engine Response (Attempt {i+1} - Snippet): {solution_text[:150]}...")
+
+    if not any(sol and not sol.startswith("LLM API Error") and not sol.startswith("ERROR:") for sol in generated_solutions_raw):
+        log_entries.append("  Genesis Engine failed to produce viable candidates.")
+        return "No valid solutions generated by the Genesis Engine.", "", "", "\n".join(log_entries)
     
-    # Exposing the "thought process" prompts for transparency
-    developer_prompts_log = f"""
-    ## Architect's Blueprint: Simulated Cognitive Core Dialogues ##
-
-    **Objective:** {problem_statement}
-
-    **1. Genesis Prompt Snippet (sent to Cognitive Core):**
-    ```
-    ... Generate {divergence_factor} distinct and innovative algorithmic solutions ...
-    Problem Statement: "{problem_statement[:100]}..."
-    Consider these initial thoughts/constraints: "{str(cognitive_catalysts)[:100]}..."
-    ```
-    *(Generated {len(initial_candidates_raw)} candidates)*
-
-    **2. Evaluation Prompt Snippet (for each candidate, e.g., Candidate 1):**
-    ```
-    Critically evaluate the following algorithmic solution candidate ...
-    Solution Candidate 1:
-    {initial_candidates_raw[0][:150]}...
-    ... Assign an overall viability score ...
-    ```
-    *(Selected Apex Candidate ID: {apex_candidate_data['id']} with score: {apex_candidate_score})*
+    # --- STAGE 2: CRITIQUE CRUCIBLE - RUTHLESS EVALUATION ---
+    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. Your task is to assess a given solution based on clarity, potential correctness, and perceived efficiency. Provide a concise critique and a numerical score from 1 (poor) to 10 (excellent)."
+
+    for i, sol_text in enumerate(generated_solutions_raw):
+        if sol_text.startswith("LLM API Error") or sol_text.startswith("ERROR:"):
+            critique = f"Solution {i+1} could not be generated due to an API error."
+            score = 0
+        else:
+            prompt_evaluate = (
+                f"Problem Reference: \"{problem_description[:200]}...\"\n"
+                f"Evaluate the following proposed solution:\n```\n{sol_text}\n```\n"
+                f"Provide your critique and a score (e.g., 'Critique: This is okay. Score: 7/10')."
+            )
+            log_entries.append(f"  Sending to Critique Crucible (Solution {i+1}):\n  Model: {model_id}\n  Prompt (snippet): {prompt_evaluate[:150]}...")
+            evaluation_text = call_llm_via_api(prompt_evaluate, model_id, eval_temp, eval_max_tokens, system_prompt_evaluate)
+            log_entries.append(f"  Critique Crucible Response (Solution {i+1} - Snippet): {evaluation_text[:150]}...")
+            
+            # Attempt to parse score (this is a simple parser, can be improved)
+            parsed_score = 0
+            try:
+                # Look for "Score: X/10" or "Score: X"
+                score_match = [s for s in evaluation_text.split() if s.endswith("/10")]
+                if score_match:
+                    parsed_score = int(score_match[0].split('/')[0].split(':')[-1].strip())
+                else: # Try just a number if X/10 not found
+                    nums = [int(s) for s in evaluation_text.replace(":"," ").split() if s.isdigit()]
+                    if nums: parsed_score = max(min(nums[-1],10),0) # Take last number, cap at 10
+            except ValueError:
+                parsed_score = random.randint(3,7) # Fallback if parsing fails
+
+            critique = evaluation_text
+            score = parsed_score
+
+        evaluated_solutions_display.append(f"**Candidate {i+1}:**\n```text\n{sol_text}\n```\n**Crucible Verdict (Score: {score}/10):**\n{critique}\n---")
+        evaluated_sols_data.append({"id": i+1, "solution": sol_text, "score": score, "critique": critique})
+
+    if not evaluated_sols_data:
+        log_entries.append("  Critique Crucible yielded no evaluations.")
+        return "\n\n".join(evaluated_solutions_display) if evaluated_solutions_display else "Generation OK, but evaluation failed.", "", "", "\n".join(log_entries)
+
+    # --- STAGE 3: SELECTION & ASCENSION PREP ---
+    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.**")
+
+    # --- STAGE 4: EVOLUTIONARY FORGE - PURSUIT OF PERFECTION ---
+    log_entries.append("\n**Stage 4: Evolutionary Forge - Refining the Champion...**")
+    system_prompt_evolve = f"You are an elite AI algorithm optimizer. Your task is to take a good solution and make it significantly better, focusing on {problem_type.lower()} best practices, efficiency, or clarity."
+    prompt_evolve = (
+        f"Original Problem: \"{problem_description}\"\n"
+        f"The current leading solution (Score: {best_initial_solution_data['score']}/10) is:\n```\n{best_initial_solution_data['solution']}\n```\n"
+        f"Original Critique: \"{best_initial_solution_data['critique']}\"\n"
+        f"Your mission: Evolve this solution. Make it demonstrably superior. Explain the key improvements you've made."
+    )
+    log_entries.append(f"  Sending to Evolutionary Forge:\n  Model: {model_id}\n  Prompt (snippet): {prompt_evolve[:150]}...")
+    evolved_solution_text = call_llm_via_api(prompt_evolve, model_id, evolve_temp, evolve_max_tokens, system_prompt_evolve)
+    log_entries.append(f"  Evolutionary Forge Response (Snippet): {evolved_solution_text[:150]}...")
+
+    # --- 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']}"
+    )
+    evolved_solution_output_md = f"**✨ AlgoForge Prime™ Evolved Artifact ✨:**\n```text\n{evolved_solution_text}\n```"
     
-    **3. Refinement Prompt Snippet (sent to Cognitive Core):**
-    ```
-    ... Refine this solution. Enhance its efficiency, elegance, robustness ...
-    Leading solution candidate (Score: {apex_candidate_score}/10):
-    {apex_candidate_solution[:150]}...
-    And its evaluation: "{apex_candidate_critique[:100]}..."
-    ```
-    --- End of Blueprint ---
-    """
+    log_entries.append("\n**AlgoForge Prime™ Cycle Complete.**")
+    final_log_output = "\n".join(log_entries)
 
-    return initial_solutions_output_md, apex_solution_output_md, refined_solution_output_md, developer_prompts_log, master_log
+    return initial_solutions_output_md, best_solution_output_md, evolved_solution_output_md, final_log_output
 
-# --- EVOFORGE PRIME - GRADIO INTERFACE MANIFEST ---
-interface_header = """
-# EvoForge Prime: Conceptual Algorithmic Evolution Engine
-### *Crafted by Aelius Kaizen, Architect of Tomorrow's Algorithms*
+# --- GRADIO UI: THE COMMAND DECK OF ALGOFORGE PRIME™ ---
+intro_markdown = """
+# ✨ AlgoForge Prime™ ✨: Conceptual Algorithmic Evolution
+Welcome, Architect of the Future! I am your humble servant, an AI-driven system inspired by the groundbreaking work of pioneers like Google DeepMind's AlphaEvolve.
+My purpose? To demonstrate a *simplified, conceptual* workflow for AI-assisted algorithm discovery and refinement.
+**This is NOT AlphaEvolve.** This is a creative exploration using powerful Hugging Face LLMs via your `HF_TOKEN`.
 
-**Inspired by the principles demonstrated by Google DeepMind's AlphaEvolve, EvoForge Prime offers a glimpse into AI-driven algorithmic discovery and refinement.**
-This is a *conceptual demonstration* using simulated or actual LLM interactions (if configured) to mimic an evolutionary process:
-1.  **Genesis:** Diverse solutions are ideated by a Cognitive Core (LLM).
-2.  **Evaluation:** Each candidate is critically analyzed (by an LLM or heuristic).
-3.  **Apex Selection:** The most promising candidate is identified.
-4.  **Refinement:** The Cognitive Core attempts to enhance the apex candidate.
+**The Process, Distilled:**
+1.  **Genesis Engine:** We command an LLM to generate multiple diverse solutions to your problem.
+2.  **Critique Crucible:** Another (or the same) LLM instance evaluates these candidates, scoring them.
+3.  **Evolutionary Forge:** The highest-scoring candidate is fed back to an LLM with the directive: *IMPROVE IT!*
 
-**This is a blueprint, a thought experiment made interactive. The actual AlphaEvolve is a vastly complex, proprietary system.**
+**Your `HF_TOKEN` must be set in this Space's Secrets for AlgoForge Prime™ to function!**
 """
 
-with gr.Blocks(theme=gr.themes.Glass(primary_hue="blue", secondary_hue="cyan"), title="EvoForge Prime") as evo_forge_interface:
-    gr.Markdown(interface_header)
+with gr.Blocks(theme=gr.themes.Monochrome(primary_hue="indigo", secondary_hue="blue"), title="AlgoForge Prime™") as demo:
+    gr.Markdown(intro_markdown)
+
+    if not HF_TOKEN:
+        gr.Markdown("<h2 style='color:red;'>⚠️ CRITICAL: `HF_TOKEN` is NOT detected in Space Secrets. AlgoForge Prime™ is non-operational. Please add your token.</h2>")
 
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown("## I. Define the Algorithmic Frontier")
-            input_problem_domain = gr.Dropdown(
-                ["Python Code Optimization", "Abstract Algorithm Design", "Mathematical Logic Puzzle", "Data Structure Innovation", "General Heuristic Improvement"],
-                label="Select Problem Domain",
-                value="Python Code Optimization"
+            gr.Markdown("## 💡 1. Define the Challenge")
+            problem_type_dd = gr.Dropdown(
+                ["Python Algorithm", "Data Structure Logic", "Mathematical Optimization", "Conceptual System Design", "Pseudocode Refinement"],
+                label="Type of Problem/Algorithm",
+                value="Python Algorithm"
             )
-            input_problem_statement = gr.Textbox(
-                lines=6,
-                label="Articulate the Problem or Goal",
-                placeholder="e.g., 'Design a Python function to efficiently find the k-th smallest element in an unsorted list.' or 'Propose a novel heuristic for the Traveling Salesperson Problem.'"
+            problem_desc_tb = gr.Textbox(
+                lines=5,
+                label="Problem Description / Desired Outcome",
+                placeholder="e.g., 'Develop a Python function to efficiently find all prime factors of a large integer.' OR 'Design a heuristic for optimizing delivery routes in a dense urban area.'"
             )
-            input_cognitive_catalysts = gr.Textbox(
+            initial_hints_tb = gr.Textbox(
                 lines=3,
-                label="Seed with Cognitive Catalysts (Optional Hints / Constraints)",
-                placeholder="e.g., 'Prioritize space complexity.' or 'Consider a non-comparison-based sort for a sub-problem.'"
+                label="Initial Thoughts / Constraints / Seed Ideas (Optional)",
+                placeholder="e.g., 'Consider dynamic programming.' OR 'Avoid brute-force if N > 1000.' OR 'Must be implementable in Verilog later.'"
             )
-            input_divergence_factor = gr.Slider(1, 5, value=3, step=1, label="Initial Solution Divergence (Number of Candidates)")
             
-            launch_evolution_btn = gr.Button("🚀 Initiate EvoForge Cycle", variant="primary")
+            gr.Markdown("## ⚙️ 2. Configure The Forge")
+            model_select_dd = gr.Dropdown(
+                choices=list(AVAILABLE_MODELS.keys()),
+                value=list(AVAILABLE_MODELS.keys())[0], # Default to first model in dict
+                label="Select LLM Core Model"
+            )
+            num_solutions_slider = gr.Slider(1, 5, value=3, step=1, label="Number of Initial Solutions (Genesis Engine)")
+
+            with gr.Accordion("Advanced LLM Parameters (Tune with Caution!)", open=False):
+                gr.Markdown("Higher temperature = more creative/random. Lower = more focused/deterministic.")
+                with gr.Row():
+                    gen_temp_slider = gr.Slider(0.0, 1.5, value=0.7, step=0.1, label="Genesis Temp")
+                    gen_max_tokens_slider = gr.Slider(100, 1000, value=350, step=50, label="Genesis Max Tokens")
+                with gr.Row():
+                    eval_temp_slider = gr.Slider(0.0, 1.5, value=0.5, step=0.1, label="Crucible Temp")
+                    eval_max_tokens_slider = gr.Slider(100, 500, value=200, step=50, label="Crucible Max Tokens")
+                with gr.Row():
+                    evolve_temp_slider = gr.Slider(0.0, 1.5, value=0.8, step=0.1, label="Evolution Temp")
+                    evolve_max_tokens_slider = gr.Slider(100, 1000, value=400, step=50, label="Evolution Max Tokens")
+
+            submit_btn = gr.Button("🚀 ENGAGE ALGOFORGE PRIME™ 🚀", variant="primary", size="lg")
 
         with gr.Column(scale=2):
-            gr.Markdown("## II. Evolutionary Trajectory & Artifacts")
+            gr.Markdown("## 🔥 3. The Forge's Output")
             with gr.Tabs():
-                with gr.TabItem("🧬 Genesis & Evaluation Matrix"):
-                    output_initial_candidates = gr.Markdown(label="Primary Solution Candidates & Heuristic Analysis")
-                with gr.TabItem("🌟 Apex Candidate"):
-                    output_apex_candidate = gr.Markdown(label="Selected Evolutionary Path (Input to Refinement Stage)")
-                with gr.TabItem("💡 Synthesized Advancement"):
-                    output_refined_solution = gr.Markdown(label="Refined Algorithmic Construct")
-                with gr.TabItem("📜 Architect's Blueprint (LLM Dialogues)"):
-                    output_developer_prompts = gr.Markdown(label="Simulated/Actual Prompts to Cognitive Core")
-                with gr.TabItem("📋 Cycle Report"):
-                    output_master_log = gr.Markdown(label="Comprehensive Log of the Evolutionary Cycle")
-
-    launch_evolution_btn.click(
-        orchestrate_evolutionary_cycle,
-        inputs=[input_problem_domain, input_problem_statement, input_cognitive_catalysts, input_divergence_factor],
-        outputs=[output_initial_candidates, output_apex_candidate, output_refined_solution, output_developer_prompts, output_master_log]
+                with gr.TabItem("📜 Genesis Candidates & Crucible Verdicts"):
+                    output_initial_solutions_md = gr.Markdown(label="LLM-Generated Initial Solutions & 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")
+                with gr.TabItem("🛠️ LLM Interaction Log (SRE View)"):
+                    output_interaction_log_md = gr.Markdown(label="Detailed Log of LLM Prompts & (Snippets of) Responses")
+
+    submit_btn.click(
+        fn=run_algoforge_simulation,
+        inputs=[
+            problem_type_dd, problem_desc_tb, initial_hints_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
+        ]
     )
 
     gr.Markdown("---")
-    gr.Markdown("**Aelius Kaizen's Disclaimer:** EvoForge Prime is a conceptual instrument designed to illuminate the *potential* of AI in algorithmic innovation. The 'Cognitive Core' (LLM) responses are probabilistic and serve as creative springboards, not definitive solutions. True algorithmic breakthroughs require rigorous mathematical proof, empirical validation, and the irreplaceable spark of human ingenuity complementing AI's prowess. This is but a humble step on a grand journey.")
+    gr.Markdown(
+        "**Disclaimer:** As the architect of this marvel, I must remind you: this is a *conceptual demonstration*. Real AI-driven algorithm discovery is vastly more complex and resource-intensive. LLM outputs are probabilistic and require rigorous human oversight and verification. This tool is for inspiration and exploration, not production deployment of unverified algorithms. Handle with brilliance and caution!"
+        "\n\n*Powered by Gradio, Hugging Face Inference API, and the boundless spirit of innovation.*"
+    )
 
-# To launch this marvel locally: python your_script_name.py
-# For Hugging Face Spaces, this file is 'app.py'. Include 'requirements.txt'.
+# To launch this magnificent creation:
 if __name__ == "__main__":
-    evo_forge_interface.launch(share=False) # Set share=True for a public link if running locally
+    if not HF_TOKEN:
+        print("="*80)
+        print("WARNING: HF_TOKEN environment variable not set.")
+        print("AlgoForge Prime™ requires this token to communicate with Hugging Face LLMs.")
+        print("Please set it in your environment or Space Secrets.")
+        print("The UI will load, but LLM functionality will be disabled.")
+        print("="*80)
+    demo.launch(debug=True) # Debug=True is useful for local development