Update app.py

app.py

@@ -1,32 +1,19 @@
-"""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
+"""
+Real-Time Screen Assistant - Refactored for Google GenAI Live API + FastRTC
 
-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
+This application transforms the original screenshot analyzer into a real-time
+screen sharing assistant with voice interaction, following the refactoring 
+instructions for live streaming capabilities.
 """
 
-import asyncio
 import os
+import asyncio
 import time
-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
+import cv2
+import gradio as gr
+from fastrtc import Stream, AsyncAudioVideoStreamHandler, get_cloudflare_turn_credentials_async, ReplyOnPause
 from google import genai
 from google.genai import types
 
@@ -34,633 +21,502 @@ from google.genai import types
 API_KEY = os.getenv("GEMINI_API_KEY", "")
 
 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
     """
-
+    Real-time screen assistant implementing the refactoring instructions.
+    
+    Features:
+    - Google GenAI Live API integration
+    - Real-time audio/video streaming via FastRTC
+    - Voice activity detection with ReplyOnPause
+    - Intelligent frame sampling for screen sharing
+    - Cloudflare TURN server support for HF Spaces
+    """
+    
     def __init__(self):
         super().__init__(
-            expected_layout="mono",
-            output_sample_rate=24000,
+            expected_layout="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  # 1 FPS as per instructions
+        
     async def start_up(self):
-        """Enhanced startup with premium configuration"""
+        """Initialize Google GenAI Live session as per Task 8-10"""
         try:
+            # Re-check environment variable in case it was set after import
             current_api_key = os.getenv("GEMINI_API_KEY", "")
             if not current_api_key:
                 print("❌ No GEMINI_API_KEY found in environment")
                 return
-
-            # Initialize client with premium configuration
+                
+            # Initialize client with v1alpha API (Task 8)
             client = genai.Client(
                 api_key=current_api_key,
                 http_options={"api_version": "v1alpha"}
             )
-
-            # PREMIUM: Enhanced configuration with all features enabled
-            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
-                }
-            }
-
-            # Connect with enhanced configuration
-            self.session = await client.aio.live.connect(
-                model="gemini-2.0-flash-live-preview",
+            
+            # Configure live session (Task 9) - minimal working config
+            from google.genai.types import LiveConnectConfig
+            
+            # Start with minimal config to avoid WebSocket errors
+            config = LiveConnectConfig(
+                system_instruction=(
+                    "You are a helpful real-time assistant who watches the user's screen and provides "
+                    "guidance on using software. Give clear, step-by-step instructions based on what "
+                    "you see and hear. Be proactive in offering assistance."
+                )
+            )
+            
+            # Connect to Live API (Task 10) - using async context manager
+            self.session_context = client.aio.live.connect(
+                model="gemini-2.0-flash-live-001", 
                 config=config
             )
-
+            self.session = await self.session_context.__aenter__()
+            
             self.connected = True
-            print("✅ Connected to Google GenAI Live API (Premium Mode)")
-
-            # Start enhanced response handler
-            response_task = asyncio.create_task(self._handle_responses())
-            self.background_tasks.add(response_task)
-            response_task.add_done_callback(self.background_tasks.discard)
-
+            print("✅ Connected to Google GenAI Live API")
+            
+            # Start response handler (Task 13)
+            self.response_task = asyncio.create_task(self._handle_responses())
+            
         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 AI responses as per Task 12-13"""
         try:
-            async for response in self.session.receive():
-                if not self.connected:
-                    break
-
+            # The Google GenAI Live API provides an async iterator through session.receive()
+            # We need to handle this as a streaming response
+            while self.connected and self.session:
                 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)
