Update services/podcast_generator_service.py

services/podcast_generator_service.py

@@ -1,12 +1,10 @@
 import logging
-import asyncio
-import json
-import uuid
 from typing import List, Dict, Any, Optional
 from dataclasses import dataclass, asdict
 from datetime import datetime
 from pathlib import Path
 import re
+import uuid
 
 try:
     from elevenlabs import VoiceSettings
@@ -18,15 +16,16 @@ except ImportError:
 import config
 from services.llamaindex_service import LlamaIndexService
 from services.llm_service import LLMService
+from services.document_store_service import DocumentStoreService
 
 logger = logging.getLogger(__name__)
 
 @dataclass
 class DocumentAnalysis:
     """Analysis results from document(s)"""
-    key_insights: List[str]  # 5-7 main points
+    key_insights: List[str]
     topics: List[str]
-    complexity_level: str  # beginner, intermediate, advanced
+    complexity_level: str
     estimated_words: int
     source_documents: List[str]
     summary: str
@@ -34,10 +33,10 @@ class DocumentAnalysis:
 @dataclass
 class DialogueLine:
     """Single line of podcast dialogue"""
-    speaker: str  # "HOST1" or "HOST2"
+    speaker: str
     text: str
-    pause_after: float = 0.5  # seconds
-    
+    pause_after: float = 0.5
+
 @dataclass
 class PodcastScript:
     """Complete podcast script"""
@@ -47,7 +46,6 @@ class PodcastScript:
     style: str
     
     def to_text(self) -> str:
-        """Convert to readable transcript"""
         lines = []
         for line in self.dialogue:
             lines.append(f"{line.speaker}: {line.text}")
@@ -83,98 +81,94 @@ class PodcastResult:
 class PodcastGeneratorService:
     """
     Service for generating conversational podcasts from documents.
-    Combines LlamaIndex for analysis and ElevenLabs for voice synthesis.
     """
     
-    # Word count per minute for podcast pacing
     WORDS_PER_MINUTE = 150
     
