Monetization & cost tracking for AI agents

import { PaidClient, PaidOpenAI } from '@paid-ai/paid-node'
import OpenAI from 'openai'
 
const client = new PaidClient({ token: '<your_paid_api_key>' })
 
// Initialize cost tracking
await client.initializeTracing()
 
// Wrap OpenAI in Paid.ai wrapper
const openaiClient = new OpenAI({ apiKey: '<your_openai_api_key' })
const paidOpenAiWrapper = new PaidOpenAI(openaiClient)
 
// Trace the call
await client.trace('<your_external_customer_id>', async () =>
  paidOpenAiWrapper.images.generate({
    // ...
  })
)
 

from openai import OpenAI
from paid import Paid
from paid.tracing.wrappers import PaidOpenAI
 
# Initialize Paid SDK
client = Paid(token="PAID_API_KEY")
 
openAIClient = PaidOpenAI(OpenAI(api_key="<OPENAI_API_KEY>"))
 
# Initialize tracing, must be after initializing Paid SDK
client.initialize_tracing()
 
 
def image_generate():
    response = openAIClient.images.generate(...)
    return response
 
 
# Trace the call
_ = client.trace(
    external_customer_id="<your_external_customer_id>",
    fn=lambda: image_generate(),
)
 

require 'paid_ruby'
require 'openai'
 
# 1. Initialize the Paid client and tracing
# Replace with your actual Paid API token
paid_client = Paid::Client.new(token: "<your_paid_api_key>")
 
# 2. initialize cost tracking
paid_client.initialize_tracing
 
# 3. Initialize the standard OpenAI client
openai_client = OpenAI::Client.new(
  access_token: "<your_openai_api_key>"
)
 
# 4. Instantiate the wrapper using its full module path
paid_openai_client = Paid::Tracing::Wrappers::PaidOpenAI.new(openai_client: openai_client)
 
def create_image(client)
image_response = client.images.generate(
  parameters: {
    #...
  }
)
end
 
paid_client.capture(external_customer_id: "<your_external_customer_id>") do
    create_image(paid_openai_client)
  end

import { PaidClient } from '@paid-ai/paid-node'
 
const client = new PaidClient({ token: '<your_paid_api_key>' })
 
const additionalData = {
    costData: {
        vendor: "<vendor_name>",
        cost : {
            amount: 0.0001,
            currency: "USD"
        }
    }
};
await client.usage.recordUsage({
    agent_id: "<your_agent_id>",
    event_name: "<your_signal_name>",
    customer_id: "<your_customer_id>",
    data: additionalData,
})
 
// Use `.flush()` to send usage immediately
await client.usage.flush(); 

from paid import Paid, Signal
 
client = Paid(token="<PAID_API_KEY>")
 
signal = Signal(
    event_name="<your_signal_name>",
    agent_id="<your_agent_id>",
    customer_id="<your_external_customer_id>",
    data = {
        "costData": {
            "vendor": "<any_vendor_name>", # can be anything
            "cost": {
                "amount": 0.002,
                "currency": "USD"
            },
            "gen_ai.response.model": "<ai_model_name>",
        }
    }
)
 
_ = client.usage.record_bulk(signals=[signal])

require 'paid_ruby'
 
client = Paid::Client.new(token: "<your_paid_api_key>")
 
client.usage.record_usage(
  signal: {
    event_name: "<your_signal_name>",
    agent_id: "<your_agent_id>",
    customer_id: "<your_customer_id>",
    data: {
        "costData": {
            "vendor": "<vendor_name>", # can be anything
            "cost": {
                "amount": 0.003,
                "currency": "USD"
            }
        }
    }
  }
)
 
client.usage.flush