Update app.py

app.py

@@ -1,572 +1,193 @@
-# Environment variable for API key
-
-"""Real-Time Screen Assistant - Premium Edition with Complete Frontend Integration
-
-This is the PREMIUM, BEST WORKING version with comprehensive real-time handlers:
-1. Continuous audio flow from user → model
-2. Model audio output → user
-3. Screen data streaming → model
-4. Text responses from system → user
-
-Features:
-- Google GenAI Live API integration with enhanced configuration
-- Real-time audio/video streaming via FastRTC
-- Voice activity detection with intelligent filtering
-- Continuous screen capture with adaptive throttling
-- AI response delivery system (audio + text)
-- Background task management with proper cleanup
-- Enhanced error handling and recovery
-- 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
-import sys
-from collections import deque
-
+import numpy as np
 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 fastrtc import Stream, AsyncAudioVideoStreamHandler, get_cloudflare_turn_credentials_async, ReplyOnPause
 from google import genai
 from google.genai import types
-import gradio as gr
-from gradio.components.base import Component
-from gradio.data_classes import FileData, GradioModel
-from typing import Optional, Literal, Any
-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
-    audio_enabled: bool = True
-    status: Literal["recording", "stopped", "error"] = "stopped"
-
-    class Config:
-        json_encoders = {
-            FileData: lambda v: v.model_dump() if v else None
-        }
-
-
-class ScreenRecorder(Component):
-    """
-    Custom Gradio component for comprehensive screen recording functionality.
-    """
-    
-    data_model = ScreenRecorderData
-    
-    EVENTS = [
-        "record_start",
-        "record_stop", 
-        "stream_update",
-        "change"
-    ]
-    
-    def __init__(
-        self,
-        value=None,
-        audio_enabled: bool = True,
-        webcam_overlay: bool = False,
-        webcam_position: Literal["top-left", "top-right", "bottom-left", "bottom-right"] = "bottom-right",
-        recording_format: str = "webm",
-        max_duration: Optional[int] = None,
-        interactive: bool = True,
-        **kwargs
-    ):
-        self.audio_enabled = audio_enabled
-        self.webcam_overlay = webcam_overlay
-        self.webcam_position = webcam_position
-        self.recording_format = recording_format
-        self.max_duration = max_duration
-        self._status = "stopped"
-        
-        super().__init__(
-            value=value,
-            interactive=interactive,
-            **kwargs
-        )
-    
-    def example_payload(self) -> dict:
-        """
-        The example inputs for this component for API usage. Must be JSON-serializable.
-        """
-        return {
-            "video": {
-                "path": "https://sample-videos.com/zip/10/mp4/SampleVideo_360x240_1mb.mp4",
-                "orig_name": "example_recording.webm",
-                "size": 1024000
-            },
-            "duration": 30.5,
-            "audio_enabled": True,
-            "status": "stopped"
-        }
-    
-    def example_value(self) -> ScreenRecorderData:
-        """
-        An example value for this component for the default app.
-        """
-        return ScreenRecorderData(
-            video=FileData(
-                path="https://sample-videos.com/zip/10/mp4/SampleVideo_360x240_1mb.mp4",
-                orig_name="example_recording.webm", 
-                size=1024000
-            ),
-            duration=30.5,
-            audio_enabled=True,
-            status="stopped"
-        )
-    
-    def flag(self, x, flag_dir: str = "") -> str:
-        """
-        Write the component's value to a format for flagging (CSV storage).
-        """
-        if x is None:
-            return ""
-        
-        if isinstance(x, ScreenRecorderData) and x.video:
-            return f"Recording: {x.video.orig_name} ({x.duration}s) - Status: {x.status}"
-        
-        if isinstance(x, dict) and "video" in x:
-            duration = x.get("duration", "unknown")
-            status = x.get("status", "unknown")
-            video_name = x["video"].get("orig_name", "unknown") if x["video"] else "none"
-            return f"Recording: {video_name} ({duration}s) - Status: {status}"
-        
-        return str(x)
-    
-    def preprocess(self, payload) -> Optional[ScreenRecorderData]:
-        """Process incoming recording data from frontend."""
-        if payload is None:
-            return None
-
-        if isinstance(payload, dict):
-            if payload.get("status") == "error": # Early exit for errors from frontend
-                raise gr.Error(f"Recording failed on frontend: {payload.get('error', 'Unknown error')}")
-
-            # If 'video' field is a string, assume it's JSON and parse it.
-            if "video" in payload and isinstance(payload["video"], str):
-                try:
-                    video_json_string = payload["video"]
-                    if video_json_string.strip().startswith("{") and video_json_string.strip().endswith("}"):
-                        payload["video"] = json.loads(video_json_string)
-                    # If it's a string but not our expected JSON (e.g. 'null', or empty string, or simple path)
-                    # json.loads would fail or Pydantic validation later will catch it if structure is wrong.
-                    # For 'null' string, json.loads results in None for payload["video"].
-                    elif video_json_string.lower() == 'null':
-                        payload["video"] = None
-                    else:
-                        # This case implies a string that isn't a JSON object or 'null',
-                        # e.g. a direct file path string, which FileData might not directly accept
-                        # if it expects a dict. Pydantic will raise error later if type is incompatible.
-                        gr.Warning(f"Video data is a string but not a recognized JSON object or 'null': {video_json_string[:100]}")
-                        # To be safe, if it's not a JSON object string, we might want to error or handle specifically
-                        # For now, let Pydantic try to handle it or fail.
-
-                except json.JSONDecodeError:
-                    raise gr.Error(f"Invalid JSON for video data: {payload['video'][:100]}")
-
-            # --- Validations from here --- 
-            video_data = payload.get("video") # Use .get() for safety, as 'video' might be absent or None
-
-            if video_data is not None: # Only validate video_data if it exists
-                if not isinstance(video_data, dict):
-                    # This can happen if payload["video"] was a string like "some_path.webm" and not parsed to dict
-                    # Or if it was parsed to something unexpected.
-                    raise gr.Error(f"Video data is not a dictionary after processing: {type(video_data)}. Value: {str(video_data)[:100]}")
-                
-                if video_data.get("size", 0) == 0:
-                    gr.Warning("Received recording with zero size. This might be an empty recording or an issue with data capture.")
-                    # Depending on requirements, could raise gr.Error here.
-
-                max_size = 500 * 1024 * 1024  # 500MB
-                if video_data.get("size", 0) > max_size:
-                    raise gr.Error(f"Recording file too large ({video_data.get('size', 0)} bytes). Maximum allowed: {max_size} bytes.")
-            # If video_data is None (e.g. 'video': null was sent, or 'video' key missing), 
-            # ScreenRecorderData will have video=None, which is allowed by Optional[FileData].
-            
-            duration = payload.get("duration", 0)
-            if duration <= 0 and video_data is not None: # Only warn about duration if there's video data
-                gr.Warning("Recording duration is 0 or invalid. The recording might be corrupted.")
-            
-            try:
-                return ScreenRecorderData(**payload)
-            except Exception as e: # Catch Pydantic validation errors or other issues during model instantiation
-                # Log the payload for easier debugging if there's a Pydantic error
-                # Be careful with logging sensitive data in production.
-                # print(f"Error creating ScreenRecorderData. Payload: {payload}")
-                raise gr.Error(f"Error creating ScreenRecorderData from payload: {e}")
-
-        elif isinstance(payload, ScreenRecorderData): # If it's already the correct type
-            return payload
-        
-        gr.Warning(f"Unexpected payload format: {type(payload)}. Payload: {str(payload)[:200]}")
-        return None
-    
-    # def postprocess(self, value) -> Optional[dict]:
-    #     """Process outgoing data to frontend."""
-    #     if value is None:
-    #         return {"status": "stopped"}  # Ensure valid empty state
-
-    #     try:
-    #         if isinstance(value, ScreenRecorderData):
-    #             return value.model_dump()
-    #         elif isinstance(value, dict):
-    #             return value
-    #         return None
-    #     except Exception as e:
-    #         return {"status": "error", "error": str(e)}
-
-
-    def postprocess(self, value) -> Optional[dict]:
-        """Process outgoing data to frontend."""
-        print(f'value in postprocess: {value}')
-        if value is None:
-            return None
-            
-        try:
-            # If it's already a dict, return as is
-            if isinstance(value, dict):
-                return value
-                
-            # If it's a ScreenRecorderData object, convert to dict
-            if hasattr(value, 'model_dump'):
-                return value.model_dump()
-                
-            # Handle string values
-            if isinstance(value, str):
-                return {"video": {"path": value}}
-                
-            return None
-            
-        except Exception as e:
-            print(f'Error in postprocess: {e}')
-            return None
-
-
-        # try:
-        #     if isinstance(value, ScreenRecorderData):
-        #         # Ensure video data exists before sending
-        #         if not value.video:
-        #             return {"status": "error", "error": "No video recorded"}
-                
-        #         return {
-        #             "video": value.video,
-        #             "duration": value.duration,
-        #             "audio_enabled": value.audio_enabled,
-        #             "status": value.status
-        #         }
-            
-        #     # Handle raw dict format from frontend
-        #     if isinstance(value, dict):
-        #         return {
-        #             "video": FileData(**value.get("video", {})),
-        #             "duration": value.get("duration"),
-        #             "audio_enabled": value.get("audio_enabled", True),
-        #             "status": value.get("status", "stopped")
-        #         }
-        
-        # except Exception as e:
-        #     return {"status": "error", "error": str(e)}
-        
-        # return {"status": "stopped"}
-
-    def as_example(self, input_data):
-        """Handle example data display."""
-        if input_data is None:
-            return None
-        
-        if isinstance(input_data, (ScreenRecorderData, dict)):
-            return input_data
-        
-        # Convert simple video path to proper format
-        if isinstance(input_data, str):
-            return {
-                "video": {
-                    "path": input_data,
-                    "orig_name": os.path.basename(input_data),
-                    "size": 0
-                },
-                "duration": None,
-                "audio_enabled": self.audio_enabled,
-                "status": "stopped"
-            }
-        
-        return input_data
-
-    def update_status(self, status: Literal["recording", "stopped", "error"]):
-        """Update the internal status of the recorder."""
-        self._status = status
-        
-    def get_status(self) -> str:
-        """Get the current status of the recorder."""
-        return self._status
-
 
-class RealTimeScreenAssistant(AsyncAudioVideoStreamHandler):
-    """Premium Real-time screen assistant with complete frontend integration.
-
-    Real-time Frontend Integration Features:
-    - Continuous audio streaming with voice activity detection
-    - Real-time screen capture with intelligent throttling
-    - AI audio response processing and delivery
-    - Text response handling and display
-    - Background task management
-    - Enhanced error recovery
-    """
+class EnhancedScreenAssistantHandler(AsyncAudioVideoStreamHandler):
+    """Enhanced real-time screen assistant with voice activity detection"""
 
     def __init__(self):
-        super().__init__(
-            expected_layout="mono",
-            output_sample_rate=24000,
-            input_sample_rate=16000
-        )
+        super().__init__(input_audio_type="mono", output_sample_rate=24000, input_sample_rate=16000)
         self.session = None
         self.last_frame_time = 0
         self.audio_queue = asyncio.Queue()
         self.text_queue = asyncio.Queue()
         self.connected = False
-        self.frame_interval = 1.0  # Adaptive frame interval
-
-        # Enhanced features for premium version
-        self.conversation_history = deque(maxlen=20)  # Keep last 20 exchanges
-        self.background_tasks = set()  # Track background tasks
-        self.voice_activity_threshold = 0.01  # Voice activity detection threshold
-        self.consecutive_silent_frames = 0
-        self.max_silent_frames = 10  # Filter out silence
-
-        # Performance optimization
-        self.last_audio_level = 0.0
-        self.frame_skip_counter = 0
-        self.adaptive_quality = True
+        self.frame_interval = 1.0  # Send one frame per second
+        self.conversation_history = []
 
     async def start_up(self):
-        """Enhanced startup with premium configuration"""
+        """Initialize Google GenAI Live session with enhanced configuration"""
         try:
-            current_api_key = os.getenv("GEMINI_API_KEY", "")
-            if not current_api_key:
+            if not API_KEY:
                 print("❌ No GEMINI_API_KEY found in environment")
                 return
 
-            # Initialize client with premium configuration
-            client = genai.Client(
-                api_key=current_api_key,
-                http_options={"api_version": "v1alpha"}
-            )
+            # Initialize Google GenAI client with alpha API access
+            client = genai.Client(api_key=API_KEY, http_options={"api_version": "v1alpha"})
 
-            # PREMIUM: Enhanced configuration with all features enabled
+            # Enhanced configuration for live session
             config = {
                 "response_modalities": ["AUDIO", "TEXT"],
                 "input_audio_transcription": {"model": "latest"},
                 "output_audio_transcription": {"model": "latest"},
-                "system_instruction": {
-                    "parts": [{
-                        "text": (
-                            "You are an expert real-time screen assistant with premium capabilities. "
-                            "You can see the user's screen continuously and hear their voice in real-time. "
-                            "Provide intelligent, proactive assistance based on what you observe. "
-                            "Give clear, actionable guidance for software usage, coding, troubleshooting, "
-                            "and any tasks you see the user working on. Be concise but comprehensive. "
-                            "Respond with both voice and text when helpful."
-                        )
-                    }]
-                },
-                "generation_config": {
-                    "response_mime_type": "text/plain",
-                    "temperature": 0.7,
-                    "max_output_tokens": 512
-                }
+                "system_instruction": (
+                    "You are an expert real-time screen assistant. You can see the user's screen "
+                    "and hear their voice. Provide clear, actionable guidance based on what you observe. "
+                    "Be proactive - if you see the user struggling or notice something important, "
+                    "offer helpful suggestions even without being asked. Keep responses concise but thorough. "
+                    "When giving instructions, be specific about what to click, where to look, "
+                    "and what to expect next."
+                ),
+                "generation_config": {"response_mime_type": "text/plain", "temperature": 0.7, "max_output_tokens": 512},
             }
 
-            # Connect with enhanced configuration
-            self.session = await client.aio.live.connect(
-                model="gemini-2.0-flash-live-preview",
-                config=config
-            )
+            # Connect to Live API
+            self.session = await client.aio.live.connect(model="gemini-2.0-flash-live-preview", config=config)
 
             self.connected = True
-            print("✅ Connected to Google GenAI Live API (Premium Mode)")
+            print("✅ Connected to Google GenAI Live API with enhanced configuration")
 
-            # Start enhanced response handler
+            # Start background tasks with proper management
+            self.background_tasks = set()
             response_task = asyncio.create_task(self._handle_responses())
+            context_task = asyncio.create_task(self._periodic_context_update())
             self.background_tasks.add(response_task)
+            self.background_tasks.add(context_task)
             response_task.add_done_callback(self.background_tasks.discard)
+            context_task.add_done_callback(self.background_tasks.discard)
 
         except Exception as e:
             print(f"❌ Failed to connect to GenAI: {e}")
             self.connected = False
 
     async def _handle_responses(self):
-        """Enhanced response handler with conversation history"""
+        """Handle incoming responses from AI with enhanced processing"""
         try:
-            async for response in self.session.receive():
-                if not self.connected:
-                    break
+            current_text = ""
 
-                try:
-                    # Handle audio responses (premium feature)
-                    if hasattr(response, 'data') and response.data:
-                        audio_array = np.frombuffer(response.data, dtype=np.int16)
-                        if len(audio_array) > 0:
-                            audio_array = audio_array.reshape(1, -1)
-                            await self.audio_queue.put(audio_array)
-
-                    # Handle text responses with conversation history
-                    if hasattr(response, 'text') and response.text:
-                        print(f"🤖 AI: {response.text}")
-
-                        # Add to conversation history
-                        self.conversation_history.append({
-                            "timestamp": time.time(),
-                            "type": "ai_response",
-                            "content": response.text
-                        })
-
-                        # Queue for frontend delivery
-                        await self.text_queue.put(response.text)
-
-                    # Handle structured responses (premium)
-                    if hasattr(response, 'server_content') and response.server_content:
-                        if hasattr(response.server_content, 'model_turn'):
-                            model_turn = response.server_content.model_turn
-                            if hasattr(model_turn, 'parts'):
-                                for part in model_turn.parts:
-                                    if hasattr(part, 'text') and part.text:
-                                        print(f"🤖 AI: {part.text}")
-                                        await self.text_queue.put(part.text)
+            async for msg in self.session.receive():
+                if msg.data:  # Audio response from AI
+                    # Convert raw PCM bytes to numpy array for FastRTC
+                    audio_array = np.frombuffer(msg.data, dtype=np.int16)
+                    if len(audio_array) > 0:
+                        audio_array = audio_array.reshape(1, -1)  # Shape: (1, N)
+                        await self.audio_queue.put(audio_array)
 
-                except Exception as e:
-                    print(f"⚠️ Response processing error: {e}")
+                if msg.text:  # Text response from AI
+                    current_text += msg.text
+                    print(f"🤖 AI: {msg.text}")
+
+                    # Add to conversation history when response is complete
+                    if msg.text.endswith((".", "!", "?", "\n")):
+                        self.conversation_history.append({"role": "assistant", "content": current_text.strip(), "timestamp": time.time()})
+                        current_text = ""
+
+                        # Keep conversation history manageable
+                        if len(self.conversation_history) > 20:
+                            self.conversation_history = self.conversation_history[-15:]
+
+                    await self.text_queue.put(msg.text)
 
         except Exception as e:
-            print(f"❌ Response handler error: {e}")
+            print(f"❌ Error handling AI responses: {e}")
 
-    async def receive(self, frame: tuple[int, npt.NDArray[np.int16]]):
-        """PREMIUM: Enhanced audio processing with voice activity detection"""
+    async def _periodic_context_update(self):
+        """Periodically send context updates to maintain session state"""
+        while self.connected:
+            await asyncio.sleep(30)  # Update every 30 seconds
+
+            if self.session and len(self.conversation_history) > 0:
+                try:
+                    # Send a subtle context maintenance message
+                    context_msg = "Continue monitoring and providing assistance as needed."
+                    await self.session.send_realtime_input(text=context_msg)
+                except Exception as e:
+                    print(f"⚠️  Context update failed: {e}")
+
+    async def receive(self, frame: tuple[int, np.ndarray]):
+        """Handle incoming audio with voice activity detection"""
         if not self.connected or not self.session:
             return
 
         try:
             _, audio_np = frame
 
-            # PREMIUM: Voice activity detection
-            audio_level = np.abs(audio_np.astype(np.float32)).mean()
-            self.last_audio_level = audio_level
+            # Basic voice activity detection
+            audio_level = np.abs(audio_np).mean()
+            if audio_level > 0.01:  # Threshold for voice activity
+                audio_bytes = audio_np.tobytes()
 
-            # Filter out silence and background noise
-            if audio_level < self.voice_activity_threshold:
-                self.consecutive_silent_frames += 1
-                if self.consecutive_silent_frames < self.max_silent_frames:
-                    return  # Skip silent frames
-            else:
-                self.consecutive_silent_frames = 0
-
-            # Convert and send audio
-            audio_bytes = audio_np.tobytes()
-
-            # PREMIUM: Send with metadata
-            await self.session.send_realtime_input(
-                input=types.Blob(
-                    data=audio_bytes,
-                    mime_type="audio/pcm;rate=16000"
-                )
-            )
-
-            # Track user interaction
-            self.conversation_history.append({
-                "timestamp": time.time(),
-                "type": "user_audio",
-                "audio_level": float(audio_level)
-            })
+                # Send audio to Google GenAI Live API
+                await self.session.send_realtime_input(media=types.Blob(data=audio_bytes, mime_type="audio/pcm;rate=16000"))
 
         except Exception as e:
-            print(f"❌ Error sending audio: {e}")
+            print(f"❌ Error processing audio: {e}")
 
-    async def video_receive(self, frame: npt.NDArray[np.float32]):
-        """PREMIUM: Enhanced screen capture with adaptive throttling"""
+    async def video_receive(self, frame: np.ndarray):
+        """Handle incoming video frames with intelligent frame selection"""
         if not self.connected or not self.session:
             return
 
         try:
-            # PREMIUM: Adaptive frame throttling based on activity
             current_time = time.time()
 
-            # Adaptive interval based on user activity
-            if hasattr(self, 'last_audio_level') and self.last_audio_level > 0.05:
-                # More frequent updates during active conversation
-                adaptive_interval = self.frame_interval * 0.5
+            # Adaptive frame rate based on activity
+            # Send frames more frequently if there's likely activity
+            frame_diff_threshold = 0.1
+            if hasattr(self, "last_frame"):
+                frame_diff = np.abs(frame.astype(float) - self.last_frame.astype(float)).mean()
+                if frame_diff > frame_diff_threshold:
+                    # More activity detected, reduce interval
+                    effective_interval = self.frame_interval * 0.5
+                else:
+                    effective_interval = self.frame_interval
             else:
-                # Standard interval during quiet periods
-                adaptive_interval = self.frame_interval
+                effective_interval = self.frame_interval
 
-            if current_time - self.last_frame_time < adaptive_interval:
+            if current_time - self.last_frame_time < effective_interval:
                 return
 
             self.last_frame_time = current_time
+            self.last_frame = frame.copy()
+
+            # Resize frame for efficiency while maintaining quality
+            height, width = frame.shape[:2]
+            if width > 1280:
+                scale = 1280 / width
+                new_width = 1280
+                new_height = int(height * scale)
+                frame = cv2.resize(frame, (new_width, new_height), interpolation=cv2.INTER_AREA)
+
+            # Encode frame as JPEG with optimized quality
+            success, jpg_bytes = cv2.imencode(
+                ".jpg",
+                frame,
+                [cv2.IMWRITE_JPEG_QUALITY, 75],  # Balanced quality/size
+            )
 
-            # PREMIUM: Enhanced frame processing
-            if frame.dtype == np.float32:
-                frame_uint8 = (frame * 255).astype(np.uint8)
-            else:
-                frame_uint8 = frame.astype(np.uint8)
-
-            # Validate frame
-            if frame_uint8.size == 0 or frame_uint8.shape[0] == 0 or frame_uint8.shape[1] == 0:
-                return
-
-            # PREMIUM: Adaptive quality encoding
-            quality = 85 if self.adaptive_quality and self.last_audio_level > 0.02 else 75
-
-            try:
-                success, jpg_bytes = cv2.imencode('.jpg', frame_uint8, [cv2.IMWRITE_JPEG_QUALITY, quality])
-                if not success:
-                    return
-            except cv2.error:
+            if not success:
                 return
 
-            # Send enhanced frame data
-            await self.session.send_realtime_input(
-                input=types.Blob(
-                    data=jpg_bytes.tobytes(),
-                    mime_type="image/jpeg"
-                )
-            )
+            # Send frame to Google GenAI
+            await self.session.send_realtime_input(media=types.Blob(data=jpg_bytes.tobytes(), mime_type="image/jpeg"))
 
-            # Track screen activity
-            self.conversation_history.append({
-                "timestamp": time.time(),
-                "type": "screen_frame",
-                "quality": quality,
-                "size": len(jpg_bytes)
-            })
+            print(f"📸 Sent frame ({frame.shape[1]}x{frame.shape[0]}, {len(jpg_bytes)} bytes)")
 
         except Exception as e:
-            print(f"❌ Error sending video frame: {e}")
+            print(f"❌ Error processing video frame: {e}")
 
     async def emit(self):
-        """PREMIUM: Enhanced audio emission with queue management"""
+        """Provide audio output back to user with queue management"""
         try:
             audio_chunk = self.audio_queue.get_nowait()
             return (24000, audio_chunk)
@@ -574,40 +195,42 @@ class RealTimeScreenAssistant(AsyncAudioVideoStreamHandler):
             return None
 
     async def get_latest_text(self):
-        """PREMIUM: Get latest text response from AI"""
+        """Get latest text response for UI updates"""
         try:
             text = self.text_queue.get_nowait()
             return text
         except asyncio.QueueEmpty:
             return None
 
-    def copy(self):
-        """Enhanced copy method with state preservation"""
-        new_instance = RealTimeScreenAssistant()
-        new_instance.frame_interval = self.frame_interval
-        new_instance.voice_activity_threshold = self.voice_activity_threshold
-        new_instance.adaptive_quality = self.adaptive_quality
-        return new_instance
-
-    async def video_emit(self):
-        """Video emit method for FastRTC compatibility"""
-        return None
-
     async def shutdown(self):
-        """PREMIUM: Enhanced shutdown with complete cleanup"""
+        """Enhanced cleanup with proper resource management"""
         self.connected = False
 
-        # Cancel all background tasks
-        for task in self.background_tasks.copy():
-            if not task.done():
-                task.cancel()
+        if self.session:
+            try:
+                # Send goodbye message
+                await self.session.send_realtime_input(text="Session ending. Thank you!")
+
+                await asyncio.sleep(0.5)  # Brief delay for message to send
+                await self.session.close()
+                print("🔴 Cleanly disconnected from GenAI Live API")
 
-        # Wait for task cleanup
-        if self.background_tasks:
-            await asyncio.gather(*self.background_tasks, return_exceptions=True)
-        self.background_tasks.clear()
+            except Exception as e:
+                print(f"⚠️  Error during shutdown: {e}")
 
-        # Clean up queues
+        # Cancel all background tasks properly
+        if hasattr(self, "background_tasks"):
+            for task in self.background_tasks.copy():
+                if not task.done():
+                    task.cancel()
+
+            # Wait for all tasks to complete or be cancelled
+            if self.background_tasks:
+                await asyncio.gather(*self.background_tasks, return_exceptions=True)
+
+            self.background_tasks.clear()
+
+        # Clear queues
         while not self.audio_queue.empty():
             try:
                 self.audio_queue.get_nowait()
@@ -620,453 +243,260 @@ class RealTimeScreenAssistant(AsyncAudioVideoStreamHandler):
             except asyncio.QueueEmpty:
                 break
 
-        # Clear conversation history
-        self.conversation_history.clear()
+        self.session = None
+        self.conversation_history = []
 
-        # Close session
-        if self.session:
-            try:
-                await self.session.close()
-                print("🔴 Disconnected from GenAI Live API")
-            except Exception as e:
-                print(f"❌ Error during shutdown: {e}")
 
-        self.session = None
+# Global state management
+app_state = {"stream": None, "handler": None, "connected": False, "screen_sharing": False}
 
-# Global state for premium app
-app_state = {
-    "stream": None,
-    "handler": None,
-    "connected": False,
-    "last_status": "Ready to connect",
-    "stats": {"audio_sent": 0, "frames_sent": 0, "responses_received": 0}
-}
 
-def initialize_real_time_assistant():
-    """PREMIUM: Enhanced stream initialization"""
+def initialize_stream():
+    """Initialize the FastRTC stream with enhanced configuration"""
     try:
-        handler = RealTimeScreenAssistant()
+        # Create enhanced handler
+        handler = EnhancedScreenAssistantHandler()
         app_state["handler"] = handler
 
-        # 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")
+        # Create stream with optimized settings for HF Spaces
+        stream = Stream(
+            handler=ReplyOnPause(handler),  # Add voice activity detection
+            modality="audio-video",
+            mode="send-receive",
+            rtc_configuration=get_cloudflare_turn_credentials_async,
+            time_limit=600,  # 10 minute session limit
+            ui_args={
+                "audio_controls": True,
+                "video_controls": True,
+            },
+        )
 
         app_state["stream"] = stream
         return stream
 
     except Exception as e:
-        print(f"❌ Error creating stream: {e}")
+        print(f"❌ Error initializing stream: {e}")
         return None
 
-async def handle_connect_async():
-    """PREMIUM: Enhanced async connection handler"""
-    current_api_key = os.getenv("GEMINI_API_KEY", "")
-    if not current_api_key:
+
+def handle_connect():
+    """Enhanced connection handler"""
+    if not API_KEY:
         return "❌ Please set GEMINI_API_KEY environment variable"
 
     if app_state["connected"]:
         return "✅ Already connected - session is active"
 
-    try:
-        if app_state["handler"]:
-            await app_state["handler"].start_up()
-            app_state["connected"] = True
-            app_state["last_status"] = "Connected to GenAI Live API"
-            return "✅ Connected to GenAI Live API - Ready for real-time interaction!"
-        else:
-            return "❌ Handler not initialized"
-    except Exception as e:
-        app_state["connected"] = False
-        return f"❌ Connection failed: {str(e)}"
+    if app_state["handler"]:
+        app_state["connected"] = True
+        return "✅ Connecting to AI... Please allow microphone and camera permissions"
 
-def handle_connect():
-    """Sync wrapper for connection"""
-    import threading
+    return "❌ Stream not initialized - please refresh the page"
 
-    app_state["connected"] = True  # Optimistic update for UI
-    app_state["last_status"] = "Initiating connection..."
 
-    # 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}"
+def handle_screen_share():
+    """Handle screen sharing toggle"""
+    app_state["screen_sharing"] = not app_state["screen_sharing"]
 
-    thread = threading.Thread(target=run_async_connection, daemon=True)
-    thread.start()
+    if app_state["screen_sharing"]:
+        return "🖥️ Screen sharing started - AI can now see your screen"
+    else:
+        return "📱 Switched back to camera view"
 
-    return "🔄 Initiating connection to GenAI Live API..."
 
 async def handle_disconnect_async():
-    """PREMIUM: Enhanced async disconnect handler"""
+    """Async enhanced disconnection handler"""
     if app_state["handler"] and app_state["connected"]:
         try:
             await app_state["handler"].shutdown()
             app_state["connected"] = False
+            app_state["screen_sharing"] = False
             app_state["handler"] = None
-            app_state["last_status"] = "Disconnected"
             return "🔴 Disconnected from AI assistant"
         except Exception as e:
-            return f"❌ Error during disconnect: {str(e)}"
-    return "Already disconnected"
+            return f"⚠️ Disconnect error: {e}"
 
-def handle_disconnect():
-    """Sync wrapper for disconnect"""
-    import threading
+    return "Already disconnected"
 
-    app_state["connected"] = False  # Immediate update for UI
 
-    # 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}")
+def handle_disconnect():
+    """Sync wrapper for enhanced disconnection handler"""
+    # Create task and store reference for proper cleanup
+    if not hasattr(app_state, "disconnect_task") or app_state.get("disconnect_task", {}).done():
+        import asyncio
+
+        app_state["disconnect_task"] = asyncio.create_task(handle_disconnect_async())
+        app_state["connected"] = False  # Immediately mark as disconnected
+        app_state["screen_sharing"] = False
+
+    return "🔄 Disconnecting... Please wait..."
+
+
+# Enhanced JavaScript for screen sharing
+enhanced_screen_share_js = """
+async function toggleScreenShare() {
+    try {
+        const videoElements = document.querySelectorAll('video');
+        const webrtcVideo = Array.from(videoElements).find(video => 
+            video.srcObject && video.srcObject.getVideoTracks().length > 0
+        );
+        
+        if (!webrtcVideo) {
+            return "❌ Could not find video element";
+        }
+        
+        const currentTrack = webrtcVideo.srcObject.getVideoTracks()[0];
+        const isScreenShare = currentTrack && currentTrack.label.includes('screen');
+        
+        if (isScreenShare) {
+            // Switch back to camera
+            const cameraStream = await navigator.mediaDevices.getUserMedia({
+                video: { width: 640, height: 480 },
+                audio: false
+            });
+            
+            const videoTrack = cameraStream.getVideoTracks()[0];
+            webrtcVideo.srcObject.removeTrack(currentTrack);
+            webrtcVideo.srcObject.addTrack(videoTrack);
+            
+            currentTrack.stop();
+            return "📱 Switched to camera view";
+            
+        } else {
+            // Switch to screen share
+            const screenStream = await navigator.mediaDevices.getDisplayMedia({
+                video: {
+                    mediaSource: 'screen',
+                    width: { ideal: 1280, max: 1920 },
+                    height: { ideal: 720, max: 1080 },
+                    frameRate: { ideal: 2, max: 5 }  // Low frame rate for efficiency
+                },
+                audio: false
+            });
+            
+            const videoTrack = screenStream.getVideoTracks()[0];
+            webrtcVideo.srcObject.removeTrack(currentTrack);
+            webrtcVideo.srcObject.addTrack(videoTrack);
+            
+            // Handle when screen sharing ends
+            videoTrack.onended = () => {
+                console.log('Screen sharing ended by user');
+                // Automatically switch back to camera
+                navigator.mediaDevices.getUserMedia({video: true, audio: false})
+                    .then(cameraStream => {
+                        const cameraTrack = cameraStream.getVideoTracks()[0];
+                        webrtcVideo.srcObject.addTrack(cameraTrack);
+                    });
+            };
+            
+            currentTrack.stop();
+            return "🖥️ Screen sharing active";
+        }
+        
+    } catch (error) {
+        console.error('Screen sharing error:', error);
+        if (error.name === 'NotAllowedError') {
+            return "❌ Screen sharing permission denied";
+        } else if (error.name === 'NotFoundError') {
+            return "❌ No screen available to share";
+        } else {
+            return `❌ Error: ${error.message}`;
+        }
+    }
+}
 
