v2

run.py

@@ -12,7 +12,7 @@ from app import demo
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
-        server_port=7867,
+        server_port=7870,
         share=False
     )
 

src/app.py

@@ -6,6 +6,7 @@ import time
 import re
 from typing import Dict, Any, List, Optional
 import threading
+from pydub import AudioSegment
 
 # Get project root directory (parent of src/)
 PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
@@ -415,12 +416,34 @@ def play_next_segment():
                         youtube_id = track["url"].split("v=")[-1].split("&")[0]
                     
                     if youtube_id:
-                        # Simple YouTube iframe embed with autoplay
+                        # Get host audio duration to calculate delay
+                        delay_ms = 0
+                        if host_audio_file and os.path.exists(host_audio_file):
+                            try:
+                                audio = AudioSegment.from_file(host_audio_file)
+                                duration_ms = len(audio)
+                                delay_ms = max(0, duration_ms - 3000)  # Start 3 seconds before end
+                                print(f"⏱️ Host audio: {duration_ms}ms, YouTube delay: {delay_ms}ms")
+                            except Exception as e:
+                                print(f"⚠️ Could not get audio duration: {e}")
+                        
+                        # YouTube iframe with delayed display via CSS animation
                         music_player_html = f"""
+                        <style>
+                            @keyframes showYoutube {{
+                                from {{ opacity: 0; }}
+                                to {{ opacity: 1; }}
+                            }}
+                            .youtube-delayed {{
+                                animation: showYoutube 0.5s ease-in forwards;
+                                animation-delay: {delay_ms}ms;
+                                opacity: 0;
+                            }}
+                        </style>
                         <div style="padding: 1rem; background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%); border-radius: 12px; margin: 1rem 0; box-shadow: 0 4px 15px rgba(0,0,0,0.3);">
                             <h4 style="margin: 0 0 0.75rem 0; color: #fff; font-size: 1.1em;">🎵 {track.get('title', 'Unknown')}</h4>
                             <p style="margin: 0 0 0.75rem 0; color: #aaa; font-size: 0.9em;">by {track.get('artist', 'Unknown')}</p>
-                            <div style="position: relative; width: 100%; padding-bottom: 56.25%; border-radius: 8px; overflow: hidden; background: #000;">
+                            <div class="youtube-delayed" style="position: relative; width: 100%; padding-bottom: 56.25%; border-radius: 8px; overflow: hidden; background: #000;">
                                 <iframe 
                                     style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: none;"
                                     src="https://www.youtube.com/embed/{youtube_id}?autoplay=1&rel=0&modestbranding=1&playsinline=1"
@@ -433,7 +456,7 @@ def play_next_segment():
                             </p>
                         </div>
                         """
-                        print(f"✅ YouTube player created: {track.get('title', 'Unknown')} (ID: {youtube_id})")
+                        print(f"✅ YouTube player created: {track.get('title', 'Unknown')} (ID: {youtube_id}) - shows after {delay_ms}ms")
                     else:
                         # Fallback: Just show link
                         music_player_html = f"""
@@ -503,12 +526,34 @@ def play_next_segment():
         if podcast.get("source") == "youtube" and podcast.get("youtube_id"):
             youtube_id = podcast.get("youtube_id", "")
             
-            # Use simple iframe embed (Gradio sanitizes script tags)
+            # Get host audio duration to calculate delay
+            delay_ms = 0
+            if host_audio_file and os.path.exists(host_audio_file):
+                try:
+                    audio = AudioSegment.from_file(host_audio_file)
+                    duration_ms = len(audio)
+                    delay_ms = max(0, duration_ms - 3000)  # Start 3 seconds before end
+                    print(f"⏱️ Podcast host audio: {duration_ms}ms, YouTube delay: {delay_ms}ms")
+                except Exception as e:
+                    print(f"⚠️ Could not get audio duration: {e}")
+            
+            # YouTube iframe with delayed display
             music_player_html = f"""
