update tts, llm engines

agents/podcast_agent.py

@@ -5,11 +5,6 @@ from processing.pdf_reader import extract_text_from_pdf
 from processing.url_fetcher import fetch_paper_from_url
 from synthesis.tts_engine import get_tts_engine
 from utils.config import (
-    DEMO_INFERENCE_KEY,
-    DEMO_INFERENCE_URL,
-    DEMO_MODE,
-    DEMO_MODEL,
-    DEMO_TTS_KEY,
     MAX_CONTEXT_CHARS,
 )
 from utils.history import save_to_history
@@ -18,45 +13,49 @@ from utils.history import save_to_history
 class PodcastAgent:
     def __init__(
         self,
-        provider_mode="demo",
+        provider_mode="own_inference",
         own_base_url=None,
         own_api_key=None,
         own_model=None,
         openai_key=None,
         openai_model=None,
-        tts_provider="edge-tts",
+        tts_provider="elevenlabs",
         elevenlabs_key=None,
         host_voice=None,
         guest_voice=None,
         max_tokens=None,
+        target_dialogue_count=15,
     ):
-        self.logs = []
-
-        # If demo mode is enabled, override all settings with demo credentials
-        if DEMO_MODE:
-            self.provider_mode = "demo"
-            self.own_base_url = DEMO_INFERENCE_URL
-            self.own_api_key = DEMO_INFERENCE_KEY
-            self.own_model = DEMO_MODEL
-            self.openai_key = None
-            self.openai_model = None
-            self.tts_provider = "edge-tts"  # Always use Edge-TTS in demo mode
-            self.elevenlabs_key = None
-            self.host_voice = host_voice
-            self.guest_voice = guest_voice
-        else:
-            self.provider_mode = provider_mode  # "own_inference" or "openai"
-            self.own_base_url = own_base_url
-            self.own_api_key = own_api_key
-            self.own_model = own_model
-            self.openai_key = openai_key
-            self.openai_model = openai_model
-            self.tts_provider = tts_provider
-            self.elevenlabs_key = elevenlabs_key
-            self.host_voice = host_voice
-            self.guest_voice = guest_voice
+        """
+        Initialize PodcastAgent with user-provided settings (BYOK).
 
+        Args:
+            provider_mode: "own_inference" or "openai"
+            own_base_url: Base URL for own inference server
+            own_api_key: API key for own inference server
+            own_model: Model name for own inference server
+            openai_key: OpenAI API key
+            openai_model: OpenAI model name
+            tts_provider: "elevenlabs" (ElevenLabs required)
+            elevenlabs_key: ElevenLabs API key (required)
+            host_voice: Voice ID for host
+            guest_voice: Voice ID for guest
+            max_tokens: Maximum tokens for generation
+            target_dialogue_count: Target number of dialogue exchanges (default: 15)
+        """
+        self.logs = []
+        self.provider_mode = provider_mode  # "own_inference" or "openai"
+        self.own_base_url = own_base_url
+        self.own_api_key = own_api_key
+        self.own_model = own_model
+        self.openai_key = openai_key
+        self.openai_model = openai_model
+        self.tts_provider = tts_provider
+        self.elevenlabs_key = elevenlabs_key
+        self.host_voice = host_voice
+        self.guest_voice = guest_voice
         self.max_tokens = max_tokens
+        self.target_dialogue_count = target_dialogue_count
 
     def log(self, message):
         timestamp = time.strftime("%H:%M:%S")
@@ -127,21 +126,15 @@ class PodcastAgent:
             openai_model=self.openai_model,
             max_tokens=self.max_tokens,
         )
-        script = generator.generate_podcast_script(text)
+        script = generator.generate_podcast_script(text, target_dialogue_count=self.target_dialogue_count)
         if not script:
             yield self.log("Error: Failed to generate script.")
             return None, self.logs
-        yield self.log(f"Generated script with {len(script)} dialogue turns.")
+        yield self.log(f"Generated script with {len(script)} dialogue turns (target: {self.target_dialogue_count}).")
 
         # Step 4: Synthesize Audio
         yield self.log("Thinking: The script looks good. Sending it to the TTS engine.")
