Update app.py

app.py

@@ -24,190 +24,189 @@ logger = logging.getLogger(__name__)
 
 # --- Document export imports ---
 try:
-    from docx import Document
-    from docx.shared import Inches, Pt, RGBColor, Mm
-    from docx.enum.text import WD_ALIGN_PARAGRAPH
-    from docx.enum.style import WD_STYLE_TYPE
-    from docx.oxml.ns import qn
-    from docx.oxml import OxmlElement
-    DOCX_AVAILABLE = True
+   from docx import Document
+   from docx.shared import Inches, Pt, RGBColor, Mm
+   from docx.enum.text import WD_ALIGN_PARAGRAPH
+   from docx.enum.style import WD_STYLE_TYPE
+   from docx.oxml.ns import qn
+   from docx.oxml import OxmlElement
+   DOCX_AVAILABLE = True
 except ImportError:
-    DOCX_AVAILABLE = False
-    logger.warning("python-docx not installed. DOCX export will be disabled.")
+   DOCX_AVAILABLE = False
+   logger.warning("python-docx not installed. DOCX export will be disabled.")
 
 # --- Environment variables and constants ---
 FRIENDLI_TOKEN = os.getenv("FRIENDLI_TOKEN", "")
 BRAVE_SEARCH_API_KEY = os.getenv("BRAVE_SEARCH_API_KEY", "")
 API_URL = "https://api.friendli.ai/dedicated/v1/chat/completions"
 MODEL_ID = "dep86pjolcjjnv8"
-DB_PATH = "screenplay_sessions_v2.db"
+DB_PATH = "screenplay_sessions_v1.db"
 
 # Screenplay length settings
 SCREENPLAY_LENGTHS = {
-    "movie": {"pages": 110, "description": "Feature Film (90-120 pages)"},
-    "tv_drama": {"pages": 55, "description": "TV Drama Episode (50-60 pages)"},
-    "ott_series": {"pages": 45, "description": "OTT Series Episode (30-60 pages)"},
-    "short_film": {"pages": 15, "description": "Short Film (10-20 pages)"}
+   "movie": {"pages": 110, "description": "Feature Film (90-120 pages)"},
+   "tv_drama": {"pages": 55, "description": "TV Drama Episode (50-60 pages)"},
+   "ott_series": {"pages": 45, "description": "OTT Series Episode (30-60 pages)"},
+   "short_film": {"pages": 15, "description": "Short Film (10-20 pages)"}
 }
 
 # --- Environment validation ---
 if not FRIENDLI_TOKEN:
-    logger.error("FRIENDLI_TOKEN not set. Application will not work properly.")
-    FRIENDLI_TOKEN = "dummy_token_for_testing"
+   logger.error("FRIENDLI_TOKEN not set. Application will not work properly.")
+   FRIENDLI_TOKEN = "dummy_token_for_testing"
 
 if not BRAVE_SEARCH_API_KEY:
-    logger.warning("BRAVE_SEARCH_API_KEY not set. Web search features will be disabled.")
+   logger.warning("BRAVE_SEARCH_API_KEY not set. Web search features will be disabled.")
 
 # --- Global variables ---
 db_lock = threading.Lock()
 
 # Genre templates
 GENRE_TEMPLATES = {
-    "action": {
-        "pacing": "fast",
-        "scene_length": "short",
-        "dialogue_ratio": 0.3,
-        "key_elements": ["set pieces", "physical conflict", "urgency", "stakes escalation"],
-        "structure_beats": ["explosive opening", "pursuit/chase", "confrontation", "climactic battle"]
-    },
-    "thriller": {
-        "pacing": "fast",
-        "scene_length": "short",
-        "dialogue_ratio": 0.35,
-        "key_elements": ["suspense", "twists", "paranoia", "time pressure"],
-        "structure_beats": ["hook", "mystery deepens", "false victory", "revelation", "final confrontation"]
-    },
-    "drama": {
-        "pacing": "moderate",
-        "scene_length": "medium",
-        "dialogue_ratio": 0.5,
-        "key_elements": ["character depth", "emotional truth", "relationships", "internal conflict"],
-        "structure_beats": ["status quo", "catalyst", "debate", "commitment", "complications", "crisis", "resolution"]
-    },
-    "comedy": {
-        "pacing": "fast",
-        "scene_length": "short",
-        "dialogue_ratio": 0.6,
-        "key_elements": ["setup/payoff", "timing", "character comedy", "escalation"],
-        "structure_beats": ["funny opening", "complication", "misunderstandings multiply", "chaos peak", "resolution with callback"]
-    },
-    "horror": {
-        "pacing": "variable",
-        "scene_length": "mixed",
-        "dialogue_ratio": 0.3,
-        "key_elements": ["atmosphere", "dread", "jump scares", "gore/psychological"],
-        "structure_beats": ["normal world", "first sign", "investigation", "first attack", "survival", "final girl/boy"]
-    },
-    "sci-fi": {
-        "pacing": "moderate",
-        "scene_length": "medium",
-        "dialogue_ratio": 0.4,
-        "key_elements": ["world building", "technology", "concepts", "visual spectacle"],
-        "structure_beats": ["ordinary world", "discovery", "new world", "complications", "understanding", "choice", "new normal"]
-    },
-    "romance": {
-        "pacing": "moderate",
-        "scene_length": "medium",
-        "dialogue_ratio": 0.55,
-        "key_elements": ["chemistry", "obstacles", "emotional moments", "intimacy"],
-        "structure_beats": ["meet cute", "attraction", "first conflict", "deepening", "crisis/breakup", "grand gesture", "together"]
-    }
+   "action": {
+       "pacing": "fast",
+       "scene_length": "short",
+       "dialogue_ratio": 0.3,
+       "key_elements": ["set pieces", "physical conflict", "urgency", "stakes escalation"],
+       "structure_beats": ["explosive opening", "pursuit/chase", "confrontation", "climactic battle"]
+   },
+   "thriller": {
+       "pacing": "fast",
+       "scene_length": "short",
+       "dialogue_ratio": 0.35,
+       "key_elements": ["suspense", "twists", "paranoia", "time pressure"],
+       "structure_beats": ["hook", "mystery deepens", "false victory", "revelation", "final confrontation"]
+   },
+   "drama": {
+       "pacing": "moderate",
+       "scene_length": "medium",
+       "dialogue_ratio": 0.5,
+       "key_elements": ["character depth", "emotional truth", "relationships", "internal conflict"],
+       "structure_beats": ["status quo", "catalyst", "debate", "commitment", "complications", "crisis", "resolution"]
+   },
+   "comedy": {
+       "pacing": "fast",
+       "scene_length": "short",
+       "dialogue_ratio": 0.6,
+       "key_elements": ["setup/payoff", "timing", "character comedy", "escalation"],
+       "structure_beats": ["funny opening", "complication", "misunderstandings multiply", "chaos peak", "resolution with callback"]
+   },
+   "horror": {
+       "pacing": "variable",
+       "scene_length": "mixed",
+       "dialogue_ratio": 0.3,
+       "key_elements": ["atmosphere", "dread", "jump scares", "gore/psychological"],
+       "structure_beats": ["normal world", "first sign", "investigation", "first attack", "survival", "final girl/boy"]
+   },
+   "sci-fi": {
+       "pacing": "moderate",
+       "scene_length": "medium",
+       "dialogue_ratio": 0.4,
+       "key_elements": ["world building", "technology", "concepts", "visual spectacle"],
+       "structure_beats": ["ordinary world", "discovery", "new world", "complications", "understanding", "choice", "new normal"]
+   },
+   "romance": {
+       "pacing": "moderate",
+       "scene_length": "medium",
+       "dialogue_ratio": 0.55,
+       "key_elements": ["chemistry", "obstacles", "emotional moments", "intimacy"],
+       "structure_beats": ["meet cute", "attraction", "first conflict", "deepening", "crisis/breakup", "grand gesture", "together"]
+   }
 }
 
 # Screenplay stages definition
 SCREENPLAY_STAGES = [
-    ("producer", "🎬 Producer: Concept Development & Market Analysis"),
-    ("story_developer", "📖 Story Developer: Synopsis & Three-Act Structure"),
-    ("character_designer", "👥 Character Designer: Cast & Relationships"),
-    ("critic_structure", "🔍 Structure Critic: Story & Character Review"),
-    ("scene_planner", "🎯 Scene Planner: Detailed Scene Breakdown"),
-    ("screenwriter", "✍️ Screenwriter: Act 1 - Setup (25%)"),
-    ("script_doctor", "🔧 Script Doctor: Act 1 Review & Polish"),
-    ("screenwriter", "✍️ Screenwriter: Act 2A - Rising Action (25%)"),
-    ("script_doctor", "🔧 Script Doctor: Act 2A Review & Polish"),
-    ("screenwriter", "✍️ Screenwriter: Act 2B - Complications (25%)"),
-    ("script_doctor", "🔧 Script Doctor: Act 2B Review & Polish"),
-    ("screenwriter", "✍️ Screenwriter: Act 3 - Resolution (25%)"),
-    ("final_reviewer", "🎭 Final Review: Complete Screenplay Analysis"),
+   ("producer", "🎬 Producer: Concept Development & Market Analysis"),
+   ("story_developer", "📖 Story Developer: Synopsis & Three-Act Structure"),
+   ("character_designer", "👥 Character Designer: Cast & Relationships"),
+   ("critic_structure", "🔍 Structure Critic: Story & Character Review"),
+   ("scene_planner", "🎯 Scene Planner: Detailed Scene Breakdown"),
+   ("screenwriter", "✍️ Screenwriter: Act 1 - Setup (25%)"),
+   ("script_doctor", "🔧 Script Doctor: Act 1 Review & Polish"),
+   ("screenwriter", "✍️ Screenwriter: Act 2A - Rising Action (25%)"),
+   ("script_doctor", "🔧 Script Doctor: Act 2A Review & Polish"),
+   ("screenwriter", "✍️ Screenwriter: Act 2B - Complications (25%)"),
+   ("script_doctor", "🔧 Script Doctor: Act 2B Review & Polish"),
+   ("screenwriter", "✍️ Screenwriter: Act 3 - Resolution (25%)"),
+   ("final_reviewer", "🎭 Final Review: Complete Screenplay Analysis"),
 ]
 
 # Save the Cat Beat Sheet
 SAVE_THE_CAT_BEATS = {
-    1: "Opening Image (0-1%)",
-    2: "Setup (1-10%)",
-    3: "Theme Stated (5%)",
-    4: "Catalyst (10%)",
-    5: "Debate (10-20%)",
-    6: "Break into Two (20%)",
-    7: "B Story (22%)",
-    8: "Fun and Games (20-50%)",
-    9: "Midpoint (50%)",
-    10: "Bad Guys Close In (50-75%)",
-    11: "All Is Lost (75%)",
-    12: "Dark Night of the Soul (75-80%)",
-    13: "Break into Three (80%)",
-    14: "Finale (80-99%)",
-    15: "Final Image (99-100%)"
+   1: "Opening Image (0-1%)",
+   2: "Setup (1-10%)",
+   3: "Theme Stated (5%)",
+   4: "Catalyst (10%)",
+   5: "Debate (10-20%)",
+   6: "Break into Two (20%)",
+   7: "B Story (22%)",
+   8: "Fun and Games (20-50%)",
+   9: "Midpoint (50%)",
+   10: "Bad Guys Close In (50-75%)",
+   11: "All Is Lost (75%)",
+   12: "Dark Night of the Soul (75-80%)",
+   13: "Break into Three (80%)",
+   14: "Finale (80-99%)",
+   15: "Final Image (99-100%)"
 }
 
 # --- Data classes ---
 @dataclass
 class ScreenplayBible:
