UNPKG

@bitkyc08/opencodex

Version:

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

89 lines (79 loc) • 4.38 kB
/** * Credit-billed pricing bounds and the billing basis a cost estimate reports. * * A provider that bills credits (Kiro) reports a measured credit count, and the operator may * configure a USD price per credit. Both numbers arrive independently, so bounding them one at a * time is not enough: `1e308 x 1e308` is still `Infinity`, and `JSON.stringify` turns that into * `null`. This module owns the pair of bounds that keeps `credits x price` representable, and the * discriminated billing basis that lets a consumer tell a credit charge from a token allocation * instead of reading four zero component costs as a measured split. * * The bounds are deliberately absurd relative to real usage — the most expensive published plans * are cents per credit, and a single response reports at most a few thousand credits — so no * plausible row is refused, while an unbounded or corrupted value fails closed instead of * serializing as `null`. */ /** Upper bound for a configured USD price of one credit. */ export const MAX_CREDIT_PRICE_USD = 1_000_000; /** Upper bound for the credits a single attempt may report. */ export const MAX_PROVIDER_CREDITS = 1_000_000_000; /** Preserve invalid or incomplete credit evidence when usage snapshots are combined. */ export function sumCreditReadings(values: readonly (number | undefined)[]): number | undefined { const readings = values.filter((value): value is number => value !== undefined); if (readings.length === 0) return undefined; if (readings.length !== values.length || readings.some(value => !Number.isFinite(value) || value < 0)) return -1; return readings.reduce((sum, value) => sum + value, 0); } /** Keep token usage while accounting for a dispatched leg with no credit reading. */ export function withMissingCreditReading<T extends { providerCredits?: number }>(usage: T | undefined): T | undefined { if (usage?.providerCredits === undefined || usage.providerCredits === -1) return usage; return { ...usage, providerCredits: sumCreditReadings([usage.providerCredits, undefined]) }; } /** * A price that can be multiplied by any admissible credit count without overflowing. * The product stays well inside the safe-integer range, so a sum over attempts stays exact * enough for display and cannot reach `Infinity`. */ export function isValidCreditPriceBound(value: unknown): value is number { return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= MAX_CREDIT_PRICE_USD; } /** A credit count small enough that `count x price` is representable for any admissible price. */ export function isRepresentableCreditCount(value: unknown): value is number { return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= MAX_PROVIDER_CREDITS; } /** * Upper bound for one token bucket of a priced request. * * `MAX_CREDIT_PRICE_USD` bounds the price, and this bounds the count, for the same reason the * credit pair exists: a token estimate is `rate x tokens / 1e6`, and a corrupt row can carry * `tokens = 1e308`. The rate is itself bounded (`MAX_COST4_RATE`), but that bound multiplied by an * unbounded token count is still `Infinity`, which `JSON.stringify` turns into `null`. 1e12 tokens * is roughly half a million full 2M-token contexts in a single request, so no real row is refused. */ export const MAX_COST_TOKENS = 1_000_000_000_000; /** Every normalized token bucket small enough for `rate x tokens / 1e6` to stay finite. */ export function costTokensWithinBound(tokens: { input: number; output: number; cacheRead: number; cacheWrite: number; }): boolean { return tokens.input <= MAX_COST_TOKENS && tokens.output <= MAX_COST_TOKENS && tokens.cacheRead <= MAX_COST_TOKENS && tokens.cacheWrite <= MAX_COST_TOKENS; } /** * How a cost estimate was billed. * * `provider-credits` means the total is `providerCredits x creditPriceUsd`; the token component * fields carry no allocation and must not be displayed as charges. `mixed` means the total is the * sum of attempt costs that were not all billed the same way (or not all at the same credit * price), so the aggregate has no single split — only the per-attempt estimates do. */ export type CreditBilling = | { source: "provider-credits"; providerCredits: number; creditPriceUsd: number } | { source: "mixed" };