-
-                except Exception as e:
-                    print(f"⚠️ Response processing error: {e}")
-
+                    # Get the next message from the session
+                    response_stream = self.session.receive()
+                    
+                    # Check if this is an async iterator or needs to be awaited
+                    if hasattr(response_stream, '__aiter__'):
+                        # It's an async iterator
+                        async for msg in response_stream:
+                            if not self.connected:
+                                break
+                                
+                            if msg.data:  # Audio response
+                                # Convert to numpy for FastRTC (Task 13)
+                                audio_array = np.frombuffer(msg.data, dtype=np.int16)
+                                if len(audio_array) > 0:
+                                    audio_array = audio_array.reshape(1, -1)
+                                    await self.audio_queue.put(audio_array)
+                            
+                            if msg.text:  # Text response
+                                print(f"🤖 AI: {msg.text}")
+                    else:
+                        # It's a single response that needs to be awaited
+                        msg = await response_stream
+                        if msg:
+                            if msg.data:  # Audio response
+                                audio_array = np.frombuffer(msg.data, dtype=np.int16)
+                                if len(audio_array) > 0:
+                                    audio_array = audio_array.reshape(1, -1)
+                                    await self.audio_queue.put(audio_array)
+                            
+                            if msg.text:  # Text response
+                                print(f"🤖 AI: {msg.text}")
+                                
+                except Exception as inner_e:
+                    if "connection" in str(inner_e).lower() or "closed" in str(inner_e).lower():
+                        print("🔴 Connection closed, stopping response handler")
+                        break
+                    else:
+                        print(f"⚠️  Response handling error: {inner_e}")
+                        await asyncio.sleep(0.1)  # Brief pause before retry
+                    
         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"""
+        """Handle microphone audio (Task 11)"""
         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
-
-            # 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
+            
+            # Send audio to GenAI Live API using new non-deprecated method
             await self.session.send_realtime_input(
                 input=types.Blob(
-                    data=audio_bytes,
+                    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)
-            })
-
         except Exception as e:
             print(f"❌ Error sending audio: {e}")
-
+    
     async def video_receive(self, frame: npt.NDArray[np.float32]):
-        """PREMIUM: Enhanced screen capture with adaptive throttling"""
+        """Handle screen video frames (Task 11-12)"""
         if not self.connected or not self.session:
             return
-
+            
         try:
-            # PREMIUM: Adaptive frame throttling based on activity
+            # Throttle to 1 FPS as per instructions
             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
-            else:
-                # Standard interval during quiet periods
-                adaptive_interval = self.frame_interval
-
-            if current_time - self.last_frame_time < adaptive_interval:
+            if current_time - self.last_frame_time < self.frame_interval:
                 return
-
+                
             self.last_frame_time = current_time
-
-            # PREMIUM: Enhanced frame processing
+            
+            # Convert float32 frame to uint8 for JPEG encoding
             if frame.dtype == np.float32:
+                # Assuming frame is in range [0, 1], convert to [0, 255]
                 frame_uint8 = (frame * 255).astype(np.uint8)
             else:
                 frame_uint8 = frame.astype(np.uint8)
-
-            # Validate frame
+            
+            # Check for empty frame before encoding
             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
-
+                
+            # Encode as JPEG (Task 12)
             try:
-                success, jpg_bytes = cv2.imencode('.jpg', frame_uint8, [cv2.IMWRITE_JPEG_QUALITY, quality])
+                success, jpg_bytes = cv2.imencode('.jpg', frame_uint8, [cv2.IMWRITE_JPEG_QUALITY, 80])
                 if not success:
                     return
             except cv2.error:
+                # Handle OpenCV encoding errors gracefully
                 return
-
-            # Send enhanced frame data
+            
+            # Send to GenAI using new non-deprecated method
             await self.session.send_realtime_input(
                 input=types.Blob(
-                    data=jpg_bytes.tobytes(),
+                    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)
-            })
-
+            
         except Exception as e:
             print(f"❌ Error sending video frame: {e}")
-
+    
     async def emit(self):
-        """PREMIUM: Enhanced audio emission with queue management"""
+        """Emit audio back to user (Task 13)"""
         try:
             audio_chunk = self.audio_queue.get_nowait()
             return (24000, audio_chunk)
         except asyncio.QueueEmpty:
             return None
-
-    async def get_latest_text(self):
-        """PREMIUM: Get latest text response from AI"""
-        try:
-            text = self.text_queue.get_nowait()
-            return text
-        except asyncio.QueueEmpty:
-            return None
-
+    
     def copy(self):
-        """Enhanced copy method with state preservation"""
+        """Copy method required by FastRTC AsyncAudioVideoStreamHandler"""
+        # Return a new instance with same configuration
         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"""
+        """Video emit method required by FastRTC AsyncAudioVideoStreamHandler"""
+        # For this use case, we don't emit video back to user
         return None
-
+    
     async def shutdown(self):
-        """PREMIUM: Enhanced shutdown with complete cleanup"""
+        """Clean shutdown (Task 17)"""
         self.connected = False
