Update app.py

app.py

@@ -1,7 +1,7 @@
 import gradio as gr
 import torch
-from diffusers import StableDiffusionPipeline, EulerAncestralDiscreteScheduler
-from PIL import Image
+from diffusers import StableDiffusionPipeline, EulerAncestralDiscreteScheduler, StableDiffusionInpaintPipeline
+from PIL import Image, ImageDraw
 import io
 import requests
 import os
@@ -9,7 +9,7 @@ from datetime import datetime
 import re
 import time
 import json
-from typing import List, Optional, Dict
+from typing import List, Optional, Dict, Tuple
 from fastapi import FastAPI, HTTPException, BackgroundTasks
 from pydantic import BaseModel
 import gc
@@ -19,6 +19,7 @@ import uuid
 import hashlib
 from enum import Enum
 import random
+import numpy as np
 
 # External OCI API URL - YOUR BUCKET SAVING API
 OCI_API_BASE_URL = "https://yukee1992-oci-story-book.hf.space"
@@ -29,7 +30,7 @@ os.makedirs(PERSISTENT_IMAGE_DIR, exist_ok=True)
 print(f"📁 Created local image directory: {PERSISTENT_IMAGE_DIR}")
 
 # Initialize FastAPI app
-app = FastAPI(title="Storybook Generator API")
+app = FastAPI(title="Dual-Pipeline Storybook Generator API")
 
 # Add CORS middleware
 from fastapi.middleware.cors import CORSMiddleware
