UNPKG

@bitkyc08/opencodex

Version:

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

352 lines (331 loc) • 12.2 kB
import type { OcxUsage } from "../types"; import { normalizeCostTokens } from "../usage/cost"; import { scanUsageLedgerCooperatively } from "../usage/ledger-scanner"; import { isKnownRequestFailureCause, type PersistedUsageEntry } from "../usage/log"; import { classifyRequestOutcome } from "../usage/request-outcome"; import { usageDisplayTotalTokens } from "../usage/totals"; import { TELEMETRY_MAX_MODELS, parseCalendarUtcDayMs, type TelemetryErrorsV1, type TelemetryFailureCause, type TelemetryModelFamily, type TelemetryModelRowV1, type TelemetryProviderKind, type TelemetryRequestsV1, } from "./contract"; export interface DisjointTelemetryTokens { inputTokens: number; cacheReadTokens: number; cacheWriteTokens: number; outputTokens: number; reasoningTokens: number; } export interface DailyTelemetryAggregate { day: string; activeMinutes: number; requests: TelemetryRequestsV1; models: TelemetryModelRowV1[]; errors: TelemetryErrorsV1; } const ACCOUNT_SUFFIX_RE = /-(?:main|[po][0-9a-f]{6}|k[0-9a-f]{32})$/i; const PRESET_TO_PROVIDER_KIND: Readonly<Record<string, TelemetryProviderKind>> = Object.freeze({ openai: "openai", "openai-apikey": "openai", "azure-openai": "openai", chatgpt: "chatgpt", "openai-multi": "chatgpt", anthropic: "anthropic", "anthropic-apikey": "anthropic", "claude-subscription": "claude-subscription", "claude-cli": "claude-subscription", anthropic2: "claude-subscription", google: "google", "google-antigravity": "google", vertex: "vertex", "google-vertex": "vertex", xai: "xai", grok: "xai", deepseek: "deepseek", moonshot: "moonshot", kimi: "moonshot", "kimi-responses": "moonshot", "kimi-code": "moonshot", qwen: "qwen", "qwen-cloud": "qwen", alibaba: "qwen", "alibaba-token-plan": "qwen", "alibaba-token-plan-intl": "qwen", zai: "zai", "zhipu-bigmodel": "zai", "zhipu-bigmodel-coding": "zai", "zhipu-bigmodel-responses": "zai", minimax: "minimax", "minimax-cn": "minimax", mistral: "mistral", openrouter: "openrouter", groq: "groq", cerebras: "cerebras", together: "together", fireworks: "fireworks", firepass: "fireworks", cursor: "cursor", kiro: "kiro", copilot: "copilot", "github-copilot": "copilot", devin: "devin", ollama: "ollama", "ollama-cloud": "ollama", lmstudio: "lmstudio", "lm-studio": "lmstudio", "local-other": "local-other", vllm: "local-other", litellm: "local-other", }); /** * Map a logged provider identifier to the closed vendor-level `TelemetryProviderKind` roster. * Custom/unknown provider keys never enter the payload; they map to `"other"`. */ export function classifyProviderKind(provider: string): TelemetryProviderKind { const trimmed = provider.trim().toLowerCase(); if (!trimmed) return "other"; const direct = PRESET_TO_PROVIDER_KIND[trimmed]; if (direct) return direct; const stripped = trimmed.replace(ACCOUNT_SUFFIX_RE, ""); return PRESET_TO_PROVIDER_KIND[stripped] ?? "other"; } /** * Map a model identifier to the closed `TelemetryModelFamily` prefix roster. */ export function classifyModelFamily(model: string): TelemetryModelFamily { const trimmed = model.trim().toLowerCase(); if (!trimmed) return "other"; const slash = trimmed.lastIndexOf("/"); const tail = (slash >= 0 ? trimmed.slice(slash + 1) : trimmed).replace(/--[a-z0-9_-]+$/, ""); if (!tail) return "other"; if (tail.startsWith("gpt-6")) return "gpt-6"; if (tail.startsWith("gpt-5")) return "gpt-5"; if (tail.startsWith("gpt-4")) return "gpt-4"; if (tail === "o-series" || /^o[134](?:$|[-._])/.test(tail)) return "o-series"; if (tail.startsWith("codex")) return "codex"; if (/^claude-(?:[\d.-]+-)?opus(?:$|[-._])/.test(tail) || tail === "claude-opus") return "claude-opus"; if (/^claude-(?:[\d.-]+-)?sonnet(?:$|[-._])/.test(tail) || tail === "claude-sonnet") return "claude-sonnet"; if (/^claude-(?:[\d.-]+-)?haiku(?:$|[-._])/.test(tail) || tail === "claude-haiku") return "claude-haiku"; if (tail.startsWith("gemini-3")) return "gemini-3"; if (tail.startsWith("gemini-2")) return "gemini-2"; if (tail.startsWith("grok")) return "grok"; if (tail.startsWith("deepseek")) return "deepseek"; if (tail.startsWith("qwen") || tail.startsWith("qwq")) return "qwen"; if (tail.startsWith("kimi") || tail.startsWith("moonshot")) return "kimi"; if (tail.startsWith("glm") || tail.startsWith("chatglm")) return "glm"; if (tail.startsWith("minimax") || tail.startsWith("abab")) return "minimax"; if ( tail.startsWith("mistral") || tail.startsWith("mixtral") || tail.startsWith("codestral") || tail.startsWith("pixtral") || tail.startsWith("ministral") ) { return "mistral"; } if (tail.startsWith("llama") || tail.startsWith("meta-llama")) return "llama"; return "other"; } function nonNegInt(value: number | undefined): number { return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0; } /** * Decompose `OcxUsage` into five disjoint token buckets whose sum equals `usageDisplayTotalTokens(usage)`: * - `inputTokens`: uncached input (`normalizeCostTokens`) * - `cacheReadTokens` * - `cacheWriteTokens` * - `outputTokens`: output minus reasoning * - `reasoningTokens` */ export function disjointTelemetryTokens(usage: OcxUsage | undefined): DisjointTelemetryTokens { if (!usage) { return { inputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, outputTokens: 0, reasoningTokens: 0, }; } const normalized = normalizeCostTokens(usage); let inputTokens: number; let cacheReadTokens: number; let cacheWriteTokens: number; let totalOutput: number; if (normalized) { inputTokens = nonNegInt(normalized.input); cacheReadTokens = nonNegInt(normalized.cacheRead); cacheWriteTokens = nonNegInt(normalized.cacheWrite); totalOutput = nonNegInt(normalized.output); } else { const rawInput = nonNegInt(usage.inputTokens); cacheWriteTokens = Math.min(rawInput, nonNegInt(usage.cacheCreationInputTokens)); cacheReadTokens = Math.min( rawInput - cacheWriteTokens, nonNegInt(usage.cacheReadInputTokens ?? usage.cachedInputTokens), ); inputTokens = Math.max(0, rawInput - cacheReadTokens - cacheWriteTokens); totalOutput = nonNegInt(usage.outputTokens); } const reasoningTokens = Math.min(totalOutput, nonNegInt(usage.reasoningOutputTokens)); const outputTokens = Math.max(0, totalOutput - reasoningTokens); const displayTotal = nonNegInt(usageDisplayTotalTokens(usage)); const accounted = inputTokens + cacheReadTokens + cacheWriteTokens + outputTokens + reasoningTokens; if (displayTotal > accounted) { inputTokens += displayTotal - accounted; } return { inputTokens, cacheReadTokens, cacheWriteTokens, outputTokens, reasoningTokens, }; } export interface DailyTelemetryAccumulator { onEntry: (entry: PersistedUsageEntry) => void; finalize: () => DailyTelemetryAggregate; } /** * Streaming accumulator for one completed UTC day. * * Accumulates counters directly inside `onEntry` for entries falling inside `day` * and never retains `PersistedUsageEntry` rows in memory. */ export function createDailyTelemetryAccumulator(day: string): DailyTelemetryAccumulator { const dayStartMs = parseCalendarUtcDayMs(day); if (dayStartMs === null) { throw new Error(`Invalid UTC day: ${day}`); } const dayEndMs = dayStartMs + 86_400_000; const minutes = new Set<number>(); const requests: TelemetryRequestsV1 = { completed: 0, failed: 0, incomplete: 0, aborted: 0, }; const modelMap = new Map<string, TelemetryModelRowV1>(); const errors: TelemetryErrorsV1 = {}; const addModelAttribution = (provider: string, model: string, usage: OcxUsage | undefined) => { const providerKind = classifyProviderKind(provider); const modelFamily = classifyModelFamily(model); const key = `${providerKind}\0${modelFamily}`; let row = modelMap.get(key); if (!row) { row = { providerKind, modelFamily, requests: 0, inputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, outputTokens: 0, reasoningTokens: 0, }; modelMap.set(key, row); } row.requests += 1; const tokens = disjointTelemetryTokens(usage); row.inputTokens += tokens.inputTokens; row.cacheReadTokens += tokens.cacheReadTokens; row.cacheWriteTokens += tokens.cacheWriteTokens; row.outputTokens += tokens.outputTokens; row.reasoningTokens += tokens.reasoningTokens; }; const onEntry = (entry: PersistedUsageEntry): void => { if (typeof entry.timestamp !== "number" || entry.timestamp < dayStartMs || entry.timestamp >= dayEndMs) { return; } minutes.add(Math.floor(entry.timestamp / 60_000)); const outcome = classifyRequestOutcome(entry); requests[outcome] += 1; const cause = entry.failureCause ?? entry.attempts?.at(-1)?.failureCause; if (cause && isKnownRequestFailureCause(cause)) { errors[cause as TelemetryFailureCause] = (errors[cause as TelemetryFailureCause] ?? 0) + 1; } const attempts = entry.attempts; const isCombo = entry.provider === "combo"; if (attempts?.length && (isCombo || attempts.some(attempt => attempt.usage && (attempt.provider !== entry.provider || attempt.model !== entry.model)))) { for (const attempt of attempts) { if (isCombo || attempt.usage) addModelAttribution(attempt.provider, attempt.model, attempt.usage); } } else { addModelAttribution(entry.provider, entry.model, entry.usage); } }; const finalize = (): DailyTelemetryAggregate => { let models = [...modelMap.values()].sort((a, b) => { if (b.requests !== a.requests) return b.requests - a.requests; const aTokens = a.inputTokens + a.cacheReadTokens + a.cacheWriteTokens + a.outputTokens + a.reasoningTokens; const bTokens = b.inputTokens + b.cacheReadTokens + b.cacheWriteTokens + b.outputTokens + b.reasoningTokens; if (bTokens !== aTokens) return bTokens - aTokens; if (a.providerKind !== b.providerKind) return a.providerKind.localeCompare(b.providerKind); return a.modelFamily.localeCompare(b.modelFamily); }); if (models.length > TELEMETRY_MAX_MODELS) { const kept = models.slice(0, TELEMETRY_MAX_MODELS - 1); const overflow = models.slice(TELEMETRY_MAX_MODELS - 1); let otherRow = kept.find(r => r.providerKind === "other" && r.modelFamily === "other"); if (!otherRow) { otherRow = { providerKind: "other", modelFamily: "other", requests: 0, inputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, outputTokens: 0, reasoningTokens: 0, }; kept.push(otherRow); } for (const row of overflow) { otherRow.requests += row.requests; otherRow.inputTokens += row.inputTokens; otherRow.cacheReadTokens += row.cacheReadTokens; otherRow.cacheWriteTokens += row.cacheWriteTokens; otherRow.outputTokens += row.outputTokens; otherRow.reasoningTokens += row.reasoningTokens; } models = kept; } return { day, activeMinutes: Math.min(1440, minutes.size), requests: { ...requests }, models, errors: { ...errors }, }; }; return { onEntry, finalize }; } export function aggregateTelemetryEntriesForDay( day: string, entries: Iterable<PersistedUsageEntry>, ): DailyTelemetryAggregate { const accumulator = createDailyTelemetryAccumulator(day); for (const entry of entries) { accumulator.onEntry(entry); } return accumulator.finalize(); } export async function aggregateTelemetryForDay( day: string, options: { signal?: AbortSignal } = {}, ): Promise<DailyTelemetryAggregate> { const accumulator = createDailyTelemetryAccumulator(day); await scanUsageLedgerCooperatively({ signal: options.signal, onEntry: accumulator.onEntry, }); return accumulator.finalize(); }