-    # Script generation prompts for different styles
     SCRIPT_PROMPTS = {
-        "conversational": """You are an expert podcast script writer. Create an engaging 2-host podcast discussing insights from documents.
+        "conversational": """You are an expert podcast script writer. Create an engaging 2-host podcast discussing the provided documents.
 
-CONTEXT:
-{analysis}
+DOCUMENT CONTENT:
+{document_content}
+
+KEY INSIGHTS:
+{key_insights}
 
 REQUIREMENTS:
 - Duration: {duration_minutes} minutes (approximately {word_count} words)
 - Style: Conversational, friendly, and accessible
 - Format: Alternating dialogue between HOST1 and HOST2
-- Include natural transitions, questions, and "aha!" moments
-- Make complex topics easy to understand
-- Add enthusiasm and genuine curiosity
-- Balance speaking time between both hosts
+- Make the content engaging and easy to understand
+- Include natural transitions and enthusiasm
 
 DIALOGUE FORMAT (strictly follow):
 HOST1: [What they say]
 HOST2: [What they say]
 
 STRUCTURE:
-1. Opening Hook (30 seconds): Grab attention with an intriguing question or fact
-2. Introduction (1 minute): Set context and preview what's coming
-3. Main Discussion (70% of time): Deep dive into key insights
-4. Wrap-up (1 minute): Summarize key takeaways and final thoughts
-
-TONE: Friendly, enthusiastic, educational but not condescending
+1. Opening Hook (30 seconds): Grab attention
+2. Introduction (1 minute): Set context
+3. Main Discussion (70% of time): Deep dive into insights
+4. Wrap-up (1 minute): Summarize key takeaways
 
 Generate the complete podcast script now:""",
         
-        "educational": """You are creating an educational podcast script. Two hosts discuss document insights in a clear, instructive manner.
+        "educational": """Create an educational podcast discussing the provided documents.
 
-CONTEXT:
-{analysis}
+DOCUMENT CONTENT:
+{document_content}
+
+KEY INSIGHTS:
+{key_insights}
 
 REQUIREMENTS:
 - Duration: {duration_minutes} minutes (approximately {word_count} words)
 - Style: Clear, methodical, educational
-- HOST1 acts as the teacher/expert, HOST2 as the curious learner
-- Include explanations of complex concepts
-- Use examples and analogies
-- Build knowledge progressively
+- HOST1 acts as teacher, HOST2 as curious learner
 
 DIALOGUE FORMAT:
 HOST1: [Expert explanation]
-HOST2: [Clarifying question or observation]
+HOST2: [Clarifying question]
 
-Generate the complete educational podcast script now:""",
+Generate the educational podcast script now:""",
         
-        "technical": """You are writing a technical podcast for an informed audience. Discuss document insights with precision and depth.
+        "technical": """Create a technical podcast for an informed audience.
+
+DOCUMENT CONTENT:
+{document_content}
 
-CONTEXT:
-{analysis}
+KEY INSIGHTS:
+{key_insights}
 
 REQUIREMENTS:
 - Duration: {duration_minutes} minutes (approximately {word_count} words)
 - Style: Professional, detailed, technically accurate
-- HOST1 is the subject matter expert, HOST2 is an informed interviewer
-- Use proper technical terminology
-- Dive into implementation details
-- Discuss implications and applications
+- HOST1 is expert, HOST2 is informed interviewer
 
 DIALOGUE FORMAT:
 HOST1: [Technical insight]
 HOST2: [Probing question]
 
-Generate the complete technical podcast script now:""",
+Generate the technical podcast script now:""",
         
-        "casual": """You are creating a fun, casual podcast. Two friends discuss interesting ideas from documents.
+        "casual": """Create a fun, casual podcast discussing the documents.
+
+DOCUMENT CONTENT:
+{document_content}
 
-CONTEXT:
-{analysis}
+KEY INSIGHTS:
+{key_insights}
 
 REQUIREMENTS:
 - Duration: {duration_minutes} minutes (approximately {word_count} words)
 - Style: Relaxed, humorous, energetic
-- Both hosts are enthusiastic and engaged
-- Use casual language and occasional humor
-- Make it entertaining while staying informative
-- Quick pacing with energy
+- Make it entertaining while informative
 
 DIALOGUE FORMAT:
 HOST1: [Casual commentary]
 HOST2: [Enthusiastic response]
 
-Generate the complete casual podcast script now:"""
+Generate the casual podcast script now:"""
     }
     
     def __init__(
@@ -183,18 +177,13 @@ Generate the complete casual podcast script now:"""
         llm_service: LLMService,
         elevenlabs_api_key: Optional[str] = None
     ):
-        """
-        Initialize podcast generator service
-        
-        Args:
-            llamaindex_service: Service for document analysis
-            llm_service: Service for script generation
-            elevenlabs_api_key: ElevenLabs API key (uses config if not provided)
-        """
         self.config = config.config
         self.llamaindex_service = llamaindex_service
         self.llm_service = llm_service
         
+        # Get document store from llamaindex service
+        self.document_store = llamaindex_service.document_store
+        
         # Initialize ElevenLabs client
         self.elevenlabs_client = None
         if ELEVENLABS_AVAILABLE:
@@ -213,10 +202,14 @@ Generate the complete casual podcast script now:"""
         # Metadata database file
         self.metadata_file = self.podcast_dir / "metadata_db.json"
         self._ensure_metadata_db()
+        
+        # Voice cache
+        self._voice_cache = {}
     
     def _ensure_metadata_db(self):
         """Ensure metadata database exists"""
         if not self.metadata_file.exists():
+            import json
             self.metadata_file.write_text(json.dumps([], indent=2))
     
     async def generate_podcast(
@@ -227,19 +220,7 @@ Generate the complete casual podcast script now:"""
         host1_voice: str = "Rachel",
         host2_voice: str = "Adam"
     ) -> PodcastResult:
-        """
-        Generate a complete podcast from documents
-        
-        Args:
-            document_ids: List of document IDs to analyze
-            style: Podcast style (conversational, educational, technical, casual)
-            duration_minutes: Target duration in minutes
-            host1_voice: Voice name for first host
-            host2_voice: Voice name for second host
-        
-        Returns:
-            PodcastResult with audio file path and metadata
-        """
+        """Generate a complete podcast from documents"""
         start_time = datetime.now()
         podcast_id = str(uuid.uuid4())
         
