UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

265 lines (246 loc) • 10.8 kB
import { baseProviderLabel } from "../providers/label"; import { cacheTokensFromUsage, usageAttributions } from "./summary"; import type { PersistedUsageEntry } from "./log"; import { usageDisplayTotalTokens } from "./totals"; export type TimelineMetric = "total" | "input" | "output" | "cached"; export type TimelineAggregation = "sum" | "average" | "max"; export type TimelineGrouping = "model" | "modelAccount"; export const TIMELINE_HOURS = [6, 24, 72, 168] as const; export interface TimelineQuery { hours: typeof TIMELINE_HOURS[number]; bucketMinutes: number; metric: TimelineMetric; aggregation: TimelineAggregation; grouping: TimelineGrouping; models: string[] | null; hiddenProviders: string[]; now: number; } export interface TimelineSeries { id: string; provider: string; model: string; accountLogLabel?: string; total: number; points: number[]; } export interface UsageTimeline { appliedFilters: { models: string[] | null; hiddenProviders: string[] }; start: number; end: number; bucketSeconds: number; buckets: number; metric: TimelineMetric; aggregation: TimelineAggregation; grouping: TimelineGrouping; series: TimelineSeries[]; availableModels: string[]; missingMeasurements: number; truncated: boolean; } const METRICS: readonly TimelineMetric[] = ["total", "input", "output", "cached"]; const AGGREGATIONS: readonly TimelineAggregation[] = ["sum", "average", "max"]; const GROUPINGS: readonly TimelineGrouping[] = ["model", "modelAccount"]; function enumValue<T extends string>(value: string | null, values: readonly T[], fallback: T): T | { error: string } { if (value === null || value === "") return fallback; return values.includes(value as T) ? value as T : { error: `invalid value for parameter: ${value}` }; } export function isTimelineModelId(value: unknown): value is string { return typeof value === "string" && /^[^/\s]+\/\S+$/.test(value); } /** * Pool accounts log as `openai-p<hex6>` (and older rows as `openai-main`/`chatgpt`), so the raw * provider would draw one line per account for the same model. The usage summary already folds these * through `baseProviderLabel`; the timeline keys on the same label so both views agree. */ function timelineModelId(provider: string, model: string): string { return `${baseProviderLabel(provider)}/${model}`; } /** A saved selection may still name a pool account (`openai-p6bc633/gpt-5`); it selects the merged row. */ export function normalizeTimelineModelId(id: string): string { const cut = id.indexOf("/"); return timelineModelId(id.slice(0, cut), id.slice(cut + 1)); } /** * In account grouping the pool suffix is the account when no explicit label was stamped. Codex pool * accounts and Anthropic OAuth accounts (`formatAnthropicProviderForLog`) both log that way. */ function poolAccountLabel(provider: string): string | undefined { if (baseProviderLabel(provider) === provider) return undefined; return provider.match(/-(main|p[a-f0-9]{6})$/)?.[1]; } function parseModels(raw: string | null): string[] | null | { error: string } { if (raw === null || raw.trim() === "") return null; const models = raw.split(",").map(model => model.trim()); if (models.length > 100) return { error: "models must contain at most 100 identifiers" }; if (models.some(model => !isTimelineModelId(model))) { return { error: "models must contain provider/model identifiers" }; } return [...new Set(models)]; } export function parseTimelineQuery(params: URLSearchParams, now: number): TimelineQuery | { error: string } { const rawHours = params.get("hours") ?? "24"; const hoursNumber = Number(rawHours); if (!TIMELINE_HOURS.includes(hoursNumber as typeof TIMELINE_HOURS[number])) { return { error: "hours must be one of 6, 24, 72, 168" }; } const bucketMinutes = Number(params.get("bucketMinutes") ?? "60"); if (!Number.isInteger(bucketMinutes) || bucketMinutes < 1 || bucketMinutes > 1440) { return { error: "bucketMinutes must be an integer from 1 through 1440" }; } const buckets = Math.ceil(hoursNumber * 60 / bucketMinutes); if (buckets > 2000) return { error: "timeline bucket count must not exceed 2000" }; const metric = enumValue(params.get("metric"), METRICS, "total"); if (typeof metric !== "string") return metric; const aggregation = enumValue(params.get("aggregation"), AGGREGATIONS, "sum"); if (typeof aggregation !== "string") return aggregation; const grouping = enumValue(params.get("grouping"), GROUPINGS, "model"); if (typeof grouping !== "string") return grouping; const models = parseModels(params.get("models")); if (typeof models === "object" && models !== null && "error" in models) return models; const hiddenProviders = params.getAll("hiddenProvider"); if (hiddenProviders.length > 100 || hiddenProviders.some(value => !value || /\s/.test(value))) { return { error: "hiddenProvider must contain at most 100 nonblank provider names" }; } if (!Number.isFinite(now)) return { error: "now must be finite" }; return { hours: hoursNumber as TimelineQuery["hours"], bucketMinutes, metric, aggregation, grouping, models: models as string[] | null, hiddenProviders: [...new Set(hiddenProviders)].sort(), now, }; } interface SeriesState { provider: string; model: string; accountLogLabel?: string; points: number[]; requests: Map<number, Map<string, number>>; } function metricValue(metric: TimelineMetric, attribution: ReturnType<typeof usageAttributions>[number]): number | undefined { if (metric === "total") return usageDisplayTotalTokens(attribution.usage, attribution.totalTokens); if (metric === "input") return attribution.usage?.inputTokens; if (metric === "output") return attribution.usage?.outputTokens; return cacheTokensFromUsage(attribution.usage).read; } export function createTimelineAccumulator(query: TimelineQuery): { add(entry: PersistedUsageEntry): void; finish(): UsageTimeline } { const bucketSeconds = query.bucketMinutes * 60; const buckets = Math.ceil(query.hours * 60 / query.bucketMinutes); const end = (Math.floor(query.now / 1000 / bucketSeconds) + 1) * bucketSeconds; const start = end - buckets * bucketSeconds; const startMs = start * 1000; const endMs = end * 1000; const series = new Map<string, SeriesState>(); const availableModels = new Set<string>(); const hiddenProviders = new Set(query.hiddenProviders); const selectedModels = query.models === null ? null : new Set(query.models.map(normalizeTimelineModelId)); let missingMeasurements = 0; function add(entry: PersistedUsageEntry): void { if (entry.timestamp < startMs || entry.timestamp >= endMs) return; const bucket = Math.floor((entry.timestamp - startMs) / (bucketSeconds * 1000)); if (bucket < 0 || bucket >= buckets) return; for (const attribution of usageAttributions(entry)) { const provider = baseProviderLabel(attribution.provider); if (hiddenProviders.has(attribution.provider) || hiddenProviders.has(provider)) continue; const modelId = timelineModelId(attribution.provider, attribution.model); availableModels.add(modelId); if (selectedModels && !selectedModels.has(modelId)) continue; const accountLogLabel = attribution.accountLogLabel ?? poolAccountLabel(attribution.provider) ?? "unknown"; const id = query.grouping === "model" ? modelId : `${modelId} · ${accountLogLabel}`; let state = series.get(id); if (!state) { state = { provider, model: attribution.model, ...(query.grouping === "modelAccount" ? { accountLogLabel } : {}), points: Array<number>(buckets).fill(0), requests: new Map(), }; series.set(id, state); } const value = metricValue(query.metric, attribution); if (value === undefined) { missingMeasurements += 1; continue; } if (query.aggregation === "sum") { state.points[bucket] = (state.points[bucket] ?? 0) + value; } else { let requests = state.requests.get(bucket); if (!requests) { requests = new Map(); state.requests.set(bucket, requests); } requests.set(attribution.requestId, (requests.get(attribution.requestId) ?? 0) + value); } } } function finish(): UsageTimeline { const rows = [...series].map(([id, state]): { row: TimelineSeries; state: SeriesState } => { if (query.aggregation !== "sum") { for (const [bucket, requests] of state.requests) { const values = [...requests.values()]; state.points[bucket] = query.aggregation === "max" ? Math.max(...values) : values.reduce((sum, value) => sum + value, 0) / values.length; } } const total = state.points.reduce((sum, value) => sum + value, 0); return { row: { id, provider: state.provider, model: state.model, ...(state.accountLogLabel !== undefined ? { accountLogLabel: state.accountLogLabel } : {}), total, points: state.points, }, state, }; }).sort((left, right) => right.row.total - left.row.total || left.row.id.localeCompare(right.row.id)); const kept = (rows.length > 24 ? rows.slice(0, 23) : rows).map(({ row }) => row); if (rows.length > 24) { const otherPoints = Array<number>(buckets).fill(0); const folded = rows.slice(23); if (query.aggregation === "sum") { for (const { row } of folded) { for (let index = 0; index < buckets; index += 1) otherPoints[index] = (otherPoints[index] ?? 0) + (row.points[index] ?? 0); } } else { for (let index = 0; index < buckets; index += 1) { const values = folded.flatMap(({ state }) => [...(state.requests.get(index)?.values() ?? [])]); if (values.length > 0) { otherPoints[index] = query.aggregation === "max" ? Math.max(...values) : values.reduce((sum, value) => sum + value, 0) / values.length; } } } kept.push({ id: "other", provider: "", model: "other", total: otherPoints.reduce((sum, value) => sum + value, 0), points: otherPoints }); } return { appliedFilters: { models: query.models === null ? null : [...new Set(query.models)].sort(), hiddenProviders: [...hiddenProviders].sort(), }, start, end, bucketSeconds, buckets, metric: query.metric, aggregation: query.aggregation, grouping: query.grouping, series: kept, availableModels: [...availableModels].sort(), missingMeasurements, truncated: false, }; } return { add, finish }; }