# example_agent.py
# Adapt imports to your project layout / package names
from livekit_agent import server, JobProcess, AgentSession  # pseudo-imports — replace with your actual modules
import silero
import soniox
from google import LLM as GoogleLLM, TTS as GoogleTTS
# from sarvam import TTS as SarvamTTS  # optional alternative TTS

# Prewarm function runs once per process before sessions start
def prewarm(proc: JobProcess):
    # Load Silero VAD once and store on proc.userdata for reuse
    proc.userdata["vad"] = silero.VAD.load()
    # Optional: log that VAD is prewarmed
    print("Silero VAD prewarmed and stored in proc.userdata['vad']")

# Assign the prewarm function to the server setup hook
server.setup_fnc = prewarm

# Example handler/entrypoint for creating an AgentSession per connection
def handle_new_session(ctx):
    # Retrieve the prewarmed VAD instance
    vad_instance = ctx.proc.userdata.get("vad")
    if vad_instance is None:
        # Fallback: load here (avoid in production; prewarming should have run)
        vad_instance = silero.VAD.load()

    # Configure components matching your provided setup
    llm = GoogleLLM(
        model="gemini-2.5-flash",
        temperature=0.7,
        max_output_tokens=200,
    )

    stt = soniox.STT(
        params=soniox.STTOptions(
            language_hints=["en", "hi", "ta", "te", "ml", "kn"],
            context="User is talking on the phone with a customer support agent.",
            enable_language_identification=True,
            language_hints_strict=True,
        )
    )

    tts = GoogleTTS(
        language="en-IN",
        voice_name="en-IN-Chirp3-HD-Aoede",
        volume_gain_db=2.0,
        use_streaming=True,
        pitch=0,
        # location="us-central1",
    )

    # Create the Agent (your agent class/init may differ)
    agent = YourAgentClass(
        instructions="Your agent instructions here",
        vad=vad_instance,
        turn_detection=MultilingualModel(),  # replace with your actual turn detection init
        llm=llm,
        tts=tts,
        stt=stt,
        allow_interruptions=False,
    )

    # Create the AgentSession; session-level flags as you specified
    session = AgentSession(
        agent=agent,  # if your API expects agent instance here; otherwise adapt
        discard_audio_if_uninterruptible=True,
        preemptive_generation=False,
    )

    # Start or run the session — adapt to your framework's session run method
    session.run(ctx)  # replace with actual run/serve call

# Wire the new-session handler to the server's connection hook
server.on_new_session(handle_new_session)

# If running as a script
if __name__ == "__main__":
    # Start the server/process loop — replace with your actual server start
    server.start()

livekit_agent

YourAgentClass

MultilingualModel

server.start()

server.setup_fnc = prewarm

vad_instance

ctx.proc.userdata

silero.VAD.load()

sip.callStatus

sip.callID

active

sip.callStatus

import asyncio
from collections import defaultdict
from datetime import datetime, timezone

# Replace these with your actual LiveKit SDK imports
# from livekit import Room, Participant, ParticipantKind

# Simple call tracker to determine outcomes
class CallTracker:
    def __init__(self):
        # call_id -> {seen_active: bool, first_seen: datetime, last_status: str}
        self.calls = defaultdict(lambda: {"seen_active": False, "first_seen": None, "last_status": None})

    def update_status(self, call_id: str, new_status: str):
        now = datetime.now(timezone.utc)
        entry = self.calls[call_id]
        if entry["first_seen"] is None:
            entry["first_seen"] = now
        entry["last_status"] = new_status
        if new_status == "active":
            entry["seen_active"] = True

    def finalize_on_hangup(self, call_id: str):
        entry = self.calls.get(call_id)
        if not entry:
            return None
        seen_active = entry["seen_active"]
        last_status = entry["last_status"]
        if last_status == "hangup" and not seen_active:
            return "no_answer"       # rang and then hung up without ever being active
        if last_status == "hangup" and seen_active:
            return "answered_then_hungup"
        if last_status == "active":
            return "answered"
        return last_status

# Instantiate a tracker
tracker = CallTracker()

# Example event handlers (adapt to your SDK event wiring)
async def on_participant_connected(participant):
    # Only handle SIP participants
    if participant.kind != "sip":  # replace with ParticipantKind.PARTICIPANT_KIND_SIP if available
        return

    call_id = participant.attributes.get("sip.callID") or participant.sid or participant.identity
    call_status = participant.attributes.get("sip.callStatus", "unknown")

    tracker.update_status(call_id, call_status)
    print(f"[connected] call_id={call_id} status={call_status}")

    if call_status == "active":
        print(f"✅ Call answered (participant connected active): {call_id}")

    if call_status == "hangup":
        outcome = tracker.finalize_on_hangup(call_id)
        print(f"📴 Call hangup detected on connect: {call_id} -> outcome={outcome}")

# Listen to attribute changes for live updates
async def on_participant_attributes_changed(participant, changed_attributes: dict):
    # Only handle SIP participants
    if participant.kind != "sip":
        return

    call_id = participant.attributes.get("sip.callID") or participant.sid or participant.identity

    if "sip.callStatus" in changed_attributes:
        new_status = changed_attributes["sip.callStatus"]
        tracker.update_status(call_id, new_status)
        print(f"[attr_change] call_id={call_id} sip.callStatus={new_status}")

        if new_status == "active":
            print(f"✅ User has answered the call: {call_id}")

        if new_status == "hangup":
            outcome = tracker.finalize_on_hangup(call_id)
            if outcome == "no_answer":
                print(f"💤 Missed / no answer (ringed then hung up): {call_id}")
            elif outcome == "answered_then_hungup":
                print(f"📞 Answered then hung up: {call_id}")
            else:
                print(f"📴 Hangup outcome: {call_id} -> {outcome}")

# Optional: participant disconnected or removed handler
async def on_participant_disconnected(participant):
    if participant.kind != "sip":
        return
    call_id = participant.attributes.get("sip.callID") or participant.sid or participant.identity
    # If participant disconnects without explicit hangup attribute, treat as hangup
    if tracker.calls.get(call_id):
        tracker.update_status(call_id, "hangup")
        outcome = tracker.finalize_on_hangup(call_id)
        print(f"[disconnected] call_id={call_id} -> outcome={outcome}")

# Example wiring function to attach handlers to your LiveKit Room object
def wire_handlers(room):
    # Replace these with your SDK's event registration methods
    room.on("participant_connected", lambda p: asyncio.create_task(on_participant_connected(p)))
    room.on("participant_updated", lambda p, changes: asyncio.create_task(on_participant_attributes_changed(p, changes)))
    room.on("participant_disconnected", lambda p: asyncio.create_task(on_participant_disconnected(p)))

# Usage example (pseudo-start)
if __name__ == "__main__":
    # room = Room(...)  # create/connect to your LiveKit room
    # wire_handlers(room)
    # run your event loop / room connect lifecycle
    pass

sip.callStatus

"active"

sip.callStatus

"hangup"

"active"

sip.callStatus == "hangup"

active