-    """Screenplay bible for maintaining consistency"""
-    title: str = ""
-    logline: str = ""
-    genre: str = ""
-    subgenre: str = ""
-    tone: str = ""
-    themes: List[str] = field(default_factory=list)
-    
-    # Characters
-    protagonist: Dict[str, Any] = field(default_factory=dict)
-    antagonist: Dict[str, Any] = field(default_factory=dict)
-    supporting_cast: Dict[str, Dict[str, Any]] = field(default_factory=dict)
-    
-    # Structure
-    three_act_structure: Dict[str, str] = field(default_factory=dict)
-    save_the_cat_beats: Dict[int, str] = field(default_factory=dict)
-    
-    # World
-    time_period: str = ""
-    primary_locations: List[Dict[str, str]] = field(default_factory=list)
-    world_rules: List[str] = field(default_factory=list)
-    
-    # Visual style
-    visual_style: str = ""
-    key_imagery: List[str] = field(default_factory=list)
+   """Screenplay bible for maintaining consistency"""
+   title: str = ""
+   logline: str = ""
+   genre: str = ""
+   subgenre: str = ""
+   tone: str = ""
+   themes: List[str] = field(default_factory=list)
+   
+   # Characters
+   protagonist: Dict[str, Any] = field(default_factory=dict)
+   antagonist: Dict[str, Any] = field(default_factory=dict)
+   supporting_cast: Dict[str, Dict[str, Any]] = field(default_factory=dict)
+   
+   # Structure
+   three_act_structure: Dict[str, str] = field(default_factory=dict)
+   save_the_cat_beats: Dict[int, str] = field(default_factory=dict)
+   
+   # World
+   time_period: str = ""
+   primary_locations: List[Dict[str, str]] = field(default_factory=list)
+   world_rules: List[str] = field(default_factory=list)
+   
+   # Visual style
+   visual_style: str = ""
+   key_imagery: List[str] = field(default_factory=list)
 
 @dataclass
 class SceneBreakdown:
-    """Individual scene information"""
-    scene_number: int
-    act: int
-    location: str
-    time_of_day: str
-    characters: List[str]
-    purpose: str
-    conflict: str
-    page_count: float
-    beat: str = ""
-    transition: str = "CUT TO:"
+   """Individual scene information"""
+   scene_number: int
+   act: int
+   location: str
+   time_of_day: str
+   characters: List[str]
+   purpose: str
+   conflict: str
+   page_count: float
+   beat: str = ""
+   transition: str = "CUT TO:"
 
 @dataclass
 class CharacterProfile:
-    """Detailed character profile"""
-    name: str
-    age: int
-    role: str  # protagonist, antagonist, supporting, etc.
-    archetype: str
-    want: str  # External goal
-    need: str  # Internal need
-    backstory: str
-    personality: List[str]
-    speech_pattern: str
-    character_arc: str
-    relationships: Dict[str, str] = field(default_factory=dict)
-    first_appearance: str = ""
+   """Detailed character profile"""
+   name: str
+   role: str  # protagonist, antagonist, supporting, etc.
+   archetype: str
+   want: str  # External goal
+   need: str  # Internal need
+   backstory: str
+   personality: List[str]
+   speech_pattern: str
+   character_arc: str
+   relationships: Dict[str, str] = field(default_factory=dict)
+   first_appearance: str = ""
 
 # --- Core logic classes ---
 class ScreenplayTracker:
@@ -537,51 +536,63 @@ class ScreenplayDatabase:
         
         return theme_id
 
+    @staticmethod
+    def get_stages(session_id: str) -> List[Dict]:
+        """Get all stages for a session"""
+        with ScreenplayDatabase.get_db() as conn:
+            rows = conn.cursor().execute(
+                '''SELECT * FROM screenplay_stages 
+                   WHERE session_id = ? 
+                   ORDER BY stage_number''', 
+                (session_id,)
+            ).fetchall()
+            return [dict(row) for row in rows]
+
 class WebSearchIntegration:
-    """Web search functionality for screenplay research"""
-    def __init__(self):
-        self.brave_api_key = BRAVE_SEARCH_API_KEY
-        self.search_url = "https://api.search.brave.com/res/v1/web/search"
-        self.enabled = bool(self.brave_api_key)
-
-    def search(self, query: str, count: int = 3, language: str = "en") -> List[Dict]:
-        if not self.enabled:
-            return []
-        headers = {
-            "Accept": "application/json",
-            "X-Subscription-Token": self.brave_api_key
-        }
-        params = {
-            "q": query,
-            "count": count,
-            "search_lang": "ko" if language == "Korean" else "en",
-            "text_decorations": False,
-            "safesearch": "moderate"
-        }
-        try:
-            response = requests.get(self.search_url, headers=headers, params=params, timeout=10)
-            response.raise_for_status()
-            results = response.json().get("web", {}).get("results", [])
-            return results
-        except requests.exceptions.RequestException as e:
-            logger.error(f"Web search API error: {e}")
-            return []
-
-    def extract_relevant_info(self, results: List[Dict], max_chars: int = 1500) -> str:
-        if not results:
-            return ""
-        extracted = []
-        total_chars = 0
-        for i, result in enumerate(results[:3], 1):
-            title = result.get("title", "")
-            description = result.get("description", "")
-            info = f"[{i}] {title}: {description}"
-            if total_chars + len(info) < max_chars:
-                extracted.append(info)
-                total_chars += len(info)
-            else:
-                break
-        return "\n".join(extracted)
+   """Web search functionality for screenplay research"""
+   def __init__(self):
+       self.brave_api_key = BRAVE_SEARCH_API_KEY
+       self.search_url = "https://api.search.brave.com/res/v1/web/search"
+       self.enabled = bool(self.brave_api_key)
+
+   def search(self, query: str, count: int = 3, language: str = "en") -> List[Dict]:
+       if not self.enabled:
+           return []
+       headers = {
+           "Accept": "application/json",
+           "X-Subscription-Token": self.brave_api_key
+       }
+       params = {
+           "q": query,
+           "count": count,
+           "search_lang": "ko" if language == "Korean" else "en",
+           "text_decorations": False,
+           "safesearch": "moderate"
+       }
+       try:
+           response = requests.get(self.search_url, headers=headers, params=params, timeout=10)
+           response.raise_for_status()
+           results = response.json().get("web", {}).get("results", [])
+           return results
+       except requests.exceptions.RequestException as e:
+           logger.error(f"Web search API error: {e}")
+           return []
+
+   def extract_relevant_info(self, results: List[Dict], max_chars: int = 1500) -> str:
+       if not results:
+           return ""
+       extracted = []
+       total_chars = 0
+       for i, result in enumerate(results[:3], 1):
+           title = result.get("title", "")
+           description = result.get("description", "")
+           info = f"[{i}] {title}: {description}"
+           if total_chars + len(info) < max_chars:
+               extracted.append(info)
+               total_chars += len(info)
+           else:
+               break
+       return "\n".join(extracted)
 
 class ScreenplayGenerationSystem:
     """Professional screenplay generation system"""
@@ -866,7 +877,7 @@ Create specific, emotionally resonant story."""
 **필수 캐릭터 프로필:**
 
 1. **주인공 (PROTAGONIST)**
-   - 이름, 나이:
+   - 이름:
    - 직업/역할:
    - 캐릭터 아크타입:
    - WANT (외적 목표):
@@ -879,7 +890,7 @@ Create specific, emotionally resonant story."""
    - 캐릭터 아크 (A→B):
 
 2. **적대자 (ANTAGONIST)**
