# file: outbound_sip_agent.py
import os
import asyncio
import logging
from typing import Dict
from dataclasses import dataclass

from dotenv import load_dotenv

# LiveKit imports (install with `pip install livekit`)
from livekit import api
from livekit.cluster import LivekitCluster  # optional depending on SDK version
from livekit.agents import AgentSession  # conceptual; adapt to your livekit-agents package
from livekit.rtc import ParticipantKind, TrackKind

load_dotenv()
logging.basicConfig(level=<http://logging.INFO|logging.INFO>)
logger = logging.getLogger("outbound_sip_agent")

# --- Configuration (edit these) ---
LIVEKIT_API_KEY = os.getenv("LIVEKIT_API_KEY")
LIVEKIT_API_SECRET = os.getenv("LIVEKIT_API_SECRET")
LIVEKIT_URL = os.getenv("LIVEKIT_URL")  # e.g. <https://your.livekit.cloud>
SIP_TRUNK_ID = os.getenv("SIP_TRUNK_ID") or "ST_YOUR_OUTBOUND_TRUNK_ID"
CALLER_NUMBER = os.getenv("CALLER_NUMBER") or "+15105550123"
ROOM_NAME = os.getenv("ROOM_NAME") or f"outbound-call-{int(asyncio.get_event_loop().time())}"
# -------------------------------

@dataclass
class ParticipantState:
    identity: str
    kind: ParticipantKind
    is_manager: bool = False

class AgentController:
    def __init__(self, room_name: str):
        self.room_name = room_name
        self.session = None  # AgentSession analog
        self.participants: Dict[str, ParticipantState] = {}
        self.in_intervention = False

    async def start(self):
        # Create a LiveKit API client
        self.lkapi = api.LiveKitAPI()  # adapt constructor if SDK requires url/key/secret
        <http://logger.info|logger.info>("LiveKit API client created")

        # Create room (idempotent)
        try:
            await self.lkapi.create_room(self.room_name)
            <http://logger.info|logger.info>(f"Room created or exists: {self.room_name}")
        except Exception:
            <http://logger.info|logger.info>("Room creation skipped or failed (may already exist)")

        # Dial outbound SIP into the room
        try:
            sip_req = {
                "room_name": self.room_name,
                "sip_trunk_id": SIP_TRUNK_ID,
                "sip_call_to": CALLER_NUMBER,
                "participant_identity": f"sip_{CALLER_NUMBER.replace('+','').replace('-','')}",
                # Depending on SDK, parameters may differ; adapt accordingly.
            }
            sip_participant = await self.lkapi.create_sip_participant(**sip_req)
            <http://logger.info|logger.info>(f"Dialed SIP participant, participant sid: {getattr(sip_participant,'sid', 'unknown')}")
        except Exception as e:
            logger.exception("Failed to create SIP participant (check SIP_TRUNK_ID, credentials): %s", e)
            return

        # Start agent session (conceptual: create AgentSession with STT, TTS, VAD)
        # Replace with your actual AgentSession initialization from your livekit-agents package
        self.session = AgentSession(
            room_name=self.room_name,
            stt_provider="deepgram",    # placeholder; instantiate your STT class
            tts_provider="elevenlabs",  # placeholder; instantiate your TTS class
        )
        # Register callbacks for incoming transcripts and participant events
        self.session.on_participant_published(self._on_participant_published)
        self.session.on_transcript(self._on_transcript)
        self.session.on_rpc(self._on_rpc)

        # Start session (connect to room, publish agent audio if needed)
        await self.session.start()
        <http://logger.info|logger.info>("Agent session started in active (speak+listen) mode")

        # Agent initial greeting (TTS spoken into room)
        await self.session.speak("Hello, this is your service agent. How can I help you today?")

        # Keep running until cancelled
        try:
            while True:
                await asyncio.sleep(1)
        except asyncio.CancelledError:
            <http://logger.info|logger.info>("Shutting down agent session")
        finally:
            await self.session.stop()
            await self.lkapi.aclose()

    async def _on_participant_published(self, participant, publication):
        # Track participants and subscribe to audio for transcription
        identity = participant.identity
        kind = participant.kind
        self.participants[identity] = ParticipantState(identity=identity, kind=kind, is_manager=(kind != ParticipantKind.PARTICIPANT_KIND_SIP))
        <http://logger.info|logger.info>(f"Participant published: {identity} (kind={kind})")

        # Ensure session subscribes to audio track so we can transcribe
        if publication.track_kind == TrackKind.KIND_AUDIO:
            await self.session.subscribe_to_track(participant, publication)

    async def _on_transcript(self, transcript):
        # Transcript object expected to contain: text, participant_identity, is_final
        identity = getattr(transcript, "participant_identity", "unknown")
        text = transcript.text.strip()
        if not text:
            return

        tag = "Manager" if self.participants.get(identity, None) and self.participants[identity].is_manager else "Customer"
        <http://logger.info|logger.info>(f"[{tag}] {identity}: {text}")

        # If in intervention mode, keep transcribing. If not, agent can respond when appropriate.
        if not self.in_intervention and transcript.is_final and tag == "Customer":
            # Example: generate a short reply using LLM -> TTS
            reply = await self.session.generate_reply_for_text(text)
            if reply:
                await self.session.speak(reply)

    async def _on_rpc(self, rpc_name, payload, from_participant):
        # Simple RPC handler that toggles intervention mode from frontend manager
        <http://logger.info|logger.info>(f"RPC received: {rpc_name} from {from_participant}")
        if rpc_name == "enter_intervention_mode":
            await self.enter_intervention_mode(from_participant, payload)
        elif rpc_name == "exit_intervention_mode":
            await self.exit_intervention_mode(from_participant, payload)

    async def enter_intervention_mode(self, manager_identity, payload):
        if self.in_intervention:
            return
        <http://logger.info|logger.info>(f"Manager {manager_identity} requested intervention: {payload}")
        self.in_intervention = True

        # Stop any agent TTS/speaking and ensure agent remains only listening
        await self.session.interrupt()                # stop current speech actions
        await self.session.set_output_enabled(False)  # mute agent's published audio
        await self.session.set_input_enabled(True)    # keep listening

        # Optionally update agent instructions to "listen-only"
        await self.session.update_system_message("You are now in listening mode. Do not speak; only transcribe.")

    async def exit_intervention_mode(self, manager_identity, payload):
        if not self.in_intervention:
            return
        <http://logger.info|logger.info>(f"Manager {manager_identity} exiting intervention: {payload}")
        self.in_intervention = False

        # Re-enable agent output so it can speak again
        await self.session.set_output_enabled(True)
        await self.session.update_system_message("You may resume speaking to the caller.")

# --- Run the controller ---
async def run():
    controller = AgentController(ROOM_NAME)
    await controller.start()

if __name__ == "__main__":
    try:
        asyncio.run(run())
    except KeyboardInterrupt:
        <http://logger.info|logger.info>("Stopped by user")

enter_intervention_mode

exit_intervention_mode

AgentSession

livekit-agents