@@ -44,6 +45,9 @@ app.add_middleware(
 # Job Status Enum
 class JobStatus(str, Enum):
     PENDING = "pending"
+    GENERATING_CHARACTERS = "generating_characters"
+    GENERATING_BACKGROUNDS = "generating_backgrounds"
+    COMPOSING_SCENES = "composing_scenes"
     PROCESSING = "processing"
     COMPLETED = "completed"
     FAILED = "failed"
@@ -52,23 +56,26 @@ class JobStatus(str, Enum):
 class StoryScene(BaseModel):
     visual: str
     text: str
-    characters_present: List[str] = []  # Which characters are in this scene
-    scene_type: str = "general"  # "action", "dialogue", "establishing", etc.
+    characters_present: List[str] = []
+    scene_type: str = "general"
+    background_context: str = ""
 
 class CharacterDescription(BaseModel):
     name: str
     description: str
-    visual_prompt: str = ""  # Detailed visual description for AI
-    key_features: List[str] = []  # Critical features that must stay consistent
+    visual_prompt: str = ""
+    key_features: List[str] = []
+    pose_reference: str = "standing naturally"
 
 class StorybookRequest(BaseModel):
     story_title: str
     scenes: List[StoryScene]
     characters: List[CharacterDescription] = []
-    model_choice: str = "dreamshaper-8"
+    model_choice: str = "sd-1.5"  # CHANGED: Default to working model
     style: str = "childrens_book"
     callback_url: Optional[str] = None
-    consistency_seed: Optional[int] = None  # For consistent character generation
+    consistency_seed: Optional[int] = None
+    pipeline_type: str = "standard"
 
 class JobStatusResponse(BaseModel):
     job_id: str
@@ -79,16 +86,14 @@ class JobStatusResponse(BaseModel):
     created_at: float
     updated_at: float
 
-# HIGH-QUALITY MODEL SELECTION
+# UPDATED MODEL CHOICES - Only use working models
 MODEL_CHOICES = {
-    "dreamshaper-8": "lykon/dreamshaper-8",
-    "realistic-vision": "SG161222/Realistic_Vision_V5.1",
-    "anything-v5": "andite/anything-v5.0",
-    "openjourney": "prompthero/openjourney",
-    "sd-2.1": "stabilityai/stable-diffusion-2-1",
+    "sd-1.5": "runwayml/stable-diffusion-v1-5",  # Most reliable
+    "openjourney": "prompthero/openjourney",     # Public & free
+    "sd-2.1": "stabilityai/stable-diffusion-2-1", # Public alternative
 }
 
-# FALLBACK CHARACTER TEMPLATES (used only if n8n doesn't provide character details)
+# FALLBACK CHARACTER TEMPLATES
 FALLBACK_CHARACTER_TEMPLATES = {
     "Sparkle the Star Cat": {
         "visual_prompt": "small white kitten with distinctive silver star-shaped spots on fur, big golden eyes, shiny blue collar with star charm, playful expression",
@@ -97,22 +102,20 @@ FALLBACK_CHARACTER_TEMPLATES = {
     "Benny the Bunny": {
         "visual_prompt": "fluffy brown rabbit with long ears, bright green eyes, red scarf around neck, cheerful expression",
         "key_features": ["red scarf", "long ears", "green eyes", "brown fur"],
-    },
-    "Tilly the Turtle": {
-        "visual_prompt": "gentle green turtle with shiny turquoise shell decorated with swirl patterns, wise expression, slow-moving",
-        "key_features": ["turquoise shell", "swirl patterns", "green skin", "wise expression"],
     }
 }
 
 # GLOBAL STORAGE
 job_storage = {}
 model_cache = {}
+inpaint_pipe = None
 current_model_name = None
 current_pipe = None
 model_lock = threading.Lock()
 
-def load_model(model_name="dreamshaper-8"):
-    """Thread-safe model loading with HIGH-QUALITY settings"""
+# FIXED MODEL LOADING - With fallback like old script
+def load_model(model_name="sd-1.5"):
+    """Thread-safe model loading with FALLBACK like old working script"""
     global model_cache, current_model_name, current_pipe
     
     with model_lock:
@@ -121,9 +124,9 @@ def load_model(model_name="dreamshaper-8"):
             current_model_name = model_name
             return current_pipe
         
-        print(f"🔄 Loading HIGH-QUALITY model: {model_name}")
+        print(f"🔄 Loading model: {model_name}")
         try:
-            model_id = MODEL_CHOICES.get(model_name, "lykon/dreamshaper-8")
+            model_id = MODEL_CHOICES.get(model_name, "runwayml/stable-diffusion-v1-5")
             
             pipe = StableDiffusionPipeline.from_pretrained(
                 model_id, 
@@ -139,24 +142,57 @@ def load_model(model_name="dreamshaper-8"):
             current_pipe = pipe
             current_model_name = model_name
             
-            print(f"✅ HIGH-QUALITY Model loaded: {model_name}")
+            print(f"✅ Model loaded: {model_name}")
             return pipe
             
         except Exception as e:
             print(f"❌ Model loading failed: {e}")
-            return StableDiffusionPipeline.from_pretrained(
-                "runwayml/stable-diffusion-v1-5", 
-                torch_dtype=torch.float32,
-                safety_checker=None,
-                requires_safety_checker=False
-            ).to("cpu")
+            # FALLBACK TO SD 1.5 LIKE OLD SCRIPT
+            print("🔄 Falling back to stable-diffusion-v1-5")
+            try:
+                fallback_pipe = StableDiffusionPipeline.from_pretrained(
+                    "runwayml/stable-diffusion-v1-5", 
+                    torch_dtype=torch.float32,
+                    safety_checker=None,
+                    requires_safety_checker=False
+                ).to("cpu")
+                model_cache["sd-1.5"] = fallback_pipe
+                return fallback_pipe
+            except Exception as fallback_error:
+                print(f"❌ Fallback model also failed: {fallback_error}")
+                return None
+
+def load_inpaint_model():
+    """Load inpainting model for composition"""
+    global inpaint_pipe
+    
+    if inpaint_pipe is not None:
+        return inpaint_pipe
+    
+    print("🔄 Loading inpainting model...")
+    try:
+        inpaint_pipe = StableDiffusionInpaintPipeline.from_pretrained(
+            "runwayml/stable-diffusion-inpainting",
+            torch_dtype=torch.float32,
+            safety_checker=None,
+            requires_safety_checker=False
+        )
+        inpaint_pipe = inpaint_pipe.to("cpu")
+        print("✅ Inpainting model loaded")
+        return inpaint_pipe
+    except Exception as e:
+        print(f"❌ Inpainting model failed: {e}")
+        return None
+
+# Initialize models
+print("🚀 Initializing Dual-Pipeline Storybook Generator API...")
+load_model("sd-1.5")  # CHANGED: Initialize with working model
+print("✅ Models loaded and ready!")
 
-# Initialize default model
-print("🚀 Initializing Storybook Generator API...")
-load_model("dreamshaper-8")
-print("✅ Model loaded and ready!")
+# ============================================================================
+# CHARACTER PROCESSING FUNCTIONS (from old script - working)
+# ============================================================================
 
-# DYNAMIC CHARACTER PROCESSING FUNCTIONS
 def process_character_descriptions(characters_from_request):
     """Process character descriptions from n8n and create consistency templates"""
     character_templates = {}
@@ -164,14 +200,11 @@ def process_character_descriptions(characters_from_request):
     for character in characters_from_request:
         char_name = character.name
         
-        # Use provided visual_prompt or generate from description
         if character.visual_prompt:
             visual_prompt = character.visual_prompt
         else:
-            # Generate visual prompt from description
             visual_prompt = generate_visual_prompt_from_description(character.description, char_name)
         
-        # Use provided key_features or extract from description
         if character.key_features:
             key_features = character.key_features
         else:
@@ -181,7 +214,7 @@ def process_character_descriptions(characters_from_request):
             "visual_prompt": visual_prompt,
             "key_features": key_features,
             "consistency_keywords": f"consistent character, same {char_name.split()[-1].lower()}, maintaining appearance",
-            "source": "n8n_request"  # Track where this template came from
+            "source": "n8n_request"
         }
     
     print(f"✅ Processed {len(character_templates)} characters from n8n request")
@@ -189,10 +222,8 @@ def process_character_descriptions(characters_from_request):
 
 def generate_visual_prompt_from_description(description, character_name):
     """Generate a visual prompt from character description"""
-    # Basic extraction of visual elements
     description_lower = description.lower()
     
-    # Extract species/type
     species_keywords = ["kitten", "cat", "rabbit", "bunny", "turtle", "dog", "bird", "dragon", "bear", "fox"]
     species = "character"
     for keyword in species_keywords:
@@ -200,21 +231,18 @@ def generate_visual_prompt_from_description(description, character_name):
             species = keyword
             break
     
-    # Extract colors
     color_keywords = ["white", "black", "brown", "red", "blue", "green", "yellow", "golden", "silver", "orange"]
     colors = []
     for color in color_keywords:
         if color in description_lower:
             colors.append(color)
     
-    # Extract distinctive features
     feature_keywords = ["spots", "stripes", "collar", "scarf", "shell", "wings", "horn", "tail", "ears", "eyes"]
     features = []
     for feature in feature_keywords:
         if feature in description_lower:
             features.append(feature)
     
-    # Build visual prompt
     visual_prompt_parts = []
     if colors:
         visual_prompt_parts.append(f"{' '.join(colors)} {species}")
@@ -226,7 +254,6 @@ def generate_visual_prompt_from_description(description, character_name):
     if features:
         visual_prompt_parts.append(f"with {', '.join(features)}")
     
-    # Add emotional/character traits
     trait_keywords = ["playful", "brave", "curious", "kind", "cheerful", "wise", "calm", "friendly"]
     traits = [trait for trait in trait_keywords if trait in description_lower]
     if traits:
@@ -242,7 +269,6 @@ def extract_key_features_from_description(description):
     description_lower = description.lower()
     key_features = []
     
-    # Look for distinctive physical features
     feature_patterns = [
         r"(\w+)\s+(?:spots|stripes|marks)",
         r"(\w+)\s+(?:collar|scarf|ribbon)",
@@ -254,10 +280,8 @@ def extract_key_features_from_description(description):
         matches = re.findall(pattern, description_lower)
         key_features.extend(matches)
     
-    # Remove duplicates and limit to 3 most important features
     key_features = list(set(key_features))[:3]
     
-    # If no features found, use some defaults based on character type
     if not key_features:
         if any(word in description_lower for word in ["kitten", "cat"]):
             key_features = ["whiskers", "tail", "paws"]
@@ -271,11 +295,25 @@ def extract_key_features_from_description(description):
     print(f"🔧 Extracted key features: {key_features}")
     return key_features
 
-# ENHANCED PROMPT ENGINEERING WITH DYNAMIC CHARACTER CONSISTENCY
+def extract_characters_from_visual(visual_description, available_characters):
+    """Extract character names from visual description using available characters"""
+    characters = []
+    visual_lower = visual_description.lower()
+    
+    for char_name in available_characters:
+        char_identifier = char_name.split()[0].lower()
+        if char_identifier in visual_lower or char_name.lower() in visual_lower:
+            characters.append(char_name)
+    
+    return characters
+
+# ============================================================================
+# STANDARD PIPELINE FUNCTIONS (from old script - working)
+# ============================================================================
+
 def enhance_prompt_with_characters(scene_visual, characters_present, character_templates, style="childrens_book", scene_number=1):
     """Create prompts that maintain character consistency using dynamic templates"""
     
-    # Get character descriptions for this scene
     character_descriptions = []
     consistency_keywords = []
     
@@ -285,11 +323,9 @@ def enhance_prompt_with_characters(scene_visual, characters_present, character_t
             character_descriptions.append(f"{char_name}: {char_data['visual_prompt']}")
             consistency_keywords.append(char_data['consistency_keywords'])
         else:
-            # Fallback if character not in templates
             character_descriptions.append(f"{char_name}: distinctive character")
             consistency_keywords.append(f"consistent {char_name}")
     
-    # Style templates
     style_templates = {
         "childrens_book": "children's book illustration, watercolor style, soft colors, whimsical, magical, storybook art, professional illustration",
         "realistic": "photorealistic, detailed, natural lighting, professional photography",
@@ -299,7 +335,6 @@ def enhance_prompt_with_characters(scene_visual, characters_present, character_t
     
     style_prompt = style_templates.get(style, style_templates["childrens_book"])
     
-    # Build the enhanced prompt
     character_context = ". ".join(character_descriptions)
     consistency_context = ", ".join(consistency_keywords)
     
@@ -310,7 +345,6 @@ def enhance_prompt_with_characters(scene_visual, characters_present, character_t
         f"Scene {scene_number} of storybook series. "
     )
     
-    # Quality boosters for consistency
     quality_boosters = [
         "consistent character design", "maintain identical features", 
         "same characters throughout", "continuous visual narrative",
@@ -320,7 +354,6 @@ def enhance_prompt_with_characters(scene_visual, characters_present, character_t
     
     enhanced_prompt += ", ".join(quality_boosters)
     
-    # Enhanced negative prompt to avoid inconsistencies
     negative_prompt = (
         "inconsistent characters, different appearances, changing features, "
         "multiple versions of same character, inconsistent art style, "
@@ -330,60 +363,30 @@ def enhance_prompt_with_characters(scene_visual, characters_present, character_t
     
     return enhanced_prompt, negative_prompt
 
-def extract_characters_from_visual(visual_description, available_characters):
-    """Extract character names from visual description using available characters"""
-    characters = []
-    visual_lower = visual_description.lower()
-    
-    # Check for each available character name in the visual description
-    for char_name in available_characters:
-        # Use the first word or main identifier from character name
-        char_identifier = char_name.split()[0].lower()
-        if char_identifier in visual_lower or char_name.lower() in visual_lower:
-            characters.append(char_name)
-    
-    return characters
-
-def generate_character_reference_sheet(characters):
-    """Generate reference descriptions for consistent character generation"""
-    reference_sheet = {}
-    
-    for character in characters:
-        char_name = character.name
-        reference_sheet[char_name] = {
-            "name": char_name,
-            "base_prompt": character.visual_prompt if character.visual_prompt else generate_visual_prompt_from_description(character.description, char_name),
-            "key_features": character.key_features if character.key_features else extract_key_features_from_description(character.description),
-            "must_include": character.key_features[:2] if character.key_features else []
-        }
-    
-    return reference_sheet
-
 def generate_consistent_image(prompt, model_choice, style, characters_present, character_templates, scene_number, consistency_seed=None):
     """Generate image with character consistency measures using dynamic templates"""
     
-    # Enhance prompt with character consistency
     enhanced_prompt, negative_prompt = enhance_prompt_with_characters(
         prompt, characters_present, character_templates, style, scene_number
     )
     
-    # Use a consistent seed for character generation
     if consistency_seed:
         base_seed = consistency_seed
     else:
         base_seed = hash("".join(characters_present)) % 1000000 if characters_present else random.randint(1000, 9999)
     
-    # Adjust seed slightly per scene but maintain character consistency
     scene_seed = base_seed + scene_number
     
     try:
         pipe = load_model(model_choice)
+        if pipe is None:
+            raise Exception("Model not available")
         
         image = pipe(
             prompt=enhanced_prompt,
             negative_prompt=negative_prompt,
-            num_inference_steps=35,  # Increased for better quality
-            guidance_scale=7.5,      # Slightly lower for more consistency
+            num_inference_steps=35,
+            guidance_scale=7.5,
             width=768,
             height=768,
             generator=torch.Generator(device="cpu").manual_seed(scene_seed)
@@ -399,118 +402,123 @@ def generate_consistent_image(prompt, model_choice, style, characters_present, c
         print(f"❌ Consistent generation failed: {str(e)}")
         raise
 
-# Backward compatibility functions
-def enhance_prompt(prompt, style="childrens_book"):
-    """Legacy function for backward compatibility"""
-    return enhance_prompt_with_characters(prompt, [], {}, style, 1)
+# ============================================================================
+# SIMPLIFIED ENHANCED PIPELINE (Basic composition without complex models)
+# ============================================================================
 
-def generate_high_quality_image(prompt, model_choice="dreamshaper-8", style="childrens_book", negative_prompt=""):
-    """Legacy function for backward compatibility"""
-    return generate_consistent_image(prompt, model_choice, style, [], {}, 1)
-
-# LOCAL FILE MANAGEMENT FUNCTIONS
-def save_image_to_local(image, prompt, style="test"):
-    """Save image to local persistent storage"""
-    try:
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        safe_prompt = "".join(c for c in prompt[:50] if c.isalnum() or c in (' ', '-', '_')).rstrip()
-        filename = f"image_{safe_prompt}_{timestamp}.png"
-        
-        # Create style subfolder
-        style_dir = os.path.join(PERSISTENT_IMAGE_DIR, style)
-        os.makedirs(style_dir, exist_ok=True)
-        filepath = os.path.join(style_dir, filename)
-        
-        # Save the image
-        image.save(filepath)
-        print(f"💾 Image saved locally: {filepath}")
-        
-        return filepath, filename
-        
-    except Exception as e:
-        print(f"❌ Failed to save locally: {e}")
-        return None, None
+def generate_character_image(character: CharacterDescription, model_choice: str, style: str, seed: int = None) -> Image.Image:
+    """Generate a single character with simple background"""
+    
+    character_prompt = f"{character.visual_prompt or character.description}, {character.pose_reference}, full body character, children's book character design"
+    
+    character_prompt = re.sub(r'\s+', ' ', character_prompt).strip()
+    
+    negative_prompt = "background, scenery, environment, other characters, blurry, low quality"
+    
+    pipe = load_model(model_choice)
+    if pipe is None:
+        raise Exception("Model not available")
+    
+    if seed is None:
+        seed = hash(character.name) % 1000000
+    
+    generator = torch.Generator(device="cpu").manual_seed(seed)
+    
+    image = pipe(
+        prompt=character_prompt,
+        negative_prompt=negative_prompt,
+        num_inference_steps=25,  # Reduced for speed
+        guidance_scale=7.0,
+        width=512,
+        height=768,
+        generator=generator
+    ).images[0]
+    
+    print(f"✅ Generated character: {character.name}")
+    return image
 
-def delete_local_image(filepath):
-    """Delete an image from local storage"""
-    try:
-        if os.path.exists(filepath):
-            os.remove(filepath)
-            print(f"🗑️ Deleted local image: {filepath}")
-            return True, f"✅ Deleted: {os.path.basename(filepath)}"
-        else:
-            return False, f"❌ File not found: {filepath}"
-    except Exception as e:
-        return False, f"❌ Error deleting: {str(e)}"
+def generate_scene_background(scene: StoryScene, model_choice: str, style: str, seed: int = None) -> Image.Image:
+    """Generate scene background without characters"""
+    
+    background_prompt = f"{scene.visual} {scene.background_context}, empty scene, no characters, background environment, children's book background"
+    
+    background_prompt = re.sub(r'\s+', ' ', background_prompt).strip()
+    
+    negative_prompt = "characters, people, animals, person, human, animal, blurry, low quality"
+    
+    pipe = load_model(model_choice)
+    if pipe is None:
+        raise Exception("Model not available")
+    
+    if seed is None:
+        seed = random.randint(1000, 9999)
+    
+    generator = torch.Generator(device="cpu").manual_seed(seed)
+    
+    image = pipe(
+        prompt=background_prompt,
+        negative_prompt=negative_prompt,
+        num_inference_steps=25,  # Reduced for speed
+        guidance_scale=7.0,
+        width=768,
+        height=768,
+        generator=generator
+    ).images[0]
+    
+    print(f"✅ Generated background for scene")
+    return image
 
-def get_local_storage_info():
-    """Get information about local storage usage"""
-    try:
-        total_size = 0
-        file_count = 0
-        images_list = []
-        
-        for root, dirs, files in os.walk(PERSISTENT_IMAGE_DIR):
-            for file in files:
-                if file.endswith(('.png', '.jpg', '.jpeg')):
-                    filepath = os.path.join(root, file)
-                    if os.path.exists(filepath):
-                        file_size = os.path.getsize(filepath)
-                        total_size += file_size
-                        file_count += 1
-                        images_list.append({
-                            'path': filepath,
-                            'filename': file,
-                            'size_kb': round(file_size / 1024, 1),
-                            'created': os.path.getctime(filepath)
-                        })
+def compose_scene_with_characters(background: Image.Image, character_images: Dict[str, Image.Image], 
+                                characters_present: List[str], scene_context: str) -> Image.Image:
+    """Simple composition by placing characters on background"""
+    
+    final_image = background.copy()
+    
+    # Simple positioning
+    positions = []
+    num_chars = len(characters_present)
+    
+    if num_chars == 1:
+        positions.append((284, 300, 200, 300))  # Center
+    elif num_chars == 2:
+        positions.extend([(184, 300, 200, 300), (484, 300, 200, 300)])  # Left & right
+    else:
+        for i in range(num_chars):
+            x = 150 + (i % 3) * 200
+            y = 250 + (i // 3) * 200
+            positions.append((x, y, 180, 270))
+    
+    for i, char_name in enumerate(characters_present):
+        if i >= len(positions) or char_name not in character_images:
+            continue
+            
+        char_image = character_images[char_name]
+        x, y, width, height = positions[i]
         
-        return {
-            "total_files": file_count,
-            "total_size_mb": round(total_size / (1024 * 1024), 2),
-            "images": sorted(images_list, key=lambda x: x['created'], reverse=True)
-        }
-    except Exception as e:
-        return {"error": str(e)}
+        char_resized = char_image.resize((width, height))
+        final_image.paste(char_resized, (x, y), char_resized)
+    
+    return final_image
 
-def refresh_local_images():
-    """Get list of all locally saved images"""
-    try:
-        image_files = []
-        for root, dirs, files in os.walk(PERSISTENT_IMAGE_DIR):
-            for file in files:
-                if file.endswith(('.png', '.jpg', '.jpeg')):
-                    filepath = os.path.join(root, file)
-                    if os.path.exists(filepath):
-                        image_files.append(filepath)
-        return image_files
-    except Exception as e:
-        print(f"Error refreshing local images: {e}")
-        return []
+# ============================================================================
+# OCI BUCKET FUNCTIONS (from old script)
+# ============================================================================
 
-# OCI BUCKET FUNCTIONS
-def save_to_oci_bucket(image, text_content, story_title, page_number, file_type="image"):
-    """Save both images and text to OCI bucket via your OCI API"""
+def save_to_oci_bucket(file_data, filename, story_title, file_type="image", subfolder=""):
+    """Save files to OCI bucket"""
     try:
-        if file_type == "image":
-            # Convert image to bytes
-            img_bytes = io.BytesIO()
-            image.save(img_bytes, format='PNG')
-            file_data = img_bytes.getvalue()
-            filename = f"page_{page_number:03d}.png"
-            mime_type = "image/png"
-        else:  # text
-            file_data = text_content.encode('utf-8')
-            filename = f"page_{page_number:03d}.txt"
-            mime_type = "text/plain"
-        
-        # Use your OCI API to save the file
         api_url = f"{OCI_API_BASE_URL}/api/upload"
         
+        if subfolder:
+            full_subfolder = f'stories/{story_title}/{subfolder}'
+        else:
+            full_subfolder = f'stories/{story_title}'
+        
+        mime_type = "image/png" if file_type == "image" else "text/plain"
         files = {'file': (filename, file_data, mime_type)}
         data = {
             'project_id': 'storybook-library',
-            'subfolder': f'stories/{story_title}'
+            'subfolder': full_subfolder
         }
         
         response = requests.post(api_url, files=files, data=data, timeout=30)
@@ -529,13 +537,14 @@ def save_to_oci_bucket(image, text_content, story_title, page_number, file_type=
     except Exception as e:
         raise Exception(f"OCI upload failed: {str(e)}")
 
-# JOB MANAGEMENT FUNCTIONS
+# ============================================================================
+# JOB MANAGEMENT (from old script with enhancements)
+# ============================================================================
+
 def create_job(story_request: StorybookRequest) -> str:
     job_id = str(uuid.uuid4())
     
-    # Process character descriptions from n8n
     character_templates = process_character_descriptions(story_request.characters)
-    character_references = generate_character_reference_sheet(story_request.characters)
     
     job_storage[job_id] = {
         "status": JobStatus.PENDING,
@@ -547,11 +556,10 @@ def create_job(story_request: StorybookRequest) -> str:
         "updated_at": time.time(),
         "pages": [],
         "character_templates": character_templates,
-        "character_references": character_references
     }
     
     print(f"📝 Created job {job_id} for story: {story_request.story_title}")
-    print(f"👥 Processed {len(character_templates)} characters from n8n request")
+    print(f"🚀 Pipeline type: {story_request.pipeline_type}")
     
     return job_id
 
@@ -569,7 +577,6 @@ def update_job_status(job_id: str, status: JobStatus, progress: int, message: st
     if result:
         job_storage[job_id]["result"] = result
     
-    # Send webhook notification if callback URL exists
     job_data = job_storage[job_id]
     request_data = job_data["request"]
     
@@ -577,7 +584,6 @@ def update_job_status(job_id: str, status: JobStatus, progress: int, message: st
         try:
             callback_url = request_data["callback_url"]
             
-            # Enhanced callback data
             callback_data = {
                 "job_id": job_id,
                 "status": status.value,
@@ -586,46 +592,12 @@ def update_job_status(job_id: str, status: JobStatus, progress: int, message: st
                 "story_title": request_data["story_title"],
                 "total_scenes": len(request_data["scenes"]),
                 "total_characters": len(request_data["characters"]),
+                "pipeline_type": request_data.get("pipeline_type", "standard"),
                 "timestamp": time.time(),
-                "source": "huggingface-storybook-generator",
-                "estimated_time_remaining": calculate_remaining_time(job_id, progress)
             }
             
-            # Add result data for completed jobs
-            if status == JobStatus.COMPLETED and result:
-                callback_data["result"] = {
-                    "total_pages": result.get("total_pages", 0),
-                    "generation_time": result.get("generation_time", 0),
-                    "oci_bucket_url": result.get("oci_bucket_url", ""),
-                    "pages_generated": result.get("generated_pages", 0),
-                    "characters_used": result.get("characters_used", 0)
-                }
-            
-            # Add current scene info for processing jobs
-            if status == JobStatus.PROCESSING:
-                current_scene = progress // (100 // len(request_data["scenes"])) + 1
-                callback_data["current_scene"] = current_scene
-                callback_data["total_scenes"] = len(request_data["scenes"])
-                if current_scene <= len(request_data["scenes"]):
-                    scene_visual = request_data["scenes"][current_scene-1]["visual"]
-                    callback_data["scene_description"] = scene_visual[:100] + "..."
-                    
-                    # Add characters in current scene
-                    if "characters_present" in request_data["scenes"][current_scene-1]:
-                        callback_data["characters_in_scene"] = request_data["scenes"][current_scene-1]["characters_present"]
-            
-            headers = {
-                'Content-Type': 'application/json',
-                'User-Agent': 'Storybook-Generator/1.0'
-            }
-            
-            response = requests.post(
-                callback_url,
-                json=callback_data,
-                headers=headers,
-                timeout=30
-            )
-            
+            headers = {'Content-Type': 'application/json'}
+            response = requests.post(callback_url, json=callback_data, headers=headers, timeout=30)
             print(f"📢 Callback sent: Status {response.status_code}")
                 
         except Exception as e:
@@ -633,43 +605,21 @@ def update_job_status(job_id: str, status: JobStatus, progress: int, message: st
     
     return True
 
-def calculate_remaining_time(job_id, progress):
-    """Calculate estimated time remaining"""
-    if progress == 0:
-        return "Calculating..."
-    
-    job_data = job_storage.get(job_id)
-    if not job_data:
-        return "Unknown"
-    
-    time_elapsed = time.time() - job_data["created_at"]
-    if progress > 0:
-        total_estimated = (time_elapsed / progress) * 100
-        remaining = total_estimated - time_elapsed
-        return f"{int(remaining // 60)}m {int(remaining % 60)}s"
-    
-    return "Unknown"
+# ============================================================================
+# BACKGROUND TASKS - SIMPLIFIED
+# ============================================================================
 
-# ENHANCED BACKGROUND TASK WITH DYNAMIC CHARACTER CONSISTENCY
-def generate_storybook_background(job_id: str):
-    """Background task to generate complete storybook with dynamic character consistency"""
+def generate_storybook_standard(job_id: str):
+    """Standard pipeline background task"""
     try:
         job_data = job_storage[job_id]
         story_request_data = job_data["request"]
         story_request = StorybookRequest(**story_request_data)
         character_templates = job_data["character_templates"]
         
-        print(f"🎬 Starting DYNAMIC storybook generation for job {job_id}")
-        print(f"📖 Story: {story_request.story_title}")
-        print(f"👥 Characters: {len(story_request.characters)} (from n8n)")
-        print(f"📄 Scenes: {len(story_request.scenes)}")
-        print(f"🌱 Consistency seed: {story_request.consistency_seed}")
+        print(f"🎬 Starting STANDARD pipeline for job {job_id}")
         
-        # Log character details
-        for char in story_request.characters:
-            print(f"   - {char.name}: {char.description[:50]}...")
-        
-        update_job_status(job_id, JobStatus.PROCESSING, 5, "Starting storybook generation with dynamic character consistency...")
+        update_job_status(job_id, JobStatus.PROCESSING, 5, "Starting storybook generation...")
         
         total_scenes = len(story_request.scenes)
         generated_pages = []
@@ -678,12 +628,10 @@ def generate_storybook_background(job_id: str):
         for i, scene in enumerate(story_request.scenes):
             progress = 5 + int((i / total_scenes) * 90)
             
-            # Extract characters for this scene
             characters_present = []
             if hasattr(scene, 'characters_present') and scene.characters_present:
                 characters_present = scene.characters_present
             else:
-                # Fallback: extract from visual description using available characters
                 available_chars = [char.name for char in story_request.characters]
                 characters_present = extract_characters_from_visual(scene.visual, available_chars)
             
@@ -691,13 +639,12 @@ def generate_storybook_background(job_id: str):
                 job_id, 
                 JobStatus.PROCESSING, 
                 progress, 
-                f"Generating page {i+1}/{total_scenes} with {len(characters_present)} characters: {scene.visual[:50]}..."
+                f"Generating page {i+1}/{total_scenes}..."
             )
             
             try:
-                print(f"🖼️ Generating page {i+1} with characters: {characters_present}")
+                print(f"🖼️ Generating page {i+1}")
                 
-                # Generate consistent image using dynamic character templates
                 image = generate_consistent_image(
                     scene.visual, 
                     story_request.model_choice, 
@@ -708,37 +655,31 @@ def generate_storybook_background(job_id: str):
                     story_request.consistency_seed
                 )
                 
-                # Save IMAGE to OCI bucket
+                img_bytes = io.BytesIO()
+                image.save(img_bytes, format='PNG')
                 image_url = save_to_oci_bucket(
-                    image, 
-                    "",  # No text for image
-                    story_request.story_title, 
-                    i + 1, 
+                    img_bytes.getvalue(),
+                    f"page_{i+1:03d}.png",
+                    story_request.story_title,
                     "image"
                 )
                 
-                # Save TEXT to OCI bucket
                 text_url = save_to_oci_bucket(
-                    None,  # No image for text
-                    scene.text, 
-                    story_request.story_title, 
-                    i + 1, 
+                    scene.text.encode('utf-8'),
+                    f"page_{i+1:03d}.txt",
+                    story_request.story_title,
                     "text"
                 )
                 
-                # Store page data
                 page_data = {
                     "page_number": i + 1,
                     "image_url": image_url,
                     "text_url": text_url,
                     "text_content": scene.text,
-                    "visual_description": scene.visual,
-                    "characters_present": characters_present,
-                    "prompt_used": f"Dynamic consistent generation with {len(characters_present)} characters"
                 }
                 generated_pages.append(page_data)
                 
-                print(f"✅ Page {i+1} completed - Characters: {characters_present}")
+                print(f"✅ Page {i+1} completed")
                 
             except Exception as e:
                 error_msg = f"Failed to generate page {i+1}: {str(e)}"
@@ -746,93 +687,79 @@ def generate_storybook_background(job_id: str):
                 update_job_status(job_id, JobStatus.FAILED, 0, error_msg)
                 return
         
-        # Complete the job
         generation_time = time.time() - start_time
         
         result = {
             "story_title": story_request.story_title,
             "total_pages": total_scenes,
-            "characters_used": len(story_request.characters),
             "generated_pages": len(generated_pages),
             "generation_time": round(generation_time, 2),
-            "folder_path": f"stories/{story_request.story_title}",
-            "oci_bucket_url": f"https://oci.com/stories/{story_request.story_title}",
-            "consistency_seed": story_request.consistency_seed,
-            "character_names": [char.name for char in story_request.characters],
-            "pages": generated_pages,
-            "file_structure": {
-                "images": [f"page_{i+1:03d}.png" for i in range(total_scenes)],
-                "texts": [f"page_{i+1:03d}.txt" for i in range(total_scenes)]
-            }
+            "pipeline_used": "standard",
+            "pages": generated_pages
         }
         
         update_job_status(
             job_id, 
             JobStatus.COMPLETED, 
             100, 
-            f"🎉 Storybook completed! {len(generated_pages)} pages with {len(story_request.characters)} dynamic characters created in {generation_time:.2f}s.",
+            f"🎉 Standard pipeline completed! {len(generated_pages)} pages in {generation_time:.2f}s.",
             result
         )
         
-        print(f"🎉 DYNAMIC Storybook generation finished for job {job_id}")
-        print(f"📁 Saved to: stories/{story_request.story_title} in OCI bucket")
-        print(f"👥 Dynamic character consistency maintained for {len(story_request.characters)} characters across {total_scenes} scenes")
+        print(f"🎉 STANDARD pipeline finished for job {job_id}")
         
     except Exception as e:
-        error_msg = f"Dynamic story generation failed: {str(e)}"
+        error_msg = f"Standard pipeline failed: {str(e)}"
         print(f"❌ {error_msg}")
         update_job_status(job_id, JobStatus.FAILED, 0, error_msg)
 
-# FASTAPI ENDPOINTS (for n8n)
+def generate_storybook_dispatcher(job_id: str):
+    """Choose between pipelines"""
+    job_data = job_storage[job_id]
+    story_request_data = job_data["request"]
+    
+    pipeline_type = story_request_data.get("pipeline_type", "standard")
+    
+    # For now, only use standard pipeline until models are stable
+    generate_storybook_standard(job_id)
+
+# ============================================================================
+# FASTAPI ENDPOINTS (simplified)
+# ============================================================================
+
 @app.post("/api/generate-storybook")
-async def generate_storybook(request: dict, background_tasks: BackgroundTasks):
-    """Main endpoint for n8n integration - generates complete storybook with dynamic character consistency"""
+async def generate_storybook_unified(request: dict, background_tasks: BackgroundTasks):
+    """Unified endpoint that handles both pipelines"""
     try:
-        print(f"📥 Received n8n request for story: {request.get('story_title', 'Unknown')}")
+        print(f"📥 Received storybook request: {request.get('story_title', 'Unknown')}")
         
-        # Add consistency seed if not provided
         if 'consistency_seed' not in request or not request['consistency_seed']:
             request['consistency_seed'] = random.randint(1000, 9999)
-            print(f"🌱 Generated consistency seed: {request['consistency_seed']}")
         
-        # Ensure characters have required fields
-        if 'characters' in request:
-            for char in request['characters']:
-                if 'visual_prompt' not in char or not char['visual_prompt']:
-                    # Generate visual prompt from description if not provided
-                    char['visual_prompt'] = ""
-                if 'key_features' not in char:
-                    char['key_features'] = []
+        # Ensure model_choice is valid
+        if request.get('model_choice') not in MODEL_CHOICES:
+            request['model_choice'] = "sd-1.5"  # Force to working model
         
-        # Convert to Pydantic model
         story_request = StorybookRequest(**request)
         
-        # Validate required fields
         if not story_request.story_title or not story_request.scenes:
             raise HTTPException(status_code=400, detail="story_title and scenes are required")
         
-        # Create job immediately
         job_id = create_job(story_request)
+        background_tasks.add_task(generate_storybook_dispatcher, job_id)
         
-        # Start background processing (runs independently of HF idle)
-        background_tasks.add_task(generate_storybook_background, job_id)
-        
-        # Immediate response for n8n
         response_data = {
             "status": "success",
-            "message": "Storybook generation with dynamic character consistency started successfully",
+            "message": f"Storybook generation started with {story_request.pipeline_type} pipeline",
             "job_id": job_id,
             "story_title": story_request.story_title,
             "total_scenes": len(story_request.scenes),
-            "total_characters": len(story_request.characters),
-            "character_names": [char.name for char in story_request.characters],
-            "consistency_seed": story_request.consistency_seed,
-            "callback_url": story_request.callback_url,
-            "estimated_time_seconds": len(story_request.scenes) * 35,
+            "model_choice": story_request.model_choice,
+            "pipeline_type": story_request.pipeline_type,
             "timestamp": datetime.now().isoformat()
         }
         
-        print(f"✅ Job {job_id} started with dynamic character consistency for: {story_request.story_title}")
+        print(f"✅ Job {job_id} started")
         
         return response_data
         
@@ -843,7 +770,6 @@ async def generate_storybook(request: dict, background_tasks: BackgroundTasks):
 
 @app.get("/api/job-status/{job_id}")
 async def get_job_status_endpoint(job_id: str):
-    """Check job status"""
     job_data = job_storage.get(job_id)
     if not job_data:
         raise HTTPException(status_code=404, detail="Job not found")
@@ -860,364 +786,50 @@ async def get_job_status_endpoint(job_id: str):
 
 @app.get("/api/health")
 async def api_health():
-    """Health check endpoint for n8n"""
     return {
         "status": "healthy",
         "service": "storybook-generator",
         "timestamp": datetime.now().isoformat(),
         "active_jobs": len(job_storage),
         "models_loaded": list(model_cache.keys()),
-        "fallback_templates": list(FALLBACK_CHARACTER_TEMPLATES.keys()),
+        "available_models": list(MODEL_CHOICES.keys()),
         "oci_api_connected": OCI_API_BASE_URL
     }
 
-@app.get("/api/local-images")
-async def get_local_images():
-    """API endpoint to get locally saved test images"""
-    storage_info = get_local_storage_info()
-    return storage_info
-
-@app.delete("/api/local-images/{filename:path}")
-async def delete_local_image_api(filename: str):
-    """API endpoint to delete a local image"""
-    try:
-        filepath = os.path.join(PERSISTENT_IMAGE_DIR, filename)
-        success, message = delete_local_image(filepath)
-        return {"status": "success" if success else "error", "message": message}
-    except Exception as e:
-        return {"status": "error", "message": str(e)}
-
-# MISSING HELPER FUNCTIONS FOR GRADIO INTERFACE
-def delete_current_image(filepath):
-    """Delete the currently displayed image"""
-    if not filepath:
-        return "❌ No image to delete", None, None, refresh_local_images()
-    
-    success, message = delete_local_image(filepath)
-    updated_files = refresh_local_images()
-    
-    if success:
-        status_msg = f"✅ {message}"
-        return status_msg, None, "Image deleted successfully!", updated_files
-    else:
-        return f"❌ {message}", None, "Delete failed", updated_files
-
-def clear_all_images():
-    """Delete all local images"""
-    try:
-        storage_info = get_local_storage_info()
-        deleted_count = 0
-        
-        if "images" in storage_info:
-            for image_info in storage_info["images"]:
-                success, _ = delete_local_image(image_info["path"])
-                if success:
-                    deleted_count += 1
-        
-        updated_files = refresh_local_images()
-        return f"✅ Deleted {deleted_count} images", updated_files
-    except Exception as e:
-        return f"❌ Error: {str(e)}", refresh_local_images()
-
-# Enhanced Gradio interface with dynamic character testing
-def create_gradio_interface():
-    """Create Gradio interface with dynamic character consistency features"""
-    
-    def generate_test_image_with_characters(prompt, model_choice, style_choice, character_names_text):
-        """Generate a single image for testing character consistency"""
-        try:
-            if not prompt.strip():
-                return None, "❌ Please enter a prompt", None
-            
-            # Parse character names from text input
-            character_names = [name.strip() for name in character_names_text.split(",") if name.strip()]
-            
-            print(f"🎨 Generating test image with prompt: {prompt}")
-            print(f"👥 Character names: {character_names}")
-            
-            # Create dynamic character templates for testing
-            character_templates = {}
-            for char_name in character_names:
-                character_templates[char_name] = {
-                    "visual_prompt": f"{char_name}, distinctive appearance, consistent features",
-                    "key_features": ["consistent appearance", "maintain features"],
-                    "consistency_keywords": f"consistent {char_name}"
-                }
-            
-            # Enhance the prompt with character consistency
-            enhanced_prompt, negative_prompt = enhance_prompt_with_characters(
-                prompt, character_names, character_templates, style_choice, 1
-            )
-            
-            # Generate the image
-            image = generate_consistent_image(
-                prompt, 
-                model_choice, 
-                style_choice,
-                character_names,
-                character_templates,
-                1
-            )
-            
-            # Save to local storage
-            filepath, filename = save_image_to_local(image, prompt, style_choice)
-            
-            character_info = f"👥 Characters: {', '.join(character_names)}" if character_names else "👥 No specific characters"
-            
-            status_msg = f"""✅ Success! Generated: {prompt}
-
-{character_info}
-
-🎨 Enhanced prompt: {enhanced_prompt[:200]}...
-
-📁 **Local file:** {filename if filename else 'Not saved'}"""
-            
-            return image, status_msg, filepath
-            
-        except Exception as e:
-            error_msg = f"❌ Generation failed: {str(e)}"
-            print(error_msg)
-            return None, error_msg, None
-    
-    with gr.Blocks(title="Premium Children's Book Illustrator with Dynamic Character Consistency", theme="soft") as demo:
-        gr.Markdown("# 🎨 Premium Children's Book Illustrator")
-        gr.Markdown("Generate **studio-quality** storybook images with **dynamic character consistency**")
-        
-        # Storage info display
-        storage_info = gr.Textbox(
-            label="📊 Local Storage Information",
-            interactive=False,
-            lines=2
-        )
-        
-        def update_storage_info():
-            info = get_local_storage_info()
-            if "error" not in info:
-                return f"📁 Local Storage: {info['total_files']} images, {info['total_size_mb']} MB used"
-            return "📁 Local Storage: Unable to calculate"
+# Simple Gradio interface
+def create_simple_interface():
+    with gr.Blocks(title="Storybook Generator") as demo:
+        gr.Markdown("# Storybook Generator")
         
         with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("### 🎯 Quality Settings")
-                
-                model_dropdown = gr.Dropdown(
-                    label="AI Model",
-                    choices=list(MODEL_CHOICES.keys()),
-                    value="dreamshaper-8"
-                )
-                
-                style_dropdown = gr.Dropdown(
-                    label="Art Style",
-                    choices=["childrens_book", "realistic", "fantasy", "anime"],
-                    value="childrens_book"
-                )
-                
-                # Dynamic character input for testing
-                character_names_input = gr.Textbox(
-                    label="Character Names (comma-separated)",
-                    placeholder="Enter character names: Sparkle the Star Cat, Benny the Bunny, Tilly the Turtle",
-                    info="Enter character names to test consistency features",
-                    lines=2
-                )
-                
-                prompt_input = gr.Textbox(
-                    label="Scene Description",
-                    placeholder="Describe your scene with character interactions...\nExample: Sparkle the Star Cat chasing butterflies while Benny the Bunny watches",
-                    lines=3
-                )
-                
-                generate_btn = gr.Button("✨ Generate Premium Image", variant="primary")
-                
-                # Current image management
-                current_file_path = gr.State()
-                delete_btn = gr.Button("🗑️ Delete This Image", variant="stop")
-                delete_status = gr.Textbox(label="Delete Status", interactive=False, lines=2)
-                
-                gr.Markdown("### 📚 API Usage for n8n")
-                gr.Markdown("""
-                **For complete storybooks (OCI bucket):**
-                - Endpoint: `POST /api/generate-storybook`
-                - Input: `story_title`, `scenes[]`, `characters[]`
-                - Output: Saves to OCI bucket with dynamic character consistency
-                """)
-            
-            with gr.Column(scale=2):
-                image_output = gr.Image(label="Generated Image", height=500, show_download_button=True)
-                status_output = gr.Textbox(label="Status", interactive=False, lines=4)
-        
-        # Dynamic character guidance section
-        with gr.Accordion("👥 Dynamic Character Guidance", open=False):
-            gr.Markdown("""
-            ### How to Use Dynamic Characters from n8n:
-            
-            **n8n Payload Structure:**
-            ```json
-            {
-              "story_title": "Your Story Title",
-              "characters": [
-                {
-                  "name": "Character Name",
-                  "description": "Character description...",
-                  "visual_prompt": "Detailed visual description",  // Optional
-                  "key_features": ["feature1", "feature2"]         // Optional
-                }
-              ],
-              "scenes": [
-                {
-                  "visual": "Scene description with characters...",
-                  "text": "Scene text...",
-                  "characters_present": ["Character Name"]         // Optional
-                }
-              ]
-            }
-            ```
-            
-            **Features:**
-            - ✅ Dynamic character processing from n8n
-            - ✅ Automatic visual prompt generation
-            - ✅ Key feature extraction
-            - ✅ Cross-scene consistency
-            - ✅ Flexible character numbers and types
-            """)
-        
-        # Examples section
-        with gr.Accordion("💡 Prompt Examples & Tips", open=False):
-            gr.Markdown("""
-            ## 🎨 Professional Prompt Examples with Dynamic Characters:
-            
-            **Best Results with Dynamic Characters:**
-            - "Sparkle the Star Cat chasing butterflies in a sunny meadow"
-            - "Benny the Bunny and Tilly the Turtle having a picnic"
-            - "Multiple characters discovering a magical portal together"
-            
-            ## ⚡ Dynamic Character Consistency Tips:
-            1. **Always mention character names** in your prompts
-            2. **n8n will send character details** automatically
-            3. **The system processes any number** of characters dynamically
-            4. **Consistency is maintained** across all scenes automatically
-            """)
-        
-        # Local file management section
-        with gr.Accordion("📁 Manage Local Test Images", open=True):
-            gr.Markdown("### Locally Saved Images")
-            
-            with gr.Row():
-                refresh_btn = gr.Button("🔄 Refresh List")
-                clear_all_btn = gr.Button("🗑️ Clear All Images", variant="stop")
-            
-            file_gallery = gr.Gallery(
-                label="Local Images",
-                show_label=True,
-                elem_id="gallery",
-                columns=4,
-                height="auto"
-            )
-            
-            clear_status = gr.Textbox(label="Clear Status", interactive=False)
+            with gr.Column():
+                prompt = gr.Textbox(label="Prompt")
+                generate_btn = gr.Button("Generate")
+            with gr.Column():
+                output = gr.Image(label="Output")
         
-        # Debug section
-        with gr.Accordion("🔧 Advanced Settings", open=False):
-            debug_btn = gr.Button("🔄 Check System Status", variant="secondary")
-            debug_output = gr.Textbox(label="System Info", interactive=False, lines=4)
-        
-        def check_system_status():
-            """Check system status"""
-            active_jobs = len(job_storage)
-            return f"""**System Status:**
-- Model: {current_model_name}
-- Dynamic Character Processing: ✅ Enabled
-- Fallback Templates: {len(FALLBACK_CHARACTER_TEMPLATES)} available
-- OCI API: {OCI_API_BASE_URL}
-- Local Storage: {get_local_storage_info().get('total_files', 0)} images
-- Active Jobs: {active_jobs}
-- Ready for dynamic character consistency generation!"""
-
-        # Connect buttons to functions
-        generate_btn.click(
-            fn=generate_test_image_with_characters,
-            inputs=[prompt_input, model_dropdown, style_dropdown, character_names_input],
-            outputs=[image_output, status_output, current_file_path]
-        ).then(
-            fn=refresh_local_images,
-            outputs=file_gallery
-        ).then(
-            fn=update_storage_info,
-            outputs=storage_info
-        )
+        def generate_image(prompt_text):
+            pipe = load_model("sd-1.5")
+            if pipe:
+                image = pipe(prompt_text, num_inference_steps=20).images[0]
+                return image
+            return None
         
-        delete_btn.click(
-            fn=delete_current_image,
-            inputs=current_file_path,
-            outputs=[delete_status, image_output, status_output, file_gallery]
-        ).then(
-            fn=update_storage_info,
-            outputs=storage_info
-        )
-        
-        refresh_btn.click(
-            fn=refresh_local_images,
-            outputs=file_gallery
-        ).then(
-            fn=update_storage_info,
-            outputs=storage_info
-        )
-        
-        clear_all_btn.click(
-            fn=clear_all_images,
-            outputs=[clear_status, file_gallery]
-        ).then(
-            fn=update_storage_info,
-            outputs=storage_info
-        )
-        
-        debug_btn.click(
-            fn=check_system_status,
-            inputs=None,
-            outputs=debug_output
-        )
-        
-        # Initialize on load
-        demo.load(fn=refresh_local_images, outputs=file_gallery)
-        demo.load(fn=update_storage_info, outputs=storage_info)
+        generate_btn.click(generate_image, inputs=prompt, outputs=output)
     
     return demo
 
-# Create enhanced Gradio app
-demo = create_gradio_interface()
+demo = create_simple_interface()
 
-# Enhanced root endpoint that explains the API structure
 @app.get("/")
 async def root():
     return {
-        "message": "Storybook Generator API with Dynamic Character Consistency is running!",
-        "api_endpoints": {
-            "health_check": "GET /api/health",
-            "generate_storybook": "POST /api/generate-storybook",
-            "check_job_status": "GET /api/job-status/{job_id}",
-            "local_images": "GET /api/local-images"
-        },
-        "features": {
-            "dynamic_characters": "✅ Enabled",
-            "character_consistency": "✅ Enabled", 
-            "flexible_storytelling": "✅ Enabled",
-            "n8n_integration": "✅ Enabled"
-        },
-        "web_interface": "GET /ui",
-        "note": "Use API endpoints for programmatic access with dynamic characters from n8n"
-    }
-
-# Add a simple test endpoint
-@app.get("/api/test")
-async def test_endpoint():
-    return {
-        "status": "success", 
-        "message": "API with dynamic character consistency is working correctly",
-        "dynamic_processing": "✅ Enabled",
-        "fallback_templates": len(FALLBACK_CHARACTER_TEMPLATES),
-        "timestamp": datetime.now().isoformat()
+        "message": "Storybook Generator API is running!",
+        "available_models": list(MODEL_CHOICES.keys()),
+        "default_model": "sd-1.5"
     }
 
-# For Hugging Face Spaces deployment
+# Mount Gradio for Hugging Face Spaces
 def get_app():
     return app
 
@@ -1225,66 +837,12 @@ if __name__ == "__main__":
     import uvicorn
     import os
     
-    # Check if we're running on Hugging Face Spaces
     HF_SPACE = os.environ.get('SPACE_ID') is not None
     
     if HF_SPACE:
-        print("🚀 Running on Hugging Face Spaces - Integrated Mode")
-        print("📚 API endpoints available at: /api/*")
-        print("🎨 Web interface available at: /ui")
-        print("👥 Dynamic character consistency features enabled")
-        print("🔌 Both API and UI running on same port")
-        
-        # Mount Gradio without reassigning app
+        print("🚀 Running on Hugging Face Spaces")
         gr.mount_gradio_app(app, demo, path="/ui")
-        
-        # Run the combined app
-        uvicorn.run(
-            app, 
-            host="0.0.0.0", 
-            port=7860, 
-            log_level="info"
-        )
+        uvicorn.run(app, host="0.0.0.0", port=7860, log_level="info")
     else:
-        # Local development - run separate servers
-        print("🚀 Running locally - Separate API and UI servers")
-        print("📚 API endpoints: http://localhost:8000/api/*")
-        print("🎨 Web interface: http://localhost:7860/ui")
-        print("👥 Dynamic character consistency features enabled")
-        
-        def run_fastapi():
-            """Run FastAPI on port 8000 for API calls"""
-            uvicorn.run(
-                app, 
-                host="0.0.0.0", 
-                port=8000, 
-                log_level="info",
-                access_log=False
-            )
-        
-        def run_gradio():
-            """Run Gradio on port 7860 for web interface"""
-            demo.launch(
-                server_name="0.0.0.0",
-                server_port=7860,
-                share=False,
-                show_error=True,
-                quiet=True
-            )
-        
-        # Start both servers in separate threads
-        api_thread = threading.Thread(target=run_fastapi, daemon=True)
-        ui_thread = threading.Thread(target=run_gradio, daemon=True)
-        
-        api_thread.start()
-        print("✅ FastAPI server started on port 8000")
-        
-        ui_thread.start()
-        print("✅ Gradio server started on port 7860")
-        
-        # Keep the main thread alive
-        try:
-            while True:
-                time.sleep(1)
-        except KeyboardInterrupt:
-            print("🛑 Shutting down servers...")
+        print("🚀 Running locally")
+        uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")