Update app.py

app.py

@@ -1,3 +1,5 @@
+# Environment variable for API key
+API_KEY = os.getenv("GEMINI_API_KEY", "")
 """Real-Time Screen Assistant - Premium Edition with Complete Frontend Integration
 
 This is the PREMIUM, BEST WORKING version with comprehensive real-time handlers:
@@ -17,6 +19,22 @@ Features:
 - 300s timeout for real-time behavior
 """
 
+import asyncio
+import os
+import time
+import sys
+from collections import deque
+
+import cv2
+import gradio as gr
+import numpy as np
+import numpy.typing as npt
+from fastrtc import AsyncAudioVideoStreamHandler, ReplyOnPause, Stream, get_cloudflare_turn_credentials_async
+from google import genai
+from google.genai import types
+from gradio.events import Dependency
+
+
 import asyncio
 import os
 import time
@@ -38,6 +56,9 @@ import tempfile
 import os
 import json
 
+# Environment variable for API key
+API_KEY = os.getenv("GEMINI_API_KEY", "")
+
 class ScreenRecorderData(GradioModel):
     video: Optional[FileData] = None
     duration: Optional[float] = None
@@ -302,8 +323,7 @@ class ScreenRecorder(Component):
     def get_status(self) -> str:
         """Get the current status of the recorder."""
         return self._status
-# Environment variable for API key
-API_KEY = os.getenv("GEMINI_API_KEY", "")
+
 
 class RealTimeScreenAssistant(AsyncAudioVideoStreamHandler):
     """Premium Real-time screen assistant with complete frontend integration.
@@ -628,19 +648,39 @@ def initialize_real_time_assistant():
         handler = RealTimeScreenAssistant()
         app_state["handler"] = handler
 
-        # PREMIUM: Enhanced stream configuration
-        stream = Stream(
-            handler=ReplyOnPause(handler),  # Voice activity detection
-            modality="audio-video",
-            mode="send-receive",
-            rtc_configuration=get_cloudflare_turn_credentials_async,
-            time_limit=300,  # 5 minutes - real-time optimized
-            ui_args={
-                "title": "Premium Real-Time Assistant",
-                "subtitle": "Audio-Video Streaming with Gemini 2.0",
-                "hide_title": False
-            }
-        )
+        # PREMIUM: Enhanced stream configuration with fallback
+        try:
+            # Try with ReplyOnPause (requires fastrtc[vad])
+            stream = Stream(
+                handler=ReplyOnPause(handler),  # Voice activity detection
+                modality="audio-video",
+                mode="send-receive",
+                rtc_configuration=get_cloudflare_turn_credentials_async,
+                time_limit=300,  # 5 minutes - real-time optimized
+                ui_args={
+                    "title": "Premium Real-Time Assistant",
+                    "subtitle": "Audio-Video Streaming with Gemini 2.0",
+                    "hide_title": False
+                }
+            )
+            print("✅ Stream created with ReplyOnPause (VAD enabled)")
+        except Exception as vad_error:
+            print(f"⚠️ ReplyOnPause failed: {vad_error}")
+            print("🔄 Falling back to basic handler...")
+            # Fallback to basic handler without VAD
+            stream = Stream(
+                handler=handler,  # Direct handler without VAD
+                modality="audio-video",
+                mode="send-receive",
+                rtc_configuration=get_cloudflare_turn_credentials_async,
+                time_limit=300,
+                ui_args={
+                    "title": "Real-Time Assistant (Basic)",
+                    "subtitle": "Audio-Video Streaming with Gemini 2.0",
+                    "hide_title": False
+                }
+            )
+            print("✅ Stream created with basic handler")
 
         app_state["stream"] = stream
         return stream
@@ -672,11 +712,28 @@ async def handle_connect_async():
 
 def handle_connect():
     """Sync wrapper for connection"""
+    import threading
+
     app_state["connected"] = True  # Optimistic update for UI
     app_state["last_status"] = "Initiating connection..."
 
-    # Start async connection
-    asyncio.create_task(handle_connect_async())
+    # Start async connection in a separate thread to avoid event loop issues
+    def run_async_connection():
+        try:
+            import asyncio
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            result = loop.run_until_complete(handle_connect_async())
+            print(f"Connection result: {result}")
+            loop.close()
+        except Exception as e:
+            print(f"Connection error: {e}")
+            app_state["connected"] = False
+            app_state["last_status"] = f"Connection failed: {e}"
+
+    thread = threading.Thread(target=run_async_connection, daemon=True)
+    thread.start()
+
     return "🔄 Initiating connection to GenAI Live API..."
 
 async def handle_disconnect_async():
@@ -694,10 +751,25 @@ async def handle_disconnect_async():
 
 def handle_disconnect():
     """Sync wrapper for disconnect"""
+    import threading
+
     app_state["connected"] = False  # Immediate update for UI
 
-    # Start async disconnect
-    asyncio.create_task(handle_disconnect_async())
+    # Start async disconnect in a separate thread to avoid event loop issues
+    def run_async_disconnect():
+        try:
+            import asyncio
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            result = loop.run_until_complete(handle_disconnect_async())
+            print(f"Disconnect result: {result}")
+            loop.close()
+        except Exception as e:
+            print(f"Disconnect error: {e}")
+
+    thread = threading.Thread(target=run_async_disconnect, daemon=True)
+    thread.start()
+
     return "🔄 Disconnecting from AI assistant..."
 
 def get_connection_status():
@@ -834,7 +906,7 @@ def create_interface():
                 """Handle screen recording data and send to AI"""
                 if not recording_data or not app_state["handler"] or not app_state["connected"]:
                     return "⚠️ Not connected to AI or no recording data"
-                
+
                 try:
                     # If we have video data, process it for the AI
                     if recording_data and recording_data.get('video'):
@@ -843,14 +915,14 @@ def create_interface():
                         duration = recording_data.get('duration', 0)
                         size = recording_data.get('size', 0)
                         print(f"📹 Screen recording received: {duration}s, {size} bytes")
-                        
+
                         # Update stats
                         app_state["stats"]["frames_sent"] += 1
-                        
+
                         return f"✅ Screen recording processed: {duration:.1f}s"
                     else:
                         return "⚠️ No video data in recording"
-                        
+
                 except Exception as e:
                     print(f"❌ Error processing screen recording: {e}")
                     return f"❌ Error: {e}"