Update app.py

app.py

@@ -20,7 +20,7 @@ import hashlib
 from enum import Enum
 import random
 
-# External OCI API URL
+# External OCI API URL - YOUR BUCKET SAVING API
 OCI_API_BASE_URL = "https://yukee1992-oci-story-book.hf.space"
 
 # Initialize FastAPI app
@@ -85,11 +85,6 @@ current_model_name = None
 current_pipe = None
 model_lock = threading.Lock()
 
-# Create persistent directory for test images
-PERSISTENT_IMAGE_DIR = "generated_test_images"
-os.makedirs(PERSISTENT_IMAGE_DIR, exist_ok=True)
-print(f"📁 Created persistent image directory: {PERSISTENT_IMAGE_DIR}")
-
 def load_model(model_name="dreamshaper-8"):
     """Thread-safe model loading with HIGH-QUALITY settings"""
     global model_cache, current_model_name, current_pipe
@@ -131,9 +126,9 @@ def load_model(model_name="dreamshaper-8"):
             ).to("cpu")
 
 # Initialize default model
-print("🚀 Initializing HIGH-QUALITY Storybook Generator...")
+print("🚀 Initializing Storybook Generator API...")
 load_model("dreamshaper-8")
-print("✅ HIGH-QUALITY Model loaded and ready!")
+print("✅ Model loaded and ready!")
 
 # PROFESSIONAL PROMPT ENGINEERING
 def enhance_prompt(prompt, style="childrens_book"):