+            <style>
+                @keyframes showPodcast {{
+                    from {{ opacity: 0; }}
+                    to {{ opacity: 1; }}
+                }}
+                .podcast-delayed {{
+                    animation: showPodcast 0.5s ease-in forwards;
+                    animation-delay: {delay_ms}ms;
+                    opacity: 0;
+                }}
+            </style>
             <div style="padding: 1rem; background: linear-gradient(135deg, #6b46c1 0%, #9f7aea 100%); border-radius: 12px; margin: 1rem 0; box-shadow: 0 4px 15px rgba(0,0,0,0.3);">
                 <h4 style="margin: 0 0 0.75rem 0; color: #fff; font-size: 1.1em;">🎙️ {podcast.get('title', 'Podcast')}</h4>
                 <p style="margin: 0 0 0.75rem 0; color: #e9d8fd; font-size: 0.9em;">by {podcast.get('host', 'Unknown Host')}</p>
-                <div style="position: relative; width: 100%; padding-bottom: 56.25%; border-radius: 8px; overflow: hidden; background: #000;">
+                <div class="podcast-delayed" style="position: relative; width: 100%; padding-bottom: 56.25%; border-radius: 8px; overflow: hidden; background: #000;">
                     <iframe 
                         style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: none;"
                         src="https://www.youtube.com/embed/{youtube_id}?autoplay=1&rel=0&modestbranding=1&playsinline=1"
@@ -521,7 +566,7 @@ def play_next_segment():
                 </p>
             </div>
             """
-            print(f"✅ Podcast YouTube player created: {podcast.get('title', 'Unknown')} (ID: {youtube_id})")
+            print(f"✅ Podcast YouTube player created: {podcast.get('title', 'Unknown')} (ID: {youtube_id}) - shows after {delay_ms}ms")
         elif podcast.get("url") and "youtube" in podcast.get("url", ""):
             # Fallback: extract YouTube ID from URL and create simple embed
             url = podcast.get("url", "")
@@ -532,11 +577,32 @@ def play_next_segment():
                 youtube_id = url.split("youtu.be/")[-1].split("?")[0]
             
             if youtube_id:
+                # Get host audio duration to calculate delay
+                delay_ms = 0
+                if host_audio_file and os.path.exists(host_audio_file):
+                    try:
+                        audio = AudioSegment.from_file(host_audio_file)
+                        duration_ms = len(audio)
+                        delay_ms = max(0, duration_ms - 3000)
+                    except:
+                        pass
+                
                 music_player_html = f"""
+                <style>
+                    @keyframes showPodcast2 {{
+                        from {{ opacity: 0; }}
+                        to {{ opacity: 1; }}
+                    }}
+                    .podcast-delayed-2 {{
+                        animation: showPodcast2 0.5s ease-in forwards;
+                        animation-delay: {delay_ms}ms;
+                        opacity: 0;
+                    }}
+                </style>
                 <div style="padding: 1rem; background: linear-gradient(135deg, #6b46c1 0%, #9f7aea 100%); border-radius: 12px; margin: 1rem 0; box-shadow: 0 4px 15px rgba(0,0,0,0.3);">
                     <h4 style="margin: 0 0 0.75rem 0; color: #fff; font-size: 1.1em;">🎙️ {podcast.get('title', 'Podcast')}</h4>
                     <p style="margin: 0 0 0.75rem 0; color: #e9d8fd; font-size: 0.9em;">by {podcast.get('host', 'Unknown Host')}</p>
-                    <div style="position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; border-radius: 8px;">
+                    <div class="podcast-delayed-2" style="position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; border-radius: 8px;">
                         <iframe 
                             src="https://www.youtube.com/embed/{youtube_id}?autoplay=1&rel=0&modestbranding=1&playsinline=1" 
                             style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: none;"
