State Management

1
from signalwire_agents import AgentBase
2
3
4
class CustomerAgent(AgentBase):
5
    def __init__(self):
6
        super().__init__(name="customer-agent")
7
        self.add_language("English", "en-US", "rime.spore")
8
9
        # Set initial global data at agent creation
10
        self.set_global_data({
11
            "business_name": "Acme Corp",
12
            "support_hours": "9 AM - 5 PM EST",
13
            "current_promo": "20% off first order"
14
        })
15
16
        self.prompt_add_section(
17
            "Role",
18
            "You are a customer service agent for ${global_data.business_name}."
19
        )
20
21
22
if __name__ == "__main__":
23
    agent = CustomerAgent()
24
    agent.run()

1
self.update_global_data({
2
    "customer_tier": "premium",
3
    "account_balance": 150.00
4
})

1
from signalwire_agents import AgentBase
2
from signalwire_agents.core.function_result import SwaigFunctionResult
3
4
5
class StateAgent(AgentBase):
6
    def __init__(self):
7
        super().__init__(name="state-agent")
8
        self.add_language("English", "en-US", "rime.spore")
9
10
        self.define_tool(
11
            name="set_customer_name",
12
            description="Store the customer's name",
13
            parameters={
14
                "type": "object",
15
                "properties": {
16
                    "name": {"type": "string", "description": "Customer name"}
17
                },
18
                "required": ["name"]
19
            },
20
            handler=self.set_customer_name
21
        )
22
23
    def set_customer_name(self, args, raw_data):
24
        name = args.get("name", "")
25
26
        return (
27
            SwaigFunctionResult(f"Stored name: {name}")
28
            .update_global_data({"customer_name": name})
29
        )
30
31
32
if __name__ == "__main__":
33
    agent = StateAgent()
34
    agent.run()

1
self.prompt_add_section(
2
    "Customer Info",
3
    """
4
    Customer Name: ${global_data.customer_name}
5
    Account Tier: ${global_data.customer_tier}
6
    Current Balance: ${global_data.account_balance}
7
    """
8
)

1
def process_order(self, args, raw_data):
2
    order_id = create_order()
3
4
    return (
5
        SwaigFunctionResult(f"Created order {order_id}")
6
        .set_metadata({"order_id": order_id, "status": "pending"})
7
    )

1
def cancel_order(self, args, raw_data):
2
    return (
3
        SwaigFunctionResult("Order cancelled")
4
        .remove_metadata(["order_id", "status"])
5
    )

1
from signalwire_agents import AgentBase
2
3
4
class SurveyAgent(AgentBase):
5
    def __init__(self):
6
        super().__init__(name="survey-agent")
7
        self.add_language("English", "en-US", "rime.spore")
8
9
        self.prompt_add_section(
10
            "Role",
11
            "Conduct a customer satisfaction survey."
12
        )
13
14
        # Post-prompt extracts structured data after call
15
        self.set_post_prompt("""
16
            Summarize the survey results as JSON:
17
            {
18
                "satisfaction_score": <1-10>,
19
                "main_feedback": "<summary>",
20
                "would_recommend": <true/false>,
21
                "issues_mentioned": ["<issue1>", "<issue2>"]
22
            }
23
        """)
24
25
        # Optionally set where to send the data
26
        self.set_post_prompt_url("https://example.com/survey-results")
27
28
29
if __name__ == "__main__":
30
    agent = SurveyAgent()
31
    agent.run()

1
self.set_post_prompt_llm_params(
2
    model="gpt-4o-mini",
3
    temperature=0.3  # Lower for consistent extraction
4
)

1
def my_handler(self, args, raw_data):
2
    # Available call information
3
    call_id = raw_data.get("call_id")
4
    caller_id_number = raw_data.get("caller_id_number")
5
    caller_id_name = raw_data.get("caller_id_name")
6
    call_direction = raw_data.get("call_direction")  # "inbound" or "outbound"
7
8
    # Current AI interaction state
9
    ai_session_id = raw_data.get("ai_session_id")
