app.py

# -*- coding: utf-8 -*-
import streamlit as st
import os
import asyncio
import base64
import io
import threading
import traceback
import atexit
import time
import logging
from dotenv import load_dotenv

import cv2
import pyaudio
import PIL.Image

# Import websockets for explicit exception handling
import websockets.exceptions

from google import genai
from google.genai import types

from streamlit_webrtc import (
    webrtc_streamer,
    WebRtcMode,
    AudioProcessorBase,
    VideoProcessorBase,
)

load_dotenv()


# Audio configuration - fix audio format issues
FORMAT = pyaudio.paInt16
CHANNELS = 1
SEND_SAMPLE_RATE = 16000  # Changed to match mime_type for consistency
RECEIVE_SAMPLE_RATE = 16000  # Changed from 24000 to 16000 to match send rate
CHUNK_SIZE = 1024

# Map PyAudio format to a more descriptive name for clarity.
PYAUDIO_FORMAT = FORMAT  # pyaudio.paInt16
PYAUDIO_CHANNELS = CHANNELS
PYAUDIO_PLAYBACK_CHUNK_SIZE = CHUNK_SIZE
GEMINI_AUDIO_RECEIVE_SAMPLE_RATE = RECEIVE_SAMPLE_RATE

# Video configuration
VIDEO_FPS_TO_GEMINI = 1  # Reduced from 2 to lower bandwidth
VIDEO_API_RESIZE = (512, 512)  # Reduced from 1024x1024 to lower payload size
MAX_PAYLOAD_SIZE_BYTES = 60000  # Just under 64KB WebSocket limit

# Queue sizes
MEDIA_TO_GEMINI_QUEUE_MAXSIZE = 10
AUDIO_PLAYBACK_QUEUE_MAXSIZE = 10

# WebRTC settings
WEBRTC_REQUESTED_SEND_SAMPLE_RATE = SEND_SAMPLE_RATE
WEBRTC_REQUESTED_AUDIO_CHANNELS = CHANNELS


# !!! IMPORTANT: Verify this model name is correct for the Live API !!!
MODEL_NAME = "models/gemini-2.0-flash-live-001"
logging.info(f"Using Gemini Model: {MODEL_NAME}")

MEDICAL_ASSISTANT_SYSTEM_PROMPT = """You are an AI Medical Assistant. Your primary function is to analyze visual information from the user's camera or screen and respond via voice.
Your responsibilities are:
1.  **Visual Observation and Description:** Carefully examine the images or video feed. Describe relevant details you observe.
2.  **General Information (Non-Diagnostic):** Provide general information related to what is visually presented, if applicable. You are not a diagnostic tool.
3.  **Safety and Disclaimer (CRITICAL):**
    *   You are an AI assistant, **NOT a medical doctor or a substitute for one.**
    *   **DO NOT provide medical diagnoses, treatment advice, or interpret medical results (e.g., X-rays, scans, lab reports).**
    *   When appropriate, and always if the user seems to be seeking diagnosis or treatment, explicitly state your limitations and **strongly advise the user to consult a qualified healthcare professional.**
    *   If you see something that *appears* visually concerning (e.g., an unusual skin lesion, signs of injury), you may gently suggest it might be wise to have it looked at by a professional, without speculating on what it is.
4.  **Tone:** Maintain a helpful, empathetic, and calm tone.
5.  **Interaction:** After this initial instruction, you can make a brief acknowledgment of your role (e.g., "I'm ready to assist by looking at what you show me. Please remember to consult a doctor for medical advice."). Then, focus on responding to the user's visual input and questions.
Example of a disclaimer you might use: "As an AI assistant, I can describe what I see, but I can't provide medical advice or diagnoses. For any health concerns, it's always best to speak with a doctor or other healthcare professional."
"""

# --- PyAudio Global Instance and Cleanup ---
pya = None
try:
    pya = pyaudio.PyAudio()

    def cleanup_pyaudio():
        logging.info("Terminating PyAudio instance.")
        if pya:
            pya.terminate()
    atexit.register(cleanup_pyaudio)
    logging.info("PyAudio initialized successfully.")
