Integrating Signals with Cost Tracking

1
from paid import Paid
2
from paid.tracing import paid_tracing
3
from paid.tracing.wrappers import PaidOpenAI
4
from openai import OpenAI
5
6
# Initialize Paid client
7
client = Paid(token="<YOUR_API_KEY>")
8
9
# Wrap your AI provider client
10
openai_client = PaidOpenAI(OpenAI(api_key="<OPENAI_API_KEY>"))
11
12
@paid_tracing("customer_123", "agent_123")
13
def process_event(event):
14
    """
15
    Process an agent event - wrapped in tracing context
16
    """
17
    # Step 1: Make AI calls (automatically traced)
18
    response = openai_client.chat.completions.create(
19
        model="gpt-4",
20
        messages=[
21
            {"role": "system", "content": "You are an AI SDR assistant"},
22
            {"role": "user", "content": event.content}
23
        ]
24
    )
25
26
    # Step 2: Your business logic
27
    send_response(response.choices[0].message.content)
28
29
    # Step 3: Emit signal with cost tracing enabled
30
    client.signal(
31
        event_name="email_sent",
32
        data={"response_length": len(response.choices[0].message.content)},
33
        enable_cost_tracing=True  # Link costs to this signal
34
    )
35
36
# Call your event processor
37
process_event(incoming_event)

1
from paid import Paid
2
from paid.tracing import paid_tracing
3
from paid.tracing.wrappers import PaidOpenAI
4
from openai import OpenAI
5
6
# Initialize
7
client = Paid(token="<YOUR_API_KEY>")
8
openai_client = PaidOpenAI(OpenAI(api_key="<OPENAI_API_KEY>"))
9
10
@paid_tracing("acme_account_123", "ai_sdr_agent")
11
def handle_email_reply(email):
12
    """
13
    Handle incoming email reply from prospect
14
    """
15
    # AI call #1: Analyze sentiment
16
    sentiment_response = openai_client.chat.completions.create(
17
        model="gpt-4",
18
        messages=[
19
            {"role": "system", "content": "Analyze email sentiment"},
20
            {"role": "user", "content": email.body}
21
        ]
22
    )
23
24
    sentiment = sentiment_response.choices[0].message.content
25
26
    # AI call #2: Generate response
27
    reply_response = openai_client.chat.completions.create(
28
        model="gpt-4",
29
        messages=[
30
            {"role": "system", "content": f"Generate reply. Sentiment: {sentiment}"},
31
            {"role": "user", "content": email.body}
32
        ]
33
    )
34
35
    reply_text = reply_response.choices[0].message.content
36
37
    # Business logic: Send the email
38
    send_email(
39
        to=email.sender,
40
        subject=f"Re: {email.subject}",
41
        body=reply_text
42
    )
43
44
    # Emit signal - costs from BOTH AI calls will be attributed here
45
    client.signal(
46
        event_name="email_reply_processed",
47
        data={
48
            "sentiment": sentiment,
49
            "reply_length": len(reply_text)
50
        },
51
        enable_cost_tracing=True
52
    )
53
54
    # Optional: Emit additional signal WITHOUT cost tracing
55
    # (to track the event without duplicating costs)
56
    client.signal(
57
        event_name="email_sentiment_analyzed",
58
        data={"sentiment": sentiment},
59
        enable_cost_tracing=False  # Don't link costs to this one
60
    )
61
62
# Process incoming email
63
handle_email_reply(incoming_email)

1
from paid import Paid
2
from paid.tracing import paid_tracing
3
from paid.tracing.wrappers import PaidOpenAI
4
from openai import OpenAI
5
6
# Initialize once
7
client = Paid(token="<YOUR_API_KEY>")
8
openai_client = PaidOpenAI(OpenAI(api_key="<OPENAI_API_KEY>"))
9
10
@paid_tracing("customer_123", "agent_123")
11
def process_agent_event(event):
12
    """Process a single agent event with cost tracking"""
13
14
    # Make AI calls as needed
15
    if event.type == "email_received":
16
        response = openai_client.chat.completions.create(
17
            model="gpt-4",
18
            messages=[{"role": "user", "content": event.content}]
19
        )
20
        handle_email_response(response)
21
22
        # Emit signal with cost tracing
23
        client.signal(
24
            event_name="email_processed",
25
            enable_cost_tracing=True
26
        )
27
28
    elif event.type == "call_completed":
29
        # Different AI calls for call processing
30
        summary = openai_client.chat.completions.create(
31
            model="gpt-4",
32
            messages=[{"role": "user", "content": f"Summarize: {event.transcript}"}]
33
        )
34
35
        client.signal(
36
            event_name="call_summarized",
37
            enable_cost_tracing=True
38
        )
39
40
# Event loop
41
while True:
42
    event = get_next_event()  # Your event queue
43
    if event:
44
        process_agent_event(event)  # Each call creates a new trace