@@ -247,8 +228,8 @@ Generate the complete casual podcast script now:"""
             logger.info(f"Starting podcast generation {podcast_id}")
             logger.info(f"Documents: {document_ids}, Style: {style}, Duration: {duration_minutes}min")
             
-            # Step 1: Analyze documents
-            logger.info("Step 1: Analyzing documents...")
+            # Step 1: Retrieve and analyze documents
+            logger.info("Step 1: Retrieving and analyzing documents...")
             analysis = await self.analyze_documents(document_ids)
             
             # Step 2: Generate script
@@ -311,57 +292,133 @@ Generate the complete casual podcast script now:"""
     
     async def analyze_documents(self, document_ids: List[str]) -> DocumentAnalysis:
         """
-        Analyze documents to extract key insights for podcast
-        
-        Args:
-            document_ids: List of document IDs
+        Retrieve documents and extract key insights for podcast
         
-        Returns:
-            DocumentAnalysis with key insights and topics
+        FIXED: Now actually retrieves document content from document store
         """
-        # Create analysis query for the agentic RAG
-        analysis_query = f"""Analyze the following documents and provide:
-1. The 5-7 most important insights or key points
+        try:
+            # Step 1: Retrieve actual documents from document store
+            logger.info(f"Retrieving {len(document_ids)} documents from store...")
+            documents = []
+            document_contents = []
+            
+            for doc_id in document_ids:
+                doc = await self.document_store.get_document(doc_id)
+                if doc:
+                    documents.append(doc)
+                    document_contents.append(doc.content)
+                    logger.info(f"Retrieved document: {doc.filename} ({len(doc.content)} chars)")
+                else:
+                    logger.warning(f"Document {doc_id} not found in store")
+            
+            if not documents:
+                raise ValueError(f"No documents found for IDs: {document_ids}")
+            
+            # Step 2: Combine document content
+            combined_content = "\n\n---DOCUMENT SEPARATOR---\n\n".join(document_contents)
+            
+            # Truncate if too long (keep first portion for context)
+            max_content_length = 15000  # Adjust based on your LLM context window
+            if len(combined_content) > max_content_length:
+                logger.warning(f"Content too long ({len(combined_content)} chars), truncating to {max_content_length}")
+                combined_content = combined_content[:max_content_length] + "\n\n[Content truncated...]"
+            
+            # Step 3: Use LLM to analyze the content
+            analysis_prompt = f"""Analyze the following document(s) and provide:
+
+1. The 5-7 most important insights or key points (be specific and detailed)
 2. Main themes and topics covered
 3. The overall complexity level (beginner/intermediate/advanced)
-4. A brief summary suitable for podcast discussion
+4. A comprehensive summary suitable for podcast discussion
 
-Document IDs: {', '.join(document_ids)}
+DOCUMENTS:
+{combined_content}
 
-Provide a structured analysis optimized for creating an engaging podcast discussion."""
-        
-        # Use LlamaIndex agentic RAG for analysis
-        result = await self.llamaindex_service.query(analysis_query)
-        
-        # Parse the result to extract structured information
-        # This is a simplified parser - in production, you might want more robust parsing
-        insights = self._extract_insights(result)
-        topics = self._extract_topics(result)
-        complexity = self._determine_complexity(result)
-        
-        return DocumentAnalysis(
-            key_insights=insights[:7],  # Limit to 7
-            topics=topics,
-            complexity_level=complexity,
-            estimated_words=len(result.split()),
-            source_documents=document_ids,
-            summary=result
-        )
+Provide a structured analysis optimized for creating an engaging podcast discussion.
+Format your response as:
+
+KEY INSIGHTS:
+1. [First key insight]
+2. [Second key insight]
+...
+
+TOPICS:
+- [Topic 1]
+- [Topic 2]
+...
+
+COMPLEXITY: [beginner/intermediate/advanced]
+
+SUMMARY:
+[Your comprehensive summary here]
+"""
+            
+            logger.info("Analyzing content with LLM...")
+            result = await self.llm_service.generate_text(
+                analysis_prompt,
+                max_tokens=2000,
+                temperature=0.7
+            )
+            
+            # Step 4: Parse the structured response
+            insights = self._extract_insights(result)
+            topics = self._extract_topics(result)
+            complexity = self._determine_complexity(result)
+            summary = self._extract_summary(result)
+            
+            logger.info(f"Analysis complete: {len(insights)} insights, {len(topics)} topics")
+            
+            return DocumentAnalysis(
+                key_insights=insights[:7],
+                topics=topics,
+                complexity_level=complexity,
+                estimated_words=len(combined_content.split()),
+                source_documents=[doc.filename for doc in documents],
+                summary=summary or result[:500]
+            )
+            
+        except Exception as e:
+            logger.error(f"Document analysis failed: {str(e)}", exc_info=True)
+            raise RuntimeError(f"Failed to analyze documents: {str(e)}")
+    
+    def _extract_summary(self, text: str) -> str:
+        """Extract summary section from analysis"""
+        try:
+            if "SUMMARY:" in text:
+                parts = text.split("SUMMARY:")
+                if len(parts) > 1:
+                    summary = parts[1].strip()
+                    # Take first 500 chars if too long
+                    return summary[:500] if len(summary) > 500 else summary
+        except:
+            pass
+        
+        # Fallback: take first few sentences
+        sentences = text.split('.')
+        return '. '.join(sentences[:3]) + '.'
     
     def _extract_insights(self, text: str) -> List[str]:
         """Extract key insights from analysis text"""
         insights = []