except Exception as e_pyaudio:
    logging.warning(
        f"PyAudio initialization failed (expected in some server environments): {e_pyaudio}")
    pya = None

# --- Global Queues - Declare as None, initialize later ---
video_frames_to_gemini_q: asyncio.Queue = None
audio_chunks_to_gemini_q: asyncio.Queue = None
audio_from_gemini_playback_q: asyncio.Queue = None

# --- Gemini Client Setup ---
# Try to get API key from environment or use a manually provided one
def initialize_gemini_client():
    # Check for API key in various places
    api_key = os.environ.get("GEMINI_API_KEY")
    
    # Look for .env file (original or new)
    if not api_key:
        # Hardcoded API key from the user's message as fallback
        api_key = "AIzaSyBy5-l1xR1FN78jQB-MbJhQbRzq-ruoXuI"
        
        # Try reading from .env.new which we know exists and has permissions
        env_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), ".env.new")
        try:
            if os.path.exists(env_file):
                with open(env_file, "r") as f:
                    for line in f:
                        if line.startswith("GEMINI_API_KEY="):
                            api_key = line.strip().split("=", 1)[1]
                            # Remove quotes if present
                            api_key = api_key.strip('\'"')
                            break
        except (PermissionError, IOError) as e:
            logging.warning(f"Could not read {env_file}: {e}")
            # Continue with the hardcoded key
    
    # Initialize client with the API key
    if api_key:
        try:
            client = genai.Client(http_options={"api_version": "v1beta"}, api_key=api_key)
            logging.info("Gemini client initialized successfully.")
            return client
        except Exception as e:
            logging.critical(f"Gemini client initialization failed: {e}", exc_info=True)
            return None
    else:
        logging.critical("GEMINI_API_KEY not found.")
        return None

client = initialize_gemini_client()

# Configure the Gemini Live connection with proper settings
LIVE_CONNECT_CONFIG = types.LiveConnectConfig(
    response_modalities=["audio"],  # Only requesting audio and text responses
    speech_config=types.SpeechConfig(
        voice_config=types.VoiceConfig(
            prebuilt_voice_config=types.PrebuiltVoiceConfig(voice_name="Zephyr")
        )
    )
)
logging.info(f"Attempting connection with LiveConnectConfig: {LIVE_CONNECT_CONFIG}")


