Cost Tracking

Every completion carries a cost estimate derived from reported token counts

Every completion carries a cost estimate — PraisonAI derives it from the token counts your provider reports.

Cost is computed from the input_tokens and output_tokens your provider returns, multiplied by a per-model rate. When litellm is installed it covers 1000+ models; otherwise a built-in fallback table prices the most common models.

Quick Start

1. Run an agent and read its token counts

   A bare Agent(llm="gpt-4o-mini") records usage automatically. Read the counts back with the global collector:

   from praisonaiagents import Agent
   from praisonaiagents.telemetry.token_collector import get_token_collector
   
   agent = Agent(llm="gpt-4o-mini")
   agent.start("Summarise the theory of relativity in one paragraph")
   
   summary = get_token_collector().get_session_summary()
   print(summary["total_metrics"]["input_tokens"], summary["total_metrics"]["output_tokens"])
   # cost is derived from these counts via calculate_llm_cost()

2. Estimate the cost from those counts

   Pass the counts and the model name to calculate_llm_cost():

   from praisonaiagents.utils.cost_utils import calculate_llm_cost
   
   cost = calculate_llm_cost(
       prompt_tokens=1000,
       completion_tokens=500,
       model="gpt-4o-mini",
   )
   print(f"${cost}")  # $0.00045  →  (1000/1M × $0.15) + (500/1M × $0.60)

3. Read cost from an async agent

   An async run reports the same telemetry as sync — every tool-loop iteration emits llm_end with tokens, cost, and latency.

   import asyncio
   from praisonaiagents import Agent
   from praisonaiagents.telemetry.token_collector import get_token_collector
   
   agent = Agent(llm="gpt-4o-mini")
   
   async def main():
       await agent.astart("Summarise the theory of relativity in one paragraph")
   
   asyncio.run(main())
   
   summary = get_token_collector().get_session_summary()
   print(summary["total_metrics"]["input_tokens"], summary["total_metrics"]["output_tokens"])
   # Same non-zero counts you would see from a sync agent.start(...)

How It Works

Cost is input_tokens × input_rate + output_tokens × output_rate. The only question is which rate applies to a given model name.

How Pricing Is Resolved

The fallback matcher resolves a model name to a rate in three steps:

1. Strip the provider prefix. openai/gpt-4o-mini becomes gpt-4o-mini, so provider-qualified names resolve the same as bare names.
2. Match longest-key-first, on exact match or prefix boundary. The table is searched from the longest key down, and a key only matches when the model name is exactly that key or starts with <key>-…. So gpt-4o-mini is billed at $0.15/1M, not gpt-4o‘s $2.50/1M, and o1-mini no longer matches o1.
3. Fall back to default. If no key matches, the default rate applies. default is never matched by name — it is only the last resort.

Fallback Pricing Table

These are the built-in rates the SDK ships in _FALLBACK_PRICING (USD per 1M tokens). They apply when litellm is not installed.

Common Patterns

from praisonaiagents import Agent
from praisonaiagents.telemetry.token_collector import get_token_collector
from praisonaiagents.utils.cost_utils import calculate_llm_cost

agent = Agent(llm="gpt-4o-mini")
agent.start("Draft a product announcement")

totals = get_token_collector().get_session_summary()["total_metrics"]
cost = calculate_llm_cost(totals["input_tokens"], totals["output_tokens"], model="gpt-4o-mini")
print(f"${cost}")

from praisonaiagents import Agent

agent = Agent(llm="anthropic/claude-3-5-sonnet-20240620")
agent.start("Summarise the theory of relativity in one paragraph")

print(agent.total_cost)                 # non-zero
print(agent.cost_summary["llm_calls"])  # >= 1

from praisonaiagents.utils.cost_utils import calculate_llm_cost

print(calculate_llm_cost(1000, 500, model="openai/gpt-4o-mini"))  # 0.00045
print(calculate_llm_cost(1000, 500, model="gpt-4o-mini"))         # 0.00045 — same

Best Practices

Related