@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
160 lines (145 loc) • 5.57 kB
text/typescript
import {
isLabRouteSubjectId,
readRecentUsageEntries,
type PersistedUsageAttempt,
type PersistedUsageEntry,
} from "../../usage/log";
export const PASSIVE_PRODUCTION_DEFAULT_LIMIT = 50;
export const PASSIVE_PRODUCTION_MAX_LIMIT = 200;
export const PASSIVE_PRODUCTION_MAX_SCAN_ROWS = 2_000;
export type PassiveProductionOutcome =
| "success"
| "client_cancel"
| "route_error"
| "environmental"
| "unknown";
export interface PassiveRouteSignalV1 {
schemaVersion: 1;
subjectId: string;
source: "production_usage_v1";
requestRef: string;
decisionRef?: string;
attemptOrdinal: number;
observedAt: number;
outcome: PassiveProductionOutcome;
httpStatus?: number;
}
export interface PassiveProductionSummaryV1 {
schemaVersion: 1;
subjectId: string;
verificationStatus: "not_verification";
recentProductionAttempts: number;
recentSuccessfulAttempts: number;
recentRouteErrorSignals: number;
lastObservedProductionAttempt?: number;
}
export interface PassiveProductionQueryResultV1 {
schemaVersion: 1;
verificationStatus: "not_verification";
summary: PassiveProductionSummaryV1;
signals: PassiveRouteSignalV1[];
scannedRows: number;
truncated: boolean;
}
const ROUTE_ERROR_CODES = new Set([
"upstream_error",
"upstream_transport_error",
"upstream_connect_error",
"upstream_timeout",
]);
const ENVIRONMENTAL_ERROR_CODES = new Set([
"authentication_error",
"rate_limit_error",
"admission_rejected",
"upstream_host_circuit_open",
]);
function boundedLimit(value: number | undefined): number {
if (value === undefined) return PASSIVE_PRODUCTION_DEFAULT_LIMIT;
if (!Number.isSafeInteger(value) || value < 1) throw new RangeError("passive production limit must be a positive integer");
return Math.min(value, PASSIVE_PRODUCTION_MAX_LIMIT);
}
function isFinalAttempt(entry: PersistedUsageEntry, attempt: PersistedUsageAttempt): boolean {
const attempts = entry.attempts ?? [];
return attempts.length > 0 && attempts[attempts.length - 1]?.ordinal === attempt.ordinal;
}
function classifyOutcome(entry: PersistedUsageEntry, attempt: PersistedUsageAttempt): PassiveProductionOutcome {
if (attempt.status >= 200 && attempt.status < 300) return "success";
if (isFinalAttempt(entry, attempt) && entry.closeReason === "client_cancel") return "client_cancel";
if (attempt.errorCode && ENVIRONMENTAL_ERROR_CODES.has(attempt.errorCode)) return "environmental";
if (attempt.errorCode && ROUTE_ERROR_CODES.has(attempt.errorCode)) return "route_error";
return "unknown";
}
function signalFor(entry: PersistedUsageEntry, attempt: PersistedUsageAttempt): PassiveRouteSignalV1 | null {
const subjectId = attempt.labRouteSubjectId;
if (!isLabRouteSubjectId(subjectId)) return null;
return {
schemaVersion: 1,
subjectId,
source: "production_usage_v1",
requestRef: entry.requestId,
...(entry.routeDecision?.decisionId ? { decisionRef: entry.routeDecision.decisionId } : {}),
attemptOrdinal: attempt.ordinal,
observedAt: entry.timestamp,
outcome: classifyOutcome(entry, attempt),
httpStatus: attempt.status,
};
}
export function derivePassiveProductionSignals(
entries: readonly PersistedUsageEntry[],
subjectId: string,
limit?: number,
): PassiveProductionQueryResultV1 {
if (!isLabRouteSubjectId(subjectId)) throw new Error("invalid passive production subject id");
const maxResults = boundedLimit(limit);
const signals: PassiveRouteSignalV1[] = [];
// readRecentUsageEntries returns the selected append-only rows oldest-first.
// Tail selection, reverse iteration, and signals[0] as the newest observation rely on this ordering.
const scanRows = entries.slice(-PASSIVE_PRODUCTION_MAX_SCAN_ROWS);
const scanTruncated = entries.length > PASSIVE_PRODUCTION_MAX_SCAN_ROWS;
let resultTruncated = false;
scan: for (let rowIndex = scanRows.length - 1; rowIndex >= 0; rowIndex--) {
const entry = scanRows[rowIndex]!;
const attempts = entry.attempts ?? [];
for (let attemptIndex = attempts.length - 1; attemptIndex >= 0; attemptIndex--) {
const signal = signalFor(entry, attempts[attemptIndex]!);
if (signal?.subjectId !== subjectId) continue;
if (signals.length >= maxResults) {
resultTruncated = true;
break scan;
}
signals.push(signal);
}
}
const recentSuccessfulAttempts = signals.filter(signal => signal.outcome === "success").length;
const recentRouteErrorSignals = signals.filter(signal => signal.outcome === "route_error").length;
return {
schemaVersion: 1,
verificationStatus: "not_verification",
summary: {
schemaVersion: 1,
subjectId,
verificationStatus: "not_verification",
recentProductionAttempts: signals.length,
recentSuccessfulAttempts,
recentRouteErrorSignals,
...(signals[0] ? { lastObservedProductionAttempt: signals[0].observedAt } : {}),
},
signals,
scannedRows: scanRows.length,
truncated: scanTruncated || resultTruncated,
};
}
/** Read-only bounded CL-09 projection over the existing usage-log authority. */
export function queryPassiveProductionSignals(
subjectId: string,
limit?: number,
configDir?: string,
): PassiveProductionQueryResultV1 {
return derivePassiveProductionSignals(
// Read one row past the scan cap so the projection can distinguish an exact-cap history
// from a history with older rows omitted by the bounded reader.
readRecentUsageEntries(PASSIVE_PRODUCTION_MAX_SCAN_ROWS + 1, configDir),
subjectId,
limit,
);
}