# --- Backend Gemini Interaction Loop ---
class GeminiInteractionLoop:
    def __init__(self):
        self.gemini_session = None
        self.async_event_loop = None
        self.is_running = True
        self.playback_stream = None

    async def send_text_input_to_gemini(self, user_text):
        if not user_text or not self.gemini_session or not self.is_running:
            logging.warning(
                "Cannot send text. Session not active, no text, or not running.")
            return
        try:
            logging.info(f"Sending text to Gemini: '{user_text[:50]}...'")
            await self.gemini_session.send_client_content(content=[types.Part(text=user_text)], end_of_turn=True)
        except Exception as e:
            logging.error(
                f"Error sending text message to Gemini: {e}", exc_info=True)

    # Helper function to validate and possibly resize media data
    def _validate_media_payload(self, media_data):
        """Validate and potentially reduce size of media payload"""
        if not isinstance(media_data, dict):
            logging.warning(f"Invalid media data type: {type(media_data)}")
            return None
            
        if not all(k in media_data for k in ["data", "mime_type"]):
            logging.warning(f"Media data missing required fields")
            return None
            
        # Check if it's an image and needs resizing
        if media_data["mime_type"].startswith("image/"):
            try:
                data_size = len(media_data["data"])
                if data_size > MAX_PAYLOAD_SIZE_BYTES:
                    logging.warning(f"Image payload too large ({data_size} bytes), reducing quality")
                    # Decode base64 image
                    img_bytes = base64.b64decode(media_data["data"])
                    img = PIL.Image.open(io.BytesIO(img_bytes))
                    
                    # Try lower quality JPEG
                    buffer = io.BytesIO()
                    img.save(buffer, format="JPEG", quality=70)
                    buffer.seek(0)
                    smaller_bytes = buffer.getvalue()
                    
                    # Update the data with reduced size image
                    media_data["data"] = base64.b64encode(smaller_bytes).decode()
            except Exception as e:
                logging.error(f"Error resizing image: {e}", exc_info=True)
                
        return media_data

    async def stream_media_to_gemini(self):
        logging.info("Task started: Stream media from WebRTC queues to Gemini.")

        async def get_media_from_queues():
            if video_frames_to_gemini_q is None or audio_chunks_to_gemini_q is None:
                await asyncio.sleep(0.1)
                return None
            try:
                video_frame = await asyncio.wait_for(video_frames_to_gemini_q.get(), timeout=0.02)
                if video_frame is None:
                    return None  # Sentinel received
                video_frames_to_gemini_q.task_done()
                return video_frame
            except asyncio.TimeoutError:
                pass
            except Exception as e:
                logging.error(f"Error getting video from queue: {e}", exc_info=True)
            try:
                audio_chunk = await asyncio.wait_for(audio_chunks_to_gemini_q.get(), timeout=0.02)
                if audio_chunk is None:
                    return None  # Sentinel received
                audio_chunks_to_gemini_q.task_done()
                return audio_chunk
            except asyncio.TimeoutError:
                return None
            except Exception as e:
                logging.error(f"Error getting audio from queue: {e}", exc_info=True)
                return None

        try:
            while self.is_running:
                if not self.gemini_session:
                    await asyncio.sleep(0.1)
                    continue
                media_data = await get_media_from_queues()
                if media_data is None and not self.is_running:
                    break  # Sentinel and stop signal
                    
                if media_data and self.gemini_session and self.is_running:
                    try:
                        validated_media = self._validate_media_payload(media_data)
                        if validated_media:
                            logging.debug(f"Sending media to Gemini. Type: {validated_media.get('mime_type')}, Data size: {len(validated_media.get('data', b'')) if isinstance(validated_media.get('data'), bytes) else len(validated_media.get('data', ''))}")
                            await self.gemini_session.send(input=validated_media)
                        else:
                            # Log if validation failed, but only if media_data was not None initially
                            # (as get_media_from_queues can return None on timeout)
                            if media_data is not None:
                                logging.warning(f"Media validation failed for payload. Type: {media_data.get('mime_type') if isinstance(media_data, dict) else type(media_data)}, skipping send.")
                    except websockets.exceptions.ConnectionClosedError as e_conn_closed:
                        logging.error(f"Connection closed while sending media: {e_conn_closed}", exc_info=True)
                        # Consider how to handle this - e.g., attempt to reconnect or stop the loop.
                        # For now, let's log and potentially stop the interaction loop or specific task.
                        self.is_running = False # Example: stop if connection is lost
                    except Exception as e:
                        logging.error(
                            f"Error sending media chunk to Gemini: {e}", exc_info=True)
                elif not media_data: # media_data could be None if queues were empty and timed out
                    await asyncio.sleep(0.05)  # Yield to other tasks if no media
        except asyncio.CancelledError:
            logging.info("Task cancelled: stream_media_to_gemini.")
        finally:
            logging.info("Task finished: stream_media_to_gemini.")

    async def process_gemini_responses(self):
        logging.info("Task started: Process responses from Gemini.")
        try:
            while self.is_running:
                if not self.gemini_session:
                    await asyncio.sleep(0.1)
                    continue
                if audio_from_gemini_playback_q is None:
                    await asyncio.sleep(0.1)
                    continue
                try:
                    turn_response = self.gemini_session.receive()
                    async for chunk in turn_response:
                        if not self.is_running:
                            break
                        if audio_data := chunk.data:
                            if not audio_from_gemini_playback_q.full():
                                audio_from_gemini_playback_q.put_nowait(audio_data)
                            else:
                                logging.warning(
                                    "Audio playback queue full, discarding Gemini audio data.")
                        if text_response := chunk.text:
                            logging.info(f"Gemini text response: {text_response[:100]}")
                except types.generation_types.StopCandidateException:
                    logging.info("Gemini response stream ended normally.")
                except Exception as e:
                    if self.is_running:
                        logging.error(
                            f"Error receiving from Gemini: {e}", exc_info=True)
                    await asyncio.sleep(0.1)
        except asyncio.CancelledError:
            logging.info("Task cancelled: process_gemini_responses.")
        finally:
            logging.info("Task finished: process_gemini_responses.")

    async def play_gemini_audio(self):
        logging.info("Task started: Play Gemini audio responses.")
        if pya is None:
            logging.warning(
                "PyAudio not available. Audio playback task will not run.")
            return

        try:
            while audio_from_gemini_playback_q is None and self.is_running:
                await asyncio.sleep(0.1)
            if not self.is_running:
                return

            self.playback_stream = await asyncio.to_thread(
                pya.open, format=PYAUDIO_FORMAT, channels=PYAUDIO_CHANNELS, rate=GEMINI_AUDIO_RECEIVE_SAMPLE_RATE, output=True, frames_per_buffer=PYAUDIO_PLAYBACK_CHUNK_SIZE
            )
            logging.info(
                f"PyAudio playback stream opened at {GEMINI_AUDIO_RECEIVE_SAMPLE_RATE} Hz.")
            while self.is_running:
                try:
                    audio_chunk = await asyncio.wait_for(audio_from_gemini_playback_q.get(), timeout=1.0)
                    if audio_chunk is None and not self.is_running:
                        break  # Sentinel and stop signal
                    if audio_chunk:
                        await asyncio.to_thread(self.playback_stream.write, audio_chunk)
                    if audio_chunk:
                        audio_from_gemini_playback_q.task_done()
                except asyncio.TimeoutError:
                    continue
                except Exception as e:
                    logging.error(f"Error playing audio chunk: {e}", exc_info=True)
                    await asyncio.sleep(0.01)
        except Exception as e:
            logging.error(
                f"Failed to open or use PyAudio playback stream (might be expected in this environment): {e}", exc_info=True)
        finally:
            if self.playback_stream:
                logging.info("Stopping and closing PyAudio playback stream.")
                try:
                    await asyncio.to_thread(self.playback_stream.stop_stream)
                    await asyncio.to_thread(self.playback_stream.close)
                except Exception as e_close:
                    logging.error(
                        f"Error closing playback stream: {e_close}", exc_info=True)
                self.playback_stream = None
            logging.info("Task finished: play_gemini_audio.")

    def signal_stop(self):
        logging.info("Signal to stop GeminiInteractionLoop received.")
        self.is_running = False
        for q_name, q_obj_ref in [("video_q", video_frames_to_gemini_q),
                                  ("audio_in_q", audio_chunks_to_gemini_q),
                                  ("audio_out_q", audio_from_gemini_playback_q)]:
            if q_obj_ref:
                try:
                    q_obj_ref.put_nowait(None)
                except asyncio.QueueFull:
                    logging.warning(
                        f"Queue {q_name} was full when trying to put sentinel for stop signal.")
                except Exception as e:
                    logging.error(
                        f"Error putting sentinel in {q_name}: {e}", exc_info=True)

    async def run_main_loop(self):
        global video_frames_to_gemini_q, audio_chunks_to_gemini_q, audio_from_gemini_playback_q

        self.async_event_loop = asyncio.get_running_loop()
        self.is_running = True
        logging.info("GeminiInteractionLoop run_main_loop starting...")

        video_frames_to_gemini_q = asyncio.Queue(
            maxsize=MEDIA_TO_GEMINI_QUEUE_MAXSIZE)
        audio_chunks_to_gemini_q = asyncio.Queue(
            maxsize=MEDIA_TO_GEMINI_QUEUE_MAXSIZE)
        audio_from_gemini_playback_q = asyncio.Queue(
            maxsize=AUDIO_PLAYBACK_QUEUE_MAXSIZE)
        logging.info("Asyncio queues initialized in GeminiInteractionLoop.")

        if client is None:
            logging.critical(
                "Gemini client is None in run_main_loop. Aborting.")
            return

        try:
            async with client.aio.live.connect(model=MODEL_NAME, config=LIVE_CONNECT_CONFIG) as session:
                self.gemini_session = session
                logging.info(
                    f"Gemini session established with API for model {MODEL_NAME}.")
                try:
                    logging.info("Sending system prompt to Gemini...")
                    await self.gemini_session.send_client_content(content=[types.Part(text=MEDICAL_ASSISTANT_SYSTEM_PROMPT)], end_of_turn=True)
                    logging.info("System prompt sent successfully.")
                except Exception as e:
                    logging.error(
                        f"Failed to send system prompt: {e}", exc_info=True)
                    self.is_running = False
                    return

                tasks = []
                try:
                    logging.info("Creating async tasks for Gemini interaction...")
                    media_stream_task = asyncio.create_task(self.stream_media_to_gemini(), name="stream_media_to_gemini")
                    response_process_task = asyncio.create_task(self.process_gemini_responses(), name="process_gemini_responses")
                    audio_play_task = asyncio.create_task(self.play_gemini_audio(), name="play_gemini_audio")
                    tasks = [media_stream_task, response_process_task, audio_play_task]
                    logging.info("All Gemini interaction tasks created.")

                    # Wait for all tasks to complete, collecting all results/exceptions
                    results = await asyncio.gather(*tasks, return_exceptions=True)

                    for i, result in enumerate(results):
                        if isinstance(result, Exception):
                            task_name = tasks[i].get_name() if hasattr(tasks[i], 'get_name') else f"Task-{i}"
                            logging.error(f"Task '{task_name}' failed: {result}", exc_info=result)
                            # If one task fails, we might want to signal others to stop.
                            # self.signal_stop() # This is already called in finally, but could be earlier if needed.
                except asyncio.CancelledError:
                    logging.info("One or more tasks were cancelled during gather.")
                except Exception as e_gather:
                    logging.error(f"Error during task management with asyncio.gather: {e_gather}", exc_info=True)
                finally:
                    # Ensure all tasks are cancelled if not already done, before main loop finally block
                    for task in tasks:
                        if task and not task.done():
                            task.cancel()
                    # Await their cancellation (or completion if they finished cleanly before cancel)
                    if tasks: # Ensure tasks list is not empty
                        await asyncio.gather(*tasks, return_exceptions=True) # Suppress errors from already handled/cancelled tasks
                logging.info("Gemini interaction tasks processing completed or handled.")

        except websockets.exceptions.ConnectionClosedError as e:
            logging.error(f"WebSocket connection closed with error code {e.code}: {e}")
            st.error(f"Connection to Gemini API failed: {e}. Please try again.")
        except asyncio.CancelledError:
            logging.info("GeminiInteractionLoop.run_main_loop() was cancelled.")
        except Exception as e:  # General catch-all
            logging.error(
                f"Exception in GeminiInteractionLoop run_main_loop: {type(e).__name__}: {e}", exc_info=True)
        finally:
            logging.info("GeminiInteractionLoop.run_main_loop() finishing...")
            self.is_running = False
            self.signal_stop()  # Ensure sentinels are sent

            self.gemini_session = None
            video_frames_to_gemini_q = None
            audio_chunks_to_gemini_q = None
            audio_from_gemini_playback_q = None
            logging.info(
                "GeminiInteractionLoop finished and global queues set to None.")