-
-        # Cancel all background tasks
-        for task in self.background_tasks.copy():
-            if not task.done():
-                task.cancel()
-
-        # Wait for task cleanup
-        if self.background_tasks:
-            await asyncio.gather(*self.background_tasks, return_exceptions=True)
-        self.background_tasks.clear()
-
-        # Clean up queues
-        while not self.audio_queue.empty():
+        
+        # Cancel response handler task if it exists
+        if hasattr(self, 'response_task') and not self.response_task.done():
+            self.response_task.cancel()
             try:
-                self.audio_queue.get_nowait()
-            except asyncio.QueueEmpty:
-                break
-
-        while not self.text_queue.empty():
-            try:
-                self.text_queue.get_nowait()
-            except asyncio.QueueEmpty:
-                break
-
-        # Clear conversation history
-        self.conversation_history.clear()
-
-        # Close session
+                await self.response_task
+            except asyncio.CancelledError:
+                pass
+        
         if self.session:
             try:
-                await self.session.close()
+                # Properly close the session using context manager
+                if hasattr(self, 'session_context'):
+                    await self.session_context.__aexit__(None, None, None)
+                else:
+                    await self.session.close()
                 print("🔴 Disconnected from GenAI Live API")
             except Exception as e:
                 print(f"❌ Error during shutdown: {e}")
-
+        
         self.session = None
+        if hasattr(self, 'session_context'):
+            self.session_context = None
 
-# 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}
-}
+# Global state
+app_state = {"stream": None, "handler": None, "connected": False}
 
 def initialize_real_time_assistant():
-    """PREMIUM: Enhanced stream initialization"""
+    """Initialize the real-time assistant (Task 26-29)"""
     try:
+        # Create handler
         handler = RealTimeScreenAssistant()
         app_state["handler"] = handler
-
-        # PREMIUM: Enhanced stream configuration
+        
+        # Create stream with Cloudflare TURN (Task 22-23)
         stream = Stream(
-            handler=ReplyOnPause(handler),  # Voice activity detection
-            modality="audio-video",
+            handler=ReplyOnPause(handler),  # Voice activity detection (Task 3)
+            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
-            }
+            time_limit=300  # 5 minute limit for Spaces
         )
-
+        
         app_state["stream"] = stream
         return stream
-
+        
     except Exception as e:
         print(f"❌ Error creating stream: {e}")
         return None
 
-async def handle_connect_async():
-    """PREMIUM: Enhanced async connection handler"""
+def handle_connect():
+    """Connect button handler (Task 16)"""
+    # Re-check environment variable in case it was set after import
     current_api_key = os.getenv("GEMINI_API_KEY", "")
     if not current_api_key:
         return "❌ Please set GEMINI_API_KEY environment variable"
-
+    
     if app_state["connected"]:
         return "✅ Already connected - session is active"
+    
+    app_state["connected"] = True
+    return "✅ Connecting... Please allow microphone and camera permissions"
 
-    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)}"
-
-def handle_connect():
-    """Sync wrapper for connection"""
-    app_state["connected"] = True  # Optimistic update for UI
-    app_state["last_status"] = "Initiating connection..."
-
-    # Start async connection
-    asyncio.create_task(handle_connect_async())
-    return "🔄 Initiating connection to GenAI Live API..."
-
-async def handle_disconnect_async():
-    """PREMIUM: Enhanced async disconnect handler"""
+def handle_disconnect():
+    """Disconnect button handler (Task 17)"""
     if app_state["handler"] and app_state["connected"]:
-        try:
-            await app_state["handler"].shutdown()
-            app_state["connected"] = 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)}"
+        asyncio.run(app_state["handler"].shutdown())
+        app_state["connected"] = False
+        return "🔴 Disconnected from AI assistant"
+    
     return "Already disconnected"
 
