Call Transfer

1
from signalwire_agents import AgentBase
2
from signalwire_agents.core.function_result import SwaigFunctionResult
3
4
5
class TransferAgent(AgentBase):
6
    def __init__(self):
7
        super().__init__(name="transfer-agent")
8
        self.add_language("English", "en-US", "rime.spore")
9
10
        self.prompt_add_section(
11
            "Role",
12
            "You are a receptionist who can transfer calls to different departments."
13
        )
14
15
        self.define_tool(
16
            name="transfer_to_sales",
17
            description="Transfer the caller to the sales department",
18
            parameters={"type": "object", "properties": {}},
19
            handler=self.transfer_to_sales
20
        )
21
22
    def transfer_to_sales(self, args, raw_data):
23
        return (
24
            SwaigFunctionResult("Transferring you to sales now.")
25
            .connect("+15551234567", final=True)
26
        )
27
28
29
if __name__ == "__main__":
30
    agent = TransferAgent()
31
    agent.run()

1
from signalwire_agents import AgentBase
2
from signalwire_agents.core.function_result import SwaigFunctionResult
3
4
5
class SmartTransferAgent(AgentBase):
6
    def __init__(self):
7
        super().__init__(name="smart-transfer-agent")
8
        self.add_language("English", "en-US", "rime.spore")
9
10
        self.prompt_add_section(
11
            "Role",
12
            "You can transfer calls permanently or temporarily."
13
        )
14
15
        self._register_functions()
16
17
    def _register_functions(self):
18
        self.define_tool(
19
            name="transfer_permanent",
20
            description="Permanently transfer to support (call ends with agent)",
21
            parameters={
22
                "type": "object",
23
                "properties": {
24
                    "number": {"type": "string", "description": "Phone number"}
25
                },
26
                "required": ["number"]
27
            },
28
            handler=self.transfer_permanent
29
        )
30
31
        self.define_tool(
32
            name="transfer_temporary",
33
            description="Temporarily connect to expert, then return to agent",
34
            parameters={
35
                "type": "object",
36
                "properties": {
37
                    "number": {"type": "string", "description": "Phone number"}
38
                },
39
                "required": ["number"]
40
            },
41
            handler=self.transfer_temporary
42
        )
43
44
    def transfer_permanent(self, args, raw_data):
45
        number = args.get("number")
46
        return (
47
            SwaigFunctionResult(f"Transferring you now. Goodbye!")
48
            .connect(number, final=True)
49
        )
50
51
    def transfer_temporary(self, args, raw_data):
52
        number = args.get("number")
53
        return (
54
            SwaigFunctionResult("Connecting you briefly. I'll be here when you're done.")
55
            .connect(number, final=False)
56
        )
57
58
59
if __name__ == "__main__":
60
    agent = SmartTransferAgent()
61
    agent.run()

1
def transfer_to_sip(self, args, raw_data):
2
    return (
3
        SwaigFunctionResult("Connecting to internal support")
4
        .connect("sip:support@company.com", final=True)
5
    )

1
def transfer_with_custom_callerid(self, args, raw_data):
2
    return (
3
        SwaigFunctionResult("Connecting you now")
4
        .connect(
5
            "+15551234567",
6
            final=True,
7
            from_addr="+15559876543"  # Custom caller ID
8
        )
9
    )

1
from signalwire_agents import AgentBase
2
from signalwire_agents.core.function_result import SwaigFunctionResult
3
4
5
class MultiAgentTransfer(AgentBase):
6
    def __init__(self):
7
        super().__init__(name="multi-agent-transfer")
8
        self.add_language("English", "en-US", "rime.spore")
9
10
        self.prompt_add_section("Role", "You route calls to specialized agents.")
11
12
        self.define_tool(
13
            name="transfer_to_billing",
14
            description="Transfer to the billing specialist agent",
15
            parameters={"type": "object", "properties": {}},
16
            handler=self.transfer_to_billing
17
        )
18
19
    def transfer_to_billing(self, args, raw_data):
20
        return (
21
            SwaigFunctionResult(
22
                "I'm transferring you to our billing specialist.",
23
                post_process=True  # Speak message before transfer
24
            )
25
            .swml_transfer(
26
                dest="https://agents.example.com/billing",
27
                ai_response="How else can I help?",  # Used if final=False
28
                final=True
29
            )
30
        )
31
32
33
if __name__ == "__main__":
34
    agent = MultiAgentTransfer()
35
    agent.run()

1
from signalwire_agents import AgentBase
2
from signalwire_agents.core.function_result import SwaigFunctionResult
3
4
5
class ReceptionistAgent(AgentBase):
6
    """Receptionist that routes calls to departments"""
7
8
    DEPARTMENTS = {
9
        "sales": "+15551111111",
10
        "support": "+15552222222",
11
        "billing": "+15553333333",
12
        "hr": "+15554444444"
13
    }
14
15
    def __init__(self):
16
        super().__init__(name="receptionist-agent")
17
        self.add_language("English", "en-US", "rime.spore")
18
19
        self.prompt_add_section(
20
            "Role",
21
            "You are the company receptionist. Help callers reach the right department."
22
        )
23
24
        self.prompt_add_section(
25
            "Available Departments",
26
            "Sales, Support, Billing, Human Resources (HR)"
27
        )