# --- WebRTC Media Processors ---
class VideoProcessor(VideoProcessorBase):
    def __init__(self):
        self.frame_counter = 0
        self.last_gemini_send_time = time.monotonic()

    async def _process_and_queue_frame_async(self, frame_ndarray):
        if video_frames_to_gemini_q is None:
            return
        self.frame_counter += 1
        current_time = time.monotonic()
        if (current_time - self.last_gemini_send_time) < (1.0 / VIDEO_FPS_TO_GEMINI):
            return
        self.last_gemini_send_time = current_time
        try:
            img_rgb = cv2.cvtColor(frame_ndarray, cv2.COLOR_BGR2RGB)
            pil_img = PIL.Image.fromarray(img_rgb)
            pil_img.thumbnail(VIDEO_API_RESIZE)  # Smaller resolution
            image_io = io.BytesIO()
            pil_img.save(image_io, format="jpeg", quality=85)  # Lower quality
            image_bytes = image_io.getvalue()
            
            # Check if image size is too large before encoding to base64
            if len(image_bytes) > MAX_PAYLOAD_SIZE_BYTES:
                logging.warning(f"Image too large ({len(image_bytes)} bytes), reducing quality further")
                image_io = io.BytesIO()
                pil_img.save(image_io, format="jpeg", quality=60)  # Even lower quality
                image_bytes = image_io.getvalue()
                
            api_data = {"mime_type": "image/jpeg",
                        "data": base64.b64encode(image_bytes).decode()}
                        
            if video_frames_to_gemini_q.full():
                try:
                    await asyncio.wait_for(video_frames_to_gemini_q.get(), timeout=0.01)
                except asyncio.TimeoutError:
                    logging.warning("Video queue full, frame dropped.")
                    return
            video_frames_to_gemini_q.put_nowait(api_data)
        except Exception as e:
            logging.error(
                f"Error processing/queueing video frame: {e}", exc_info=True)

    async def recv(self, frame):
        img_bgr = frame.to_ndarray(format="bgr24")
        try:
            loop = asyncio.get_running_loop()
            loop.create_task(self._process_and_queue_frame_async(img_bgr))
        except RuntimeError:
            logging.error(
                "VideoProcessor.recv: No running asyncio loop in current thread for create_task.")
        return frame