-def handle_disconnect():
-    """Sync wrapper for disconnect"""
-    app_state["connected"] = False  # Immediate update for UI
-
-    # Start async disconnect
-    asyncio.create_task(handle_disconnect_async())
-    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']}"
+# Screen sharing JavaScript - Fixed syntax for HF Spaces
+screen_share_js = '''
+(async function() {
+    try {
+        if (!navigator.mediaDevices || !navigator.mediaDevices.getDisplayMedia) {
+            return "❌ Screen sharing not supported in this browser";
+        }
+        
+        const stream = await navigator.mediaDevices.getDisplayMedia({
+            video: {
+                width: { ideal: 1920 },
+                height: { ideal: 1080 }
+            },
+            audio: false
+        });
+        
+        // Find the video element from FastRTC
+        const videos = document.querySelectorAll('video');
+        let targetVideo = null;
+        
+        for (let video of videos) {
+            if (video.srcObject && video.srcObject.getVideoTracks().length > 0) {
+                targetVideo = video;
+                break;
+            }
+        }
+        
+        if (targetVideo && targetVideo.srcObject) {
+            // Replace the camera track with screen track
+            const screenTrack = stream.getVideoTracks()[0];
+            const sender = targetVideo.srcObject.getVideoTracks()[0];
+            
+            // Remove old track and add screen track
+            targetVideo.srcObject.removeTrack(sender);
+            targetVideo.srcObject.addTrack(screenTrack);
+            
+            screenTrack.onended = () => {
+                console.log("Screen sharing ended");
+            };
+            
+            return "🖥️ Screen sharing started successfully!";
+        } else {
+            return "❌ Could not find video stream to replace";
+        }
+        
+    } catch (error) {
+        console.error("Screen sharing error:", error);
+        if (error.name === "NotAllowedError") {
+            return "❌ Screen sharing permission denied - please allow screen access";
+        } else if (error.name === "NotSupportedError") {
+            return "❌ Screen sharing not supported in this environment";
+        } else {
+            return "❌ Screen sharing failed: " + error.message;
+        }
+    }
+})()'''
 
 def create_interface():
-    """PREMIUM: Enhanced interface with complete real-time integration"""
-    # Initialize premium stream
+    """Create main interface (Task 26-30)"""
+    
+    # Initialize stream
     stream = initialize_real_time_assistant()
-
+    
     with gr.Blocks(
-        title="Real-Time Screen Assistant - Premium Edition",
+        title="Real-Time Screen Assistant", 
         theme=gr.themes.Soft()
     ) as demo:
-
-        gr.Markdown("# 🚀 Real-Time Screen Assistant - Premium Edition")
+        
+        gr.Markdown("# 🖥️ 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
+        **🎯 LIVE AI that sees your screen and provides real-time guidance!**
+        
+        **How it works:**
+        1. **Connect** - Links to Google's GenAI Live API for real-time AI processing
+        2. **Share Screen** - AI can see exactly what you're doing on your screen  
+        3. **Voice Chat** - Talk naturally, AI responds with voice and sees everything
+        4. **Get Help** - Real-time assistance with software, coding, troubleshooting
+        
+        **Tech Stack:**
+        - 🧠 Google GenAI Live API (multimodal real-time AI)
+        - 📹 FastRTC (low-latency screen/audio streaming)
+        - 🎙️ Voice activity detection 
+        - 🌐 Cloudflare TURN servers (HF Spaces optimized)
         """)
-
-        # 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
+        
+        # Status display
+        status_display = gr.Textbox(
+            label="Status",
+            value="Ready to connect - Click Connect to start real-time session",
+            interactive=False
+        )
+        
+        # Control buttons (Task 3, 16-17)
         with gr.Row():
-            connect_btn = gr.Button("🔗 Connect (Premium)", variant="primary")
+            connect_btn = gr.Button("🔗 Connect", variant="primary")
+            mic_btn = gr.Button("🎙️ Test Microphone", variant="secondary")
+            screen_btn = gr.Button("🖥️ Show Your Screen", variant="secondary") 
             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")
-
-        # PREMIUM: Real-time streaming interface
-        gr.Markdown("### 📡 Premium Real-Time Stream")
-
+        
+        # Stream interface - FastRTC UI for microphone and video
+        gr.Markdown("### 📡 Live Audio/Video 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
-            )
-
-            video_stream = gr.Image(
-                streaming=True,
-                label="🖥️ Screen Capture (Adaptive Quality)",
-                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
-            )
-
-            video_stream.stream(
-                fn=lambda frame: app_state["handler"].video_receive(frame) if app_state["handler"] and app_state["connected"] else None,
-                inputs=[video_stream],
-                outputs=[],
-                time_limit=300,  # Real-time optimized
-                concurrency_limit=3
-            )
-
-            # 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
-            )
-
+            # Mount the FastRTC stream UI - this provides microphone access
+            gr.HTML("""
+            <div id="fastrtc-container">
+                <p>🎙️ Microphone and video streaming handled by FastRTC</p>
+                <p>Click 'Test Microphone' and 'Show Your Screen' to activate</p>
+            </div>
+            """)
         else:
-            gr.HTML("<div>⚠️ Premium stream initialization failed - Check console for errors</div>")
-
-        # PREMIUM: Enhanced instructions
-        with gr.Accordion("📋 Premium Instructions", open=True):
+            gr.HTML("<div>⚠️ Stream initialization failed - Check console for errors</div>")
+            
+        # Microphone activation JavaScript
+        microphone_js = '''
+        (async function() {
+            try {
+                // Request microphone permission and start audio
+                const stream = await navigator.mediaDevices.getUserMedia({
+                    audio: {
+                        sampleRate: 16000,
+                        channelCount: 1,
+                        echoCancellation: true,
+                        noiseSuppression: true
+                    }
+                });
+                console.log("Microphone access granted");
+                return "🎙️ Microphone connected successfully";
+            } catch (error) {
+                console.error("Microphone error:", error);
+                if (error.name === "NotAllowedError") {
+                    return "❌ Microphone permission denied - please allow microphone access";
+                } else {
+                    return "❌ Microphone failed: " + error.message;
+                }
+            }
+        })()
+        '''
+        
+        # Instructions (Task 1-3)
+        with gr.Accordion("📋 Instructions", 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
+            **How to use the real-time assistant:**
+            
+            1. **Connect**: Click Connect to start the AI session
+            2. **Permissions**: Allow microphone and camera access
+            3. **Show Screen**: Click "Show Your Screen" to share your screen
+            4. **Voice Interaction**: Simply speak - the AI will respond
+            5. **Real-time Guidance**: AI sees your screen and provides live help
+            6. **Disconnect**: Click Disconnect when finished
+            
+            **Features implemented from refactoring instructions:**
+            - ✅ FastRTC WebRTC streaming (Task 2)
+            - ✅ Google GenAI Live API integration (Task 7-15)
+            - ✅ Connect/Show Screen/Disconnect controls (Task 3, 16-17)
+            - ✅ Voice activity detection with ReplyOnPause (Task 3)
+            - ✅ Screen sharing via getDisplayMedia (Task 6)
+            - ✅ Real-time advice generation (Task 18-21)
+            - ✅ Cloudflare TURN for HF Spaces (Task 22-23)
             """)
