Update app.py

app.py

@@ -1879,7 +1879,1011 @@ You provide feedback that's critical yet encouraging."""
             value = re.sub(r'\*\*', '', value)
             value = re.sub(r'^\s*[-•]\s*', '', value)
             # Remove trailing punctuation
-            value = re.sub(r'[,.:;], '', value)
+            value = re.sub(r'[,.:;]
+
+    def _parse_character_profile(self, content: str, role: str) -> CharacterProfile:
+        """Parse character profile from content"""
+        # 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*',
+            r'^\s*[-*•]\s*([^,\n]+?)(?:\s*\([^)]+\))?\s*',
+            r'^([^,\n]+?)(?:\s*\([^)]+\))?\s*'
+        ]
+        
+        for pattern in name_patterns:
+            name_match = re.search(pattern, content, re.IGNORECASE | re.MULTILINE)
+            if name_match and name_match.group(1):
+                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)
+                if extracted_name and len(extracted_name) > 1:
+                    name = extracted_name
+                    break
+        
+        # Helper function to extract clean fields
+        def extract_clean_field(patterns):
+            if isinstance(patterns, str):
+                patterns = [patterns]
+            
+            for pattern in patterns:
+                # Improved pattern with better capturing groups
+                match = re.search(rf'{pattern}[:\s]*([^\n*]+?)(?=\n|$)', content, re.IGNORECASE | re.DOTALL)
+                if match and match.group(1):
+                    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 with safer extraction
+        profile = CharacterProfile(
+            name=name,
+            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"
+            ]),
+            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}")
+        return profile
+
+    def _extract_personality_traits(self, content: str) -> List[str]:
+        """Extract personality traits from content"""
+        traits = []
+        # Look for personality section with multiple pattern options
+        personality_patterns = [
+            r"(?:Personality|성격 특성|성격)[:\s]*([^\n]+(?:\n(?![\w가-힣]+:)[^\n]+)*)",
+            r"성격[:\s]*(?:\n?[-•*]\s*[^\n]+)+"
+        ]
+        
+        for pattern in personality_patterns:
+            match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
+            if match and match.group(1):
+                personality_section = match.group(1)
+                # Extract individual traits (usually listed)
+                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)  # Remove numbered lists
+                        if trait and len(trait) > 2:  # Skip very short entries
+                            traits.append(trait)
+                if traits:  # If we found traits, stop looking
+                    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:
+                try:
+                    protagonist = self._parse_character_profile(protagonist_section, "protagonist")
+                    self.screenplay_tracker.add_character(protagonist)
+                    ScreenplayDatabase.save_character(self.current_session_id, protagonist)
+                except Exception as e:
+                    logger.error(f"Error parsing protagonist: {e}")
+                    # Create a default protagonist to continue
+                    protagonist = CharacterProfile(
+                        name="Protagonist",
+                        role="protagonist",
+                        archetype="Hero",
+                        want="To achieve goal",
+                        need="To grow",
+                        backstory="Unknown",
+                        personality=["Determined"],
+                        speech_pattern="Normal",
+                        character_arc="Growth"
+                    )
+                    self.screenplay_tracker.add_character(protagonist)
+            
+            # Extract antagonist
+            antagonist_section = self._extract_section(content, r"(?:ANTAGONIST|적대자)")
+            if antagonist_section:
+                try:
+                    antagonist = self._parse_character_profile(antagonist_section, "antagonist")
+                    self.screenplay_tracker.add_character(antagonist)
+                    ScreenplayDatabase.save_character(self.current_session_id, antagonist)
+                except Exception as e:
+                    logger.error(f"Error parsing antagonist: {e}")
+                    # Create a default antagonist to continue
+                    antagonist = CharacterProfile(
+                        name="Antagonist",
+                        role="antagonist",
+                        archetype="Villain",
+                        want="To stop protagonist",
+                        need="Power",
+                        backstory="Unknown",
+                        personality=["Ruthless"],
+                        speech_pattern="Menacing",
+                        character_arc="Downfall"
+                    )
+                    self.screenplay_tracker.add_character(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 _extract_section(self, content: str, section_pattern: str) -> str:
+        """Extract section from content with improved pattern matching"""
+        # More flexible section extraction
+        patterns = [
+            # Pattern 1: Section header followed by content until next major section
+            rf'{section_pattern}[:\s]*\n?(.*?)(?=\n\n[A-Z가-힣]{{2,}}[:\s]|\n\n\d+\.|$)',
+            # Pattern 2: Section header with content until next section (alternative)
+            rf'{section_pattern}.*?\n((?:.*\n)*?)(?=\n[A-Z가-힣]{{2,}}:|$)',
+            # Pattern 3: More flexible pattern for Korean text
+            rf'{section_pattern}[:\s]*\n?((?:[^\n]+\n?)*?)(?=\n\n|\Z)'
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
+            if match and match.group(1):
+                section_content = match.group(1).strip()
+                if section_content:  # Only return if we got actual content
+                    return section_content
+        
+        return ""
+
+    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:
+                    # Try multiple name extraction patterns
+                    name = None
+                    name_patterns = [
+                        r"(?:이름|Name)[:\s]*([^,\n]+)",
+                        r"^([^:\n]+?)(?:\s*[-–]\s*|:\s*)",  # Name at start before dash or colon
+                        r"^([가-힣A-Za-z\s]+?)(?:\s*\(|$)"  # Korean/English name before parenthesis
+                    ]
+                    
+                    for pattern in name_patterns:
+                        name_match = re.search(pattern, section.strip(), re.IGNORECASE)
+                        if name_match and name_match.group(1):
+                            name = name_match.group(1).strip()
+                            if name and len(name) > 1:
+                                break
+                    
+                    if not name:
+                        name = f"Supporting_{i}"
+                    
+                    role_desc = self._extract_field(section, r"(?:Role|역할)[:\s]*") or "supporting"
+                    
+                    character = CharacterProfile(
+                        name=name,
+                        role="supporting",
+                        archetype=role_desc,
+                        want="",
+                        need="",
+                        backstory=self._extract_field(section, r"(?:Backstory|백스토리)[:\s]*") 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 _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]+)'
+            ]
+            
+            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]+)',
+                r'\*\*(?:LOGLINE|로그라인)\*\*[:\s]*([^\n]+)',
+                r'Logline[:\s]*([^\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()
+                    # Continue reading if it's incomplete
+                    if not logline_text.endswith('.'):
+                        next_lines = content[logline_match.end():].split('\n')
+                        for line in next_lines[:3]:  # Check next 3 lines
+                            if line.strip() and not re.match(r'^[A-Z가-힣\d]', line.strip()):
+                                logline_text += ' ' + line.strip()
+                            else:
+                                break
+                    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\.)(.*?),
+       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]+),
+       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
+   ), '', value)
             return value.strip() if value else None
         return None