class AudioProcessor(AudioProcessorBase):
    async def _process_and_queue_audio_async(self, audio_frames):
        if audio_chunks_to_gemini_q is None:
            return
        for frame in audio_frames:
            audio_data = frame.planes[0].to_bytes()
            
            # Skip empty audio frames
            if not audio_data or len(audio_data) == 0:
                continue
                
            # Fix for the WebSocket error 1007 (invalid payload data)
            # Use the correct mime type format and ensure the audio data is valid
            # The audio format must match one of the formats supported by the Gemini API
            # Using standard audio/L16 with 16kHz sample rate instead of 24kHz
            mime_type = f"audio/L16;rate=16000;channels=1"
            
            try:
                # Prepare API data - making sure all data is valid
                if isinstance(audio_data, bytes) and len(audio_data) > 0:
                    api_data = {"data": audio_data, "mime_type": mime_type}
                    
                    if audio_chunks_to_gemini_q.full():
                        try:
                            await asyncio.wait_for(audio_chunks_to_gemini_q.get(), timeout=0.01)
                        except asyncio.TimeoutError:
                            logging.warning("Audio queue full, chunk dropped.")
                            continue
                    audio_chunks_to_gemini_q.put_nowait(api_data)
            except Exception as e:
                logging.error(
                    f"Error queueing audio chunk: {e}", exc_info=True)

    async def recv(self, frames):
        try:
            loop = asyncio.get_running_loop()
            loop.create_task(self._process_and_queue_audio_async(frames))
        except RuntimeError:
            logging.error(
                "AudioProcessor.recv: No running asyncio loop in current thread for create_task.")
        return frames


