Update app.py

app.py

@@ -1,425 +1,299 @@
-# algoforge_prime/app.py
+# storyverse_weaver/app.py
 import gradio as gr
 import os
 import time
-import json # For potentially displaying structured data or passing complex states
+from PIL import Image
 
 # --- Core Logic Imports ---
-from core.llm_clients import initialize_all_clients, is_gemini_api_configured, is_hf_api_configured
-initialize_all_clients() 
-
-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, EvaluationResultOutput
-from core.evolution_engine import evolve_solution
-from prompts.system_prompts import get_system_prompt
-from prompts.prompt_templates import format_code_test_analysis_user_prompt
-from core.safe_executor import execute_python_code_with_tests, ExecutionResult # For re-evaluating
-
-# --- Application Configuration ---
-# (This section should ideally move to a config file or env vars for production)
-AVAILABLE_MODELS_CONFIG = {}
-UI_DEFAULT_MODEL_KEY = None
-GEMINI_1_5_PRO_LATEST_ID = "gemini-1.5-pro-latest" # Ensure this is the correct ID usable via API
-GEMINI_1_5_FLASH_LATEST_ID = "gemini-1.5-flash-latest"
-
-if GEMINI_API_READY:
-    AVAILABLE_MODELS_CONFIG.update({
-        f"✨ Google Gemini 1.5 Pro (API)": {"id": GEMINI_1_5_PRO_LATEST_ID, "type": "google_gemini"},
-        f"⚡ Google Gemini 1.5 Flash (API)": {"id": GEMINI_1_5_FLASH_LATEST_ID, "type": "google_gemini"},
-        "Legacy Gemini 1.0 Pro (API)": {"id": "gemini-1.0-pro-latest", "type": "google_gemini"},
-    })
-    UI_DEFAULT_MODEL_KEY = f"✨ Google Gemini 1.5 Pro (API)"
-    if UI_DEFAULT_MODEL_KEY not in AVAILABLE_MODELS_CONFIG: 
-        UI_DEFAULT_MODEL_KEY = f"⚡ Google Gemini 1.5 Flash (API)"
-else: print("WARNING: app.py - Gemini API not configured.")
-
-if HF_API_READY:
-    AVAILABLE_MODELS_CONFIG.update({
-        "Gemma 2B (HF Test)": {"id": "google/gemma-2b-it", "type": "hf"},
-        "Mistral 7B (HF)": {"id": "mistralai/Mistral-7B-Instruct-v0.2", "type": "hf"},
-    })
-    if not UI_DEFAULT_MODEL_KEY: UI_DEFAULT_MODEL_KEY = "Gemma 2B (HF Test)"
-else: print("WARNING: app.py - HF API not configured.")
-
-if not AVAILABLE_MODELS_CONFIG:
-    AVAILABLE_MODELS_CONFIG["No Models Available (Setup API Keys!)"] = {"id": "dummy_error", "type": "none"}
-    UI_DEFAULT_MODEL_KEY = "No Models Available (Setup API Keys!)"
-elif not UI_DEFAULT_MODEL_KEY and AVAILABLE_MODELS_CONFIG: 
-    UI_DEFAULT_MODEL_KEY = list(AVAILABLE_MODELS_CONFIG.keys())[0]
-
-# --- UI Customization (Conceptual - real CSS would be in a file) ---
-# For a "WOW" UI, you'd link a custom CSS file.
-# Here's a conceptual placeholder for some styles we might imply.
-APP_THEME = gr.themes.Soft(
-    primary_hue=gr.themes.colors.blue, 
-    secondary_hue=gr.themes.colors.sky,
-    neutral_hue=gr.themes.colors.slate,
-    font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "system-ui", "sans-serif"],
-).set(
-    # Example: input_background_fill="rgba(240, 240, 240, 0.5)" # Slightly transparent inputs
-    # button_primary_background_fill="linear-gradient(to bottom right, hsl(210, 80%, 50%), hsl(210, 100%, 30%))"
+from core.llm_services import initialize_text_llms, is_gemini_text_ready, is_hf_text_ready, generate_text_gemini, generate_text_hf
+from core.image_services import initialize_image_llms, STABILITY_API_CONFIGURED, OPENAI_DALLE_CONFIGURED, generate_image_stabilityai, generate_image_dalle # Add other providers if implemented
+from core.story_engine import Story, Scene # Manages the story
+from prompts.narrative_prompts import get_narrative_system_prompt, format_narrative_user_prompt
+from prompts.image_style_prompts import STYLE_PRESETS, COMMON_NEGATIVE_PROMPTS, format_image_generation_prompt
+from core.utils import basic_text_cleanup
+
+# --- Initialize Services ---
+initialize_text_llms()
+initialize_image_llms()
+
+# --- Available Model Configuration (Simplified for StoryVerse) ---
+# Text Models
+TEXT_MODELS = {}
+if is_gemini_text_ready():
+    TEXT_MODELS["Gemini 1.5 Flash (Text)"] = {"id": "gemini-1.5-flash-latest", "type": "gemini"}
+    TEXT_MODELS["Gemini 1.0 Pro (Text)"] = {"id": "gemini-1.0-pro-latest", "type": "gemini"}
+if is_hf_text_ready():
+    TEXT_MODELS["Mistral 7B (HF Text)"] = {"id": "mistralai/Mistral-7B-Instruct-v0.2", "type": "hf_text"}
+DEFAULT_TEXT_MODEL_KEY = list(TEXT_MODELS.keys())[0] if TEXT_MODELS else "No Text Models Available"
+
+# Image Models (Providers)
+IMAGE_PROVIDERS = {}
+if STABILITY_API_CONFIGURED: IMAGE_PROVIDERS["Stability AI (Stable Diffusion XL)"] = "stability_ai"
+if OPENAI_DALLE_CONFIGURED: IMAGE_PROVIDERS["OpenAI DALL-E 3 (Simulated)"] = "dalle"
+# Add other HF image models if you implement image_services.generate_image_hf_model
+DEFAULT_IMAGE_PROVIDER_KEY = list(IMAGE_PROVIDERS.keys())[0] if IMAGE_PROVIDERS else "No Image Providers Available"
+
+
+# --- Gradio UI Theme and CSS ---
+story_theme = gr.themes.Soft(
+    primary_hue=gr.themes.colors.purple, 
+    secondary_hue=gr.themes.colors.pink,
+    font=[gr.themes.GoogleFont("Quicksand"), "ui-sans-serif", "system-ui", "sans-serif"]
 )
+custom_css = """
+.gradio-container { max-width: 1200px !important; margin: auto !important; }
+.panel_image img { object-fit: contain; width: 100%; height: 100%; max-height: 512px; }
+.gallery_output .thumbnail-item { height: 150px !important; width: 150px !important; }
+.gallery_output .thumbnail-item img { height: 100% !important; width: 100% !important; object-fit: cover !important; }
+.status_text { font-weight: bold; padding: 8px; text-align: center; border-radius: 5px; margin-top:10px;}
+.error_text { background-color: #ffebee; color: #c62828; }
+.success_text { background-color: #e8f5e9; color: #2e7d32; }
+.processing_text { background-color: #e3f2fd; color: #1565c0; }
+.compact-row .gr-form {gap: 8px !important;} /* Reduce gap in rows */
+"""
 
-# --- Main Orchestration Logic (More detailed progress and error handling for UI) ---
-def run_algoforge_orchestrator_ui_wrapper(
-    problem_type_selected: str, problem_description_text: str, initial_hints_text: str, 
-    user_provided_tests_code: str, 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,
-    # Gradio's Request object can give session info if needed for advanced state
-    # request: gr.Request 
+# --- StoryVerse Weaver Orchestrator ---
+def add_scene_to_story(
+    current_story_obj: Story, # Comes from gr.State
+    scene_prompt_text: str,
+    image_style_dropdown: str,
+    artist_style_text: str,
+    negative_prompt_text: str,
+    text_model_key: str,
+    image_provider_key: str,
+    progress=gr.Progress(track_tqdm=True)
 ):
-    # This wrapper allows for more fine-grained UI updates via yielding
-    # and handles the overall try-except for better error display.
-
-    log_accumulator = [f"**AlgoForge Omega™ Cycle Starting at {time.strftime('%Y-%m-%d %H:%M:%S')}**\n"]
-    # Initial state for UI outputs
-    yield {
-        output_status_bar: gr.HTML(value="<p style='color: dodgerblue;'>🚀 Initializing AlgoForge Omega™...</p>", visible=True),
-        output_initial_solutions_accordion: gr.Accordion(label="⏳ Generating Initial Candidates...", open=False, visible=True),
-        output_initial_solutions_markdown: gr.Markdown(value="Working...", visible=True),
-        output_champion_accordion: gr.Accordion(label="⏳ Awaiting Champion Selection...", open=False, visible=False),
-        output_champion_markdown: gr.Markdown(value="", visible=False),
-        output_evolved_accordion: gr.Accordion(label="⏳ Awaiting Evolution...", open=False, visible=False),
-        output_evolved_markdown: gr.Markdown(value="", visible=False),
-        output_ai_test_analysis_markdown: gr.Markdown(value="", visible=False),
-        output_interaction_log_markdown: gr.Markdown(value="\n".join(log_accumulator), visible=True),
-        engage_button: gr.Button(interactive=False) # Disable button during run
-    }
-
-    try:
-        start_time = time.time()
-
-        if not problem_description_text.strip():
-            raise ValueError("Problem Description is mandatory.")
-
-        current_model_config = AVAILABLE_MODELS_CONFIG.get(selected_model_ui_key)
-        if not current_model_config or current_model_config["type"] == "none":
-            raise ValueError(f"No valid LLM selected ('{selected_model_ui_key}'). Check API key configurations.")
-        
-        log_accumulator.append(f"Selected Model: {selected_model_ui_key} (Type: {current_model_config['type']}, ID: {current_model_config['id']})")
-        log_accumulator.append(f"Problem Type: {problem_type_selected}")
-        log_accumulator.append(f"User Tests Provided: {'Yes' if user_provided_tests_code.strip() else 'No'}\n")
-        yield { output_interaction_log_markdown: gr.Markdown(value="\n".join(log_accumulator)) }
+    if not scene_prompt_text.strip():
+        return current_story_obj, None, "<p class='error_text status_text'>Scene prompt cannot be empty!</p>"
 
+    progress(0, desc="Initializing new scene...")
+    log_updates = ["Starting new scene generation..."]
 
-        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 ---
-        yield { output_status_bar: gr.HTML(value="<p style='color: dodgerblue;'>🧬 Stage 1: Genesis Engine - Generating Solutions...</p>") }
-        log_accumulator.append("**------ 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_accumulator.append(f"Genesis Engine produced {len(initial_raw_solutions)} raw candidate(s).")
-        for i, sol_text in enumerate(initial_raw_solutions): log_accumulator.append(f"  Candidate {i+1} (Raw Snippet): {str(sol_text)[:100]}...")
-        yield { output_interaction_log_markdown: gr.Markdown(value="\n".join(log_accumulator)) }
-
-
-        # --- STAGE 2: CRITIQUE & AUTOMATED EVALUATION ---
-        yield { 
-            output_status_bar: gr.HTML(value="<p style='color: dodgerblue;'>🔬 Stage 2: Critique Crucible - Evaluating Candidates...</p>"),
-            output_initial_solutions_accordion: gr.Accordion(label="Initial Candidates & Evaluations (Processing...)", open=True)
-        }
-        log_accumulator.append("\n**------ STAGE 2: CRITIQUE CRUCIBLE & AUTOMATED EVALUATION ------**")
-        evaluated_candidates_list = []
-        initial_solutions_md_accumulator = ["**Initial Candidates & Detailed Evaluations:**\n"]
-
-        for i, candidate_solution_text in enumerate(initial_raw_solutions):
-            log_accumulator.append(f"\n--- Evaluating Candidate {i+1} ---")
-            yield { output_status_bar: gr.HTML(value=f"<p style='color: dodgerblue;'>🔬 Evaluating Candidate {i+1} of {num_initial_solutions_to_gen}...</p>") }
-            
-            evaluation_output_obj = evaluate_solution_candidate(str(candidate_solution_text), problem_description_text, problem_type_selected, user_provided_tests_code, llm_config_critique)
-            evaluated_candidates_list.append({"id": i + 1, "solution_text": str(candidate_solution_text), "evaluation_obj": evaluation_output_obj})
-            
-            log_accumulator.append(f"  Combined Score: {evaluation_output_obj.combined_score}/10")
-            # ... (more detailed logging from evaluation_obj as before)
-            
-            # Update UI with this candidate's evaluation progressively
-            current_eval_md = (
-                f"**Candidate {i+1} (Score: {evaluation_output_obj.combined_score}/10):**\n"
-                f"```python\n{str(candidate_solution_text)}\n```\n\n"
-                f"**Evaluation Verdict:**\n{evaluation_output_obj.get_display_critique()}\n---"
-            )
-            initial_solutions_md_accumulator.append(current_eval_md)
-            yield { 
-                output_initial_solutions_markdown: gr.Markdown(value="\n".join(initial_solutions_md_accumulator)),
-                output_interaction_log_markdown: gr.Markdown(value="\n".join(log_accumulator))
-            }
-        
-        # --- STAGE 3: SELECTION OF CHAMPION ---
-        yield { output_status_bar: gr.HTML(value="<p style='color: dodgerblue;'>🏆 Stage 3: Selecting Champion Candidate...</p>") }
-        log_accumulator.append("\n**------ STAGE 3: CHAMPION SELECTION ------**")
-        potentially_viable_candidates = [c for c in evaluated_candidates_list if c["evaluation_obj"] and c["evaluation_obj"].combined_score > 0 and not str(c["solution_text"]).startswith("ERROR")]
+    # --- 1. Generate Narrative Text ---
+    progress(0.2, desc="Generating narrative...")
+    narrative_text_generated = "Narrative generation failed."
+    text_model_info = TEXT_MODELS.get(text_model_key)
+    
+    if text_model_info:
+        system_p = get_narrative_system_prompt("default") # or "comic"
+        # Could use last scene's narrative for context if desired
+        # prev_narrative = current_story_obj.get_last_scene_narrative() 
+        user_p = format_narrative_user_prompt(scene_prompt_text) #, prev_narrative)
+
+        text_response = None
+        if text_model_info["type"] == "gemini":
+            text_response = generate_text_gemini(user_p, model_id=text_model_info["id"], system_prompt=system_p, max_tokens=300)
+        elif text_model_info["type"] == "hf_text":
+            text_response = generate_text_hf(user_p, model_id=text_model_info["id"], system_prompt=system_p, max_tokens=300)
         
-        if not potentially_viable_candidates:
-            raise ValueError("No viable candidate solutions found after evaluation. All attempts may have failed or scored too low.")
+        if text_response and text_response.success:
+            narrative_text_generated = basic_text_cleanup(text_response.text)
+            log_updates.append(f"Narrative generated using {text_model_key}.")
+        elif text_response:
+            narrative_text_generated = f"Narrative Error: {text_response.error}"
+            log_updates.append(f"Narrative generation FAILED with {text_model_key}: {text_response.error}")
+        else:
+             log_updates.append(f"Narrative generation FAILED with {text_model_key}: No response object.")
+    else:
+        narrative_text_generated = "Selected text model not available."
+        log_updates.append("Narrative generation FAILED: Text model not found.")
 
-        champion_candidate_data = sorted(potentially_viable_candidates, key=lambda x: x["evaluation_obj"].combined_score, reverse=True)[0]
-        log_accumulator.append(f"Champion Selected: Candidate {champion_candidate_data['id']} with score {champion_candidate_data['evaluation_obj'].combined_score}/10.")
-        champion_display_markdown = (
-            f"**Champion Candidate ID: {champion_candidate_data['id']} "
-            f"(Original Score: {champion_candidate_data['evaluation_obj'].combined_score}/10):**\n"
-            f"```python\n{champion_candidate_data['solution_text']}\n```\n\n"
-            f"**Original Comprehensive Evaluation:**\n{champion_candidate_data['evaluation_obj'].get_display_critique()}"
-        )
-        yield { 
-            output_champion_accordion: gr.Accordion(label=f"🏆 Champion: Candidate {champion_candidate_data['id']} (Score: {champion_candidate_data['evaluation_obj'].combined_score}/10)", open=True, visible=True),
-            output_champion_markdown: gr.Markdown(value=champion_display_markdown, visible=True),
-            output_interaction_log_markdown: gr.Markdown(value="\n".join(log_accumulator))
-        }
 
-        # --- STAGE 4: EVOLUTIONARY FORGE ---
-        yield { output_status_bar: gr.HTML(value="<p style='color: dodgerblue;'>🛠️ Stage 4: Evolutionary Forge - Refining Champion...</p>") }
-        log_accumulator.append("\n**------ STAGE 4: EVOLUTIONARY FORGE ------**")
-        evolved_solution_code = evolve_solution(
-            str(champion_candidate_data["solution_text"]), champion_candidate_data["evaluation_obj"],
-            problem_description_text, problem_type_selected, llm_config_evolution
+    # --- 2. Generate Image ---
+    progress(0.6, desc="Generating image...")
+    image_generated = None
+    image_error = None
+    selected_image_provider = IMAGE_PROVIDERS.get(image_provider_key)
+    
+    # Use the generated narrative (or original prompt if narrative failed) for image prompt
+    image_content_prompt = narrative_text_generated if narrative_text_generated and "Error" not in narrative_text_generated else scene_prompt_text
+    full_image_prompt = format_image_generation_prompt(image_content_prompt[:300], image_style_dropdown, artist_style_text) # Limit prompt length for image gen
+    
+    if selected_image_provider:
+        image_response = None
+        if selected_image_provider == "stability_ai":
+            image_response = generate_image_stabilityai(full_image_prompt, style_preset=None, negative_prompt=negative_prompt_text or COMMON_NEGATIVE_PROMPTS)
+        elif selected_image_provider == "dalle":
+            image_response = generate_image_dalle(full_image_prompt) # Uses default DALL-E settings from image_services
+        # Add elif for HF image models if implemented
+
+        if image_response and image_response.success:
+            image_generated = image_response.image
+            log_updates.append(f"Image generated using {image_provider_key}.")
+        elif image_response:
+            image_error = f"Image Error ({image_provider_key}): {image_response.error}"
+            log_updates.append(f"Image generation FAILED with {image_provider_key}: {image_response.error}")
+        else:
+            image_error = f"Image generation failed: No response from {image_provider_key} service."
+            log_updates.append(f"Image generation FAILED with {image_provider_key}: No response object.")
+    else:
+        image_error = "Selected image provider not available."
+        log_updates.append("Image generation FAILED: Image provider not found.")
+
+    # --- 3. Add Scene to Story Object ---
+    if image_error and "Error" in narrative_text_generated: # Both failed
+        current_story_obj.add_scene_with_error(scene_prompt_text, f"Narrative: {narrative_text_generated}. Image: {image_error}")
+    else:
+        current_story_obj.add_scene_from_elements(
+            user_prompt=scene_prompt_text,
+            narrative_text=narrative_text_generated,
+            image=image_generated,
+            image_style_prompt=f"{image_style_dropdown}{f', by {artist_style_text}' if artist_style_text else ''}",
+            image_provider=image_provider_key
         )
-        log_accumulator.append(f"Raw Evolved Solution (Snippet): {str(evolved_solution_code)[:100]}...")
-        
-        evolved_solution_display_markdown = ""
-        ai_test_analysis_markdown = ""
-
-        if str(evolved_solution_code).startswith("ERROR"):
-            evolved_solution_display_markdown = f"<p style='color: red;'>**Evolution Stage Failed:**<br>{evolved_solution_code}</p>"
+    
+    progress(1.0, desc="Scene complete!")
+    
+    # --- 4. Prepare Outputs for Gradio ---
+    # Gallery expects list of (image_path_or_PIL, caption_string) tuples
+    gallery_items = []
+    for scene in current_story_obj.scenes:
+        caption = f"S{scene.scene_number}: {scene.user_prompt[:40]}..."
+        if scene.error_message:
+            # Create a placeholder image for errors or display error text
+            error_img = Image.new('RGB', (100,100), color='red') # Simple red square
+            gallery_items.append((error_img, f"{caption}\nError: {scene.error_message[:100]}..."))
         else:
-            evolved_solution_display_markdown = f"**✨ AlgoForge Omega™ Evolved Artifact ✨:**\n```python\n{evolved_solution_code}\n```"
-            if "python" in problem_type_selected.lower() and user_provided_tests_code.strip():
-                yield { output_status_bar: gr.HTML(value="<p style='color: dodgerblue;'>🧪 Post-Evolution: Re-testing Evolved Code...</p>") }
-                log_accumulator.append("\n--- Post-Evolution Test of Evolved Code ---")
-                from core.safe_executor import execute_python_code_with_tests # Ensure imported
-                evolved_code_exec_result = execute_python_code_with_tests(str(evolved_solution_code), user_provided_tests_code, timeout_seconds=10)
-                
-                evolved_solution_display_markdown += (
-                    f"\n\n**Post-Evolution Automated Test Results (Simulated):**\n"
-                    f"  Status: {'SUCCESS' if evolved_code_exec_result.success else 'FAILED/ERRORS'}\n"
-                    f"  Tests Attempted: {evolved_code_exec_result.total_tests}\n"
-                    f"  Tests Passed:    {evolved_code_exec_result.passed_tests}\n"
-                    f"  Execution Time:  {evolved_code_exec_result.execution_time:.4f}s\n"
-                )
-                if evolved_code_exec_result.compilation_error: evolved_solution_display_markdown += f"  Compilation Error: {evolved_code_exec_result.compilation_error}\n"
-                elif evolved_code_exec_result.timeout_error: evolved_solution_display_markdown += f"  Timeout Error.\n"
-                elif evolved_code_exec_result.error: evolved_solution_display_markdown += f"  Execution Error/Output: {evolved_code_exec_result.overall_error_summary}\n"
-                elif evolved_code_exec_result.stdout: evolved_solution_display_markdown += f"  Execution Stdout:\n```\n{evolved_code_exec_result.stdout[:300].strip()}\n```\n"
-                log_accumulator.append(f"  Evolved Code Test Results: {evolved_code_exec_result}")
-
-                if evolved_code_exec_result.total_tests > 0 :
-                    yield { output_status_bar: gr.HTML(value="<p style='color: dodgerblue;'>🧠 Post-Evolution: AI Analyzing Test Results...</p>") }
-                    log_accumulator.append("\n--- AI Analysis of Evolved Code's Test Results ---")
-                    exec_summary_for_analysis = str(evolved_code_exec_result.overall_error_summary or "Tests completed.")
-                    analysis_user_prompt = format_code_test_analysis_user_prompt(str(evolved_solution_code), user_provided_tests_code, f"Passed: {evolved_code_exec_result.passed_tests}/{evolved_code_exec_result.total_tests}. Detail: {exec_summary_for_analysis}")
-                    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 + 200}
-                    
-                    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)
-                    elif llm_analysis_config["type"] == "google_gemini": explanation_response_obj = call_gemini_api(analysis_user_prompt, llm_analysis_config["model_id"], llm_analysis_config["temp"], llm_analysis_config["max_tokens"], analysis_system_prompt)
-
-                    if explanation_response_obj and explanation_response_obj.success: 
-                        ai_test_analysis_markdown = f"**AI Analysis of Evolved Code's Test Performance:**\n{explanation_response_obj.text}"
-                    elif explanation_response_obj: 
-                        ai_test_analysis_markdown = f"<p style='color: orange;'>**AI Analysis of Test Performance Failed:**<br>{explanation_response_obj.error}</p>"
-                    log_accumulator.append(f"  AI Test Analysis result logged.")
+            gallery_items.append((scene.image if scene.image else Image.new('RGB', (100,100), color='grey'), caption)) # Grey if no image but no error
+
+    # Display the latest scene's full details
+    latest_scene_display = ""
+    if current_story_obj.scenes:
+        ls = current_story_obj.scenes[-1]
+        latest_scene_display = f"## Scene {ls.scene_number}: {ls.user_prompt}\n\n"
+        if ls.error_message:
+            latest_scene_display += f"**Error:** {ls.error_message}\n"
+        else:
+            if ls.image:
+                # Gradio Markdown can't directly display PIL.Image. We'll show it in the gallery.
+                # For single image display, use gr.Image component.
+                latest_scene_display += f"**Style:** {ls.image_style_prompt}\n\n"
+            latest_scene_display += f"{ls.narrative_text}"
+    
+    # Determine status message
+    status_message_html = ""
+    if image_error or "Error" in narrative_text_generated:
+        status_message_html = f"<p class='error_text status_text'>Scene added with errors. Narrative: {'OK' if 'Error' not in narrative_text_generated else 'Failed'}. Image: {'OK' if not image_error else 'Failed'}.</p>"
+    else:
+        status_message_html = "<p class='success_text status_text'>New scene added successfully!</p>"
         
-        total_time = time.time() - start_time
-        log_accumulator.append(f"\n**AlgoForge Omega™ Cycle Complete. Total time: {total_time:.2f} seconds.**")
-        yield {
-            output_status_bar: gr.HTML(value=f"<p style='color: green;'>✅ Cycle Complete! ({total_time:.2f}s)</p>"),
-            output_evolved_accordion: gr.Accordion(label="🌟 Evolved Artifact & Test Analysis", open=True, visible=True),
-            output_evolved_markdown: gr.Markdown(value=evolved_solution_display_markdown, visible=True),
-            output_ai_test_analysis_markdown: gr.Markdown(value=ai_test_analysis_markdown, visible=True if ai_test_analysis_markdown else False),
-            output_interaction_log_markdown: gr.Markdown(value="\n".join(log_accumulator)),
-            engage_button: gr.Button(interactive=True) # Re-enable button
-        }
+    # For the single image display component, show the latest generated image
+    latest_image_output = image_generated if image_generated else None # (or a placeholder if error)
+
+    return current_story_obj, gallery_items, latest_image_output, latest_scene_display, status_message_html, "\n".join(log_updates)
 
-    except ValueError as ve: # Catch our specific input/config errors
-        log_accumulator.append(f"\n**INPUT/CONFIG ERROR:** {ve}")
-        yield {
-            output_status_bar: gr.HTML(value=f"<p style='color: red;'>❌ CONFIGURATION ERROR: {ve}</p>", visible=True),
-            output_interaction_log_markdown: gr.Markdown(value="\n".join(log_accumulator)),
-            engage_button: gr.Button(interactive=True)
-        }
-    except Exception as e:
-        log_accumulator.append(f"\n**UNEXPECTED RUNTIME ERROR:** {type(e).__name__} - {e}\n{traceback.format_exc()}")
-        # For other outputs, we might want to clear them or show a general error message
-        yield {
-            output_status_bar: gr.HTML(value=f"<p style='color: red;'>❌ UNEXPECTED ERROR: {e}. Check logs.</p>", visible=True),
-            output_initial_solutions_markdown: gr.Markdown(value="An unexpected error occurred. Please check the interaction log."),
-            output_champion_markdown: gr.Markdown(value="Error state."),
-            output_evolved_markdown: gr.Markdown(value="Error state."),
-            output_ai_test_analysis_markdown: gr.Markdown(value="Error state."),
-            output_interaction_log_markdown: gr.Markdown(value="\n".join(log_accumulator)),
-            engage_button: gr.Button(interactive=True)
-        }
 
+def clear_story_state():
+    new_story = Story()
+    return new_story, [], None, "Story Cleared. Ready for a new verse!", "<p class='status_text'>Story Cleared</p>", "Log Cleared."
 
 # --- Gradio UI Definition ---
-# (This section is the full UI layout with improvements)
-css = """
-body { font-family: 'Inter', sans-serif; }
-.gradio-container { max-width: 1280px !important; margin: auto !important; }
-.gr-button-primary { 
-    background: linear-gradient(135deg, #007bff 0%, #0056b3 100%) !important; 
-    color: white !important;
-    border: none !important;
-    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1) !important;
-    transition: all 0.2s ease-in-out !important;
-}
-.gr-button-primary:hover { 
-    transform: translateY(-2px) !important;
-    box-shadow: 0 6px 12px rgba(0, 0, 0, 0.15) !important;
-}
-.status-bar p {
-    padding: 8px 12px;
-    border-radius: 6px;
-    font-weight: 500;
-    text-align: center;
-    margin-bottom: 10px; /* Add some space below status bar */
-}
-.accordion-section .gr-markdown { padding-top: 5px; padding-bottom: 5px; }
-.output-tabs .gr-tabitem {min-height: 400px;} /* Ensure tabs have some min height */
-"""
+with gr.Blocks(theme=story_theme, css=custom_css) as story_weaver_demo:
+    story_state = gr.State(Story()) # Manages the story object
 
-with gr.Blocks(theme=APP_THEME, css=css, title="✨ AlgoForge Omega™ ✨") as app_demo:
-    gr.Markdown("# ✨ AlgoForge Omega™ ✨\n### Conceptual AI-Powered Algorithm & Application Foundry")
-    gr.Markdown(
-        "Define a challenge, configure the AI forge, and witness the (conceptual) evolution of solutions, "
-        "now with (simulated) unit testing and more detailed feedback loops!"
-    )
+    gr.Markdown("# ✨ StoryVerse Weaver ✨\nCreate multimodal stories with AI-generated narrative and images!")
 
-    with gr.Row(equal_height=False):
-        # --- INPUT COLUMN ---
-        with gr.Column(scale=2, min_width=400):
-            gr.Markdown("## 💡 1. Define the Challenge")
-            with gr.Group():
-                problem_type_dropdown = gr.Dropdown(
-                    choices=["Python Algorithm with Tests", "Python Algorithm (Critique Only)", "General Algorithm Idea", "Conceptual System Design", "Pseudocode Refinement"],
-                    label="Problem Type", value="Python Algorithm with Tests",
-                    info="Select '...with Tests' to enable (simulated) unit testing if you provide tests below."
-                )
-                problem_description_textbox = gr.Textbox(
-                    lines=7, 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=4, label="Initial Thoughts / Constraints / Seed Ideas (Optional)",
-                    placeholder="E.g., 'Prefer an iterative solution over recursive for factorial.' or 'Consider time complexity and edge cases like empty inputs.'"
-                )
-                user_tests_textbox = gr.Textbox(
-                    lines=7, 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, simulated):\n# try:\n#   calculate_factorial(-1)\n# except ValueError:\n#   assert True\n# else:\n#   assert False, \"ValueError not raised\"",
-                    info="For 'Python Algorithm with Tests'. Ensure function names match your problem description. Basic try-except for error testing is crudely simulated."
-                )
+    # API Status Check (Conceptual - real app might hide this or make it admin-only)
+    with gr.Accordion("API & Model Status (Developer Info)", open=False):
+        status_text = []
+        if not GEMINI_API_READY and not HF_API_READY and not STABILITY_API_CONFIGURED and not OPENAI_DALLE_CONFIGURED:
+            status_text.append("<p style='color:red;font-weight:bold;'>⚠️ CRITICAL: NO APIs CONFIGURED. App will be non-functional.</p>")
+        else:
+            if GEMINI_API_READY or HF_API_READY: status_text.append("<p style='color:green;'>✅ Text LLM(s) Ready.</p>")
+            else: status_text.append("<p style='color:orange;'>⚠️ No Text LLMs Ready (Check STORYVERSE_GOOGLE_API_KEY/STORYVERSE_HF_TOKEN).</p>")
+            if STABILITY_API_CONFIGURED or OPENAI_DALLE_CONFIGURED: status_text.append("<p style='color:green;'>✅ Image Generation Service(s) Ready.</p>")
+            else: status_text.append("<p style='color:orange;'>⚠️ No Image Generation Services Ready (Check API Keys).</p>")
+        gr.HTML("".join(status_text))
+
+
+    with gr.Row():
+        # --- CONTROL PANEL (Inputs) ---
+        with gr.Column(scale=1):
+            gr.Markdown("### 🎬 Scene Input")
+            scene_prompt_input = gr.Textbox(lines=5, label="Describe your scene or story beat:", placeholder="e.g., A lone astronaut discovers a glowing alien artifact on a desolate moon.")
             
-            gr.Markdown("## ⚙️ 2. Configure The Forge")
-            with gr.Group():
-                api_status_html = gr.HTML() # For dynamic API status
-                
-                # Logic to set API status text (must be done after initialize_all_clients)
-                status_messages = []
-                if not GEMINI_API_READY and not HF_API_READY:
-                    status_messages.append("<p style='color:red; font-weight:bold;'>⚠️ CRITICAL: NO APIs CONFIGURED. App non-functional.</p>")
-                else:
-                    if GEMINI_API_READY: status_messages.append("<p style='color:green;'>✅ Google Gemini API Ready.</p>")
-                    else: status_messages.append("<p style='color:orange;'>⚠️ Google Gemini API NOT Ready (Check GOOGLE_API_KEY).</p>")
-                    if HF_API_READY: status_messages.append("<p style='color:green;'>✅ Hugging Face API Ready.</p>")
-                    else: status_messages.append("<p style='color:orange;'>⚠️ Hugging Face API NOT Ready (Check HF_TOKEN).</p>")
-                api_status_html.value = "".join(status_messages)
-
-
-                model_selection_dropdown = gr.Dropdown(
-                    choices=list(AVAILABLE_MODELS_CONFIG.keys()),
-                    value=UI_DEFAULT_MODEL_KEY if UI_DEFAULT_MODEL_KEY in AVAILABLE_MODELS_CONFIG else (list(AVAILABLE_MODELS_CONFIG.keys())[0] if AVAILABLE_MODELS_CONFIG else None),
-                    label="LLM Core Model",
-                    info="Ensure the corresponding API key is correctly set in Space Secrets."
-                )
-                num_initial_solutions_slider = gr.Slider(minimum=1, maximum=4, value=2, step=1, label="# Initial Solutions (Genesis Engine)", info="More solutions take longer but provide more diversity.")
-
-                with gr.Accordion("Advanced LLM Parameters (Tune with Caution!)", open=False):
-                    with gr.Row():
-                        genesis_temp_slider = gr.Slider(minimum=0.0, maximum=1.2, 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")
-                    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=768, step=64, label="Critique Max Tokens")
-                    with gr.Row():
-                        evolution_temp_slider = gr.Slider(minimum=0.0, maximum=1.2, 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")
+            with gr.Accordion("🎨 Visual Style (Optional)", open=True):
+                image_style_input = gr.Dropdown(choices=["Default"] + list(STYLE_PRESETS.keys()), value="Default", label="Image Style Preset")
+                artist_style_input = gr.Textbox(label="Inspired by Artist (Optional):", placeholder="e.g., Van Gogh, Hayao Miyazaki, HR Giger")
+                negative_prompt_input = gr.Textbox(lines=2, label="Negative Prompt (Optional):", placeholder="e.g., blurry, text, watermark, poorly drawn", value=COMMON_NEGATIVE_PROMPTS)
+
+            with gr.Accordion("⚙️ AI Configuration (Advanced)", open=False):
+                text_model_dropdown = gr.Dropdown(choices=list(TEXT_MODELS.keys()), value=DEFAULT_TEXT_MODEL_KEY, label="Text Generation Model")
+                image_provider_dropdown = gr.Dropdown(choices=list(IMAGE_PROVIDERS.keys()), value=DEFAULT_IMAGE_PROVIDER_KEY, label="Image Generation Provider")
+                # Could add sliders for temperature, tokens etc. here later
+
+            with gr.Row(elem_classes=["compact-row"]):
+                add_scene_button = gr.Button("➕ Weave Next Scene", variant="primary")
+                clear_story_button = gr.Button("🗑️ Clear Story")
             
-            engage_button = gr.Button("🚀 ENGAGE ALGOFORGE OMEGA™ 🚀", variant="primary", size="lg", elem_id="engage_button_elem")
+            status_bar_output = gr.HTML(value="<p class='status_text'>Ready to weave...</p>")
 
-        # --- OUTPUT COLUMN ---
-        with gr.Column(scale=3, min_width=600):
-            gr.Markdown("## 🔥 3. The Forge's Output")
-            output_status_bar = gr.HTML(value="<p>Idle. Define a challenge and engage!</p>", elem_classes=["status-bar"], visible=True)
+        # --- STORY DISPLAY (Outputs) ---
+        with gr.Column(scale=2):
+            gr.Markdown("### 📖 Your StoryVerse So Far")
             
-            with gr.Tabs(elem_id="output_tabs_elem", elem_classes=["output-tabs"]):
-                with gr.TabItem("📜 Initial Candidates & Evaluations", id="tab_initial_evals"):
-                    output_initial_solutions_accordion = gr.Accordion(label="Initial Candidates & Evaluations", open=True, visible=False, elem_classes=["accordion-section"])
-                    with output_initial_solutions_accordion:
-                        output_initial_solutions_markdown = gr.Markdown(visible=True)
+            with gr.Tabs():
+                with gr.TabItem("🖼️ Latest Scene View"):
+                    latest_scene_image_output = gr.Image(label="Latest Scene Image", type="pil", interactive=False, show_download_button=True, elem_classes=["panel_image"])
+                    latest_scene_narrative_output = gr.Markdown(label="Latest Scene Narrative")
                 
-                with gr.TabItem("🏆 Champion Candidate", id="tab_champion"):
-                    output_champion_accordion = gr.Accordion(label="Champion Candidate (Pre-Evolution)", open=True, visible=False, elem_classes=["accordion-section"])
-                    with output_champion_accordion:
-                        output_champion_markdown = gr.Markdown(visible=True)
+                with gr.TabItem(" галерея | Story Scroll"): # Gallery in Russian, for fun :)
+                    story_gallery_output = gr.Gallery(label="Story Scroll", show_label=False, columns=[3], object_fit="contain", height="auto", elem_classes=["gallery_output"])
                 
-                with gr.TabItem("🌟 Evolved & Tested", id="tab_evolved"):
-                    output_evolved_accordion = gr.Accordion(label="Evolved Artifact & Test Analysis", open=True, visible=False, elem_classes=["accordion-section"])
-                    with output_evolved_accordion:
-                        output_evolved_markdown = gr.Markdown(visible=True)
-                        output_ai_test_analysis_markdown = gr.Markdown(visible=True, label="AI Analysis of Evolved Code's Tests")
-                
-                with gr.TabItem("🛠️ Interaction Log", id="tab_log"):
-                    with gr.Accordion(label="Developer Interaction Log", open=True, elem_classes=["accordion-section"]): # Always open log
-                        output_interaction_log_markdown = gr.Markdown(value="Log will appear here...", visible=True)
-        
-        # Connect button to the orchestration function wrapper
-        # The wrapper handles UI updates via yield
-        engage_button.click(
-            fn=run_algoforge_orchestrator_ui_wrapper, # Call the wrapper
-            inputs=[
-                problem_type_dropdown, problem_description_textbox, initial_hints_textbox, user_tests_textbox,
-                num_initial_solutions_slider, model_selection_dropdown,
-                genesis_temp_slider, genesis_max_tokens_slider,
-                critique_temp_slider, critique_max_tokens_slider,
-                evolution_temp_slider, evolution_max_tokens_slider
-            ],
-            outputs=[ # These are the components updated by the `yield` statements
-                output_status_bar,
-                output_initial_solutions_accordion, output_initial_solutions_markdown,
-                output_champion_accordion, output_champion_markdown,
-                output_evolved_accordion, output_evolved_markdown, output_ai_test_analysis_markdown,
-                output_interaction_log_markdown,
-                engage_button # To disable/re-enable it
-            ]
-        )
-    
-    gr.Markdown("---")
-    gr.Markdown(
-        "**Disclaimer:** This is a conceptual, educational demonstration. "
-        "The (simulated) unit testing feature is for illustrative purposes. "
-        "**NEVER run LLM-generated code from an untrusted source in an unrestricted environment.** "
-        "Implementing robust and secure code sandboxing is complex and absolutely critical for safety in real-world applications. "
-        "LLM outputs always require careful human review and verification."
+                with gr.TabItem("📜 Interaction Log"):
+                    log_output_markdown = gr.Markdown("Log will appear here...")
+
+    # --- Event Handlers ---
+    add_scene_button.click(
+        fn=add_scene_to_story,
+        inputs=[
+            story_state, scene_prompt_input, 
+            image_style_input, artist_style_input, negative_prompt_input,
+            text_model_dropdown, image_provider_dropdown
+        ],
+        outputs=[ # Order must match the return order of add_scene_to_story
+            story_state, story_gallery_output, 
+            latest_scene_image_output, latest_scene_narrative_output, 
+            status_bar_output, log_output_markdown
+        ]
+    )
+    clear_story_button.click(
+        fn=clear_story_state,
+        inputs=[],
+        outputs=[
+            story_state, story_gallery_output, 
+            latest_scene_image_output, latest_scene_narrative_output, 
+            status_bar_output, log_output_markdown
+        ]
     )
-    gr.HTML("<p style='text-align:center; font-size:0.9em; color:grey;'>AlgoForge Omega™ - Powered by Gradio, Gemini & Hugging Face Models</p>")
 
+    # Example Prompts for User
+    gr.Examples(
+        examples=[
+            ["A knight faces a dragon in a fiery volcano.", "Fantasy Art", "Frank Frazetta", "blurry, low quality"],
+            ["A futuristic detective investigates a crime in a neon-lit alley.", "Cyberpunk", "Syd Mead", "cartoon, painting"],
+            ["Two children discover a hidden portal in an old oak tree.", "Studio Ghibli Inspired", "", "dark, scary"],
+            ["A single red rose blooming in a post-apocalyptic wasteland.", "Photorealistic", "Ansel Adams", "oversaturated, vibrant"],
+        ],
+        inputs=[scene_prompt_input, image_style_input, artist_style_input, negative_prompt_input],
+        label="✨ Example Scene Ideas & Styles ✨"
+    )
 
-# --- Entry Point for Running the Gradio App ---
+# --- Entry Point ---
 if __name__ == "__main__":
     print("="*80)
-    print("AlgoForge Omega™ Conceptual Demo (WOW UI Attempt) - Launching...")
-    print(f"  Google Gemini API Configured (from app.py check): {GEMINI_API_READY}")
-    print(f"  Hugging Face API Configured (from app.py check): {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("✨ StoryVerse Weaver™ - Multimodal Story Creator - Launching... ✨")
+    print(f"  Text LLM Ready (Gemini): {is_gemini_text_ready()}")
+    print(f"  Text LLM Ready (HF): {is_hf_text_ready()}")
+    print(f"  Image Provider Ready (Stability AI): {STABILITY_API_CONFIGURED}")
+    print(f"  Image Provider Ready (DALL-E): {OPENAI_DALLE_CONFIGURED}")
+    if not (is_gemini_text_ready() or is_hf_text_ready()) or not (STABILITY_API_CONFIGURED or OPENAI_DALLE_CONFIGURED):
+        print("  🔴 WARNING: Not all required API services are configured. Functionality will be limited or fail.")
+        print("     Please set: STORYVERSE_GOOGLE_API_KEY (for Gemini text), and/or STORYVERSE_HF_TOKEN (for HF text),")
+        print("     AND STORYVERSE_STABILITY_API_KEY (for Stability AI images) or STORYVERSE_OPENAI_API_KEY (for DALL-E images) in your environment/secrets.")
+    print(f"  Default Text Model: {DEFAULT_TEXT_MODEL_KEY}")
+    print(f"  Default Image Provider: {DEFAULT_IMAGE_PROVIDER_KEY}")
+    print(f"  Available Text Models: {list(TEXT_MODELS.keys())}")
+    print(f"  Available Image Providers: {list(IMAGE_PROVIDERS.keys())}")
     print("="*80)
-    app_demo.launch(debug=True, server_name="0.0.0.0")
+    story_weaver_demo.launch(debug=True, server_name="0.0.0.0")