-   - 이름, 나이:
+   - 이름:
    - 직업/역할:
    - 악역 아크타입:
    - 목표 & 동기:
@@ -890,7 +901,7 @@ Create specific, emotionally resonant story."""
 
 3. **조력자들 (SUPPORTING CAST)**
    최소 3명, 각각:
-   - 이름, 역할:
+   - 이름 & 역할:
    - 주인공과의 관계:
    - 스토리 기능:
    - 독특한 특성:
@@ -904,7 +915,7 @@ Create specific, emotionally resonant story."""
 
 5. **캐스팅 제안**
    - 각 주요 캐릭터별 이상적인 배우 타입
-   - 연령대, 외모, 연기 스타일
+   - 외모, 연기 스타일
 
 6. **대화 샘플**
    - 각 주요 캐릭터의 시그니처 대사 2-3개
@@ -923,7 +934,7 @@ Create specific, emotionally resonant story."""
 **Required Character Profiles:**
 
 1. **PROTAGONIST**
-   - Name, Age:
+   - Name:
    - Occupation/Role:
    - Character Archetype:
    - WANT (External Goal):
@@ -936,7 +947,7 @@ Create specific, emotionally resonant story."""
    - Character Arc (A→B):
 
 2. **ANTAGONIST**
-   - Name, Age:
+   - Name:
    - Occupation/Role:
    - Villain Archetype:
    - Goal & Motivation:
@@ -947,7 +958,7 @@ Create specific, emotionally resonant story."""
 
 3. **SUPPORTING CAST**
    Minimum 3, each with:
-   - Name, Role:
+   - Name & Role:
    - Relationship to Protagonist:
    - Story Function:
    - Unique Traits:
@@ -961,7 +972,7 @@ Create specific, emotionally resonant story."""
 
 5. **CASTING SUGGESTIONS**
    - Ideal actor type for each major character
-   - Age range, appearance, acting style
+   - Appearance, acting style
 
 6. **DIALOGUE SAMPLES**
    - 2-3 signature lines per major character
@@ -1092,7 +1103,7 @@ Plan each scene to advance story and develop character."""
    - 감정은 행동으로 표현
 
 3. **캐릭터 소개**
-   첫 등장시: 이름 (나이) 간단한 묘사
+   첫 등장시: 이름과 간단한 묘사
 
 4. **대화**
    캐릭터명
@@ -1139,7 +1150,7 @@ Plan each scene to advance story and develop character."""
    - Emotions through actions
 
 3. **Character Intros**
-   First appearance: NAME (age) brief description
+   First appearance: NAME with brief description
 
 4. **Dialogue**
    CHARACTER NAME
@@ -1470,6 +1481,8 @@ Provide specific solutions for each issue."""
             raise Exception(f"LLM Call Failed: {full_content}")
         return full_content
 
+
+
     def call_llm_streaming(self, messages: List[Dict[str, str]], role: str, 
                           language: str) -> Generator[str, None, None]:
         try:
@@ -1533,422 +1546,7 @@ Provide specific solutions for each issue."""
                         elif 'message' in error_data:
                             error_msg += f" - {error_data['message']}"
                 except Exception as e:
