Integrating Signals with Cost Tracking

1
from paid.tracing import paid_autoinstrument, paid_tracing, initialize_tracing
2
from openai import OpenAI
3
4
initialize_tracing()
5
paid_autoinstrument(libraries=["openai"])
6
7
openai_client = OpenAI(api_key="<OPENAI_API_KEY>")
8
9
@paid_tracing("your_external_customer_id", external_product_id="your_external_product_id")
10
def chat_with_gpt():
11
    response = openai_client.chat.completions.create(
12
        model="gpt-4",
13
        messages=[{"role": "user", "content": "Hello!"}]
14
    )
15
    return response
16
17
chat_with_gpt()

1
from paid import Paid
2
from openai import OpenAI
3
4
# Initialize clients
5
paid_client = Paid(token="YOUR_PAID_API_KEY")
6
openai_client = OpenAI(api_key="<OPENAI_API_KEY>")
7
8
def process_event(event, customer_id: str, product_id: str):
9
    """
10
    Process an event and send signal via SDK
11
    """
12
    # Step 1: Make AI calls
13
    response = openai_client.chat.completions.create(
14
        model="gpt-4",
15
        messages=[
16
            {"role": "system", "content": "You are an AI SDR assistant"},
17
            {"role": "user", "content": event.content}
18
        ]
19
    )
20
21
    # Step 2: Your business logic
22
    send_response(response.choices[0].message.content)
23
24
    # Step 3: Send signal via SDK
25
    paid_client.signals.create_signals(
26
        signals=[{
27
            "event_name": "email_sent",
28
            "customer": {"external_customer_id": customer_id},
29
            "attribution": {"external_product_id": product_id},
30
            "data": {"response_length": len(response.choices[0].message.content)}
31
        }]
32
    )
33
34
# Call your event processor
35
process_event(incoming_event, "customer_123", "agent_123")

1
from paid import Paid
2
from openai import OpenAI
3
4
# Initialize clients
5
paid_client = Paid(token="YOUR_PAID_API_KEY")
6
openai_client = OpenAI(api_key="<OPENAI_API_KEY>")
7
8
def handle_email_reply(email, customer_id: str):
9
    """
10
    Handle incoming email reply from prospect
11
    """
12
    # AI call #1: Analyze sentiment
13
    sentiment_response = openai_client.chat.completions.create(
14
        model="gpt-4",
15
        messages=[
16
            {"role": "system", "content": "Analyze email sentiment"},
17
            {"role": "user", "content": email.body}
18
        ]
19
    )
20
21
    sentiment = sentiment_response.choices[0].message.content
22
23
    # AI call #2: Generate response
24
    reply_response = openai_client.chat.completions.create(
25
        model="gpt-4",
26
        messages=[
27
            {"role": "system", "content": f"Generate reply. Sentiment: {sentiment}"},
28
            {"role": "user", "content": email.body}
29
        ]
30
    )
31
32
    reply_text = reply_response.choices[0].message.content
33
34
    # Business logic: Send the email
35
    send_email(
36
        to=email.sender,
37
        subject=f"Re: {email.subject}",
38
        body=reply_text
39
    )
40
41
    # Send signal via SDK
42
    paid_client.signals.create_signals(
43
        signals=[{
44
            "event_name": "email_reply_processed",
45
            "customer": {"external_customer_id": customer_id},
46
            "attribution": {"external_product_id": "ai_sdr_product"},
47
            "data": {
48
                "sentiment": sentiment,
49
                "reply_length": len(reply_text)
50
            },
51
            "idempotency_key": f"email_reply_{email.id}"
52
        }]
53
    )
54
55
# Process incoming email
56
handle_email_reply(incoming_email, "acme_account_123")

1
from paid import Paid
2
from openai import OpenAI
3
4
# Initialize clients once
5
paid_client = Paid(token="YOUR_PAID_API_KEY")
6
openai_client = OpenAI(api_key="<OPENAI_API_KEY>")
7
8
def send_signal(event_name: str, customer_id: str, product_id: str, data: dict = None):
9
    """Helper function to send signals"""
10
    signal = {
11
        "event_name": event_name,
12
        "customer": {"external_customer_id": customer_id},
13
        "attribution": {"external_product_id": product_id}
14
    }
15
    if data:
16
        signal["data"] = data
17
18
    paid_client.signals.create_signals(signals=[signal])
19
20
def process_event(event, customer_id: str, product_id: str):
21
    """Process a single agent event"""
22
23
    # Make AI calls as needed
24
    if event.type == "email_received":
25
        response = openai_client.chat.completions.create(
26
            model="gpt-4",
27
            messages=[{"role": "user", "content": event.content}]
28
        )
29
        handle_email_response(response)
30
31
        # Send signal
32
        send_signal("email_processed", customer_id, product_id)
33
34
    elif event.type == "call_completed":
35
        # Different AI calls for call processing
36
        summary = openai_client.chat.completions.create(
37
            model="gpt-4",
38
            messages=[{"role": "user", "content": f"Summarize: {event.transcript}"}]
39
        )
40
41
        send_signal("call_summarized", customer_id, product_id)
42
43
# Event loop
44
while True:
45
    event = get_next_event()  # Your event queue
46
    if event:
47
        process_event(event, "customer_123", "agent_123")

1
from paid import Paid
2
3
paid_client = Paid(token="YOUR_PAID_API_KEY")
4
5
def send_signal(event_name, customer_id, product_id, data=None):
6
    signal = {
7
        "event_name": event_name,
8
        "customer": {"external_customer_id": customer_id},
9
        "attribution": {"external_product_id": product_id},
10
        "data": data or {}
11
    }
12
    paid_client.signals.create_signals(signals=[signal])
13
14
# ✅ Good: One signal per outcome
15
def book_meeting(prospect, customer_id):
16
    # Multiple AI calls OK
17
    analyze_calendar(prospect)
18
    generate_invite(prospect)
19
    send_confirmation(prospect)
20
21
    # Single signal for the outcome
22
    send_signal("meeting_booked", customer_id, "agent_123")
23
24
# ❌ Bad: Multiple signals for same workflow
25
def process_workflow(prospect, customer_id):
26
    analyze_calendar(prospect)
27
    send_signal("calendar_analyzed", customer_id, "agent_123")  # Too granular
28
29
    generate_invite(prospect)
30
    send_signal("invite_generated", customer_id, "agent_123")   # Too granular

1
from paid import Paid
2
3
paid_client = Paid(token="YOUR_PAID_API_KEY")
4
5
signal = {
6
    "event_name": "email_sent",
7
    "customer": {"external_customer_id": "customer_123"},
8
    "attribution": {"external_product_id": "agent_123"},
9
    "idempotency_key": f"email_{email_id}_{timestamp}"  # Unique per event
10
}
11
12
paid_client.signals.create_signals(signals=[signal])