@danypops/jittor 0.14.0 → 0.16.0

package/src/operations/context-operations.ts

@@ -1,4 +1,8 @@
-import { COMPACTION_DURATION_ESTIMATE_MAX_SAMPLES, CONTEXT_ASSESSMENT_DEFAULT_WINDOW_MS, CONTEXT_ASSESSMENT_QUERY_LIMIT } from "../constants.ts";
+import {
+	COMPACTION_DURATION_ESTIMATE_MAX_SAMPLES,
+	CONTEXT_ASSESSMENT_DEFAULT_WINDOW_MS,
+	CONTEXT_ASSESSMENT_QUERY_LIMIT,
+} from "../constants.ts";
 import { assessContextTelemetry, estimateCompactionDuration } from "../domain/context-telemetry.ts";
 import type { MetricStore } from "../ports/metric-store.ts";
 import type { OperationHandlerMap } from "./types.ts";
@@ -7,9 +11,11 @@ import type { OperationHandlerMap } from "./types.ts";
 export function contextOperations(metrics: MetricStore): OperationHandlerMap {
 	return {
 		"context.assess": (input) => {
-			const until = input["until"] === undefined ? Date.now() : input["until"];
-			const since = input["since"] === undefined && typeof until === "number" ? Math.max(0, until - CONTEXT_ASSESSMENT_DEFAULT_WINDOW_MS) : input["since"];
-			if (!Number.isSafeInteger(since) || !Number.isSafeInteger(until) || (since as number) < 0 || (until as number) < (since as number)) throw new Error("context assessment requires non-negative ordered integer bounds");
+			const until = input.until === undefined ? Date.now() : input.until;
+			const since =
+				input.since === undefined && typeof until === "number" ? Math.max(0, until - CONTEXT_ASSESSMENT_DEFAULT_WINDOW_MS) : input.since;
+			if (!Number.isSafeInteger(since) || !Number.isSafeInteger(until) || (since as number) < 0 || (until as number) < (since as number))
+				throw new Error("context assessment requires non-negative ordered integer bounds");
 			const query = { since: since as number, until: until as number, order: "asc" as const, limit: CONTEXT_ASSESSMENT_QUERY_LIMIT };
 			const injections = metrics.query({ ...query, source: "papyrus-context", metric: "injected-characters" });
 			const compactions = metrics.query({ ...query, source: "pi-context" });
@@ -21,8 +27,11 @@ export function contextOperations(metrics: MetricStore): OperationHandlerMap {
 		},
 		"compaction.estimate": () => {
 			const rows = metrics.query({
-				source: "pi-context", scope: "compaction", metric: "compaction-duration",
-				order: "desc", limit: COMPACTION_DURATION_ESTIMATE_MAX_SAMPLES,
+				source: "pi-context",
+				scope: "compaction",
+				metric: "compaction-duration",
+				order: "desc",
+				limit: COMPACTION_DURATION_ESTIMATE_MAX_SAMPLES,
 			});
 			return estimateCompactionDuration(rows);
 		},

package/src/operations/metrics-operations.ts

@@ -1,5 +1,11 @@
-import { MAX_USAGE_BUCKETS, METRIC_BATCH_MAX_OBSERVATIONS, PRUNE_MIN_AGE_MS, TASK_COST_QUERY_LIMIT, USAGE_MAX_DISTINCT_SCOPES } from "../constants.ts";
-import { validateMetricObservation, type MetricQuery } from "../domain/metric.ts";
+import {
+	MAX_USAGE_BUCKETS,
+	METRIC_BATCH_MAX_OBSERVATIONS,
+	PRUNE_MIN_AGE_MS,
+	TASK_COST_QUERY_LIMIT,
+	USAGE_MAX_DISTINCT_SCOPES,
+} from "../constants.ts";
+import { type MetricQuery, validateMetricObservation } from "../domain/metric.ts";
 import { buildTaskCostSummary } from "../domain/task-cost.ts";
 import type { MetricStore } from "../ports/metric-store.ts";
 import type { OperationHandlerMap } from "./types.ts";
@@ -9,69 +15,98 @@ export function metricsOperations(metrics: MetricStore): OperationHandlerMap {
 	return {
 		"metrics.record": (input) => metrics.record(validateMetricObservation(input)),
 		"metrics.record_batch": (input) => {
-			const observations = input["observations"];
+			const observations = input.observations;
 			if (!Array.isArray(observations) || observations.length === 0) throw new Error("observations must be a non-empty array");
-			if (observations.length > METRIC_BATCH_MAX_OBSERVATIONS) throw new Error(`observations must contain at most ${METRIC_BATCH_MAX_OBSERVATIONS} entries`);
+			if (observations.length > METRIC_BATCH_MAX_OBSERVATIONS)
+				throw new Error(`observations must contain at most ${METRIC_BATCH_MAX_OBSERVATIONS} entries`);
 			return metrics.recordBatch(observations.map((observation) => validateMetricObservation(observation)));
 		},
 		"metrics.query": (input) => metrics.query(input as MetricQuery),
 		"metrics.distinct_scopes": (input) => {
-			const source = input["source"];
-			const since = input["since"];
-			const until = input["until"];
+			const source = input.source;
+			const since = input.since;
+			const until = input.until;
 			if (typeof source !== "string" || source.length === 0) throw new Error("source is required");
 			if (!Number.isSafeInteger(since) || !Number.isSafeInteger(until) || (since as number) < 0 || (until as number) < (since as number)) {
 				throw new Error("distinct scopes requires non-negative ordered integer bounds");
 			}
-			const requestedLimit = input["limit"];
-			const limit = Number.isFinite(requestedLimit) ? Math.max(1, Math.min(USAGE_MAX_DISTINCT_SCOPES, Math.floor(requestedLimit as number))) : USAGE_MAX_DISTINCT_SCOPES;
+			const requestedLimit = input.limit;
+			const limit = Number.isFinite(requestedLimit)
+				? Math.max(1, Math.min(USAGE_MAX_DISTINCT_SCOPES, Math.floor(requestedLimit as number)))
+				: USAGE_MAX_DISTINCT_SCOPES;
 			return metrics.distinctScopes({ source, since: since as number, until: until as number, limit });
 		},
 		"metrics.usage_series": (input) => {
-			const source = input["source"];
-			const since = input["since"];
-			const until = input["until"];
-			const bucketSizeMs = input["bucketSizeMs"];
-			const bucketCount = input["bucketCount"];
+			const source = input.source;
+			const since = input.since;
+			const until = input.until;
+			const bucketSizeMs = input.bucketSizeMs;
+			const bucketCount = input.bucketCount;
 			if (typeof source !== "string" || source.length === 0) throw new Error("source is required");
 			if (!Number.isSafeInteger(since) || !Number.isSafeInteger(until) || (since as number) < 0 || (until as number) < (since as number)) {
 				throw new Error("usage series requires non-negative ordered integer bounds");
 			}
-			if (typeof bucketSizeMs !== "number" || !Number.isFinite(bucketSizeMs) || bucketSizeMs <= 0) throw new Error("bucketSizeMs must be a positive number");
+			if (typeof bucketSizeMs !== "number" || !Number.isFinite(bucketSizeMs) || bucketSizeMs <= 0)
+				throw new Error("bucketSizeMs must be a positive number");
 			if (!Number.isInteger(bucketCount) || (bucketCount as number) <= 0 || (bucketCount as number) > MAX_USAGE_BUCKETS) {
 				throw new Error(`bucketCount must be a positive integer up to ${MAX_USAGE_BUCKETS}`);
 			}
-			const requestedScopeLimit = input["scopeLimit"];
-			const scopeLimit = Number.isFinite(requestedScopeLimit) ? Math.max(1, Math.min(USAGE_MAX_DISTINCT_SCOPES, Math.floor(requestedScopeLimit as number))) : USAGE_MAX_DISTINCT_SCOPES;
+			const requestedScopeLimit = input.scopeLimit;
+			const scopeLimit = Number.isFinite(requestedScopeLimit)
+				? Math.max(1, Math.min(USAGE_MAX_DISTINCT_SCOPES, Math.floor(requestedScopeLimit as number)))
+				: USAGE_MAX_DISTINCT_SCOPES;
 			const scopes = metrics.distinctScopes({ source, since: since as number, until: until as number, limit: scopeLimit });
 			// More distinct scopes may exist beyond this bounded list -- that is the only remaining
 			// truncation risk once aggregation replaces a per-scope raw-row fetch (see aggregateUsage's
 			// own doc comment for the incident this was built to stop repeating).
 			const truncated = scopes.length >= scopeLimit;
-			const rows = scopes.length === 0 ? [] : metrics.aggregateUsage({
-				source, scopes, since: since as number, until: until as number, bucketSizeMs, bucketCount: bucketCount as number,
-			});
+			const rows =
+				scopes.length === 0
+					? []
+					: metrics.aggregateUsage({
+							source,
+							scopes,
+							since: since as number,
+							until: until as number,
+							bucketSizeMs,
+							bucketCount: bucketCount as number,
+						});
 			return { rows, truncated };
 		},
 		"metrics.cost_by_task": (input) => {
-			const since = input["since"];
-			const until = input["until"];
+			const since = input.since;
+			const until = input.until;
 			if (!Number.isSafeInteger(since) || !Number.isSafeInteger(until) || (since as number) < 0 || (until as number) < (since as number)) {
 				throw new Error("cost by task requires non-negative ordered integer bounds");
 			}
-			const rows = metrics.query({ source: "pi", since: since as number, until: until as number, order: "desc", limit: TASK_COST_QUERY_LIMIT });
-			return buildTaskCostSummary(rows, { since: since as number, until: until as number, truncated: rows.length >= TASK_COST_QUERY_LIMIT });
+			const rows = metrics.query({
+				source: "pi",
+				since: since as number,
+				until: until as number,
+				order: "desc",
+				limit: TASK_COST_QUERY_LIMIT,
+			});
+			return buildTaskCostSummary(rows, {
+				since: since as number,
+				until: until as number,
+				truncated: rows.length >= TASK_COST_QUERY_LIMIT,
+			});
 		},
 		"metrics.prune": (input) => {
-			const before = input["before"];
+			const before = input.before;
 			if (typeof before !== "number") throw new Error("before is required");
-			const force = input["force"] === true;
+			const force = input.force === true;
 			const minCutoff = Date.now() - PRUNE_MIN_AGE_MS;
 			if (!force && before > minCutoff) {
-				throw new Error(`refusing to prune metrics newer than ${new Date(minCutoff).toISOString()} without force: true (this looked like it could delete recent or live data)`);
+				throw new Error(
+					`refusing to prune metrics newer than ${new Date(minCutoff).toISOString()} without force: true (this looked like it could delete recent or live data)`,
+				);
 			}
 			return { deleted: metrics.pruneBefore(before) };
 		},
-		"service.checkpoint": () => { metrics.checkpoint(); return { ok: true }; },
+		"service.checkpoint": () => {
+			metrics.checkpoint();
+			return { ok: true };
+		},
 	};
 }

package/src/operations/model-ranking-operations.ts

@@ -3,12 +3,19 @@ import type { RouterController } from "../ports/router-controller.ts";
 import type { OperationHandlerMap } from "./types.ts";
 
 /** models.rank -- scores candidates via the model ranker, then, only for an automatic selection, applies it as a router mutation (so it shares the same session-identity authorization as every other router mutation). */
-export function modelRankingOperations(modelRanker: ModelRanker, router: RouterController, authorize: (input: Record<string, unknown>) => string | undefined): OperationHandlerMap {
+export function modelRankingOperations(
+	modelRanker: ModelRanker,
+	router: RouterController,
+	authorize: (input: Record<string, unknown>) => string | undefined,
+): OperationHandlerMap {
 	return {
 		"models.rank": (input) => {
 			const result = modelRanker.rank(input as unknown as ModelRecommendationInput);
 			if (result.automaticSelection && router.applyModelRanking) {
-				router.applyModelRanking(result.ranked.map((item) => item.candidate), authorize(input));
+				router.applyModelRanking(
+					result.ranked.map((item) => item.candidate),
+					authorize(input),
+				);
 			}
 			return result;
 		},

package/src/operations/router-operations.ts

@@ -1,10 +1,13 @@
-import type { RouteOverride, RouterController } from "../ports/router-controller.ts";
 import type { Route } from "../policy.ts";
-import type { OperationHandlerMap } from "./types.ts";
+import type { RouteOverride, RouterController } from "../ports/router-controller.ts";
 import { routerSessionId } from "./session-scope.ts";
+import type { OperationHandlerMap } from "./types.ts";
 
 /** telemetry.poll and every router.* operation -- reads pass a bare session_id through; mutations run authorize first, matching the opt-in session-identity armor. */
-export function routerOperations(router: RouterController, authorize: (input: Record<string, unknown>) => string | undefined): OperationHandlerMap {
+export function routerOperations(
+	router: RouterController,
+	authorize: (input: Record<string, unknown>) => string | undefined,
+): OperationHandlerMap {
 	return {
 		"telemetry.poll": () => router.poll(),
 		"router.status": (input) => router.status(routerSessionId(input)),
@@ -14,6 +17,7 @@ export function routerOperations(router: RouterController, authorize: (input: Re
 		"router.override": (input) => router.setOverride(input as unknown as RouteOverride, authorize(input)),
 		"router.clear_override": (input) => router.clearOverride(authorize(input)),
 		"router.current_route": (input) => router.setCurrentRoute(input as unknown as Route, authorize(input)),
-		"router.available_routes": (input) => router.setAvailableRoutes(Array.isArray(input["routes"]) ? input["routes"] as Route[] : [], authorize(input)),
+		"router.available_routes": (input) =>
+			router.setAvailableRoutes(Array.isArray(input.routes) ? (input.routes as Route[]) : [], authorize(input)),
 	};
 }

package/src/operations/session-identity-operations.ts

@@ -1,6 +1,6 @@
 import type { SessionIdentity } from "../session-identity-service.ts";
-import type { OperationHandlerMap } from "./types.ts";
 import { requiredString, routerSessionSecret } from "./session-scope.ts";
+import type { OperationHandlerMap } from "./types.ts";
 
 /** session.register and session.release -- the only two operations that mutate SessionIdentity itself, distinct from the router mutations it later authorizes. */
 export function sessionIdentityOperations(sessionIdentity: SessionIdentity | undefined): OperationHandlerMap {

package/src/operations/session-scope.ts

@@ -2,14 +2,14 @@ import type { SessionIdentity } from "../session-identity-service.ts";
 
 /** Shared input parsing for every operation that accepts an optional session_id/session_secret pair. */
 export function routerSessionId(input: Record<string, unknown>): string | undefined {
-	const value = input["session_id"];
+	const value = input.session_id;
 	if (value === undefined) return undefined;
 	if (typeof value !== "string") throw new Error("session_id must be a string");
 	return value;
 }
 
 export function routerSessionSecret(input: Record<string, unknown>): string | undefined {
-	const value = input["session_secret"];
+	const value = input.session_secret;
 	if (value === undefined) return undefined;
 	if (typeof value !== "string") throw new Error("session_secret must be a string");
 	return value;
@@ -22,7 +22,9 @@ export function requiredString(input: Record<string, unknown>, key: string): str
 }
 
 /** Opt-in armor: a session_id never registered via session.register mutates exactly as before. Bound once per JittorService instance and shared by every router-mutating operation module. */
-export function routerMutationAuthorizer(sessionIdentity: SessionIdentity | undefined): (input: Record<string, unknown>) => string | undefined {
+export function routerMutationAuthorizer(
+	sessionIdentity: SessionIdentity | undefined,
+): (input: Record<string, unknown>) => string | undefined {
 	return (input) => {
 		const sessionId = routerSessionId(input);
 		sessionIdentity?.assertAuthorized(sessionId, routerSessionSecret(input));

package/src/policy.ts

@@ -76,12 +76,18 @@ const ACTION_SEVERITY: Record<PolicyAction, number> = {
 
 function actionThreshold(action: PolicyAction, thresholds: PolicyThresholds): number {
 	switch (action) {
-		case "continue": return 0;
-		case "throttle": return thresholds.throttle;
-		case "lower-thinking": return thresholds.lowerThinking;
-		case "switch-model": return thresholds.switchModel;
-		case "switch-provider": return thresholds.switchProvider;
-		case "halt": return thresholds.halt;
+		case "continue":
+			return 0;
+		case "throttle":
+			return thresholds.throttle;
+		case "lower-thinking":
+			return thresholds.lowerThinking;
+		case "switch-model":
+			return thresholds.switchModel;
+		case "switch-provider":
+			return thresholds.switchProvider;
+		case "halt":
+			return thresholds.halt;
 	}
 }
 
@@ -145,12 +151,7 @@ function holdPrevious(input: PolicyInput, pressure: number, trace: string[]): Po
 	return undefined;
 }
 
-function decisionFromPrevious(
-	previous: PreviousDecision,
-	pressure: number,
-	trace: string[],
-	reason: string,
-): PolicyDecision {
+function decisionFromPrevious(previous: PreviousDecision, pressure: number, trace: string[], reason: string): PolicyDecision {
 	return {
 		action: previous.action,
 		pressure,
@@ -171,15 +172,19 @@ export function evaluateRoutingPolicy(input: PolicyInput): PolicyDecision {
 	if (input.windows.length === 0) return failClosed(input, "required budget telemetry is missing", trace);
 	for (const window of input.windows) {
 		if (window.freshness !== "fresh") return failClosed(input, `telemetry ${window.id} is ${window.freshness}`, trace, window.id);
-		if (input.now - window.observedAt > input.config.maxTelemetryAgeMs) return failClosed(input, `telemetry ${window.id} is stale`, trace, window.id);
-		if (window.confidence < (input.config.minimumConfidence ?? 0)) return failClosed(input, `telemetry ${window.id} confidence is too low`, trace, window.id);
-		if (window.usedFraction < 0 || window.usedFraction > 1) return failClosed(input, `telemetry ${window.id} has invalid utilization`, trace, window.id);
-		if (window.usedFraction >= input.config.hardStopUsedFraction) return failClosed(input, `hard stop reached for ${window.id}`, trace, window.id);
+		if (input.now - window.observedAt > input.config.maxTelemetryAgeMs)
+			return failClosed(input, `telemetry ${window.id} is stale`, trace, window.id);
+		if (window.confidence < (input.config.minimumConfidence ?? 0))
+			return failClosed(input, `telemetry ${window.id} confidence is too low`, trace, window.id);
+		if (window.usedFraction < 0 || window.usedFraction > 1)
+			return failClosed(input, `telemetry ${window.id} has invalid utilization`, trace, window.id);
+		if (window.usedFraction >= input.config.hardStopUsedFraction)
+			return failClosed(input, `hard stop reached for ${window.id}`, trace, window.id);
 	}
 
 	const pressures = input.windows.map((window) => ({ window, pressure: pressureFor(window, input.now) }));
 	for (const { window, pressure } of pressures) trace.push(`${window.id}: pressure=${pressure.toFixed(3)} sustainable=${pressure <= 1}`);
-	const binding = pressures.reduce((worst, candidate) => candidate.pressure > worst.pressure ? candidate : worst);
+	const binding = pressures.reduce((worst, candidate) => (candidate.pressure > worst.pressure ? candidate : worst));
 	const held = holdPrevious(input, binding.pressure, trace);
 	if (held) return { ...held, windowId: binding.window.id };
 

package/src/ports/benchmark-controller.ts

@@ -1,8 +1,4 @@
-import type {
-	BenchmarkQuery,
-	BenchmarkQueryResult,
-	BenchmarkRefreshResult,
-} from "../domain/benchmark.ts";
+import type { BenchmarkQuery, BenchmarkQueryResult, BenchmarkRefreshResult } from "../domain/benchmark.ts";
 
 export interface BenchmarkController {
 	refresh(force?: boolean): Promise<BenchmarkRefreshResult>;

package/src/ports/metric-store.ts

@@ -1,5 +1,5 @@
-import type { UsageAggregateRow } from "../domain/usage.ts";
 import type { MetricObservation, MetricQuery, StoredMetricObservation } from "../domain/metric.ts";
+import type { UsageAggregateRow } from "../domain/usage.ts";
 
 export interface DistinctScopesFilter {
 	source: string;

package/src/providers/anthropic-contracts.ts

@@ -42,7 +42,8 @@ function headerInteger(headers: Headers, name: string): number | null {
 	const raw = headers.get(name);
 	if (raw === null) return null;
 	const value = Number(raw);
-	if (!Number.isFinite(value) || !Number.isSafeInteger(value) || value < 0) throw new Error(`Anthropic rate-limit header schema changed: ${name}`);
+	if (!Number.isFinite(value) || !Number.isSafeInteger(value) || value < 0)
+		throw new Error(`Anthropic rate-limit header schema changed: ${name}`);
 	return value;
 }
 
@@ -62,7 +63,12 @@ function parseWindow(headers: Headers, prefix: string): AnthropicRateLimitWindow
 	return { limit, remaining, resetsAt };
 }
 
-function windowMetrics(source: AnthropicMetricSource, scope: string, window: AnthropicRateLimitWindow | null, observedAt: number): MetricObservation[] {
+function windowMetrics(
+	source: AnthropicMetricSource,
+	scope: string,
+	window: AnthropicRateLimitWindow | null,
+	observedAt: number,
+): MetricObservation[] {
 	if (!window) return [];
 	const metrics: MetricObservation[] = [];
 	const attributes = { limit: window.limit, remaining: window.remaining, resetsAt: window.resetsAt };
@@ -85,7 +91,11 @@ function windowMetrics(source: AnthropicMetricSource, scope: string, window: Ant
  */
 export type AnthropicMetricSource = "anthropic" | "anthropic-vertex";
 
-export function parseAnthropicRateLimitHeaders(headers: Headers, observedAt = Date.now(), source: AnthropicMetricSource = "anthropic"): AnthropicRateLimitSnapshot {
+export function parseAnthropicRateLimitHeaders(
+	headers: Headers,
+	observedAt = Date.now(),
+	source: AnthropicMetricSource = "anthropic",
+): AnthropicRateLimitSnapshot {
 	const requests = parseWindow(headers, "anthropic-ratelimit-requests");
 	const tokens = parseWindow(headers, "anthropic-ratelimit-tokens");
 	const inputTokens = parseWindow(headers, "anthropic-ratelimit-input-tokens");

package/src/providers/codex-contracts.ts

@@ -101,10 +101,10 @@ function parseWindow(value: unknown, name: string): CodexWindow | null {
 	const window = optionalRecord(value, name);
 	if (!window) return null;
 	return {
-		usedPercent: percent(window["used_percent"], name),
-		windowSeconds: integer(window["limit_window_seconds"], `${name} window seconds`),
-		resetAfterSeconds: integer(window["reset_after_seconds"], `${name} reset after seconds`),
-		resetsAt: integer(window["reset_at"], `${name} reset at`),
+		usedPercent: percent(window.used_percent, name),
+		windowSeconds: integer(window.limit_window_seconds, `${name} window seconds`),
+		resetAfterSeconds: integer(window.reset_after_seconds, `${name} reset after seconds`),
+		resetsAt: integer(window.reset_at, `${name} reset at`),
 	};
 }
 
@@ -112,9 +112,9 @@ function parseCredits(value: unknown): CodexCredits | null {
 	const credits = optionalRecord(value, "credits");
 	if (!credits) return null;
 	return {
-		hasCredits: boolean(credits["has_credits"], "credits has_credits"),
-		unlimited: boolean(credits["unlimited"], "credits unlimited"),
-		balance: optionalString(credits["balance"], "credits balance"),
+		hasCredits: boolean(credits.has_credits, "credits has_credits"),
+		unlimited: boolean(credits.unlimited, "credits unlimited"),
+		balance: optionalString(credits.balance, "credits balance"),
 	};
 }
 
@@ -132,10 +132,10 @@ function parseRateLimit(
 	const snapshot: CodexRateLimitSnapshot = {
 		limitId,
 		limitName,
-		allowed: boolean(rateLimit["allowed"], `${limitId} allowed`),
-		limitReached: boolean(rateLimit["limit_reached"], `${limitId} limit_reached`),
-		primary: parseWindow(rateLimit["primary_window"], `${limitId} primary`),
-		secondary: parseWindow(rateLimit["secondary_window"], `${limitId} secondary`),
+		allowed: boolean(rateLimit.allowed, `${limitId} allowed`),
+		limitReached: boolean(rateLimit.limit_reached, `${limitId} limit_reached`),
+		primary: parseWindow(rateLimit.primary_window, `${limitId} primary`),
+		secondary: parseWindow(rateLimit.secondary_window, `${limitId} secondary`),
 		credits,
 		observedAt,
 		metrics: [],
@@ -158,68 +158,73 @@ function metric(
 function windowMetrics(snapshot: CodexRateLimitSnapshot, name: "primary" | "secondary", window: CodexWindow | null): MetricObservation[] {
 	if (!window) return [];
 	const scope = snapshot.limitId === "codex" ? `codex:${name}` : `${snapshot.limitId}:${name}`;
-	return [metric(scope, "used-fraction", window.usedPercent / 100, "ratio", snapshot.observedAt, {
-		limitId: snapshot.limitId,
-		limitName: snapshot.limitName,
-		windowSeconds: window.windowSeconds,
-		resetAfterSeconds: window.resetAfterSeconds,
-		resetsAt: window.resetsAt,
-	})];
+	return [
+		metric(scope, "used-fraction", window.usedPercent / 100, "ratio", snapshot.observedAt, {
+			limitId: snapshot.limitId,
+			limitName: snapshot.limitName,
+			windowSeconds: window.windowSeconds,
+			resetAfterSeconds: window.resetAfterSeconds,
+			resetsAt: window.resetsAt,
+		}),
+	];
 }
 
 export function rateLimitMetrics(snapshot: CodexRateLimitSnapshot): MetricObservation[] {
-	const metrics = [
-		...windowMetrics(snapshot, "primary", snapshot.primary),
-		...windowMetrics(snapshot, "secondary", snapshot.secondary),
-	];
+	const metrics = [...windowMetrics(snapshot, "primary", snapshot.primary), ...windowMetrics(snapshot, "secondary", snapshot.secondary)];
 	if (snapshot.allowed !== null) metrics.push(metric(snapshot.limitId, "allowed", snapshot.allowed ? 1 : 0, "count", snapshot.observedAt));
-	if (snapshot.limitReached !== null) metrics.push(metric(snapshot.limitId, "limit-reached", snapshot.limitReached ? 1 : 0, "count", snapshot.observedAt));
+	if (snapshot.limitReached !== null)
+		metrics.push(metric(snapshot.limitId, "limit-reached", snapshot.limitReached ? 1 : 0, "count", snapshot.observedAt));
 	return metrics;
 }
 
 function parseSpendControl(value: unknown): CodexSpendControl | null {
 	const spend = optionalRecord(value, "spend control");
 	if (!spend) return null;
-	const limit = optionalRecord(spend["individual_limit"], "spend individual limit");
+	const limit = optionalRecord(spend.individual_limit, "spend individual limit");
 	return {
-		reached: boolean(spend["reached"], "spend control reached"),
-		individualLimit: limit ? {
-			source: optionalString(limit["source"], "spend source"),
-			limit: string(limit["limit"], "spend limit"),
-			used: string(limit["used"], "spend used"),
-			remaining: string(limit["remaining"], "spend remaining"),
-			usedPercent: percent(limit["used_percent"], "spend"),
-			remainingPercent: percent(limit["remaining_percent"], "spend remaining"),
-			resetAfterSeconds: integer(limit["reset_after_seconds"], "spend reset after"),
-			resetsAt: integer(limit["reset_at"], "spend reset at"),
-		} : null,
+		reached: boolean(spend.reached, "spend control reached"),
+		individualLimit: limit
+			? {
+					source: optionalString(limit.source, "spend source"),
+					limit: string(limit.limit, "spend limit"),
+					used: string(limit.used, "spend used"),
+					remaining: string(limit.remaining, "spend remaining"),
+					usedPercent: percent(limit.used_percent, "spend"),
+					remainingPercent: percent(limit.remaining_percent, "spend remaining"),
+					resetAfterSeconds: integer(limit.reset_after_seconds, "spend reset after"),
+					resetsAt: integer(limit.reset_at, "spend reset at"),
+				}
+			: null,
 	};
 }
 
 export function parseCodexUsage(value: unknown, observedAt = Date.now()): CodexUsageSnapshot {
 	const payload = record(value, "payload");
-	const planType = string(payload["plan_type"], "plan_type");
-	const credits = parseCredits(payload["credits"]);
-	const defaultLimit = parseRateLimit(payload["rate_limit"], "codex", null, credits, observedAt);
-	const additionalValue = payload["additional_rate_limits"];
-	if (additionalValue !== undefined && additionalValue !== null && !Array.isArray(additionalValue)) schema("additional_rate_limits must be an array");
-	const additionalLimits = (additionalValue as unknown[] | null | undefined ?? []).map((entry) => {
+	const planType = string(payload.plan_type, "plan_type");
+	const credits = parseCredits(payload.credits);
+	const defaultLimit = parseRateLimit(payload.rate_limit, "codex", null, credits, observedAt);
+	const additionalValue = payload.additional_rate_limits;
+	if (additionalValue !== undefined && additionalValue !== null && !Array.isArray(additionalValue))
+		schema("additional_rate_limits must be an array");
+	const additionalLimits = ((additionalValue as unknown[] | null | undefined) ?? []).map((entry) => {
 		const additional = record(entry, "additional rate limit");
-		const limitName = string(additional["limit_name"], "additional limit_name");
-		const limitId = string(additional["metered_feature"], "additional metered_feature").trim().toLowerCase().replaceAll("-", "_");
-		return parseRateLimit(additional["rate_limit"], limitId, limitName, credits, observedAt);
+		const limitName = string(additional.limit_name, "additional limit_name");
+		const limitId = string(additional.metered_feature, "additional metered_feature").trim().toLowerCase().replaceAll("-", "_");
+		return parseRateLimit(additional.rate_limit, limitId, limitName, credits, observedAt);
 	});
-	const reached = optionalRecord(payload["rate_limit_reached_type"], "rate limit reached type");
-	const spendControl = parseSpendControl(payload["spend_control"]);
+	const reached = optionalRecord(payload.rate_limit_reached_type, "rate limit reached type");
+	const spendControl = parseSpendControl(payload.spend_control);
 	const metrics = [...defaultLimit.metrics, ...additionalLimits.flatMap((limit) => limit.metrics)];
 	if (credits?.balance !== null && credits?.balance !== undefined) {
 		const balance = Number(credits.balance);
 		if (Number.isFinite(balance)) metrics.push(metric("codex:credits", "balance", balance, "count", observedAt));
 	}
 	if (spendControl?.individualLimit) {
-		metrics.push(metric("codex:spend-control", "used-fraction", spendControl.individualLimit.usedPercent / 100, "ratio", observedAt, {
-			resetsAt: spendControl.individualLimit.resetsAt,
-		}));
+		metrics.push(
+			metric("codex:spend-control", "used-fraction", spendControl.individualLimit.usedPercent / 100, "ratio", observedAt, {
+				resetsAt: spendControl.individualLimit.resetsAt,
+			}),
+		);
 	}
 	return {
 		stability: "experimental",
@@ -228,7 +233,7 @@ export function parseCodexUsage(value: unknown, observedAt = Date.now()): CodexU
 		additionalLimits,
 		credits,
 		spendControl,
-		rateLimitReachedType: reached ? string(reached["type"], "rate limit reached type") : null,
+		rateLimitReachedType: reached ? string(reached.type, "rate limit reached type") : null,
 		observedAt,
 		metrics,
 	};
@@ -238,7 +243,8 @@ function headerNumber(headers: Headers, name: string, integerOnly = false): numb
 	const raw = headers.get(name);
 	if (raw === null) return null;
 	const value = Number(raw);
-	if (!Number.isFinite(value) || (integerOnly && !Number.isSafeInteger(value))) throw new Error(`Codex experimental header schema changed: ${name}`);
+	if (!Number.isFinite(value) || (integerOnly && !Number.isSafeInteger(value)))
+		throw new Error(`Codex experimental header schema changed: ${name}`);
 	return value;
 }
 
@@ -282,7 +288,9 @@ export function parseCodexRateLimitHeaders(headers: Headers, observedAt = Date.n
 	}
 	const credits = parseHeaderCredits(headers);
 	const snapshots: CodexRateLimitSnapshot[] = [];
-	for (const prefix of [...prefixes].sort((left, right) => left === "x-codex" ? -1 : right === "x-codex" ? 1 : left.localeCompare(right))) {
+	for (const prefix of [...prefixes].sort((left, right) =>
+		left === "x-codex" ? -1 : right === "x-codex" ? 1 : left.localeCompare(right),
+	)) {
 		const normalized = prefix.slice(2).replaceAll("-", "_");
 		const primary = parseHeaderWindow(headers, prefix, "primary");
 		const secondary = parseHeaderWindow(headers, prefix, "secondary");

package/src/providers/codex.ts

@@ -1,21 +1,16 @@
 import { readFileSync, statSync } from "node:fs";
-import {
-	parseCodexRateLimitHeaders,
-	parseCodexUsage,
-	type CodexRateLimitSnapshot,
-	type CodexUsageSnapshot,
-} from "./codex-contracts.ts";
+import { type CodexRateLimitSnapshot, type CodexUsageSnapshot, parseCodexRateLimitHeaders, parseCodexUsage } from "./codex-contracts.ts";
 
 export {
-	parseCodexRateLimitHeaders,
-	parseCodexUsage,
-	rateLimitMetrics,
 	type CodexCredits,
 	type CodexRateLimitSnapshot,
 	type CodexSpendControl,
 	type CodexSpendLimit,
 	type CodexUsageSnapshot,
 	type CodexWindow,
+	parseCodexRateLimitHeaders,
+	parseCodexUsage,
+	rateLimitMetrics,
 } from "./codex-contracts.ts";
 
 const CHATGPT_BACKEND_BASE_URL = "https://chatgpt.com/backend-api";
@@ -54,10 +49,10 @@ export function loadCodexFileCredentials(path: string): CodexCredentials {
 		throw new Error(`Codex credentials are unavailable at ${path}`);
 	}
 	const root = record(parsed, "auth.json root");
-	const tokens = record(root["tokens"], "auth.json tokens");
+	const tokens = record(root.tokens, "auth.json tokens");
 	return {
-		accessToken: requiredString(tokens["access_token"], "access_token"),
-		accountId: requiredString(tokens["account_id"], "account_id"),
+		accessToken: requiredString(tokens.access_token, "access_token"),
+		accountId: requiredString(tokens.account_id, "account_id"),
 	};
 }
 
@@ -79,13 +74,15 @@ export class CodexSubscriptionTelemetryAdapter {
 	}
 
 	async readUsage(observedAt = Date.now()): Promise<CodexUsageSnapshot> {
-		const response = await this.transport(new Request(`${this.baseUrl}/wham/usage`, {
-			headers: {
-				authorization: `Bearer ${this.credentials.accessToken}`,
-				"chatgpt-account-id": this.credentials.accountId,
-				accept: "application/json",
-			},
-		}));
+		const response = await this.transport(
+			new Request(`${this.baseUrl}/wham/usage`, {
+				headers: {
+					authorization: `Bearer ${this.credentials.accessToken}`,
+					"chatgpt-account-id": this.credentials.accountId,
+					accept: "application/json",
+				},
+			}),
+		);
 		if (!response.ok) throw new Error(`Codex experimental usage request failed with HTTP ${response.status}`);
 		let payload: unknown;
 		try {