@danypops/jittor 0.1.0

package/src/providers/codex-contracts.ts

@@ -0,0 +1,307 @@
+import type { MetricObservation } from "../domain/metric.ts";
+
+export interface CodexWindow {
+	usedPercent: number;
+	windowSeconds: number | null;
+	resetAfterSeconds: number | null;
+	resetsAt: number | null;
+}
+
+export interface CodexCredits {
+	hasCredits: boolean;
+	unlimited: boolean;
+	balance: string | null;
+}
+
+export interface CodexRateLimitSnapshot {
+	limitId: string;
+	limitName: string | null;
+	allowed: boolean | null;
+	limitReached: boolean | null;
+	primary: CodexWindow | null;
+	secondary: CodexWindow | null;
+	credits: CodexCredits | null;
+	observedAt: number;
+	metrics: MetricObservation[];
+}
+
+export interface CodexSpendLimit {
+	source: string | null;
+	limit: string;
+	used: string;
+	remaining: string;
+	usedPercent: number;
+	remainingPercent: number;
+	resetAfterSeconds: number;
+	resetsAt: number;
+}
+
+export interface CodexSpendControl {
+	reached: boolean;
+	individualLimit: CodexSpendLimit | null;
+}
+
+export interface CodexUsageSnapshot {
+	stability: "experimental";
+	planType: string;
+	defaultLimit: CodexRateLimitSnapshot;
+	additionalLimits: CodexRateLimitSnapshot[];
+	credits: CodexCredits | null;
+	spendControl: CodexSpendControl | null;
+	rateLimitReachedType: string | null;
+	observedAt: number;
+	metrics: MetricObservation[];
+}
+
+function schema(message: string): never {
+	throw new Error(`Codex experimental usage schema changed: ${message}`);
+}
+
+function record(value: unknown, name: string): Record<string, unknown> {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) schema(`${name} must be an object`);
+	return value as Record<string, unknown>;
+}
+
+function string(value: unknown, name: string): string {
+	if (typeof value !== "string" || value.length === 0) schema(`${name} must be a non-empty string`);
+	return value;
+}
+
+function optionalString(value: unknown, name: string): string | null {
+	return value === undefined || value === null ? null : string(value, name);
+}
+
+function boolean(value: unknown, name: string): boolean {
+	if (typeof value !== "boolean") schema(`${name} must be boolean`);
+	return value;
+}
+
+function finite(value: unknown, name: string): number {
+	if (typeof value !== "number" || !Number.isFinite(value)) schema(`${name} must be finite`);
+	return value;
+}
+
+function integer(value: unknown, name: string): number {
+	const parsed = finite(value, name);
+	if (!Number.isSafeInteger(parsed)) schema(`${name} must be an integer`);
+	return parsed;
+}
+
+function percent(value: unknown, name: string): number {
+	const parsed = finite(value, name);
+	if (parsed < 0 || parsed > 100) throw new Error(`Codex ${name} used percent must be between 0 and 100`);
+	return parsed;
+}
+
+function optionalRecord(value: unknown, name: string): Record<string, unknown> | null {
+	return value === undefined || value === null ? null : record(value, name);
+}
+
+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`),
+	};
+}
+
+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"),
+	};
+}
+
+function parseRateLimit(
+	value: unknown,
+	limitId: string,
+	limitName: string | null,
+	credits: CodexCredits | null,
+	observedAt: number,
+): CodexRateLimitSnapshot {
+	const rateLimit = optionalRecord(value, `${limitId} rate limit`);
+	if (!rateLimit) {
+		return { limitId, limitName, allowed: null, limitReached: null, primary: null, secondary: null, credits, observedAt, metrics: [] };
+	}
+	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`),
+		credits,
+		observedAt,
+		metrics: [],
+	};
+	snapshot.metrics = rateLimitMetrics(snapshot);
+	return snapshot;
+}
+
+function metric(
+	scope: string,
+	name: string,
+	value: number,
+	unit: MetricObservation["unit"],
+	observedAt: number,
+	attributes: Record<string, unknown> = {},
+): MetricObservation {
+	return { source: "codex-subscription", scope, metric: name, value, unit, observedAt, attributes: { experimental: true, ...attributes } };
+}
+
+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,
+	})];
+}
+
+export function rateLimitMetrics(snapshot: CodexRateLimitSnapshot): MetricObservation[] {
+	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));
+	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");
+	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,
+	};
+}
+
+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 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 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,
+		}));
+	}
+	return {
+		stability: "experimental",
+		planType,
+		defaultLimit,
+		additionalLimits,
+		credits,
+		spendControl,
+		rateLimitReachedType: reached ? string(reached["type"], "rate limit reached type") : null,
+		observedAt,
+		metrics,
+	};
+}
+
+function headerNumber(headers: Headers, name: string, integerOnly = false): number | null {
+	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}`);
+	return value;
+}
+
+function headerBoolean(headers: Headers, name: string): boolean | null {
+	const raw = headers.get(name);
+	if (raw === null) return null;
+	if (raw === "1" || raw.toLowerCase() === "true") return true;
+	if (raw === "0" || raw.toLowerCase() === "false") return false;
+	throw new Error(`Codex experimental header schema changed: ${name}`);
+}
+
+function parseHeaderWindow(headers: Headers, prefix: string, windowName: "primary" | "secondary"): CodexWindow | null {
+	const usedName = `${prefix}-${windowName}-used-percent`;
+	const minutesName = `${prefix}-${windowName}-window-minutes`;
+	const resetName = `${prefix}-${windowName}-reset-at`;
+	const used = headerNumber(headers, usedName);
+	const minutes = headerNumber(headers, minutesName, true);
+	const resetsAt = headerNumber(headers, resetName, true);
+	if (used === null) {
+		if (minutes !== null || resetsAt !== null) throw new Error(`Codex experimental header schema changed: ${usedName} missing`);
+		return null;
+	}
+	if (used < 0 || used > 100) throw new Error(`Codex ${windowName} used percent must be between 0 and 100`);
+	if (used === 0 && minutes === null && resetsAt === null) return null;
+	return { usedPercent: used, windowSeconds: minutes === null ? null : minutes * 60, resetAfterSeconds: null, resetsAt };
+}
+
+function parseHeaderCredits(headers: Headers): CodexCredits | null {
+	const hasCredits = headerBoolean(headers, "x-codex-credits-has-credits");
+	const unlimited = headerBoolean(headers, "x-codex-credits-unlimited");
+	const balance = headers.get("x-codex-credits-balance");
+	if (hasCredits === null && unlimited === null && balance === null) return null;
+	if (hasCredits === null || unlimited === null) throw new Error("Codex experimental header schema changed: incomplete credits");
+	return { hasCredits, unlimited, balance: balance?.trim() || null };
+}
+
+export function parseCodexRateLimitHeaders(headers: Headers, observedAt = Date.now()): CodexRateLimitSnapshot[] {
+	const prefixes = new Set<string>(["x-codex"]);
+	for (const name of headers.keys()) {
+		if (name.startsWith("x-") && name.endsWith("-primary-used-percent")) prefixes.add(name.slice(0, -"-primary-used-percent".length));
+	}
+	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))) {
+		const normalized = prefix.slice(2).replaceAll("-", "_");
+		const primary = parseHeaderWindow(headers, prefix, "primary");
+		const secondary = parseHeaderWindow(headers, prefix, "secondary");
+		const limitName = headers.get(`${prefix}-limit-name`)?.trim() || null;
+		if (prefix !== "x-codex" && !primary && !secondary) continue;
+		if (prefix === "x-codex" && !primary && !secondary && !credits) continue;
+		const snapshot: CodexRateLimitSnapshot = {
+			limitId: normalized,
+			limitName,
+			allowed: null,
+			limitReached: null,
+			primary,
+			secondary,
+			credits,
+			observedAt,
+			metrics: [],
+		};
+		snapshot.metrics = rateLimitMetrics(snapshot);
+		snapshots.push(snapshot);
+	}
+	return snapshots;
+}

package/src/providers/codex.ts

@@ -0,0 +1,102 @@
+import { readFileSync, statSync } from "node:fs";
+import {
+	parseCodexRateLimitHeaders,
+	parseCodexUsage,
+	type CodexRateLimitSnapshot,
+	type CodexUsageSnapshot,
+} from "./codex-contracts.ts";
+
+export {
+	parseCodexRateLimitHeaders,
+	parseCodexUsage,
+	rateLimitMetrics,
+	type CodexCredits,
+	type CodexRateLimitSnapshot,
+	type CodexSpendControl,
+	type CodexSpendLimit,
+	type CodexUsageSnapshot,
+	type CodexWindow,
+} from "./codex-contracts.ts";
+
+const CHATGPT_BACKEND_BASE_URL = "https://chatgpt.com/backend-api";
+
+export interface CodexCredentials {
+	accessToken: string;
+	accountId: string;
+}
+
+export type CodexTransport = (request: Request) => Promise<Response>;
+
+function record(value: unknown, name: string): Record<string, unknown> {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`Codex credentials schema changed: ${name}`);
+	return value as Record<string, unknown>;
+}
+
+function requiredString(value: unknown, name: string): string {
+	if (typeof value !== "string" || value.length === 0) throw new Error(`Codex credentials schema changed: ${name}`);
+	return value;
+}
+
+/** Explicit file-mode credential bridge. Codex remains responsible for refresh. */
+export function loadCodexFileCredentials(path: string): CodexCredentials {
+	try {
+		if ((statSync(path).mode & 0o077) !== 0) throw new Error("unsafe permissions");
+	} catch (error) {
+		if (error instanceof Error && error.message === "unsafe permissions") {
+			throw new Error("Codex auth.json must use private file permissions");
+		}
+		throw new Error(`Codex credentials are unavailable at ${path}`);
+	}
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		throw new Error(`Codex credentials are unavailable at ${path}`);
+	}
+	const root = record(parsed, "auth.json root");
+	const tokens = record(root["tokens"], "auth.json tokens");
+	return {
+		accessToken: requiredString(tokens["access_token"], "access_token"),
+		accountId: requiredString(tokens["account_id"], "account_id"),
+	};
+}
+
+/**
+ * Experimental adapter for the private ChatGPT Codex usage contract used by the
+ * open-source Codex CLI. This is not a documented stable personal-plan API.
+ */
+export class CodexSubscriptionTelemetryAdapter {
+	readonly stability = "experimental" as const;
+
+	constructor(
+		private readonly credentials: CodexCredentials,
+		private readonly transport: CodexTransport = fetch,
+		private readonly baseUrl = CHATGPT_BACKEND_BASE_URL,
+	) {
+		if (credentials.accessToken.length === 0 || credentials.accountId.length === 0) {
+			throw new Error("Codex access token and account id are required");
+		}
+	}
+
+	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",
+			},
+		}));
+		if (!response.ok) throw new Error(`Codex experimental usage request failed with HTTP ${response.status}`);
+		let payload: unknown;
+		try {
+			payload = await response.json();
+		} catch {
+			throw new Error("Codex experimental usage response was not JSON");
+		}
+		return parseCodexUsage(payload, observedAt);
+	}
+
+	readResponseHeaders(headers: Headers, observedAt = Date.now()): CodexRateLimitSnapshot[] {
+		return parseCodexRateLimitHeaders(headers, observedAt);
+	}
+}

package/src/providers/openrouter-contracts.ts

@@ -0,0 +1,218 @@
+import type { MetricObservation } from "../domain/metric.ts";
+
+export interface OpenRouterUsage {
+	promptTokens: number;
+	completionTokens: number;
+	totalTokens: number;
+	reasoningTokens: number;
+	cachedReadTokens: number;
+	cachedWriteTokens: number;
+	cost: number;
+	upstreamCost: number;
+}
+
+export interface OpenRouterUsageContext {
+	observedAt: number;
+	generationId: string;
+	model: string;
+}
+
+export interface OpenRouterKeySnapshot {
+	label: string | null;
+	limit: number | null;
+	remaining: number | null;
+	reset: string | null;
+	usage: number;
+	usageDaily: number | null;
+	usageWeekly: number | null;
+	usageMonthly: number | null;
+	management: boolean;
+	provisioning: boolean;
+	rateLimit: Record<string, unknown> | null;
+	observedAt: number;
+	metrics: MetricObservation[];
+}
+
+export interface OpenRouterModel {
+	id: string;
+	canonicalSlug: string;
+	name: string;
+	contextLength: number;
+	pricing: { prompt: number; completion: number; request: number };
+	supportedParameters: string[];
+	maxCompletionTokens: number | null;
+	expiresAt: string | null;
+}
+
+export interface OpenRouterGeneration {
+	id: string;
+	totalCost: number;
+	promptTokens: number;
+	completionTokens: number;
+	raw: Record<string, unknown>;
+}
+
+export interface OpenRouterAnalyticsResult {
+	data: Array<Record<string, unknown>>;
+	metadata: { truncated: boolean; [key: string]: unknown };
+}
+
+export function contractRecord(value: unknown, name: string): Record<string, unknown> {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`OpenRouter ${name} schema changed`);
+	return value as Record<string, unknown>;
+}
+
+function finite(value: unknown, name: string): number {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`OpenRouter ${name} schema changed`);
+	return value;
+}
+
+function optionalFinite(value: unknown, name: string): number | null {
+	return value === null || value === undefined ? null : finite(value, name);
+}
+
+function text(value: unknown, name: string): string {
+	if (typeof value !== "string" || value.length === 0) throw new Error(`OpenRouter ${name} schema changed`);
+	return value;
+}
+
+function optionalText(value: unknown, name: string): string | null {
+	return value === null || value === undefined ? null : text(value, name);
+}
+
+function price(value: unknown, name: string): number {
+	const parsed = Number(text(value, name));
+	if (!Number.isFinite(parsed)) throw new Error(`OpenRouter ${name} schema changed`);
+	return parsed;
+}
+
+function metric(
+	scope: string,
+	metricName: string,
+	value: number,
+	unit: MetricObservation["unit"],
+	observedAt: number,
+	attributes: Record<string, unknown> = {},
+): MetricObservation {
+	return { source: "openrouter", scope, metric: metricName, value, unit, observedAt, attributes };
+}
+
+export function parseOpenRouterUsage(value: unknown): OpenRouterUsage {
+	const usage = contractRecord(value, "usage");
+	const promptDetails = usage["prompt_tokens_details"] === undefined
+		? {}
+		: contractRecord(usage["prompt_tokens_details"], "prompt token details");
+	const costDetails = usage["cost_details"] === undefined
+		? {}
+		: contractRecord(usage["cost_details"], "cost details");
+	return {
+		promptTokens: finite(usage["prompt_tokens"], "prompt tokens"),
+		completionTokens: finite(usage["completion_tokens"], "completion tokens"),
+		totalTokens: finite(usage["total_tokens"], "total tokens"),
+		reasoningTokens: optionalFinite(usage["reasoning_tokens"], "reasoning tokens") ?? 0,
+		cachedReadTokens: optionalFinite(promptDetails["cached_tokens"], "cached tokens") ?? 0,
+		cachedWriteTokens: optionalFinite(promptDetails["cache_write_tokens"], "cache write tokens") ?? 0,
+		cost: finite(usage["cost"], "cost"),
+		upstreamCost: optionalFinite(costDetails["upstream_inference_cost"], "upstream inference cost") ?? 0,
+	};
+}
+
+export function openRouterUsageMetrics(usage: OpenRouterUsage, context: OpenRouterUsageContext): MetricObservation[] {
+	const attributes = { generationId: context.generationId, model: context.model };
+	const token = (name: string, value: number) => metric("response", name, value, "tokens", context.observedAt, attributes);
+	return [
+		token("prompt-tokens", usage.promptTokens),
+		token("completion-tokens", usage.completionTokens),
+		token("total-tokens", usage.totalTokens),
+		token("reasoning-tokens", usage.reasoningTokens),
+		token("cached-read-tokens", usage.cachedReadTokens),
+		token("cached-write-tokens", usage.cachedWriteTokens),
+		metric("response", "cost", usage.cost, "usd", context.observedAt, attributes),
+		metric("response", "upstream-cost", usage.upstreamCost, "usd", context.observedAt, attributes),
+	];
+}
+
+export function parseOpenRouterKey(rootValue: unknown, observedAt: number): OpenRouterKeySnapshot {
+	const root = contractRecord(rootValue, "key response");
+	const data = contractRecord(root["data"], "key data");
+	const label = optionalText(data["label"], "key label");
+	const limit = optionalFinite(data["limit"], "key limit");
+	const remaining = optionalFinite(data["limit_remaining"], "key limit remaining");
+	const usage = finite(data["usage"], "key usage");
+	const snapshot: OpenRouterKeySnapshot = {
+		label,
+		limit,
+		remaining,
+		reset: optionalText(data["limit_reset"], "key limit reset"),
+		usage,
+		usageDaily: optionalFinite(data["usage_daily"], "daily usage"),
+		usageWeekly: optionalFinite(data["usage_weekly"], "weekly usage"),
+		usageMonthly: optionalFinite(data["usage_monthly"], "monthly usage"),
+		management: data["is_management_key"] === true,
+		provisioning: data["is_provisioning_key"] === true,
+		rateLimit: data["rate_limit"] === undefined || data["rate_limit"] === null ? null : contractRecord(data["rate_limit"], "rate limit"),
+		observedAt,
+		metrics: [],
+	};
+	const scope = `key:${label ?? "default"}`;
+	const add = (name: string, value: number | null): void => {
+		if (value !== null) snapshot.metrics.push(metric(scope, name, value, "usd", observedAt));
+	};
+	add("usage", usage);
+	add("usage-daily", snapshot.usageDaily);
+	add("usage-weekly", snapshot.usageWeekly);
+	add("usage-monthly", snapshot.usageMonthly);
+	add("limit", limit);
+	add("limit-remaining", remaining);
+	if (limit !== null && limit > 0) snapshot.metrics.push(metric(scope, "used-fraction", usage / limit, "ratio", observedAt));
+	return snapshot;
+}
+
+export function parseOpenRouterModels(rootValue: unknown): OpenRouterModel[] {
+	const root = contractRecord(rootValue, "models response");
+	if (!Array.isArray(root["data"])) throw new Error("OpenRouter models schema changed");
+	return root["data"].map((value) => {
+		const model = contractRecord(value, "model");
+		const pricing = contractRecord(model["pricing"], "model pricing");
+		const provider = contractRecord(model["top_provider"], "top provider");
+		if (!Array.isArray(model["supported_parameters"]) || !model["supported_parameters"].every((parameter) => typeof parameter === "string")) {
+			throw new Error("OpenRouter supported parameters schema changed");
+		}
+		return {
+			id: text(model["id"], "model id"),
+			canonicalSlug: text(model["canonical_slug"], "canonical slug"),
+			name: text(model["name"], "model name"),
+			contextLength: finite(model["context_length"], "context length"),
+			pricing: {
+				prompt: price(pricing["prompt"], "prompt pricing"),
+				completion: price(pricing["completion"], "completion pricing"),
+				request: price(pricing["request"], "request pricing"),
+			},
+			supportedParameters: model["supported_parameters"] as string[],
+			maxCompletionTokens: optionalFinite(provider["max_completion_tokens"], "max completion tokens"),
+			expiresAt: optionalText(model["expiration_date"], "expiration date"),
+		};
+	});
+}
+
+export function parseOpenRouterGeneration(rootValue: unknown): OpenRouterGeneration {
+	const root = contractRecord(rootValue, "generation response");
+	const data = contractRecord(root["data"], "generation data");
+	return {
+		id: text(data["id"], "generation id"),
+		totalCost: finite(data["total_cost"], "generation cost"),
+		promptTokens: finite(data["tokens_prompt"], "generation prompt tokens"),
+		completionTokens: finite(data["tokens_completion"], "generation completion tokens"),
+		raw: data,
+	};
+}
+
+export function parseOpenRouterAnalytics(rootValue: unknown): OpenRouterAnalyticsResult {
+	const root = contractRecord(rootValue, "analytics response");
+	if (!Array.isArray(root["data"]) || !root["data"].every((row) => typeof row === "object" && row !== null && !Array.isArray(row))) {
+		throw new Error("OpenRouter analytics data schema changed");
+	}
+	const metadata = contractRecord(root["metadata"], "analytics metadata");
+	if (typeof metadata["truncated"] !== "boolean") throw new Error("OpenRouter analytics metadata schema changed");
+	return { data: root["data"] as Array<Record<string, unknown>>, metadata: metadata as OpenRouterAnalyticsResult["metadata"] };
+}