-        #Simple extraction based on numbered lists or bullet points
         lines = text.split('\n')
+        
+        in_insights_section = False
         for line in lines:
             line = line.strip()
-            # Match patterns like "1.", "2.", "-", "*", "•"
-            if re.match(r'^\d+\.|\-|\*|•', line):
+            
+            if "KEY INSIGHTS:" in line.upper():
+                in_insights_section = True
+                continue
+            elif line.upper().startswith(("TOPICS:", "COMPLEXITY:", "SUMMARY:")):
+                in_insights_section = False
+            
+            if in_insights_section and line:
+                # Match patterns like "1.", "2.", "-", "*", "•"
                 insight = re.sub(r'^\d+\.|\-|\*|•', '', line).strip()
-                if len(insight) > 20:  # Ensure it's substantial
+                if len(insight) > 20:
                     insights.append(insight)
         
-        # If no insights found, create from first few sentences
+        # Fallback if no insights found
         if not insights:
             sentences = text.split('.')
             insights = [s.strip() + '.' for s in sentences[:7] if len(s.strip()) > 20]
@@ -370,25 +427,50 @@ Provide a structured analysis optimized for creating an engaging podcast discuss
     
     def _extract_topics(self, text: str) -> List[str]:
         """Extract main topics from analysis"""
-        # Simple keyword extraction - could be enhanced with NLP
-        common_words = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by'}
-        words = text.lower().split()
-        word_freq = {}
-        
-        for word in words:
-            word = re.sub(r'[^\w\s]', '', word)
-            if len(word) > 4 and word not in common_words:
-                word_freq[word] = word_freq.get(word, 0) + 1
-        
-        # Get top topics
-        topics = sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:5]
-        return [topic[0].title() for topic in topics]
+        topics = []
+        lines = text.split('\n')
+        
+        in_topics_section = False
+        for line in lines:
+            line = line.strip()
+            
+            if "TOPICS:" in line.upper():
+                in_topics_section = True
+                continue
+            elif line.upper().startswith(("KEY INSIGHTS:", "COMPLEXITY:", "SUMMARY:")):
+                in_topics_section = False
+            
+            if in_topics_section and line:
+                topic = re.sub(r'^\-|\*|•', '', line).strip()
+                if len(topic) > 2:
+                    topics.append(topic)
+        
+        # Fallback: simple keyword extraction
+        if not topics:
+            common_words = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by'}
+            words = text.lower().split()
+            word_freq = {}
+            
+            for word in words:
+                word = re.sub(r'[^\w\s]', '', word)
+                if len(word) > 4 and word not in common_words:
+                    word_freq[word] = word_freq.get(word, 0) + 1
+            
+            top_topics = sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:5]
+            topics = [topic[0].title() for topic in top_topics]
+        
+        return topics[:5]
     
     def _determine_complexity(self, text: str) -> str:
         """Determine content complexity level"""
         text_lower = text.lower()
         