@@ -549,7 +615,7 @@ def play_next_segment():
                     </p>
                 </div>
                 """
-                print(f"✅ Podcast iframe player created: {podcast.get('title', 'Unknown')} (ID: {youtube_id})")
+                print(f"✅ Podcast iframe player created: {podcast.get('title', 'Unknown')} (ID: {youtube_id}) - shows after {delay_ms}ms")
     
     # Progress info
     progress = f"Segment {radio_state['current_segment_index']}/{len(radio_state['planned_show'])}"
@@ -783,12 +849,34 @@ def handle_voice_request():
                 youtube_id = track["url"].split("v=")[-1].split("&")[0]
             
             if youtube_id:
-                # YouTube embed with direct iframe (Gradio sanitizes script tags)
+                # Get host audio duration to calculate delay
+                delay_ms = 0
+                if audio_file and os.path.exists(audio_file):
+                    try:
+                        audio = AudioSegment.from_file(audio_file)
+                        duration_ms = len(audio)
+                        delay_ms = max(0, duration_ms - 3000)  # Start 3 seconds before end
+                        print(f"⏱️ Voice request audio: {duration_ms}ms, YouTube delay: {delay_ms}ms")
+                    except Exception as e:
+                        print(f"⚠️ Could not get audio duration: {e}")
+                
+                # YouTube embed with delayed display
                 music_player_html = f"""
+                <style>
+                    @keyframes showVoiceYoutube {{
+                        from {{ opacity: 0; }}
+                        to {{ opacity: 1; }}
+                    }}
+                    .voice-youtube-delayed {{
+                        animation: showVoiceYoutube 0.5s ease-in forwards;
+                        animation-delay: {delay_ms}ms;
+                        opacity: 0;
+                    }}
+                </style>
                 <div style="padding: 1rem; background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%); border-radius: 12px; margin: 1rem 0; box-shadow: 0 4px 15px rgba(0,0,0,0.3);">
                     <h4 style="margin: 0 0 0.75rem 0; color: #fff; font-size: 1.1em;">🎵 {track.get('title', 'Unknown')}</h4>
                     <p style="margin: 0 0 0.75rem 0; color: #aaa; font-size: 0.9em;">by {track.get('artist', 'Unknown')}</p>
-                    <div style="position: relative; width: 100%; padding-bottom: 56.25%; border-radius: 8px; overflow: hidden; background: #000;">
+                    <div class="voice-youtube-delayed" style="position: relative; width: 100%; padding-bottom: 56.25%; border-radius: 8px; overflow: hidden; background: #000;">
                         <iframe 
                             style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: none;"
                             src="https://www.youtube.com/embed/{youtube_id}?autoplay=1&rel=0&modestbranding=1&playsinline=1"
@@ -801,6 +889,7 @@ def handle_voice_request():
                     </p>
                 </div>
                 """
+                print(f"✅ Voice request YouTube player created - shows after {delay_ms}ms")
                 print(f"✅ YouTube player created: {track.get('title', 'Unknown')} (ID: {youtube_id})")
             else:
                 music_player_html = f"""
@@ -1520,7 +1609,7 @@ Your passphrase: **{passphrase}**
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
-        server_port=7867,
+        server_port=7870,
         share=False
     )
 

src/mcp_servers/music_server.py

@@ -24,8 +24,78 @@ class MusicMCPServer:
         self.description = "Provides music recommendations and free music tracks"
         self.cache_dir = "music_cache"
         os.makedirs(self.cache_dir, exist_ok=True)