10
11
    self.log.info(f"Call from {caller_id_number}")
12
13
    return SwaigFunctionResult("Processing...")

1
#!/usr/bin/env python3
2
## order_agent.py - Order management with state
3
from signalwire_agents import AgentBase
4
from signalwire_agents.core.function_result import SwaigFunctionResult
5
6
7
class OrderAgent(AgentBase):
8
    def __init__(self):
9
        super().__init__(name="order-agent")
10
        self.add_language("English", "en-US", "rime.spore")
11
12
        # Initial global state
13
        self.set_global_data({
14
            "store_name": "Pizza Palace",
15
            "order_items": [],
16
            "order_total": 0.0
17
        })
18
19
        self.prompt_add_section(
20
            "Role",
21
            "You are an order assistant for ${global_data.store_name}. "
22
            "Help customers place their order."
23
        )
24
25
        self.prompt_add_section(
26
            "Current Order",
27
            "Items: ${global_data.order_items}\n"
28
            "Total: $${global_data.order_total}"
29
        )
30
31
        # Post-prompt for order summary
32
        self.set_post_prompt("""
33
            Extract the final order as JSON:
34
            {
35
                "items": [{"name": "", "quantity": 0, "price": 0.00}],
36
                "total": 0.00,
37
                "customer_name": "",
38
                "special_instructions": ""
39
            }
40
        """)
41
42
        self._register_functions()
43
44
    def _register_functions(self):
45
        self.define_tool(
46
            name="add_item",
47
            description="Add an item to the order",
48
            parameters={
49
                "type": "object",
50
                "properties": {
51
                    "item": {"type": "string", "description": "Item name"},
52
                    "price": {"type": "number", "description": "Item price"}
53
                },
54
                "required": ["item", "price"]
55
            },
56
            handler=self.add_item
57
        )
58
59
    def add_item(self, args, raw_data):
60
        item = args.get("item")
61
        price = args.get("price", 0.0)
62
63
        # Note: In real implementation, maintain state server-side
64
        # This example shows the pattern
65
        return (
66
            SwaigFunctionResult(f"Added {item} (${price}) to your order")
67
            .update_global_data({
68
                "last_item_added": item,
69
                "last_item_price": price
70
            })
71
        )
72
73
74
if __name__ == "__main__":
75
    agent = OrderAgent()
76
    agent.run()

1
from signalwire_agents.core.data_map import DataMap
2
from signalwire_agents.core.function_result import SwaigFunctionResult
3
4
lookup_dm = (
5
    DataMap("lookup_customer")
6
    .description("Look up customer by ID")
7
    .parameter("customer_id", "string", "Customer ID", required=True)
8
    .webhook(
9
        "GET",
10
        "https://api.example.com/customers/${enc:args.customer_id}"
11
        "?store=${enc:global_data.store_id}"
12
    )
13
    .output(SwaigFunctionResult(
14
        "Customer: ${response.name}, Tier: ${response.tier}"
15
    ))
16
)

1
self.set_global_data({
2
    "customer_name": "",
3
    "customer_email": "",
4
    "order_total": 0.0,
5
    "current_step": "greeting"
6
})

1
# Harder to access and update
2
self.set_global_data({
3
    "customer": {
4
        "profile": {
5
            "personal": {
6
                "name": ""  # ${global_data.customer.profile.personal.name} is cumbersome
7
            }
8
        }
9
    }
10
})

1
# Good: Clear, consistent naming
2
self.set_global_data({
3
    "order_id": "",
4
    "order_items": [],
5
    "order_total": 0.0,
6
    "customer_name": "",
7
    "customer_phone": ""
8
})
9
10
# Avoid: Inconsistent naming
11
self.set_global_data({
12
    "orderId": "",
13
    "items": [],
14
    "total": 0.0,
15
    "customerName": "",
16
    "phone": ""
17
})

1
def my_handler(self, args, raw_data):
2
    self.log.info(f"Current global_data: {raw_data.get('global_data', {})}")
3
    # ... rest of handler