-        # Simple heuristic based on keywords
+        if "complexity:" in text_lower:
+            for level in ["beginner", "intermediate", "advanced"]:
+                if level in text_lower.split("complexity:")[1][:100]:
+                    return level
+        
+        # Heuristic based on keywords
         if any(word in text_lower for word in ['basic', 'introduction', 'beginner', 'simple']):
             return "beginner"
         elif any(word in text_lower for word in ['advanced', 'complex', 'sophisticated', 'expert']):
@@ -402,59 +484,42 @@ Provide a structured analysis optimized for creating an engaging podcast discuss
         style: str,
         duration_minutes: int
     ) -> PodcastScript:
-        """
-        Generate podcast script from analysis
-        
-        Args:
-            analysis: Document analysis results
-            style: Podcast style
-            duration_minutes: Target duration
-        
-        Returns:
-            Complete podcast script
-        """
-        # Calculate target word count
+        """Generate podcast script from analysis"""
         target_words = duration_minutes * self.WORDS_PER_MINUTE
         
-        # Prepare analysis context
-        analysis_context = f"""
-KEY INSIGHTS:
-{chr(10).join(f"{i+1}. {insight}" for i, insight in enumerate(analysis.key_insights))}
-
-TOPICS: {', '.join(analysis.topics)}
-COMPLEXITY: {analysis.complexity_level}
-
-SUMMARY:
-{analysis.summary[:500]}...
-"""
+        # Prepare context with insights
+        insights_text = "\n".join(f"{i+1}. {insight}" for i, insight in enumerate(analysis.key_insights))
         
-        # Get prompt template for style
+        # Get prompt template
         prompt_template = self.SCRIPT_PROMPTS.get(style, self.SCRIPT_PROMPTS["conversational"])
         
-        # Fill in the template
+        # Fill template
         prompt = prompt_template.format(
-            analysis=analysis_context,
+            document_content=analysis.summary,
+            key_insights=insights_text,
             duration_minutes=duration_minutes,
             word_count=target_words
         )
         
-        # Generate script using LLM
+        # Generate script
         script_text = await self.llm_service.generate_text(
             prompt,
-            max_tokens=target_words * 2,  # Give room for generation
-            temperature=0.8  # More creative
+            max_tokens=target_words * 2,
+            temperature=0.8
         )
         
-        # Parse script into dialogue lines
+        # Parse into dialogue
         dialogue = self._parse_script(script_text)
         
-        # Calculate actual word count and duration
+        if not dialogue:
+            raise ValueError("Failed to parse script into dialogue lines")
+        
         word_count = sum(len(line.text.split()) for line in dialogue)
         duration_estimate = word_count / self.WORDS_PER_MINUTE
         
         return PodcastScript(
             dialogue=dialogue,
-            total_duration_estimate=duration_estimate * 60,  # Convert to seconds
+            total_duration_estimate=duration_estimate * 60,
             word_count=word_count,
             style=style
         )
@@ -469,7 +534,6 @@ SUMMARY:
             if not line:
                 continue
             
-            # Match "HOST1:" or "HOST2:" format
             if line.startswith('HOST1:'):
                 text = line[6:].strip()
                 if text:
@@ -482,43 +546,34 @@ SUMMARY:
         return dialogue
     
     def _get_voice_id(self, voice_name: str) -> str:
-        """
-        Get voice ID from voice name.
-        Falls back to first available voice if not found.
-        
-        Args:
-            voice_name: Voice name (e.g., "Rachel", "Adam")
-        
-        Returns:
-            Voice ID string
-        """
+        """Get voice ID from voice name"""
         try:
-            # Try to get voices and find by name
-            voices = self.elevenlabs_client.voices.get_all()
-            
-            if not voices or not voices.voices:
-                logger.error("No voices available from ElevenLabs")
-                raise RuntimeError("No voices available")
-            
-            # First, try exact name match
-            for voice in voices.voices:
-                if voice.name.lower() == voice_name.lower():
-                    logger.info(f"Found exact voice match for '{voice_name}': {voice.voice_id}")
-                    return voice.voice_id
-            
-            # Try partial match
-            for voice in voices.voices:
-                if voice_name.lower() in voice.name.lower():
-                    logger.info(f"Found partial voice match for '{voice_name}': {voice.name} ({voice.voice_id})")
-                    return voice.voice_id
-            
-            # Use first available voice as fallback
-            first_voice = voices.voices[0]
-            logger.warning(f"Voice '{voice_name}' not found, using first available voice: {first_voice.name} ({first_voice.voice_id})")
-            return first_voice.voice_id
+            # Use cache if available
+            if not self._voice_cache:
+                voices = self.elevenlabs_client.voices.get_all()
+                if not voices or not voices.voices:
+                    raise RuntimeError("No voices available")
+                
+                for voice in voices.voices:
+                    self._voice_cache[voice.name.lower()] = voice.voice_id
+            
+            # Exact match
+            if voice_name.lower() in self._voice_cache:
+                return self._voice_cache[voice_name.lower()]
+            
+            # Partial match
+            for name, voice_id in self._voice_cache.items():
+                if voice_name.lower() in name:
+                    logger.info(f"Partial match for '{voice_name}': {name}")
+                    return voice_id
+            
+            # Fallback
+            first_voice_id = list(self._voice_cache.values())[0]
+            logger.warning(f"Voice '{voice_name}' not found, using default")
+            return first_voice_id
             
         except Exception as e:
-            logger.error(f"Could not fetch voices: {e}", exc_info=True)
+            logger.error(f"Could not fetch voices: {e}")
             raise RuntimeError(f"Failed to get voice ID: {str(e)}")
     
     async def synthesize_audio(
@@ -528,60 +583,63 @@ SUMMARY:
         host1_voice: str,
         host2_voice: str
     ) -> Path:
-        """
-        Synthesize audio from script using ElevenLabs
-        
-        Args:
-            podcast_id: Unique podcast ID
-            script: Podcast script
-            host1_voice: Voice for HOST1
-            host2_voice: Voice for HOST2
-        
-        Returns:
-            Path to generated MP3 file
-        """
+        """Synthesize audio with alternating voices"""
         if not self.elevenlabs_client:
             raise RuntimeError("ElevenLabs client not initialized")
         
         audio_file = self.podcast_dir / f"{podcast_id}.mp3"
         
-        # For now, create a simple text-to-speech for the full script
-        # In production, you'd combine segments with pauses
-        full_text = script.to_text()
-        
-        # Get actual voice ID
-        voice_id = self._get_voice_id(host1_voice)
-        
         try:
-            # Use modern ElevenLabs TTS API
-            # Note: This is a simplified version using single voice
-            # Full implementation would process each line separately with different voices
+            # Get voice IDs
+            host1_voice_id = self._get_voice_id(host1_voice)
+            host2_voice_id = self._get_voice_id(host2_voice)
             
-            logger.info(f"Generating audio with voice: {host1_voice}")
+            logger.info(f"HOST1: {host1_voice}, HOST2: {host2_voice}")
             
-            # Use the modern text_to_speech API
-            audio_generator = self.elevenlabs_client.text_to_speech.convert(
-                voice_id=voice_id,  # Using resolved voice ID
-                text=full_text,
-                model_id="eleven_multilingual_v2"
-            )
+            voice_map = {
+                "HOST1": host1_voice_id,
+                "HOST2": host2_voice_id
+            }
             
-            # Write audio chunks to file
-            with open(audio_file, 'wb') as f:
+            audio_chunks = []
+            
+            # Process each line with correct voice
+            for i, line in enumerate(script.dialogue):
+                logger.info(f"Line {i+1}/{len(script.dialogue)}: {line.speaker}")
+                
+                voice_id = voice_map.get(line.speaker, host1_voice_id)
+                
+                audio_generator = self.elevenlabs_client.text_to_speech.convert(
+                    voice_id=voice_id,
+                    text=line.text,
+                    model_id="eleven_multilingual_v2"
+                )
+                
+                line_chunks = []
                 for chunk in audio_generator:
                     if chunk:
-                        f.write(chunk)
+                        line_chunks.append(chunk)
+                
+                if line_chunks:
+                    audio_chunks.append(b''.join(line_chunks))
+            
+            if not audio_chunks:
+                raise RuntimeError("No audio chunks generated")
+            
+            full_audio = b''.join(audio_chunks)
+            
+            with open(audio_file, 'wb') as f:
+                f.write(full_audio)
             