-        if self.tts_provider == "edge-tts":
-            yield self.log("Using Edge-TTS (Microsoft, free)")
-        elif self.tts_provider == "elevenlabs":
-            if self.elevenlabs_key:
-                yield self.log("Using custom ElevenLabs API key")
-            else:
-                yield self.log("Using demo ElevenLabs key")
+        yield self.log("Using ElevenLabs TTS")
         yield self.log("Tool Call: synthesize_podcast(...)")
         tts = get_tts_engine(
             tts_provider=self.tts_provider,
@@ -305,7 +298,7 @@ class PodcastAgent:
 
         # Add instruction for multi-paper script
         multi_paper_prompt = f"[MULTIPLE PAPERS - {len(all_texts)} papers total. Create a comprehensive podcast discussing all papers.]\n\n{combined_text}"
-        script = generator.generate_podcast_script(multi_paper_prompt)
+        script = generator.generate_podcast_script(multi_paper_prompt, target_dialogue_count=self.target_dialogue_count)
 
         if not script:
             yield self.log("Error: Failed to generate script.")
@@ -319,13 +312,7 @@ class PodcastAgent:
         yield self.log(
             "\nThinking: The script looks good. Sending it to the TTS engine."
         )
-        if self.tts_provider == "edge-tts":
-            yield self.log("Using Edge-TTS (Microsoft, free)")
-        elif self.tts_provider == "elevenlabs":
-            if self.elevenlabs_key:
-                yield self.log("Using custom ElevenLabs API key")
-            else:
-                yield self.log("Using demo ElevenLabs key")
+        yield self.log("Using ElevenLabs TTS")
         yield self.log("Tool Call: synthesize_podcast(...)")
         tts = get_tts_engine(
             tts_provider=self.tts_provider,

app.py

@@ -4,13 +4,8 @@ from datetime import datetime
 import gradio as gr
 
 from agents.podcast_agent import PodcastAgent
-from synthesis.tts_engine import EDGE_TTS_VOICES, ELEVENLABS_VOICES
+from synthesis.tts_engine import ELEVENLABS_VOICES
 from utils.config import (
-    DEMO_INFERENCE_KEY,
-    DEMO_INFERENCE_URL,
-    DEMO_MODE,
-    DEMO_MODEL,
-    DEMO_TTS_KEY,
     OUTPUT_DIR,
     SCRIPT_GENERATION_MODEL,
 )
@@ -20,19 +15,39 @@ from utils.history import get_history_items, load_history
 os.makedirs(OUTPUT_DIR, exist_ok=True)
 
 
+# Podcast length presets: maps UI choice to (target_exchanges, max_tokens)
+PODCAST_LENGTH_PRESETS = {
+    "⚡ Very Short (6-8 exchanges, ~2-3 min)": (7, 2000),
+    "📝 Short (10-12 exchanges, ~3-4 min)": (11, 3000),
+    "📄 Medium (14-16 exchanges, ~5-6 min)": (15, 4000),
+    "📚 Medium-Long (18-20 exchanges, ~7-8 min)": (19, 5000),
+    "📖 Long (22-25 exchanges, ~9-11 min)": (23, 6000),
+    "📕 Very Long (28-32 exchanges, ~12-15 min)": (30, 8000),
+}
+
+
+def get_podcast_length_params(length_choice):
+    """
+    Convert podcast length choice to parameters.
+
+    Returns:
+        tuple: (target_dialogue_count, max_tokens)
+    """
+    return PODCAST_LENGTH_PRESETS.get(
+        length_choice,
+        (15, 4000)  # Default to Medium
+    )
+
+
 def validate_settings_for_generation(
     llm_choice, own_base_url, own_api_key, openai_key, tts_provider, elevenlabs_key
 ):
     """
-    Validate user settings for podcast generation in non-demo mode.
+    Validate user settings for podcast generation (BYOK - Bring Your Own Key).
 
     Returns:
         tuple: (is_valid, error_message)
     """
-    # Skip validation if in demo mode
-    if DEMO_MODE:
-        return True, ""
-
     errors = []
 
     # Validate LLM settings
@@ -52,13 +67,11 @@ def validate_settings_for_generation(
         elif not openai_key.startswith("sk-"):
             errors.append("❌ **OpenAI**: API key must start with 'sk-'")
 
-    # Validate TTS settings
-    if tts_provider == "elevenlabs":
-        if not elevenlabs_key:
-            errors.append("❌ **ElevenLabs**: API key is required")
-        elif not elevenlabs_key.startswith("sk_"):
-            errors.append("❌ **ElevenLabs**: API key must start with 'sk_'")
-    # Edge-TTS doesn't require any validation (it's free)
+    # Validate TTS settings (ElevenLabs required)
+    if not elevenlabs_key:
+        errors.append("❌ **ElevenLabs TTS**: API key is required")
+    elif not elevenlabs_key.startswith("sk_"):
+        errors.append("❌ **ElevenLabs TTS**: API key must start with 'sk_'")
 
     if errors:
         return False, "\n".join(errors)
@@ -189,16 +202,17 @@ def run_agent(
     user_podcast_length,
     progress=gr.Progress(),
 ):
-    """Run podcast generation with optional user settings"""
+    """Run podcast generation with user settings (BYOK)"""
 
     # Determine provider mode
-    if DEMO_MODE:
-        provider_mode = "demo"
-    elif user_llm_choice == "Own Inference":
+    if user_llm_choice == "Own Inference":
         provider_mode = "own_inference"
     else:  # OpenAI
         provider_mode = "openai"
 
+    # Parse podcast length settings
+    target_exchanges, max_tokens = get_podcast_length_params(user_podcast_length)
+
     agent = PodcastAgent(
         provider_mode=provider_mode,
         own_base_url=user_own_base_url if user_own_base_url else None,
@@ -206,34 +220,23 @@ def run_agent(
         own_model=user_own_model if user_own_model else None,
         openai_key=user_openai_key if user_openai_key else None,
         openai_model=user_openai_model if user_openai_model else None,
-        tts_provider=user_tts_provider if user_tts_provider else "edge-tts",
+        tts_provider=user_tts_provider if user_tts_provider else "elevenlabs",
         elevenlabs_key=user_elevenlabs_key if user_elevenlabs_key else None,
         host_voice=user_host_voice if user_host_voice else None,
         guest_voice=user_guest_voice if user_guest_voice else None,
-        max_tokens=user_podcast_length if user_podcast_length else 4096,
+        max_tokens=max_tokens,
+        target_dialogue_count=target_exchanges,
     )
     logs_history = ""
 
     # Log settings being used
     settings_log = "Settings: "
-    if provider_mode == "demo":
-        settings_log += "LLM: Demo Inference | TTS: Edge-TTS (Microsoft) | "
-    elif provider_mode == "own_inference":
+    if provider_mode == "own_inference":
         settings_log += f"LLM: Own Inference | "
-        if user_tts_provider == "edge-tts":
-            settings_log += "TTS: Edge-TTS (Microsoft) | "
-        elif user_elevenlabs_key:
-            settings_log += "TTS: Custom ElevenLabs | "
-        else:
-            settings_log += "TTS: ElevenLabs (no key provided) | "
+        settings_log += "TTS: ElevenLabs | "
     else:  # openai
         settings_log += f"LLM: OpenAI ({user_openai_model or 'gpt-4o-mini'}) | "
-        if user_tts_provider == "edge-tts":
-            settings_log += "TTS: Edge-TTS (Microsoft) | "
-        elif user_elevenlabs_key:
-            settings_log += "TTS: Custom ElevenLabs | "
-        else:
-            settings_log += "TTS: ElevenLabs (no key provided) | "
+        settings_log += "TTS: ElevenLabs | "
 
     settings_log += (
         f"Length: {user_podcast_length if user_podcast_length else 4096} tokens"
@@ -385,34 +388,23 @@ def main():
     )
 
     with gr.Blocks(title="PaperCast", theme=theme) as demo:
-        # Session state for settings
-        if DEMO_MODE:
-            user_llm_choice = gr.State(value="demo")
-            user_own_base_url = gr.State(value=DEMO_INFERENCE_URL)
-            user_own_api_key = gr.State(value=DEMO_INFERENCE_KEY)
-            user_own_model = gr.State(value=DEMO_MODEL)
-            user_openai_key = gr.State(value="")
-            user_openai_model = gr.State(value="")
-            user_tts_provider = gr.State(value="edge-tts")
-            user_elevenlabs_key = gr.State(value="")
-            user_host_voice = gr.State(value="en-US-GuyNeural")
-            user_guest_voice = gr.State(value="en-US-JennyNeural")
-        else:
-            user_llm_choice = gr.State(value="Own Inference")
-            user_own_base_url = gr.State(value="")
-            user_own_api_key = gr.State(value="")
-            user_own_model = gr.State(value="")
-            user_openai_key = gr.State(value="")
-            user_openai_model = gr.State(value="")
-            user_tts_provider = gr.State(value="edge-tts")
-            user_elevenlabs_key = gr.State(value="")
-            user_host_voice = gr.State(value="en-US-GuyNeural")
-            user_guest_voice = gr.State(value="en-US-JennyNeural")
+        # Session state for settings (BYOK - Bring Your Own Key)
+        # NOTE: Settings are session-only for security (multi-user HF Spaces)
+        user_llm_choice = gr.State(value="Own Inference")
+        user_own_base_url = gr.State(value="")
+        user_own_api_key = gr.State(value="")
+        user_own_model = gr.State(value="")
+        user_openai_key = gr.State(value="")
+        user_openai_model = gr.State(value="")
+        user_tts_provider = gr.State(value="elevenlabs")
+        user_elevenlabs_key = gr.State(value="")
+        user_host_voice = gr.State(value="ErXwobaYiN019PkySvjV")  # Antoni
+        user_guest_voice = gr.State(value="EXAVITQu4vr4xnSDxMaL")  # Bella
         user_podcast_length = gr.State(value=4096)
-        settings_valid = gr.State(value=DEMO_MODE)  # Settings are valid in demo mode
+        settings_valid = gr.State(value=False)  # Users must configure settings
 
-        # Initialize generate button state based on demo mode
-        generate_btn_state = gr.State(value=DEMO_MODE)
+        # Initialize generate button state
+        generate_btn_state = gr.State(value=False)
 
         with gr.Row():
             gr.HTML("""
@@ -718,27 +710,22 @@ Configure your PaperCast experience with your own API keys and preferences.
                         )
 
                         with gr.Group():
-                            if DEMO_MODE:
-                                gr.Markdown(
-                                    "**🔧 Demo Mode Active** - Using built-in inference and TTS services"
-                                )
-                            else:
-                                llm_choice = gr.Radio(
-                                    choices=[
-                                        "Own Inference",
-                                        "OpenAI",
-                                    ],
-                                    value="Own Inference",
-                                    label="Language Model Provider",
-                                    info="Choose your language model provider for script generation",
-                                )
+                            llm_choice = gr.Radio(
+                                choices=[
+                                    "Own Inference",
+                                    "OpenAI",
+                                ],
+                                value="Own Inference",
+                                label="Language Model Provider",
+                                info="Choose your language model provider for script generation",
+                            )
 
                             # Own Inference inputs (base URL + API key)
                             own_inference_base_url = gr.Textbox(
                                 label="Base URL",
                                 placeholder="https://your-server.com/v1",
                                 info="OpenAI-compatible endpoint",
-                                visible=not DEMO_MODE,
+                                visible=True,
                             )
 
                             own_inference_api_key = gr.Textbox(
@@ -746,14 +733,14 @@ Configure your PaperCast experience with your own API keys and preferences.
                                 placeholder="Optional - leave empty if not required",
                                 type="password",
                                 info="API key for your inference server (if required)",
-                                visible=not DEMO_MODE,
+                                visible=True,
                             )
 
                             own_inference_model = gr.Textbox(
                                 label="Model Name",
                                 placeholder="e.g., llama-3.1-8b, mistral-7b",
                                 info="Model name on your server",
-                                visible=not DEMO_MODE,
+                                visible=True,
                             )
 
                             # OpenAI inputs
@@ -762,7 +749,7 @@ Configure your PaperCast experience with your own API keys and preferences.
                                 placeholder="sk-...",
                                 type="password",
                                 info="Required when using OpenAI",
-                                visible=False,  # Hidden by default, shown only when OpenAI is selected
+                                visible=False,  # Hidden by default
                             )
 
                             openai_model_input = gr.Textbox(
@@ -770,149 +757,92 @@ Configure your PaperCast experience with your own API keys and preferences.
                                 placeholder="gpt-4o-mini",
                                 value="gpt-4o-mini",
                                 info="Model name (e.g., gpt-4o-mini, gpt-4, gpt-3.5-turbo)",
-                                visible=False,  # Hidden by default, shown only when OpenAI is selected
+                                visible=False,  # Hidden by default
                             )
 
                         gr.Markdown("---")
 
                         gr.Markdown("## 🔊 Text-to-Speech (TTS)")
-                        if DEMO_MODE:
-                            gr.Markdown(
-                                "**🔧 Demo Mode Active** - Using Edge-TTS (Microsoft, free)"
-                            )
-                        else:
-                            gr.Markdown(
-                                "Choose your TTS provider for audio generation"
-                            )
+                        gr.Markdown(
+                            "Powered by ElevenLabs - Premium AI voice synthesis"
+                        )
 
                         with gr.Group():
-                            tts_provider_choice = gr.Radio(
-                                choices=[
-                                    "Edge-TTS (Free, Microsoft)",
-                                    "ElevenLabs (Paid, Better Quality)",
-                                ],
-                                value="Edge-TTS (Free, Microsoft)",
-                                label="TTS Provider",
-                                info="Edge-TTS is free and works without API key. ElevenLabs offers better voice quality.",
-                                visible=not DEMO_MODE,
-                            )
-
                             elevenlabs_key_input = gr.Textbox(
                                 label="ElevenLabs API Key",
-                                placeholder="sk_... (required for ElevenLabs)",
+                                placeholder="sk_...",
                                 type="password",
-                                info="Get your key at: elevenlabs.io",
-                                visible=False,  # Hidden by default since Edge-TTS is default
+                                info="Get your key at: elevenlabs.io (Required)",
+                                value="",
+                                visible=True,
                             )
 
                         gr.Markdown("### 🎭 Voice Selection")
-                        if DEMO_MODE:
-                            gr.Markdown("*Choose voices for your podcast (Demo mode uses Edge-TTS)*")
-
-                        # Edge-TTS voice selections
-                        with gr.Group(visible=True if DEMO_MODE else not DEMO_MODE) as edge_voice_group:
-                            edge_host_voice = gr.Dropdown(
-                                choices=list(EDGE_TTS_VOICES.keys()),
-                                value="Guy (US Male - Casual)",
-                                label="Host Voice (Edge-TTS)",
+
+                        with gr.Group(visible=True) as elevenlabs_voice_group:
+                            elevenlabs_host_voice = gr.Dropdown(
+                                choices=list(ELEVENLABS_VOICES.keys()),
+                                value="Antoni (Male - Well-rounded)",
+                                label="Host Voice",
                                 info="Select voice for the podcast host",
                             )
-                            edge_guest_voice = gr.Dropdown(
-                                choices=list(EDGE_TTS_VOICES.keys()),
-                                value="Jenny (US Female - Friendly)",
-                                label="Guest Voice (Edge-TTS)",
+                            elevenlabs_guest_voice = gr.Dropdown(
+                                choices=list(ELEVENLABS_VOICES.keys()),
+                                value="Bella (Female - Soft)",
+                                label="Guest Voice",
                                 info="Select voice for the expert guest",
                             )
 
-                        # ElevenLabs voice selections (hidden by default, hidden in demo mode)
-                        if not DEMO_MODE:
-                            with gr.Group(visible=False) as elevenlabs_voice_group:
-                                elevenlabs_host_voice = gr.Dropdown(
-                                    choices=list(ELEVENLABS_VOICES.keys()),
-                                    value="Antoni (Male - Well-rounded)",
-                                    label="Host Voice (ElevenLabs)",
-                                    info="Select voice for the podcast host",
-                                )
-                                elevenlabs_guest_voice = gr.Dropdown(
-                                    choices=list(ELEVENLABS_VOICES.keys()),
-                                    value="Bella (Female - Soft)",
-                                    label="Guest Voice (ElevenLabs)",
-                                    info="Select voice for the expert guest",
-                                )
-                        else:
-                            # Create dummy components for demo mode so we can reference them
-                            elevenlabs_voice_group = None
-                            elevenlabs_host_voice = gr.State(value="Antoni (Male - Well-rounded)")
-                            elevenlabs_guest_voice = gr.State(value="Bella (Female - Soft)")
-
-                        # Toggle visibility based on LLM choice (only when not in demo mode)
-                        if not DEMO_MODE:
-
-                            def toggle_llm_inputs(choice):
-                                if choice == "Own Inference":
-                                    return {
-                                        own_inference_base_url: gr.update(visible=True),
-                                        own_inference_api_key: gr.update(visible=True),
-                                        own_inference_model: gr.update(visible=True),
-                                        openai_key_input: gr.update(visible=False),
-                                        openai_model_input: gr.update(visible=False),
-                                    }
-                                elif choice == "OpenAI":
-                                    return {
-                                        own_inference_base_url: gr.update(
-                                            visible=False
-                                        ),
-                                        own_inference_api_key: gr.update(visible=False),
-                                        own_inference_model: gr.update(visible=False),
-                                        openai_key_input: gr.update(visible=True),
-                                        openai_model_input: gr.update(visible=True),
-                                    }
-
-                            llm_choice.change(
-                                fn=toggle_llm_inputs,
-                                inputs=[llm_choice],
-                                outputs=[
-                                    own_inference_base_url,
-                                    own_inference_api_key,
-                                    own_inference_model,
-                                    openai_key_input,
-                                    openai_model_input,
-                                ],
-                            )
-
-                            # Toggle visibility based on TTS provider choice
-                            def toggle_tts_inputs(choice):
-                                if choice == "Edge-TTS (Free, Microsoft)":
-                                    return {
-                                        elevenlabs_key_input: gr.update(visible=False),
-                                        edge_voice_group: gr.update(visible=True),
-                                        elevenlabs_voice_group: gr.update(visible=False),
-                                    }
-                                else:  # ElevenLabs
-                                    return {
-                                        elevenlabs_key_input: gr.update(visible=True),
-                                        edge_voice_group: gr.update(visible=False),
-                                        elevenlabs_voice_group: gr.update(visible=True),
-                                    }
-
-                            tts_provider_choice.change(
-                                fn=toggle_tts_inputs,
-                                inputs=[tts_provider_choice],
-                                outputs=[elevenlabs_key_input, edge_voice_group, elevenlabs_voice_group],
-                            )
+                        # Toggle visibility based on LLM choice
+                        def toggle_llm_inputs(choice):
+                            if choice == "Own Inference":
+                                return {
+                                    own_inference_base_url: gr.update(visible=True),
+                                    own_inference_api_key: gr.update(visible=True),
+                                    own_inference_model: gr.update(visible=True),
+                                    openai_key_input: gr.update(visible=False),
+                                    openai_model_input: gr.update(visible=False),
+                                }
+                            elif choice == "OpenAI":
+                                return {
+                                    own_inference_base_url: gr.update(
+                                        visible=False
+                                    ),
+                                    own_inference_api_key: gr.update(visible=False),
+                                    own_inference_model: gr.update(visible=False),
+                                    openai_key_input: gr.update(visible=True),
+                                    openai_model_input: gr.update(visible=True),
+                                }
+
+                        llm_choice.change(
+                            fn=toggle_llm_inputs,
+                            inputs=[llm_choice],
+                            outputs=[
+                                own_inference_base_url,
+                                own_inference_api_key,
+                                own_inference_model,
+                                openai_key_input,
+                                openai_model_input,
+                            ],
+                        )
 
                         gr.Markdown("---")
 
                         gr.Markdown("## 🎚️ Podcast Settings")
 
                         with gr.Group():
-                            podcast_length = gr.Slider(
-                                minimum=1000,
-                                maximum=8000,
-                                value=4096,
-                                step=500,
-                                label="Podcast Length (Max Tokens)",
-                                info="Higher values = longer podcasts",
+                            podcast_length = gr.Radio(
+                                choices=[
+                                    "⚡ Very Short (6-8 exchanges, ~2-3 min)",
+                                    "📝 Short (10-12 exchanges, ~3-4 min)",
+                                    "📄 Medium (14-16 exchanges, ~5-6 min)",
+                                    "📚 Medium-Long (18-20 exchanges, ~7-8 min)",
+                                    "📖 Long (22-25 exchanges, ~9-11 min)",
+                                    "📕 Very Long (28-32 exchanges, ~12-15 min)",
+                                ],
+                                value="📄 Medium (14-16 exchanges, ~5-6 min)",
+                                label="Podcast Length",
+                                info="Select desired podcast duration based on dialogue exchanges",
                             )
 
                         gr.Markdown("---")
@@ -929,38 +859,27 @@ Configure your PaperCast experience with your own API keys and preferences.
                             own_model,
                             openai_key,
                             openai_model,
-                            tts_provider,
                             elevenlabs_key,
-                            edge_host,
-                            edge_guest,
                             elevenlabs_host,
                             elevenlabs_guest,
                             length,
                         ):
                             status = "✅ **Settings Saved!**\n\n"
 
-                            # Convert TTS provider choice to internal format
-                            if tts_provider == "Edge-TTS (Free, Microsoft)":
-                                tts_provider_internal = "edge-tts"
-                            else:
-                                tts_provider_internal = "elevenlabs"
-
-                            # Validate settings first (only in non-demo mode)
+                            # Validate settings
                             is_valid, validation_message = (
                                 validate_settings_for_generation(
                                     llm_choice,
                                     own_base_url,
                                     own_api_key,
                                     openai_key,
-                                    tts_provider_internal,
+                                    "elevenlabs",  # Always ElevenLabs
                                     elevenlabs_key,
                                 )
                             )
 
                             # LLM Settings
-                            if DEMO_MODE:
-                                status += "- LLM: Demo Inference ✓\n"
-                            elif llm_choice == "Own Inference":
+                            if llm_choice == "Own Inference":
                                 if own_base_url:
                                     status += f"- LLM: Own Inference ✓\n"
                                     status += f"  - URL: {own_base_url[:50]}...\n"
@@ -974,114 +893,78 @@ Configure your PaperCast experience with your own API keys and preferences.
                                     status += "- ⚠️ LLM: OpenAI selected but no API key provided\n"
 
                             # TTS Settings
-                            if DEMO_MODE:
-                                status += "- TTS: Edge-TTS (Microsoft, free) ✓\n"
+                            if elevenlabs_key:
+                                status += "- TTS: ElevenLabs ✓\n"
                             else:
-                                if tts_provider_internal == "edge-tts":
-                                    status += "- TTS: Edge-TTS (Microsoft, free) ✓\n"
-                                elif elevenlabs_key:
-                                    status += "- TTS: ElevenLabs (Custom key) ✓\n"
-                                else:
-                                    status += "- ⚠️ TTS: ElevenLabs key required\n"
+                                status += "- ⚠️ TTS: ElevenLabs API key required\n"
 
                             # Add validation result
-                            if not DEMO_MODE:
-                                if is_valid:
-                                    status += "\n✅ **All settings are valid!**\n"
-                                    status += "🎉 Generate button is now enabled.\n"
-                                else:
-                                    status += "\n⚠️ **Settings incomplete!**\n"
-                                    status += "🚫 Generate button remains disabled.\n"
-                                    status += f"\nRequired fixes:\n{validation_message}"
+                            if is_valid:
+                                status += "\n✅ **All settings are valid!**\n"
+                                status += "🎉 Generate button is now enabled.\n"
+                            else:
+                                status += "\n⚠️ **Settings incomplete!**\n"
+                                status += "🚫 Generate button remains disabled.\n"
+                                status += f"\nRequired fixes:\n{validation_message}"
+
+                            # Parse podcast length
+                            target_exchanges, max_tokens = get_podcast_length_params(length)
+                            status += f"\n- Podcast Length: {length}\n"
+                            status += f"  - Target: {target_exchanges} dialogue exchanges\n"
+                            status += f"  - Max tokens: {max_tokens}\n"
+
+                            # Add reasoning model info if using OpenAI reasoning models
+                            if llm_choice == "OpenAI" and openai_model:
+                                model_lower = openai_model.lower()
+                                # Check if it's a reasoning model
+                                is_reasoning = any(
+                                    keyword in model_lower
+                                    for keyword in ["gpt-5", "o1", "o3", "o4"]
+                                ) and "chat" not in model_lower
+
+                                if is_reasoning:
+                                    total_tokens = max_tokens * 2
+                                    status += f"  - ⚡ Reasoning model: {max_tokens} × 2 = {total_tokens} max tokens\n"
 
-                            status += f"\n- Podcast Length: {int(length)} tokens\n"
                             status += (
                                 "\n*Settings will be used for next podcast generation.*"
                             )
 
-                            # Determine which voices to use based on TTS provider
-                            if tts_provider_internal == "edge-tts":
-                                host_voice = EDGE_TTS_VOICES.get(edge_host, "en-US-GuyNeural")
-                                guest_voice = EDGE_TTS_VOICES.get(edge_guest, "en-US-JennyNeural")
-                            else:  # elevenlabs
-                                host_voice = ELEVENLABS_VOICES.get(elevenlabs_host, "ErXwobaYiN019PkySvjV")
-                                guest_voice = ELEVENLABS_VOICES.get(elevenlabs_guest, "EXAVITQu4vr4xnSDxMaL")
+                            # Get ElevenLabs voices
+                            host_voice = ELEVENLABS_VOICES.get(elevenlabs_host, "ErXwobaYiN019PkySvjV")
+                            guest_voice = ELEVENLABS_VOICES.get(elevenlabs_guest, "EXAVITQu4vr4xnSDxMaL")
 
+                            # Settings are stored in gr.State() for session-only (no disk persistence for security)
                             return (
                                 status,
-                                llm_choice if not DEMO_MODE else "demo",
-                                own_base_url if not DEMO_MODE else DEMO_INFERENCE_URL,
-                                own_api_key if not DEMO_MODE else DEMO_INFERENCE_KEY,
-                                own_model if not DEMO_MODE else DEMO_MODEL,
+                                llm_choice,
+                                own_base_url,
+                                own_api_key,
+                                own_model,
                                 openai_key,
                                 openai_model,
-                                tts_provider_internal if not DEMO_MODE else "edge-tts",
-                                elevenlabs_key if not DEMO_MODE else "",
-                                host_voice if not DEMO_MODE else "en-US-GuyNeural",
-                                guest_voice if not DEMO_MODE else "en-US-JennyNeural",
-                                int(length),
+                                "elevenlabs",  # Always ElevenLabs
+                                elevenlabs_key,
+                                host_voice,
+                                guest_voice,
+                                length,  # Now stores the full choice string
                                 is_valid,
                             )
 
-                        if DEMO_MODE:
-                            # In demo mode, settings are pre-configured but voices can be customized
-                            def save_demo_settings(edge_host, edge_guest, length):
-                                host_voice = EDGE_TTS_VOICES.get(edge_host, "en-US-GuyNeural")
-                                guest_voice = EDGE_TTS_VOICES.get(edge_guest, "en-US-JennyNeural")
-
-                                return (
-                                    f"✅ **Settings Saved!**\n\n- LLM: Demo Inference ✓\n- TTS: Edge-TTS (Microsoft, free) ✓\n- Host Voice: {edge_host}\n- Guest Voice: {edge_guest}\n\n*Demo mode is active with built-in services.*",
-                                    "demo",
-                                    DEMO_INFERENCE_URL,
-                                    DEMO_INFERENCE_KEY,
-                                    DEMO_MODEL,
-                                    "",
-                                    "",
-                                    "edge-tts",
-                                    "",
-                                    host_voice,
-                                    guest_voice,
-                                    int(length),
-                                    True,  # settings_valid = True in demo mode
-                                )
-
-                            save_settings_btn.click(
-                                fn=save_demo_settings,
-                                inputs=[edge_host_voice, edge_guest_voice, podcast_length],
-                                outputs=[
-                                    settings_status,
-                                    user_llm_choice,
-                                    user_own_base_url,
-                                    user_own_api_key,
-                                    user_own_model,
-                                    user_openai_key,
-                                    user_openai_model,
-                                    user_tts_provider,
-                                    user_elevenlabs_key,
-                                    user_host_voice,
-                                    user_guest_voice,
-                                    user_podcast_length,
-                                    settings_valid,
-                                ],
-                            )
-                        else:
-                            save_settings_btn.click(
-                                fn=save_settings,
-                                inputs=[
-                                    llm_choice,
-                                    own_inference_base_url,
-                                    own_inference_api_key,
-                                    own_inference_model,
-                                    openai_key_input,
-                                    openai_model_input,
-                                    tts_provider_choice,
-                                    elevenlabs_key_input,
-                                    edge_host_voice,
-                                    edge_guest_voice,
-                                    elevenlabs_host_voice,
-                                    elevenlabs_guest_voice,
-                                    podcast_length,
-                                ],
+                        save_settings_btn.click(
+                            fn=save_settings,
+                            inputs=[
+                                llm_choice,
+                                own_inference_base_url,
+                                own_inference_api_key,
+                                own_inference_model,
+                                openai_key_input,
+                                openai_model_input,
+                                elevenlabs_key_input,
+                                elevenlabs_host_voice,
+                                elevenlabs_guest_voice,
+                                podcast_length,
+                            ],
                                 outputs=[
                                     settings_status,
                                     user_llm_choice,
@@ -1113,73 +996,149 @@ Configure your PaperCast experience with your own API keys and preferences.
 
 # About PaperCast
 
-**PaperCast** is an AI-powered application that transforms complex research papers into engaging, accessible audio podcasts.
-Making scientific knowledge more accessible, one paper at a time.
+**The world's first interactive, multi-modal, AI-powered academic podcast studio.**
+
+Transform any research paper into engaging audio conversations with our proprietary frameworks powered by MCP tools, Gradio 6, and ElevenLabs.
+
+---
+
+## 🚀 Revolutionary Frameworks
+
+We built 4 original frameworks that redefine how people consume research:
+
+### **PPF** — Podcast Persona Framework
+Choose from 5 unique conversation styles:
+- 🤝 **Friendly Explainer** - Casual discussion between friends (default)
+- ⚔️ **Academic Debate** - Constructive challenges and defenses
+- 🔥 **Savage Roast** - Brutal critique meets stubborn defense
+- 🎓 **Pedagogical** - Professor teaching curious student
+- 🌐 **Interdisciplinary Clash** - Domain expert vs. complete outsider
+
+### **PAD** — Paper Auto-Discovery
+- 🔍 Natural language search: "diffusion survey 2025" or "Grok reasoning"
+- 📚 Semantic Scholar + arXiv API integration
+- 🎯 Zero-friction paper discovery
+
+### **PVF** — Paper Visual Framework *(Coming Soon)*
+- 📄 Synchronized PDF viewer with audio playback
+- 🎯 Auto-scroll to figures/tables when mentioned
+- ⏱️ Clickable timestamps in transcript
+
+### **CPM** — Counterfactual Paper Mode *(Coming Soon)*
+- 🤔 "What if this paper was written by Yann LeCun?"
+- 🕰️ "What if GPT-4 never existed?"
+- 🌀 Alternate reality interpretations
 
 ---
 
 ## 🎯 How It Works
 
-Our intelligent agent orchestrates a multi-step pipeline to create your podcast:
+Our intelligent agent orchestrates a multi-step pipeline:
 
-1. **📥 Input** - Provide a paper URL (arXiv, medRxiv) or upload any PDF
-2. **📄 Extraction** - AI extracts and analyzes the paper content
-3. **🎬 Script Generation** - Creates natural dialogue between Host and Expert personas
-4. **🎤 Voice Synthesis** - Generates high-quality audio with distinct voices
-5. **✅ Delivery** - Your podcast is ready to listen and download
+1. **📥 Input** - URL, PDF upload, or free-text search
+2. **📄 Extraction** - Marker-pdf MCP extracts clean markdown with LaTeX
+3. **🎬 Script Generation** - Claude creates persona-aware dialogue
+4. **🎤 Voice Synthesis** - ElevenLabs generates premium audio
+5. **✅ Delivery** - Listen, download, share
 
 ---
 
 ## 🌟 Key Features
 
-**Multiple Sources**: Support for arXiv, medRxiv, and direct PDF uploads
-**Natural Dialogue**: Engaging conversation between Host and Expert characters
-**High-Quality Audio**: Professional voice synthesis powered by ElevenLabs
-**Smart Processing**: AI understands paper structure and creates contextual discussions
-**History Tracking**: Keep track of all your generated podcasts
+✨ **5 Persona Modes** - From friendly to savage
+🔍 **Smart Paper Search** - Semantic Scholar + arXiv
+🎙️ **Premium Audio** - ElevenLabs TTS (required)
+📝 **Multi-format Export** - TXT, SRT, VTT, DOCX *(coming)*
+🧠 **Agent Intelligence** - MCP-powered autonomous reasoning
+📚 **History Tracking** - All podcasts saved locally
+⚡ **Multi-paper Processing** - Batch generation support
 
 ---
 
 ## 🔧 Technology Stack
 
 **LLM**: {SCRIPT_GENERATION_MODEL}
-**TTS**: Edge-TTS (Microsoft, Free) / ElevenLabs API (Optional)
+**TTS**: ElevenLabs (Premium AI Voice Synthesis)
+**PDF Processing**: Marker-pdf MCP Server
+**Search**: Semantic Scholar Graph API + arXiv API
 **Infrastructure**: ☁️ Remote Inference
-**Framework**: Gradio 6
-**PDF Processing**: PyMuPDF
+**Framework**: Gradio 6 with MCP Integration
+**Agent**: Claude with Model Context Protocol
 
 ---
 
 ## 🎓 Built For
 
 **MCP 1st Birthday Hackathon** - Track 2: MCP in Action (Consumer)
+*Tag: `mcp-in-action-track-consumer`*
 
-This project demonstrates autonomous agent capabilities through intelligent orchestration
-of multiple AI tools to transform static research papers into dynamic audio content.
+This project demonstrates:
+- 🤖 Autonomous agent planning and reasoning
+- 🔧 MCP tools as cognitive extensions
+- 🎨 Innovative UI/UX with Gradio 6
+- 🚀 Real-world impact on research accessibility
 
 ---
 
 ## 📝 About the Agent
 
-PaperCast uses an autonomous agent that:
+PaperCast's autonomous agent:
 
-**Plans** conversation flow based on paper structure
-**Reasons** about which concepts need simplification
-**Executes** multi-step processing pipeline
-**Adapts** dialogue based on paper complexity
+- **Plans** - Analyzes paper structure and selects optimal conversation strategy
+- **Reasons** - Determines which concepts need simplification based on persona
+- **Executes** - Orchestrates MCP tools (Marker, Semantic Scholar, arXiv)
+- **Adapts** - Adjusts dialogue complexity and style per persona mode
+- **Discovers** - Intelligently searches and retrieves relevant papers
 
 ---
 
 ## 💡 Use Cases
 
-🎧 Listen to papers during commute or exercise
-📚 Quick overview of research before deep reading
-🌍 Make research accessible to broader audiences
-🔬 Stay updated with latest papers in your field
+🎧 **Commute Learning** - Listen during travel or exercise
+📚 **Quick Previews** - Overview before deep reading
+🌍 **Accessibility** - Make research understandable for everyone
+🔬 **Stay Current** - Keep up with latest papers effortlessly
+🎭 **Entertainment** - Savage Roast mode for fun paper critiques
+🤔 **What-If Scenarios** - Explore counterfactual interpretations
+
+---
+
+## 🏆 What Makes Us Different
+
+**Not just another summarizer** - We invented the Podcast Persona Framework (PPF)
+**Visual sync** - Paper Visual Framework (PVF) connects audio to figures
+**Smart discovery** - Paper Auto-Discovery (PAD) finds papers via natural language
+**Counterfactuals** - Counterfactual Paper Mode (CPM) explores alternate realities
+**MCP Native** - Built from ground up with Model Context Protocol
+
+---
+
+## 🙏 Special Thanks
+
+This project was made possible by the incredible support from:
+
+<div style="display: flex; justify-content: center; align-items: center; gap: 80px; margin: 50px 0; flex-wrap: wrap;">
+    <div style="text-align: center;">
+        <a href="https://modal.com" target="_blank">
+            <img src="https://images.prismic.io/contrary-research/aDnorSdWJ-7kSv6V_ModalLabs_Cover.png?auto=format,compress" alt="Modal" style="height: 140px; width: auto; display: block; margin: 0 auto;">
+        </a>
+    </div>
+    <div style="text-align: center;">
+        <a href="https://elevenlabs.io" target="_blank">
+            <img src="https://eleven-public-cdn.elevenlabs.io/payloadcms/9trrmnj2sj8-logo-logo.svg" alt="ElevenLabs" style="height: 100px; width: auto; display: block; margin: 0 auto;">
+        </a>
+    </div>
+</div>
+
+**Why we chose these partners:**
+
+🚀 **Modal** - Serverless AI infrastructure that gives us instant access to powerful GPUs (A100, H100) with sub-second cold starts. Their platform handles automatic scaling, letting us process papers efficiently without managing infrastructure. Perfect for variable workloads and rapid iteration.
+
+🎙️ **ElevenLabs** - We use their **Turbo v2.5** model for studio-quality voice synthesis. This model delivers incredibly natural, emotionally expressive voices with low latency (~250-300ms) and 50% lower cost. The voice quality makes our podcasts truly engaging and professional.
 
 ---
 
-Made with ❤️ using AI, Gradio, and ElevenLabs
+Made with ❤️ using Anthropic, OpenAI, Modal, ElevenLabs, Gradio, and MCP
 
 </div>
 """)

generation/script_generator.py

@@ -1,14 +1,9 @@
-import base64
 import json
 
 import httpx
 from openai import OpenAI
 
 from utils.config import (
-    DEMO_INFERENCE_KEY,
-    DEMO_INFERENCE_URL,
-    DEMO_MODE,
-    DEMO_MODEL,
     MAX_TOKENS,
     SCRIPT_GENERATION_MODEL,
     TEMPERATURE,
@@ -18,7 +13,7 @@ from utils.config import (
 class ScriptGenerator:
     def __init__(
         self,
-        provider_mode="demo",
+        provider_mode="own_inference",
         own_base_url=None,
         own_api_key=None,
         own_model=None,
@@ -30,7 +25,7 @@ class ScriptGenerator:
         Initialize ScriptGenerator with flexible provider support.
 
         Args:
-            provider_mode: "demo", "own_inference", or "openai"
+            provider_mode: "own_inference" or "openai"
             own_base_url: Base URL for own inference server
             own_api_key: API key for own inference server
             own_model: Model name for own inference server
@@ -41,20 +36,7 @@ class ScriptGenerator:
         self.provider_mode = provider_mode
         self.max_tokens = max_tokens or MAX_TOKENS
 
-        if provider_mode == "demo":
-            # Demo mode - use hardcoded credentials
-            print(f"Using Demo Inference: {DEMO_INFERENCE_URL}")
-            username, password = DEMO_INFERENCE_KEY.split(":", 1)
-            http_client = httpx.Client(auth=(username, password))
-            self.client = OpenAI(
-                base_url=DEMO_INFERENCE_URL,
-                api_key="dummy",
-                http_client=http_client,
-            )
-            self.model_name = DEMO_MODEL
-            print("✓ Demo inference client initialized")
-
-        elif provider_mode == "own_inference":
+        if provider_mode == "own_inference":
             # Own inference server
             print(f"Connecting to own inference API: {own_base_url}")
 
@@ -94,18 +76,19 @@ class ScriptGenerator:
         else:
             raise ValueError(f"Invalid provider_mode: {provider_mode}")
 
-    def generate_podcast_script(self, paper_text: str) -> list:
+    def generate_podcast_script(self, paper_text: str, target_dialogue_count: int = 15) -> list:
         """
         Generates a podcast script from the given paper text.
 
         Args:
             paper_text (str): The text content of the research paper.
+            target_dialogue_count (int): Target number of dialogue exchanges (default: 15)
 
         Returns:
             list: A list of dictionaries representing the dialogue.
         """
 
-        system_prompt = """You are an expert podcast producer. Your goal is to convert technical research papers into engaging, accessible podcast dialogues between two hosts:
+        system_prompt = f"""You are an expert podcast producer. Your goal is to convert technical research papers into engaging, accessible podcast dialogues between two hosts:
 - Host (Alex): Enthusiastic, asks clarifying questions, guides the conversation.
 - Guest (Jamie): Expert researcher, explains concepts simply but accurately.
 
@@ -113,6 +96,8 @@ CRITICAL RULES:
 1. The Host MUST ALWAYS start with "Welcome to PaperCast!" - This is the show's branding and must never be skipped.
 2. NEVER read URLs, links, or web addresses out loud in the dialogue. Skip them completely. They sound awkward in audio format.
 3. NEVER mention arxiv IDs, DOIs, or reference numbers. Focus on the content, not the metadata.
+4. Generate EXACTLY {target_dialogue_count} dialogue exchanges (back-and-forth between Host and Guest). Do not exceed this count.
+5. Each exchange should be substantive but concise. Keep individual dialogue turns focused and conversational.
 
 Output the script in a valid JSON format. The JSON should be a list of objects, where each object has:
 - "speaker": "Host" or "Guest"
@@ -121,14 +106,15 @@ Output the script in a valid JSON format. The JSON should be a list of objects,
 
 Example:
 [
-    {"speaker": "Host", "text": "Welcome to PaperCast! Today we're diving into something really cool.", "emotion": "excited"},
-    {"speaker": "Guest", "text": "That's right, Alex. We're looking at a new way to handle large language models.", "emotion": "happy"}
+    {{"speaker": "Host", "text": "Welcome to PaperCast! Today we're diving into something really cool.", "emotion": "excited"}},
+    {{"speaker": "Guest", "text": "That's right, Alex. We're looking at a new way to handle large language models.", "emotion": "happy"}}
 ]
 
 Keep the conversation natural. Use fillers like "Um", "So", "You know" sparingly but effectively.
+IMPORTANT: Generate exactly {target_dialogue_count} dialogue items total. No more, no less.
 """
 
-        user_prompt = f"Here is the research paper text. Generate a podcast script summarizing the key findings, methodology, and implications.\n\n{paper_text[:10000]}..."
+        user_prompt = f"Here is the research paper text. Generate a podcast script with EXACTLY {target_dialogue_count} dialogue exchanges, summarizing the key findings, methodology, and implications.\n\n{paper_text[:10000]}..."
 
         messages = [
             {"role": "system", "content": system_prompt},
@@ -139,15 +125,81 @@ Keep the conversation natural. Use fillers like "Um", "So", "You know" sparingly
             f"Generating script with {self.provider_mode} (model: {self.model_name})..."
         )
 
-        # Call LLM
-        response = self.client.chat.completions.create(
-            model=self.model_name,
-            messages=messages,
-            max_tokens=self.max_tokens,
-            temperature=TEMPERATURE,
-        )
+        # Call LLM with appropriate parameters
+        # OpenAI's newer models use max_completion_tokens instead of max_tokens
+        # All OpenAI models support JSON mode (response_format)
+        if self.provider_mode == "openai":
+            # Check if this is a reasoning model (o1, o3, gpt-5 series except gpt-5-chat)
+            # Reasoning models don't support temperature parameter
+            is_reasoning_model = any(
+                keyword in self.model_name.lower()
+                for keyword in ["o1", "o3", "o4", "gpt-5"]
+            ) and "chat" not in self.model_name.lower()
+
+            # Common parameters for all OpenAI models
+            common_params = {
+                "model": self.model_name,
+                "messages": messages,
+                "response_format": {"type": "json_object"},  # JSON mode for all OpenAI models
+            }
+
+            if is_reasoning_model:
+                # Reasoning models: no temperature parameter
+                # Determine appropriate reasoning_effort based on model
+                model_lower = self.model_name.lower()
+
+                # GPT-5 series supports "minimal" (fastest)
+                # O-series only supports "low", "medium", "high"
+                # 2x multiplier: user's desired tokens + reasoning headroom
+                if "gpt-5" in model_lower:
+                    # GPT-5, GPT-5-mini, GPT-5-nano, GPT-5.1 all support "minimal"
+                    reasoning_effort_value = "minimal"
+                    reasoning_tokens = self.max_tokens * 2  # 2x: desired output + minimal reasoning
+                    effort_desc = "minimal (fastest for GPT-5 series)"
+                elif any(x in model_lower for x in ["o1-preview", "o1-mini"]):
+                    # Old O-series don't support reasoning_effort parameter at all
+                    reasoning_effort_value = None
+                    reasoning_tokens = self.max_tokens * 2  # 2x for default reasoning
+                    effort_desc = "default (no reasoning_effort support)"
+                else:
+                    # O1, O3, O4 series support "low" as minimum
+                    reasoning_effort_value = "low"
+                    reasoning_tokens = self.max_tokens * 2  # 2x: desired output + low reasoning
+                    effort_desc = "low (fastest for O-series)"
+
+                print(f"  ℹ️  Reasoning model detected - temperature disabled, tokens increased to {reasoning_tokens}")
+                print(f"     (Using {effort_desc} + JSON mode)")
+
+                # Add reasoning-specific parameters
+                common_params["max_completion_tokens"] = reasoning_tokens
+                if reasoning_effort_value:
+                    common_params["reasoning_effort"] = reasoning_effort_value
+
+                response = self.client.chat.completions.create(**common_params)
+            else:
+                # Regular chat models: include temperature
+                print(f"  ℹ️  Chat model with JSON mode enabled")
+                common_params["max_completion_tokens"] = self.max_tokens
+                common_params["temperature"] = TEMPERATURE
+                response = self.client.chat.completions.create(**common_params)
+        else:
+            # Own inference servers typically use max_tokens
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=messages,
+                max_tokens=self.max_tokens,
+                temperature=TEMPERATURE,
+            )
         generated_text = response.choices[0].message.content
 
+        # Debug: Print raw output info
+        print(f"  📄 Response length: {len(generated_text) if generated_text else 0} characters")
+
+        if not generated_text:
+            print("❌ Error: Model returned empty response")
+            print(f"Full response object: {response}")
+            return []
+
         # Extract JSON from the response
         try:
             # Find the first '[' and last ']'
@@ -156,13 +208,28 @@ Keep the conversation natural. Use fillers like "Um", "So", "You know" sparingly
             if start_index != -1 and end_index != -1:
                 json_str = generated_text[start_index:end_index]
                 script = json.loads(json_str)
+                print(f"  ✅ Successfully parsed {len(script)} dialogue items")
                 return script
             else:
-                print("No JSON found in output.")
+                print("❌ No JSON found in output.")
+                print(f"📝 Raw output preview (first 500 chars):\n{generated_text[:500]}")
+                if len(generated_text) > 500:
+                    print(f"... (truncated, total length: {len(generated_text)})")
                 return []
         except json.JSONDecodeError as e:
-            print(f"Error parsing JSON: {e}")
-            print(f"Raw output: {generated_text}")
+            print(f"❌ Error parsing JSON: {e}")
+
+            # Show context around the error location
+            if hasattr(e, 'pos') and e.pos:
+                error_pos = e.pos
+                context_start = max(0, error_pos - 200)
+                context_end = min(len(generated_text), error_pos + 200)
+                print(f"\n📍 Error at position {error_pos}:")
+                print(f"Context:\n...{generated_text[context_start:context_end]}...")
+
+            print(f"\n📝 Full output (first 1000 chars):\n{generated_text[:1000]}")
+            if len(generated_text) > 1000:
+                print(f"\n... (truncated, total length: {len(generated_text)} chars)")
             return []
 
 
@@ -171,7 +238,7 @@ _generator_instance = None
 
 
 def get_generator(
-    provider_mode="demo",
+    provider_mode="own_inference",
     own_base_url=None,
     own_api_key=None,
     own_model=None,
@@ -183,7 +250,7 @@ def get_generator(
     Get a script generator instance with flexible provider support.
 
     Args:
-        provider_mode: "demo", "own_inference", or "openai"
+        provider_mode: "own_inference" or "openai"
         own_base_url: Base URL for own inference server
         own_api_key: API key for own inference server
         own_model: Model name for own inference server
@@ -196,41 +263,26 @@ def get_generator(
     """
     global _generator_instance
 
-    # Always create new instance for OpenAI or own_inference with custom settings
-    # Reuse demo instance if same config
+    # Create instance based on provider mode
     if provider_mode == "openai":
         if not openai_key:
-            print(
-                "Warning: OpenAI selected but no API key provided. Falling back to demo mode."
-            )
-            provider_mode = "demo"
-        else:
-            return ScriptGenerator(
-                provider_mode="openai",
-                openai_key=openai_key,
-                openai_model=openai_model,
-                max_tokens=max_tokens or MAX_TOKENS,
-            )
+            raise ValueError("OpenAI API key is required for OpenAI provider mode")
+        return ScriptGenerator(
+            provider_mode="openai",
+            openai_key=openai_key,
+            openai_model=openai_model,
+            max_tokens=max_tokens or MAX_TOKENS,
+        )
 
     if provider_mode == "own_inference":
         if not own_base_url:
-            print(
-                "Warning: Own Inference selected but no base URL provided. Falling back to demo mode."
-            )
-            provider_mode = "demo"
-        else:
-            return ScriptGenerator(
-                provider_mode="own_inference",
-                own_base_url=own_base_url,
-                own_api_key=own_api_key,
-                own_model=own_model,
-                max_tokens=max_tokens or MAX_TOKENS,
-            )
-
-    # Demo mode - reuse global instance
-    if _generator_instance is None or provider_mode == "demo":
-        _generator_instance = ScriptGenerator(
-            provider_mode="demo",
+            raise ValueError("Base URL is required for own inference provider mode")
+        return ScriptGenerator(
+            provider_mode="own_inference",
+            own_base_url=own_base_url,
+            own_api_key=own_api_key,
+            own_model=own_model,
             max_tokens=max_tokens or MAX_TOKENS,
         )
-    return _generator_instance
+
+    raise ValueError(f"Invalid provider_mode: {provider_mode}")

live.py

@@ -3,50 +3,65 @@ import subprocess
 import datetime
 
 # ---------------------------------------------------------------------------
-# Lütfen curl komutunuzu tırnak işaretleri arasına yapıştırın.
-# Örnek: curl -X POST http://api.example.com/update
+# OPTIONAL: Keep-Alive Script for Inference Servers
 # ---------------------------------------------------------------------------
+# This script sends periodic requests to keep inference servers active.
+# Configure your own endpoint and credentials below if needed.
+#
+# Note: This is optional and only useful if you're hosting your own
+# inference server that goes to sleep after inactivity.
+# ---------------------------------------------------------------------------
+
+# Replace with your own inference endpoint and credentials
 CURL_COMMAND = """
-curl --location 'https://8000-dep-01kady4n8bfqjjatmpqtzhdcp9-d.cloudspaces.litng.ai/v1/chat/completions' \
+curl --location 'YOUR_INFERENCE_URL_HERE' \
 --header 'Content-Type: application/json' \
---header 'Authorization: Basic YmF0dTpCYXR1aGFuMTIz' \
+--header 'Authorization: YOUR_AUTH_HEADER_HERE' \
 --data '{
-  "model": "unsloth/Phi-4-mini-instruct-unsloth-bnb-4bit",
+  "model": "your-model-name",
   "messages": [
     {
       "role": "user",
-      "content": "You are a helpful assistant. How manny letters in strawberry?"
+      "content": "Hello, this is a keep-alive ping."
     }
   ]
 }'
 """
+
+# How often to send requests (in seconds)
+INTERVAL_SECONDS = 60
+
 # ---------------------------------------------------------------------------
 
 def run_periodically():
-    print(f"Script başlatıldı: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-    print(f"Komut: {CURL_COMMAND.strip()}")
+    print(f"Keep-alive script started: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print(f"Interval: {INTERVAL_SECONDS} seconds")
     print("-" * 50)
-    
+
+    if "YOUR_INFERENCE_URL_HERE" in CURL_COMMAND:
+        print("⚠️  WARNING: Please configure CURL_COMMAND with your actual endpoint!")
+        print("⚠️  Edit this file and replace the placeholder values.")
+        return
+
     while True:
         try:
             current_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-            print(f"[{current_time}] İstek gönderiliyor...")
-            
-            # shell=True, komutun terminaldeki gibi çalışmasını sağlar
+            print(f"[{current_time}] Sending keep-alive request...")
+
             result = subprocess.run(CURL_COMMAND, shell=True, capture_output=True, text=True)
-            
+
             if result.returncode == 0:
-                print(f"Başarılı! Çıktı (ilk 100 karakter): {result.stdout[:100]}...")
+                print(f"✓ Success! Response (first 100 chars): {result.stdout[:100]}...")
             else:
-                print(f"Hata kodu: {result.returncode}")
-                print(f"Hata çıktısı: {result.stderr}")
-                
+                print(f"✗ Error code: {result.returncode}")
+                print(f"Error output: {result.stderr}")
+
         except Exception as e:
-            print(f"Beklenmedik bir hata oluştu: {e}")
-        
-        print("60 saniye bekleniyor...")
+            print(f"Unexpected error: {e}")
+
+        print(f"Waiting {INTERVAL_SECONDS} seconds...")
         print("-" * 50)
-        time.sleep(60)
+        time.sleep(INTERVAL_SECONDS)
 
 if __name__ == "__main__":
     run_periodically()

output/history.json

@@ -54,5 +54,12 @@
     "script_length": 11,
     "timestamp": "2025-11-19 23:07:42",
     "audio_filename": "podcast_20251119_230742.wav"
+  },
+  {
+    "url": "https://arxiv.org/abs/2204.06125",
+    "audio_path": "/home/batuhan/lab/papercast/output/podcast_20251121_221210.wav",
+    "script_length": 21,
+    "timestamp": "2025-11-21 22:12:10",
+    "audio_filename": "podcast_20251121_221210.wav"
   }
 ]

requirements.txt

@@ -1,5 +1,4 @@
 beautifulsoup4
-edge-tts
 elevenlabs
 gradio
 mcp

synthesis/tts_engine.py

@@ -1,9 +1,7 @@
-import asyncio
 import os
 from datetime import datetime
 from io import BytesIO
 
-import edge_tts
 from elevenlabs import ElevenLabs, VoiceSettings
 from pydub import AudioSegment
 
@@ -14,38 +12,7 @@ from utils.config import (
     OUTPUT_DIR,
 )
 
-# Edge-TTS Voice Options
-EDGE_TTS_VOICES = {
-    # English (US) - Male
-    "Guy (US Male - Casual)": "en-US-GuyNeural",
-    "Christopher (US Male - Authoritative)": "en-US-ChristopherNeural",
-    "Eric (US Male - Professional)": "en-US-EricNeural",
-    "Steffan (US Male - Energetic)": "en-US-SteffanNeural",
-    "Roger (US Male - Elderly)": "en-US-RogerNeural",
-
-    # English (US) - Female
-    "Jenny (US Female - Friendly)": "en-US-JennyNeural",
-    "Aria (US Female - Professional)": "en-US-AriaNeural",
-    "Michelle (US Female - Enthusiastic)": "en-US-MichelleNeural",
-    "Sara (US Female - News Anchor)": "en-US-SaraNeural",
-    "Ana (US Female - Child)": "en-US-AnaNeural",
-
-    # English (UK)
-    "Ryan (UK Male)": "en-GB-RyanNeural",
-    "Thomas (UK Male - Elderly)": "en-GB-ThomasNeural",
-    "Sonia (UK Female)": "en-GB-SoniaNeural",
-    "Libby (UK Female - Enthusiastic)": "en-GB-LibbyNeural",
-
-    # English (Australia)
-    "William (AU Male)": "en-AU-WilliamNeural",
-    "Natasha (AU Female)": "en-AU-NatashaNeural",
-
-    # English (India)
-    "Prabhat (IN Male)": "en-IN-PrabhatNeural",
-    "Neerja (IN Female)": "en-IN-NeerjaNeural",
-}
-
-# ElevenLabs Voice Options (popular voices)
+# ElevenLabs Voice Options
 ELEVENLABS_VOICES = {
     # Male Voices
     "Antoni (Male - Well-rounded)": "ErXwobaYiN019PkySvjV",
@@ -80,58 +47,45 @@ def generate_unique_filename():
 
 
 class TTSEngine:
-    def __init__(self, tts_provider="edge-tts", custom_api_key=None, host_voice=None, guest_voice=None):
+    def __init__(self, tts_provider="elevenlabs", custom_api_key=None, host_voice=None, guest_voice=None):
         """
-        Initialize TTS Engine with specified provider.
+        Initialize TTS Engine with ElevenLabs.
 
         Args:
-            tts_provider: "edge-tts" or "elevenlabs"
-            custom_api_key: API key for ElevenLabs (only used if provider is "elevenlabs")
-            host_voice: Voice ID/name for Host (optional, uses default if not provided)
-            guest_voice: Voice ID/name for Guest (optional, uses default if not provided)
+            tts_provider: Must be "elevenlabs" (kept for compatibility)
+            custom_api_key: API key for ElevenLabs (required)
+            host_voice: Voice ID for Host (optional, uses default if not provided)
+            guest_voice: Voice ID for Guest (optional, uses default if not provided)
         """
-        self.mode = tts_provider.lower()
-
-        if self.mode == "elevenlabs":
-            print("Initializing ElevenLabs TTS API...")
-            # Use custom key if provided, otherwise use default
-            api_key = custom_api_key if custom_api_key else ELEVENLABS_API_KEY
-            self.client = ElevenLabs(api_key=api_key)
-
-            # Use custom voices or defaults
-            self.host_voice_id = host_voice if host_voice else ELEVENLABS_HOST_VOICE
-            self.guest_voice_id = guest_voice if guest_voice else ELEVENLABS_GUEST_VOICE
-
-            if custom_api_key:
-                print("✓ ElevenLabs TTS ready (custom API key)")
-            else:
-                print("✓ ElevenLabs TTS ready (demo API key)")
-
-            # Print selected voices
-            host_name = [k for k, v in ELEVENLABS_VOICES.items() if v == self.host_voice_id]
-            guest_name = [k for k, v in ELEVENLABS_VOICES.items() if v == self.guest_voice_id]
-            print(f"  Host: {host_name[0] if host_name else 'Custom/Default'}")
-            print(f"  Guest: {guest_name[0] if guest_name else 'Custom/Default'}")
-
-        elif self.mode == "edge-tts":
-            print("Initializing Edge-TTS (Microsoft)...")
-            # Use custom voices or defaults
-            self.host_voice = host_voice if host_voice else "en-US-GuyNeural"
-            self.guest_voice = guest_voice if guest_voice else "en-US-JennyNeural"
-            print("✓ Edge-TTS ready (free, no API key required)")
-
-            # Print selected voices
-            host_name = [k for k, v in EDGE_TTS_VOICES.items() if v == self.host_voice]
-            guest_name = [k for k, v in EDGE_TTS_VOICES.items() if v == self.guest_voice]
-            print(f"  Host: {host_name[0] if host_name else 'Custom/Default'}")
-            print(f"  Guest: {guest_name[0] if guest_name else 'Custom/Default'}")
+        self.mode = "elevenlabs"
+
+        print("Initializing ElevenLabs TTS API...")
+        # Use custom key if provided, otherwise use default
+        api_key = custom_api_key if custom_api_key else ELEVENLABS_API_KEY
+
+        if not api_key:
+            raise ValueError("ElevenLabs API key is required")
+
+        self.client = ElevenLabs(api_key=api_key)
 
+        # Use custom voices or defaults
+        self.host_voice_id = host_voice if host_voice else ELEVENLABS_HOST_VOICE
+        self.guest_voice_id = guest_voice if guest_voice else ELEVENLABS_GUEST_VOICE
+
+        if custom_api_key:
+            print("✓ ElevenLabs TTS ready (custom API key)")
         else:
-            raise ValueError(f"Unknown TTS provider: {tts_provider}. Use 'edge-tts' or 'elevenlabs'")
+            print("✓ ElevenLabs TTS ready")
+
+        # Print selected voices
+        host_name = [k for k, v in ELEVENLABS_VOICES.items() if v == self.host_voice_id]
+        guest_name = [k for k, v in ELEVENLABS_VOICES.items() if v == self.guest_voice_id]
+        print(f"  Host: {host_name[0] if host_name else 'Custom/Default'}")
+        print(f"  Guest: {guest_name[0] if guest_name else 'Custom/Default'}")
 
     def synthesize_dialogue(self, script: list) -> str:
         """
-        Synthesize the script to audio using selected TTS provider.
+        Synthesize the script to audio using ElevenLabs.
 
         Args:
             script: List of dialogue items
@@ -139,12 +93,7 @@ class TTSEngine:
         Returns:
             str: Path to the generated audio file
         """
-        if self.mode == "elevenlabs":
-            return self._synthesize_elevenlabs(script)
-        elif self.mode == "edge-tts":
-            return self._synthesize_edge_tts(script)
-        else:
-            raise ValueError(f"Unknown TTS mode: {self.mode}")
+        return self._synthesize_elevenlabs(script)
 
     def _synthesize_elevenlabs(self, script: list) -> str:
         """Synthesize using ElevenLabs API"""
@@ -154,23 +103,30 @@ class TTSEngine:
         for i, item in enumerate(script):
             text = item["text"]
             speaker = item["speaker"]
+            emotion = item.get("emotion", "neutral")
+
+            # Note: ElevenLabs doesn't have a direct emotion parameter.
+            # Emotion is conveyed through the text content itself (exclamation marks, word choice, etc.)
+            # which the script generator already creates based on the emotion field.
+            # We log the emotion for debugging but don't modify the text (would be spoken out loud).
 
             # Select voice based on speaker
             voice_id = self.guest_voice_id if speaker == "Guest" else self.host_voice_id
 
             try:
-                print(f"Synthesizing line {i + 1}/{len(script)} ({speaker})...")
+                print(f"Synthesizing line {i + 1}/{len(script)} ({speaker}, {emotion})...")
 
-                # Generate audio using ElevenLabs
+                # Generate audio using ElevenLabs with Turbo v2.5 for better quality and speed
+                # Turbo v2.5: High quality, low latency (~250-300ms), 50% cheaper than v2
                 audio_generator = self.client.text_to_speech.convert(
                     voice_id=voice_id,
                     text=text,
-                    model_id="eleven_multilingual_v2",
+                    model_id="eleven_turbo_v2_5",  # Upgraded from multilingual_v2 for better quality
                     voice_settings=VoiceSettings(
-                        stability=0.5,
-                        similarity_boost=0.75,
-                        style=0.5,
-                        use_speaker_boost=True,
+                        stability=0.4,  # Lower = more expressiveness and variation (default: 0.5)
+                        similarity_boost=0.8,  # Higher = better voice consistency (default: 0.75)
+                        style=0.6,  # Higher = more dynamic, expressive delivery (default: 0.5)
+                        use_speaker_boost=True,  # Enhances similarity to original voice
                     ),
                 )
 
@@ -207,123 +163,20 @@ class TTSEngine:
 
         return output_path
 
-    def _synthesize_edge_tts(self, script: list) -> str:
-        """Synthesize using Edge-TTS (Microsoft)"""
-        print("Synthesizing audio via Edge-TTS (Microsoft)...")
-        audio_segments = []
-
-        for i, item in enumerate(script):
-            text = item["text"]
-            speaker = item["speaker"]
-
-            # Select voice based on speaker
-            voice = self.guest_voice if speaker == "Guest" else self.host_voice
-
-            try:
-                print(f"Synthesizing line {i + 1}/{len(script)} ({speaker})...")
-
-                # Generate audio using Edge-TTS (synchronous wrapper for async)
-                audio_bytes = asyncio.run(self._edge_tts_synthesize(text, voice))
-
-                # Convert to AudioSegment
-                audio_segment = AudioSegment.from_mp3(BytesIO(audio_bytes))
-
-                # Trim silence from the end of the audio (Edge-TTS adds trailing silence)
-                # Detect silence threshold: -40 dBFS
-                audio_segment = self._trim_silence(audio_segment)
-
-                audio_segments.append(audio_segment)
-
-                # Add minimal silence between speakers (50ms for natural flow)
-                silence = AudioSegment.silent(duration=50)
-                audio_segments.append(silence)
-
-                print(f"✓ Synthesized line {i + 1}/{len(script)}")
-
-            except Exception as e:
-                print(f"Error synthesizing line '{text[:50]}...': {e}")
-                # Continue with next line even if one fails
-
-        if not audio_segments:
-            print("No audio generated")
-            return ""
-
-        # Combine all segments
-        print("Combining audio segments...")
-        combined = sum(audio_segments)
-
-        # Export as WAV with unique filename
-        filename = generate_unique_filename()
-        output_path = os.path.join(OUTPUT_DIR, filename)
-        combined.export(output_path, format="wav")
-        print(f"✓ Podcast saved to: {output_path}")
-
-        return output_path
-
-    async def _edge_tts_synthesize(self, text: str, voice: str) -> bytes:
-        """
-        Async helper to synthesize text using Edge-TTS.
-
-        Args:
-            text: Text to synthesize
-            voice: Voice name to use
-
-        Returns:
-            bytes: Audio data in MP3 format
-        """
-        communicate = edge_tts.Communicate(text, voice)
-        audio_data = b""
-
-        async for chunk in communicate.stream():
-            if chunk["type"] == "audio":
-                audio_data += chunk["data"]
-
-        return audio_data
-
-    def _trim_silence(self, audio_segment, silence_thresh=-40, chunk_size=10):
-        """
-        Trim silence from the end of audio segment.
-
-        Args:
-            audio_segment: AudioSegment to trim
-            silence_thresh: Silence threshold in dBFS (default: -40)
-            chunk_size: Size of chunks to analyze in ms (default: 10)
-
-        Returns:
-            Trimmed AudioSegment
-        """
-        # Start from the end and find where audio actually ends
-        trim_ms = 0
-
-        # Check from the end in chunks
-        for i in range(len(audio_segment) - chunk_size, 0, -chunk_size):
-            chunk = audio_segment[i:i + chunk_size]
-            if chunk.dBFS > silence_thresh:
-                # Found non-silent audio
-                trim_ms = i + chunk_size
-                break
-
-        # If we found non-silent audio, trim there
-        if trim_ms > 0:
-            return audio_segment[:trim_ms]
-
-        # Otherwise return original
-        return audio_segment
-
 
 # Global instance
 _tts_instance = None
 
 
-def get_tts_engine(tts_provider="edge-tts", custom_api_key=None, host_voice=None, guest_voice=None):
+def get_tts_engine(tts_provider="elevenlabs", custom_api_key=None, host_voice=None, guest_voice=None):
     """
-    Get TTS engine instance with optional provider, API key, and voices.
+    Get TTS engine instance with ElevenLabs.
 
     Args:
-        tts_provider: "edge-tts" or "elevenlabs" (default: "edge-tts")
-        custom_api_key: Optional custom ElevenLabs API key (only used for ElevenLabs)
-        host_voice: Voice ID/name for Host (optional)
-        guest_voice: Voice ID/name for Guest (optional)
+        tts_provider: Must be "elevenlabs" (kept for compatibility)
+        custom_api_key: ElevenLabs API key (required)
+        host_voice: Voice ID for Host (optional)
+        guest_voice: Voice ID for Guest (optional)
 
     Returns:
         TTSEngine instance
@@ -331,7 +184,7 @@ def get_tts_engine(tts_provider="edge-tts", custom_api_key=None, host_voice=None
     global _tts_instance
 
     # Always create new instance if custom settings provided
-    if custom_api_key or tts_provider != "edge-tts" or host_voice or guest_voice:
+    if custom_api_key or tts_provider != "elevenlabs" or host_voice or guest_voice:
         return TTSEngine(
             tts_provider=tts_provider,
             custom_api_key=custom_api_key,
@@ -339,7 +192,7 @@ def get_tts_engine(tts_provider="edge-tts", custom_api_key=None, host_voice=None
             guest_voice=guest_voice
         )
 
-    # Otherwise, reuse global instance (for default Edge-TTS)
+    # Otherwise, reuse global instance (for default ElevenLabs)
     if _tts_instance is None:
-        _tts_instance = TTSEngine(tts_provider="edge-tts")
+        _tts_instance = TTSEngine(tts_provider="elevenlabs")
     return _tts_instance

utils/config.py

@@ -5,39 +5,23 @@ from dotenv import load_dotenv
 # Load environment variables from .env.local
 load_dotenv(os.path.join(os.path.dirname(os.path.dirname(__file__)), ".env.local"))
 
-# Demo Mode Configuration - Load from environment variable
-# Set DEMO_MODE=true in .env.local or HuggingFace Spaces secrets
-DEMO_MODE = True
-
 # Model Configurations
 SCRIPT_GENERATION_MODEL = "unsloth/Phi-4-mini-instruct-unsloth-bnb-4bit"
 
-# LLM API Inference Settings (Cloud GPU) - Load from .env.local
-INFERENCE_API_URL = os.getenv("DEMO_INFERENCE_URL")
-INFERENCE_API_KEY = os.getenv("DEMO_INFERENCE_KEY")
+# User API Keys (Bring Your Own Key - BYOK)
+# Users provide these through the settings interface or environment variables
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
+INFERENCE_API_URL = os.getenv("INFERENCE_API_URL", "")
+INFERENCE_API_KEY = os.getenv("INFERENCE_API_KEY", "")
 
 # TTS API Settings (ElevenLabs)
-
-# Load from .env.local
-ELEVENLABS_API_KEY = os.getenv("DEMO_TTS_KEY")
+ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY", "")
 
 # ElevenLabs Voice IDs (you can change these to different voices)
 # Find more voices at: https://api.elevenlabs.io/v1/voices
 ELEVENLABS_HOST_VOICE = "ErXwobaYiN019PkySvjV"  # Antoni - male voice for Host
 ELEVENLABS_GUEST_VOICE = "EXAVITQu4vr4xnSDxMaL"  # Bella - female voice for Guest
 
-# Demo Mode Settings (loaded from .env.local)
-DEMO_INFERENCE_URL = INFERENCE_API_URL
-DEMO_INFERENCE_KEY = INFERENCE_API_KEY
-DEMO_MODEL = SCRIPT_GENERATION_MODEL
-DEMO_TTS_KEY = ELEVENLABS_API_KEY
-
-# Optional: Additional API keys for non-demo mode
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
-CUSTOM_ELEVENLABS_KEY = os.getenv("CUSTOM_ELEVENLABS_KEY", "")
-CUSTOM_INFERENCE_URL = os.getenv("CUSTOM_INFERENCE_URL", "")
-CUSTOM_INFERENCE_KEY = os.getenv("CUSTOM_INFERENCE_KEY", "")
-
 # Paths
 BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 TEMP_DIR = os.path.join(BASE_DIR, "temp")