@@ -207,114 +202,45 @@ def generate_high_quality_image(prompt, model_choice="dreamshaper-8", style="chi
         print(f"❌ HQ Generation failed: {str(e)}")
         raise
 
-def save_image_to_persistent_storage(image, prompt, subfolder=""):
-    """Save image to persistent storage that appears in Files tab"""
-    try:
-        # Create filename
-        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 subfolder if specified
-        if subfolder:
-            save_dir = os.path.join(PERSISTENT_IMAGE_DIR, subfolder)
-            os.makedirs(save_dir, exist_ok=True)
-            filepath = os.path.join(save_dir, filename)
-        else:
-            filepath = os.path.join(PERSISTENT_IMAGE_DIR, filename)
-        
-        # Save the image
-        image.save(filepath)
-        print(f"💾 Image saved to persistent storage: {filepath}")
-        
-        # Return relative path for display
-        return filepath
-        
-    except Exception as e:
-        print(f"❌ Failed to save to persistent storage: {e}")
-        return None
-
-def delete_image_file(filepath):
-    """Delete an image file from persistent storage"""
+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"""
     try:
-        if os.path.exists(filepath):
-            os.remove(filepath)
-            print(f"🗑️ Deleted image: {filepath}")
-            return True, f"✅ Successfully deleted: {os.path.basename(filepath)}"
-        else:
-            return False, f"❌ File not found: {filepath}"
-    except Exception as e:
-        return False, f"❌ Error deleting file: {str(e)}"
-
-def get_storage_info():
-    """Get information about storage usage"""
-    try:
-        total_size = 0
-        file_count = 0
-        
-        for root, dirs, files in os.walk(PERSISTENT_IMAGE_DIR):
-            for file in files:
-                filepath = os.path.join(root, file)
-                if os.path.exists(filepath):
-                    total_size += os.path.getsize(filepath)
-                    file_count += 1
-        
-        return {
-            "total_files": file_count,
-            "total_size_mb": round(total_size / (1024 * 1024), 2),
-            "directory": PERSISTENT_IMAGE_DIR
+        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"
+        
+        files = {'file': (filename, file_data, mime_type)}
+        data = {
+            'project_id': 'storybook-library',
+            'subfolder': f'stories/{story_title}'
         }
-    except Exception as e:
-        return {"error": str(e)}
-
-def generate_test_image(prompt, model_choice, style_choice):
-    """Generate a single image for testing and save to persistent storage"""
-    try:
-        if not prompt.strip():
-            return None, "❌ Please enter a prompt", None
-        
-        print(f"🎨 Generating test image with prompt: {prompt}")
         
-        # Enhance the prompt
-        enhanced_prompt, negative_prompt = enhance_prompt(prompt, style_choice)
-        
-        # Generate the image
-        image = generate_high_quality_image(
-            enhanced_prompt, 
-            model_choice, 
-            style_choice,
-            negative_prompt
-        )
+        response = requests.post(api_url, files=files, data=data, timeout=30)
         
-        # Save to persistent storage with style-based subfolder
-        saved_path = save_image_to_persistent_storage(image, prompt, style_choice)
+        print(f"📨 OCI API Response: {response.status_code}")
         
-        if saved_path:
-            # Get just the filename for display
-            filename = os.path.basename(saved_path)
-            save_info = f"💾 **Auto-saved to Files tab:** `{PERSISTENT_IMAGE_DIR}/{style_choice}/{filename}`"
+        if response.status_code == 200:
+            result = response.json()
+            if result['status'] == 'success':
+                return result.get('file_url', 'Unknown URL')
+            else:
+                raise Exception(f"OCI API Error: {result.get('message', 'Unknown error')}")
         else:
-            save_info = "⚠️ Could not auto-save to persistent storage"
-        
-        status_msg = f"""✅ Success! Generated: {prompt}
-
-{save_info}
-
-🎨 Enhanced prompt: {enhanced_prompt}
-
-📁 **Location in Files tab:** 
-- Navigate to: `{PERSISTENT_IMAGE_DIR}/` 
-- Then go to: `{style_choice}/` folder
-- Find your image: `{os.path.basename(saved_path) if saved_path else 'filename'}`
-
-💡 You can also use the download button below the image!"""
-        
-        return image, status_msg, saved_path
-        
+            raise Exception(f"HTTP Error: {response.status_code}")
+            
     except Exception as e:
-        error_msg = f"❌ Generation failed: {str(e)}"
-        print(error_msg)
-        return None, error_msg, None
+        raise Exception(f"OCI upload failed: {str(e)}")
 
 # JOB MANAGEMENT FUNCTIONS
 def create_job(story_request: StorybookRequest) -> str:
@@ -348,6 +274,7 @@ 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"]
     
@@ -370,30 +297,168 @@ def update_job_status(job_id: str, status: JobStatus, progress: int, message: st
                 json=callback_data,
                 timeout=10
             )
-            print(f"📢 Callback sent: Status {response.status_code}")
+            print(f"📢 Callback sent to n8n: Status {response.status_code}")
         except Exception as e:
             print(f"⚠️ Callback failed: {str(e)}")
     
     return True
 
+# BACKGROUND TASK FOR COMPLETE STORYBOOK GENERATION
+def generate_storybook_background(job_id: str):
+    """Background task to generate complete storybook with images and text"""
+    try:
+        job_data = job_storage[job_id]
+        story_request_data = job_data["request"]
+        story_request = StorybookRequest(**story_request_data)
+        
+        print(f"🎬 Starting COMPLETE storybook generation for job {job_id}")
+        print(f"📖 Story: {story_request.story_title}")
+        print(f"📄 Pages: {len(story_request.scenes)} scenes")
+        
+        update_job_status(job_id, JobStatus.PROCESSING, 5, "Starting storybook generation...")
+        
+        total_scenes = len(story_request.scenes)
+        generated_pages = []
+        start_time = time.time()
+        
+        for i, scene in enumerate(story_request.scenes):
+            progress = 5 + int((i / total_scenes) * 90)
+            update_job_status(
+                job_id, 
+                JobStatus.PROCESSING, 
+                progress, 
+                f"Generating page {i+1}/{total_scenes}: {scene.visual[:50]}..."
+            )
+            
+            try:
+                print(f"🖼️ Generating page {i+1}: {scene.visual}")
+                
+                # Create enhanced prompt for high-quality image
+                enhanced_prompt, negative_prompt = enhance_prompt(scene.visual, story_request.style)
+                
+                # Generate high-quality image
+                image = generate_high_quality_image(
+                    enhanced_prompt, 
+                    story_request.model_choice, 
+                    story_request.style,
+                    negative_prompt
+                )
+                
+                # Save IMAGE to OCI bucket
+                image_url = save_to_oci_bucket(
+                    image, 
+                    "",  # No text for image
+                    story_request.story_title, 
+                    i + 1, 
+                    "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, 
+                    "text"
+                )
+                
+                # Store page data
+                page_data = {
+                    "page_number": i + 1,
+                    "image_url": image_url,
+                    "text_url": text_url,
+                    "text_content": scene.text,
+                    "prompt_used": enhanced_prompt,
+                    "visual_description": scene.visual
+                }
+                generated_pages.append(page_data)
+                
+                print(f"✅ Page {i+1} completed - Image: {image_url}, Text: {text_url}")
+                
+            except Exception as e:
+                error_msg = f"Failed to generate page {i+1}: {str(e)}"
+                print(f"❌ {error_msg}")
+                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}",
+            "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)]
+            }
+        }
+        
+        update_job_status(
+            job_id, 
+            JobStatus.COMPLETED, 
+            100, 
+            f"🎉 Storybook completed! {len(generated_pages)} pages created in {generation_time:.2f}s. Saved to OCI bucket.",
+            result
+        )
+        
+        print(f"🎉 COMPLETE Storybook generation finished for job {job_id}")
+        print(f"📁 Saved to: stories/{story_request.story_title} in OCI bucket")
+        
+    except Exception as e:
+        error_msg = f"Story generation failed: {str(e)}"
+        print(f"❌ {error_msg}")
+        update_job_status(job_id, JobStatus.FAILED, 0, error_msg)
+
 # FASTAPI ENDPOINTS
-@app.post("/api/generate-storybook", response_model=dict)
-async def generate_storybook(request: StorybookRequest, background_tasks: BackgroundTasks):
+@app.post("/api/generate-storybook")
+async def generate_storybook(request: dict, background_tasks: BackgroundTasks):
+    """Main endpoint for n8n integration - generates complete storybook"""
     try:
-        job_id = create_job(request)
-        return {
+        print(f"📥 Received n8n request for story: {request.get('story_title', 'Unknown')}")
+        
+        # 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)
+        
+        # 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 started",
+            "message": "Storybook generation started successfully",
             "job_id": job_id,
-            "story_title": request.story_title,
-            "total_scenes": len(request.scenes),
-            "callback_url": request.callback_url
+            "story_title": story_request.story_title,
+            "total_scenes": len(story_request.scenes),
+            "callback_url": story_request.callback_url,
+            "estimated_time_seconds": len(story_request.scenes) * 30,  # ~30s per image
+            "timestamp": datetime.now().isoformat()
         }
+        
+        print(f"✅ Job {job_id} started for: {story_request.story_title}")
+        
+        return response_data
+        
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Failed to start generation: {str(e)}")
+        error_msg = f"API Error: {str(e)}"
+        print(f"❌ {error_msg}")
+        raise HTTPException(status_code=500, detail=error_msg)
 
-@app.get("/api/job-status/{job_id}", response_model=JobStatusResponse)
+@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")
@@ -408,320 +473,39 @@ async def get_job_status_endpoint(job_id: str):
         updated_at=job_data["updated_at"]
     )
 
-@app.get("/api/list-test-images")
-async def list_test_images():
-    """API endpoint to list all generated test images"""
-    try:
-        images_list = []
-        for root, dirs, files in os.walk(PERSISTENT_IMAGE_DIR):
-            for file in files:
-                if file.endswith(('.png', '.jpg', '.jpeg')):
-                    full_path = os.path.join(root, file)
-                    rel_path = os.path.relpath(full_path, PERSISTENT_IMAGE_DIR)
-                    images_list.append({
-                        "filename": file,
-                        "path": rel_path,
-                        "full_path": full_path,
-                        "size": os.path.getsize(full_path) if os.path.exists(full_path) else 0,
-                        "created": os.path.getctime(full_path) if os.path.exists(full_path) else 0
-                    })
-        
-        storage_info = get_storage_info()
-        
-        return {
-            "status": "success",
-            "image_count": len(images_list),
-            "image_directory": PERSISTENT_IMAGE_DIR,
-            "storage_info": storage_info,
-            "images": sorted(images_list, key=lambda x: x["created"], reverse=True)
-        }
-    except Exception as e:
-        return {"status": "error", "message": str(e)}
-
-@app.delete("/api/delete-image/{image_path:path}")
-async def delete_image(image_path: str):
-    """API endpoint to delete an image"""
-    try:
-        # Security check: ensure the path is within our image directory
-        full_path = os.path.join(PERSISTENT_IMAGE_DIR, image_path)
-        if not full_path.startswith(os.path.abspath(PERSISTENT_IMAGE_DIR)):
-            return {"status": "error", "message": "Invalid path"}
-        
-        success, message = delete_image_file(full_path)
-        return {"status": "success" if success else "error", "message": message}
-    except Exception as e:
-        return {"status": "error", "message": str(e)}
-
-@app.delete("/api/clear-all-images")
-async def clear_all_images():
-    """API endpoint to delete all generated images"""
-    try:
-        deleted_count = 0
-        error_count = 0
-        
-        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)
-                    success, _ = delete_image_file(filepath)
-                    if success:
-                        deleted_count += 1
-                    else:
-                        error_count += 1
-        
-        return {
-            "status": "success",
-            "message": f"Deleted {deleted_count} images, {error_count} errors",
-            "deleted_count": deleted_count,
-            "error_count": error_count
-        }
-    except Exception as e:
-        return {"status": "error", "message": str(e)}
-
-# GRADIO INTERFACE
-def create_test_interface():
-    with gr.Blocks(title="High-Quality Image Generator", theme="soft") as demo:
-        gr.Markdown("# 🎨 High-Quality Image Generator")
-        gr.Markdown("**Generate studio-quality images that auto-save to your Files tab!**")
-        
-        # Storage info display
-        storage_info = gr.Textbox(
-            label="📊 Storage Information",
-            interactive=False,
-            lines=2
-        )
-        
-        def update_storage_info():
-            info = get_storage_info()
-            if "error" not in info:
-                return f"📁 Storage: {info['total_files']} images, {info['total_size_mb']} MB used"
-            return "📁 Storage: Unable to calculate"
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                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"
-                )
-                
-                prompt_input = gr.Textbox(
-                    label="Prompt",
-                    placeholder="Describe what you want to generate...",
-                    lines=3
-                )
-                
-                generate_btn = gr.Button("✨ Generate Image", variant="primary", size="lg")
-                
-                gr.Markdown("### 💡 Auto-Save Feature")
-                gr.Markdown(f"""
-                **All images are automatically saved to:**
-                - `{PERSISTENT_IMAGE_DIR}/[style]/` in your Files tab
-                - Organized by art style for easy browsing
-                - Also available via download button below
-                """)
-            
-            with gr.Column(scale=2):
-                image_output = gr.Image(
-                    label="Generated Image", 
-                    height=400, 
-                    show_download_button=True,
-                    show_share_button=True
-                )
-                
-                # Delete button for current image
-                current_file_path = gr.State()  # Hidden state to store file path
-                delete_btn = gr.Button("🗑️ Delete This Image", variant="stop", size="sm")
-                delete_status = gr.Textbox(label="Delete Status", interactive=False, lines=2)
-                
-                status_output = gr.Textbox(
-                    label="Status & File Location", 
-                    lines=4,
-                    show_copy_button=True
-                )
-        
-        # Quick examples
-        with gr.Row():
-            gr.Button("🐉 Dragon Example").click(
-                lambda: "A friendly dragon reading a giant book under a magical tree with glowing fairies",
-                outputs=prompt_input
-            )
-            gr.Button("🐱 Kitten Example").click(
-                lambda: "Cute kitten playing with yarn ball in a sunny living room",
-                outputs=prompt_input
-            )
-            gr.Button("🚀 Space Example").click(
-                lambda: "Space astronaut exploring a colorful alien planet with strange creatures",
-                outputs=prompt_input
-            )
-        
-        # Image browser section with delete functionality
-        with gr.Accordion("📁 Manage Generated Images", open=False):
-            gr.Markdown(f"### Images saved in `{PERSISTENT_IMAGE_DIR}/`")
-            
-            with gr.Row():
-                refresh_btn = gr.Button("🔄 Refresh List")
-                clear_all_btn = gr.Button("🗑️ Clear All Images", variant="stop")
-            
-            file_list = gr.Gallery(
-                label="Generated Images",
-                show_label=True,
-                elem_id="gallery",
-                columns=3,
-                height="auto"
-            )
-            
-            selected_file_info = gr.Textbox(label="Selected Image Info", interactive=False)
-            delete_selected_btn = gr.Button("🗑️ Delete Selected Image", variant="stop")
-            delete_selected_status = gr.Textbox(label="Delete Status", interactive=False)
-            
-            def refresh_file_list():
-                """Refresh the list of generated images"""
-                try:
-                    image_files = []
-                    image_info = []
-                    
-                    for root, dirs, files in os.walk(PERSISTENT_IMAGE_DIR):
-                        for file in files:
-                            if file.endswith(('.png', '.jpg', '.jpeg')):
-                                full_path = os.path.join(root, file)
-                                if os.path.exists(full_path):
-                                    image_files.append(full_path)
-                                    image_info.append(f"📄 {file}\n📁 {os.path.relpath(root, PERSISTENT_IMAGE_DIR)}")
-                    
-                    return image_files, update_storage_info()
-                except Exception as e:
-                    print(f"Error refreshing file list: {e}")
-                    return [], "❌ Error loading images"
-            
-            def get_file_info(evt: gr.SelectData):
-                """Get info about selected file"""
-                if evt.value:
-                    filepath = evt.value
-                    filename = os.path.basename(filepath)
-                    size_kb = os.path.getsize(filepath) / 1024 if os.path.exists(filepath) else 0
-                    return f"Selected: {filename}\nSize: {size_kb:.1f} KB\nPath: {filepath}"
-                return "No image selected"
-            
-            def delete_selected_file(selected_files):
-                """Delete the selected file"""
-                if not selected_files:
-                    return "❌ No image selected", None, update_storage_info()
-                
-                filepath = selected_files[0] if isinstance(selected_files, list) else selected_files
-                success, message = delete_image_file(filepath)
-                
-                # Refresh the file list
-                new_files, storage_info = refresh_file_list()
-                return message, new_files, storage_info
-            
-            def clear_all_images_func():
-                """Clear all images"""
-                try:
-                    deleted_count = 0
-                    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)
-                                success, _ = delete_image_file(filepath)
-                                if success:
-                                    deleted_count += 1
-                    
-                    new_files, storage_info = refresh_file_list()
-                    return f"✅ Deleted {deleted_count} images", new_files, storage_info
-                except Exception as e:
-                    return f"❌ Error: {str(e)}", None, update_storage_info()
-            
-            # Connect events
-            refresh_btn.click(fn=refresh_file_list, outputs=[file_list, storage_info])
-            clear_all_btn.click(fn=clear_all_images_func, outputs=[delete_selected_status, file_list, storage_info])
-            file_list.select(fn=get_file_info, outputs=selected_file_info)
-            delete_selected_btn.click(
-                fn=delete_selected_file, 
-                inputs=file_list,
-                outputs=[delete_selected_status, file_list, storage_info]
-            )
-        
-        # Delete current image functionality
-        def delete_current_image(filepath):
-            """Delete the currently displayed image"""
-            if not filepath:
-                return "❌ No image to delete", None, None, update_storage_info()
-            
-            success, message = delete_image_file(filepath)
-            new_files, storage_info = refresh_file_list()
-            
-            if success:
-                return message, None, "✅ Image deleted successfully!", storage_info
-            else:
-                return message, None, "❌ Delete failed", storage_info
-        
-        # Connect main generate button
-        generate_btn.click(
-            fn=generate_test_image,
-            inputs=[prompt_input, model_dropdown, style_dropdown],
-            outputs=[image_output, status_output, current_file_path]
-        ).then(
-            fn=refresh_file_list,
-            outputs=[file_list, storage_info]
-        )
-        
-        # Connect delete button
-        delete_btn.click(
-            fn=delete_current_image,
-            inputs=current_file_path,
-            outputs=[delete_status, image_output, status_output, storage_info]
-        ).then(
-            fn=refresh_file_list,
-            outputs=[file_list, storage_info]
-        )
-        
-        # Initialize on load
-        demo.load(fn=refresh_file_list, outputs=[file_list, storage_info])
-    
-    return demo
-
-# Create and launch Gradio app
-gradio_app = create_test_interface()
+@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()),
+        "oci_api_connected": OCI_API_BASE_URL
+    }
 
 @app.get("/")
 async def root():
-    return {"message": "Storybook Generator API + UI is running!"}
-
-@app.get("/files")
-async def files_info():
-    """Endpoint to check file structure"""
-    try:
-        file_structure = {}
-        for root, dirs, files in os.walk(PERSISTENT_IMAGE_DIR):
-            rel_root = os.path.relpath(root, PERSISTENT_IMAGE_DIR)
-            file_structure[rel_root] = {
-                "files": files,
-                "file_count": len(files)
-            }
-        
-        return {
-            "persistent_directory": PERSISTENT_IMAGE_DIR,
-            "exists": os.path.exists(PERSISTENT_IMAGE_DIR),
-            "file_structure": file_structure,
-            "storage_info": get_storage_info()
-        }
-    except Exception as e:
-        return {"error": str(e)}
+    return {
+        "message": "Storybook Generator API is running!",
+        "endpoints": {
+            "generate_storybook": "POST /api/generate-storybook",
+            "check_status": "GET /api/job-status/{job_id}",
+            "health": "GET /api/health"
+        },
+        "oci_bucket_api": OCI_API_BASE_URL
+    }
 
 # For Hugging Face Spaces
 def get_app():
     return app
 
 if __name__ == "__main__":
-    print("🚀 Starting High-Quality Storybook Generator...")
-    print(f"📁 Persistent image directory: {PERSISTENT_IMAGE_DIR}")
-    print("✅ Images will auto-save to your Files tab")
-    print("🗑️  Delete functionality enabled for storage management")
-    gradio_app.launch(server_name="0.0.0.0", server_port=7860)
+    import uvicorn
+    print("🚀 Starting Storybook Generator API...")
+    print("📚 Features: Multi-image generation + Text saving + OCI bucket storage")
+    print("🔗 OCI API:", OCI_API_BASE_URL)
+    print("🌐 API ready at: http://localhost:7860")
+    
+    uvicorn.run(app, host="0.0.0.0", port=7860)