Agents telephony integration

{
    "rule": {
        "dispatchRuleIndividual": {
            "roomPrefix": "call-"
        }
    }
}

# ... your existing agent code ...

if __name__ == "__main__":
    agents.cli.run_app(agents.WorkerOptions(
        entrypoint_fnc=entrypoint,

        # Add the agent_name parameter to your WorkerOptions
        agent_name="my-outbound-caller-agent"
    ))

# add these imports at the top of your file
from livekit import api
import json

# ... any existing code / imports ...

def entrypoint(ctx: agents.JobContext):
    await ctx.connect(auto_subscribe=AutoSubscribe.AUDIO_ONLY)

    # If a phone number was provided, then place an outbound call
    # By having a condition like this, you can use the same agent for inbound/outbound telephony as well as web/mobile/etc.
    phone_number = json.loads(ctx.job.metadata)["phone_number"]

    # The participant's identity can be anything you want, but this example uses the phone number itself
    sip_participant_identity = phone_number
    if phone_number is not None:
        # The outbound call will be placed after this method is executed
        try:
             await ctx.api.sip.create_sip_participant(api.CreateSIPParticipantRequest(
                # This ensures the participant joins the correct room
                room_name=ctx.room.name,

                # This is the outbound trunk ID to use (i.e. which phone number the call will come from)
                # You can get this from LiveKit CLI with `lk sip outbound list`
                sip_trunk_id='ST_xxxx',

                # The outbound phone number to dial and identity to use
                sip_call_to=phone_number,
                participant_identity=sip_participant_identity,
            ))
        except Exception:
            # An error occurred such as invalid phone number, trunk configuration, network connectivity, etc.
            pass
    
    # .. start your AgentSession as normal ...

# Add this import at the top of your file
from livekit import rtc

def entrypoint(ctx: agents.JobContext):
    ### ... existing code to connect and create sip participant ...

    # Monitor the SIP participant's attributes for changes
    @ctx.room.on("participant_attributes_changed")
    def on_attributes_changed(
        changed_attributes: dict[str, str], participant: rtc.Participant
    ):
        if participant.identity == sip_participant_identity:
            if changed_attributes.get("sip.callStatus") == "dialing":
                # outbound call is dialing and not yet answered
                pass
            elif changed_attributes.get("sip.callStatus") == "active":
                # call has been answered (either by human or machine)
                pass
            elif changed_attributes.get("sip.callStatus") == "hangup":
                # call has been ended
                pass
            elif changed_attributes.get("sip.callStatus") == "automation":
                # call has connected but is still dialing DTMF numbers (changes to `active` after completion)
                pass

    # Watch for the SIP participant to leave the room
    @ctx.room.on("participant_disconnected")
    def on_participant_disconnected(participant: rtc.Participant):
        if participant.identity == sip_participant_identity:
            # SIP participant has hung up
            pass

    ### ... existing code to start AgentSession ...

import asyncio # add this import at the top of your file

class Assistant(Agent):
    ## ... existing init code ...
        
    @function_tool
    async def detected_answering_machine(self):
        """Call this tool if you have detected a voicemail system, AFTER hearing the voicemail greeting"""
        await self.session.say("I'll call back later.")
        await asyncio.sleep(0.5) # Add a natural gap to the end of the voicemail message
        await hangup_call()

# Add these imports at the top of your file
from livekit import api, rtc

# Add this function definition anywhere, then call it to disconnect all remote SIP participants.
async def hangup_call():
    ctx = agents.job.get_current_job_context()
    if ctx is None:
        # Not running in a job context
        return
    
    sip_participants = [
        p for p in ctx.room.remote_participants.values() 
        if p.kind == rtc.ParticipantKind.PARTICIPANT_KIND_SIP
    ]
    
    for participant in sip_participants:
        await ctx.api.room.remove_participant(
            api.RoomParticipantIdentity(
                room=ctx.room.name,
                identity=participant.identity,
            )
        )