+        # Cache for embed check results to avoid repeated API calls
+        self._embed_cache = {}
+    
+    def check_video_embeddable(self, video_id: str) -> bool:
+        """
+        Check if a YouTube video is available and embeddable.
         
-    def search_youtube_music(self, query: str, limit: int = 5, fast: bool = False) -> List[Dict[str, Any]]:
+        Args:
+            video_id: YouTube video ID
+            
+        Returns:
+            True if video is embeddable, False otherwise
+        """
+        # Check cache first
+        if video_id in self._embed_cache:
+            return self._embed_cache[video_id]
+        
+        try:
+            ydl_opts = {
+                'quiet': True,
+                'no_warnings': True,
+                'skip_download': True,
+            }
+            
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                url = f"https://www.youtube.com/watch?v={video_id}"
+                info = ydl.extract_info(url, download=False)
+                
+                if not info:
+                    print(f"⚠️ Video {video_id}: not found")
+                    self._embed_cache[video_id] = False
+                    return False
+                
+                # Check if video is available
+                availability = info.get('availability')
+                if availability and availability != 'public':
+                    print(f"⚠️ Video {video_id}: not public ({availability})")
+                    self._embed_cache[video_id] = False
+                    return False
+                
+                # Check if video is age-restricted (often blocks embedding)
+                if info.get('age_limit', 0) > 0:
+                    print(f"⚠️ Video {video_id}: age restricted")
+                    self._embed_cache[video_id] = False
+                    return False
+                
+                # Check if video is live (live streams might have issues)
+                if info.get('is_live'):
+                    print(f"ℹ️ Video {video_id}: live stream (may have embed issues)")
+                    # Allow live streams but note they might have issues
+                
+                # Check playability
+                playable_in_embed = info.get('playable_in_embed', True)
+                if playable_in_embed is False:
+                    print(f"⚠️ Video {video_id}: not playable in embed")
+                    self._embed_cache[video_id] = False
+                    return False
+                
+                print(f"✅ Video {video_id}: embeddable")
+                self._embed_cache[video_id] = True
+                return True
+                
+        except Exception as e:
+            error_msg = str(e).lower()
+            if 'unavailable' in error_msg or 'private' in error_msg or 'removed' in error_msg:
+                print(f"⚠️ Video {video_id}: unavailable - {e}")
+            else:
+                print(f"⚠️ Video {video_id}: check failed - {e}")
+            self._embed_cache[video_id] = False
+            return False
+        
+    def search_youtube_music(self, query: str, limit: int = 5, fast: bool = False, check_embed: bool = True) -> List[Dict[str, Any]]:
         """
         Search for free music on YouTube
         
@@ -33,6 +103,7 @@ class MusicMCPServer:
             query: Search query (e.g., "pop music", "jazz instrumental", "song name")
             limit: Number of results to fetch (will randomly select one)
             fast: If True, use flat extraction for faster results (less metadata)
+            check_embed: If True, verify videos are embeddable (recommended)
             
         Returns:
             List of track dictionaries with YouTube URLs
@@ -47,8 +118,8 @@ class MusicMCPServer:
                 'default_search': 'ytsearch',
             }
             
-            # Search for more results to allow random selection
-            search_limit = max(limit, 10)  # Get at least 10 for variety
+            # Search for more results to allow for filtering and random selection
+            search_limit = max(limit * 3, 15) if check_embed else max(limit, 10)
             
             with yt_dlp.YoutubeDL(ydl_opts) as ydl:
                 # Don't add "music" if query already contains it or is specific
@@ -84,10 +155,18 @@ class MusicMCPServer:
                     if len(valid_entries) > 1:
                         random.shuffle(valid_entries)
                     
-                    # Take requested limit from shuffled results
-                    for entry in valid_entries[:limit]:
+                    # Check embeddability and take requested limit
+                    for entry in valid_entries:
+                        if len(tracks) >= limit:
+                            break
+                            
                         video_id = entry.get('id') or entry.get('url', '')
                         if video_id:
+                            # Check if video is embeddable
+                            if check_embed and not self.check_video_embeddable(video_id):
+                                print(f"  ✗ Skipping non-embeddable: {entry.get('title', 'Unknown')}")
+                                continue
+                            
                             track = {
                                 "title": entry.get('title', 'Unknown'),
                                 "artist": entry.get('uploader', entry.get('channel', 'Unknown Artist')),
@@ -98,7 +177,7 @@ class MusicMCPServer:
                                 "source": "youtube"
                             }
                             tracks.append(track)
-                            print(f"  ✓ Found: {track['title']} by {track['artist']}")
+                            print(f"  ✓ Found embeddable: {track['title']} by {track['artist']}")
                             
         except Exception as e:
             print(f"❌ Error searching YouTube: {e}")

src/mcp_servers/podcast_server.py

@@ -17,6 +17,57 @@ class PodcastMCPServer:
     def __init__(self):
         self.name = "podcast_server"
         self.description = "Provides podcast recommendations from YouTube"
+        self._embed_cache = {}
+    
+    def check_video_embeddable(self, video_id: str) -> bool:
+        """Check if a YouTube video is embeddable"""
+        if video_id in self._embed_cache:
+            return self._embed_cache[video_id]
+        
+        if not YT_DLP_AVAILABLE:
+            return True  # Assume embeddable if we can't check
+        
+        try:
+            ydl_opts = {
+                'quiet': True,
+                'no_warnings': True,
+                'skip_download': True,
+            }
+            
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                url = f"https://www.youtube.com/watch?v={video_id}"
+                info = ydl.extract_info(url, download=False)
+                
+                if not info:
+                    self._embed_cache[video_id] = False
+                    return False
+                
+                # Check availability
+                availability = info.get('availability')
+                if availability and availability != 'public':
+                    print(f"⚠️ Podcast {video_id}: not public ({availability})")
+                    self._embed_cache[video_id] = False
+                    return False
+                
+                # Check age restriction
+                if info.get('age_limit', 0) > 0:
+                    print(f"⚠️ Podcast {video_id}: age restricted")
+                    self._embed_cache[video_id] = False
+                    return False
+                
+                # Check embed playability
+                if info.get('playable_in_embed') is False:
+                    print(f"⚠️ Podcast {video_id}: not playable in embed")
+                    self._embed_cache[video_id] = False
+                    return False
+                
+                self._embed_cache[video_id] = True
+                return True
+                
+        except Exception as e:
+            print(f"⚠️ Podcast {video_id}: check failed - {e}")
+            self._embed_cache[video_id] = False
+            return False
     
     def search_youtube_podcast(self, query: str, category: str = "technology", limit: int = 5) -> List[Dict[str, Any]]:
         """
