mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-17 07:08:01 +08:00
Add attempt-scoped HomeSelection metadata carrying the reused and additional flags, scheduling route model, and credential policy through usage records to the Redis queue. Mark retained executions and Codex duplex successors as reused so Home can compensate later turns after completion without redispatching or reacquiring a concurrency slot. Mark split additional-model records as additional so they never add scheduling charges, while preserving independent per-response execution IDs for deduplication. Document the deferred accounting and add coverage across conductor, duplex, reporter, and queue.
4167 lines
129 KiB
Go
4167 lines
129 KiB
Go
package helps
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"mime"
|
|
"mime/multipart"
|
|
"net/http"
|
|
"reflect"
|
|
"strings"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
|
|
"github.com/MoeForge/moego/ojson"
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/google/uuid"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/clienterror"
|
|
internallogging "github.com/router-for-me/CLIProxyAPI/v8/internal/logging"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/thinking"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/internal/util"
|
|
cliproxyauth "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/auth"
|
|
cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/executor"
|
|
"github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/usage"
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
type UsageReporter struct {
|
|
requestID string
|
|
traceID string
|
|
selectionID string
|
|
homeSelection *usage.HomeSelection
|
|
provider string
|
|
baseURL string
|
|
executorType string
|
|
model string
|
|
alias string
|
|
authID string
|
|
authIndex string
|
|
authMu sync.RWMutex
|
|
accessTokenHash string
|
|
authType string
|
|
apiKey string
|
|
accessProvider string
|
|
isNativeKey bool
|
|
sessionID string
|
|
parentSessionID string
|
|
source string
|
|
reasoning string
|
|
serviceTier string
|
|
effectiveServiceTier string
|
|
generate bool
|
|
stream bool
|
|
requestedAt time.Time
|
|
ttftMu sync.RWMutex
|
|
ttft time.Duration
|
|
firstPacketDuration time.Duration
|
|
firstPacketSet bool
|
|
ttftStart time.Time
|
|
ttftSet bool
|
|
once sync.Once
|
|
|
|
responseModelMu sync.RWMutex
|
|
// responseModel holds the latest model name reported by the upstream response.
|
|
responseModel string
|
|
// responseModelFinal marks that a terminal event already reported the served
|
|
// model, so later frames skip parsing entirely.
|
|
responseModelFinal atomic.Bool
|
|
|
|
upstreamModelMu sync.RWMutex
|
|
// upstreamModel holds the canonical upstream model expected to be served when
|
|
// it differs from the requested model (e.g. local Kimi model mappings).
|
|
upstreamModel string
|
|
}
|
|
|
|
type usageExecutor interface {
|
|
Identifier() string
|
|
}
|
|
|
|
func NewExecutorUsageReporter(ctx context.Context, executor usageExecutor, model string, auth *cliproxyauth.Auth) *UsageReporter {
|
|
provider := ""
|
|
if executor != nil {
|
|
provider = executor.Identifier()
|
|
}
|
|
reporter := NewUsageReporter(ctx, provider, model, auth)
|
|
reporter.executorType = ExecutorTypeName(executor)
|
|
return reporter
|
|
}
|
|
|
|
func NewUsageReporter(ctx context.Context, provider, model string, auth *cliproxyauth.Auth) *UsageReporter {
|
|
apiKey := APIKeyFromContext(ctx)
|
|
accessProvider := AccessProviderFromContext(ctx)
|
|
isNativeKey := false
|
|
if nativeExplicit, ok := usage.IsNativeKeyFromContext(ctx); ok {
|
|
isNativeKey = nativeExplicit
|
|
} else if accessProvider != "" {
|
|
isNativeKey = usage.IsNativeAccessProvider(accessProvider)
|
|
}
|
|
alias := usage.RequestedModelAliasFromContext(ctx)
|
|
if alias == "" {
|
|
alias = model
|
|
}
|
|
sessionID := ""
|
|
parentSessionID := ""
|
|
clientMeta := internallogging.GetClientRequestMetadata(ctx)
|
|
if clientMeta.SessionID != "" {
|
|
sessionID = clientMeta.SessionID
|
|
parentSessionID = clientMeta.ParentSessionID
|
|
if sessionID == parentSessionID || !isHierarchyParent(sessionID, parentSessionID) {
|
|
parentSessionID = ""
|
|
}
|
|
}
|
|
baseURL := ""
|
|
if auth != nil {
|
|
if auth.Attributes != nil {
|
|
baseURL = strings.TrimSpace(auth.Attributes["base_url"])
|
|
}
|
|
if baseURL == "" && auth.Metadata != nil {
|
|
if v, ok := auth.Metadata["base_url"].(string); ok {
|
|
baseURL = strings.TrimSpace(v)
|
|
}
|
|
}
|
|
}
|
|
traceID := usage.TraceIDFromContext(ctx)
|
|
if traceID == "" {
|
|
traceID = internallogging.GetRequestID(ctx)
|
|
}
|
|
reporter := &UsageReporter{
|
|
requestID: uuid.NewString(),
|
|
traceID: traceID,
|
|
selectionID: usage.SelectionIDFromContext(ctx),
|
|
homeSelection: usage.HomeSelectionFromContext(ctx),
|
|
provider: provider,
|
|
baseURL: baseURL,
|
|
model: model,
|
|
alias: strings.TrimSpace(alias),
|
|
requestedAt: time.Now(),
|
|
apiKey: apiKey,
|
|
accessProvider: accessProvider,
|
|
isNativeKey: isNativeKey,
|
|
sessionID: sessionID,
|
|
parentSessionID: parentSessionID,
|
|
source: resolveUsageSource(auth, apiKey),
|
|
authType: resolveUsageAuthType(auth),
|
|
reasoning: usage.ReasoningEffortFromContext(ctx),
|
|
serviceTier: usage.ServiceTierFromContext(ctx),
|
|
generate: usage.GenerateFromContext(ctx),
|
|
stream: usage.StreamFromContext(ctx),
|
|
}
|
|
if auth != nil {
|
|
reporter.authID = auth.ID
|
|
reporter.authIndex = auth.EnsureIndex()
|
|
reporter.accessTokenHash = authAccessTokenSHA256(auth)
|
|
}
|
|
return reporter
|
|
}
|
|
|
|
// SetStream records whether the request was executed in streaming mode.
|
|
func (r *UsageReporter) SetStream(stream bool) {
|
|
if r == nil {
|
|
return
|
|
}
|
|
r.stream = stream
|
|
}
|
|
|
|
// SetSessionHierarchy sets the explicit session and parent session identifiers.
|
|
// Callers should invoke this method before Publish or EnsurePublished on the request thread.
|
|
func (r *UsageReporter) SetSessionHierarchy(sessionID, parentSessionID string) {
|
|
if r == nil {
|
|
return
|
|
}
|
|
r.sessionID = strings.TrimSpace(sessionID)
|
|
r.parentSessionID = strings.TrimSpace(parentSessionID)
|
|
if r.sessionID == "" || r.sessionID == r.parentSessionID || !isHierarchyParent(r.sessionID, r.parentSessionID) {
|
|
r.parentSessionID = ""
|
|
}
|
|
}
|
|
|
|
func isHierarchyParent(primary, parent string) bool {
|
|
if parent == "" || primary == "" || primary == parent {
|
|
return false
|
|
}
|
|
if strings.Contains(primary, ":agent:") {
|
|
return true
|
|
}
|
|
idx1 := strings.Index(primary, ":")
|
|
idx2 := strings.Index(parent, ":")
|
|
if idx1 > 0 && idx2 > 0 && primary[:idx1] == parent[:idx2] {
|
|
return true
|
|
}
|
|
if idx1 == -1 && idx2 == -1 {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// UpdateAccessTokenFingerprint records the token version actually used upstream.
|
|
func (r *UsageReporter) UpdateAccessTokenFingerprint(auth *cliproxyauth.Auth) {
|
|
if r == nil {
|
|
return
|
|
}
|
|
r.authMu.Lock()
|
|
r.accessTokenHash = authAccessTokenSHA256(auth)
|
|
r.authMu.Unlock()
|
|
}
|
|
|
|
func (r *UsageReporter) accessTokenFingerprint() string {
|
|
if r == nil {
|
|
return ""
|
|
}
|
|
r.authMu.RLock()
|
|
defer r.authMu.RUnlock()
|
|
return r.accessTokenHash
|
|
}
|
|
|
|
// ObserveResponseModel stores the model reported by an upstream response or event and
|
|
// ignores payloads without one; the substitution warning is emitted at publish time.
|
|
func (r *UsageReporter) ObserveResponseModel(payload []byte) {
|
|
if r == nil || r.responseModelFinal.Load() {
|
|
return
|
|
}
|
|
provider := ""
|
|
if r != nil {
|
|
provider = r.provider
|
|
}
|
|
served, terminal := extractResponseModelEvent(payload, provider)
|
|
if served == "" {
|
|
if terminal {
|
|
r.responseModelFinal.Store(true)
|
|
}
|
|
return
|
|
}
|
|
r.responseModelMu.Lock()
|
|
r.responseModel = served
|
|
r.responseModelMu.Unlock()
|
|
if terminal {
|
|
r.responseModelFinal.Store(true)
|
|
}
|
|
}
|
|
|
|
// SetResponseModel sets the reported model directly if valid and not already marked final.
|
|
func (r *UsageReporter) SetResponseModel(model string) {
|
|
if r == nil || r.responseModelFinal.Load() {
|
|
return
|
|
}
|
|
model = strings.TrimSpace(model)
|
|
if model == "" || len(model) > maxResponseModelLength {
|
|
return
|
|
}
|
|
r.responseModelMu.Lock()
|
|
r.responseModel = model
|
|
r.responseModelMu.Unlock()
|
|
}
|
|
|
|
// SetUpstreamModel records the upstream model expected to be served when it differs
|
|
// from the requested model (e.g. due to provider-specific mapping or canonicalization).
|
|
// Model substitution detection compares the response against this upstream model,
|
|
// while usage accounting preserves the client's requested model.
|
|
func (r *UsageReporter) SetUpstreamModel(model string) {
|
|
if r == nil {
|
|
return
|
|
}
|
|
r.upstreamModelMu.Lock()
|
|
r.upstreamModel = strings.TrimSpace(model)
|
|
r.upstreamModelMu.Unlock()
|
|
}
|
|
|
|
// UpstreamModel returns the expected upstream model, or an empty string if not explicitly set.
|
|
func (r *UsageReporter) UpstreamModel() string {
|
|
if r == nil {
|
|
return ""
|
|
}
|
|
r.upstreamModelMu.RLock()
|
|
defer r.upstreamModelMu.RUnlock()
|
|
return r.upstreamModel
|
|
}
|
|
|
|
// IsResponseModelFinal reports whether the response model was already finalized by a terminal event.
|
|
func (r *UsageReporter) IsResponseModelFinal() bool {
|
|
return r != nil && r.responseModelFinal.Load()
|
|
}
|
|
|
|
// warnModelSubstitution warns about a silent upstream model swap, and labels the
|
|
// credential by index only, never by account.
|
|
func (r *UsageReporter) warnModelSubstitution(ctx context.Context) {
|
|
if r == nil {
|
|
return
|
|
}
|
|
served := r.ResponseModel()
|
|
expectedModel := r.UpstreamModel()
|
|
if expectedModel == "" {
|
|
expectedModel = r.model
|
|
}
|
|
if served == "" || !IsModelSubstituted(expectedModel, served) {
|
|
return
|
|
}
|
|
if r.model != "" && !IsModelSubstituted(r.model, served) {
|
|
return
|
|
}
|
|
providerName := strings.TrimSpace(r.provider)
|
|
if providerName == "" {
|
|
providerName = "unknown"
|
|
}
|
|
LogWithRequestID(ctx).Warnf("%s executor: upstream served model %q for requested model %q (auth_index=%s)", providerName, served, r.model, r.authIndexForLog())
|
|
}
|
|
|
|
// authIndexForLog labels the credential without exposing its file name or account.
|
|
func (r *UsageReporter) authIndexForLog() string {
|
|
if r == nil {
|
|
return "nil"
|
|
}
|
|
if authIndex := strings.TrimSpace(r.authIndex); authIndex != "" {
|
|
return authIndex
|
|
}
|
|
return "nil"
|
|
}
|
|
|
|
// ResponseModel returns the latest model reported by the upstream response.
|
|
func (r *UsageReporter) ResponseModel() string {
|
|
if r == nil {
|
|
return ""
|
|
}
|
|
r.responseModelMu.RLock()
|
|
defer r.responseModelMu.RUnlock()
|
|
return r.responseModel
|
|
}
|
|
|
|
func ExecutorTypeName(executor any) string {
|
|
if executor == nil {
|
|
return ""
|
|
}
|
|
executorType := reflect.TypeOf(executor)
|
|
for executorType.Kind() == reflect.Pointer {
|
|
executorType = executorType.Elem()
|
|
}
|
|
return strings.TrimSpace(executorType.Name())
|
|
}
|
|
|
|
func (r *UsageReporter) Publish(ctx context.Context, detail usage.Detail) {
|
|
r.publishWithOutcome(ctx, detail, false, usage.Failure{})
|
|
}
|
|
|
|
func (r *UsageReporter) PublishAdditionalModel(ctx context.Context, model string, detail usage.Detail) {
|
|
record, ok := r.buildAdditionalModelRecord(model, detail)
|
|
if !ok {
|
|
return
|
|
}
|
|
r.publishRecord(ctx, record)
|
|
}
|
|
|
|
// SetTranslatedRequestMetadata captures usage-relevant values from the final
|
|
// outbound payload after translation and payload defaults or overrides.
|
|
func (r *UsageReporter) SetTranslatedRequestMetadata(payload []byte, format string) {
|
|
if r == nil {
|
|
return
|
|
}
|
|
r.reasoning = thinking.ExtractTranslatedReasoningEffort(payload, format)
|
|
r.effectiveServiceTier = extractEffectiveServiceTier(payload)
|
|
}
|
|
|
|
// SetTranslatedReasoningEffort is retained for existing executor call sites.
|
|
// It captures all post-translation request metadata used by usage records.
|
|
func (r *UsageReporter) SetTranslatedReasoningEffort(payload []byte, format string) {
|
|
r.SetTranslatedRequestMetadata(payload, format)
|
|
}
|
|
|
|
func extractEffectiveServiceTier(payload []byte) string {
|
|
if len(payload) == 0 || !ojson.ValidBytes(payload) {
|
|
return ""
|
|
}
|
|
for _, path := range []string{"service_tier", "request.service_tier", "interaction.service_tier"} {
|
|
if node := ojson.GetBytesNoCopy(payload, path); node.Type == ojson.String {
|
|
if tier := strings.TrimSpace(node.String()); tier != "" {
|
|
return strings.Clone(tier)
|
|
}
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (r *UsageReporter) TrackHTTPClient(client *http.Client) *http.Client {
|
|
return r.trackHTTPClient(client, false)
|
|
}
|
|
|
|
// TrackHTTPClientRoundTripOnly records the TTFT start time upon sending the request
|
|
// and captures first-packet arrival fallback on initial body reads, while keeping
|
|
// effective TTFT unset. This allows protocol-aware streaming executors (like Codex SSE)
|
|
// to mark effective TTFT explicitly upon receiving substantive token events, while
|
|
// preserving first-packet fallback metrics for non-2xx error bodies or keepalive streams.
|
|
func (r *UsageReporter) TrackHTTPClientRoundTripOnly(client *http.Client) *http.Client {
|
|
return r.trackHTTPClient(client, true)
|
|
}
|
|
|
|
func (r *UsageReporter) trackHTTPClient(client *http.Client, packetOnly bool) *http.Client {
|
|
if r == nil || client == nil {
|
|
return client
|
|
}
|
|
tracked := *client
|
|
transport := tracked.Transport
|
|
if transport == nil {
|
|
transport = http.DefaultTransport
|
|
}
|
|
tracked.Transport = usageTTFTRoundTripper{
|
|
base: transport,
|
|
reporter: r,
|
|
packetOnly: packetOnly,
|
|
}
|
|
return &tracked
|
|
}
|
|
|
|
func (r *UsageReporter) ObserveResponse(resp *http.Response) {
|
|
if r == nil || resp == nil || resp.Body == nil {
|
|
return
|
|
}
|
|
r.StartResponseTTFT()
|
|
resp.Body = &usageTTFTReadCloser{
|
|
ReadCloser: resp.Body,
|
|
mark: func() {
|
|
r.MarkFirstResponseByte()
|
|
},
|
|
}
|
|
}
|
|
|
|
func (r *UsageReporter) ObserveResponsePacketOnly(resp *http.Response) {
|
|
if r == nil || resp == nil || resp.Body == nil {
|
|
return
|
|
}
|
|
r.StartResponseTTFT()
|
|
resp.Body = &usageTTFTReadCloser{
|
|
ReadCloser: resp.Body,
|
|
mark: func() {
|
|
r.RecordFirstPacket()
|
|
},
|
|
}
|
|
}
|
|
|
|
func (r *UsageReporter) StartResponseTTFT() {
|
|
if r == nil {
|
|
return
|
|
}
|
|
r.ttftMu.Lock()
|
|
if !r.ttftSet && r.ttftStart.IsZero() {
|
|
r.ttftStart = time.Now()
|
|
}
|
|
r.ttftMu.Unlock()
|
|
}
|
|
|
|
func (r *UsageReporter) IsTTFTSet() bool {
|
|
if r == nil {
|
|
return false
|
|
}
|
|
r.ttftMu.RLock()
|
|
defer r.ttftMu.RUnlock()
|
|
return r.ttftSet
|
|
}
|
|
|
|
func (r *UsageReporter) IsFirstPacketSet() bool {
|
|
if r == nil {
|
|
return false
|
|
}
|
|
r.ttftMu.RLock()
|
|
defer r.ttftMu.RUnlock()
|
|
return r.firstPacketSet
|
|
}
|
|
|
|
// RecordFirstPacket records the arrival time of the first packet/chunk from upstream as a fallback.
|
|
func (r *UsageReporter) RecordFirstPacket() {
|
|
r.ObserveTokenEvent(false)
|
|
}
|
|
|
|
// ObserveTokenEvent records the first packet fallback time on the first frame,
|
|
// and if isToken is true, records the effective TTFT. It uses a fast-path
|
|
// read check to return immediately with zero write lock contention once TTFT is set
|
|
// or when subsequent non-token metadata frames arrive after the first packet.
|
|
func (r *UsageReporter) ObserveTokenEvent(isToken bool) {
|
|
if r == nil {
|
|
return
|
|
}
|
|
r.ttftMu.RLock()
|
|
if r.ttftSet {
|
|
r.ttftMu.RUnlock()
|
|
return
|
|
}
|
|
start := r.ttftStart
|
|
alreadyRecordedPacket := r.firstPacketSet
|
|
r.ttftMu.RUnlock()
|
|
|
|
if start.IsZero() {
|
|
return
|
|
}
|
|
|
|
if !isToken && alreadyRecordedPacket {
|
|
return
|
|
}
|
|
|
|
r.ttftMu.Lock()
|
|
defer r.ttftMu.Unlock()
|
|
if r.ttftSet {
|
|
return
|
|
}
|
|
if !r.firstPacketSet {
|
|
r.firstPacketDuration = time.Since(start)
|
|
r.firstPacketSet = true
|
|
}
|
|
if isToken {
|
|
r.ttft = time.Since(start)
|
|
r.ttftSet = true
|
|
r.ttftStart = time.Time{}
|
|
}
|
|
}
|
|
|
|
func (r *UsageReporter) MarkFirstResponseByte() {
|
|
if r == nil {
|
|
return
|
|
}
|
|
r.ttftMu.Lock()
|
|
if r.ttftSet {
|
|
r.ttftMu.Unlock()
|
|
return
|
|
}
|
|
start := r.ttftStart
|
|
r.ttftStart = time.Time{}
|
|
r.ttftMu.Unlock()
|
|
if start.IsZero() {
|
|
return
|
|
}
|
|
r.setTTFT(time.Since(start))
|
|
}
|
|
|
|
func (r *UsageReporter) buildAdditionalModelRecord(model string, detail usage.Detail) (usage.Record, bool) {
|
|
if r == nil {
|
|
return usage.Record{}, false
|
|
}
|
|
model = strings.TrimSpace(model)
|
|
if model == "" {
|
|
return usage.Record{}, false
|
|
}
|
|
detail = normalizeUsageDetailTotal(detail, r.provider, r.executorType)
|
|
if !hasNonZeroTokenUsage(detail) {
|
|
return usage.Record{}, false
|
|
}
|
|
rec := r.buildRecordForModel(model, detail, false, usage.Failure{})
|
|
rec.RequestID = uuid.NewString()
|
|
if rec.HomeSelection != nil {
|
|
// Split billing details do not represent another scheduled request.
|
|
// Mark them separately without changing the primary usage metadata.
|
|
selection := *rec.HomeSelection
|
|
selection.Additional = true
|
|
rec.HomeSelection = &selection
|
|
}
|
|
return rec, true
|
|
}
|
|
|
|
func (r *UsageReporter) PublishFailure(ctx context.Context, errs ...error) {
|
|
r.publishWithOutcome(ctx, usage.Detail{}, true, failFromErrors(errs...))
|
|
}
|
|
|
|
func (r *UsageReporter) PublishFailureWithDetail(ctx context.Context, detail usage.Detail, errs ...error) {
|
|
r.publishWithOutcome(ctx, detail, true, failFromErrors(errs...))
|
|
}
|
|
|
|
func (r *UsageReporter) TrackFailure(ctx context.Context, errPtr *error) {
|
|
if r == nil || errPtr == nil {
|
|
return
|
|
}
|
|
if *errPtr != nil {
|
|
r.PublishFailure(ctx, *errPtr)
|
|
}
|
|
}
|
|
|
|
func (r *UsageReporter) publishWithOutcome(ctx context.Context, detail usage.Detail, failed bool, fail usage.Failure) {
|
|
if r == nil {
|
|
return
|
|
}
|
|
detail = normalizeUsageDetailTotal(detail, r.provider, r.executorType)
|
|
r.once.Do(func() {
|
|
r.publishAttemptRecord(ctx, r.buildRecord(detail, failed, fail))
|
|
})
|
|
}
|
|
|
|
func normalizeUsageDetailTotal(detail usage.Detail, provider, executorType string) usage.Detail {
|
|
return usage.EnsureTokenBreakdownForProvider(detail, provider, executorType)
|
|
}
|
|
|
|
func hasNonZeroTokenUsage(detail usage.Detail) bool {
|
|
return detail.InputTokens != 0 ||
|
|
detail.OutputTokens != 0 ||
|
|
detail.ReasoningTokens != 0 ||
|
|
detail.CachedTokens != 0 ||
|
|
detail.CacheReadTokens != 0 ||
|
|
detail.CacheCreationTokens != 0 ||
|
|
detail.TotalTokens != 0 ||
|
|
detail.TokenBreakdown.TotalTokens != 0
|
|
}
|
|
|
|
// ensurePublished guarantees that a usage record is emitted exactly once.
|
|
// It is safe to call multiple times; only the first call wins due to once.Do.
|
|
// This is used to ensure request counting even when upstream responses do not
|
|
// include any usage fields (tokens), especially for streaming paths.
|
|
func (r *UsageReporter) EnsurePublished(ctx context.Context) {
|
|
if r == nil {
|
|
return
|
|
}
|
|
r.once.Do(func() {
|
|
r.publishAttemptRecord(ctx, r.buildRecord(usage.Detail{}, false, usage.Failure{}))
|
|
})
|
|
}
|
|
|
|
// publishAttemptRecord emits the record for one upstream attempt and the
|
|
// observability warnings that belong to the attempt rather than to a single event.
|
|
func (r *UsageReporter) publishAttemptRecord(ctx context.Context, record usage.Record) {
|
|
r.publishRecord(ctx, record)
|
|
r.warnModelSubstitution(ctx)
|
|
}
|
|
|
|
func (r *UsageReporter) publishRecord(ctx context.Context, record usage.Record) {
|
|
record.ResponseHeaders = internallogging.GetResponseHeaders(ctx)
|
|
if r != nil {
|
|
ctx = usage.WithCapturedIdentity(ctx, r.apiKey, r.accessProvider, r.isNativeKey)
|
|
}
|
|
usage.PublishRecord(ctx, record)
|
|
}
|
|
|
|
// RequestID returns the execution instance request ID for this reporter.
|
|
func (r *UsageReporter) RequestID() string {
|
|
if r == nil {
|
|
return ""
|
|
}
|
|
return r.requestID
|
|
}
|
|
|
|
// TraceID returns the parent inbound request ID for this reporter.
|
|
func (r *UsageReporter) TraceID() string {
|
|
if r == nil {
|
|
return ""
|
|
}
|
|
return r.traceID
|
|
}
|
|
|
|
// SelectionID returns the scheduler selection ID for this reporter.
|
|
func (r *UsageReporter) SelectionID() string {
|
|
if r == nil {
|
|
return ""
|
|
}
|
|
return r.selectionID
|
|
}
|
|
|
|
// IsNativeKey reports whether the client API key was authenticated by CPA's native config provider.
|
|
func (r *UsageReporter) IsNativeKey() bool {
|
|
if r == nil {
|
|
return false
|
|
}
|
|
return r.isNativeKey
|
|
}
|
|
|
|
// AccessProvider identifies the client request authentication provider.
|
|
func (r *UsageReporter) AccessProvider() string {
|
|
if r == nil {
|
|
return ""
|
|
}
|
|
return r.accessProvider
|
|
}
|
|
|
|
func (r *UsageReporter) buildRecord(detail usage.Detail, failed bool, failures ...usage.Failure) usage.Record {
|
|
var fail usage.Failure
|
|
if len(failures) > 0 {
|
|
fail = failures[0]
|
|
}
|
|
if r == nil {
|
|
return usage.Record{Detail: detail, Failed: failed, Fail: fail, Generate: usage.GenerateFlag(true)}
|
|
}
|
|
return r.buildRecordForModel(r.model, detail, failed, fail)
|
|
}
|
|
|
|
func (r *UsageReporter) buildRecordForModel(model string, detail usage.Detail, failed bool, fail usage.Failure) usage.Record {
|
|
if r == nil {
|
|
return usage.Record{Model: model, Detail: detail, Failed: failed, Fail: fail, Generate: usage.GenerateFlag(true)}
|
|
}
|
|
// Additional-model records describe a side model (image generation tool usage) that
|
|
// the upstream response model never refers to, so they must stay empty.
|
|
responseModel := ""
|
|
if model == r.model {
|
|
responseModel = r.ResponseModel()
|
|
}
|
|
return usage.Record{
|
|
RequestID: r.requestID,
|
|
TraceID: r.traceID,
|
|
SelectionID: r.selectionID,
|
|
HomeSelection: r.homeSelection,
|
|
Provider: r.provider,
|
|
BaseURL: r.baseURL,
|
|
ExecutorType: r.executorType,
|
|
Model: model,
|
|
Alias: r.alias,
|
|
Source: r.source,
|
|
APIKey: r.apiKey,
|
|
IsNativeKey: r.isNativeKey,
|
|
AccessProvider: r.accessProvider,
|
|
SessionID: r.sessionID,
|
|
ParentSessionID: r.parentSessionID,
|
|
AuthID: r.authID,
|
|
AuthIndex: r.authIndex,
|
|
AccessTokenSHA256: r.accessTokenFingerprint(),
|
|
AuthType: r.authType,
|
|
ReasoningEffort: r.reasoning,
|
|
ServiceTier: r.serviceTier,
|
|
EffectiveServiceTier: r.effectiveServiceTier,
|
|
ResponseServiceTier: strings.TrimSpace(detail.ResponseServiceTier),
|
|
ResponseModel: responseModel,
|
|
Generate: usage.GenerateFlag(r.generate),
|
|
Stream: r.stream,
|
|
RequestedAt: r.requestedAt,
|
|
Latency: r.latency(),
|
|
TTFT: r.ttftDuration(),
|
|
Failed: failed,
|
|
Fail: fail,
|
|
Detail: detail,
|
|
}
|
|
}
|
|
|
|
func failFromErrors(errs ...error) usage.Failure {
|
|
for _, err := range errs {
|
|
if err == nil {
|
|
continue
|
|
}
|
|
body := strings.TrimSpace(err.Error())
|
|
type responseBodyProvider interface {
|
|
ResponseBody() []byte
|
|
}
|
|
var responseErr responseBodyProvider
|
|
if errors.As(err, &responseErr) && responseErr != nil {
|
|
if responseBody := responseErr.ResponseBody(); len(responseBody) > 0 {
|
|
body = string(responseBody)
|
|
}
|
|
}
|
|
fail := usage.Failure{
|
|
Body: body,
|
|
StatusCode: clienterror.HTTPStatusFromError(err),
|
|
}
|
|
if truncatedErr, ok := errors.AsType[cliproxyexecutor.StreamTruncatedError](err); ok && truncatedErr != nil && truncatedErr.IsStreamTruncated() {
|
|
fail.Code = usage.FailureStreamTruncatedCode
|
|
} else if requestErr, ok := errors.AsType[cliproxyexecutor.RequestScopedError](err); ok && requestErr != nil && requestErr.IsRequestScoped() {
|
|
fail.Code = usage.FailureRequestScopedCode
|
|
}
|
|
return fail
|
|
}
|
|
return usage.Failure{}
|
|
}
|
|
|
|
func (r *UsageReporter) latency() time.Duration {
|
|
if r == nil || r.requestedAt.IsZero() {
|
|
return 0
|
|
}
|
|
latency := time.Since(r.requestedAt)
|
|
if latency < 0 {
|
|
return 0
|
|
}
|
|
return latency
|
|
}
|
|
|
|
func (r *UsageReporter) setTTFT(ttft time.Duration) {
|
|
if r == nil {
|
|
return
|
|
}
|
|
if ttft < 0 {
|
|
ttft = 0
|
|
}
|
|
r.ttftMu.Lock()
|
|
if r.ttftSet {
|
|
r.ttftMu.Unlock()
|
|
return
|
|
}
|
|
r.ttft = ttft
|
|
r.ttftSet = true
|
|
r.ttftStart = time.Time{}
|
|
r.ttftMu.Unlock()
|
|
}
|
|
|
|
func (r *UsageReporter) ttftDuration() time.Duration {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
r.ttftMu.RLock()
|
|
defer r.ttftMu.RUnlock()
|
|
if r.ttftSet {
|
|
return r.ttft
|
|
}
|
|
if r.firstPacketSet {
|
|
return r.firstPacketDuration
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type usageTTFTRoundTripper struct {
|
|
base http.RoundTripper
|
|
reporter *UsageReporter
|
|
packetOnly bool
|
|
}
|
|
|
|
func (t usageTTFTRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
|
|
cliproxyexecutor.MarkUpstreamAttempt(req.Context())
|
|
t.reporter.StartResponseTTFT()
|
|
resp, errRoundTrip := t.base.RoundTrip(req)
|
|
if errRoundTrip != nil {
|
|
return resp, errRoundTrip
|
|
}
|
|
if t.packetOnly {
|
|
t.reporter.ObserveResponsePacketOnly(resp)
|
|
} else {
|
|
t.reporter.ObserveResponse(resp)
|
|
}
|
|
return resp, nil
|
|
}
|
|
|
|
type usageTTFTReadCloser struct {
|
|
io.ReadCloser
|
|
once sync.Once
|
|
mark func()
|
|
}
|
|
|
|
func (r *usageTTFTReadCloser) Read(p []byte) (int, error) {
|
|
if r == nil || r.ReadCloser == nil {
|
|
return 0, io.ErrClosedPipe
|
|
}
|
|
n, errRead := r.ReadCloser.Read(p)
|
|
if n > 0 && r.mark != nil {
|
|
r.once.Do(r.mark)
|
|
}
|
|
return n, errRead
|
|
}
|
|
|
|
func APIKeyFromContext(ctx context.Context) string {
|
|
if ctx == nil {
|
|
return ""
|
|
}
|
|
if usage.HasCapturedIdentity(ctx) {
|
|
return usage.APIKeyFromContext(ctx)
|
|
}
|
|
ginCtx, ok := ctx.Value("gin").(*gin.Context)
|
|
if !ok || ginCtx == nil {
|
|
return usage.APIKeyFromContext(ctx)
|
|
}
|
|
if v, exists := ginCtx.Get("userApiKey"); exists {
|
|
switch value := v.(type) {
|
|
case string:
|
|
return value
|
|
case fmt.Stringer:
|
|
return value.String()
|
|
default:
|
|
return fmt.Sprintf("%v", value)
|
|
}
|
|
}
|
|
return usage.APIKeyFromContext(ctx)
|
|
}
|
|
|
|
// AccessProviderFromContext extracts the client authentication provider identifier from the context.
|
|
func AccessProviderFromContext(ctx context.Context) string {
|
|
if provider := usage.AccessProviderFromContext(ctx); provider != "" {
|
|
return provider
|
|
}
|
|
if usage.HasCapturedIdentity(ctx) {
|
|
return ""
|
|
}
|
|
if ctx == nil {
|
|
return ""
|
|
}
|
|
ginCtx, ok := ctx.Value("gin").(*gin.Context)
|
|
if !ok || ginCtx == nil {
|
|
return ""
|
|
}
|
|
if v, exists := ginCtx.Get("accessProvider"); exists {
|
|
switch value := v.(type) {
|
|
case string:
|
|
return strings.TrimSpace(value)
|
|
case fmt.Stringer:
|
|
return strings.TrimSpace(value.String())
|
|
default:
|
|
return strings.TrimSpace(fmt.Sprintf("%v", value))
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func resolveUsageSource(auth *cliproxyauth.Auth, ctxAPIKey string) string {
|
|
if auth != nil {
|
|
provider := strings.TrimSpace(auth.Provider)
|
|
if strings.EqualFold(provider, "vertex") {
|
|
if auth.Metadata != nil {
|
|
if projectID, ok := auth.Metadata["project_id"].(string); ok {
|
|
if trimmed := strings.TrimSpace(projectID); trimmed != "" {
|
|
return trimmed
|
|
}
|
|
}
|
|
if project, ok := auth.Metadata["project"].(string); ok {
|
|
if trimmed := strings.TrimSpace(project); trimmed != "" {
|
|
return trimmed
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if _, value := auth.AccountInfo(); value != "" {
|
|
return strings.TrimSpace(value)
|
|
}
|
|
if auth.Metadata != nil {
|
|
if email, ok := auth.Metadata["email"].(string); ok {
|
|
if trimmed := strings.TrimSpace(email); trimmed != "" {
|
|
return trimmed
|
|
}
|
|
}
|
|
}
|
|
if auth.Attributes != nil {
|
|
if key := strings.TrimSpace(auth.Attributes["api_key"]); key != "" {
|
|
return key
|
|
}
|
|
}
|
|
}
|
|
if trimmed := strings.TrimSpace(ctxAPIKey); trimmed != "" {
|
|
return trimmed
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func resolveUsageAuthType(auth *cliproxyauth.Auth) string {
|
|
if auth == nil {
|
|
return ""
|
|
}
|
|
return auth.AuthKind()
|
|
}
|
|
|
|
// StreamUsageBuffer keeps the latest usage detail observed in a stream.
|
|
type StreamUsageBuffer struct {
|
|
detail usage.Detail
|
|
ok bool
|
|
responseModel string
|
|
seenClaudeToolUseIDs map[string]struct{}
|
|
seenClaudeToolResultIDs map[string]struct{}
|
|
claudeWebSearchQueries int64
|
|
claudeCompletedSearches int64
|
|
claudeSearchResultsCount int64
|
|
claudeHasCompletedSearch bool
|
|
claudeReportedWebSearchCalls *int64
|
|
seenOpenAIToolCallKeys map[string]struct{}
|
|
openAIToolCallsRequested int64
|
|
openAIExplicitToolCalls bool
|
|
geminiCallCounter geminiFunctionCallCounter
|
|
openAIStreamImages int64
|
|
openAIExplicitImageCount bool
|
|
openAIStreamImageDetails *usage.ImageDetails
|
|
responsesOutputByIndex map[int64][]byte
|
|
responsesOutputFallback [][]byte
|
|
geminiToolDetails *usage.ToolUsageDetails
|
|
geminiWebSearchRequests *int64
|
|
geminiImageCount int64
|
|
geminiImageDetails *usage.ImageDetails
|
|
requestedImageDetails *usage.ImageDetails
|
|
}
|
|
|
|
var (
|
|
openAIStreamUsageMarker = []byte(`"usage"`)
|
|
openAIStreamCacheMarker = []byte(`"prompt_cache_`)
|
|
openAIStreamServiceTierMarker = []byte(`"service_tier"`)
|
|
openAIStreamToolCallsMarker = []byte(`"tool_calls"`)
|
|
openAIStreamImageDoneMarker = []byte(`.completed"`)
|
|
responsesOutputItemDoneMarker = []byte(`"response.output_item.done"`)
|
|
claudeStreamBlockStartMarker = []byte(`"content_block_start"`)
|
|
geminiUsageMetaMarker = []byte(`"usageMetadata"`)
|
|
geminiUsageMetaSnakeMarker = []byte(`"usage_metadata"`)
|
|
geminiGroundingMetaMarker = []byte(`"groundingMetadata"`)
|
|
geminiGroundingSnakeMarker = []byte(`"grounding_metadata"`)
|
|
geminiURLContextMetaMarker = []byte(`"urlContextMetadata"`)
|
|
geminiURLContextSnakeMarker = []byte(`"url_context_metadata"`)
|
|
geminiExecCodeMarker = []byte(`"executableCode"`)
|
|
geminiExecCodeSnakeMarker = []byte(`"executable_code"`)
|
|
geminiFunctionCallMarker = []byte(`"functionCall"`)
|
|
geminiFunctionCallSnakeMarker = []byte(`"function_call"`)
|
|
geminiInlineDataMarker = []byte(`"inlineData"`)
|
|
geminiInlineDataSnakeMarker = []byte(`"inline_data"`)
|
|
geminiPredictionsMarker = []byte(`"predictions"`)
|
|
)
|
|
|
|
func cloneTrimmedString(s string) string {
|
|
s = strings.TrimSpace(s)
|
|
if s == "" {
|
|
return ""
|
|
}
|
|
return strings.Clone(s)
|
|
}
|
|
|
|
func hasGeminiCandidateArtifactMarker(payload []byte) bool {
|
|
return bytes.Contains(payload, geminiGroundingMetaMarker) ||
|
|
bytes.Contains(payload, geminiGroundingSnakeMarker) ||
|
|
bytes.Contains(payload, geminiURLContextMetaMarker) ||
|
|
bytes.Contains(payload, geminiURLContextSnakeMarker) ||
|
|
bytes.Contains(payload, geminiExecCodeMarker) ||
|
|
bytes.Contains(payload, geminiExecCodeSnakeMarker) ||
|
|
bytes.Contains(payload, geminiFunctionCallMarker) ||
|
|
bytes.Contains(payload, geminiFunctionCallSnakeMarker) ||
|
|
bytes.Contains(payload, geminiInlineDataMarker) ||
|
|
bytes.Contains(payload, geminiInlineDataSnakeMarker) ||
|
|
bytes.Contains(payload, geminiPredictionsMarker)
|
|
}
|
|
|
|
// Observe records detail when ok is true, allowing the final stream usage to win.
|
|
func (b *StreamUsageBuffer) Observe(detail usage.Detail, ok bool) {
|
|
if b == nil || !ok {
|
|
return
|
|
}
|
|
responseServiceTier := strings.TrimSpace(detail.ResponseServiceTier)
|
|
if responseServiceTier == "" || hasNonZeroTokenUsage(detail) || hasStructuredUsageDetail(detail) {
|
|
preservedTier := b.detail.ResponseServiceTier
|
|
preservedUpstreamTier := b.detail.UpstreamServiceTier
|
|
b.detail = detail
|
|
if b.detail.ResponseServiceTier == "" {
|
|
b.detail.ResponseServiceTier = preservedTier
|
|
}
|
|
if b.detail.UpstreamServiceTier == "" {
|
|
b.detail.UpstreamServiceTier = preservedUpstreamTier
|
|
}
|
|
} else {
|
|
b.detail.ResponseServiceTier = responseServiceTier
|
|
if b.detail.UpstreamServiceTier == "" {
|
|
b.detail.UpstreamServiceTier = detail.UpstreamServiceTier
|
|
}
|
|
}
|
|
b.applyGeminiStreamObservations()
|
|
b.ok = true
|
|
}
|
|
|
|
func (b *StreamUsageBuffer) rememberGeminiCandidateArtifacts(detail *usage.Detail) {
|
|
if b == nil || detail == nil {
|
|
return
|
|
}
|
|
if detail.ToolUsageDetails != nil {
|
|
// Content parts are incremental executions; grounding metadata is a snapshot.
|
|
previous := b.geminiToolDetails
|
|
b.geminiToolDetails = mergeToolUsageDetails(previous, detail.ToolUsageDetails)
|
|
if previous != nil {
|
|
addCounter := func(prev, delta *int64) *int64 {
|
|
if prev == nil || delta == nil {
|
|
return mergeInt64Ptr(prev, delta)
|
|
}
|
|
if sum, ok := safeUsageTokenSum(*prev, *delta); ok {
|
|
return usage.Int64Ptr(sum)
|
|
}
|
|
return nil
|
|
}
|
|
b.geminiToolDetails.ToolCallsRequested = addCounter(
|
|
previous.ToolCallsRequested, detail.ToolUsageDetails.ToolCallsRequested,
|
|
)
|
|
b.geminiToolDetails.CodeExecutionCalls = addCounter(
|
|
previous.CodeExecutionCalls, detail.ToolUsageDetails.CodeExecutionCalls,
|
|
)
|
|
}
|
|
}
|
|
if detail.WebSearchRequests != nil {
|
|
b.geminiWebSearchRequests = mergeInt64Ptr(b.geminiWebSearchRequests, detail.WebSearchRequests)
|
|
}
|
|
if detail.ImageCount != nil && *detail.ImageCount > 0 {
|
|
b.geminiImageCount += *detail.ImageCount
|
|
}
|
|
if detail.ImageDetails != nil {
|
|
b.geminiImageDetails = detail.ImageDetails.Clone()
|
|
}
|
|
}
|
|
|
|
func (b *StreamUsageBuffer) applyGeminiStreamObservations() {
|
|
if b == nil {
|
|
return
|
|
}
|
|
if b.geminiToolDetails != nil {
|
|
b.detail.ToolUsageDetails = mergeToolUsageDetails(b.detail.ToolUsageDetails, b.geminiToolDetails)
|
|
}
|
|
if b.geminiWebSearchRequests != nil {
|
|
b.detail.WebSearchRequests = usage.CloneInt64Ptr(b.geminiWebSearchRequests)
|
|
}
|
|
if b.geminiImageCount > 0 {
|
|
b.detail.ImageCount = usage.Int64Ptr(b.geminiImageCount)
|
|
}
|
|
if b.geminiImageDetails != nil && b.detail.ImageDetails == nil {
|
|
b.detail.ImageDetails = b.geminiImageDetails.Clone()
|
|
}
|
|
if b.geminiImageCount > 0 && b.requestedImageDetails != nil && b.detail.RequestedImageDetails == nil {
|
|
b.detail.RequestedImageDetails = b.requestedImageDetails.Clone()
|
|
}
|
|
}
|
|
|
|
// SetRequestPayload records request-side image/media configuration on the stream buffer
|
|
// so it can be attached as RequestedImageDetails if the stream produces images.
|
|
func (b *StreamUsageBuffer) SetRequestPayload(requestPayload []byte, contentType ...string) {
|
|
if b == nil || len(requestPayload) == 0 {
|
|
return
|
|
}
|
|
b.requestedImageDetails = ParseRequestImageDetails(requestPayload, contentType...)
|
|
}
|
|
|
|
// ObserveGeminiStream records and merges usage and candidate tool/media artifacts from a Gemini SSE line.
|
|
func (b *StreamUsageBuffer) ObserveGeminiStream(line []byte) {
|
|
b.observeGeminiFamilyStream(line, false)
|
|
}
|
|
|
|
// ObserveAntigravityStream records and merges usage and candidate tool/media artifacts from an Antigravity SSE line.
|
|
func (b *StreamUsageBuffer) ObserveAntigravityStream(line []byte) {
|
|
b.observeGeminiFamilyStream(line, true)
|
|
}
|
|
|
|
func (b *StreamUsageBuffer) observeGeminiFamilyStream(line []byte, allowResponseWrapper bool) {
|
|
if b == nil {
|
|
return
|
|
}
|
|
payload := jsonPayload(line)
|
|
if len(payload) == 0 || !ojson.ValidBytes(payload) {
|
|
return
|
|
}
|
|
root := util.ParseGJSONBytesNoCopy(payload)
|
|
var (
|
|
node ojson.Result
|
|
candidatesNode ojson.Result
|
|
predsNode ojson.Result
|
|
)
|
|
root.ForEach(func(key, val ojson.Result) bool {
|
|
switch key.String() {
|
|
case "usageMetadata", "usage_metadata":
|
|
if !node.Exists() {
|
|
node = val
|
|
}
|
|
case "candidates":
|
|
candidatesNode = val
|
|
case "predictions":
|
|
predsNode = val
|
|
case "response":
|
|
if allowResponseWrapper && val.IsObject() {
|
|
val.ForEach(func(rk, rv ojson.Result) bool {
|
|
switch rk.String() {
|
|
case "usageMetadata", "usage_metadata":
|
|
if !node.Exists() {
|
|
node = rv
|
|
}
|
|
case "candidates":
|
|
if !candidatesNode.Exists() {
|
|
candidatesNode = rv
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
if candidatesNode.Exists() || predsNode.Exists() {
|
|
var artifactDetail usage.Detail
|
|
applyGeminiNodesArtifactsWithCounter(&artifactDetail, candidatesNode, predsNode, &b.geminiCallCounter)
|
|
b.rememberGeminiCandidateArtifacts(&artifactDetail)
|
|
if !node.Exists() && (artifactDetail.ToolUsageDetails != nil || artifactDetail.ImageCount != nil) {
|
|
b.applyGeminiStreamObservations()
|
|
b.ok = true
|
|
return
|
|
}
|
|
}
|
|
if !node.Exists() {
|
|
return
|
|
}
|
|
detail := parseGeminiFamilyUsageDetail(node)
|
|
if !allowResponseWrapper && !hasNonZeroTokenUsage(detail) {
|
|
return
|
|
}
|
|
if b.ok {
|
|
update := detail
|
|
mergeStreamStructuredFields(&detail, b.detail, update)
|
|
// Explicit zero modality counts are authoritative, not absent fields.
|
|
for _, pair := range []struct {
|
|
dst **int64
|
|
src *int64
|
|
}{
|
|
{&detail.TextInputTokens, update.TextInputTokens},
|
|
{&detail.ImageInputTokens, update.ImageInputTokens},
|
|
{&detail.AudioInputTokens, update.AudioInputTokens},
|
|
{&detail.VideoInputTokens, update.VideoInputTokens},
|
|
{&detail.FileInputTokens, update.FileInputTokens},
|
|
{&detail.CachedTextTokens, update.CachedTextTokens},
|
|
{&detail.CachedImageTokens, update.CachedImageTokens},
|
|
{&detail.CachedAudioTokens, update.CachedAudioTokens},
|
|
{&detail.TextOutputTokens, update.TextOutputTokens},
|
|
{&detail.ImageOutputTokens, update.ImageOutputTokens},
|
|
{&detail.AudioOutputTokens, update.AudioOutputTokens},
|
|
} {
|
|
if pair.src != nil {
|
|
*pair.dst = usage.CloneInt64Ptr(pair.src)
|
|
}
|
|
}
|
|
}
|
|
b.Observe(detail, true)
|
|
}
|
|
|
|
// ObserveOpenAIStream records response-tier state and the latest usage from an
|
|
// OpenAI-style stream while avoiding JSON parsing for irrelevant chunks.
|
|
func (b *StreamUsageBuffer) ObserveOpenAIStream(line []byte) {
|
|
if b == nil {
|
|
return
|
|
}
|
|
payload := jsonPayload(line)
|
|
if len(payload) == 0 {
|
|
return
|
|
}
|
|
|
|
hasUsageCandidate := bytes.Contains(payload, openAIStreamUsageMarker)
|
|
hasCacheCandidate := bytes.Contains(payload, openAIStreamCacheMarker)
|
|
needTier := b.detail.ResponseServiceTier == "" || hasUsageCandidate
|
|
hasTierCandidate := needTier && bytes.Contains(payload, openAIStreamServiceTierMarker)
|
|
hasToolCallsCandidate := bytes.Contains(payload, openAIStreamToolCallsMarker)
|
|
hasImageCompletedCandidate := bytes.Contains(payload, openAIStreamImageDoneMarker)
|
|
if b.responseModel == "" {
|
|
if model, _ := extractGenericResponseModelEvent(payload); model != "" {
|
|
b.responseModel = model
|
|
}
|
|
}
|
|
if !hasUsageCandidate && !hasCacheCandidate && !hasTierCandidate && !hasToolCallsCandidate && !hasImageCompletedCandidate {
|
|
return
|
|
}
|
|
if !ojson.ValidBytes(payload) {
|
|
return
|
|
}
|
|
|
|
if hasToolCallsCandidate {
|
|
b.observeOpenAIStreamToolCalls(payload)
|
|
}
|
|
if hasImageCompletedCandidate {
|
|
b.observeOpenAIImageStreamCompleted(payload)
|
|
}
|
|
|
|
detail := usage.Detail{}
|
|
usageOK := false
|
|
if hasUsageCandidate || hasCacheCandidate {
|
|
root := util.ParseGJSONBytesNoCopy(payload)
|
|
usageNode := root.Get("usage")
|
|
detail, usageOK = parseOpenAIStyleUsageWithCache(root, usageNode)
|
|
if detail.ToolUsageDetails != nil && detail.ToolUsageDetails.ToolCallsRequested != nil {
|
|
b.openAIExplicitToolCalls = true
|
|
}
|
|
if detail.ImageCount != nil {
|
|
b.openAIExplicitImageCount = true
|
|
}
|
|
if usageOK && b.ok {
|
|
// Metadata-only frames do not replace the last token snapshot.
|
|
if !hasOpenAIStyleUsageTokenFields(usageNode) {
|
|
detail.InputTokens = b.detail.InputTokens
|
|
detail.OutputTokens = b.detail.OutputTokens
|
|
detail.ReasoningTokens = b.detail.ReasoningTokens
|
|
detail.CachedTokens = b.detail.CachedTokens
|
|
detail.CacheReadTokens = b.detail.CacheReadTokens
|
|
detail.CacheCreationTokens = b.detail.CacheCreationTokens
|
|
detail.TotalTokens = b.detail.TotalTokens
|
|
detail.TokenBreakdown = b.detail.TokenBreakdown
|
|
}
|
|
mergeStreamStructuredFields(&detail, b.detail, detail)
|
|
}
|
|
}
|
|
if hasTierCandidate {
|
|
detail.ResponseServiceTier = extractResponseServiceTierFromValidJSON(payload)
|
|
if detail.UpstreamServiceTier == "" {
|
|
detail.UpstreamServiceTier = detail.ResponseServiceTier
|
|
}
|
|
}
|
|
b.Observe(detail, usageOK || detail.ResponseServiceTier != "")
|
|
b.applyOpenAIStreamObservations()
|
|
}
|
|
|
|
func (b *StreamUsageBuffer) observeOpenAIStreamToolCalls(payload []byte) {
|
|
root := util.ParseGJSONBytesNoCopy(payload)
|
|
for choiceIdx, choice := range root.Get("choices").Array() {
|
|
if idx := choice.Get("index"); idx.Type == ojson.Number {
|
|
choiceIdx = int(idx.Int())
|
|
}
|
|
tcNode := choice.Get("delta.tool_calls")
|
|
if !tcNode.IsArray() {
|
|
tcNode = choice.Get("message.tool_calls")
|
|
}
|
|
if !tcNode.IsArray() {
|
|
continue
|
|
}
|
|
for itemIdx, tc := range tcNode.Array() {
|
|
key := ""
|
|
if idxNode := tc.Get("index"); idxNode.Type == ojson.Number {
|
|
key = fmt.Sprintf("%d:%d", choiceIdx, idxNode.Int())
|
|
} else if id := strings.TrimSpace(tc.Get("id").String()); id != "" {
|
|
key = fmt.Sprintf("%d:id:%s", choiceIdx, id)
|
|
} else {
|
|
key = fmt.Sprintf("%d:pos:%d", choiceIdx, itemIdx)
|
|
}
|
|
if b.seenOpenAIToolCallKeys == nil {
|
|
b.seenOpenAIToolCallKeys = make(map[string]struct{})
|
|
}
|
|
if _, exists := b.seenOpenAIToolCallKeys[key]; exists {
|
|
continue
|
|
}
|
|
b.seenOpenAIToolCallKeys[key] = struct{}{}
|
|
b.openAIToolCallsRequested++
|
|
}
|
|
}
|
|
}
|
|
|
|
func (b *StreamUsageBuffer) observeOpenAIImageStreamCompleted(payload []byte) {
|
|
root := util.ParseGJSONBytesNoCopy(payload)
|
|
evType := strings.TrimSpace(root.Get("type").String())
|
|
if evType != "image_generation.completed" && evType != "image_edit.completed" {
|
|
return
|
|
}
|
|
b.openAIStreamImages++
|
|
details := &usage.ImageDetails{
|
|
Size: cloneTrimmedString(root.Get("size").String()),
|
|
Quality: cloneTrimmedString(root.Get("quality").String()),
|
|
Background: cloneTrimmedString(root.Get("background").String()),
|
|
OutputFormat: cloneTrimmedString(root.Get("output_format").String()),
|
|
MimeType: cloneTrimmedString(root.Get("mime_type").String()),
|
|
}
|
|
if !isEmptyImageDetails(details) {
|
|
b.openAIStreamImageDetails = details
|
|
}
|
|
}
|
|
|
|
func (b *StreamUsageBuffer) applyOpenAIStreamObservations() {
|
|
if b == nil {
|
|
return
|
|
}
|
|
if b.openAIToolCallsRequested > 0 {
|
|
if b.detail.ToolUsageDetails == nil {
|
|
b.detail.ToolUsageDetails = &usage.ToolUsageDetails{}
|
|
}
|
|
if !b.openAIExplicitToolCalls {
|
|
b.detail.ToolUsageDetails.ToolCallsRequested = usage.Int64Ptr(b.openAIToolCallsRequested)
|
|
}
|
|
b.ok = true
|
|
}
|
|
if b.openAIStreamImages > 0 {
|
|
if !b.openAIExplicitImageCount || b.detail.ImageCount == nil {
|
|
b.detail.ImageCount = usage.Int64Ptr(b.openAIStreamImages)
|
|
}
|
|
if b.openAIStreamImageDetails != nil {
|
|
b.detail.ImageDetails = b.openAIStreamImageDetails.Clone()
|
|
}
|
|
if b.detail.RequestedImageDetails == nil && b.requestedImageDetails != nil {
|
|
b.detail.RequestedImageDetails = b.requestedImageDetails.Clone()
|
|
}
|
|
b.ok = true
|
|
}
|
|
}
|
|
|
|
// ObserveClaudeStream records and merges usage from a Claude SSE line.
|
|
func (b *StreamUsageBuffer) ObserveClaudeStream(line []byte) {
|
|
if b == nil {
|
|
return
|
|
}
|
|
payload := jsonPayload(line)
|
|
if b.responseModel == "" && len(payload) > 0 {
|
|
if model, _ := extractClaudeResponseModelEvent(payload); model != "" {
|
|
b.responseModel = model
|
|
}
|
|
}
|
|
if len(payload) > 0 {
|
|
b.observeClaudeStreamToolBlocks(payload)
|
|
}
|
|
if detail, ok := ParseClaudeStreamUsage(line); ok {
|
|
if detail.ToolUsageDetails != nil && detail.ToolUsageDetails.WebSearchCalls != nil && *detail.ToolUsageDetails.WebSearchCalls > 0 {
|
|
b.claudeReportedWebSearchCalls = usage.CloneInt64Ptr(detail.ToolUsageDetails.WebSearchCalls)
|
|
}
|
|
ObserveMergedStreamUsage(b, detail)
|
|
b.applyClaudeStreamToolObservations()
|
|
}
|
|
}
|
|
|
|
// ObserveClaudeSSEEvent extracts joined multi-line SSE data payloads from rawEvent
|
|
// and records any model or usage details when a frame was split across lines.
|
|
func (b *StreamUsageBuffer) ObserveClaudeSSEEvent(rawEvent []byte) {
|
|
if b == nil || len(rawEvent) == 0 {
|
|
return
|
|
}
|
|
var dataLines [][]byte
|
|
for _, line := range bytes.Split(rawEvent, []byte("\n")) {
|
|
trimmed := bytes.TrimSpace(line)
|
|
if !bytes.HasPrefix(trimmed, []byte("data:")) {
|
|
continue
|
|
}
|
|
payload := bytes.TrimSpace(trimmed[len("data:"):])
|
|
if len(payload) > 0 {
|
|
dataLines = append(dataLines, payload)
|
|
}
|
|
}
|
|
if len(dataLines) <= 1 {
|
|
return
|
|
}
|
|
joined := bytes.TrimSpace(bytes.Join(dataLines, []byte("\n")))
|
|
if len(joined) == 0 || !ojson.ValidBytes(joined) {
|
|
return
|
|
}
|
|
b.ObserveClaudeStream(joined)
|
|
}
|
|
|
|
func (b *StreamUsageBuffer) observeClaudeStreamToolBlocks(payload []byte) {
|
|
if b == nil || !bytes.Contains(payload, claudeStreamBlockStartMarker) || !ojson.ValidBytes(payload) {
|
|
return
|
|
}
|
|
root := util.ParseGJSONBytesNoCopy(payload)
|
|
if root.Get("type").String() != "content_block_start" {
|
|
return
|
|
}
|
|
cb := root.Get("content_block")
|
|
if !cb.Exists() || !cb.IsObject() {
|
|
return
|
|
}
|
|
switch cb.Get("type").String() {
|
|
case "server_tool_use":
|
|
if strings.TrimSpace(cb.Get("name").String()) != "web_search" {
|
|
return
|
|
}
|
|
id := strings.TrimSpace(cb.Get("id").String())
|
|
if id != "" {
|
|
if b.seenClaudeToolUseIDs == nil {
|
|
b.seenClaudeToolUseIDs = make(map[string]struct{})
|
|
}
|
|
if _, exists := b.seenClaudeToolUseIDs[id]; exists {
|
|
return
|
|
}
|
|
b.seenClaudeToolUseIDs[strings.Clone(id)] = struct{}{}
|
|
}
|
|
b.claudeWebSearchQueries++
|
|
b.applyClaudeStreamToolObservations()
|
|
case "web_search_tool_result":
|
|
content := cb.Get("content")
|
|
if !content.Exists() || !content.IsArray() {
|
|
return
|
|
}
|
|
toolUseID := strings.TrimSpace(cb.Get("tool_use_id").String())
|
|
if toolUseID != "" {
|
|
if b.seenClaudeToolResultIDs == nil {
|
|
b.seenClaudeToolResultIDs = make(map[string]struct{})
|
|
}
|
|
if _, exists := b.seenClaudeToolResultIDs[toolUseID]; exists {
|
|
return
|
|
}
|
|
b.seenClaudeToolResultIDs[strings.Clone(toolUseID)] = struct{}{}
|
|
}
|
|
b.claudeHasCompletedSearch = true
|
|
b.claudeCompletedSearches++
|
|
for _, item := range content.Array() {
|
|
if item.Get("type").String() == "web_search_result" {
|
|
b.claudeSearchResultsCount++
|
|
}
|
|
}
|
|
b.applyClaudeStreamToolObservations()
|
|
}
|
|
}
|
|
|
|
func (b *StreamUsageBuffer) applyClaudeStreamToolObservations() {
|
|
if b == nil {
|
|
return
|
|
}
|
|
if b.claudeWebSearchQueries == 0 && !b.claudeHasCompletedSearch {
|
|
return
|
|
}
|
|
if b.detail.ToolUsageDetails == nil {
|
|
b.detail.ToolUsageDetails = &usage.ToolUsageDetails{}
|
|
}
|
|
if b.claudeWebSearchQueries > 0 {
|
|
b.detail.ToolUsageDetails.WebSearchQueries = usage.Int64Ptr(b.claudeWebSearchQueries)
|
|
}
|
|
if b.claudeHasCompletedSearch {
|
|
b.detail.ToolUsageDetails.NumSearchResults = usage.Int64Ptr(b.claudeSearchResultsCount)
|
|
calls := b.claudeCompletedSearches
|
|
if b.claudeReportedWebSearchCalls != nil {
|
|
calls = *b.claudeReportedWebSearchCalls
|
|
}
|
|
b.detail.ToolUsageDetails.WebSearchCalls = usage.Int64Ptr(calls)
|
|
b.detail.WebSearchRequests = usage.Int64Ptr(calls)
|
|
}
|
|
b.ok = true
|
|
}
|
|
|
|
// Publish emits the latest observed usage detail, if any.
|
|
func (b *StreamUsageBuffer) Publish(ctx context.Context, reporter *UsageReporter) bool {
|
|
if b == nil || !b.ok || reporter == nil {
|
|
return false
|
|
}
|
|
if b.responseModel != "" && reporter.ResponseModel() == "" {
|
|
reporter.SetResponseModel(b.responseModel)
|
|
}
|
|
reporter.Publish(ctx, b.detail)
|
|
return true
|
|
}
|
|
|
|
// PublishFailure emits the latest observed usage detail together with failure details.
|
|
func (b *StreamUsageBuffer) PublishFailure(ctx context.Context, reporter *UsageReporter, errs ...error) bool {
|
|
if b == nil || reporter == nil {
|
|
return false
|
|
}
|
|
if b.responseModel != "" && reporter.ResponseModel() == "" {
|
|
reporter.SetResponseModel(b.responseModel)
|
|
}
|
|
reporter.PublishFailureWithDetail(ctx, b.detail, errs...)
|
|
return true
|
|
}
|
|
|
|
// Detail returns the latest observed usage detail.
|
|
func (b *StreamUsageBuffer) Detail() (usage.Detail, bool) {
|
|
if b == nil || !b.ok {
|
|
return usage.Detail{}, false
|
|
}
|
|
return b.detail, true
|
|
}
|
|
|
|
// ResponseModel returns the latest model observed in the stream buffer.
|
|
func (b *StreamUsageBuffer) ResponseModel() string {
|
|
if b == nil {
|
|
return ""
|
|
}
|
|
return b.responseModel
|
|
}
|
|
|
|
// ObserveResponsesStream collects response.output_item.done items across a
|
|
// Responses SSE/WebSocket stream and parses terminal response.usage payloads
|
|
// with those collected items so tool usage is preserved when response.output is empty.
|
|
func (b *StreamUsageBuffer) ObserveResponsesStream(line []byte) bool {
|
|
if b == nil {
|
|
return false
|
|
}
|
|
payload := jsonPayload(line)
|
|
if len(payload) == 0 || !ojson.ValidBytes(payload) {
|
|
return false
|
|
}
|
|
if b.responseModel == "" {
|
|
if model, _ := extractGenericResponseModelEvent(payload); model != "" {
|
|
b.responseModel = model
|
|
}
|
|
}
|
|
if bytes.Contains(payload, responsesOutputItemDoneMarker) {
|
|
root := util.ParseGJSONBytesNoCopy(payload)
|
|
if strings.TrimSpace(root.Get("type").String()) == "response.output_item.done" {
|
|
if item := root.Get("item"); item.Exists() && item.IsObject() {
|
|
rawItem := bytes.Clone([]byte(item.Raw))
|
|
if idxNode := root.Get("output_index"); idxNode.Type == ojson.Number && idxNode.Int() >= 0 {
|
|
if b.responsesOutputByIndex == nil {
|
|
b.responsesOutputByIndex = make(map[int64][]byte)
|
|
}
|
|
b.responsesOutputByIndex[idxNode.Int()] = rawItem
|
|
} else {
|
|
b.responsesOutputFallback = append(b.responsesOutputFallback, rawItem)
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
detail, ok := ParseCodexUsageWithOutputItems(payload, b.responsesOutputByIndex, b.responsesOutputFallback)
|
|
if !ok || (!hasNonZeroTokenUsage(detail) && !hasStructuredUsageDetail(detail) && detail.ResponseServiceTier == "") {
|
|
return false
|
|
}
|
|
b.Observe(detail, true)
|
|
return true
|
|
}
|
|
|
|
func ParseCodexUsage(data []byte) (usage.Detail, bool) {
|
|
return ParseCodexUsageWithOutputItems(data, nil, nil)
|
|
}
|
|
|
|
func ParseCodexUsageWithOutputItems(data []byte, itemsByIndex map[int64][]byte, fallback [][]byte) (usage.Detail, bool) {
|
|
if len(data) == 0 {
|
|
return usage.Detail{}, false
|
|
}
|
|
var responseServiceTier string
|
|
if bytes.Contains(data, openAIStreamServiceTierMarker) {
|
|
responseServiceTier = extractResponseServiceTier(data)
|
|
}
|
|
root := util.ParseGJSONBytesNoCopy(data)
|
|
usageNode := root.Get("response.usage")
|
|
detail, ok := parseOpenAIStyleUsageWithCache(root, usageNode)
|
|
if !ok {
|
|
if responseServiceTier == "" {
|
|
return usage.Detail{}, false
|
|
}
|
|
return usage.Detail{
|
|
ResponseServiceTier: responseServiceTier,
|
|
UpstreamServiceTier: responseServiceTier,
|
|
}, true
|
|
}
|
|
detail.ResponseServiceTier = responseServiceTier
|
|
if detail.UpstreamServiceTier == "" {
|
|
detail.UpstreamServiceTier = responseServiceTier
|
|
}
|
|
if wsReq := root.Get("response.tool_usage.web_search.num_requests"); wsReq.Type == ojson.Number {
|
|
v := wsReq.Int()
|
|
if detail.ToolUsageDetails == nil {
|
|
detail.ToolUsageDetails = &usage.ToolUsageDetails{}
|
|
}
|
|
if detail.ToolUsageDetails.WebSearchCalls == nil || (v > 0 && *detail.ToolUsageDetails.WebSearchCalls == 0) {
|
|
detail.ToolUsageDetails.WebSearchCalls = usage.Int64Ptr(v)
|
|
}
|
|
if detail.WebSearchRequests == nil || (v > 0 && *detail.WebSearchRequests == 0) {
|
|
detail.WebSearchRequests = usage.Int64Ptr(v)
|
|
}
|
|
}
|
|
outputNode := root.Get("response.output")
|
|
if outputNode.Exists() && outputNode.IsArray() && len(outputNode.Array()) > 0 {
|
|
applyResponsesOutputItemsUsage(&detail, outputNode)
|
|
} else if len(itemsByIndex) > 0 || len(fallback) > 0 {
|
|
applyResponsesCollectedOutputItemsUsage(&detail, itemsByIndex, fallback)
|
|
}
|
|
// When response.tool_usage.image_gen is present, CodexExecutor publishes a dedicated
|
|
// additional usage record for the image model (e.g. gpt-image-2) carrying ImageCount
|
|
// and ImageDetails; clear them on the orchestrator model record to avoid double-counting.
|
|
if hasOpenAIStyleUsageTokenFields(root.Get("response.tool_usage.image_gen")) {
|
|
detail.ImageCount = nil
|
|
detail.ImageDetails = nil
|
|
}
|
|
return detail, true
|
|
}
|
|
|
|
func applyResponsesCacheRetention(detail *usage.Detail, root, usageNode ojson.Result) {
|
|
if detail == nil {
|
|
return
|
|
}
|
|
retention := strings.TrimSpace(firstExistingUsageNode(
|
|
root,
|
|
"response.prompt_cache_retention",
|
|
"prompt_cache_retention",
|
|
).String())
|
|
if retention == "" {
|
|
retention = strings.TrimSpace(firstExistingUsageNode(
|
|
usageNode,
|
|
"prompt_cache_retention",
|
|
"prompt_cache_options.retention",
|
|
).String())
|
|
}
|
|
options := firstExistingUsageNode(root, "response.prompt_cache_options", "prompt_cache_options")
|
|
mode := cloneTrimmedString(options.Get("mode").String())
|
|
ttl := cloneTrimmedString(options.Get("ttl").String())
|
|
buckets := firstExistingUsageNode(usageNode, "input_tokens_details.cache_write_tokens_details", "prompt_tokens_details.cache_write_tokens_details")
|
|
short := buckets.Get("ttl_30m_tokens")
|
|
long := buckets.Get("ttl_12h_tokens")
|
|
if retention == "" && mode == "" && ttl == "" && short.Type != ojson.Number && long.Type != ojson.Number {
|
|
return
|
|
}
|
|
if detail.CacheDetails == nil {
|
|
detail.CacheDetails = &usage.CacheDetails{}
|
|
}
|
|
detail.CacheDetails.Retention = strings.Clone(retention)
|
|
detail.CacheDetails.Mode = mode
|
|
detail.CacheDetails.TTL = ttl
|
|
if short.Type == ojson.Number {
|
|
detail.CacheCreation30mTokens = usage.Int64Ptr(short.Int())
|
|
detail.CacheDetails.Ephemeral30mInputTokens = usage.Int64Ptr(short.Int())
|
|
}
|
|
if long.Type == ojson.Number {
|
|
detail.CacheCreation12hTokens = usage.Int64Ptr(long.Int())
|
|
detail.CacheDetails.Ephemeral12hInputTokens = usage.Int64Ptr(long.Int())
|
|
}
|
|
}
|
|
|
|
func ParseCodexImageToolUsage(data []byte) (usage.Detail, bool) {
|
|
return ParseCodexImageToolUsageWithOutputItems(nil, data, nil, nil)
|
|
}
|
|
|
|
func ParseCodexImageToolUsageWithOutputItems(requestBody, data []byte, itemsByIndex map[int64][]byte, fallback [][]byte) (usage.Detail, bool) {
|
|
if len(data) == 0 {
|
|
return usage.Detail{}, false
|
|
}
|
|
root := util.ParseGJSONBytesNoCopy(data)
|
|
usageNode := root.Get("response.tool_usage.image_gen")
|
|
if !hasOpenAIStyleUsageTokenFields(usageNode) {
|
|
return usage.Detail{}, false
|
|
}
|
|
detail := parseOpenAIStyleUsageNode(usageNode)
|
|
applyCodexImageToolOutputMetadata(&detail, requestBody, root.Get("response.output"), itemsByIndex, fallback)
|
|
return detail, true
|
|
}
|
|
|
|
func applyCodexImageToolOutputMetadata(detail *usage.Detail, requestBody []byte, outputNode ojson.Result, itemsByIndex map[int64][]byte, fallback [][]byte) {
|
|
if detail == nil {
|
|
return
|
|
}
|
|
var items []ojson.Result
|
|
if outputNode.Exists() && outputNode.IsArray() && len(outputNode.Array()) > 0 {
|
|
items = outputNode.Array()
|
|
} else {
|
|
items = parseCollectedOutputItems(itemsByIndex, fallback)
|
|
}
|
|
var count int64
|
|
var respMeta *usage.ImageDetails
|
|
for _, item := range items {
|
|
if strings.TrimSpace(item.Get("type").String()) != "image_generation_call" {
|
|
continue
|
|
}
|
|
if status := strings.TrimSpace(item.Get("status").String()); strings.EqualFold(status, "failed") || strings.EqualFold(status, "in_progress") {
|
|
continue
|
|
}
|
|
count++
|
|
if respMeta == nil {
|
|
meta := &usage.ImageDetails{
|
|
Size: cloneTrimmedString(item.Get("size").String()),
|
|
Resolution: cloneTrimmedString(item.Get("resolution").String()),
|
|
AspectRatio: cloneTrimmedString(item.Get("aspect_ratio").String()),
|
|
Quality: cloneTrimmedString(item.Get("quality").String()),
|
|
Background: cloneTrimmedString(item.Get("background").String()),
|
|
OutputFormat: cloneTrimmedString(item.Get("output_format").String()),
|
|
MimeType: cloneTrimmedString(firstExistingUsageNode(item, "mime_type", "mimeType").String()),
|
|
InputFidelity: cloneTrimmedString(item.Get("input_fidelity").String()),
|
|
}
|
|
if !isEmptyImageDetails(meta) {
|
|
respMeta = meta
|
|
}
|
|
}
|
|
}
|
|
if count > 0 {
|
|
detail.ImageCount = usage.Int64Ptr(count)
|
|
}
|
|
detail.ImageDetails = respMeta
|
|
detail.RequestedImageDetails = ParseRequestImageDetails(requestBody)
|
|
}
|
|
|
|
func ParseOpenAIUsage(data []byte) usage.Detail {
|
|
if len(data) == 0 {
|
|
return usage.Detail{}
|
|
}
|
|
var responseServiceTier string
|
|
if bytes.Contains(data, openAIStreamServiceTierMarker) {
|
|
responseServiceTier = extractResponseServiceTier(data)
|
|
}
|
|
root := util.ParseGJSONBytesNoCopy(data)
|
|
usageNode := root.Get("usage")
|
|
detail, _ := parseOpenAIStyleUsageWithCache(root, usageNode)
|
|
detail.ResponseServiceTier = responseServiceTier
|
|
if detail.UpstreamServiceTier == "" {
|
|
detail.UpstreamServiceTier = responseServiceTier
|
|
}
|
|
applyOpenAIChatToolCallsUsage(&detail, root)
|
|
if outputNode := root.Get("output"); outputNode.Exists() && outputNode.IsArray() {
|
|
applyResponsesOutputItemsUsage(&detail, outputNode)
|
|
}
|
|
return detail
|
|
}
|
|
|
|
func applyOpenAIChatToolCallsUsage(detail *usage.Detail, root ojson.Result) {
|
|
if detail == nil || !root.Exists() || !root.IsObject() {
|
|
return
|
|
}
|
|
var requested int64
|
|
for _, choice := range root.Get("choices").Array() {
|
|
if tc := choice.Get("message.tool_calls"); tc.IsArray() {
|
|
requested += int64(len(tc.Array()))
|
|
} else if tc := choice.Get("delta.tool_calls"); tc.IsArray() {
|
|
requested += int64(len(tc.Array()))
|
|
}
|
|
}
|
|
if requested > 0 {
|
|
if detail.ToolUsageDetails == nil {
|
|
detail.ToolUsageDetails = &usage.ToolUsageDetails{}
|
|
}
|
|
if detail.ToolUsageDetails.ToolCallsRequested == nil {
|
|
detail.ToolUsageDetails.ToolCallsRequested = usage.Int64Ptr(requested)
|
|
}
|
|
}
|
|
}
|
|
|
|
// parseOpenAIStyleUsageWithCache keeps structured-only usage and cache metadata
|
|
// consistent across Chat, Responses, and streaming entry points.
|
|
func parseOpenAIStyleUsageWithCache(root, usageNode ojson.Result) (usage.Detail, bool) {
|
|
var detail usage.Detail
|
|
hasTokens := hasOpenAIStyleUsageTokenFields(usageNode)
|
|
if hasTokens {
|
|
detail = parseOpenAIStyleUsageNode(usageNode)
|
|
} else {
|
|
populateOpenAIStyleStructuredFields(&detail, usageNode)
|
|
}
|
|
applyResponsesCacheRetention(&detail, root, usageNode)
|
|
return detail, hasTokens || hasStructuredUsageDetail(detail)
|
|
}
|
|
|
|
func hasStructuredUsageDetail(d usage.Detail) bool {
|
|
return d.CacheDetails != nil || d.ToolUsageDetails != nil || d.CostDetails != nil ||
|
|
d.WebSearchRequests != nil || d.ImageCount != nil || d.ImageDetails != nil ||
|
|
d.RequestedImageDetails != nil || d.MediaCounts != nil || d.Iterations != nil ||
|
|
d.CacheCreation5mTokens != nil || d.CacheCreation30mTokens != nil ||
|
|
d.CacheCreation1hTokens != nil || d.CacheCreation12hTokens != nil ||
|
|
d.TextInputTokens != nil || d.ImageInputTokens != nil || d.AudioInputTokens != nil ||
|
|
d.VideoInputTokens != nil || d.FileInputTokens != nil || d.CachedTextTokens != nil ||
|
|
d.CachedImageTokens != nil || d.CachedAudioTokens != nil ||
|
|
d.TextOutputTokens != nil || d.ImageOutputTokens != nil || d.AudioOutputTokens != nil ||
|
|
d.AcceptedPredictionTokens != nil || d.RejectedPredictionTokens != nil ||
|
|
d.Speed != "" || d.InferenceGeo != ""
|
|
}
|
|
|
|
func hasOpenAIStyleUsageTokenFields(usageNode ojson.Result) bool {
|
|
if !usageNode.Exists() || !usageNode.IsObject() {
|
|
return false
|
|
}
|
|
return usageNode.Get("total_tokens").Exists() || hasOpenAIStyleUsageBucketFields(usageNode)
|
|
}
|
|
|
|
func hasOpenAIStyleUsageBucketFields(usageNode ojson.Result) bool {
|
|
return usageNode.Get("prompt_tokens").Exists() ||
|
|
usageNode.Get("input_tokens").Exists() ||
|
|
usageNode.Get("completion_tokens").Exists() ||
|
|
usageNode.Get("output_tokens").Exists() ||
|
|
usageNode.Get("prompt_tokens_details.cached_tokens").Exists() ||
|
|
usageNode.Get("input_tokens_details.cached_tokens").Exists() ||
|
|
usageNode.Get("prompt_tokens_details.cache_write_tokens").Exists() ||
|
|
usageNode.Get("prompt_tokens_details.cache_creation_tokens").Exists() ||
|
|
usageNode.Get("input_tokens_details.cache_write_tokens").Exists() ||
|
|
usageNode.Get("input_tokens_details.cache_creation_tokens").Exists() ||
|
|
usageNode.Get("completion_tokens_details.reasoning_tokens").Exists() ||
|
|
usageNode.Get("output_tokens_details.reasoning_tokens").Exists() ||
|
|
usageNode.Get("reasoning_tokens").Exists()
|
|
}
|
|
|
|
func parseOpenAIStyleUsageNode(usageNode ojson.Result) usage.Detail {
|
|
if !usageNode.Exists() || !usageNode.IsObject() {
|
|
return usage.Detail{}
|
|
}
|
|
var (
|
|
detail usage.Detail
|
|
hasInput bool
|
|
hasOutput bool
|
|
hasBucketFields bool
|
|
inputDetails ojson.Result
|
|
promptDetails ojson.Result
|
|
outputDetails ojson.Result
|
|
compDetails ojson.Result
|
|
flatReasoning ojson.Result
|
|
)
|
|
usageNode.ForEach(func(key, val ojson.Result) bool {
|
|
switch key.String() {
|
|
case "prompt_tokens":
|
|
detail.InputTokens = val.Int()
|
|
hasInput = true
|
|
hasBucketFields = true
|
|
case "input_tokens":
|
|
if !hasInput {
|
|
detail.InputTokens = val.Int()
|
|
hasInput = true
|
|
}
|
|
hasBucketFields = true
|
|
case "completion_tokens":
|
|
detail.OutputTokens = val.Int()
|
|
hasOutput = true
|
|
hasBucketFields = true
|
|
case "output_tokens":
|
|
if !hasOutput {
|
|
detail.OutputTokens = val.Int()
|
|
hasOutput = true
|
|
}
|
|
hasBucketFields = true
|
|
case "total_tokens":
|
|
detail.TotalTokens = val.Int()
|
|
case "reasoning_tokens":
|
|
flatReasoning = val
|
|
hasBucketFields = true
|
|
case "prompt_tokens_details":
|
|
promptDetails = val
|
|
case "input_tokens_details":
|
|
inputDetails = val
|
|
case "completion_tokens_details":
|
|
compDetails = val
|
|
case "output_tokens_details":
|
|
outputDetails = val
|
|
}
|
|
return true
|
|
})
|
|
|
|
var hasCached, hasCacheCreation, hasReasoning bool
|
|
scanInDetails := func(node ojson.Result) {
|
|
if !node.Exists() || !node.IsObject() {
|
|
return
|
|
}
|
|
node.ForEach(func(k, v ojson.Result) bool {
|
|
switch k.String() {
|
|
case "cached_tokens":
|
|
if !hasCached {
|
|
detail.CachedTokens = v.Int()
|
|
detail.CacheReadTokens = v.Int()
|
|
hasCached = true
|
|
}
|
|
hasBucketFields = true
|
|
case "cache_creation_tokens", "cache_write_tokens":
|
|
if !hasCacheCreation {
|
|
detail.CacheCreationTokens = v.Int()
|
|
hasCacheCreation = true
|
|
}
|
|
hasBucketFields = true
|
|
case "text_tokens":
|
|
if v.Type == ojson.Number && detail.TextInputTokens == nil {
|
|
detail.TextInputTokens = usage.Int64Ptr(v.Int())
|
|
}
|
|
case "image_tokens", "prompt_image_tokens":
|
|
if v.Type == ojson.Number && detail.ImageInputTokens == nil {
|
|
detail.ImageInputTokens = usage.Int64Ptr(v.Int())
|
|
}
|
|
case "audio_tokens":
|
|
if v.Type == ojson.Number && detail.AudioInputTokens == nil {
|
|
detail.AudioInputTokens = usage.Int64Ptr(v.Int())
|
|
}
|
|
case "video_tokens":
|
|
if v.Type == ojson.Number && detail.VideoInputTokens == nil {
|
|
detail.VideoInputTokens = usage.Int64Ptr(v.Int())
|
|
}
|
|
case "file_tokens":
|
|
if v.Type == ojson.Number && detail.FileInputTokens == nil {
|
|
detail.FileInputTokens = usage.Int64Ptr(v.Int())
|
|
}
|
|
case "cached_prompt_text_tokens", "cached_text_tokens":
|
|
if v.Type == ojson.Number && detail.CachedTextTokens == nil {
|
|
detail.CachedTextTokens = usage.Int64Ptr(v.Int())
|
|
}
|
|
case "cached_image_tokens":
|
|
if v.Type == ojson.Number && detail.CachedImageTokens == nil {
|
|
detail.CachedImageTokens = usage.Int64Ptr(v.Int())
|
|
}
|
|
case "cached_audio_tokens":
|
|
if v.Type == ojson.Number && detail.CachedAudioTokens == nil {
|
|
detail.CachedAudioTokens = usage.Int64Ptr(v.Int())
|
|
}
|
|
case "cached_tokens_details":
|
|
if v.IsObject() {
|
|
if detail.CachedTextTokens == nil {
|
|
if tv := v.Get("text_tokens"); tv.Type == ojson.Number {
|
|
detail.CachedTextTokens = usage.Int64Ptr(tv.Int())
|
|
}
|
|
}
|
|
if detail.CachedImageTokens == nil {
|
|
if iv := v.Get("image_tokens"); iv.Type == ojson.Number {
|
|
detail.CachedImageTokens = usage.Int64Ptr(iv.Int())
|
|
}
|
|
}
|
|
if detail.CachedAudioTokens == nil {
|
|
if av := v.Get("audio_tokens"); av.Type == ojson.Number {
|
|
detail.CachedAudioTokens = usage.Int64Ptr(av.Int())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
// Match original precedence: prompt_tokens_details first for cached_tokens, input_tokens_details first for structured fields & cache_creation_tokens.
|
|
if promptDetails.Exists() {
|
|
if c := promptDetails.Get("cached_tokens"); c.Exists() {
|
|
detail.CachedTokens = c.Int()
|
|
detail.CacheReadTokens = c.Int()
|
|
hasCached = true
|
|
hasBucketFields = true
|
|
}
|
|
}
|
|
scanInDetails(inputDetails)
|
|
scanInDetails(promptDetails)
|
|
|
|
scanOutDetails := func(node ojson.Result) {
|
|
if !node.Exists() || !node.IsObject() {
|
|
return
|
|
}
|
|
node.ForEach(func(k, v ojson.Result) bool {
|
|
switch k.String() {
|
|
case "reasoning_tokens":
|
|
if !hasReasoning {
|
|
detail.ReasoningTokens = v.Int()
|
|
hasReasoning = true
|
|
}
|
|
hasBucketFields = true
|
|
case "text_tokens":
|
|
if v.Type == ojson.Number && detail.TextOutputTokens == nil {
|
|
detail.TextOutputTokens = usage.Int64Ptr(v.Int())
|
|
}
|
|
case "image_tokens":
|
|
if v.Type == ojson.Number && detail.ImageOutputTokens == nil {
|
|
detail.ImageOutputTokens = usage.Int64Ptr(v.Int())
|
|
}
|
|
case "audio_tokens":
|
|
if v.Type == ojson.Number && detail.AudioOutputTokens == nil {
|
|
detail.AudioOutputTokens = usage.Int64Ptr(v.Int())
|
|
}
|
|
case "accepted_prediction_tokens":
|
|
if v.Type == ojson.Number && detail.AcceptedPredictionTokens == nil {
|
|
detail.AcceptedPredictionTokens = usage.Int64Ptr(v.Int())
|
|
}
|
|
case "rejected_prediction_tokens":
|
|
if v.Type == ojson.Number && detail.RejectedPredictionTokens == nil {
|
|
detail.RejectedPredictionTokens = usage.Int64Ptr(v.Int())
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
if compDetails.Exists() {
|
|
if r := compDetails.Get("reasoning_tokens"); r.Exists() {
|
|
detail.ReasoningTokens = r.Int()
|
|
hasReasoning = true
|
|
hasBucketFields = true
|
|
}
|
|
}
|
|
scanOutDetails(outputDetails)
|
|
scanOutDetails(compDetails)
|
|
if !hasReasoning && flatReasoning.Exists() {
|
|
detail.ReasoningTokens = flatReasoning.Int()
|
|
hasReasoning = true
|
|
}
|
|
|
|
if hasBucketFields {
|
|
if hasInput && hasOutput {
|
|
detail.TokenBreakdown = usage.NewSubsetTokenBreakdown(
|
|
detail.InputTokens,
|
|
detail.CacheReadTokens,
|
|
detail.CacheCreationTokens,
|
|
detail.OutputTokens,
|
|
detail.ReasoningTokens,
|
|
detail.TotalTokens,
|
|
)
|
|
} else {
|
|
cacheReadTokens := detail.CacheReadTokens
|
|
cacheCreationTokens := detail.CacheCreationTokens
|
|
if !hasInput {
|
|
cacheReadTokens = 0
|
|
cacheCreationTokens = 0
|
|
}
|
|
reasoningTokens := detail.ReasoningTokens
|
|
if !hasOutput {
|
|
reasoningTokens = 0
|
|
}
|
|
detail.TokenBreakdown = usage.NewPartialSubsetTokenBreakdown(
|
|
detail.InputTokens,
|
|
cacheReadTokens,
|
|
cacheCreationTokens,
|
|
detail.OutputTokens,
|
|
reasoningTokens,
|
|
detail.TotalTokens,
|
|
)
|
|
}
|
|
} else {
|
|
detail.TokenBreakdown = usage.NewUnclassifiedTokenBreakdown(detail.TotalTokens)
|
|
}
|
|
if detail.TotalTokens == 0 {
|
|
detail.TotalTokens = detail.TokenBreakdown.TotalTokens
|
|
}
|
|
populateOpenAIStyleStructuredFields(&detail, usageNode)
|
|
return detail
|
|
}
|
|
|
|
func populateOpenAIStyleStructuredFields(detail *usage.Detail, usageNode ojson.Result) {
|
|
if detail == nil || !usageNode.Exists() || !usageNode.IsObject() {
|
|
return
|
|
}
|
|
var (
|
|
toolDetails *usage.ToolUsageDetails
|
|
costNode ojson.Result
|
|
ticksNode ojson.Result
|
|
byokNode ojson.Result
|
|
costDetails ojson.Result
|
|
hasCost bool
|
|
)
|
|
usageNode.ForEach(func(key, val ojson.Result) bool {
|
|
switch key.String() {
|
|
case "service_tier":
|
|
if detail.UpstreamServiceTier == "" && val.Type == ojson.String {
|
|
detail.UpstreamServiceTier = cloneTrimmedString(val.String())
|
|
}
|
|
case "attribution":
|
|
if detail.UpstreamServiceTier == "" && val.IsObject() {
|
|
if t := val.Get("tier"); t.Type == ojson.String {
|
|
detail.UpstreamServiceTier = cloneTrimmedString(t.String())
|
|
}
|
|
}
|
|
case "server_side_tool_usage_details", "server_side_tool_usage", "server_tool_use_details", "server_tool_use":
|
|
if parsed := parseOpenAIToolUsageDetailsNode(val); parsed != nil {
|
|
toolDetails = mergeToolUsageDetails(toolDetails, parsed)
|
|
}
|
|
case "num_sources_used":
|
|
if val.Type == ojson.Number {
|
|
if toolDetails == nil {
|
|
toolDetails = &usage.ToolUsageDetails{}
|
|
}
|
|
toolDetails.NumSourcesUsed = usage.Int64Ptr(val.Int())
|
|
}
|
|
case "num_server_side_tools_used":
|
|
if val.Type == ojson.Number {
|
|
if toolDetails == nil {
|
|
toolDetails = &usage.ToolUsageDetails{}
|
|
}
|
|
toolDetails.NumServerSideToolsUsed = usage.Int64Ptr(val.Int())
|
|
}
|
|
case "cost":
|
|
costNode = val
|
|
hasCost = true
|
|
case "cost_in_usd_ticks":
|
|
ticksNode = val
|
|
hasCost = true
|
|
case "is_byok":
|
|
byokNode = val
|
|
hasCost = true
|
|
case "cost_details":
|
|
costDetails = val
|
|
hasCost = true
|
|
}
|
|
return true
|
|
})
|
|
detail.ToolUsageDetails = toolDetails
|
|
if toolDetails != nil {
|
|
if toolDetails.WebSearchCalls != nil {
|
|
detail.WebSearchRequests = usage.CloneInt64Ptr(toolDetails.WebSearchCalls)
|
|
}
|
|
if detail.ImageCount == nil && toolDetails.ImageGenerationCalls != nil && *toolDetails.ImageGenerationCalls > 0 {
|
|
detail.ImageCount = usage.CloneInt64Ptr(toolDetails.ImageGenerationCalls)
|
|
}
|
|
}
|
|
if hasCost {
|
|
_ = costNode
|
|
_ = ticksNode
|
|
_ = byokNode
|
|
_ = costDetails
|
|
detail.CostDetails = parseClaudeCostNode(usageNode)
|
|
}
|
|
}
|
|
|
|
func parseCollectedOutputItems(itemsByIndex map[int64][]byte, fallback [][]byte) []ojson.Result {
|
|
if len(itemsByIndex) == 0 && len(fallback) == 0 {
|
|
return nil
|
|
}
|
|
items := make([]ojson.Result, 0, len(itemsByIndex)+len(fallback))
|
|
if len(itemsByIndex) > 0 {
|
|
indexes := make([]int64, 0, len(itemsByIndex))
|
|
for idx := range itemsByIndex {
|
|
indexes = append(indexes, idx)
|
|
}
|
|
for i := 0; i < len(indexes); i++ {
|
|
for j := i + 1; j < len(indexes); j++ {
|
|
if indexes[j] < indexes[i] {
|
|
indexes[i], indexes[j] = indexes[j], indexes[i]
|
|
}
|
|
}
|
|
}
|
|
for _, idx := range indexes {
|
|
if raw := itemsByIndex[idx]; len(raw) > 0 && ojson.ValidBytes(raw) {
|
|
items = append(items, util.ParseGJSONBytesNoCopy(raw))
|
|
}
|
|
}
|
|
}
|
|
for _, raw := range fallback {
|
|
if len(raw) > 0 && ojson.ValidBytes(raw) {
|
|
items = append(items, util.ParseGJSONBytesNoCopy(raw))
|
|
}
|
|
}
|
|
return items
|
|
}
|
|
|
|
func applyResponsesCollectedOutputItemsUsage(detail *usage.Detail, itemsByIndex map[int64][]byte, fallback [][]byte) {
|
|
if detail == nil {
|
|
return
|
|
}
|
|
items := parseCollectedOutputItems(itemsByIndex, fallback)
|
|
if len(items) == 0 {
|
|
return
|
|
}
|
|
applyResponsesOutputItemSliceUsage(detail, items)
|
|
}
|
|
|
|
func applyResponsesOutputItemsUsage(detail *usage.Detail, outputNode ojson.Result) {
|
|
if detail == nil || !outputNode.Exists() || !outputNode.IsArray() {
|
|
return
|
|
}
|
|
applyResponsesOutputItemSliceUsage(detail, outputNode.Array())
|
|
}
|
|
|
|
func applyResponsesOutputItemSliceUsage(detail *usage.Detail, items []ojson.Result) {
|
|
if detail == nil || len(items) == 0 {
|
|
return
|
|
}
|
|
seenIDs := make(map[string]struct{})
|
|
var (
|
|
webSearchCalls int64
|
|
webSearchQueries int64
|
|
webSearchSources int64
|
|
imageSearchCalls int64
|
|
xSearchCalls int64
|
|
codeExecCalls int64
|
|
fileSearchCalls int64
|
|
documentSearchCalls int64
|
|
mcpCalls int64
|
|
imageGenCalls int64
|
|
toolCallsRequested int64
|
|
firstImageMeta *usage.ImageDetails
|
|
)
|
|
for _, item := range items {
|
|
if !item.IsObject() {
|
|
continue
|
|
}
|
|
if status := strings.TrimSpace(item.Get("status").String()); strings.EqualFold(status, "failed") || strings.EqualFold(status, "in_progress") {
|
|
continue
|
|
}
|
|
if id := strings.TrimSpace(firstExistingUsageNode(item, "id", "call_id").String()); id != "" {
|
|
if _, exists := seenIDs[id]; exists {
|
|
continue
|
|
}
|
|
seenIDs[id] = struct{}{}
|
|
}
|
|
switch strings.TrimSpace(item.Get("type").String()) {
|
|
case "web_search_call":
|
|
webSearchCalls++
|
|
if strings.HasPrefix(strings.TrimSpace(item.Get("id").String()), "is_") {
|
|
imageSearchCalls++
|
|
}
|
|
action := item.Get("action")
|
|
if queries := action.Get("queries"); queries.IsArray() && len(queries.Array()) > 0 {
|
|
webSearchQueries += int64(len(queries.Array()))
|
|
} else if q := strings.TrimSpace(action.Get("query").String()); q != "" || strings.EqualFold(strings.TrimSpace(action.Get("type").String()), "search") {
|
|
webSearchQueries++
|
|
}
|
|
if sources := action.Get("sources"); sources.IsArray() {
|
|
webSearchSources += int64(len(sources.Array()))
|
|
}
|
|
case "file_search_call":
|
|
fileSearchCalls++
|
|
case "code_interpreter_call":
|
|
codeExecCalls++
|
|
case "mcp_call":
|
|
mcpCalls++
|
|
case "image_generation_call":
|
|
imageGenCalls++
|
|
if firstImageMeta == nil {
|
|
meta := &usage.ImageDetails{
|
|
Size: cloneTrimmedString(item.Get("size").String()),
|
|
Resolution: cloneTrimmedString(item.Get("resolution").String()),
|
|
AspectRatio: cloneTrimmedString(item.Get("aspect_ratio").String()),
|
|
Quality: cloneTrimmedString(item.Get("quality").String()),
|
|
Background: cloneTrimmedString(item.Get("background").String()),
|
|
OutputFormat: cloneTrimmedString(item.Get("output_format").String()),
|
|
MimeType: cloneTrimmedString(firstExistingUsageNode(item, "mime_type", "mimeType").String()),
|
|
InputFidelity: cloneTrimmedString(item.Get("input_fidelity").String()),
|
|
}
|
|
if !isEmptyImageDetails(meta) {
|
|
firstImageMeta = meta
|
|
}
|
|
}
|
|
case "function_call", "local_shell_call", "shell_call", "computer_call", "apply_patch_call":
|
|
toolCallsRequested++
|
|
case "custom_tool_call":
|
|
callID := strings.TrimSpace(item.Get("call_id").String())
|
|
switch {
|
|
case strings.HasPrefix(callID, "xs_"):
|
|
xSearchCalls++
|
|
case strings.HasPrefix(callID, "as_"):
|
|
documentSearchCalls++
|
|
default:
|
|
toolCallsRequested++
|
|
}
|
|
}
|
|
}
|
|
if webSearchCalls == 0 && xSearchCalls == 0 && codeExecCalls == 0 && fileSearchCalls == 0 && documentSearchCalls == 0 && mcpCalls == 0 && imageGenCalls == 0 && toolCallsRequested == 0 {
|
|
return
|
|
}
|
|
if detail.ToolUsageDetails == nil {
|
|
detail.ToolUsageDetails = &usage.ToolUsageDetails{}
|
|
}
|
|
if webSearchCalls > 0 && (detail.ToolUsageDetails.WebSearchCalls == nil || *detail.ToolUsageDetails.WebSearchCalls == 0) {
|
|
detail.ToolUsageDetails.WebSearchCalls = usage.Int64Ptr(webSearchCalls)
|
|
if detail.WebSearchRequests == nil || *detail.WebSearchRequests == 0 {
|
|
detail.WebSearchRequests = usage.Int64Ptr(webSearchCalls)
|
|
}
|
|
} else if imageSearchCalls > 0 && detail.ToolUsageDetails.WebSearchCalls != nil && *detail.ToolUsageDetails.WebSearchCalls == 0 {
|
|
// xAI Image Search (id prefix "is_") is billed at the standard Web Search rate
|
|
// even when server_side_tool_usage_details.web_search_calls reports 0.
|
|
detail.ToolUsageDetails.WebSearchCalls = usage.Int64Ptr(imageSearchCalls)
|
|
detail.WebSearchRequests = usage.Int64Ptr(imageSearchCalls)
|
|
}
|
|
if imageSearchCalls > 0 {
|
|
if detail.ToolUsageDetails.Extra == nil {
|
|
detail.ToolUsageDetails.Extra = make(map[string]int64)
|
|
}
|
|
detail.ToolUsageDetails.Extra["image_search_calls"] = imageSearchCalls
|
|
}
|
|
if xSearchCalls > 0 && detail.ToolUsageDetails.XSearchCalls == nil {
|
|
detail.ToolUsageDetails.XSearchCalls = usage.Int64Ptr(xSearchCalls)
|
|
}
|
|
if codeExecCalls > 0 && detail.ToolUsageDetails.CodeExecutionCalls == nil {
|
|
detail.ToolUsageDetails.CodeExecutionCalls = usage.Int64Ptr(codeExecCalls)
|
|
}
|
|
if fileSearchCalls > 0 && detail.ToolUsageDetails.FileSearchCalls == nil {
|
|
detail.ToolUsageDetails.FileSearchCalls = usage.Int64Ptr(fileSearchCalls)
|
|
}
|
|
if documentSearchCalls > 0 && detail.ToolUsageDetails.DocumentSearchCalls == nil {
|
|
detail.ToolUsageDetails.DocumentSearchCalls = usage.Int64Ptr(documentSearchCalls)
|
|
}
|
|
if mcpCalls > 0 && detail.ToolUsageDetails.MCPCalls == nil {
|
|
detail.ToolUsageDetails.MCPCalls = usage.Int64Ptr(mcpCalls)
|
|
}
|
|
if webSearchQueries > 0 && detail.ToolUsageDetails.WebSearchQueries == nil {
|
|
detail.ToolUsageDetails.WebSearchQueries = usage.Int64Ptr(webSearchQueries)
|
|
}
|
|
if webSearchSources > 0 && detail.ToolUsageDetails.NumSourcesUsed == nil {
|
|
detail.ToolUsageDetails.NumSourcesUsed = usage.Int64Ptr(webSearchSources)
|
|
}
|
|
if imageGenCalls > 0 {
|
|
if detail.ToolUsageDetails.ImageGenerationCalls == nil {
|
|
detail.ToolUsageDetails.ImageGenerationCalls = usage.Int64Ptr(imageGenCalls)
|
|
}
|
|
if detail.ImageCount == nil {
|
|
detail.ImageCount = usage.Int64Ptr(imageGenCalls)
|
|
}
|
|
if detail.ImageDetails == nil && firstImageMeta != nil {
|
|
detail.ImageDetails = firstImageMeta
|
|
}
|
|
}
|
|
if toolCallsRequested > 0 && detail.ToolUsageDetails.ToolCallsRequested == nil {
|
|
detail.ToolUsageDetails.ToolCallsRequested = usage.Int64Ptr(toolCallsRequested)
|
|
}
|
|
}
|
|
|
|
func isEmptyImageDetails(d *usage.ImageDetails) bool {
|
|
if d == nil {
|
|
return true
|
|
}
|
|
return d.Size == "" && d.Resolution == "" && d.ImageSize == "" && d.AspectRatio == "" && d.Quality == "" && d.Background == "" && d.OutputFormat == "" && d.ResponseFormat == "" && d.MimeType == "" && d.InputFidelity == ""
|
|
}
|
|
|
|
// ParseRequestImageDetails extracts requested image/video parameters strictly from a request payload,
|
|
// preserving each upstream protocol's native field names.
|
|
func ParseRequestImageDetails(requestPayload []byte, contentType ...string) *usage.ImageDetails {
|
|
if len(contentType) > 0 {
|
|
mediaType, params, errParse := mime.ParseMediaType(contentType[0])
|
|
if errParse == nil && mediaType == "multipart/form-data" {
|
|
return parseMultipartImageDetails(requestPayload, params["boundary"])
|
|
}
|
|
}
|
|
if len(requestPayload) == 0 || !ojson.ValidBytes(requestPayload) {
|
|
return nil
|
|
}
|
|
root := util.ParseGJSONBytesNoCopy(requestPayload)
|
|
pick := func(paths ...string) string {
|
|
for _, p := range paths {
|
|
if v := root.Get(p); v.Type == ojson.String {
|
|
if s := cloneTrimmedString(v.String()); s != "" {
|
|
return s
|
|
}
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
out := &usage.ImageDetails{
|
|
Size: pick("size"),
|
|
Resolution: pick("resolution", "image_config.resolution"),
|
|
ImageSize: pick("image_size", "imageSize", "image_config.image_size", "image_config.imageSize", "generationConfig.imageConfig.imageSize", "generation_config.image_config.image_size", "request.generationConfig.imageConfig.imageSize", "request.generation_config.image_config.image_size", "parameters.sampleImageSize"),
|
|
AspectRatio: pick("aspect_ratio", "aspectRatio", "image_config.aspect_ratio", "image_config.aspectRatio", "generationConfig.imageConfig.aspectRatio", "generation_config.image_config.aspect_ratio", "request.generationConfig.imageConfig.aspectRatio", "request.generation_config.image_config.aspect_ratio", "parameters.aspectRatio"),
|
|
Quality: pick("quality"),
|
|
Background: pick("background"),
|
|
OutputFormat: pick("output_format"),
|
|
ResponseFormat: pick("response_format"),
|
|
MimeType: pick("mime_type", "mimeType", "parameters.outputOptions.mimeType"),
|
|
InputFidelity: pick("input_fidelity"),
|
|
}
|
|
if isEmptyImageDetails(out) {
|
|
for _, tool := range root.Get("tools").Array() {
|
|
if strings.TrimSpace(tool.Get("type").String()) != "image_generation" {
|
|
continue
|
|
}
|
|
out = &usage.ImageDetails{
|
|
Size: cloneTrimmedString(tool.Get("size").String()),
|
|
Resolution: cloneTrimmedString(tool.Get("resolution").String()),
|
|
ImageSize: cloneTrimmedString(firstExistingUsageNode(tool, "image_size", "imageSize").String()),
|
|
AspectRatio: cloneTrimmedString(firstExistingUsageNode(tool, "aspect_ratio", "aspectRatio").String()),
|
|
Quality: cloneTrimmedString(tool.Get("quality").String()),
|
|
Background: cloneTrimmedString(tool.Get("background").String()),
|
|
OutputFormat: cloneTrimmedString(tool.Get("output_format").String()),
|
|
MimeType: cloneTrimmedString(firstExistingUsageNode(tool, "mime_type", "mimeType").String()),
|
|
InputFidelity: cloneTrimmedString(tool.Get("input_fidelity").String()),
|
|
}
|
|
break
|
|
}
|
|
}
|
|
if isEmptyImageDetails(out) {
|
|
return nil
|
|
}
|
|
return out
|
|
}
|
|
|
|
// parseMultipartImageDetails reads only small scalar attributes. File parts and
|
|
// unrelated fields are drained without allocating another copy or temporary files.
|
|
func parseMultipartImageDetails(payload []byte, boundary string) *usage.ImageDetails {
|
|
if boundary == "" {
|
|
return nil
|
|
}
|
|
out := &usage.ImageDetails{}
|
|
fields := map[string]*string{
|
|
"size": &out.Size, "resolution": &out.Resolution, "image_size": &out.ImageSize,
|
|
"aspect_ratio": &out.AspectRatio, "quality": &out.Quality,
|
|
"background": &out.Background, "output_format": &out.OutputFormat,
|
|
"response_format": &out.ResponseFormat, "mime_type": &out.MimeType,
|
|
"input_fidelity": &out.InputFidelity,
|
|
}
|
|
reader := multipart.NewReader(bytes.NewReader(payload), boundary)
|
|
for {
|
|
part, errNext := reader.NextPart()
|
|
if errNext == io.EOF {
|
|
break
|
|
}
|
|
if errNext != nil {
|
|
log.Debugf("usage: read multipart image attributes: %v", errNext)
|
|
return nil
|
|
}
|
|
dst := fields[part.FormName()]
|
|
var value []byte
|
|
var errRead error
|
|
const maxAttributeBytes = 4096
|
|
if dst != nil && part.FileName() == "" {
|
|
value, errRead = io.ReadAll(io.LimitReader(part, maxAttributeBytes+1))
|
|
}
|
|
errClose := part.Close()
|
|
if errRead != nil || errClose != nil {
|
|
log.Debugf("usage: read multipart image attribute: read=%v close=%v", errRead, errClose)
|
|
return nil
|
|
}
|
|
if dst != nil && len(value) <= maxAttributeBytes && len(value) > 0 {
|
|
*dst = strings.TrimSpace(string(value))
|
|
}
|
|
}
|
|
if isEmptyImageDetails(out) {
|
|
return nil
|
|
}
|
|
return out
|
|
}
|
|
|
|
// ParseOpenAIImageUsage extracts token usage, generated image count, and separate
|
|
// request vs upstream response image parameters from an OpenAI or xAI image request/response.
|
|
func ParseOpenAIImageUsage(requestPayload, responsePayload []byte, contentType ...string) usage.Detail {
|
|
var detail usage.Detail
|
|
detail.RequestedImageDetails = ParseRequestImageDetails(requestPayload, contentType...)
|
|
if len(responsePayload) == 0 || !ojson.ValidBytes(responsePayload) {
|
|
return detail
|
|
}
|
|
root := util.ParseGJSONBytesNoCopy(responsePayload)
|
|
var (
|
|
usageNode ojson.Result
|
|
serviceTier string
|
|
imageCount int64
|
|
imgDetails usage.ImageDetails
|
|
firstItemMeta usage.ImageDetails
|
|
)
|
|
root.ForEach(func(key, val ojson.Result) bool {
|
|
switch key.String() {
|
|
case "usage":
|
|
usageNode = val
|
|
case "service_tier":
|
|
if val.Type == ojson.String {
|
|
serviceTier = cloneTrimmedString(val.String())
|
|
}
|
|
case "data":
|
|
if val.IsArray() {
|
|
arr := val.Array()
|
|
imageCount = int64(len(arr))
|
|
if len(arr) > 0 && arr[0].IsObject() {
|
|
arr[0].ForEach(func(dk, dv ojson.Result) bool {
|
|
if dv.Type != ojson.String {
|
|
return true
|
|
}
|
|
switch dk.String() {
|
|
case "b64_json", "url", "revised_prompt":
|
|
return true
|
|
case "size":
|
|
firstItemMeta.Size = cloneTrimmedString(dv.String())
|
|
case "resolution":
|
|
firstItemMeta.Resolution = cloneTrimmedString(dv.String())
|
|
case "image_size", "imageSize":
|
|
if firstItemMeta.ImageSize == "" {
|
|
firstItemMeta.ImageSize = cloneTrimmedString(dv.String())
|
|
}
|
|
case "aspect_ratio", "aspectRatio":
|
|
if firstItemMeta.AspectRatio == "" {
|
|
firstItemMeta.AspectRatio = cloneTrimmedString(dv.String())
|
|
}
|
|
case "quality":
|
|
firstItemMeta.Quality = cloneTrimmedString(dv.String())
|
|
case "background":
|
|
firstItemMeta.Background = cloneTrimmedString(dv.String())
|
|
case "output_format":
|
|
firstItemMeta.OutputFormat = cloneTrimmedString(dv.String())
|
|
case "mime_type", "mimeType":
|
|
if firstItemMeta.MimeType == "" {
|
|
firstItemMeta.MimeType = cloneTrimmedString(dv.String())
|
|
}
|
|
case "input_fidelity":
|
|
firstItemMeta.InputFidelity = cloneTrimmedString(dv.String())
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
}
|
|
case "size":
|
|
if val.Type == ojson.String {
|
|
imgDetails.Size = cloneTrimmedString(val.String())
|
|
}
|
|
case "resolution":
|
|
if val.Type == ojson.String {
|
|
imgDetails.Resolution = cloneTrimmedString(val.String())
|
|
}
|
|
case "image_size", "imageSize":
|
|
if val.Type == ojson.String && imgDetails.ImageSize == "" {
|
|
imgDetails.ImageSize = cloneTrimmedString(val.String())
|
|
}
|
|
case "aspect_ratio", "aspectRatio":
|
|
if val.Type == ojson.String && imgDetails.AspectRatio == "" {
|
|
imgDetails.AspectRatio = cloneTrimmedString(val.String())
|
|
}
|
|
case "quality":
|
|
if val.Type == ojson.String {
|
|
imgDetails.Quality = cloneTrimmedString(val.String())
|
|
}
|
|
case "background":
|
|
if val.Type == ojson.String {
|
|
imgDetails.Background = cloneTrimmedString(val.String())
|
|
}
|
|
case "output_format":
|
|
if val.Type == ojson.String {
|
|
imgDetails.OutputFormat = cloneTrimmedString(val.String())
|
|
}
|
|
case "mime_type", "mimeType":
|
|
if val.Type == ojson.String && imgDetails.MimeType == "" {
|
|
imgDetails.MimeType = cloneTrimmedString(val.String())
|
|
}
|
|
case "input_fidelity":
|
|
if val.Type == ojson.String {
|
|
imgDetails.InputFidelity = cloneTrimmedString(val.String())
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
if usageNode.Exists() {
|
|
if hasOpenAIStyleUsageTokenFields(usageNode) {
|
|
detail = parseOpenAIStyleUsageNode(usageNode)
|
|
} else {
|
|
populateOpenAIStyleStructuredFields(&detail, usageNode)
|
|
}
|
|
detail.RequestedImageDetails = ParseRequestImageDetails(requestPayload, contentType...)
|
|
}
|
|
if serviceTier != "" {
|
|
detail.ResponseServiceTier = serviceTier
|
|
if detail.UpstreamServiceTier == "" {
|
|
detail.UpstreamServiceTier = serviceTier
|
|
}
|
|
}
|
|
if imageCount > 0 {
|
|
detail.ImageCount = usage.Int64Ptr(imageCount)
|
|
}
|
|
if imgDetails.Size == "" {
|
|
imgDetails.Size = firstItemMeta.Size
|
|
}
|
|
if imgDetails.Resolution == "" {
|
|
imgDetails.Resolution = firstItemMeta.Resolution
|
|
}
|
|
if imgDetails.ImageSize == "" {
|
|
imgDetails.ImageSize = firstItemMeta.ImageSize
|
|
}
|
|
if imgDetails.AspectRatio == "" {
|
|
imgDetails.AspectRatio = firstItemMeta.AspectRatio
|
|
}
|
|
if imgDetails.Quality == "" {
|
|
imgDetails.Quality = firstItemMeta.Quality
|
|
}
|
|
if imgDetails.Background == "" {
|
|
imgDetails.Background = firstItemMeta.Background
|
|
}
|
|
if imgDetails.OutputFormat == "" {
|
|
imgDetails.OutputFormat = firstItemMeta.OutputFormat
|
|
}
|
|
if imgDetails.MimeType == "" {
|
|
imgDetails.MimeType = firstItemMeta.MimeType
|
|
}
|
|
if imgDetails.InputFidelity == "" {
|
|
imgDetails.InputFidelity = firstItemMeta.InputFidelity
|
|
}
|
|
if !isEmptyImageDetails(&imgDetails) {
|
|
detail.ImageDetails = &imgDetails
|
|
}
|
|
return detail
|
|
}
|
|
|
|
// ParseXAIImageUsage extracts token usage, generated image count, and image parameters
|
|
// from an xAI image generation/edit request and response.
|
|
func ParseXAIImageUsage(requestPayload, responsePayload []byte) usage.Detail {
|
|
return ParseOpenAIImageUsage(requestPayload, responsePayload)
|
|
}
|
|
|
|
// ParseXAIVideoUsage extracts token usage and video parameters from an xAI video response.
|
|
func ParseXAIVideoUsage(requestPayload, responsePayload []byte) usage.Detail {
|
|
detail := ParseOpenAIUsage(responsePayload)
|
|
root := util.ParseGJSONBytesNoCopy(responsePayload)
|
|
reqRoot := util.ParseGJSONBytesNoCopy(requestPayload)
|
|
// Only attach video media attributes when a completed video output or usage is present,
|
|
// not on an initial async job creation response that only returns {"request_id":"..."}.
|
|
hasCompletedVideo := root.Get("usage").Exists() || root.Get("video").Exists() || root.Get("data").Exists() || root.Get("url").Exists() || strings.EqualFold(strings.TrimSpace(root.Get("status").String()), "completed")
|
|
if !hasCompletedVideo {
|
|
return detail
|
|
}
|
|
pickRespString := func(paths ...string) string {
|
|
for _, p := range paths {
|
|
if v := root.Get(p); v.Type == ojson.String {
|
|
if s := cloneTrimmedString(v.String()); s != "" {
|
|
return s
|
|
}
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
imgDetails := &usage.ImageDetails{
|
|
Resolution: pickRespString("resolution", "video.resolution", "data.0.resolution"),
|
|
AspectRatio: pickRespString("aspect_ratio", "video.aspect_ratio", "data.0.aspect_ratio"),
|
|
}
|
|
if !isEmptyImageDetails(imgDetails) {
|
|
detail.ImageDetails = imgDetails
|
|
}
|
|
detail.RequestedImageDetails = ParseRequestImageDetails(requestPayload)
|
|
if dur := firstExistingUsageNode(root, "duration", "video.duration"); dur.Type == ojson.Number && dur.Float() > 0 {
|
|
detail.MediaCounts = &usage.MediaCounts{
|
|
CompletionMedia: usage.Int64Ptr(1),
|
|
AudioSeconds: usage.Float64Ptr(dur.Float()),
|
|
}
|
|
} else if dur := reqRoot.Get("duration"); dur.Type == ojson.Number && dur.Float() > 0 {
|
|
detail.MediaCounts = &usage.MediaCounts{
|
|
CompletionMedia: usage.Int64Ptr(1),
|
|
AudioSeconds: usage.Float64Ptr(dur.Float()),
|
|
}
|
|
}
|
|
return detail
|
|
}
|
|
|
|
func parseOpenAIToolUsageDetailsNode(node ojson.Result) *usage.ToolUsageDetails {
|
|
if !node.Exists() || !node.IsObject() {
|
|
return nil
|
|
}
|
|
out := &usage.ToolUsageDetails{}
|
|
hasAny := false
|
|
node.ForEach(func(key, value ojson.Result) bool {
|
|
if value.Type != ojson.Number {
|
|
return true
|
|
}
|
|
k := strings.TrimSpace(key.String())
|
|
if k == "" {
|
|
return true
|
|
}
|
|
v := value.Int()
|
|
switch k {
|
|
case "web_search_calls", "web_search_requests", "SERVER_SIDE_TOOL_WEB_SEARCH":
|
|
out.WebSearchCalls = usage.Int64Ptr(v)
|
|
case "web_search_queries":
|
|
out.WebSearchQueries = usage.Int64Ptr(v)
|
|
case "web_fetch_calls", "web_fetch_requests":
|
|
out.WebFetchCalls = usage.Int64Ptr(v)
|
|
case "num_search_results":
|
|
out.NumSearchResults = usage.Int64Ptr(v)
|
|
case "num_sources_used":
|
|
out.NumSourcesUsed = usage.Int64Ptr(v)
|
|
case "num_server_side_tools_used":
|
|
out.NumServerSideToolsUsed = usage.Int64Ptr(v)
|
|
case "tool_calls_requested":
|
|
out.ToolCallsRequested = usage.Int64Ptr(v)
|
|
case "tool_calls_executed":
|
|
out.ToolCallsExecuted = usage.Int64Ptr(v)
|
|
case "x_search_calls", "x_search_requests", "SERVER_SIDE_TOOL_X_SEARCH":
|
|
out.XSearchCalls = usage.Int64Ptr(v)
|
|
case "x_posts_fetched":
|
|
out.XPostsFetched = usage.Int64Ptr(v)
|
|
case "x_users_fetched":
|
|
out.XUsersFetched = usage.Int64Ptr(v)
|
|
case "code_interpreter_calls", "code_execution_calls", "code_execution_requests", "SERVER_SIDE_TOOL_CODE_EXECUTION":
|
|
out.CodeExecutionCalls = usage.Int64Ptr(v)
|
|
case "file_search_calls", "file_search_requests", "SERVER_SIDE_TOOL_COLLECTIONS_SEARCH":
|
|
out.FileSearchCalls = usage.Int64Ptr(v)
|
|
case "mcp_calls", "mcp_requests", "SERVER_SIDE_TOOL_MCP":
|
|
out.MCPCalls = usage.Int64Ptr(v)
|
|
case "document_search_calls", "document_search_requests", "attachment_search_calls", "attachment_search_requests", "SERVER_SIDE_TOOL_ATTACHMENT_SEARCH", "SERVER_SIDE_TOOL_DOCUMENT_SEARCH":
|
|
out.DocumentSearchCalls = usage.Int64Ptr(v)
|
|
case "image_generation_calls", "image_generation_requests":
|
|
out.ImageGenerationCalls = usage.Int64Ptr(v)
|
|
default:
|
|
if out.Extra == nil {
|
|
out.Extra = make(map[string]int64)
|
|
}
|
|
out.Extra[strings.Clone(k)] = v
|
|
}
|
|
hasAny = true
|
|
return true
|
|
})
|
|
if !hasAny {
|
|
return nil
|
|
}
|
|
return out
|
|
}
|
|
|
|
func ParseOpenAIStreamUsage(line []byte) (usage.Detail, bool) {
|
|
payload := jsonPayload(line)
|
|
if len(payload) == 0 || !ojson.ValidBytes(payload) {
|
|
return usage.Detail{}, false
|
|
}
|
|
root := util.ParseGJSONBytesNoCopy(payload)
|
|
detail, ok := parseOpenAIStyleUsageWithCache(root, root.Get("usage"))
|
|
detail.ResponseServiceTier = extractResponseServiceTierFromValidJSON(payload)
|
|
if detail.UpstreamServiceTier == "" {
|
|
detail.UpstreamServiceTier = detail.ResponseServiceTier
|
|
}
|
|
return detail, ok || detail.ResponseServiceTier != ""
|
|
}
|
|
|
|
func ParseClaudeUsage(data []byte) usage.Detail {
|
|
root := util.ParseGJSONBytesNoCopy(data)
|
|
usageNode := root.Get("usage")
|
|
if !usageNode.Exists() {
|
|
return usage.Detail{}
|
|
}
|
|
detail := parseClaudeUsageNode(usageNode)
|
|
applyClaudeContentBlocksUsage(&detail, root.Get("content"))
|
|
return detail
|
|
}
|
|
|
|
func ParseClaudeStreamUsage(line []byte) (usage.Detail, bool) {
|
|
payload := jsonPayload(line)
|
|
if len(payload) == 0 || !bytes.Contains(payload, openAIStreamUsageMarker) || !ojson.ValidBytes(payload) {
|
|
return usage.Detail{}, false
|
|
}
|
|
root := util.ParseGJSONBytesNoCopy(payload)
|
|
usageNode := root.Get("usage")
|
|
if !usageNode.Exists() {
|
|
usageNode = root.Get("message.usage")
|
|
}
|
|
if !usageNode.Exists() {
|
|
return usage.Detail{}, false
|
|
}
|
|
return parseClaudeUsageNode(usageNode), true
|
|
}
|
|
|
|
func parseClaudeUsageNode(usageNode ojson.Result) usage.Detail {
|
|
cacheReadTokens := usageNode.Get("cache_read_input_tokens").Int()
|
|
cacheCreationTokens := usageNode.Get("cache_creation_input_tokens").Int()
|
|
rawOutputTokens := usageNode.Get("output_tokens").Int()
|
|
// Anthropic reports thinking as a subset of output_tokens. Prefer the official
|
|
// nested field, then fall back to legacy aliases used by some gateways.
|
|
reasoningNode := firstExistingUsageNode(
|
|
usageNode,
|
|
"output_tokens_details.thinking_tokens",
|
|
"output_tokens_details.reasoning_tokens",
|
|
"thinking_tokens",
|
|
)
|
|
reasoningTokens := reasoningNode.Int()
|
|
if reasoningTokens < 0 {
|
|
reasoningTokens = 0
|
|
}
|
|
nonReasoningOutput := rawOutputTokens
|
|
if reasoningTokens > 0 && reasoningTokens <= rawOutputTokens {
|
|
nonReasoningOutput = rawOutputTokens - reasoningTokens
|
|
} else if reasoningTokens > rawOutputTokens {
|
|
// Keep Detail.OutputTokens authoritative for keeper subset checks and
|
|
// avoid inventing extra non-reasoning output when the upstream payload
|
|
// is inconsistent.
|
|
nonReasoningOutput = 0
|
|
}
|
|
detail := usage.Detail{
|
|
InputTokens: usageNode.Get("input_tokens").Int(),
|
|
OutputTokens: rawOutputTokens,
|
|
ReasoningTokens: reasoningTokens,
|
|
CachedTokens: cacheReadTokens,
|
|
CacheReadTokens: cacheReadTokens,
|
|
CacheCreationTokens: cacheCreationTokens,
|
|
}
|
|
// Anthropic reports the speed a response was served and billed at in
|
|
// usage.speed ("fast" or "standard"): fast mode costs more, and a
|
|
// fast request on a model without it runs, and is billed, at standard.
|
|
// Carried as the response tier so usage sinks can price it.
|
|
if speed := cloneTrimmedString(usageNode.Get("speed").String()); speed != "" {
|
|
detail.ResponseServiceTier = speed
|
|
}
|
|
if detail.CachedTokens == 0 {
|
|
detail.CachedTokens = detail.CacheCreationTokens
|
|
}
|
|
// raw output_tokens already includes thinking; cache fields are independent
|
|
// from input_tokens in the Messages API.
|
|
detail.TotalTokens = detail.InputTokens + rawOutputTokens + detail.CacheReadTokens + detail.CacheCreationTokens
|
|
detail.TokenBreakdown = usage.NewIndependentTokenBreakdown(
|
|
detail.InputTokens,
|
|
detail.CacheReadTokens,
|
|
detail.CacheCreationTokens,
|
|
nonReasoningOutput,
|
|
detail.ReasoningTokens,
|
|
detail.TotalTokens,
|
|
)
|
|
populateClaudeUsageStructuredFields(&detail, usageNode)
|
|
return detail
|
|
}
|
|
|
|
func populateClaudeUsageStructuredFields(detail *usage.Detail, usageNode ojson.Result) {
|
|
if detail == nil || !usageNode.Exists() || !usageNode.IsObject() {
|
|
return
|
|
}
|
|
if v := usageNode.Get("service_tier"); v.Type == ojson.String {
|
|
detail.UpstreamServiceTier = cloneTrimmedString(v.String())
|
|
}
|
|
if v := usageNode.Get("speed"); v.Type == ojson.String {
|
|
detail.Speed = cloneTrimmedString(v.String())
|
|
}
|
|
if v := usageNode.Get("inference_geo"); v.Type == ojson.String {
|
|
detail.InferenceGeo = cloneTrimmedString(v.String())
|
|
}
|
|
iterations := parseClaudeIterationsNode(usageNode.Get("iterations"))
|
|
detail.Iterations = usage.IterationsPtr(iterations)
|
|
cacheDetails := parseClaudeCacheCreationNode(usageNode.Get("cache_creation"))
|
|
if cacheDetails == nil && len(iterations) > 0 &&
|
|
(usageNode.Get("cache_creation_input_tokens").Type == ojson.Number || detail.CacheCreationTokens > 0) {
|
|
cacheDetails = deriveClaudeCacheCreationFromIterations(iterations, detail.CacheCreationTokens)
|
|
}
|
|
applyCacheDetailsToUsageDetail(detail, cacheDetails)
|
|
detail.ToolUsageDetails = parseClaudeServerToolUseNode(usageNode.Get("server_tool_use"))
|
|
if detail.ToolUsageDetails != nil && detail.ToolUsageDetails.WebSearchCalls != nil {
|
|
detail.WebSearchRequests = usage.CloneInt64Ptr(detail.ToolUsageDetails.WebSearchCalls)
|
|
}
|
|
detail.CostDetails = parseClaudeCostNode(usageNode)
|
|
}
|
|
|
|
func applyClaudeContentBlocksUsage(detail *usage.Detail, contentNode ojson.Result) {
|
|
if detail == nil || !contentNode.Exists() || !contentNode.IsArray() {
|
|
return
|
|
}
|
|
seenToolUseIDs := make(map[string]struct{})
|
|
seenToolResultIDs := make(map[string]struct{})
|
|
var (
|
|
webSearchQueries int64
|
|
completedSearches int64
|
|
searchResults int64
|
|
hasCompleted bool
|
|
)
|
|
for _, block := range contentNode.Array() {
|
|
if !block.IsObject() {
|
|
continue
|
|
}
|
|
switch block.Get("type").String() {
|
|
case "server_tool_use":
|
|
if strings.TrimSpace(block.Get("name").String()) != "web_search" {
|
|
continue
|
|
}
|
|
if id := strings.TrimSpace(block.Get("id").String()); id != "" {
|
|
if _, ok := seenToolUseIDs[id]; ok {
|
|
continue
|
|
}
|
|
seenToolUseIDs[id] = struct{}{}
|
|
}
|
|
webSearchQueries++
|
|
case "web_search_tool_result":
|
|
content := block.Get("content")
|
|
if !content.Exists() || !content.IsArray() {
|
|
continue
|
|
}
|
|
if id := strings.TrimSpace(block.Get("tool_use_id").String()); id != "" {
|
|
if _, ok := seenToolResultIDs[id]; ok {
|
|
continue
|
|
}
|
|
seenToolResultIDs[id] = struct{}{}
|
|
}
|
|
hasCompleted = true
|
|
completedSearches++
|
|
for _, item := range content.Array() {
|
|
if item.Get("type").String() == "web_search_result" {
|
|
searchResults++
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if webSearchQueries == 0 && !hasCompleted {
|
|
return
|
|
}
|
|
if detail.ToolUsageDetails == nil {
|
|
detail.ToolUsageDetails = &usage.ToolUsageDetails{}
|
|
}
|
|
if webSearchQueries > 0 {
|
|
detail.ToolUsageDetails.WebSearchQueries = usage.Int64Ptr(webSearchQueries)
|
|
}
|
|
if hasCompleted {
|
|
detail.ToolUsageDetails.NumSearchResults = usage.Int64Ptr(searchResults)
|
|
if detail.ToolUsageDetails.WebSearchCalls == nil || (completedSearches > 0 && *detail.ToolUsageDetails.WebSearchCalls == 0) {
|
|
detail.ToolUsageDetails.WebSearchCalls = usage.Int64Ptr(completedSearches)
|
|
}
|
|
if detail.WebSearchRequests == nil || (completedSearches > 0 && *detail.WebSearchRequests == 0) {
|
|
detail.WebSearchRequests = usage.Int64Ptr(completedSearches)
|
|
}
|
|
}
|
|
}
|
|
|
|
func applyCacheDetailsToUsageDetail(detail *usage.Detail, cacheDetails *usage.CacheDetails) {
|
|
if detail == nil {
|
|
return
|
|
}
|
|
detail.CacheDetails = cacheDetails.Clone()
|
|
if cacheDetails == nil {
|
|
detail.CacheCreation5mTokens = nil
|
|
detail.CacheCreation30mTokens = nil
|
|
detail.CacheCreation1hTokens = nil
|
|
detail.CacheCreation12hTokens = nil
|
|
return
|
|
}
|
|
detail.CacheCreation5mTokens = usage.CloneInt64Ptr(cacheDetails.Ephemeral5mInputTokens)
|
|
detail.CacheCreation30mTokens = usage.CloneInt64Ptr(cacheDetails.Ephemeral30mInputTokens)
|
|
detail.CacheCreation1hTokens = usage.CloneInt64Ptr(cacheDetails.Ephemeral1hInputTokens)
|
|
detail.CacheCreation12hTokens = usage.CloneInt64Ptr(cacheDetails.Ephemeral12hInputTokens)
|
|
}
|
|
|
|
func parseClaudeCacheCreationNode(node ojson.Result) *usage.CacheDetails {
|
|
if !node.Exists() || !node.IsObject() {
|
|
return nil
|
|
}
|
|
out := &usage.CacheDetails{}
|
|
hasAny := false
|
|
node.ForEach(func(key, value ojson.Result) bool {
|
|
k := strings.TrimSpace(key.String())
|
|
switch k {
|
|
case "ttl":
|
|
if value.Type == ojson.String {
|
|
out.TTL = cloneTrimmedString(value.String())
|
|
hasAny = out.TTL != "" || hasAny
|
|
}
|
|
return true
|
|
case "mode":
|
|
if value.Type == ojson.String {
|
|
out.Mode = cloneTrimmedString(value.String())
|
|
hasAny = out.Mode != "" || hasAny
|
|
}
|
|
return true
|
|
case "retention":
|
|
if value.Type == ojson.String {
|
|
out.Retention = cloneTrimmedString(value.String())
|
|
hasAny = out.Retention != "" || hasAny
|
|
}
|
|
return true
|
|
}
|
|
if value.Type != ojson.Number {
|
|
return true
|
|
}
|
|
v := value.Int()
|
|
if v < 0 {
|
|
return true
|
|
}
|
|
ttlKey := ""
|
|
switch {
|
|
case k == "ephemeral_5m_input_tokens" || k == "5m":
|
|
out.Ephemeral5mInputTokens = usage.Int64Ptr(v)
|
|
ttlKey = "5m"
|
|
case k == "ephemeral_30m_input_tokens" || k == "30m":
|
|
out.Ephemeral30mInputTokens = usage.Int64Ptr(v)
|
|
ttlKey = "30m"
|
|
case k == "ephemeral_1h_input_tokens" || k == "1h":
|
|
out.Ephemeral1hInputTokens = usage.Int64Ptr(v)
|
|
ttlKey = "1h"
|
|
case k == "ephemeral_12h_input_tokens" || k == "12h":
|
|
out.Ephemeral12hInputTokens = usage.Int64Ptr(v)
|
|
ttlKey = "12h"
|
|
case strings.HasPrefix(k, "ephemeral_") && strings.HasSuffix(k, "_input_tokens"):
|
|
ttlKey = strings.TrimSuffix(strings.TrimPrefix(k, "ephemeral_"), "_input_tokens")
|
|
}
|
|
if ttlKey != "" {
|
|
if out.ByTTL == nil {
|
|
out.ByTTL = make(map[string]int64)
|
|
}
|
|
out.ByTTL[strings.Clone(ttlKey)] = v
|
|
hasAny = true
|
|
}
|
|
return true
|
|
})
|
|
if !hasAny {
|
|
return nil
|
|
}
|
|
return out
|
|
}
|
|
|
|
func parseClaudeServerToolUseNode(node ojson.Result) *usage.ToolUsageDetails {
|
|
if !node.Exists() || !node.IsObject() {
|
|
return nil
|
|
}
|
|
out := &usage.ToolUsageDetails{}
|
|
hasAny := false
|
|
node.ForEach(func(key, value ojson.Result) bool {
|
|
if value.Type != ojson.Number {
|
|
return true
|
|
}
|
|
k := strings.TrimSpace(key.String())
|
|
if k == "" {
|
|
return true
|
|
}
|
|
v := value.Int()
|
|
switch k {
|
|
case "web_search_requests", "web_search_calls":
|
|
out.WebSearchCalls = usage.Int64Ptr(v)
|
|
case "web_fetch_requests", "web_fetch_calls":
|
|
out.WebFetchCalls = usage.Int64Ptr(v)
|
|
case "code_execution_requests", "code_execution_calls", "code_interpreter_calls":
|
|
out.CodeExecutionCalls = usage.Int64Ptr(v)
|
|
case "tool_calls_requested":
|
|
out.ToolCallsRequested = usage.Int64Ptr(v)
|
|
case "tool_calls_executed":
|
|
out.ToolCallsExecuted = usage.Int64Ptr(v)
|
|
case "file_search_requests", "file_search_calls":
|
|
out.FileSearchCalls = usage.Int64Ptr(v)
|
|
case "mcp_requests", "mcp_calls":
|
|
out.MCPCalls = usage.Int64Ptr(v)
|
|
default:
|
|
if out.Extra == nil {
|
|
out.Extra = make(map[string]int64)
|
|
}
|
|
out.Extra[strings.Clone(k)] = v
|
|
}
|
|
hasAny = true
|
|
return true
|
|
})
|
|
if !hasAny {
|
|
return nil
|
|
}
|
|
return out
|
|
}
|
|
|
|
func parseClaudeIterationsNode(node ojson.Result) []usage.IterationUsage {
|
|
if !node.Exists() || !node.IsArray() {
|
|
return nil
|
|
}
|
|
items := node.Array()
|
|
if len(items) == 0 {
|
|
return nil
|
|
}
|
|
out := make([]usage.IterationUsage, 0, len(items))
|
|
for _, item := range items {
|
|
if !item.IsObject() {
|
|
continue
|
|
}
|
|
it := usage.IterationUsage{}
|
|
if v := item.Get("type"); v.Type == ojson.String {
|
|
it.Type = cloneTrimmedString(v.String())
|
|
}
|
|
if v := item.Get("model"); v.Type == ojson.String {
|
|
it.Model = cloneTrimmedString(v.String())
|
|
}
|
|
if v := item.Get("input_tokens"); v.Type == ojson.Number {
|
|
it.InputTokens = usage.Int64Ptr(v.Int())
|
|
}
|
|
if v := item.Get("output_tokens"); v.Type == ojson.Number {
|
|
it.OutputTokens = usage.Int64Ptr(v.Int())
|
|
}
|
|
if v := firstExistingUsageNode(item, "output_tokens_details.thinking_tokens", "thinking_tokens"); v.Type == ojson.Number {
|
|
val := v.Int()
|
|
if val < 0 {
|
|
val = 0
|
|
}
|
|
it.ThinkingTokens = usage.Int64Ptr(val)
|
|
it.ReasoningTokens = usage.Int64Ptr(val)
|
|
} else if v := item.Get("output_tokens_details.reasoning_tokens"); v.Type == ojson.Number {
|
|
val := v.Int()
|
|
if val < 0 {
|
|
val = 0
|
|
}
|
|
it.ReasoningTokens = usage.Int64Ptr(val)
|
|
}
|
|
if v := item.Get("cache_read_input_tokens"); v.Type == ojson.Number {
|
|
it.CacheReadInputTokens = usage.Int64Ptr(v.Int())
|
|
}
|
|
if v := item.Get("cache_creation_input_tokens"); v.Type == ojson.Number {
|
|
it.CacheCreationInputTokens = usage.Int64Ptr(v.Int())
|
|
}
|
|
it.CacheCreation = parseClaudeCacheCreationNode(item.Get("cache_creation"))
|
|
if it.CacheCreation != nil {
|
|
if it.CacheCreation.Ephemeral5mInputTokens != nil {
|
|
it.CacheCreation5mTokens = usage.Int64Ptr(*it.CacheCreation.Ephemeral5mInputTokens)
|
|
}
|
|
if it.CacheCreation.Ephemeral1hInputTokens != nil {
|
|
it.CacheCreation1hTokens = usage.Int64Ptr(*it.CacheCreation.Ephemeral1hInputTokens)
|
|
}
|
|
}
|
|
out = append(out, it)
|
|
}
|
|
if len(out) == 0 {
|
|
return nil
|
|
}
|
|
return out
|
|
}
|
|
|
|
func deriveClaudeCacheCreationFromIterations(iterations []usage.IterationUsage, totalCacheCreation int64) *usage.CacheDetails {
|
|
if len(iterations) == 0 || totalCacheCreation < 0 {
|
|
return nil
|
|
}
|
|
byTTL := make(map[string]int64)
|
|
var has5m, has30m, has1h, has12h bool
|
|
for _, it := range iterations {
|
|
if it.Type != "" && it.Type != "message" {
|
|
continue
|
|
}
|
|
if it.CacheCreation == nil {
|
|
if it.CacheCreationInputTokens != nil && *it.CacheCreationInputTokens > 0 {
|
|
return nil
|
|
}
|
|
continue
|
|
}
|
|
if it.CacheCreation.Ephemeral5mInputTokens != nil {
|
|
has5m = true
|
|
}
|
|
if it.CacheCreation.Ephemeral30mInputTokens != nil {
|
|
has30m = true
|
|
}
|
|
if it.CacheCreation.Ephemeral1hInputTokens != nil {
|
|
has1h = true
|
|
}
|
|
if it.CacheCreation.Ephemeral12hInputTokens != nil {
|
|
has12h = true
|
|
}
|
|
for ttl, tokens := range it.CacheCreation.ByTTL {
|
|
sum, ok := safeUsageTokenSum(byTTL[ttl], tokens)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
byTTL[ttl] = sum
|
|
}
|
|
}
|
|
if len(byTTL) == 0 {
|
|
return nil
|
|
}
|
|
out := &usage.CacheDetails{ByTTL: byTTL}
|
|
sum, ok := out.SumTokens()
|
|
if !ok || sum != totalCacheCreation {
|
|
return nil
|
|
}
|
|
if has5m {
|
|
out.Ephemeral5mInputTokens = usage.Int64Ptr(byTTL["5m"])
|
|
}
|
|
if has30m {
|
|
out.Ephemeral30mInputTokens = usage.Int64Ptr(byTTL["30m"])
|
|
}
|
|
if has1h {
|
|
out.Ephemeral1hInputTokens = usage.Int64Ptr(byTTL["1h"])
|
|
}
|
|
if has12h {
|
|
out.Ephemeral12hInputTokens = usage.Int64Ptr(byTTL["12h"])
|
|
}
|
|
return out
|
|
}
|
|
|
|
func parseClaudeCostNode(usageNode ojson.Result) *usage.CostDetails {
|
|
costNode := usageNode.Get("cost")
|
|
byokNode := usageNode.Get("is_byok")
|
|
detailsNode := usageNode.Get("cost_details")
|
|
out := &usage.CostDetails{}
|
|
hasAny := false
|
|
if costNode.Type == ojson.Number {
|
|
out.Cost = usage.Float64Ptr(costNode.Float())
|
|
hasAny = true
|
|
}
|
|
if ticksNode := usageNode.Get("cost_in_usd_ticks"); ticksNode.Type == ojson.Number {
|
|
out.CostInUSDTicks = usage.Int64Ptr(ticksNode.Int())
|
|
hasAny = true
|
|
}
|
|
if byokNode.Type == ojson.True || byokNode.Type == ojson.False {
|
|
out.IsBYOK = usage.BoolPtr(byokNode.Bool())
|
|
hasAny = true
|
|
}
|
|
if detailsNode.Exists() && detailsNode.IsObject() {
|
|
if v := detailsNode.Get("upstream_inference_cost"); v.Type == ojson.Number {
|
|
out.UpstreamInferenceCost = usage.Float64Ptr(v.Float())
|
|
hasAny = true
|
|
}
|
|
if v := detailsNode.Get("upstream_inference_prompt_cost"); v.Type == ojson.Number {
|
|
out.UpstreamInferencePromptCost = usage.Float64Ptr(v.Float())
|
|
hasAny = true
|
|
}
|
|
if v := detailsNode.Get("upstream_inference_completions_cost"); v.Type == ojson.Number {
|
|
out.UpstreamInferenceCompletionsCost = usage.Float64Ptr(v.Float())
|
|
hasAny = true
|
|
}
|
|
}
|
|
if !hasAny {
|
|
return nil
|
|
}
|
|
return out
|
|
}
|
|
|
|
func parseGeminiFamilyUsageDetail(node ojson.Result) usage.Detail {
|
|
if !node.Exists() || !node.IsObject() {
|
|
return usage.Detail{}
|
|
}
|
|
var (
|
|
promptTokens int64
|
|
toolUseTokens int64
|
|
candidatesTokens int64
|
|
thoughtsTokens int64
|
|
totalTokens int64
|
|
cachedTokens int64
|
|
serviceTier string
|
|
trafficType string
|
|
promptDetails ojson.Result
|
|
toolUseDetails ojson.Result
|
|
cacheDetails ojson.Result
|
|
candDetails ojson.Result
|
|
)
|
|
node.ForEach(func(key, val ojson.Result) bool {
|
|
switch key.String() {
|
|
case "promptTokenCount", "prompt_token_count":
|
|
if promptTokens == 0 {
|
|
promptTokens = val.Int()
|
|
}
|
|
case "toolUsePromptTokenCount", "tool_use_prompt_token_count":
|
|
if toolUseTokens == 0 {
|
|
toolUseTokens = val.Int()
|
|
}
|
|
case "candidatesTokenCount", "candidates_token_count":
|
|
if candidatesTokens == 0 {
|
|
candidatesTokens = val.Int()
|
|
}
|
|
case "thoughtsTokenCount", "thoughts_token_count":
|
|
if thoughtsTokens == 0 {
|
|
thoughtsTokens = val.Int()
|
|
}
|
|
case "totalTokenCount", "total_token_count":
|
|
if totalTokens == 0 {
|
|
totalTokens = val.Int()
|
|
}
|
|
case "cachedContentTokenCount", "cached_content_token_count":
|
|
if cachedTokens == 0 {
|
|
cachedTokens = val.Int()
|
|
}
|
|
case "serviceTier", "service_tier":
|
|
if serviceTier == "" && val.Type == ojson.String {
|
|
serviceTier = cloneTrimmedString(val.String())
|
|
}
|
|
case "trafficType", "traffic_type":
|
|
if trafficType == "" && val.Type == ojson.String {
|
|
trafficType = cloneTrimmedString(val.String())
|
|
}
|
|
case "promptTokensDetails", "prompt_tokens_details":
|
|
if !promptDetails.Exists() {
|
|
promptDetails = val
|
|
}
|
|
case "toolUsePromptTokensDetails", "tool_use_prompt_tokens_details":
|
|
if !toolUseDetails.Exists() {
|
|
toolUseDetails = val
|
|
}
|
|
case "cacheTokensDetails", "cache_tokens_details":
|
|
if !cacheDetails.Exists() {
|
|
cacheDetails = val
|
|
}
|
|
case "candidatesTokensDetails", "candidates_tokens_details":
|
|
if !candDetails.Exists() {
|
|
candDetails = val
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
inputTokens, okInput := safeUsageTokenSum(promptTokens, toolUseTokens)
|
|
detail := usage.Detail{
|
|
InputTokens: inputTokens,
|
|
OutputTokens: candidatesTokens,
|
|
ReasoningTokens: thoughtsTokens,
|
|
TotalTokens: totalTokens,
|
|
CachedTokens: cachedTokens,
|
|
CacheReadTokens: cachedTokens,
|
|
}
|
|
if !okInput {
|
|
detail.TokenBreakdown = invalidUsageTokenBreakdown(detail.TotalTokens)
|
|
return detail
|
|
}
|
|
if detail.TotalTokens == 0 {
|
|
var okTotal bool
|
|
detail.TotalTokens, okTotal = safeUsageTokenSum(detail.InputTokens, detail.OutputTokens, detail.ReasoningTokens)
|
|
if !okTotal {
|
|
detail.TotalTokens = 0
|
|
detail.TokenBreakdown = invalidUsageTokenBreakdown(0)
|
|
return detail
|
|
}
|
|
}
|
|
detail.TokenBreakdown = usage.NewSeparateReasoningTokenBreakdown(
|
|
detail.InputTokens,
|
|
detail.CacheReadTokens,
|
|
detail.CacheCreationTokens,
|
|
detail.OutputTokens,
|
|
detail.ReasoningTokens,
|
|
detail.TotalTokens,
|
|
)
|
|
if serviceTier != "" {
|
|
detail.ResponseServiceTier = serviceTier
|
|
if detail.UpstreamServiceTier == "" {
|
|
detail.UpstreamServiceTier = serviceTier
|
|
}
|
|
}
|
|
if trafficType != "" {
|
|
detail.UpstreamServiceTier = trafficType
|
|
if detail.ResponseServiceTier == "" {
|
|
detail.ResponseServiceTier = trafficType
|
|
}
|
|
}
|
|
if toolUseTokens > 0 {
|
|
detail.ToolUsageDetails = &usage.ToolUsageDetails{
|
|
Extra: map[string]int64{"tool_use_prompt_tokens": toolUseTokens},
|
|
}
|
|
}
|
|
parseModalityList := func(arr ojson.Result, target func(modality string, count int64)) {
|
|
if !arr.Exists() || !arr.IsArray() {
|
|
return
|
|
}
|
|
arr.ForEach(func(_, entry ojson.Result) bool {
|
|
mod := strings.ToUpper(strings.TrimSpace(entry.Get("modality").String()))
|
|
if mod == "" {
|
|
return true
|
|
}
|
|
cntNode := entry.Get("tokenCount")
|
|
if !cntNode.Exists() {
|
|
cntNode = entry.Get("token_count")
|
|
}
|
|
if cntNode.Type == ojson.Number {
|
|
target(mod, cntNode.Int())
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
if promptDetails.Exists() || toolUseDetails.Exists() {
|
|
var textIn, imgIn, audioIn, videoIn, docIn int64
|
|
var hasTextIn, hasImgIn, hasAudioIn, hasVideoIn, hasDocIn bool
|
|
addInputModality := func(mod string, cnt int64) {
|
|
switch mod {
|
|
case "TEXT":
|
|
textIn += cnt
|
|
hasTextIn = true
|
|
case "IMAGE":
|
|
imgIn += cnt
|
|
hasImgIn = true
|
|
case "AUDIO":
|
|
audioIn += cnt
|
|
hasAudioIn = true
|
|
case "VIDEO":
|
|
videoIn += cnt
|
|
hasVideoIn = true
|
|
case "DOCUMENT":
|
|
docIn += cnt
|
|
hasDocIn = true
|
|
}
|
|
}
|
|
parseModalityList(promptDetails, addInputModality)
|
|
parseModalityList(toolUseDetails, addInputModality)
|
|
if hasTextIn {
|
|
detail.TextInputTokens = usage.Int64Ptr(textIn)
|
|
}
|
|
if hasImgIn {
|
|
detail.ImageInputTokens = usage.Int64Ptr(imgIn)
|
|
}
|
|
if hasAudioIn {
|
|
detail.AudioInputTokens = usage.Int64Ptr(audioIn)
|
|
}
|
|
if hasVideoIn {
|
|
detail.VideoInputTokens = usage.Int64Ptr(videoIn)
|
|
}
|
|
if hasDocIn {
|
|
detail.FileInputTokens = usage.Int64Ptr(docIn)
|
|
}
|
|
}
|
|
if cacheDetails.Exists() {
|
|
var cachedText, cachedImg, cachedAudio int64
|
|
var hasCachedText, hasCachedImg, hasCachedAudio bool
|
|
parseModalityList(cacheDetails, func(mod string, cnt int64) {
|
|
switch mod {
|
|
case "TEXT":
|
|
cachedText += cnt
|
|
hasCachedText = true
|
|
case "IMAGE":
|
|
cachedImg += cnt
|
|
hasCachedImg = true
|
|
case "AUDIO":
|
|
cachedAudio += cnt
|
|
hasCachedAudio = true
|
|
}
|
|
})
|
|
if hasCachedText {
|
|
detail.CachedTextTokens = usage.Int64Ptr(cachedText)
|
|
}
|
|
if hasCachedImg {
|
|
detail.CachedImageTokens = usage.Int64Ptr(cachedImg)
|
|
}
|
|
if hasCachedAudio {
|
|
detail.CachedAudioTokens = usage.Int64Ptr(cachedAudio)
|
|
}
|
|
}
|
|
if candDetails.Exists() {
|
|
var textOut, imgOut, audioOut int64
|
|
var hasTextOut, hasImgOut, hasAudioOut bool
|
|
parseModalityList(candDetails, func(mod string, cnt int64) {
|
|
switch mod {
|
|
case "TEXT":
|
|
textOut += cnt
|
|
hasTextOut = true
|
|
case "IMAGE":
|
|
imgOut += cnt
|
|
hasImgOut = true
|
|
case "AUDIO":
|
|
audioOut += cnt
|
|
hasAudioOut = true
|
|
}
|
|
})
|
|
if hasTextOut {
|
|
detail.TextOutputTokens = usage.Int64Ptr(textOut)
|
|
}
|
|
if hasImgOut {
|
|
detail.ImageOutputTokens = usage.Int64Ptr(imgOut)
|
|
}
|
|
if hasAudioOut {
|
|
detail.AudioOutputTokens = usage.Int64Ptr(audioOut)
|
|
}
|
|
}
|
|
return detail
|
|
}
|
|
|
|
func applyGeminiPayloadArtifacts(detail *usage.Detail, root ojson.Result) {
|
|
if detail == nil || !root.Exists() || !root.IsObject() {
|
|
return
|
|
}
|
|
candidates := root.Get("candidates")
|
|
if !candidates.Exists() {
|
|
candidates = root.Get("response.candidates")
|
|
}
|
|
var preds ojson.Result
|
|
if strings.Contains(root.Raw, `"predictions"`) {
|
|
preds = root.Get("predictions")
|
|
}
|
|
applyGeminiNodesArtifacts(detail, candidates, preds)
|
|
}
|
|
|
|
func applyGeminiNodesArtifacts(detail *usage.Detail, candidates, preds ojson.Result) {
|
|
var callCounter geminiFunctionCallCounter
|
|
applyGeminiNodesArtifactsWithCounter(detail, candidates, preds, &callCounter)
|
|
}
|
|
|
|
func applyGeminiNodesArtifactsWithCounter(detail *usage.Detail, candidates, preds ojson.Result, callCounter *geminiFunctionCallCounter) {
|
|
if detail == nil {
|
|
return
|
|
}
|
|
if callCounter == nil {
|
|
callCounter = &geminiFunctionCallCounter{}
|
|
}
|
|
if candidates.Exists() && candidates.IsArray() {
|
|
var (
|
|
webSearchGrounded bool
|
|
webSearchQueries int64
|
|
webChunks int64
|
|
fileChunks int64
|
|
mapsChunks int64
|
|
urlFetchCount int64
|
|
codeExecCount int64
|
|
fnCallCount int64
|
|
imageOutCount int64
|
|
firstImageMime string
|
|
)
|
|
candidates.ForEach(func(candPos, cand ojson.Result) bool {
|
|
if !cand.IsObject() {
|
|
return true
|
|
}
|
|
candIdx := candPos.Int()
|
|
if idxNode := cand.Get("index"); idxNode.Type == ojson.Number {
|
|
candIdx = idxNode.Int()
|
|
}
|
|
cand.ForEach(func(ck, cv ojson.Result) bool {
|
|
switch ck.String() {
|
|
case "groundingMetadata", "grounding_metadata":
|
|
if !cv.IsObject() {
|
|
return true
|
|
}
|
|
cv.ForEach(func(gk, gv ojson.Result) bool {
|
|
switch gk.String() {
|
|
case "webSearchQueries", "web_search_queries":
|
|
if gv.IsArray() {
|
|
gv.ForEach(func(_, qItem ojson.Result) bool {
|
|
if strings.TrimSpace(qItem.String()) != "" {
|
|
webSearchQueries++
|
|
webSearchGrounded = true
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
case "searchEntryPoint", "search_entry_point":
|
|
webSearchGrounded = true
|
|
case "groundingChunks", "grounding_chunks":
|
|
if gv.IsArray() {
|
|
gv.ForEach(func(_, ch ojson.Result) bool {
|
|
switch {
|
|
case ch.Get("web").Exists():
|
|
webChunks++
|
|
webSearchGrounded = true
|
|
case ch.Get("retrievedContext").Exists() || ch.Get("retrieved_context").Exists():
|
|
fileChunks++
|
|
case ch.Get("maps").Exists():
|
|
mapsChunks++
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
case "urlContextMetadata", "url_context_metadata":
|
|
if cv.IsObject() {
|
|
if urls := firstExistingUsageNode(cv, "urlMetadata", "url_metadata"); urls.IsArray() {
|
|
urlFetchCount += int64(len(urls.Array()))
|
|
}
|
|
}
|
|
case "content":
|
|
if parts := cv.Get("parts"); parts.IsArray() {
|
|
parts.ForEach(func(_, part ojson.Result) bool {
|
|
if !part.IsObject() {
|
|
return true
|
|
}
|
|
part.ForEach(func(pk, pv ojson.Result) bool {
|
|
switch pk.String() {
|
|
case "executableCode", "executable_code":
|
|
codeExecCount++
|
|
case "functionCall", "function_call":
|
|
fnCallCount += callCounter.observePart(candIdx, pv)
|
|
case "inlineData", "inline_data":
|
|
if pv.IsObject() {
|
|
mimeNode := pv.Get("mimeType")
|
|
if !mimeNode.Exists() {
|
|
mimeNode = pv.Get("mime_type")
|
|
}
|
|
mimeType := cloneTrimmedString(mimeNode.String())
|
|
if len(mimeType) >= 6 && strings.EqualFold(mimeType[:6], "image/") {
|
|
imageOutCount++
|
|
if firstImageMime == "" {
|
|
firstImageMime = mimeType
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
return true
|
|
})
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
return true
|
|
})
|
|
if webSearchGrounded || webSearchQueries > 0 || webChunks > 0 || fileChunks > 0 || mapsChunks > 0 || urlFetchCount > 0 || codeExecCount > 0 || fnCallCount > 0 {
|
|
if detail.ToolUsageDetails == nil {
|
|
detail.ToolUsageDetails = &usage.ToolUsageDetails{}
|
|
}
|
|
if webSearchGrounded {
|
|
calls := int64(1)
|
|
if webSearchQueries > 1 {
|
|
calls = webSearchQueries
|
|
}
|
|
detail.ToolUsageDetails.WebSearchCalls = usage.Int64Ptr(calls)
|
|
detail.WebSearchRequests = usage.Int64Ptr(calls)
|
|
}
|
|
if webSearchQueries > 0 {
|
|
detail.ToolUsageDetails.WebSearchQueries = usage.Int64Ptr(webSearchQueries)
|
|
}
|
|
if webChunks > 0 {
|
|
detail.ToolUsageDetails.NumSearchResults = usage.Int64Ptr(webChunks)
|
|
detail.ToolUsageDetails.NumSourcesUsed = usage.Int64Ptr(webChunks)
|
|
}
|
|
if fileChunks > 0 {
|
|
detail.ToolUsageDetails.FileSearchCalls = usage.Int64Ptr(fileChunks)
|
|
}
|
|
if urlFetchCount > 0 {
|
|
detail.ToolUsageDetails.WebFetchCalls = usage.Int64Ptr(urlFetchCount)
|
|
}
|
|
if codeExecCount > 0 {
|
|
detail.ToolUsageDetails.CodeExecutionCalls = usage.Int64Ptr(codeExecCount)
|
|
}
|
|
if fnCallCount > 0 {
|
|
detail.ToolUsageDetails.ToolCallsRequested = usage.Int64Ptr(fnCallCount)
|
|
}
|
|
if mapsChunks > 0 {
|
|
if detail.ToolUsageDetails.Extra == nil {
|
|
detail.ToolUsageDetails.Extra = make(map[string]int64)
|
|
}
|
|
detail.ToolUsageDetails.Extra["google_maps_chunks"] = mapsChunks
|
|
}
|
|
}
|
|
if imageOutCount > 0 {
|
|
detail.ImageCount = usage.Int64Ptr(imageOutCount)
|
|
if firstImageMime != "" {
|
|
if detail.ImageDetails == nil {
|
|
detail.ImageDetails = &usage.ImageDetails{}
|
|
}
|
|
detail.ImageDetails.MimeType = firstImageMime
|
|
}
|
|
}
|
|
}
|
|
if preds.Exists() && preds.IsArray() {
|
|
var count int64
|
|
var firstMime string
|
|
preds.ForEach(func(_, pred ojson.Result) bool {
|
|
if !pred.IsObject() {
|
|
return true
|
|
}
|
|
var hasImg bool
|
|
var mime string
|
|
pred.ForEach(func(pk, pv ojson.Result) bool {
|
|
switch pk.String() {
|
|
case "bytesBase64Encoded", "gcsUri":
|
|
if pv.Type == ojson.String && len(pv.Raw) > 2 {
|
|
hasImg = true
|
|
}
|
|
case "mimeType":
|
|
if pv.Type == ojson.String {
|
|
mime = cloneTrimmedString(pv.String())
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
if hasImg {
|
|
count++
|
|
if firstMime == "" {
|
|
firstMime = mime
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
if count > 0 {
|
|
detail.ImageCount = usage.Int64Ptr(count)
|
|
if firstMime != "" {
|
|
if detail.ImageDetails == nil {
|
|
detail.ImageDetails = &usage.ImageDetails{}
|
|
}
|
|
detail.ImageDetails.MimeType = firstMime
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ApplyGeminiRequestImageConfig populates detail.RequestedImageDetails from a Gemini or Vertex
|
|
// request payload without overwriting upstream-returned detail.ImageDetails.
|
|
func ApplyGeminiRequestImageConfig(detail *usage.Detail, requestPayload []byte) {
|
|
if detail == nil || detail.ImageCount == nil || *detail.ImageCount <= 0 {
|
|
return
|
|
}
|
|
detail.RequestedImageDetails = ParseRequestImageDetails(requestPayload)
|
|
}
|
|
|
|
func parseInteractionsUsageDetail(node ojson.Result) usage.Detail {
|
|
cacheRead := firstExistingUsageNode(node, "cache_read_tokens", "cacheReadTokens")
|
|
toolUseTokens := firstExistingUsageNode(node, "tool_use_tokens", "total_tool_use_tokens", "toolUseTokens", "totalToolUseTokens").Int()
|
|
inputTokens, okInput := safeUsageTokenSum(
|
|
firstExistingUsageNode(node, "input_tokens", "prompt_tokens", "total_input_tokens").Int(),
|
|
toolUseTokens,
|
|
)
|
|
detail := usage.Detail{
|
|
InputTokens: inputTokens,
|
|
OutputTokens: firstExistingUsageNode(node, "output_tokens", "completion_tokens", "total_output_tokens").Int(),
|
|
ReasoningTokens: firstExistingUsageNode(node, "reasoning_tokens", "thoughtsTokenCount", "total_thought_tokens").Int(),
|
|
TotalTokens: firstExistingUsageNode(node, "total_tokens", "totalTokenCount").Int(),
|
|
CachedTokens: firstExistingUsageNode(node, "cached_tokens", "cachedContentTokenCount", "total_cached_tokens").Int(),
|
|
CacheReadTokens: cacheRead.Int(),
|
|
CacheCreationTokens: firstExistingUsageNode(node, "cache_creation_tokens", "cacheCreationTokens", "cache_write_tokens", "cacheWriteTokens").Int(),
|
|
}
|
|
if !okInput {
|
|
detail.TokenBreakdown = invalidUsageTokenBreakdown(detail.TotalTokens)
|
|
return detail
|
|
}
|
|
if !cacheRead.Exists() && detail.CachedTokens > 0 {
|
|
detail.CacheReadTokens = detail.CachedTokens
|
|
}
|
|
if detail.TotalTokens == 0 {
|
|
var okTotal bool
|
|
detail.TotalTokens, okTotal = safeUsageTokenSum(detail.InputTokens, detail.OutputTokens, detail.ReasoningTokens)
|
|
if !okTotal {
|
|
detail.TotalTokens = 0
|
|
detail.TokenBreakdown = invalidUsageTokenBreakdown(0)
|
|
return detail
|
|
}
|
|
}
|
|
detail.TokenBreakdown = usage.NewSeparateReasoningTokenBreakdown(
|
|
detail.InputTokens,
|
|
detail.CacheReadTokens,
|
|
detail.CacheCreationTokens,
|
|
detail.OutputTokens,
|
|
detail.ReasoningTokens,
|
|
detail.TotalTokens,
|
|
)
|
|
parseInteractionsModalities := func(arr ojson.Result, target func(mod string, cnt int64)) {
|
|
if !arr.Exists() || !arr.IsArray() {
|
|
return
|
|
}
|
|
arr.ForEach(func(_, entry ojson.Result) bool {
|
|
mod := strings.ToUpper(strings.TrimSpace(entry.Get("modality").String()))
|
|
if mod == "" {
|
|
return true
|
|
}
|
|
cntNode := firstExistingUsageNode(entry, "tokens", "tokenCount", "token_count")
|
|
if cntNode.Type == ojson.Number {
|
|
target(mod, cntNode.Int())
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
if inMod := firstExistingUsageNode(node, "input_tokens_by_modality", "inputTokensByModality"); inMod.Exists() {
|
|
var textIn, imgIn, audioIn, videoIn, docIn int64
|
|
var hasTextIn, hasImgIn, hasAudioIn, hasVideoIn, hasDocIn bool
|
|
parseInteractionsModalities(inMod, func(mod string, cnt int64) {
|
|
switch mod {
|
|
case "TEXT":
|
|
textIn += cnt
|
|
hasTextIn = true
|
|
case "IMAGE":
|
|
imgIn += cnt
|
|
hasImgIn = true
|
|
case "AUDIO":
|
|
audioIn += cnt
|
|
hasAudioIn = true
|
|
case "VIDEO":
|
|
videoIn += cnt
|
|
hasVideoIn = true
|
|
case "DOCUMENT", "FILE":
|
|
docIn += cnt
|
|
hasDocIn = true
|
|
}
|
|
})
|
|
if hasTextIn {
|
|
detail.TextInputTokens = usage.Int64Ptr(textIn)
|
|
}
|
|
if hasImgIn {
|
|
detail.ImageInputTokens = usage.Int64Ptr(imgIn)
|
|
}
|
|
if hasAudioIn {
|
|
detail.AudioInputTokens = usage.Int64Ptr(audioIn)
|
|
}
|
|
if hasVideoIn {
|
|
detail.VideoInputTokens = usage.Int64Ptr(videoIn)
|
|
}
|
|
if hasDocIn {
|
|
detail.FileInputTokens = usage.Int64Ptr(docIn)
|
|
}
|
|
}
|
|
if cacheMod := firstExistingUsageNode(node, "cached_tokens_by_modality", "cachedTokensByModality"); cacheMod.Exists() {
|
|
var cachedText, cachedImg, cachedAudio int64
|
|
var hasCachedText, hasCachedImg, hasCachedAudio bool
|
|
parseInteractionsModalities(cacheMod, func(mod string, cnt int64) {
|
|
switch mod {
|
|
case "TEXT":
|
|
cachedText += cnt
|
|
hasCachedText = true
|
|
case "IMAGE":
|
|
cachedImg += cnt
|
|
hasCachedImg = true
|
|
case "AUDIO":
|
|
cachedAudio += cnt
|
|
hasCachedAudio = true
|
|
}
|
|
})
|
|
if hasCachedText {
|
|
detail.CachedTextTokens = usage.Int64Ptr(cachedText)
|
|
}
|
|
if hasCachedImg {
|
|
detail.CachedImageTokens = usage.Int64Ptr(cachedImg)
|
|
}
|
|
if hasCachedAudio {
|
|
detail.CachedAudioTokens = usage.Int64Ptr(cachedAudio)
|
|
}
|
|
}
|
|
return detail
|
|
}
|
|
|
|
func hasUsageDetail(detail usage.Detail) bool {
|
|
return hasNonZeroTokenUsage(detail)
|
|
}
|
|
|
|
func ParseInteractionsUsage(data []byte) usage.Detail {
|
|
root := util.ParseGJSONBytesNoCopy(data)
|
|
node := firstExistingUsageNode(root, "usage", "total_usage", "metadata.total_usage", "metadata.usage", "usageMetadata", "usage_metadata", "interaction.usage", "interaction.total_usage", "interaction.metadata.total_usage")
|
|
if !node.Exists() {
|
|
return usage.Detail{}
|
|
}
|
|
if node.Get("promptTokenCount").Exists() || node.Get("candidatesTokenCount").Exists() {
|
|
detail := parseGeminiFamilyUsageDetail(node)
|
|
detail.ResponseServiceTier = extractResponseServiceTier(data)
|
|
return detail
|
|
}
|
|
detail := parseInteractionsUsageDetail(node)
|
|
detail.ResponseServiceTier = extractResponseServiceTier(data)
|
|
return detail
|
|
}
|
|
|
|
func extractResponseServiceTier(payload []byte) string {
|
|
if len(payload) == 0 || !ojson.ValidBytes(payload) {
|
|
return ""
|
|
}
|
|
return extractResponseServiceTierFromValidJSON(payload)
|
|
}
|
|
|
|
func extractResponseServiceTierFromValidJSON(payload []byte) string {
|
|
for _, path := range []string{"response.service_tier", "service_tier", "interaction.service_tier"} {
|
|
if tier := strings.TrimSpace(ojson.GetBytesNoCopy(payload, path).String()); tier != "" {
|
|
return strings.Clone(tier)
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func ParseInteractionsStreamUsage(line []byte) (usage.Detail, bool) {
|
|
payload := jsonPayload(line)
|
|
if len(payload) == 0 {
|
|
payload = line
|
|
}
|
|
if len(payload) == 0 || !ojson.ValidBytes(payload) {
|
|
return usage.Detail{}, false
|
|
}
|
|
detail := ParseInteractionsUsage(payload)
|
|
if !hasUsageDetail(detail) {
|
|
return usage.Detail{}, false
|
|
}
|
|
return detail, true
|
|
}
|
|
|
|
func ParseGeminiUsage(data []byte) usage.Detail {
|
|
if len(data) == 0 || !ojson.ValidBytes(data) {
|
|
return usage.Detail{}
|
|
}
|
|
root := util.ParseGJSONBytesNoCopy(data)
|
|
var (
|
|
node ojson.Result
|
|
candidatesNode ojson.Result
|
|
predsNode ojson.Result
|
|
)
|
|
root.ForEach(func(key, val ojson.Result) bool {
|
|
switch key.String() {
|
|
case "usageMetadata", "usage_metadata":
|
|
if !node.Exists() {
|
|
node = val
|
|
}
|
|
case "candidates":
|
|
candidatesNode = val
|
|
case "predictions":
|
|
predsNode = val
|
|
case "response":
|
|
if val.IsObject() {
|
|
val.ForEach(func(rk, rv ojson.Result) bool {
|
|
switch rk.String() {
|
|
case "usageMetadata", "usage_metadata":
|
|
if !node.Exists() {
|
|
node = rv
|
|
}
|
|
case "candidates":
|
|
if !candidatesNode.Exists() {
|
|
candidatesNode = rv
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
var detail usage.Detail
|
|
if node.Exists() {
|
|
detail = parseGeminiFamilyUsageDetail(node)
|
|
}
|
|
if candidatesNode.Exists() || predsNode.Exists() {
|
|
applyGeminiNodesArtifacts(&detail, candidatesNode, predsNode)
|
|
}
|
|
return detail
|
|
}
|
|
|
|
func ParseGeminiStreamUsage(line []byte) (usage.Detail, bool) {
|
|
payload := jsonPayload(line)
|
|
if len(payload) == 0 {
|
|
return usage.Detail{}, false
|
|
}
|
|
hasCamel := bytes.Contains(payload, geminiUsageMetaMarker)
|
|
hasSnake := !hasCamel && bytes.Contains(payload, geminiUsageMetaSnakeMarker)
|
|
if (!hasCamel && !hasSnake) || !ojson.ValidBytes(payload) {
|
|
return usage.Detail{}, false
|
|
}
|
|
root := util.ParseGJSONBytesNoCopy(payload)
|
|
var node ojson.Result
|
|
if hasCamel {
|
|
node = root.Get("usageMetadata")
|
|
} else {
|
|
node = root.Get("usage_metadata")
|
|
}
|
|
if !node.Exists() {
|
|
return usage.Detail{}, false
|
|
}
|
|
detail := parseGeminiFamilyUsageDetail(node)
|
|
if !hasNonZeroTokenUsage(detail) {
|
|
return usage.Detail{}, false
|
|
}
|
|
if hasGeminiCandidateArtifactMarker(payload) {
|
|
applyGeminiPayloadArtifacts(&detail, root)
|
|
}
|
|
return detail, true
|
|
}
|
|
|
|
func firstExistingUsageNode(root ojson.Result, paths ...string) ojson.Result {
|
|
for _, path := range paths {
|
|
node := root.Get(path)
|
|
if node.Exists() {
|
|
return node
|
|
}
|
|
}
|
|
return ojson.Result{}
|
|
}
|
|
|
|
func safeUsageTokenSum(values ...int64) (int64, bool) {
|
|
var total int64
|
|
for _, value := range values {
|
|
if value < 0 || total > int64(^uint64(0)>>1)-value {
|
|
return 0, false
|
|
}
|
|
total += value
|
|
}
|
|
return total, true
|
|
}
|
|
|
|
func invalidUsageTokenBreakdown(total int64) usage.TokenBreakdown {
|
|
if total < 0 {
|
|
total = 0
|
|
}
|
|
return usage.TokenBreakdown{
|
|
SchemaVersion: usage.TokenAccountingSchemaVersion,
|
|
Quality: usage.TokenAccountingQualityInconsistent,
|
|
TotalTokens: total,
|
|
UnclassifiedTokens: total,
|
|
}
|
|
}
|
|
|
|
func ParseAntigravityUsage(data []byte) usage.Detail {
|
|
return ParseGeminiUsage(data)
|
|
}
|
|
|
|
func ParseAntigravityStreamUsage(line []byte) (usage.Detail, bool) {
|
|
payload := jsonPayload(line)
|
|
if len(payload) == 0 {
|
|
return usage.Detail{}, false
|
|
}
|
|
hasCamel := bytes.Contains(payload, geminiUsageMetaMarker)
|
|
hasSnake := !hasCamel && bytes.Contains(payload, geminiUsageMetaSnakeMarker)
|
|
if (!hasCamel && !hasSnake) || !ojson.ValidBytes(payload) {
|
|
return usage.Detail{}, false
|
|
}
|
|
root := util.ParseGJSONBytesNoCopy(payload)
|
|
node := root.Get("response.usageMetadata")
|
|
if !node.Exists() && hasCamel {
|
|
node = root.Get("usageMetadata")
|
|
}
|
|
if !node.Exists() && hasSnake {
|
|
node = root.Get("usage_metadata")
|
|
}
|
|
if !node.Exists() {
|
|
return usage.Detail{}, false
|
|
}
|
|
detail := parseGeminiFamilyUsageDetail(node)
|
|
if hasGeminiCandidateArtifactMarker(payload) {
|
|
applyGeminiPayloadArtifacts(&detail, root)
|
|
}
|
|
return detail, true
|
|
}
|
|
|
|
var stopChunkWithoutUsage sync.Map
|
|
|
|
func rememberStopWithoutUsage(traceID string) {
|
|
stopChunkWithoutUsage.Store(traceID, struct{}{})
|
|
time.AfterFunc(10*time.Minute, func() { stopChunkWithoutUsage.Delete(traceID) })
|
|
}
|
|
|
|
// FilterSSEUsageMetadata removes usageMetadata from SSE events that are not
|
|
// terminal (finishReason != "stop"). Stop chunks are left untouched. This
|
|
// function is shared between aistudio and antigravity executors.
|
|
func FilterSSEUsageMetadata(payload []byte) []byte {
|
|
if len(payload) == 0 {
|
|
return payload
|
|
}
|
|
|
|
lines := bytes.Split(payload, []byte("\n"))
|
|
modified := false
|
|
foundData := false
|
|
for idx, line := range lines {
|
|
trimmed := bytes.TrimSpace(line)
|
|
if len(trimmed) == 0 || !bytes.HasPrefix(trimmed, []byte("data:")) {
|
|
continue
|
|
}
|
|
foundData = true
|
|
dataIdx := bytes.Index(line, []byte("data:"))
|
|
if dataIdx < 0 {
|
|
continue
|
|
}
|
|
rawJSON := bytes.TrimSpace(line[dataIdx+5:])
|
|
traceID := strings.Clone(ojson.GetBytesNoCopy(rawJSON, "traceId").String())
|
|
if isStopChunkWithoutUsage(rawJSON) && traceID != "" {
|
|
rememberStopWithoutUsage(traceID)
|
|
continue
|
|
}
|
|
if traceID != "" {
|
|
if _, ok := stopChunkWithoutUsage.Load(traceID); ok && hasUsageMetadata(rawJSON) {
|
|
stopChunkWithoutUsage.Delete(traceID)
|
|
continue
|
|
}
|
|
}
|
|
|
|
cleaned, changed := StripUsageMetadataFromJSON(rawJSON)
|
|
if !changed {
|
|
continue
|
|
}
|
|
rebuiltCap := dataIdx + 5
|
|
if len(cleaned) > 0 {
|
|
rebuiltCap += 1 + len(cleaned)
|
|
}
|
|
rebuilt := make([]byte, 0, rebuiltCap)
|
|
rebuilt = append(rebuilt, line[:dataIdx]...)
|
|
rebuilt = append(rebuilt, "data:"...)
|
|
if len(cleaned) > 0 {
|
|
rebuilt = append(rebuilt, ' ')
|
|
rebuilt = append(rebuilt, cleaned...)
|
|
}
|
|
lines[idx] = rebuilt
|
|
modified = true
|
|
}
|
|
if !modified {
|
|
if !foundData {
|
|
// Handle payloads that are raw JSON without SSE data: prefix.
|
|
trimmed := bytes.TrimSpace(payload)
|
|
cleaned, changed := StripUsageMetadataFromJSON(trimmed)
|
|
if !changed {
|
|
return payload
|
|
}
|
|
return cleaned
|
|
}
|
|
return payload
|
|
}
|
|
return bytes.Join(lines, []byte("\n"))
|
|
}
|
|
|
|
// StripUsageMetadataFromJSON drops usageMetadata unless finishReason is present (terminal).
|
|
// It handles both formats:
|
|
// - Aistudio: candidates.0.finishReason
|
|
// - Antigravity: response.candidates.0.finishReason
|
|
func StripUsageMetadataFromJSON(rawJSON []byte) ([]byte, bool) {
|
|
jsonBytes := bytes.TrimSpace(rawJSON)
|
|
if len(jsonBytes) == 0 || !bytes.Contains(jsonBytes, geminiUsageMetaMarker) || !ojson.ValidBytes(jsonBytes) {
|
|
return rawJSON, false
|
|
}
|
|
|
|
root := util.ParseGJSONBytesNoCopy(jsonBytes)
|
|
var (
|
|
finishReason string
|
|
topUsage ojson.Result
|
|
respUsage ojson.Result
|
|
topUsageKey ojson.Result
|
|
respUsageKey ojson.Result
|
|
)
|
|
root.ForEach(func(key, val ojson.Result) bool {
|
|
switch key.String() {
|
|
case "usageMetadata":
|
|
topUsage = val
|
|
topUsageKey = key
|
|
case "candidates":
|
|
if finishReason == "" && val.IsArray() {
|
|
finishReason = strings.TrimSpace(val.Get("0.finishReason").String())
|
|
}
|
|
case "response":
|
|
if val.IsObject() {
|
|
val.ForEach(func(rk, rv ojson.Result) bool {
|
|
switch rk.String() {
|
|
case "usageMetadata":
|
|
respUsage = rv
|
|
respUsageKey = rk
|
|
case "candidates":
|
|
if finishReason == "" && rv.IsArray() {
|
|
finishReason = strings.TrimSpace(rv.Get("0.finishReason").String())
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
|
|
if finishReason != "" || (!topUsage.Exists() && !respUsage.Exists()) {
|
|
return rawJSON, false
|
|
}
|
|
|
|
// Fast single-allocation key rename when only one usageMetadata exists
|
|
// (avoids 2 full-buffer sjson copies on multi-MB 4K image chunks).
|
|
if topUsage.Exists() != respUsage.Exists() {
|
|
key := topUsageKey
|
|
if respUsage.Exists() {
|
|
key = respUsageKey
|
|
}
|
|
if key.Raw == string(geminiUsageMetaMarker) && key.Index > 0 &&
|
|
key.Index+len(key.Raw) <= len(jsonBytes) {
|
|
keyPos := key.Index + 1 // Right after the selected key's opening quote.
|
|
out := make([]byte, 0, len(jsonBytes)+3)
|
|
out = append(out, jsonBytes[:keyPos]...)
|
|
out = append(out, "cpaUsageMetadata"...)
|
|
out = append(out, jsonBytes[keyPos+len("usageMetadata"):]...)
|
|
return out, true
|
|
}
|
|
}
|
|
|
|
doc := ojson.NewDoc(jsonBytes)
|
|
var changed bool
|
|
if topUsage.Exists() {
|
|
_ = doc.SetRaw("cpaUsageMetadata", topUsage.Raw)
|
|
_ = doc.Delete("usageMetadata")
|
|
changed = true
|
|
}
|
|
if respUsage.Exists() {
|
|
_ = doc.SetRaw("response.cpaUsageMetadata", respUsage.Raw)
|
|
_ = doc.Delete("response.usageMetadata")
|
|
changed = true
|
|
}
|
|
if !changed {
|
|
return rawJSON, false
|
|
}
|
|
return doc.Bytes(), true
|
|
}
|
|
|
|
func hasUsageMetadata(jsonBytes []byte) bool {
|
|
if len(jsonBytes) == 0 || !ojson.ValidBytes(jsonBytes) {
|
|
return false
|
|
}
|
|
if ojson.GetBytesNoCopy(jsonBytes, "usageMetadata").Exists() {
|
|
return true
|
|
}
|
|
if ojson.GetBytesNoCopy(jsonBytes, "response.usageMetadata").Exists() {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
var finishReasonMarker = []byte(`"finishReason"`)
|
|
|
|
func isStopChunkWithoutUsage(jsonBytes []byte) bool {
|
|
if len(jsonBytes) == 0 || !bytes.Contains(jsonBytes, finishReasonMarker) || bytes.Contains(jsonBytes, geminiUsageMetaMarker) || !ojson.ValidBytes(jsonBytes) {
|
|
return false
|
|
}
|
|
finishReason := ojson.GetBytesNoCopy(jsonBytes, "candidates.0.finishReason")
|
|
if !finishReason.Exists() {
|
|
finishReason = ojson.GetBytesNoCopy(jsonBytes, "response.candidates.0.finishReason")
|
|
}
|
|
trimmed := strings.TrimSpace(finishReason.String())
|
|
if !finishReason.Exists() || trimmed == "" {
|
|
return false
|
|
}
|
|
return !hasUsageMetadata(jsonBytes)
|
|
}
|
|
|
|
func JSONPayload(line []byte) []byte {
|
|
return jsonPayload(line)
|
|
}
|
|
|
|
func jsonPayload(line []byte) []byte {
|
|
trimmed := bytes.TrimSpace(line)
|
|
if len(trimmed) == 0 {
|
|
return nil
|
|
}
|
|
if bytes.Equal(trimmed, []byte("[DONE]")) {
|
|
return nil
|
|
}
|
|
if bytes.HasPrefix(trimmed, []byte("event:")) {
|
|
return nil
|
|
}
|
|
if bytes.HasPrefix(trimmed, []byte("data:")) {
|
|
trimmed = bytes.TrimSpace(trimmed[len("data:"):])
|
|
}
|
|
if len(trimmed) == 0 || trimmed[0] != '{' {
|
|
return nil
|
|
}
|
|
return trimmed
|
|
}
|