Files
ai/controllers/model_pricing.go
zeekay 74bd659492 billing: a program in this process is told what its call cost
A call cloud makes for a customer over the plane is covered with a
PaysCaller grant and debits no wallet here, because cloud's meter
charges the customer. It charged its own flat rate, $2 a million
tokens for any model, so an in-process enso-ultra call was billed
below what it cost to serve and an enso-free call was billed at all.

The stated caller now carries a Bill. The caller-paid grant hands it
on, and recordUsage adds each answer's billed amount to it: what the
same answer debits any other caller. The program charges that and
has no price of its own. PriceOf exposes the billed row as a Rate
for a program that must reserve before it calls; a model nobody
priced answers false rather than the conservative default.
2026-10-18 21:46:32 -07:00

721 lines
35 KiB
Go

// Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package controllers
import (
"math"
"strconv"
"strings"
"sync"
"github.com/hanzoai/ai/log"
"github.com/hanzoai/ai/object"
"github.com/hanzoai/decimal"
)
// modelPrice defines per-model economics in dollars per 1M tokens. Input/Output/Cache*
// are the CUSTOMER PRICE (what the org is billed); CostIn/CostOut are the PROVIDER COGS
// (what it costs Hanzo to serve the call). The two are independent facts: a price is
// what we chose to charge, a cost is what an upstream invoices us, and a model may
// state one without the other. Where CostIn/CostOut are unset the cost is not known —
// see costed — and no margin is reported for it.
type modelPrice struct {
InputPerMillion float64 // $ per 1M input tokens (customer price)
OutputPerMillion float64 // $ per 1M output tokens (customer price)
CacheReadPerMillion float64 // $ per 1M cache-read tokens (0 = use InputPerMillion)
CacheWritePerMillion float64 // $ per 1M cache-write tokens (0 = use InputPerMillion)
CostInPerMillion float64 // $ per 1M input tokens (provider COGS; 0 = not known)
CostOutPerMillion float64 // $ per 1M output tokens (provider COGS; 0 = not known)
// Variable: each call bills at the cost its answer states (zenModel.variable), and
// the rates above are only the ceiling a hold reserves, never a price.
Variable bool
// Card is the exact price list of a SKU we resell (zenModel.Card); nil otherwise.
Card *rateCard
}
// costed reports whether this model states what it costs us to serve.
//
// Both legs, because half a COGS is not a COGS: a rate on the input leg and nothing on
// the output leg would price the completion — the expensive half — at zero and read as
// enormous margin.
//
// The rates are what an upstream invoices us. Where they are not configured, nothing
// here knows them, and the honest report is that nobody asked the vendor rather than a
// number chosen so the arithmetic completes. Every caller of costInputPerMillion asks
// this first; there is no path that reads a rate without knowing whether it is one.
func (p modelPrice) costed() bool {
return p.CostInPerMillion > 0 && p.CostOutPerMillion > 0
}
// costInputPerMillion is the provider COGS for input tokens. Ask costed first.
func (p modelPrice) costInputPerMillion() float64 { return p.CostInPerMillion }
// costOutputPerMillion is the provider COGS for output tokens. Ask costed first.
func (p modelPrice) costOutputPerMillion() float64 { return p.CostOutPerMillion }
// modelPricingInfo is the pricing block of a /v1/models row (modelInfo.Pricing),
// emitted ONLY when ai holds real pricing for the model — never synthesized from
// defaults.
//
// Every key names its unit. Prompt and Completion are OpenRouter's keys in
// OpenRouter's unit, US dollars per ONE token as a decimal string, which is what a
// reader of an OpenAI-compatible catalog takes `pricing` to mean. InputPerMillion
// and OutputPerMillion are the same two rates per million tokens, the unit every
// price table here and hanzoai/pricing keep. No per-million figure sits under a
// bare `input`/`output`: Vercel-style catalogs use those keys per token, so a
// reader would price the model a million times over.
//
// Variable marks a router billed at what serves each call: the rates are then the
// most a token can bill, the ceiling its hold reserves, and a call bills its
// serving model's price at our margin, never more than these.
type modelPricingInfo struct {
Prompt string `json:"prompt"` // USD per input token, decimal string
Completion string `json:"completion"` // USD per output token, decimal string
InputPerMillion float64 `json:"input_per_million"` // USD per 1M input tokens
OutputPerMillion float64 `json:"output_per_million"` // USD per 1M output tokens
Variable bool `json:"variable,omitempty"` // the rates are a ceiling; each call bills what served it
// Rates is every rate the model's vendor states, in the vendor's names and units
// (USD per token for prompt, completion, input_cache_read, input_cache_write,
// internal_reasoning, image, audio; per request for request; per search for
// web_search), as billed: the vendor's rate plus the vendor's fee, exact. Present for a
// model we resell.
Rates map[string]string `json:"rates,omitempty"`
// Overrides are the vendor's conditional rates as billed: each states its
// condition (min_prompt_tokens, or utc_start, utc_end and utc_days for hours of
// the day) beside the rates that apply under it.
Overrides []map[string]any `json:"overrides,omitempty"`
}
// pricingInfo projects an internal modelPrice into the public pricing block, or
// returns nil (→ dropped by omitempty) when nobody stated a price. ok is the whole
// question: it reports that a real per-model entry was FOUND, and a found price of
// zero is a price — the one a caller most needs to see, since it says the route is
// free. A variable SKU lists the ceiling its hold reserves, marked variable, so a
// billed model never reads as unpriced. Only a model no source names has its pricing
// block dropped, and so does a rate that is not a number (a YAML `.inf`).
func pricingInfo(p modelPrice, ok bool) *modelPricingInfo {
if !ok || !finite(p.InputPerMillion) || !finite(p.OutputPerMillion) {
return nil
}
info := &modelPricingInfo{
Prompt: perToken(p.InputPerMillion),
Completion: perToken(p.OutputPerMillion),
InputPerMillion: p.InputPerMillion,
OutputPerMillion: p.OutputPerMillion,
Variable: p.Variable,
}
// A resold SKU's rates are stated exactly, never through the float above.
if c := p.Card; c != nil {
if r, ok := c.Rates["prompt"]; ok {
info.Prompt = r
}
if r, ok := c.Rates["completion"]; ok {
info.Completion = r
}
info.Rates, info.Overrides = c.Rates, c.Overrides
}
// The cache prices a call is billed at (cacheReadRate, cacheWriteRate), stated
// wherever the vendor's card does not state them: a model with no cache rate of its
// own bills a read at a tenth of input and a write at cacheWriteMultiple of it, and
// a caller pricing a cached conversation from this catalog reads the same numbers.
// Not a variable SKU: each of its calls bills what served it, cache included.
if p.InputPerMillion > 0 && !p.Variable {
rates := make(map[string]string, len(info.Rates)+2)
for k, v := range info.Rates {
rates[k] = v
}
read, write := cacheRates(p)
if _, ok := rates["input_cache_read"]; !ok {
rates["input_cache_read"] = read
}
if _, ok := rates["input_cache_write"]; !ok {
rates["input_cache_write"] = write
}
info.Rates = rates
}
return info
}
// cacheRates is what a cache read and a cache write of this price bill, per token and
// exactly: the model's own rate when it states one, else the ledger's defaults
// (cacheReadRate, cacheWriteRate) applied in decimal, so $0.80/M reads at
// "0.00000008" and never a float's 8.000000000000002e-08.
func cacheRates(p modelPrice) (read, write string) {
in := decimal.MustParse(perToken(p.InputPerMillion))
read, write = perToken(p.CacheReadPerMillion), perToken(p.CacheWritePerMillion)
if p.CacheReadPerMillion == 0 {
read = in.Mul(decimal.MustParse("0.1")).String()
}
if p.CacheWritePerMillion == 0 {
write = in.Mul(decimal.MustParse(strconv.FormatFloat(cacheWriteMultiple, 'f', -1, 64))).String()
}
return read, write
}
// perToken is a per-million rate as US dollars per token, exactly: the rate is read
// at its shortest round-tripping decimal and its point moved six places, so $0.80/M
// is "0.0000008" and never the float quotient 7.999999999999999e-07.
func perToken(perMillion float64) string {
d := decimal.MustParse(strconv.FormatFloat(perMillion, 'f', -1, 64))
return decimal.NewFromBig(d.Coef(), d.Scale()+6).String()
}
func finite(f float64) bool { return !math.IsNaN(f) && !math.IsInf(f, 0) }
// modelPricing maps upstream model identifiers to their pricing.
// Keyed by user-facing model name (lowercase). Pricing reflects actual
// upstream costs with Hanzo margin applied.
//
// Sources:
// - DO-AI: DigitalOcean GenAI Platform pricing (Feb 2026)
// - Fireworks: Fireworks AI pricing (Feb 2026)
// - OpenAI Direct: OpenAI API pricing (Feb 2026)
var modelPricing = map[string]modelPrice{
// ── DO-AI models (non-premium) ───────────────────────────────────
// OpenAI via DO-AI
"gpt-4o": {InputPerMillion: 2.50, OutputPerMillion: 10.00},
"gpt-4o-mini": {InputPerMillion: 0.15, OutputPerMillion: 0.60},
"gpt-4.1": {InputPerMillion: 2.00, OutputPerMillion: 8.00},
"gpt-5": {InputPerMillion: 5.00, OutputPerMillion: 15.00},
"gpt-5-mini": {InputPerMillion: 1.25, OutputPerMillion: 5.00},
"gpt-5-nano": {InputPerMillion: 0.30, OutputPerMillion: 1.20},
"gpt-5.1-codex-max": {InputPerMillion: 3.00, OutputPerMillion: 12.00},
"gpt-5.2": {InputPerMillion: 5.00, OutputPerMillion: 15.00},
"gpt-5.2-pro": {InputPerMillion: 10.00, OutputPerMillion: 30.00},
"gpt-oss-120b": {InputPerMillion: 0.90, OutputPerMillion: 0.90},
"gpt-oss-20b": {InputPerMillion: 0.20, OutputPerMillion: 0.20},
"o1": {InputPerMillion: 15.00, OutputPerMillion: 60.00},
"o3": {InputPerMillion: 10.00, OutputPerMillion: 40.00},
"o3-mini": {InputPerMillion: 1.10, OutputPerMillion: 4.40},
// Anthropic via DO-AI
"claude-3-5-haiku": {InputPerMillion: 0.80, OutputPerMillion: 4.00},
"claude-3-7-sonnet": {InputPerMillion: 3.00, OutputPerMillion: 15.00},
"claude-4-1-opus": {InputPerMillion: 15.00, OutputPerMillion: 75.00},
"claude-haiku-4-5": {InputPerMillion: 1.00, OutputPerMillion: 5.00},
"claude-opus-4": {InputPerMillion: 15.00, OutputPerMillion: 75.00},
"claude-opus-4-5": {InputPerMillion: 15.00, OutputPerMillion: 75.00},
"claude-opus-4-6": {InputPerMillion: 15.00, OutputPerMillion: 75.00},
"claude-sonnet-4": {InputPerMillion: 3.00, OutputPerMillion: 15.00},
"claude-sonnet-4-5": {InputPerMillion: 3.00, OutputPerMillion: 15.00},
// Open source via DO-AI
"deepseek-r1-distill-70b": {InputPerMillion: 0.35, OutputPerMillion: 1.20},
"llama-3.1-8b": {InputPerMillion: 0.10, OutputPerMillion: 0.10},
"llama-3.3-70b": {InputPerMillion: 0.59, OutputPerMillion: 0.79},
"mistral-nemo": {InputPerMillion: 0.15, OutputPerMillion: 0.15},
"qwen3-32b": {InputPerMillion: 0.20, OutputPerMillion: 0.60},
"gemma-4-31b": {InputPerMillion: 0.18, OutputPerMillion: 0.50}, // DO published rate
// DO-AI embeddings (POST /v1/embeddings). Output cost is 0 — embeddings
// bill on input tokens only. Rates are DigitalOcean's published per-1M
// embedding prices (real, not defaulted).
"bge-m3": {InputPerMillion: 0.02},
"e5-large-v2": {InputPerMillion: 0.02},
"gte-large-en-v1.5": {InputPerMillion: 0.09},
"all-mini-lm-l6-v2": {InputPerMillion: 0.009},
"multi-qa-mpnet-base-dot-v1": {InputPerMillion: 0.009},
// DO-AI Inference Router. The router itself adds no cost (public preview);
// the request bills at the underlying foundation model it selects. There is
// no fixed per-router token price upstream, so this is a conservative
// in-pattern estimate matching the gpt-oss-120b class the routers select
// (DEFAULTED — not a published per-router rate).
"router:general": {InputPerMillion: 0.90, OutputPerMillion: 0.90},
"router:knowledge-base-document": {InputPerMillion: 0.90, OutputPerMillion: 0.90},
"router:software-engineering": {InputPerMillion: 0.90, OutputPerMillion: 0.90},
"router:software-engineering-01": {InputPerMillion: 0.90, OutputPerMillion: 0.90},
"router:writing": {InputPerMillion: 0.90, OutputPerMillion: 0.90},
// ── Fireworks premium models ────────────────────────────────────
"fireworks/cogito-671b": {InputPerMillion: 3.00, OutputPerMillion: 3.00},
"fireworks/deepseek-r1": {InputPerMillion: 3.00, OutputPerMillion: 8.00},
"fireworks/deepseek-v3": {InputPerMillion: 0.90, OutputPerMillion: 0.90},
"fireworks/deepseek-v3p1": {InputPerMillion: 0.90, OutputPerMillion: 0.90},
"fireworks/deepseek-v3p2": {InputPerMillion: 0.90, OutputPerMillion: 0.90},
"fireworks/glm-4p7": {InputPerMillion: 1.80, OutputPerMillion: 6.60},
"fireworks/glm-5": {InputPerMillion: 3.00, OutputPerMillion: 9.60},
"fireworks/glm-5-thinking": {InputPerMillion: 3.00, OutputPerMillion: 9.60},
"fireworks/gpt-oss-120b": {InputPerMillion: 0.90, OutputPerMillion: 0.90},
"fireworks/gpt-oss-20b": {InputPerMillion: 0.20, OutputPerMillion: 0.20},
"fireworks/kimi-k2": {InputPerMillion: 2.00, OutputPerMillion: 8.00},
"fireworks/kimi-k2-thinking": {InputPerMillion: 2.00, OutputPerMillion: 8.00},
"fireworks/kimi-k2p5": {InputPerMillion: 2.50, OutputPerMillion: 10.00},
"fireworks/minimax-m2p5": {InputPerMillion: 1.00, OutputPerMillion: 4.00},
"fireworks/mixtral-8x22b": {InputPerMillion: 0.90, OutputPerMillion: 0.90},
"fireworks/qwen3-4b": {InputPerMillion: 0.30, OutputPerMillion: 0.30},
"fireworks/qwen3-8b": {InputPerMillion: 0.60, OutputPerMillion: 0.60},
"fireworks/qwen3-235b-a22b": {InputPerMillion: 3.60, OutputPerMillion: 3.60},
"fireworks/qwen3-coder-30b-a3b": {InputPerMillion: 1.50, OutputPerMillion: 1.50},
"fireworks/qwen3-coder-480b": {InputPerMillion: 3.60, OutputPerMillion: 3.60},
"fireworks/qwen3-coder-480b-bf16": {InputPerMillion: 4.50, OutputPerMillion: 4.50},
"fireworks/qwen3-next-80b-a3b": {InputPerMillion: 2.70, OutputPerMillion: 2.70},
"fireworks/qwen3-next-80b-a3b-thinking": {InputPerMillion: 2.70, OutputPerMillion: 2.70},
"fireworks/qwen3-vl-30b-a3b": {InputPerMillion: 0.45, OutputPerMillion: 1.80},
"fireworks/qwen3-vl-235b": {InputPerMillion: 1.20, OutputPerMillion: 1.20},
// ── OpenAI Direct premium models ────────────────────────────────
"openai-direct/gpt-4o": {InputPerMillion: 2.50, OutputPerMillion: 10.00},
"openai-direct/gpt-4o-mini": {InputPerMillion: 0.15, OutputPerMillion: 0.60},
"openai-direct/gpt-5": {InputPerMillion: 5.00, OutputPerMillion: 15.00},
"openai-direct/o3": {InputPerMillion: 10.00, OutputPerMillion: 40.00},
"openai-direct/o3-mini": {InputPerMillion: 1.10, OutputPerMillion: 4.40},
// ── Hanzo Decision (POST /v1/decisions) ─────
// Kai is half of Jev's $0.042 per million input tokens, and Jev — reached
// through OpenRouter under its vendor ids — is billed at that list price on the
// input tokens its answer reports. Output is free for both.
"kai": {InputPerMillion: 0.021},
"typesafe/jev-1.13": {InputPerMillion: 0.042},
"~typesafe/jev-latest": {InputPerMillion: 0.042},
// Zen answering a decision is a chat completion the decision service buys from
// Hanzo's router, so its output is priced: both legs at the published Zen chat
// row (zen5's), the two ids being served by one chain.
"zenlm/zen6": {InputPerMillion: 2.28, OutputPerMillion: 7.26},
"zenlm/zen6-flash": {InputPerMillion: 2.28, OutputPerMillion: 7.26},
}
// imagePricePerImageCents maps an image model (user-facing name OR upstream
// fal/OpenAI id, lowercase) to its price per generated image, in cents. Image
// generation is billed per image, NOT per token — the token-based
// calculateCostCents math yields 0 for a 0-token image call, so image billing
// is this separate, explicit seam. Keyed by both the user-facing zen3-image
// name and the upstream id so a lookup succeeds whichever the caller records.
var imagePricePerImageCents = map[string]int64{
// Upstream ids (the do-ai fal image models) — same price, so billing is
// correct whether the record carries the user-facing or upstream name.
"fal-ai/flux/schnell": 5,
"fal-ai/fast-sdxl": 6,
// Stable Diffusion 3.5 Large — synchronous OpenAI /images shape (not fal
// async). DO published rate is $0.08/image. Keyed by both the user-facing
// name and the identical upstream id so billing is correct either way.
"stable-diffusion-3.5-large": 8,
// OpenAI-family image models, if ever routed directly ($0.08/image).
"gpt-image-1": 8,
"dall-e-3": 8,
"dall-e-2": 2,
}
// imageCostCents returns the total cost in cents for generating n images with
// the given model. It matches the user-facing name or the upstream id, falling
// back to a conservative per-image floor for an unknown image model so an image
// call is never silently free. n <= 0 costs nothing.
func imageCostCents(model string, n int) int64 {
if n <= 0 {
return 0
}
m := strings.ToLower(model)
per, ok := imagePricePerImageCents[m]
if !ok {
// Unknown image model: charge a conservative floor rather than $0.
per = 5
}
return per * int64(n)
}
// videoPricePerVideoCents maps a text-to-video model (user-facing name OR
// upstream do-ai id, lowercase) to its price per generated video, in cents. Like
// images, video is billed per unit, NOT per token (the token-based math yields 0
// for a 0-token video call), so video billing is this separate, explicit seam.
// Keyed by both the user-facing zen3-video name and the upstream id so a lookup
// succeeds whichever the caller records.
//
// PRICING NOTE: DigitalOcean publishes NO per-video rate for wan2-2-t2v-a14b (the
// catalog record carries only token fields, which are meaningless for video). 40
// cents/video is a real, defensible estimate: Wan 2.2 T2V on comparable fal /
// serverless GPU markets runs ~$0.20-0.40 for a short clip; 40¢ sits at the top
// of that band with Hanzo margin, and is intentionally an order of magnitude
// above the image rate (5-8¢) since a t2v inference is minutes of A14B compute.
// FLAGGED as best-estimate — refine when DO publishes a per-video price.
var videoPricePerVideoCents = map[string]int64{
// The do-ai text-to-video upstream, callable by its raw id. The zen video
// family (zen-video) is served by the zen service and priced from its catalog.
"wan2-2-t2v-a14b": 40,
}
// ── Audio ── transcription bills per SECOND heard, synthesis per CHARACTER spoken ─
//
// Two tables, not one, because the two directions are sold in different units:
// transcription by the length of the audio, synthesis by the length of the text.
// Collapsing them would force one of the two into a unit its market does not quote.
//
// THE RATES ARE THE PUBLISHED ONES: hanzo.ai/pricing lists Speech-to-Text at $0.006
// per minute and Text-to-Speech at $15 per 1M characters, and these tables are that
// list in nano-USD (1 USD = 1e9) — 100,000 per second and 15,000 per character. Nano
// because a dictated sentence is a few seconds, and a per-call cent would bill it at
// twelve times the published rate; the debit is exact (usageBilledUSD), so the
// quoted rate and the booked one are the same number. Sell prices, not COGS: speech
// runs on our own hardware, so the margin is the whole price (providerCostNano).
//
// Keyed by every id a caller can send that reaches the speech service — the SKU we
// list and the upstream ids that stay callable — so no spelling of the same model is
// cheaper than another. A name absent here meters its quantity and is flagged
// Unpriced by recordUnpriced, never billed at an invented rate.
var sttNanoPerSecond = map[string]int64{
"zen-scribe": 100_000,
"zen-scribe-mini": 100_000,
"parakeet": 100_000,
"whisper": 100_000,
"whisper-small": 100_000,
}
var ttsNanoPerChar = map[string]int64{
"zen-voice-mini": 15_000,
"kokoro": 15_000,
}
// sttCostNano prices a transcription from the seconds of audio it heard, rounding
// UP to the nano. No rate costs nothing (and the row is flagged Unpriced) rather
// than falling back to an invented floor: audio here is OUR service, so an absent
// rate is a decision not made, not a gap to paper over.
func sttCostNano(model string, seconds float64) int64 {
rate := sttNanoPerSecond[strings.ToLower(model)]
if seconds <= 0 || rate <= 0 {
return 0
}
return int64(math.Ceil(seconds * float64(rate)))
}
// ttsCostNano prices a synthesis from the characters it spoke. Same absent-rate
// rule as sttCostNano.
func ttsCostNano(model string, chars int) int64 {
rate := ttsNanoPerChar[strings.ToLower(model)]
if chars <= 0 || rate <= 0 {
return 0
}
return int64(chars) * rate
}
// audioPriced reports whether a configured rate exists for the model in the
// direction the record measured. It is what keeps the Unpriced flag HONEST
// without a second hardcoded `Unpriced: true` at every audio emit site: the flag
// follows the rate table, so setting a rate prices the traffic with no further
// edit at the call sites.
func audioPriced(model string, seconds float64, chars int) bool {
m := strings.ToLower(model)
return seconds > 0 && sttNanoPerSecond[m] > 0 || chars > 0 && ttsNanoPerChar[m] > 0
}
// recordIsAudio reports whether the record measured an audio quantity, in either
// direction. The ONE predicate the cost switches and the Unpriced detector share,
// so they can never disagree about what an audio row is.
func recordIsAudio(record *usageRecord) bool {
return record.AudioSeconds > 0 || record.AudioChars > 0
}
// audioCostNano prices an audio record from whichever quantity it carries. A
// record carries at most one direction (a call either transcribes or
// synthesizes), so the two are summed rather than branched.
func audioCostNano(record *usageRecord) int64 {
return sttCostNano(record.Model, record.AudioSeconds) +
ttsCostNano(record.Model, record.AudioChars)
}
// videoDefaultCostCents is the conservative per-video floor for an unknown video
// model, so a video call is never silently free. Set to the known real rate.
const videoDefaultCostCents int64 = 40
// videoCostCents returns the total cost in cents for generating n videos with
// the given model, matching the user-facing name or the upstream id and falling
// back to a conservative per-video floor for an unknown video model. n <= 0
// costs nothing.
func videoCostCents(model string, n int) int64 {
if n <= 0 {
return 0
}
m := strings.ToLower(model)
per, ok := videoPricePerVideoCents[m]
if !ok {
per = videoDefaultCostCents
}
return per * int64(n)
}
// decisionCostNano is the billed price of a decision in nano-USD: its input and
// output tokens at the model's price, as every model is priced. Kai's and Jev's
// output is priced at zero, so their output tokens move nothing; an LLM model's
// completion, reasoning included, bills at its output price. A count is what the
// service reports, relayed from whatever answered it, so each is bounded: none below
// zero, output at the most a completion is asked for, input short of overflow.
func decisionCostNano(model string, inputTokens, outputTokens int) int64 {
return tokenCostNano(model, min(max(inputTokens, 0), decisionInputTokens),
min(max(outputTokens, 0), decisionOutputTokens), 0, 0)
}
// DO-AI alias pricing (same as their base model)
var aliasPricing = map[string]string{
"openai/gpt-4o": "gpt-4o",
"openai/gpt-4o-mini": "gpt-4o-mini",
"openai/gpt-5": "gpt-5",
"openai/o3": "o3",
"openai/o3-mini": "o3-mini",
"anthropic/claude-haiku-4-5-20251001": "claude-haiku-4-5",
"anthropic/claude-opus-4-6": "claude-opus-4-6",
"anthropic/claude-sonnet-4-5-20250929": "claude-sonnet-4-5",
}
// PriceOf is the price a model is billed at for org, dollars a million tokens by
// class — the same row every call of it is debited from — and whether a real row
// priced it. A model nobody priced answers false rather than the conservative
// default, which is a guess and not a price.
func PriceOf(model, org string) (Rate, bool) {
p, ok := getModelPriceForOrgOK(model, org)
if !ok {
return Rate{}, false
}
return Rate{
Input: p.InputPerMillion,
Output: p.OutputPerMillion,
CacheRead: cacheReadRate(p.InputPerMillion, p.CacheReadPerMillion),
CacheWrite: cacheWriteRate(p.InputPerMillion, p.CacheWritePerMillion),
}, true
}
// getModelPrice looks up pricing for a user-facing model name.
// Returns a default price if the model isn't in the pricing table.
func getModelPrice(model string) modelPrice {
return getModelPriceForOrg(model, "")
}
func getModelPriceForOrg(model string, orgId string) modelPrice {
p, _ := getModelPriceForOrgOK(model, orgId)
return p
}
// getModelPriceForOrgOK is getModelPriceForOrg plus whether a REAL price was found. ok
// is false ONLY when every source missed (family, DB route, conf, static map/alias) and
// the conservative default ($1/$4 per 1M) was synthesized — the caller then marks the
// usage row Unpriced instead of silently trusting an invented price. The returned price
// is byte-identical to getModelPriceForOrg; nothing about billing changes.
func getModelPriceForOrgOK(model string, orgId string) (modelPrice, bool) {
// Zen family: the discovered retail price is the source of truth (hip-00NN).
//
// What the call COSTS us is a separate fact, and the family wire carries no cost
// field — so a family price arrives priced and uncosted, and the cost is completed
// from where costs are registered. Resolving the two together would make restating
// the price the only way to state a family model's COGS, which is how the cost came
// to BE the price.
// A route to the decision service is priced by its own row, never by a family that
// claims the id by prefix or alias: zenlm/zen6 starts with "zen", and the Zen chat
// SKU it names lists at $0.
if !decisionRoute(model) {
if p, ok := familyModelPrice(model); ok {
if !p.costed() {
p.CostInPerMillion, p.CostOutPerMillion = registeredCost(model, orgId)
}
return p, true
}
}
// Check DB route pricing first (org-specific -> global)
//
// Priced is what lets the answer be zero: a route that states its price is the
// price, and a route that states nothing still reads as unstated at zero, so the
// fall-through to config and the static table is unchanged for every row written
// before the column existed.
dbRoute, err := object.ResolveModelRouteFromDB(strings.ToLower(model), orgId)
if err == nil && dbRoute != nil && (dbRoute.Priced || dbRoute.InputPrice > 0 || dbRoute.OutputPrice > 0) {
return modelPrice{
InputPerMillion: dbRoute.InputPrice,
OutputPerMillion: dbRoute.OutputPrice,
CostInPerMillion: dbRoute.CostInPerMillion,
CostOutPerMillion: dbRoute.CostOutPerMillion,
}, true
}
// YAML config pricing. When a config is loaded it is authoritative: a hit is a real
// price, a miss returns the configured default (a synthesized price ⇒ ok=false).
if cfg := GetModelConfig(); cfg != nil {
return cfg.GetPriceOK(model)
}
// Static fallback
m := strings.ToLower(model)
// Direct lookup
if price, ok := modelPricing[m]; ok {
return price, true
}
// Check aliases
if base, ok := aliasPricing[m]; ok {
if price, ok := modelPricing[base]; ok {
return price, true
}
}
// Default: conservative pricing for unknown models — the ONE synthesized price.
return modelPrice{InputPerMillion: 1.00, OutputPerMillion: 4.00}, false
}
// registeredCost is what an operator has recorded that a model costs us, per 1M tokens,
// and 0,0 when nobody has recorded anything.
//
// The route row is the one place a COGS is registered — object.ModelRoute carries the
// pair, and the admin cockpit reads and writes it there. The configured PRICE tables are
// deliberately not consulted: a price is what we charge, and reaching for it here is the
// substitution this function exists to avoid.
//
// Both legs or neither, matching costed(): a row that names only the input rate would
// leave the completion — the expensive half — at zero and report the call as almost pure
// margin.
func registeredCost(model, orgId string) (float64, float64) {
route, err := object.ResolveModelRouteFromDB(strings.ToLower(model), orgId)
if err != nil || route == nil {
return 0, 0
}
if route.CostInPerMillion > 0 && route.CostOutPerMillion > 0 {
return route.CostInPerMillion, route.CostOutPerMillion
}
return 0, 0
}
// unpricedWarned dedupes the unpriced-model warning to once per model id, so a popular
// unknown model logs a single actionable line instead of one per request.
var unpricedWarned sync.Map
// warnUnpricedOnce logs (once per model) that calls are billing at the conservative
// default because the model has no configured price. The row is also flagged Unpriced;
// this log is the ops signal to add the model to conf/models.yaml or a model route.
func warnUnpricedOnce(model string) {
if _, seen := unpricedWarned.LoadOrStore(strings.ToLower(model), struct{}{}); seen {
return
}
log.Warning("pricing: model %q has no configured price — billing at the conservative default ($1.00/$4.00 per 1M); add it to conf/models.yaml or a model route. Its usage rows are flagged unpriced.", model)
}
// recordUnpriced reports whether a token-billed call fell back to the conservative
// default price because the model is unknown to every pricing source. Image/video calls
// have their own per-unit pricing and are never "unpriced" here. The ONE detector, read
// by recordUsage (warn + row flag) and zapWriteUsage (warehouse column).
func recordUnpriced(record *usageRecord) bool {
// A free route has a price and it is zero. Reading "the table has no rate for
// this SKU" as "we guessed" would file the one honest number in the ledger as
// an invented one.
if record.Free {
return false
}
if record.ImageCount > 0 || record.VideoCount > 0 {
return false
}
// Audio is priced per second heard / per character spoken, not per token, so
// the token table cannot answer for it. The flag follows the audio rate table:
// an id with no rate is honestly Unpriced, and setting one prices the traffic
// without touching a single emit site.
if recordIsAudio(record) {
return !audioPriced(record.Model, record.AudioSeconds, record.AudioChars)
}
_, ok := getModelPriceForOrgOK(record.Model, "")
return !ok
}
// costsNothing reports that a model's price is zero on both sides.
//
// It reads the price the LEDGER bills from, so "free" here and "$0.00" on the
// invoice are one fact rather than two opinions that can drift. It fails closed
// twice over: a model whose price is synthesized rather than found reads as not
// free (ok is false), and so does one this cannot name at all — `auto` among them,
// since what that resolves to is not yet decided.
func costsNothing(model, orgId string) bool {
p, ok := getModelPriceForOrgOK(model, orgId)
// A variable SKU bills what each call costs, whatever its rates read.
return ok && !p.Variable && p.InputPerMillion <= 0 && p.OutputPerMillion <= 0
}
// ModelCostsNothing is costsNothing for the router's balance filter, which runs
// BEFORE any controller and therefore before the in-controller gate. Exported for
// the same reason FamilyModelGated is: the filter must be able to ask what a model
// costs without knowing how families and price tables are laid out.
func ModelCostsNothing(model, orgId string) bool { return costsNothing(model, orgId) }
// calculateCostCents computes the cost in cents for a model call.
func calculateCostCents(model string, promptTokens, completionTokens int) int64 {
return calculateCostCentsWithCache(model, promptTokens, completionTokens, 0, 0)
}
// costBreakdown is the per-component dollar cost of a token-billed LLM call. It is
// the ONE place the input/output/cache component split is computed, so the billing
// total (calculateCostCentsWithCache) and the o11y gen_ai span cost-detail
// (_o11y.gen_ai.cost_*) read the same numbers and can never drift.
type costBreakdown struct {
Input float64
Output float64
CacheRead float64
CacheWrite float64
Total float64
}
// Cache writes cost more than the input they store, by how long it is kept:
// Anthropic prices a five-minute write at 1.25x input and a one-hour write at 2x.
const (
cacheWriteMultiple = 1.25
cacheWriteHourMultiple = 2.0
)
// cacheWriteRate is the per-million price of a five-minute cache write: the model's
// own rate when it states one, else cacheWriteMultiple times its input rate. The
// one rule for the price path (modelCostBreakdown) and the nano ledger (tokenNanoAt).
func cacheWriteRate(inputPerM, writePerM float64) float64 {
if writePerM != 0 {
return writePerM
}
return inputPerM * cacheWriteMultiple
}
// modelCostBreakdown computes the per-component dollar cost of a token-billed call.
// promptTokens is every input token, cache reads and writes among them; Input prices
// the part read fresh.
// Cache-read defaults to 10% of input price (Anthropic parity) and cache-write to
// cacheWriteRate when the model declares no explicit cache rate. Pure: a pricing
// lookup and arithmetic, no I/O, no globals mutated — safe to call from the span
// emit path.
func modelCostBreakdown(model string, promptTokens, completionTokens, cacheReadTokens, cacheWriteTokens int) costBreakdown {
price := getModelPrice(model)
// Cache-read price: use explicit CacheReadPerMillion if set, else 10% of input.
cacheReadRate := price.CacheReadPerMillion
if cacheReadRate == 0 && price.InputPerMillion > 0 {
cacheReadRate = price.InputPerMillion * 0.10
}
cacheWriteRate := cacheWriteRate(price.InputPerMillion, price.CacheWritePerMillion)
b := costBreakdown{
Input: float64(fresh(promptTokens, cacheReadTokens, cacheWriteTokens)) * price.InputPerMillion / 1_000_000.0,
Output: float64(completionTokens) * price.OutputPerMillion / 1_000_000.0,
CacheRead: float64(cacheReadTokens) * cacheReadRate / 1_000_000.0,
CacheWrite: float64(cacheWriteTokens) * cacheWriteRate / 1_000_000.0,
}
b.Total = b.Input + b.Output + b.CacheRead + b.CacheWrite
return b
}
// calculateCostCentsWithCache computes cost in cents including cache token pricing.
// Cache-read tokens are billed at 10% of input price and cache-write tokens at
// cacheWriteRate (matching Anthropic).
func calculateCostCentsWithCache(model string, promptTokens, completionTokens, cacheReadTokens, cacheWriteTokens int) int64 {
b := modelCostBreakdown(model, promptTokens, completionTokens, cacheReadTokens, cacheWriteTokens)
costCents := int64(math.Round(b.Total * 100))
// Minimum 1 cent for any non-zero usage
if costCents <= 0 && (promptTokens > 0 || completionTokens > 0 || cacheReadTokens > 0 || cacheWriteTokens > 0) {
costCents = 1
}
return costCents
}