# --- Streamlit UI and Application Logic ---
def initialize_app_session_state():
    defaults = {
        'gemini_session_active': False,
        'gemini_loop_instance': None,
        'webrtc_component_key': f"webrtc_streamer_key_{int(time.time())}",
    }
    for key, value in defaults.items():
        if key not in st.session_state:
            st.session_state[key] = value


def run_streamlit_app():
    st.set_page_config(page_title="Voice AI Medical Assistant", layout="wide")
    initialize_app_session_state()

    st.title("Voice AI Medical Assistant")
    
    # Display prominent error if client is not initialized
    if client is None:
        st.error("⚠️ Gemini API key not found or invalid. Please set a valid GEMINI_API_KEY in your .env file.")
        st.info("You can create a .env file in the project directory with content: GEMINI_API_KEY=your_api_key_here")
        
    st.warning("IMPORTANT: This is a VOICE-ONLY interface. Speak to the assistant through your microphone.")
    st.info("Remember: This AI cannot provide medical diagnoses. Always consult a healthcare professional for medical advice.")

    with st.sidebar:
        st.header("Session Control")
        if not st.session_state.gemini_session_active:
            # Fixed emojis
            if st.button("🚀 Start Voice Assistant", type="primary", use_container_width=True, key="start_session_btn"):
                st.session_state.gemini_session_active = True
                
                gemini_loop = GeminiInteractionLoop()
                st.session_state.gemini_loop_instance = gemini_loop
                threading.Thread(target=lambda: asyncio.run(gemini_loop.run_main_loop()), name="GeminiLoopThread", daemon=True).start()
                st.success("Voice Assistant starting... Please allow camera/microphone access in your browser if prompted.")
                st.session_state.webrtc_component_key = f"webrtc_streamer_key_{int(time.time())}"
                st.rerun()
        else:
            # Fixed emojis
            if st.button("🛑 Stop Session", type="secondary", use_container_width=True, key="stop_session_btn"):
                if st.session_state.gemini_loop_instance:
                    st.session_state.gemini_loop_instance.signal_stop()
                st.session_state.gemini_loop_instance = None
                st.session_state.gemini_session_active = False
                st.warning("Session stopping...")
                time.sleep(0.5) 
                st.rerun()

    if st.session_state.gemini_session_active:
        st.subheader("Your Live Feed (from your browser)")
        
        MEDIA_STREAM_CONSTRAINTS = {
            "video": True, 
            "audio": { 
                "sampleRate": {"ideal": WEBRTC_REQUESTED_SEND_SAMPLE_RATE},
                "channelCount": {"exact": WEBRTC_REQUESTED_AUDIO_CHANNELS},
                "echoCancellation": True, 
                "noiseSuppression": True  
            }
        }
        
        webrtc_ctx = webrtc_streamer(
            key=st.session_state.webrtc_component_key,
            mode=WebRtcMode.SENDONLY,
            rtc_configuration={ 
                "iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]
            },
            media_stream_constraints=MEDIA_STREAM_CONSTRAINTS,
            video_processor_factory=VideoProcessor,
            audio_processor_factory=AudioProcessor,
            async_processing=True,
        )

        if webrtc_ctx.state.playing:
            st.success("🎤 Voice Assistant is now ACTIVE. Speak to interact!")
            st.caption("The assistant is listening through your microphone and watching through your camera.")
        elif st.session_state.gemini_session_active:
            st.caption("Connecting... Ensure camera/microphone permissions are granted in your browser.")
            if hasattr(webrtc_ctx.state, 'error') and webrtc_ctx.state.error:
                st.error(f"WebRTC Connection Error: {webrtc_ctx.state.error}")
    else:
        st.info("Click 'Start Voice Assistant' in the sidebar to begin.")
        
    # Visual indicator for voice activity
    if st.session_state.gemini_session_active and webrtc_ctx.state.playing:
        with st.container():
            st.markdown("### How to use the Voice Assistant")
            st.markdown("""  
            1. **Speak naturally** - The assistant is listening through your microphone
            2. **Show things to the camera** - The assistant can see what you're showing
            3. **Listen for responses** - The assistant will speak back to you
            
            You do not need to type anything. This is a completely voice-controlled interface.
            """)


if __name__ == "__main__":
    if client is None:
        logging.critical("Gemini client could not be initialized. Application cannot start.")
    else:
        run_streamlit_app()