mirror of
https://github.com/hanzoai/ai.git
synced 2026-11-20 14:13:23 +00:00
prompt_tokens meant two things. The family and relay paths recorded the part of the prompt read fresh, the table path and the providers the whole prompt, so a cached enso-auto row read cache_read > prompt. No path recorded a cache write: Anthropic's cache_creation_input_tokens was folded into the fresh read and billed at the input rate, though a write is priced above it, and OpenRouter's cache_write_tokens was not read at all. cache_write_tokens was 0 on every row. A record's prompt is now every input token, with the cache reads and writes parts of it, whatever shape the upstream reported: OpenAI's cached_tokens inside prompt_tokens, OpenRouter's cache_write_tokens beside them, Anthropic's two counts beside input_tokens. Pricing bills the input rate on the part read fresh and each cache part at its own rate: a family SKU's cache_read and cache_write (a resold model's input_cache_read and input_cache_write plus the vendor's fee), else the input rate. The Anthropic provider and the OpenAI adapter over Anthropic now read both cache counts, and the providers' settles pass them.
100 lines
4.2 KiB
Go
100 lines
4.2 KiB
Go
// Copyright 2023-2026 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 (
|
|
"context"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
// ServedUsage is the trace input for a request that was BILLED ELSEWHERE — a
|
|
// co-resident subsystem that debits commerce itself (zen's Meter in the unified
|
|
// cloud binary) but must still land in the ONE usage warehouse + o11y span
|
|
// plane this package owns. Money is exact nano-USD when the biller knows it
|
|
// (zen computes both retail and upstream COGS per served tier); 0 falls back to
|
|
// the rate-table recompute.
|
|
type ServedUsage struct {
|
|
Owner string // billing org (who paid) — the warehouse partition key
|
|
User string // actor, "owner/name" when known
|
|
Model string // the SKU the caller requested (zen5, …)
|
|
Provider string // serving family label ("zen")
|
|
RequestID string
|
|
Status string // "success" | "error" | "failover" (an arm that failed)
|
|
ErrorMsg string
|
|
PromptTokens int // the WHOLE prompt; CachedTokens is a part of it
|
|
CompletionTokens int
|
|
BilledNano int64 // exact retail billed, nano-USD; 0 = recompute from rates
|
|
CostNano int64 // exact upstream COGS, nano-USD; 0 = recompute from rates
|
|
StartTime time.Time
|
|
|
|
Served string // the arm that generated the answer (gen_ai.response.model)
|
|
Vendor string // the provider that ran that arm (gen_ai.provider.name)
|
|
Failover string // the arms that failed before it, with why
|
|
CachedTokens int // of PromptTokens: served from the upstream's prompt cache
|
|
WrittenTokens int // of PromptTokens: written to the upstream's prompt cache
|
|
ReasoningTokens int // of CompletionTokens: spent reasoning
|
|
First time.Duration // time from StartTime to the first token of the answer
|
|
}
|
|
|
|
// TraceServedUsage emits the warehouse row (hanzo.cloud_usage) + gen_ai span for
|
|
// a self-billed request — recordTrace WITHOUT recordUsage, so the commerce debit
|
|
// the caller already made is never doubled. One warehouse writer, two billers,
|
|
// zero double-billing. Safe under a nil/zero input: an empty Owner still writes
|
|
// an (unattributed) row so traffic is never silently invisible; StartTime zero
|
|
// anchors at now.
|
|
func TraceServedUsage(ctx context.Context, in ServedUsage) {
|
|
if in.StartTime.IsZero() {
|
|
in.StartTime = time.Now().UTC()
|
|
}
|
|
if in.RequestID == "" {
|
|
in.RequestID = uuid.NewString()
|
|
}
|
|
recordTrace(ctx, servedRecord(in), in.StartTime)
|
|
}
|
|
|
|
// servedRecord projects a ServedUsage onto the usage record recordTrace writes.
|
|
func servedRecord(in ServedUsage) *usageRecord {
|
|
// The record counts the prompt as every path does: PromptTokens is the whole
|
|
// prompt, and CacheReadTokens and CacheWriteTokens the parts of it read from and
|
|
// written to the upstream's cache.
|
|
cached := min(max(in.CachedTokens, 0), max(in.PromptTokens, 0))
|
|
written := min(max(in.WrittenTokens, 0), max(in.PromptTokens, 0)-cached)
|
|
return &usageRecord{
|
|
Owner: in.Owner,
|
|
Organization: in.Owner,
|
|
User: in.User,
|
|
Model: in.Model,
|
|
Provider: in.Provider,
|
|
PromptTokens: max(in.PromptTokens, 0),
|
|
CacheReadTokens: cached,
|
|
CacheWriteTokens: written,
|
|
CompletionTokens: in.CompletionTokens,
|
|
TotalTokens: in.PromptTokens + in.CompletionTokens,
|
|
Served: in.Served,
|
|
Vendor: in.Vendor,
|
|
Failover: in.Failover,
|
|
ReasoningTokens: in.ReasoningTokens,
|
|
First: in.First,
|
|
Currency: "USD",
|
|
Status: in.Status,
|
|
ErrorMsg: in.ErrorMsg,
|
|
RequestID: in.RequestID,
|
|
BilledNanoExact: &in.BilledNano,
|
|
CostNanoExact: &in.CostNano,
|
|
}
|
|
}
|