28
29
        self.define_tool(
30
            name="transfer_to_department",
31
            description="Transfer caller to a specific department",
32
            parameters={
33
                "type": "object",
34
                "properties": {
35
                    "department": {
36
                        "type": "string",
37
                        "description": "Department name",
38
                        "enum": ["sales", "support", "billing", "hr"]
39
                    }
40
                },
41
                "required": ["department"]
42
            },
43
            handler=self.transfer_to_department
44
        )
45
46
    def transfer_to_department(self, args, raw_data):
47
        dept = args.get("department", "").lower()
48
49
        if dept not in self.DEPARTMENTS:
50
            return SwaigFunctionResult(
51
                f"I don't recognize the department '{dept}'. "
52
                "Available departments are: Sales, Support, Billing, and HR."
53
            )
54
55
        number = self.DEPARTMENTS[dept]
56
        dept_name = dept.upper() if dept == "hr" else dept.capitalize()
57
58
        return (
59
            SwaigFunctionResult(f"Transferring you to {dept_name} now. Have a great day!")
60
            .connect(number, final=True)
61
        )
62
63
64
if __name__ == "__main__":
65
    agent = ReceptionistAgent()
66
    agent.run()

1
def transfer_with_sms(self, args, raw_data):
2
    caller_number = raw_data.get("caller_id_number")
3
4
    return (
5
        SwaigFunctionResult("I'm transferring you and sending a confirmation text.")
6
        .send_sms(
7
            to_number=caller_number,
8
            from_number="+15559876543",
9
            body="You're being transferred to our support team. Reference #12345"
10
        )
11
        .connect("+15551234567", final=True)
12
    )

1
def announced_transfer(self, args, raw_data):
2
    return (
3
        SwaigFunctionResult(
4
            "Please hold while I transfer you to our specialist. "
5
            "This should only take a moment.",
6
            post_process=True  # AI speaks this before transfer executes
7
        )
8
        .connect("+15551234567", final=True)
9
    )

1
def cold_transfer(self, args, raw_data):
2
    return (
3
        SwaigFunctionResult("Transferring you to support now.")
4
        .connect("+15551234567", final=True)
5
    )

1
def warm_transfer_with_context(self, args, raw_data):
2
    caller_number = raw_data.get("caller_id_number")
3
    call_summary = "Caller needs help with billing dispute"
4
5
    return (
6
        SwaigFunctionResult(
7
            "I'm transferring you to our billing specialist. "
8
            "I'll let them know about your situation.",
9
            post_process=True
10
        )
11
        # Send context via SMS to the agent's phone
12
        .send_sms(
13
            to_number="+15551234567",
14
            from_number="+15559876543",
15
            body=f"Incoming transfer: {caller_number}\n{call_summary}"
16
        )
17
        .connect("+15551234567", final=True)
18
    )

1
def transfer_to_department(self, args, raw_data):
2
    dept = args.get("department", "").lower()
3
4
    DEPARTMENTS = {
5
        "sales": "+15551111111",
6
        "support": "+15552222222",
7
    }
8
9
    if dept not in DEPARTMENTS:
10
        return SwaigFunctionResult(
11
            f"I don't have a number for '{dept}'. "
12
            "I can transfer you to Sales or Support."
13
        )
14
15
    return (
16
        SwaigFunctionResult(f"Transferring to {dept}.")
17
        .connect(DEPARTMENTS[dept], final=True)
18
    )

1
def consultation_transfer(self, args, raw_data):
2
    return (
3
        SwaigFunctionResult(
4
            "Let me connect you with a specialist briefly."
5
        )
6
        .connect(
7
            "+15551234567",
8
            final=False  # Call returns to agent if transfer fails or ends
9
        )
10
    )
11
    # When the call returns, the agent continues the conversation
12
    # The ai_response parameter in swml_transfer can specify what to say

1
def escalate_to_human(self, args, raw_data):
2
    reason = args.get("reason", "Customer requested")
3
4
    # Log the escalation
5
    self.log.info(f"Escalating call: {reason}")
6
7
    return (
8
        SwaigFunctionResult(
9
            "I understand you'd like to speak with a person. "
10
            "Let me transfer you to one of our team members.",
11
            post_process=True
12
        )
13
        .connect("+15551234567", final=True)
14
    )

1
def route_to_queue(self, args, raw_data):
2
    issue_type = args.get("issue_type", "general")
3
4
    QUEUES = {
5
        "billing": "+15551111111",
6
        "technical": "+15552222222",
7
        "sales": "+15553333333",
8
        "general": "+15554444444"
9
    }
10
11
    queue_number = QUEUES.get(issue_type, QUEUES["general"])
12
13
    return (
14
        SwaigFunctionResult(f"Routing you to our {issue_type} team.")
15
        .connect(queue_number, final=True)
16
    )

1
def handoff_to_specialist(self, args, raw_data):
2
    specialty = args.get("specialty")
3
4
    SPECIALIST_AGENTS = {
5
        "billing": "https://agents.example.com/billing",
6
        "technical": "https://agents.example.com/technical",
7
        "sales": "https://agents.example.com/sales"
8
    }
9
10
    if specialty not in SPECIALIST_AGENTS:
11
        return SwaigFunctionResult(
12
            "I don't have a specialist for that area. Let me help you directly."
13
        )
14
15
    return (
16
        SwaigFunctionResult(
17
            f"I'm connecting you with our {specialty} specialist.",
18
            post_process=True
19
        )
20
        .swml_transfer(
21
            dest=SPECIALIST_AGENTS[specialty],
22
            final=True
23
        )
24
    )