-    thread = threading.Thread(target=run_async_disconnect, daemon=True)
-    thread.start()
+return toggleScreenShare();
+"""
 
-    return "🔄 Disconnecting from AI assistant..."
 
-def get_connection_status():
-    """PREMIUM: Get detailed connection status"""
-    if app_state["connected"]:
-        stats = app_state["stats"]
-        return f"🟢 Connected | Audio: {stats['audio_sent']} | Frames: {stats['frames_sent']} | Responses: {stats['responses_received']}"
-    else:
-        return f"🔴 Disconnected | Status: {app_state['last_status']}"
+def create_main_interface():
+    """Create the enhanced main interface"""
 
-def create_interface():
-    """PREMIUM: Enhanced interface with complete real-time integration"""
-    # Initialize premium stream
-    stream = initialize_real_time_assistant()
+    # Initialize stream
+    stream = initialize_stream()
 
     with gr.Blocks(
-        title="Real-Time Screen Assistant - Premium Edition",
-        theme=gr.themes.Soft()
+        title="Enhanced Real-Time Screen Assistant",
+        theme=gr.themes.Soft(),
+        css="""
+        .status-connected { background: linear-gradient(90deg, #4CAF50, #45a049); color: white; }
+        .status-disconnected { background: linear-gradient(90deg, #f44336, #da190b); color: white; }
+        .status-warning { background: linear-gradient(90deg, #ff9800, #f57c00); color: white; }
+        .control-row { margin: 10px 0; }
+        .stream-container { border: 2px solid #ddd; border-radius: 10px; padding: 20px; margin: 20px 0; }
+        """,
     ) as demo:
-
-        gr.Markdown("# 🚀 Real-Time Screen Assistant - Premium Edition")
+        gr.Markdown("# 🖥️ Enhanced Real-Time Screen Assistant")
         gr.Markdown("""
-        **🎯 PREMIUM AI with complete real-time frontend integration!**
-
-        **Real-time Frontend Integration Features:**
-        ✅ **Continuous audio flow** - Voice activity detection, noise filtering
-        ✅ **Model audio output** - AI voice responses with queue management
-        ✅ **Screen data streaming** - Adaptive capture with intelligent throttling
-        ✅ **Text response delivery** - Real-time text display with conversation history
-
-        **Enhanced Premium Features:**
-        - 🧠 Enhanced GenAI configuration with full modalities
-        - 🎙️ Intelligent voice activity detection
-        - 📹 Adaptive screen capture (300s real-time timeout)
-        - 🔄 Background task management with cleanup
-        - 📊 Performance monitoring and optimization
-        - 🛡️ Enhanced error handling and recovery
+        **Advanced AI assistant with live screen sharing, voice interaction, and real-time guidance**
+        
+        Powered by Google's Gemini Live API and FastRTC for ultra-low latency communication.
         """)
 
-        # PREMIUM: Enhanced status display
-        with gr.Row():
-            status_display = gr.Textbox(
-                label="🔴 Connection Status",
-                value="Ready to connect - Premium features enabled",
-                interactive=False
-            )
-            stats_display = gr.Textbox(
-                label="📊 Performance Stats",
-                value="Audio: 0 | Frames: 0 | Responses: 0",
-                interactive=False
-            )
-
-        # PREMIUM: Enhanced control panel
-        with gr.Row():
-            connect_btn = gr.Button("🔗 Connect (Premium)", variant="primary")
-            disconnect_btn = gr.Button("🔴 Disconnect", variant="stop")
-
-        with gr.Row():
-            mic_test_btn = gr.Button("🎙️ Test Microphone", variant="secondary")
-            screen_share_btn = gr.Button("🖥️ Share Screen", variant="secondary")
-
-        # --- Backend logic for mic test and screen sharing ---
-        def backend_mic_test():
-            # Simulate a backend mic test (could be extended to record/playback)
-            if app_state.get("handler") and app_state.get("connected"):
-                return "🎙️ Microphone is active and streaming to backend."
-            return "⚠️ Please connect first to test microphone."
-
-        def backend_screen_share():
-            # Simulate backend screen sharing trigger
-            if app_state.get("handler") and app_state.get("connected"):
-                # In a real implementation, you might set a flag or trigger a backend event
-                return "🖥️ Screen sharing is active and streaming to backend."
-            return "⚠️ Please connect first to share your screen."
-
-        # PREMIUM: Real-time streaming interface
-        gr.Markdown("### 📡 Premium Real-Time Stream")
-
-        if stream:
-            # Create streaming interface with enhanced configuration
-            audio_stream = gr.Audio(
-                streaming=True,
-                autoplay=False,
-                show_download_button=False,
-                label="🎙️ Microphone Input (Voice Activity Detection)",
-                interactive=True
-            )
-
-            # PREMIUM: Integrated ScreenRecorder component
-            screen_recorder = ScreenRecorder(
-                audio_enabled=True,
-                webcam_overlay=True,
-                webcam_position="bottom-right",
-                recording_format="webm",
-                max_duration=300,  # 5 minutes - real-time optimized
-                label="🖥️ Screen Recorder (Premium)",
-                interactive=True
-            )
-
-            # PREMIUM: Connect streaming handlers
-            audio_stream.stream(
-                fn=lambda audio: app_state["handler"].receive(audio) if app_state["handler"] and app_state["connected"] else None,
-                inputs=[audio_stream],
-                outputs=[],
-                time_limit=300,  # Real-time optimized
-                concurrency_limit=5
-            )
-
-            # PREMIUM: AI response display
-            ai_response_display = gr.Textbox(
-                label="🤖 AI Response Stream",
-                value="AI responses will appear here...",
-                interactive=False,
-                max_lines=10
-            )
-
-            # PREMIUM: Audio output
-            ai_audio_output = gr.Audio(
-                label="🔊 AI Voice Response",
-                autoplay=True,
-                streaming=True
-            )
-
-            # Connect AI response handlers
-            ai_audio_output.stream(
-                fn=lambda: app_state["handler"].emit() if app_state["handler"] and app_state["connected"] else None,
-                inputs=[],
-                outputs=[ai_audio_output],
-                time_limit=300
-            )
-
-            # Connect screen recorder to video handler
-            def handle_screen_recording(recording_data):
-                """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'):
-                        # For real-time processing, we could extract frames
-                        # For now, just acknowledge the recording
-                        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}"
-
-            screen_recorder.change(
-                fn=handle_screen_recording,
-                inputs=[screen_recorder],
-                outputs=[ai_response_display],
-                show_progress=False
-            )
+        # Status display
+        status_display = gr.Textbox(
+            label="🔍 Status",
+            value="Ready to connect - Click Connect to start your AI session",
+            interactive=False,
+            elem_classes=["status-disconnected"],
+        )
 
+        # Control buttons
+        with gr.Row(elem_classes=["control-row"]):
+            connect_btn = gr.Button("🔗 Connect to AI", variant="primary", size="lg")
+            screen_btn = gr.Button("🖥️ Toggle Screen Share", variant="secondary", size="lg")
+            disconnect_btn = gr.Button("🔴 Disconnect", variant="stop", size="lg")
+
+        # Stream container
+        if stream and stream.ui:
+            with gr.Group(elem_classes=["stream-container"]):
+                gr.Markdown("### 📡 Live Stream")
+                stream_interface = stream.ui
         else:
-            gr.HTML("<div>⚠️ Premium stream initialization failed - Check console for errors</div>")
+            stream_interface = gr.HTML("<div>⚠️ Stream initialization failed - check console for errors</div>")
 
-        # PREMIUM: Enhanced instructions
-        with gr.Accordion("📋 Premium Instructions", open=True):
+        # Usage instructions
+        with gr.Accordion("📋 How to Use This Assistant", open=True):
             gr.Markdown("""
-            **How to use the Premium Real-Time Assistant:**
-
-            1. **Connect**: Click "Connect (Premium)" to start enhanced AI session
-            2. **Permissions**: Allow microphone and camera access when prompted
-            3. **Voice Interaction**: Speak naturally - voice activity detection filters noise
-            4. **Screen Sharing**: Click "Share Screen" for continuous screen analysis
-            5. **Real-time Responses**: Receive both voice and text responses immediately
-            6. **Monitor Performance**: Check stats display for real-time metrics
-
-            **Premium Features Active:**
-            - ✅ **Continuous Audio Flow**: Voice activity detection with noise filtering
-            - ✅ **Model Audio Output**: AI voice responses with smart queue management
-            - ✅ **Screen Data Streaming**: Adaptive capture with 1 FPS optimization
-            - ✅ **Text Response Delivery**: Real-time text with conversation history
-            - ✅ **Background Task Management**: Proper async task handling and cleanup
-            - ✅ **Enhanced Error Recovery**: Robust connection management
+            **Getting Started:**
+            1. **Connect**: Click "Connect to AI" to establish the AI session
+            2. **Permissions**: Allow microphone and camera access in your browser
+            3. **Screen Share**: Click "Toggle Screen Share" to let the AI see your screen
+            4. **Interact**: Simply speak naturally - the AI will respond with voice and can see your screen
+            
+            **What the AI can help with:**
+            - 🖥️ **Software tutorials**: "Show me how to use this feature"
+            - 🔧 **Troubleshooting**: "Why isn't this working?"
+            - 📊 **Data analysis**: "Help me understand this chart"
+            - 🎨 **Design feedback**: "How can I improve this layout?"
+            - 📝 **Writing assistance**: "Help me edit this document"
+            - 🌐 **Web navigation**: "Guide me through this website"
+            
+            **Voice Commands:**
+            - "What am I looking at?"
+            - "What should I do next?"
+            - "Explain this to me"
+            - "Help me fix this error"
+            - "Is this the right approach?"
             """)
 
-        # PREMIUM: Technical details
-        with gr.Accordion("🔧 Premium Technical Features", open=False):
+        # Advanced features
+        with gr.Accordion("⚙️ Advanced Features", open=False):
             gr.Markdown("""
-            **Real-Time Frontend Integration Implementation:**
-
-            **1. Continuous Audio Flow (User → Model):**
-            ```python
-            # Voice activity detection with threshold filtering
-            audio_level = np.abs(audio_np.astype(np.float32)).mean()
-            if audio_level < voice_activity_threshold:
-                return  # Filter silence
-
-            # Enhanced send with metadata
-            await session.send_realtime_input(input=types.Blob(...))
-            ```
-
-            **2. Model Audio Output (Model → User):**
-            ```python
-            # AI response processing with queue management
-            audio_array = np.frombuffer(response.data, dtype=np.int16)
-            await audio_queue.put(audio_array.reshape(1, -1))
-            ```
-
-            **3. Screen Data Streaming (Screen → Model):**
-            ```python
-            # Adaptive throttling based on activity
-            adaptive_interval = frame_interval * (0.5 if active else 1.0)
-            # Quality optimization: 85% for active, 75% for quiet
-            ```
-
-            **4. Text Response Delivery (System → User):**
-            ```python
-            # Conversation history with timestamps
-            conversation_history.append({
-                "timestamp": time.time(),
-                "type": "ai_response",
-                "content": response.text
-            })
-            ```
-
-            **Premium Optimizations:**
-            - Background task management with proper cleanup
-            - Enhanced error handling and recovery
-            - Performance monitoring and adaptive quality
-            - 300s timeout optimized for real-time behavior
-            """)
-
-        # Wire up premium controls
-        connect_btn.click(
-            fn=handle_connect,
-            outputs=[status_display]
-        )
-
-        disconnect_btn.click(
-            fn=handle_disconnect,
-            outputs=[status_display]
-        )
-
-        mic_test_btn.click(
-            fn=backend_mic_test,
-            outputs=[status_display]
-        )
-
-        screen_share_btn.click(
-            fn=backend_screen_share,
-            outputs=[status_display]
-        )
-
-        # Initial load of connection status
-        demo.load(
-            fn=get_connection_status,
-            outputs=[stats_display]
-        )
-
-        return demo
-
-# Main execution
-if __name__ == "__main__":
-    print("🚀 Real-Time Screen Assistant - PREMIUM EDITION")
-    print("=" * 60)
-    print("✅ Complete real-time frontend integration:")
-    print("   1. Continuous audio flow (user → model)")
-    print("   2. Model audio output (model → user)")
-    print("   3. Screen data streaming (screen → model)")
-    print("   4. Text response delivery (system → user)")
-    print("✅ Enhanced features:")
-    print("   - Voice activity detection with noise filtering")
-    print("   - Adaptive screen capture with quality optimization")
-    print("   - Background task management with cleanup")
-    print("   - Enhanced error handling and recovery")
-    print("   - 300s timeout optimized for real-time behavior")
-
-    if not API_KEY:
-        print("\n⚠️  No GEMINI_API_KEY environment variable found")
-        print("Please set your Google AI API key:")
-        print("export GEMINI_API_KEY='your-api-key-here'")
-    else:
-        print(f"\n✅ API key configured (Premium Mode)")
-
-    print("\n🚀 Starting Premium Real-Time Assistant...")
-
-    try:
-        demo = create_interface()
-        demo.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=False,
-            show_error=True
-        )
-    except Exception as e:
-        print(f"❌ Failed to launch: {e}")
-        print("Ensure all dependencies are installed: pip install -r requirements.txt")
+            **Technical Capabilities:**
+            - 🎙️ **Voice Activity Detection**: AI responds when you finish speaking
+            - 📸 **Intelligent Frame Sampling**: Optimized screen capture (1-2 FPS)
+            - 🧠 **Context Awareness**: AI remembers your conversation history
+            - 🔄 **Adaptive Quality**: Automatically adjusts based on connection
+            - ⚡ **Ultra-Low Latency**: Typical response time under 500ms
+            
+            **Privacy & Security:**
+            - 🔒 All data encrypted in transit (WebRTC + TLS)
+            - 🏠 Processing by Google's secure AI infrastructure
+            - 🚫 No permanent storage of your screen or voice data
+            - 👤 Each session is completely isolated and private
+            
+            **Optimization for Hugging Face Spaces:**
+            - ☁️ Cloudflare TURN servers for reliable connectivity
+            - 🔧 Automatic resource management and cleanup
+            - ⏱️ Session timeout prot