-                    logger.error(f"Error processing line {line_count}: {str(e)}")
-                    logger.debug(f"Problematic line: {line_str[:100] if 'line_str' in locals() else 'N/A'}")
-                    continue
-            
-            # Yield any remaining buffer content
-            if buffer:
-                yield buffer
-            
-            # Check if we got any content
-            if line_count == 0:
-                logger.error("No lines received from API")
-                yield "❌ No response from API"
-                
-        except requests.exceptions.Timeout:
-            logger.error("API request timed out")
-            yield "❌ Request timed out. Please try again."
-        except requests.exceptions.ConnectionError as e:
-            logger.error(f"Connection error: {e}")
-            yield "❌ Connection error. Please check your internet connection."
-        except requests.exceptions.RequestException as e:
-            logger.error(f"Request error: {type(e).__name__}: {str(e)}")
-            yield f"❌ Network error: {str(e)}"
-        except Exception as e:
-            logger.error(f"Unexpected error in streaming: {type(e).__name__}: {str(e)}")
-            import traceback
-            logger.error(traceback.format_exc())
-            yield f"❌ Unexpected error: {str(e)}"
-
-    def get_system_prompts(self, language: str) -> Dict[str, str]:
-        """Role-specific system prompts"""
-        
-        base_prompts = {
-            "Korean": {
-                "producer": """당신은 20년 경력의 할리우드 프로듀서입니다.
-상업적 성공과 예술적 가치를 모두 추구합니다.
-시장 트렌드와 관객 심리를 정확히 파악합니다.
-실현 가능하고 매력적인 프로젝트를 개발합니다.""",
-                
-                "story_developer": """당신은 수상 경력이 있는 스토리 개발자입니다.
-감정적으로 공감가고 구조적으로 탄탄한 이야기를 만듭니다.
-캐릭터의 내적 여정과 외적 플롯을 조화롭게 엮습니다.
-보편적 주제를 독특한 방식으로 탐구합니다.""",
-                
-                "character_designer": """당신은 심리학을 공부한 캐릭터 디자이너입니다.
-진짜 같은 인물들을 창조하는 전문가입니다.
-각 캐릭터에게 고유한 목소리와 관점을 부여합니다.
-복잡하고 모순적인 인간성을 포착합니다.""",
-                
-                "scene_planner": """당신은 정밀한 씬 구성의 대가입니다.
-각 씬이 스토리와 캐릭터를 전진시키도록 설계합니다.
-리듬과 페이싱을 완벽하게 조절합니다.
-시각적 스토리텔링을 극대화합니다.""",
-                
-                "screenwriter": """당신은 다작의 시나리오 작가입니다.
-'보여주기'의 대가이며 서브텍스트를 능숙하게 다룹니다.
-생생하고 자연스러운 대화를 쓰는 전문가입니다.
-제작 현실을 고려하면서도 창의적인 해결책을 찾습니다.""",
-                
-                "script_doctor": """당신은 까다로운 스크립트 닥터입니다.
-작은 디테일도 놓치지 않는 완벽주의자입니다.
-스토리의 잠재력을 최대한 끌어냅니다.
-건설적이고 구체적인 개선안을 제시합니다.""",
-                
-                "critic_structure": """당신은 구조 분석 전문가입니다.
-스토리의 뼈대와 근육을 꿰뚫어 봅니다.
-논리적 허점과 감정적 공백을 찾아냅니다.
-더 나은 구조를 위한 구체적 제안을 합니다.""",
-                
-                "final_reviewer": """당신은 업계 베테랑 최종 리뷰어입니다.
-상업성과 예술성을 균형있게 평가합니다.
-제작사, 배우, 관객 모든 관점을 고려합니다.
-냉정하지만 격려하는 피드백을 제공합니다."""
-            },
-            "English": {
-                "producer": """You are a Hollywood producer with 20 years experience.
-You pursue both commercial success and artistic value.
-You accurately grasp market trends and audience psychology.
-You develop feasible and attractive projects.""",
-                
-                "story_developer": """You are an award-winning story developer.
-You create emotionally resonant and structurally sound stories.
-You harmoniously weave internal journeys with external plots.
-You explore universal themes in unique ways.""",
-                
-                "character_designer": """You are a character designer who studied psychology.
-You're an expert at creating lifelike characters.
-You give each character a unique voice and perspective.
-You capture complex and contradictory humanity.""",
-                
-                "scene_planner": """You are a master of precise scene construction.
-You design each scene to advance story and character.
-You perfectly control rhythm and pacing.
-You maximize visual storytelling.""",
-                
-                "screenwriter": """You are a prolific screenwriter.
-You're a master of 'showing' and skilled with subtext.
-You're an expert at writing vivid, natural dialogue.
-You find creative solutions while considering production reality.""",
-                
-                "script_doctor": """You are a demanding script doctor.
-You're a perfectionist who misses no small detail.
-You maximize the story's potential.
-You provide constructive and specific improvements.""",
-                
-                "critic_structure": """You are a structure analysis expert.
-You see through the story's skeleton and muscles.
-You find logical gaps and emotional voids.
-You make specific suggestions for better structure.""",
-                
-                "final_reviewer": """You are an industry veteran final reviewer.
-You evaluate commercial and artistic value in balance.
-You consider all perspectives: producers, actors, audience.
-You provide feedback that's critical yet encouraging."""
-            }
-        }
-        
-        return base_prompts.get(language, base_prompts["English"])
-
-    # --- Main process ---
-    def process_screenplay_stream(self, query: str, screenplay_type: str, genre: str,
-                                language: str, session_id: Optional[str] = None
-                                ) -> Generator[Tuple[str, List[Dict[str, Any]], str], None, None]:
-        """Main screenplay generation process"""
-        try:
-            resume_from_stage = 0
-            if session_id:
-                self.current_session_id = session_id
-                session = ScreenplayDatabase.get_session(session_id)
-                if session:
-                    query = session['user_query']
-                    screenplay_type = session['screenplay_type']
-                    genre = session['genre']
-                    language = session['language']
-                    resume_from_stage = session['current_stage'] + 1
-            else:
-                self.current_session_id = ScreenplayDatabase.create_session(
-                    query, screenplay_type, genre, language
-                )
-                logger.info(f"Created new screenplay session: {self.current_session_id}")
-
-            stages = []
-            if resume_from_stage > 0:
-                # Get existing stages from database
-                db_stages = ScreenplayDatabase.get_stages(self.current_session_id)
-                stages = [{
-                    "name": s['stage_name'], 
-                    "status": s['status'], 
-                    "content": s.get('content', ''),
-                    "page_count": s.get('page_count', 0)
-                } for s in db_stages]
-
-            for stage_idx in range(resume_from_stage, len(SCREENPLAY_STAGES)):
-                role, stage_name = SCREENPLAY_STAGES[stage_idx]
-                
-                if stage_idx >= len(stages):
-                    stages.append({
-                        "name": stage_name, 
-                        "status": "active", 
-                        "content": "", 
-                        "page_count": 0
-                    })
-                else:
-                    stages[stage_idx]["status"] = "active"
-
-                yield f"🔄 Processing {stage_name}...", stages, self.current_session_id
-                
-                prompt = self.get_stage_prompt(stage_idx, role, query, screenplay_type, 
-                                             genre, language, stages)
-                stage_content = ""
-                
-                for chunk in self.call_llm_streaming([{"role": "user", "content": prompt}], 
-                                                   role, language):
-                    stage_content += chunk
-                    stages[stage_idx]["content"] = stage_content
-                    if role == "screenwriter":
-                        stages[stage_idx]["page_count"] = len(stage_content.split('\n')) / 55
-                    yield f"🔄 {stage_name} in progress...", stages, self.current_session_id
-
-                # Process content based on role
-                if role == "producer":
-                    self._process_producer_content(stage_content)
-                elif role == "story_developer":
-                    self._process_story_content(stage_content)
-                elif role == "character_designer":
-                    self._process_character_content(stage_content)
-                elif role == "scene_planner":
-                    self._process_scene_content(stage_content)
-
-                stages[stage_idx]["status"] = "complete"
-                ScreenplayDatabase.save_stage(
-                    self.current_session_id, stage_idx, stage_name, role,
-                    stage_content, "complete"
-                )
-                
-                yield f"✅ {stage_name} completed", stages, self.current_session_id
-
-            # Final processing
-            final_screenplay = ScreenplayDatabase.get_screenplay_content(self.current_session_id)
-            title = self.screenplay_tracker.screenplay_bible.title
-            logline = self.screenplay_tracker.screenplay_bible.logline
-            
-            ScreenplayDatabase.update_final_screenplay(
-                self.current_session_id, final_screenplay, title, logline
-            )
-            
-            yield f"✅ Screenplay completed! {title}", stages, self.current_session_id
-
-        except Exception as e:
-            logger.error(f"Screenplay generation error: {e}", exc_info=True)
-            yield f"❌ Error occurred: {e}", stages if 'stages' in locals() else [], self.current_session_id
-
-    def get_stage_prompt(self, stage_idx: int, role: str, query: str, 
-                        screenplay_type: str, genre: str, language: str, 
-                        stages: List[Dict]) -> str:
-        """Generate stage-specific prompt"""
-        if stage_idx == 0:  # Producer
-            return self.create_producer_prompt(query, screenplay_type, genre, language)
-        
-        if stage_idx == 1:  # Story Developer
-            return self.create_story_developer_prompt(
-                stages[0]["content"], query, screenplay_type, genre, language
-            )
-        
-        if stage_idx == 2:  # Character Designer
-            return self.create_character_designer_prompt(
-                stages[0]["content"], stages[1]["content"], genre, language
-            )
-        
-        if stage_idx == 3:  # Structure Critic
-            return self.create_critic_structure_prompt(
-                stages[1]["content"], stages[2]["content"], screenplay_type, genre, language
-            )
-        
-        if stage_idx == 4:  # Scene Planner
-            return self.create_scene_planner_prompt(
-                stages[1]["content"], stages[2]["content"], screenplay_type, genre, language
-            )
-        
-        # Screenwriter acts
-        if role == "screenwriter":
-            act_mapping = {5: "Act 1", 7: "Act 2A", 9: "Act 2B", 11: "Act 3"}
-            if stage_idx in act_mapping:
-                act = act_mapping[stage_idx]
-                previous_acts = self._get_previous_acts(stages, stage_idx)
-                return self.create_screenwriter_prompt(
-                    act, stages[4]["content"], stages[2]["content"], 
-                    previous_acts, screenplay_type, genre, language
-                )
-        
-        # Script doctor reviews
-        if role == "script_doctor":
-            act_mapping = {6: "Act 1", 8: "Act 2A", 10: "Act 2B"}
-            if stage_idx in act_mapping:
-                act = act_mapping[stage_idx]
-                act_content = stages[stage_idx-1]["content"]
-                return self.create_script_doctor_prompt(act_content, act, genre, language)
-        
-        # Final reviewer
-        if role == "final_reviewer":
-            complete_screenplay = ScreenplayDatabase.get_screenplay_content(self.current_session_id)
-            return self.create_final_reviewer_prompt(
-                complete_screenplay, screenplay_type, genre, language
-            )
-        
-        return ""
-
-    def _get_previous_acts(self, stages: List[Dict], current_idx: int) -> str:
-        """Get previous acts content"""
-        previous = []
-        act_indices = {5: [], 7: [5], 9: [5, 7], 11: [5, 7, 9]}
-        
-        if current_idx in act_indices:
-            for idx in act_indices[current_idx]:
-                if idx < len(stages) and stages[idx]["content"]:
-                    previous.append(stages[idx]["content"])
-        
-        return "\n\n---\n\n".join(previous) if previous else ""
-
-    def _parse_character_profile(self, content: str, role: str) -> CharacterProfile:
-        """Parse character profile from content with improved error handling"""
-        # Debug logging
-        logger.debug(f"Parsing character profile for role: {role}")
-        logger.debug(f"Content preview: {content[:200]}...")
-        
-        # Extract name first - handle various formats
-        name = f"Character_{role}"  # default
-        name_patterns = [
-            r'(?:이름|Name)[:\s]*([^,\n]+?)(?:\s*\([^)]+\))?\s*[,:]?\s*(?:\d+세)?',
-            r'^\s*[-*•]\s*([^,\n]+?)(?:\s*\([^)]+\))?\s*[,:]?\s*(?:\d+세)?',
-            r'^([^,\n]+?)(?:\s*\([^)]+\))?\s*[,:]?\s*(?:\d+세)?'
-        ]
-        
-        for pattern in name_patterns:
-            name_match = re.search(pattern, content, re.IGNORECASE | re.MULTILINE)
-            if name_match:
-                extracted_name = name_match.group(1).strip()
-                # Remove markdown and extra characters
-                extracted_name = re.sub(r'[*:\s]+', '', extracted_name)
-                extracted_name = re.sub(r'^[*:\s]+', '', extracted_name)
-                # Remove age if it's part of the name
-                extracted_name = re.sub(r'\s*,?\s*\d+\s*(?:세|살)?', '', extracted_name)
-                if extracted_name and len(extracted_name) > 1:
-                    name = extracted_name
-                    break
-        
-        # Extract age with multiple patterns - FIXED VERSION
-        age = 30  # default age
-        age_patterns = [
-            r'(\d+)\s*세',
-            r'(\d+)\s*살',
-            r'(?:나이|Age)[:\s]*(\d+)',
-            r',\s*(\d+)\s*(?:세|살)?(?:\s|,|$)',
-            r'\((\d+)\)',
-            r':\s*\w+\s*,?\s*(\d+)(?:\s|,|$)'
-        ]
-        
-        for pattern in age_patterns:
-            age_match = re.search(pattern, content, re.IGNORECASE)
-            if age_match:
-                try:
-                    extracted_age = int(age_match.group(1))
-                    if 10 <= extracted_age <= 100:  # Reasonable age range
-                        age = extracted_age
-                        logger.debug(f"Extracted age: {age}")
-                        break
-                except (ValueError, AttributeError):
-                    continue
-        
-        # Helper function to extract clean fields
-        def extract_clean_field(patterns, multiline=False):
-            if isinstance(patterns, str):
-                patterns = [patterns]
-            
-            flags = re.IGNORECASE | re.DOTALL if multiline else re.IGNORECASE
-            
-            for pattern in patterns:
-                match = re.search(rf'{pattern}[:\s]*([^\n*]+?)(?=\n|$)', content, flags)
-                if match:
-                    value = match.group(1).strip()
-                    # Clean up the value
-                    value = re.sub(r'^[-*•:\s]+', '', value)
-                    value = re.sub(r'[*]+', '', value)
-                    value = re.sub(r'\s+', ' ', value)
-                    if value:
-                        return value
-            return ""
-        
-        # Extract all fields
-        profile = CharacterProfile(
-            name=name,
-            age=age,
-            role=role,
-            archetype=extract_clean_field([
-                r"캐릭터 아크타입",
-                r"Character Archetype",
-                r"Archetype",
-                r"아크타입"
-            ]),
-            want=extract_clean_field([
-                r"WANT\s*\(외적 목표\)",
-                r"WANT",
-                r"외적 목표",
-                r"External Goal"
-            ]),
-            need=extract_clean_field([
-                r"NEED\s*\(내적 필요\)",
-                r"NEED",
-                r"내적 필요",
-                r"Internal Need"
-            ]),
-            backstory=extract_clean_field([
-                r"백스토리",
-                r"Backstory",
-                r"핵심 상처",
-                r"Core Wound"
-            ], multiline=True),
-            personality=self._extract_personality_traits(content),
-            speech_pattern=extract_clean_field([
-                r"말투.*?패턴",
-                r"Speech Pattern",
-                r"언어 패턴",
-                r"말투"
-            ]),
-            character_arc=extract_clean_field([
-                r"캐릭터 아크",
-                r"Character Arc",
-                r"Arc",
-                r"변화"
-            ])
-        )
-        
-        logger.debug(f"Parsed character: {profile.name}, age: {profile.age}")
-        return profile
-
-    def _extract_field(self, content: str, field_pattern: str) -> Optional[str]:
-        """Extract field value from content with improved parsing"""
-        # More flexible pattern that handles various formats
-        patterns = field_pattern.split('|')
-        
-        for pattern in patterns:
-            # Try different regex patterns
-            regex_patterns = [
-                rf'\b{pattern}\b[:\s]*([^\n]+?)(?=\n[A-Z가-힣]|$)',
-                rf'{pattern}[:\s]*([^\n]+)',
-                rf'{pattern}.*?[:\s]+([^\n]+)'
-            ]
-            
-            for regex in regex_patterns:
-                match = re.search(regex, content, re.IGNORECASE | re.DOTALL)
-                if match:
-                    value = match.group(1).strip()
-                    # Remove markdown formatting if present
-                    value = re.sub(r'\*\*', '', value)
-                    value = re.sub(r'^\s*[-•*]\s*', '', value)
-                    # Remove trailing punctuation
-                    value = re.sub(r'[,.:;]error(f"Error parsing error response: {e}")
+                    logger.error(f"Error parsing error response: {e}")
                     error_msg += f" - {response.text[:200]}"
                 
                 yield f"❌ {error_msg}"
@@ -2005,988 +1603,4 @@ You provide feedback that's critical yet encouraging."""
                                             yield buffer
                                             buffer = ""
                                             time.sleep(0.01)
-                    
-                except Exception as e:
-                    logger., '', value)
-                    cleaned = value.strip()
-                    if cleaned:
-                        return cleaned
-        
-        return None
-
-    def _extract_personality_traits(self, content: str) -> List[str]:
-        """Extract personality traits from content"""
-        traits = []
-        # Look for personality section
-        personality_patterns = [
-            r"(?:Personality|성격)[:\s]*([^\n]+(?:\n\s*[-•*][^\n]+)*)",
-            r"성격 특성[:\s]*([^\n]+(?:\n\s*[-•*][^\n]+)*)",
-            r"Personality Traits[:\s]*([^\n]+(?:\n\s*[-•*][^\n]+)*)"
-        ]
-        
-        for pattern in personality_patterns:
-            match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-            if match:
-                personality_section = match.group(1)
-                # Extract individual traits
-                trait_lines = personality_section.split('\n')
-                for line in trait_lines:
-                    line = line.strip()
-                    if line and not line.endswith(':'):
-                        # Remove list markers
-                        trait = re.sub(r'^\s*[-•*]\s*', '', line)
-                        trait = re.sub(r'^\d+\.\s*', '', trait)
-                        if trait and len(trait) > 2:
-                            traits.append(trait)
-                break
-        
-        return traits[:5]  # Limit to 5 traits
-
-    def _process_character_content(self, content: str):
-        """Process character designer output with better error handling"""
-        try:
-            # Extract protagonist
-            protagonist_section = self._extract_section(content, r"(?:PROTAGONIST|주인공)")
-            if protagonist_section:
-                protagonist = self._parse_character_profile(protagonist_section, "protagonist")
-                self.screenplay_tracker.add_character(protagonist)
-                ScreenplayDatabase.save_character(self.current_session_id, protagonist)
-            
-            # Extract antagonist
-            antagonist_section = self._extract_section(content, r"(?:ANTAGONIST|적대자)")
-            if antagonist_section:
-                antagonist = self._parse_character_profile(antagonist_section, "antagonist")
-                self.screenplay_tracker.add_character(antagonist)
-                ScreenplayDatabase.save_character(self.current_session_id, antagonist)
-            
-            # Extract supporting characters
-            supporting_section = self._extract_section(content, r"(?:SUPPORTING CAST|조력자들)")
-            if supporting_section:
-                # Parse multiple supporting characters
-                self._parse_supporting_characters(supporting_section)
-                
-        except Exception as e:
-            logger.error(f"Error processing character content: {e}")
-            # Continue with default values rather than failing
-
-    def _parse_supporting_characters(self, content: str):
-        """Parse supporting characters from content"""
-        # Split by character markers (numbers or bullets)
-        char_sections = re.split(r'\n(?:\d+\.|[-•*])\s*', content)
-        
-        for i, section in enumerate(char_sections[1:], 1):  # Skip first empty split
-            if section.strip():
-                try:
-                    name = self._extract_field(section, r"(?:Name|이름)") or f"Supporting_{i}"
-                    role = self._extract_field(section, r"(?:Role|역할)") or "supporting"
-                    
-                    character = CharacterProfile(
-                        name=name,
-                        age=30,  # Default age for supporting characters
-                        role="supporting",
-                        archetype=role,
-                        want="",
-                        need="",
-                        backstory=self._extract_field(section, r"(?:Backstory|백스토리)") or "",
-                        personality=[],
-                        speech_pattern="",
-                        character_arc=""
-                    )
-                    
-                    self.screenplay_tracker.add_character(character)
-                    ScreenplayDatabase.save_character(self.current_session_id, character)
-                    
-                except Exception as e:
-                    logger.warning(f"Error parsing supporting character {i}: {e}")
-                    continue
-
-    def _extract_section(self, content: str, section_pattern: str) -> str:
-        """Extract section from content with improved pattern matching"""
-        # More flexible section extraction
-        patterns = [
-            rf'{section_pattern}[:\s]*\n?(.*?)(?=\n\n[A-Z가-힣]{{2,}}[:\s]|\n\n\d+\.|$)',
-            rf'{section_pattern}.*?\n((?:.*\n)*?)(?=\n[A-Z가-힣]{{2,}}:|$)',
-            rf'{section_pattern}[:\s]*((?:[^\n]+\n?)*?)(?=\n\n|\Z)'
-        ]
-        
-        for pattern in patterns:
-            match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-            if match:
-                return match.group(1).strip()
-        
-        return ""
-
-    def _process_producer_content(self, content: str):
-        """Process producer output with better extraction"""
-        try:
-            # Extract title with various formats
-            title_patterns = [
-                r'(?:TITLE|제목)[:\s]*\*?\*?([^\n*]+)\*?\*?',
-                r'\*\*(?:TITLE|제목)\*\*[:\s]*([^\n]+)',
-                r'Title[:\s]*([^\n]+)',
-                r'1\.\s*\*?\*?(?:TITLE|제목).*?[:\s]*([^\n]+)'
-            ]
-            
-            for pattern in title_patterns:
-                title_match = re.search(pattern, content, re.IGNORECASE)
-                if title_match:
-                    self.screenplay_tracker.screenplay_bible.title = title_match.group(1).strip()
-                    break
-            
-            # Extract logline with various formats
-            logline_patterns = [
-                r'(?:LOGLINE|로그라인)[:\s]*\*?\*?([^\n]+(?:\n(?!\s*\n)[^\n]+)*)',
-                r'\*\*(?:LOGLINE|로그라인)\*\*[:\s]*([^\n]+(?:\n(?!\s*\n)[^\n]+)*)',
-                r'Logline[:\s]*([^\n]+(?:\n(?!\s*\n)[^\n]+)*)',
-                r'2\.\s*\*?\*?(?:LOGLINE|로그라인).*?[:\s]*([^\n]+(?:\n(?!\s*\n)[^\n]+)*)'
-            ]
-            
-            for pattern in logline_patterns:
-                logline_match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-                if logline_match:
-                    # Get full logline (might be multi-line)
-                    logline_text = logline_match.group(1).strip()
-                    # Clean up the logline
-                    logline_text = re.sub(r'\s+', ' ', logline_text)
-                    logline_text = re.sub(r'^[-•*]\s*', '', logline_text)
-                    self.screenplay_tracker.screenplay_bible.logline = logline_text
-                    break
-            
-            # Extract genre
-            genre_match = re.search(r'(?:Primary Genre|주 장르)[:\s]*([^\n]+)', content, re.IGNORECASE)
-            if genre_match:
-                self.screenplay_tracker.screenplay_bible.genre = genre_match.group(1).strip()
-            
-            # Save to database
-            ScreenplayDatabase.save_screenplay_bible(self.current_session_id, 
-                                                   self.screenplay_tracker.screenplay_bible)
-                                                   
-        except Exception as e:
-            logger.error(f"Error processing producer content: {e}")
-
-    def _process_story_content(self, content: str):
-        """Process story developer output"""
-        # Extract three-act structure
-        self.screenplay_tracker.screenplay_bible.three_act_structure = {
-            "act1": self._extract_section(content, "ACT 1|제1막"),
-            "act2a": self._extract_section(content, "ACT 2A|제2막A"),
-            "act2b": self._extract_section(content, "ACT 2B|제2막B"),
-            "act3": self._extract_section(content, "ACT 3|제3막")
-        }
-        
-        ScreenplayDatabase.save_screenplay_bible(self.current_session_id,
-                                               self.screenplay_tracker.screenplay_bible)
-
-    def _process_scene_content(self, content: str):
-        """Process scene planner output"""
-        # Parse scene breakdown
-        scene_pattern = r'(?:Scene|씬)\s*(\d+).*?(?:INT\.|EXT\.)\s*(.+?)\s*-\s*(\w+)'
-        scenes = re.finditer(scene_pattern, content, re.IGNORECASE | re.MULTILINE)
-        
-        for match in scenes:
-            scene_num = int(match.group(1))
-            location = match.group(2).strip()
-            time_of_day = match.group(3).strip()
-            
-            # Determine act based on scene number
-            act = 1 if scene_num <= 12 else 2 if scene_num <= 35 else 3
-            
-            scene = SceneBreakdown(
-                scene_number=scene_num,
-                act=act,
-                location=location,
-                time_of_day=time_of_day,
-                characters=[],  # Would be extracted from content
-                purpose="",  # Would be extracted from content
-                conflict="",  # Would be extracted from content
-                page_count=1.5  # Default estimate
-            )
-            
-            self.screenplay_tracker.add_scene(scene)
-            ScreenplayDatabase.save_scene(self.current_session_id, scene)
-
-# --- Utility functions ---
-def generate_random_screenplay_theme(screenplay_type: str, genre: str, language: str) -> str:
-    """Generate random screenplay theme"""
-    try:
-        # Log the attempt
-        logger.info(f"Generating random theme - Type: {screenplay_type}, Genre: {genre}, Language: {language}")
-        
-        # Load themes data
-        themes_data = load_screenplay_themes_data()
-        
-        # Select random elements
-        import secrets
-        situations = themes_data['situations'].get(genre, themes_data['situations']['drama'])
-        protagonists = themes_data['protagonists'].get(genre, themes_data['protagonists']['drama'])
-        conflicts = themes_data['conflicts'].get(genre, themes_data['conflicts']['drama'])
-        
-        if not situations or not protagonists or not conflicts:
-            logger.error(f"No theme data available for genre {genre}")
-            return f"Error: No theme data available for genre {genre}"
-        
-        situation = secrets.choice(situations)
-        protagonist = secrets.choice(protagonists)
-        conflict = secrets.choice(conflicts)
-        
-        logger.info(f"Selected elements - Situation: {situation}, Protagonist: {protagonist}, Conflict: {conflict}")
-        
-        # Check if API token is valid
-        if not FRIENDLI_TOKEN or FRIENDLI_TOKEN == "dummy_token_for_testing":
-            logger.warning("No valid API token, returning fallback theme")
-            return get_fallback_theme(screenplay_type, genre, language, situation, protagonist, conflict)
-        
-        # Generate theme using LLM
-        system = ScreenplayGenerationSystem()
-        
-        if language == "Korean":
-            prompt = f"""다음 요소들로 {screenplay_type}용 매력적인 컨셉을 생성하세요:
-
-상황: {situation}
-주인공: {protagonist}
-갈등: {conflict}
-장르: {genre}
-
-다음 형식으로 작성:
-
-**제목:** [매력적인 제목]
-
-**로그라인:** [25단어 이내 한 문장]
-
-**컨셉:** [주인공]이(가) [상황]에서 [갈등]을 겪으며 [목표]를 추구하는 이야기.
-
-**독특한 요소:** [이 이야기만의 특별한 점]"""
-        else:
-            prompt = f"""Generate an attractive concept for {screenplay_type} using these elements:
-
-Situation: {situation}
-Protagonist: {protagonist}  
-Conflict: {conflict}
-Genre: {genre}
-
-Format as:
-
-**Title:** [Compelling title]
-
-**Logline:** [One sentence, 25 words max]
-
-**Concept:** A story about [protagonist] who faces [conflict] in [situation] while pursuing [goal].
-
-**Unique Element:** [What makes this story special]"""
-
-        messages = [{"role": "user", "content": prompt}]
-        
-        # Call LLM with error handling
-        logger.info("Calling LLM for theme generation...")
-        
-        generated_theme = ""
-        error_occurred = False
-        
-        # Use streaming to get the response
-        for chunk in system.call_llm_streaming(messages, "producer", language):
-            if chunk.startswith("❌"):
-                logger.error(f"LLM streaming error: {chunk}")
-                error_occurred = True
-                break
-            generated_theme += chunk
-        
-        # If error occurred or no content generated, use fallback
-        if error_occurred or not generated_theme.strip():
-            logger.warning("LLM call failed or empty response, using fallback theme")
-            return get_fallback_theme(screenplay_type, genre, language, situation, protagonist, conflict)
-        
-        logger.info(f"Successfully generated theme of length: {len(generated_theme)}")
-        
-        # Extract metadata
-        metadata = {
-            'title': extract_title_from_theme(generated_theme),
-            'logline': extract_logline_from_theme(generated_theme),
-            'protagonist': protagonist,
-            'conflict': conflict,
-            'situation': situation,
-            'tags': [genre, screenplay_type]
-        }
-        
-        # Save to database
-        try:
-            theme_id = ScreenplayDatabase.save_random_theme(
-                generated_theme, screenplay_type, genre, language, metadata
-            )
-            logger.info(f"Saved theme with ID: {theme_id}")
-        except Exception as e:
-            logger.error(f"Failed to save theme to database: {e}")
-        
-        return generated_theme
-        
-    except Exception as e:
-        logger.error(f"Theme generation error: {str(e)}")
-        import traceback
-        logger.error(traceback.format_exc())
-        return f"Error generating theme: {str(e)}"
-
-def get_fallback_theme(screenplay_type: str, genre: str, language: str, 
-                      situation: str, protagonist: str, conflict: str) -> str:
-    """Generate fallback theme without LLM"""
-    if language == "Korean":
-        return f"""**제목:** {protagonist}의 선택
-
-**로그라인:** {situation}에 갇힌 {protagonist}가 {conflict}에 맞서며 생존을 위해 싸운다.
-
-**컨셉:** {protagonist}가 {situation}에서 {conflict}을 겪으며 자신의 한계를 극복하는 이야기.
-
-**독특한 요소:** {genre} 장르의 전통적 요소를 현대적으로 재해석한 작품."""
-    else:
-        return f"""**Title:** The {protagonist.title()}'s Choice
-
-**Logline:** When trapped in {situation}, a {protagonist} must face {conflict} to survive.
-
-**Concept:** A story about a {protagonist} who faces {conflict} in {situation} while discovering their true strength.
-
-**Unique Element:** A fresh take on {genre} genre conventions with contemporary relevance."""
-
-def load_screenplay_themes_data() -> Dict:
-    """Load screenplay themes data"""
-    return {
-        'situations': {
-            'action': ['hostage crisis', 'heist gone wrong', 'revenge mission', 'race against time'],
-            'thriller': ['false accusation', 'witness protection', 'conspiracy uncovered', 'identity theft'],
-            'drama': ['family reunion', 'terminal diagnosis', 'divorce proceedings', 'career crossroads'],
-            'comedy': ['mistaken identity', 'wedding disaster', 'workplace chaos', 'odd couple roommates'],
-            'horror': ['isolated location', 'ancient curse', 'home invasion', 'supernatural investigation'],
-            'sci-fi': ['first contact', 'time loop', 'AI awakening', 'space colony crisis'],
-            'romance': ['second chance', 'enemies to lovers', 'long distance', 'forbidden love']
-        },
-        'protagonists': {
-            'action': ['ex-soldier', 'undercover cop', 'skilled thief', 'reluctant hero'],
-            'thriller': ['investigative journalist', 'wrongly accused person', 'FBI agent', 'whistleblower'],
-            'drama': ['single parent', 'recovering addict', 'immigrant', 'caregiver'],
-            'comedy': ['uptight professional', 'slacker', 'fish out of water', 'eccentric artist'],
-            'horror': ['skeptical scientist', 'final girl', 'paranormal investigator', 'grieving parent'],
-            'sci-fi': ['astronaut', 'AI researcher', 'time traveler', 'colony leader'],
-            'romance': ['workaholic', 'hopeless romantic', 'cynical divorce lawyer', 'small town newcomer']
-        },
-        'conflicts': {
-            'action': ['stop the villain', 'save the hostages', 'prevent disaster', 'survive pursuit'],
-            'thriller': ['prove innocence', 'expose truth', 'stay alive', 'protect loved ones'],
-            'drama': ['reconcile past', 'find purpose', 'heal relationships', 'accept change'],
-            'comedy': ['save the business', 'win the competition', 'fool everyone', 'find love'],
-            'horror': ['survive the night', 'break the curse', 'escape the monster', 'save the town'],
-            'sci-fi': ['save humanity', 'prevent paradox', 'stop the invasion', 'preserve identity'],
-            'romance': ['overcome differences', 'choose between options', 'trust again', 'follow heart']
-        }
-    }
-
-def extract_title_from_theme(theme_text: str) -> str:
-    """Extract title from generated theme"""
-    match = re.search(r'\*\*(?:Title|제목):\*\*\s*(.+)', theme_text, re.IGNORECASE)
-    return match.group(1).strip() if match else ""
-
-def extract_logline_from_theme(theme_text: str) -> str:
-    """Extract logline from generated theme"""
-    match = re.search(r'\*\*(?:Logline|로그라인):\*\*\s*(.+)', theme_text, re.IGNORECASE)
-    return match.group(1).strip() if match else ""
-
-def format_screenplay_display(screenplay_text: str) -> str:
-    """Format screenplay for display"""
-    if not screenplay_text:
-        return "No screenplay content yet."
-    
-    formatted = "# 🎬 Screenplay\n\n"
-    
-    # Format scene headings
-    formatted_text = re.sub(
-        r'^(INT\.|EXT\.)(.*?)error(f"Error parsing error response: {e}")
-                    error_msg += f" - {response.text[:200]}"
-                
-                yield f"❌ {error_msg}"
-                return
-            
-            buffer = ""
-            line_count = 0
-            
-            for line in response.iter_lines():
-                if not line:
-                    continue
-                
-                line_count += 1
-                
-                try:
-                    line_str = line.decode('utf-8').strip()
-                    
-                    # Skip non-SSE lines
-                    if not line_str.startswith("data: "):
-                        logger.debug(f"Skipping non-SSE line: {line_str[:50]}")
-                        continue
-                    
-                    data_str = line_str[6:]  # Remove "data: " prefix
-                    
-                    if data_str == "[DONE]":
-                        logger.info(f"Stream completed. Total lines: {line_count}")
-                        break
-                    
-                    if not data_str:
-                        continue
-                    
-                    # Parse JSON data
-                    try:
-                        data = json.loads(data_str)
-                    except json.JSONDecodeError as e:
-                        logger.warning(f"JSON decode error on line {line_count}: {e}")
-                        logger.debug(f"Problematic data: {data_str[:100]}")
-                        continue
-                    
-                    # Extract content from response
-                    if isinstance(data, dict) and "choices" in data:
-                        choices = data["choices"]
-                        if isinstance(choices, list) and len(choices) > 0:
-                            choice = choices[0]
-                            if isinstance(choice, dict) and "delta" in choice:
-                                delta = choice["delta"]
-                                if isinstance(delta, dict) and "content" in delta:
-                                    content = delta["content"]
-                                    if content:
-                                        buffer += content
-                                        
-                                        # Yield when buffer is large enough
-                                        if len(buffer) >= 50 or '\n' in buffer:
-                                            yield buffer
-                                            buffer = ""
-                                            time.sleep(0.01)
-                    
-                except Exception as e:
-                    logger.,
-        r'**\1\2**',
-        screenplay_text,
-        flags=re.MULTILINE
-    )
-    
-    # Format character names (all caps on their own line)
-    formatted_text = re.sub(
-        r'^([A-Z][A-Z\s]+)error(f"Error parsing error response: {e}")
-                    error_msg += f" - {response.text[:200]}"
-                
-                yield f"❌ {error_msg}"
-                return
-            
-            buffer = ""
-            line_count = 0
-            
-            for line in response.iter_lines():
-                if not line:
-                    continue
-                
-                line_count += 1
-                
-                try:
-                    line_str = line.decode('utf-8').strip()
-                    
-                    # Skip non-SSE lines
-                    if not line_str.startswith("data: "):
-                        logger.debug(f"Skipping non-SSE line: {line_str[:50]}")
-                        continue
-                    
-                    data_str = line_str[6:]  # Remove "data: " prefix
-                    
-                    if data_str == "[DONE]":
-                        logger.info(f"Stream completed. Total lines: {line_count}")
-                        break
-                    
-                    if not data_str:
-                        continue
-                    
-                    # Parse JSON data
-                    try:
-                        data = json.loads(data_str)
-                    except json.JSONDecodeError as e:
-                        logger.warning(f"JSON decode error on line {line_count}: {e}")
-                        logger.debug(f"Problematic data: {data_str[:100]}")
-                        continue
-                    
-                    # Extract content from response
-                    if isinstance(data, dict) and "choices" in data:
-                        choices = data["choices"]
-                        if isinstance(choices, list) and len(choices) > 0:
-                            choice = choices[0]
-                            if isinstance(choice, dict) and "delta" in choice:
-                                delta = choice["delta"]
-                                if isinstance(delta, dict) and "content" in delta:
-                                    content = delta["content"]
-                                    if content:
-                                        buffer += content
-                                        
-                                        # Yield when buffer is large enough
-                                        if len(buffer) >= 50 or '\n' in buffer:
-                                            yield buffer
-                                            buffer = ""
-                                            time.sleep(0.01)
-                    
-                except Exception as e:
-                    logger.,
-        r'**\1**',
-        formatted_text,
-        flags=re.MULTILINE
-    )
-    
-    # Add spacing for readability
-    lines = formatted_text.split('\n')
-    formatted_lines = []
-    
-    for i, line in enumerate(lines):
-        formatted_lines.append(line)
-        # Add extra space after scene headings
-        if line.startswith('**INT.') or line.startswith('**EXT.'):
-            formatted_lines.append('')
-    
-    formatted += '\n'.join(formatted_lines)
-    
-    # Add page count
-    page_count = len(screenplay_text.split('\n')) / 55
-    formatted = f"**Total Pages: {page_count:.1f}**\n\n" + formatted
-    
-    return formatted
-
-def format_stages_display(stages: List[Dict]) -> str:
-    """Format stages display for screenplay"""
-    markdown = "## 🎬 Production Progress\n\n"
-    
-    # Progress summary
-    completed = sum(1 for s in stages if s.get('status') == 'complete')
-    total = len(stages)
-    markdown += f"**Progress: {completed}/{total} stages complete**\n\n"
-    
-    # Page count if available
-    total_pages = sum(s.get('page_count', 0) for s in stages if s.get('page_count'))
-    if total_pages > 0:
-        markdown += f"**Current Page Count: {total_pages:.1f} pages**\n\n"
-    
-    markdown += "---\n\n"
-    
-    # Stage details
-    current_act = None
-    for i, stage in enumerate(stages):
-        status_icon = "✅" if stage['status'] == 'complete' else "🔄" if stage['status'] == 'active' else "⏳"
-        
-        # Group by acts
-        if 'Act' in stage.get('name', ''):
-            act_match = re.search(r'Act (\w+)', stage['name'])
-            if act_match and act_match.group(1) != current_act:
-                current_act = act_match.group(1)
-                markdown += f"\n### 📄 Act {current_act}\n\n"
-        
-        markdown += f"{status_icon} **{stage['name']}**"
-        
-        if stage.get('page_count', 0) > 0:
-            markdown += f" ({stage['page_count']:.1f} pages)"
-        
-        markdown += "\n"
-        
-        if stage['content'] and stage['status'] == 'complete':
-            preview_length = 200
-            preview = stage['content'][:preview_length] + "..." if len(stage['content']) > preview_length else stage['content']
-            markdown += f"> {preview}\n\n"
-        elif stage['status'] == 'active':
-            markdown += "> *In progress...*\n\n"
-    
-    return markdown
-
-def process_query(query: str, screenplay_type: str, genre: str, language: str, 
-                session_id: Optional[str] = None) -> Generator[Tuple[str, str, str, str], None, None]:
-    """Main query processing function"""
-    if not query.strip():
-        yield "", "", "❌ Please enter a screenplay concept.", session_id
-        return
-    
-    system = ScreenplayGenerationSystem()
-    stages_markdown = ""
-    screenplay_display = ""
-    
-    for status, stages, current_session_id in system.process_screenplay_stream(
-        query, screenplay_type, genre, language, session_id
-    ):
-        stages_markdown = format_stages_display(stages)
-        
-        # Get screenplay content when available
-        if stages and all(s.get("status") == "complete" for s in stages[-4:]):
-            screenplay_text = ScreenplayDatabase.get_screenplay_content(current_session_id)
-            screenplay_display = format_screenplay_display(screenplay_text)
-        
-        yield stages_markdown, screenplay_display, status or "🔄 Processing...", current_session_id
-
-def get_active_sessions() -> List[str]:
-    """Get active screenplay sessions"""
-    sessions = ScreenplayDatabase.get_active_sessions()
-    return [
-        f"{s['session_id'][:8]}... - {s.get('title', s['user_query'][:30])}... "
-        f"({s['screenplay_type']}/{s['genre']}) [{s['total_pages']:.1f} pages]"
-        for s in sessions
-    ]
-
-def export_screenplay_pdf(screenplay_text: str, title: str, session_id: str) -> str:
-    """Export screenplay to PDF format"""
-    # This would use a library like reportlab to create industry-standard PDF
-    # For now, returning a placeholder
-    pdf_path = f"screenplay_{session_id[:8]}.pdf"
-    # PDF generation logic would go here
-    return pdf_path
-
-def export_screenplay_fdx(screenplay_text: str, title: str, session_id: str) -> str:
-    """Export to Final Draft format"""
-    # This would create .fdx XML format
-    fdx_path = f"screenplay_{session_id[:8]}.fdx"
-    # FDX generation logic would go here
-    return fdx_path
-
-def download_screenplay(screenplay_text: str, format_type: str, title: str, 
-                      session_id: str) -> Optional[str]:
-    """Generate screenplay download file"""
-    if not screenplay_text or not session_id:
-        return None
-    
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    
-    try:
-        if format_type == "PDF":
-            return export_screenplay_pdf(screenplay_text, title, session_id)
-        elif format_type == "FDX":
-            return export_screenplay_fdx(screenplay_text, title, session_id)
-        elif format_type == "FOUNTAIN":
-            filepath = f"screenplay_{session_id[:8]}_{timestamp}.fountain"
-            with open(filepath, 'w', encoding='utf-8') as f:
-                f.write(screenplay_text)
-            return filepath
-        else:  # TXT
-            filepath = f"screenplay_{session_id[:8]}_{timestamp}.txt"
-            with open(filepath, 'w', encoding='utf-8') as f:
-                f.write(f"Title: {title}\n")
-                f.write("=" * 50 + "\n\n")
-                f.write(screenplay_text)
-            return filepath
-    except Exception as e:
-        logger.error(f"Download generation failed: {e}")
-        return None
-
-# Create Gradio interface
-def create_interface():
-    """Create Gradio interface for screenplay generation"""
-    
-    css = """
-    .main-header {
-        text-align: center;
-        margin-bottom: 2rem;
-        padding: 2rem;
-        background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
-        border-radius: 10px;
-        color: white;
-    }
-    
-    .header-title {
-        font-size: 3rem;
-        margin-bottom: 1rem;
-        background: linear-gradient(45deg, #f39c12, #e74c3c);
-        -webkit-background-clip: text;
-        -webkit-text-fill-color: transparent;
-    }
-    
-    .header-description {
-        font-size: 1.1rem;
-        opacity: 0.9;
-        line-height: 1.6;
-    }
-    
-    .type-selector {
-        display: flex;
-        gap: 1rem;
-        margin: 1rem 0;
-    }
-    
-    .type-card {
-        flex: 1;
-        padding: 1rem;
-        border: 2px solid #ddd;
-        border-radius: 8px;
-        cursor: pointer;
-        transition: all 0.3s;
-    }
-    
-    .type-card:hover {
-        border-color: #f39c12;
-        transform: translateY(-2px);
-    }
-    
-    .type-card.selected {
-        border-color: #e74c3c;
-        background: #fff5f5;
-    }
-    
-    #stages-display {
-        max-height: 600px;
-        overflow-y: auto;
-        padding: 1rem;
-        background: #f8f9fa;
-        border-radius: 8px;
-    }
-    
-    #screenplay-output {
-        font-family: 'Courier New', monospace;
-        white-space: pre-wrap;
-        background: white;
-        padding: 2rem;
-        border: 1px solid #ddd;
-        border-radius: 8px;
-        max-height: 800px;
-        overflow-y: auto;
-    }
-    
-    .genre-grid {
-        display: grid;
-        grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
-        gap: 0.5rem;
-        margin: 1rem 0;
-    }
-    
-    .genre-btn {
-        padding: 0.75rem;
-        border: 2px solid #e0e0e0;
-        background: white;
-        border-radius: 8px;
-        cursor: pointer;
-        transition: all 0.3s;
-        text-align: center;
-    }
-    
-    .genre-btn:hover {
-        border-color: #f39c12;
-        background: #fffbf0;
-    }
-    
-    .genre-btn.selected {
-        border-color: #e74c3c;
-        background: #fff5f5;
-        font-weight: bold;
-    }
-    """
-    
-    with gr.Blocks(theme=gr.themes.Soft(), css=css, title="Screenplay Generator") as interface:
-        gr.HTML("""
-        <div class="main-header">
-            <h1 class="header-title">🎬 AI Screenplay Generator</h1>
-            <p class="header-description">
-                Transform your ideas into professional screenplays for films, TV shows, and streaming series.
-                Using industry-standard format and story structure to create compelling, producible scripts.
-            </p>
-        </div>
-        """)
-        
-        # State management
-        current_session_id = gr.State(None)
-        
-        with gr.Tabs():
-            # Main Writing Tab
-            with gr.Tab("✍️ Write Screenplay"):
-                with gr.Row():
-                    with gr.Column(scale=3):
-                        query_input = gr.Textbox(
-                            label="Screenplay Concept",
-                            placeholder="""Describe your screenplay idea. For example:
-- A detective with memory loss must solve their own attempted murder
-- Two rival food truck owners forced to work together to save the city food festival  
-- A space station AI develops consciousness during a critical mission
-- A family reunion turns into a murder mystery during a hurricane
-
-The more specific your concept, the better the screenplay will be tailored to your vision.""",
-                            lines=6
-                        )
-                    
-                    with gr.Column(scale=1):
-                        screenplay_type = gr.Radio(
-                            choices=list(SCREENPLAY_LENGTHS.keys()),
-                            value="movie",
-                            label="Screenplay Type",
-                            info="Choose your format"
-                        )
-                        
-                        genre_select = gr.Dropdown(
-                            choices=list(GENRE_TEMPLATES.keys()),
-                            value="drama",
-                            label="Primary Genre",
-                            info="Select main genre"
-                        )
-                        
-                        language_select = gr.Radio(
-                            choices=["English", "Korean"],
-                            value="English",
-                            label="Language"
-                        )
-                
-                with gr.Row():
-                    random_btn = gr.Button("🎲 Random Concept", scale=1)
-                    clear_btn = gr.Button("🗑️ Clear", scale=1)
-                    submit_btn = gr.Button("🎬 Start Writing", variant="primary", scale=2)
-                
-                status_text = gr.Textbox(
-                    label="Status",
-                    interactive=False,
-                    value="Ready to create your screenplay"
-                )
-                
-                # Session management
-                with gr.Group():
-                    gr.Markdown("### 📁 Saved Projects")
-                    with gr.Row():
-                        session_dropdown = gr.Dropdown(
-                            label="Active Sessions",
-                            choices=[],
-                            interactive=True,
-                            scale=3
-                        )
-                        refresh_btn = gr.Button("🔄", scale=1)
-                        resume_btn = gr.Button("📂 Load", scale=1)
-                
-                # Output displays
-                with gr.Row():
-                    with gr.Column():
-                        with gr.Tab("🎭 Writing Progress"):
-                            stages_display = gr.Markdown(
-                                value="*Your screenplay journey will unfold here...*",
-                                elem_id="stages-display"
-                            )
-                        
-                        with gr.Tab("📄 Screenplay"):
-                            screenplay_output = gr.Markdown(
-                                value="*Your formatted screenplay will appear here...*",
-                                elem_id="screenplay-output"
-                            )
-                            
-                            with gr.Row():
-                                format_select = gr.Radio(
-                                    choices=["PDF", "FDX", "FOUNTAIN", "TXT"],
-                                    value="PDF",
-                                    label="Export Format"
-                                )
-                                download_btn = gr.Button("📥 Download Screenplay", variant="secondary")
-                            
-                            download_file = gr.File(
-                                label="Download",
-                                visible=False
-                            )
-                
-                # Examples
-                gr.Examples(
-                    examples=[
-                        ["A burned-out teacher discovers her students are being replaced by AI duplicates"],
-                        ["Two funeral home employees accidentally release a ghost who helps them solve murders"],
-                        ["A time-loop forces a wedding planner to relive the worst wedding until they find true love"],
-                        ["An astronaut returns to Earth to find everyone has forgotten space exists"],
-                        ["A support group for reformed villains must save the city when heroes disappear"],
-                        ["A food critic loses their sense of taste and teams up with a street food vendor"]
-                    ],
-                    inputs=query_input,
-                    label="💡 Example Concepts"
-                )
-            
-            # Screenplay Library Tab
-            with gr.Tab("📚 Concept Library"):
-                gr.Markdown("""
-                ### 🎲 Random Screenplay Concepts
-                
-                Browse through AI-generated screenplay concepts. Each concept includes a title, logline, and brief setup.
-                """)
-                
-                library_display = gr.HTML(
-                    value="<p>Library feature coming soon...</p>"
-                )
-        
-        # Event handlers
-        def handle_submit(query, s_type, genre, lang, session_id):
-            if not query:
-                yield "", "", "❌ Please enter a concept", session_id
-                return
-            
-            yield from process_query(query, s_type, genre, lang, session_id)
-        
-        def handle_random(s_type, genre, lang):
-            return generate_random_screenplay_theme(s_type, genre, lang)
-        
-        def handle_download(screenplay_text, format_type, session_id):
-            if not screenplay_text or not session_id:
-                return gr.update(visible=False)
-            
-            # Get title from database
-            session = ScreenplayDatabase.get_session(session_id)
-            title = session.get('title', 'Untitled') if session else 'Untitled'
-            
-            file_path = download_screenplay(screenplay_text, format_type, title, session_id)
-            if file_path and os.path.exists(file_path):
-                return gr.update(value=file_path, visible=True)
-            return gr.update(visible=False)
-        
-        # Connect events
-        submit_btn.click(
-            fn=handle_submit,
-            inputs=[query_input, screenplay_type, genre_select, language_select, current_session_id],
-            outputs=[stages_display, screenplay_output, status_text, current_session_id]
-        )
-        
-        random_btn.click(
-            fn=handle_random,
-            inputs=[screenplay_type, genre_select, language_select],
-            outputs=[query_input]
-        )
-        
-        clear_btn.click(
-            fn=lambda: ("", "", "Ready to create your screenplay", None),
-            outputs=[stages_display, screenplay_output, status_text, current_session_id]
-        )
-        
-        refresh_btn.click(
-            fn=get_active_sessions,
-            outputs=[session_dropdown]
-        )
-        
-        download_btn.click(
-            fn=handle_download,
-            inputs=[screenplay_output, format_select, current_session_id],
-            outputs=[download_file]
-        )
-        
-        # Load sessions on start
-        interface.load(
-            fn=get_active_sessions,
-            outputs=[session_dropdown]
-        )
-    
-    return interface
-
-# Main function
-if __name__ == "__main__":
-    logger.info("Screenplay Generator Starting...")
-    logger.info("=" * 60)
-    
-    # Environment check
-    logger.info(f"API Endpoint: {API_URL}")
-    logger.info("Screenplay Types Available:")
-    for s_type, info in SCREENPLAY_LENGTHS.items():
-        logger.info(f"  - {s_type}: {info['description']}")
-    logger.info(f"Genres: {', '.join(GENRE_TEMPLATES.keys())}")
-    
-    if BRAVE_SEARCH_API_KEY:
-        logger.info("Web search enabled for market research.")
-    else:
-        logger.warning("Web search disabled.")
-    
-    logger.info("=" * 60)
-    
-    # Initialize database
-    logger.info("Initializing database...")
-    ScreenplayDatabase.init_db()
-    logger.info("Database initialization complete.")
-    
-    # Create and launch interface
-    interface = create_interface()
-    
-    interface.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        debug=True
-    )
+