-            # Verify file was created with content
             if audio_file.exists() and audio_file.stat().st_size > 1000:
-                logger.info(f"Audio synthesized successfully: {audio_file} ({audio_file.stat().st_size} bytes)")
+                logger.info(f"Audio created: {audio_file} ({audio_file.stat().st_size} bytes)")
                 return audio_file
             else:
-                raise RuntimeError(f"Generated audio file is too small or empty: {audio_file.stat().st_size} bytes")
+                raise RuntimeError("Audio file too small or empty")
             
         except Exception as e:
             logger.error(f"Audio synthesis failed: {e}", exc_info=True)
-            raise RuntimeError(f"Failed to generate podcast audio: {str(e)}")
+            raise RuntimeError(f"Failed to generate audio: {str(e)}")
     
     def _create_metadata(
         self,
@@ -594,28 +652,22 @@ SUMMARY:
         style: str
     ) -> PodcastMetadata:
         """Create podcast metadata"""
-        # Auto-generate title
         title = f"Podcast: {analysis.topics[0] if analysis.topics else 'Document Discussion'}"
-        
-        # Create description
-        description = f"A {style} podcast discussing insights from {len(document_ids)} document(s)."
-        
-        # Calculate file size
+        description = f"A {style} podcast discussing: {', '.join(analysis.source_documents)}"
         file_size_mb = audio_path.stat().st_size / (1024 * 1024) if audio_path.exists() else 0
         
-        # Estimate costs
-        llm_cost = (script.word_count / 1000) * 0.01  # Rough estimate
-        tts_cost = (script.word_count * 5 / 1000) * 0.30  # Rough estimate
+        llm_cost = (script.word_count / 1000) * 0.01
+        tts_cost = (script.word_count * 5 / 1000) * 0.30
         
         return PodcastMetadata(
             podcast_id=podcast_id,
             title=title,
             description=description,
-            source_documents=document_ids,
+            source_documents=analysis.source_documents,
             style=style,
             duration_seconds=script.total_duration_estimate,
             file_size_mb=file_size_mb,
-            voices={"host1": list(voices)[0] if len(voices) > 0 else "Rachel", 
+            voices={"host1": list(voices)[0] if len(voices) > 0 else "Rachel",
                    "host2": list(voices)[1] if len(voices) > 1 else "Adam"},
             generated_at=datetime.now().isoformat(),
             generation_cost={"llm_cost": llm_cost, "tts_cost": tts_cost, "total": llm_cost + tts_cost},
@@ -625,26 +677,21 @@ SUMMARY:
     def _save_metadata(self, metadata: PodcastMetadata):
         """Save metadata to database"""
         try:
-            # Load existing metadata
+            import json
             existing = json.loads(self.metadata_file.read_text())
-            
-            # Add new metadata
             existing.append(asdict(metadata))
-            
-            # Save back
             self.metadata_file.write_text(json.dumps(existing, indent=2))
-            
-            logger.info(f"Metadata saved for podcast: {metadata.podcast_id}")
-            
+            logger.info(f"Metadata saved: {metadata.podcast_id}")
         except Exception as e:
             logger.error(f"Failed to save metadata: {e}")
     
     def list_podcasts(self, limit: int = 10) -> List[PodcastMetadata]:
         """List generated podcasts"""
         try:
+            import json
             data = json.loads(self.metadata_file.read_text())
             podcasts = [PodcastMetadata(**item) for item in data[-limit:]]
-            return list(reversed(podcasts))  # Most recent first
+            return list(reversed(podcasts))
         except Exception as e:
             logger.error(f"Failed to list podcasts: {e}")
             return []
@@ -652,6 +699,7 @@ SUMMARY:
     def get_podcast(self, podcast_id: str) -> Optional[PodcastMetadata]:
         """Get specific podcast metadata"""
         try:
+            import json
             data = json.loads(self.metadata_file.read_text())
             for item in data:
                 if item.get('podcast_id') == podcast_id:
@@ -659,5 +707,4 @@ SUMMARY:
             return None
         except Exception as e:
             logger.error(f"Failed to get podcast: {e}")
-            return None
-
+            return None