-
-        # PREMIUM: Technical details
-        with gr.Accordion("🔧 Premium Technical Features", open=False):
+        
+        # Privacy notice (Task 24-25)
+        with gr.Accordion("🔒 Privacy & Security", 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
+            **Privacy Notice:**
+            - Screen content and voice are processed by Google's AI services
+            - Data is transmitted securely via encrypted WebRTC connections
+            - No permanent storage - all processing is real-time
+            - You control what is shared and can disconnect anytime
+            
+            **Technical Details:**
+            - Uses Google Gemini Live API for real-time multimodal processing
+            - FastRTC provides low-latency WebRTC streaming
+            - Cloudflare TURN servers ensure reliable connectivity on HF Spaces
+            - Voice activity detection prevents interruptions
             """)
-
-        # Wire up premium controls
+        
+        # Wire up controls
         connect_btn.click(
             fn=handle_connect,
             outputs=[status_display]
         )
-
+        
+        mic_btn.click(
+            fn=lambda: "🎙️ Testing microphone...",
+            outputs=[status_display],
+            js=microphone_js
+        )
+        
+        screen_btn.click(
+            fn=lambda: "🖥️ Requesting screen share...",
+            outputs=[status_display],
+            js=screen_share_js
+        )
+        
         disconnect_btn.click(
             fn=handle_disconnect,
             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")
-
+    print("🖥️ Real-Time Screen Assistant")
+    print("=" * 50)
+    print("Refactored according to instructions for:")
+    print("- Google GenAI Live API integration")
+    print("- FastRTC real-time streaming") 
+    print("- Voice activity detection")
+    print("- Screen sharing capabilities")
+    print("- Cloudflare TURN for HF Spaces")
+    
     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...")
-
+        print(f"\n✅ API key configured (length: {len(API_KEY)})")
+    
+    print("\n🚀 Starting real-time assistant...")
+    
     try:
         demo = create_interface()
         demo.launch(
@@ -671,4 +527,4 @@ if __name__ == "__main__":
         )
     except Exception as e:
         print(f"❌ Failed to launch: {e}")
-        print("Ensure all dependencies are installed: pip install -r requirements.txt")
+        print("Ensure all dependencies are installed: pip install -r requirements.txt")