@@ -58,18 +109,28 @@ class PodcastMCPServer:
                     print("❌ No podcast entries found")
                     return self._get_demo_podcasts(category, limit)
                 
-                # Filter and format results
+                # Filter and format results, checking embeddability
                 podcasts = []
+                random.shuffle(entries)  # Shuffle first for variety
+                
                 for entry in entries:
                     if entry is None:
                         continue
                     
+                    if len(podcasts) >= limit:
+                        break
+                    
                     video_id = entry.get('id', '')
                     title = entry.get('title', 'Unknown Podcast')
                     channel = entry.get('uploader', entry.get('channel', 'Unknown Host'))
                     duration = entry.get('duration', 0)
                     
                     if video_id:
+                        # Check if video is embeddable
+                        if not self.check_video_embeddable(video_id):
+                            print(f"  ✗ Skipping non-embeddable podcast: {title[:50]}")
+                            continue
+                        
                         podcasts.append({
                             "title": title,
                             "description": f"Podcast episode about {category}",
@@ -82,12 +143,11 @@ class PodcastMCPServer:
                             "youtube_id": video_id,
                             "url": f"https://www.youtube.com/watch?v={video_id}"
                         })
+                        print(f"  ✓ Found embeddable podcast: {title[:50]}")
                 
                 if podcasts:
-                    # Shuffle and return limited results
-                    random.shuffle(podcasts)
-                    print(f"✅ Found {len(podcasts)} podcasts on YouTube")
-                    return podcasts[:limit]
+                    print(f"✅ Found {len(podcasts)} embeddable podcasts on YouTube")
+                    return podcasts
                 else:
                     return self._get_demo_podcasts(category, limit)