@hyav/pi-provider 0.1.0-oidc-bootstrap.0

package/core/types.ts

@@ -0,0 +1,175 @@
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+	ProviderConfig,
+	ProviderModelConfig,
+} from "@earendil-works/pi-coding-agent";
+
+export type ThinkingLevel = ReturnType<ExtensionAPI["getThinkingLevel"]>;
+
+export type ProviderCost = ProviderModelConfig["cost"];
+export type ProviderModel = ProviderModelConfig;
+export type PricingSku = "input" | "output" | "cacheRead" | "cacheWrite";
+/** Pricing provenance used by Provider Kit sidecars; not added to Pi model objects. */
+export type ProviderPricingSource = "provider" | "fallback" | "official";
+export type ModelPricingSource = ProviderPricingSource | "native";
+export type ModelFieldSource = ProviderPricingSource | "native" | "default";
+export type ModelMetadataState = "fresh" | "stale" | "checking" | "unavailable";
+
+export interface ModelMetadataStatus {
+	state: ModelMetadataState;
+	updatedAt?: number;
+	source?: string;
+}
+
+export interface ModelFieldSources {
+	contextWindow?: ModelFieldSource;
+	maxTokens?: ModelFieldSource;
+	input?: ModelFieldSource;
+	reasoning?: ModelFieldSource;
+}
+
+export interface ProviderPricingAdjustment {
+	/** 0.8 means a 20% discount; values above 1 represent a markup. */
+	multiplier: number;
+	label: string;
+	source?: string;
+	/** Whether this explicit adjustment may be applied to a reference price. */
+	appliesToReference?: boolean;
+	appliesTo?: readonly PricingSku[];
+}
+
+export interface ProviderPricingPolicy {
+	defaultAdjustment?: ProviderPricingAdjustment;
+	models?: Record<string, ProviderPricingAdjustment>;
+}
+
+export interface ModelPricingDetails {
+	known: boolean;
+	source: ModelPricingSource | "none";
+	baseCost?: ProviderCost;
+	effectiveCost?: ProviderCost;
+	adjustment?: ProviderPricingAdjustment;
+	note?: string;
+}
+
+export interface ModelQualityScore {
+	source: string;
+	benchmark: string;
+	category: string;
+	metric: "elo" | "rating" | "score" | "ips";
+	value: number;
+	rank?: number;
+	winRate?: number;
+	confidenceInterval?: {
+		lower: number;
+		upper: number;
+	};
+}
+
+export interface ProviderModelMetadata {
+	pricing: ModelPricingDetails;
+	fieldSources?: ModelFieldSources;
+	quality?: ModelQualityScore[];
+}
+
+export type ProviderModelDraft = Partial<ProviderModel> &
+	Pick<ProviderModel, "id"> & {
+		pricingSource?: ProviderPricingSource;
+		pricingAdjustment?: ProviderPricingAdjustment;
+	};
+export type ProviderRefreshContext = Parameters<NonNullable<ProviderConfig["refreshModels"]>>[0];
+export type ActiveModel = NonNullable<ExtensionContext["model"]>;
+export type TunerContext = Pick<ExtensionContext, "model">;
+
+export type ProviderDefinition = Omit<ProviderConfig, "models" | "refreshModels"> & {
+	name: string;
+	baseUrl: string;
+	apiKey: string;
+	api: ProviderConfig["api"];
+	headers?: ProviderConfig["headers"];
+	oauth?: ProviderConfig["oauth"];
+	models: ProviderModelDraft[];
+	refreshModels?: (context: ProviderRefreshContext) => Promise<ProviderModelDraft[]>;
+};
+
+export type ModelCatalogSource = "static" | "live" | "fallback";
+
+export interface ModelCatalogStatus {
+	source: ModelCatalogSource;
+	modelCount: number;
+	updatedAt?: number;
+	lastError?: string;
+}
+
+export interface StatusTextEntry {
+	kind: "text";
+	id: string;
+	label: string;
+	value: string;
+}
+
+export interface StatusAmountEntry {
+	kind: "amount";
+	id: string;
+	label: string;
+	value: number;
+	unit: string;
+}
+
+export interface StatusWindowEntry {
+	kind: "window";
+	id: string;
+	label: string;
+	remainingPercent: number;
+	resetAt?: number;
+}
+
+export type StatusEntry = StatusTextEntry | StatusAmountEntry | StatusWindowEntry;
+
+export interface StatusSnapshot {
+	entries: StatusEntry[];
+	updatedAt: number;
+}
+
+export interface StatusContext {
+	fetch: typeof globalThis.fetch;
+	getApiKey: () => Promise<string | undefined>;
+	/** Optional non-secret credential metadata for provider-specific account labels. */
+	getCredentialMetadata?: () => unknown;
+	signal?: AbortSignal;
+	now: () => number;
+}
+
+export interface StatusAdapter {
+	id: string;
+	providerId: string;
+	name: string;
+	cacheTtlMs: number;
+	requestTimeoutMs: number;
+	fetch(context: StatusContext): Promise<StatusSnapshot>;
+}
+
+export interface TunerAdapter {
+	id: string;
+	/** Lower priorities run first. Ties use deterministic Adapter ID order. */
+	priority?: number;
+	matches(context: TunerContext, payload: unknown): boolean;
+	transform(payload: unknown, context: TunerContext): unknown | undefined | Promise<unknown | undefined>;
+}
+
+export interface ProviderAdapter {
+	id: string;
+	provider: ProviderDefinition;
+	/** Optional explicit price adjustments owned by this Provider. */
+	pricing?: ProviderPricingPolicy;
+	catalog?: ModelCatalogStatus;
+	/** @internal Draft state shared across isolated Adapter and Host contexts. */
+	registration?: {
+		modelDrafts: ProviderModelDraft[];
+		normalizedModels?: ProviderModel[];
+		modelMetadata?: Record<string, ProviderModelMetadata>;
+	};
+}
+
+export type PiApi = ExtensionAPI;

package/index.ts

@@ -0,0 +1,108 @@
+import { createProviderKitHost } from "./core/host.ts";
+
+export type {
+	AdapterExtensionContext,
+	PreflightExtensionDefinition,
+	ProviderExtensionDefinition,
+	StatusExtensionDefinition,
+	TunerExtensionDefinition,
+} from "./core/adapter-extensions.ts";
+export {
+	definePreflightExtension,
+	defineProviderExtension,
+	defineStatusExtension,
+	defineTunerExtension,
+} from "./core/adapter-extensions.ts";
+export type { ProviderDataErrorLike } from "./core/errors.ts";
+export { isProviderDataError, ProviderDataError } from "./core/errors.ts";
+export type {
+	ProviderKitDefinition,
+	ProviderKitDependencies,
+	ProviderKitLoader,
+	ProviderKitRuntimeController,
+} from "./core/extension.ts";
+export {
+	createProviderKitRuntime,
+	getDefaultProviderKitDependencies,
+	installProviderKitRuntime,
+	prepareProviderRegistration,
+	registerProviderAdapter,
+	resolveProviderKitDependencies,
+	validateProviderKitDefinition,
+	validateProviderKitDependencies,
+} from "./core/extension.ts";
+export { createProviderKitHost } from "./core/host.ts";
+export type {
+	LiveCheckContextLike,
+	LiveCheckDiagnostics,
+	LiveCheckErrorState,
+	LiveCheckResult,
+	LiveCheckSnapshot,
+} from "./core/live-check-manager.ts";
+export { getLiveCheckKey, LIVE_CHECK_SCOPE, LiveCheckManager } from "./core/live-check-manager.ts";
+export {
+	applyOfficialModelCosts,
+	clearPricingCache,
+	fetchOfficialPricing,
+	findOfficialCost,
+	findOfficialMeta,
+	getDefaultOpenRouterMetadataCachePath,
+	getPricingCache,
+	getPricingCacheAge,
+	type OfficialModelMeta,
+	type OfficialPricingFetchOptions,
+	OPENROUTER_MODELS_URL,
+	parseOpenRouterModels,
+	parseOpenRouterPricing,
+	setPricingCache,
+} from "./core/official-pricing.ts";
+export type {
+	PreflightAdapter,
+	PreflightContext,
+	PreflightContextLike,
+	PreflightDiagnostics,
+	PreflightErrorState,
+	PreflightModel,
+	PreflightSnapshot,
+} from "./core/preflight-manager.ts";
+export { getPreflightKey, normalizePreflightSnapshot, PreflightManager } from "./core/preflight-manager.ts";
+export { applyPricingAdjustment, resolvePricingDetails } from "./core/pricing-adjustments.ts";
+export type { StatusDiagnostics, StatusErrorState } from "./core/status-manager.ts";
+export { normalizeStatusSnapshot, StatusManager } from "./core/status-manager.ts";
+export { applyTunerAdapters, sortTunerAdapters } from "./core/tuner-manager.ts";
+export type {
+	ActiveModel,
+	ModelCatalogSource,
+	ModelCatalogStatus,
+	ModelFieldSource,
+	ModelFieldSources,
+	ModelMetadataState,
+	ModelMetadataStatus,
+	ModelPricingDetails,
+	ModelPricingSource,
+	ModelQualityScore,
+	PiApi,
+	PricingSku,
+	ProviderAdapter,
+	ProviderCost,
+	ProviderDefinition,
+	ProviderModel,
+	ProviderModelDraft,
+	ProviderModelMetadata,
+	ProviderPricingAdjustment,
+	ProviderPricingPolicy,
+	ProviderPricingSource,
+	ProviderRefreshContext,
+	StatusAdapter,
+	StatusAmountEntry,
+	StatusContext,
+	StatusEntry,
+	StatusSnapshot,
+	StatusTextEntry,
+	StatusWindowEntry,
+	ThinkingLevel,
+	TunerAdapter,
+	TunerContext,
+} from "./core/types.ts";
+
+export default createProviderKitHost();

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@hyav/pi-provider",
+  "version": "0.1.0-oidc-bootstrap.0",
+  "description": "Provider extension toolkit for Pi to integrate and manage custom LLM providers with dynamic models, request tuners, and account status.",
+  "author": "hyav",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hyav/pi-provider.git"
+  },
+  "homepage": "https://github.com/hyav/pi-provider#readme",
+  "bugs": {
+    "url": "https://github.com/hyav/pi-provider/issues"
+  },
+  "type": "module",
+  "main": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./package.json": "./package.json"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "provider",
+    "provider-kit",
+    "charm-hyper",
+    "llm"
+  ],
+  "scripts": {
+    "test": "tsx --test test/**/*.test.ts",
+    "typecheck": "tsc --noEmit",
+    "check": "biome check . && tsc --noEmit",
+    "audit:runtime": "npm audit --omit=dev --audit-level=high",
+    "audit:all": "npm audit --audit-level=high",
+    "artifact:check": "node scripts/check-package.mjs",
+    "release:check": "node scripts/check-release.mjs",
+    "prepublishOnly": "npm run audit:runtime && npm run audit:all && npm run release:check && npm run check && npm test && npm run artifact:check"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.3.5",
+    "@earendil-works/pi-coding-agent": "0.84.1",
+    "@earendil-works/pi-tui": "0.84.1",
+    "@types/node": "22.20.1",
+    "tsx": "4.23.11",
+    "typescript": "5.9.3"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts",
+      "./providers/*.ts",
+      "./status/*.ts",
+      "./preflight/*.ts",
+      "./tuners/*.ts"
+    ]
+  },
+  "files": [
+    "index.ts",
+    "core",
+    "providers",
+    "preflight",
+    "status",
+    "tuners",
+    "README.md",
+    "README.zh-CN.md",
+    "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "SECURITY.md",
+    "SUPPORT.md",
+    "LICENSE"
+  ]
+}

package/preflight/charm-hyper.ts

@@ -0,0 +1,62 @@
+import { definePreflightExtension } from "../core/adapter-extensions.ts";
+import { ProviderDataError } from "../core/errors.ts";
+import type { PreflightAdapter } from "../core/preflight-manager.ts";
+import { parseRetryAfter } from "../core/retry-after.ts";
+import { hyperJsonHeaders } from "../providers/charm-hyper/constants.ts";
+import { HYPER_MODELS_URL, HYPER_PROVIDER_URL, parseHyperModels } from "../providers/charm-hyper.ts";
+
+export function createCharmHyperPreflightAdapter(requestTimeoutMs: number): PreflightAdapter {
+	return {
+		id: "charm-hyper-preflight",
+		providerId: "charm-hyper",
+		name: "Charm Hyper",
+		cacheTtlMs: 30_000,
+		requestTimeoutMs,
+		async fetch(context) {
+			const apiKey = await context.getApiKey();
+			if (!apiKey) return { passed: false, checks: ["auth"], updatedAt: context.now() };
+			const headers = new Headers(hyperJsonHeaders());
+			if (apiKey !== "proxy-managed") headers.set("Authorization", `Bearer ${apiKey}`);
+			let endpoint = HYPER_PROVIDER_URL;
+			let response = await context.fetch(endpoint, { headers, signal: context.signal });
+			if (response.status === 404) {
+				endpoint = HYPER_MODELS_URL;
+				response = await context.fetch(endpoint, { headers, signal: context.signal });
+			}
+			if (!response.ok) {
+				throw new ProviderDataError(
+					`Charm Hyper preflight failed: HTTP ${response.status}`,
+					`http${response.status}`,
+					parseRetryAfter(response.headers.get("retry-after"), context.now()),
+					response.status,
+				);
+			}
+			let payload: unknown;
+			try {
+				payload = await response.json();
+			} catch {
+				throw new ProviderDataError(`Charm Hyper preflight returned invalid JSON from ${endpoint}`, "badjson");
+			}
+			const models = parseHyperModels(payload);
+			if (models.length === 0) {
+				throw new ProviderDataError("Charm Hyper preflight returned invalid catalog data", "badjson");
+			}
+			const modelIds = new Set(models.map(({ id }) => id.toLowerCase()));
+			const modelMatched = modelIds.has(context.model.id.toLowerCase());
+			return {
+				passed: modelMatched,
+				checks: ["endpoint", "auth", "catalog"],
+				updatedAt: context.now(),
+				httpStatus: response.status,
+			};
+		},
+	};
+}
+
+const charmHyperPreflightExtension = definePreflightExtension({
+	id: "charm-hyper-preflight",
+	providerId: "charm-hyper",
+	create: ({ statusRequestTimeoutMs }) => createCharmHyperPreflightAdapter(statusRequestTimeoutMs),
+});
+
+export default charmHyperPreflightExtension;

package/preflight/deepseek.ts

@@ -0,0 +1,73 @@
+import { definePreflightExtension } from "../core/adapter-extensions.ts";
+import { ProviderDataError } from "../core/errors.ts";
+import type { PreflightAdapter } from "../core/preflight-manager.ts";
+import { parseRetryAfter } from "../core/retry-after.ts";
+
+export const DEEPSEEK_MODELS_URL = "https://api.deepseek.com/models";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export const deepSeekPreflightAdapter: PreflightAdapter = {
+	id: "deepseek-preflight",
+	providerId: "deepseek",
+	name: "DeepSeek",
+	cacheTtlMs: 30_000,
+	requestTimeoutMs: 8_000,
+	async fetch(context) {
+		const apiKey = await context.getApiKey();
+		if (!apiKey || apiKey === "proxy-managed") {
+			return { passed: false, checks: ["auth"], updatedAt: context.now() };
+		}
+		const response = await context.fetch(DEEPSEEK_MODELS_URL, {
+			headers: {
+				Accept: "application/json",
+				"Accept-Encoding": "identity",
+				Authorization: `Bearer ${apiKey}`,
+			},
+			signal: context.signal,
+		});
+		if (!response.ok) {
+			throw new ProviderDataError(
+				`DeepSeek preflight failed: HTTP ${response.status}`,
+				`http${response.status}`,
+				parseRetryAfter(response.headers.get("retry-after"), context.now()),
+				response.status,
+			);
+		}
+		let payload: unknown;
+		try {
+			payload = await response.json();
+		} catch {
+			throw new ProviderDataError("DeepSeek preflight returned invalid JSON", "badjson");
+		}
+		if (!isRecord(payload) || !Array.isArray(payload.data)) {
+			throw new ProviderDataError("DeepSeek preflight returned invalid catalog data", "badjson");
+		}
+		const modelIds = new Set(
+			payload.data
+				.filter(isRecord)
+				.map((model) => (typeof model.id === "string" ? model.id.trim() : undefined))
+				.filter((id): id is string => id !== undefined && id !== ""),
+		);
+		return {
+			passed: modelIds.has(context.model.id),
+			checks: ["endpoint", "auth", "catalog"],
+			updatedAt: context.now(),
+			httpStatus: response.status,
+		};
+	},
+};
+
+export function createDeepSeekPreflightAdapter(requestTimeoutMs: number): PreflightAdapter {
+	return { ...deepSeekPreflightAdapter, requestTimeoutMs };
+}
+
+const deepSeekPreflightExtension = definePreflightExtension({
+	id: "deepseek-preflight",
+	providerId: "deepseek",
+	create: ({ statusRequestTimeoutMs }) => createDeepSeekPreflightAdapter(statusRequestTimeoutMs),
+});
+
+export default deepSeekPreflightExtension;

package/preflight/google.ts

@@ -0,0 +1,89 @@
+import { definePreflightExtension } from "../core/adapter-extensions.ts";
+import { ProviderDataError } from "../core/errors.ts";
+import type { PreflightAdapter } from "../core/preflight-manager.ts";
+import { parseRetryAfter } from "../core/retry-after.ts";
+
+export const GOOGLE_MODELS_URL = "https://generativelanguage.googleapis.com/v1beta/models";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function isStringArray(value: unknown): value is string[] {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
+function catalogModelIds(value: Record<string, unknown>): string[] {
+	const ids: string[] = [];
+	if (typeof value.baseModelId === "string" && value.baseModelId.trim() !== "") {
+		ids.push(value.baseModelId.trim());
+	}
+	if (typeof value.name === "string" && value.name.trim() !== "") {
+		ids.push(value.name.trim().replace(/^models\//, ""));
+	}
+	return ids;
+}
+
+export const googlePreflightAdapter: PreflightAdapter = {
+	id: "google-preflight",
+	providerId: "google",
+	name: "Google Gemini",
+	cacheTtlMs: 30_000,
+	requestTimeoutMs: 8_000,
+	async fetch(context) {
+		const apiKey = await context.getApiKey();
+		if (!apiKey || apiKey === "proxy-managed") {
+			return { passed: false, checks: ["auth"], updatedAt: context.now() };
+		}
+		const response = await context.fetch(GOOGLE_MODELS_URL, {
+			headers: {
+				Accept: "application/json",
+				"Accept-Encoding": "identity",
+				"x-goog-api-key": apiKey,
+			},
+			signal: context.signal,
+		});
+		if (!response.ok) {
+			throw new ProviderDataError(
+				`Google preflight failed: HTTP ${response.status}`,
+				`http${response.status}`,
+				parseRetryAfter(response.headers.get("retry-after"), context.now()),
+				response.status,
+			);
+		}
+		let payload: unknown;
+		try {
+			payload = await response.json();
+		} catch {
+			throw new ProviderDataError("Google preflight returned invalid JSON", "badjson");
+		}
+		if (!isRecord(payload) || !Array.isArray(payload.models)) {
+			throw new ProviderDataError("Google preflight returned invalid catalog data", "badjson");
+		}
+		const modelIds = new Set(
+			payload.models.flatMap((value) => {
+				if (!isRecord(value)) return [];
+				const methods = value.supportedGenerationMethods;
+				return isStringArray(methods) && methods.includes("generateContent") ? catalogModelIds(value) : [];
+			}),
+		);
+		return {
+			passed: modelIds.has(context.model.id),
+			checks: ["endpoint", "auth", "catalog"],
+			updatedAt: context.now(),
+			httpStatus: response.status,
+		};
+	},
+};
+
+export function createGooglePreflightAdapter(requestTimeoutMs: number): PreflightAdapter {
+	return { ...googlePreflightAdapter, requestTimeoutMs };
+}
+
+const googlePreflightExtension = definePreflightExtension({
+	id: "google-preflight",
+	providerId: "google",
+	create: ({ statusRequestTimeoutMs }) => createGooglePreflightAdapter(statusRequestTimeoutMs),
+});
+
+export default googlePreflightExtension;

package/preflight/openai-codex.ts

@@ -0,0 +1,88 @@
+import { definePreflightExtension } from "../core/adapter-extensions.ts";
+import { ProviderDataError } from "../core/errors.ts";
+import type { PreflightAdapter } from "../core/preflight-manager.ts";
+import { parseRetryAfter } from "../core/retry-after.ts";
+import { extractCodexAccountId } from "../status/openai-codex.ts";
+
+export const CODEX_MODELS_URL = "https://chatgpt.com/backend-api/codex/models";
+export const CODEX_MODELS_CLIENT_VERSION = "0.144.1";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function codexModelIds(payload: unknown): Set<string> {
+	if (!isRecord(payload) || !Array.isArray(payload.models)) {
+		throw new ProviderDataError("OpenAI Codex preflight returned invalid catalog data", "badjson");
+	}
+	return new Set(
+		payload.models
+			.filter(isRecord)
+			.filter((model) => model.visibility === "list" && model.supported_in_api !== false)
+			.map((model) => (typeof model.slug === "string" ? model.slug.trim() : undefined))
+			.filter((id): id is string => id !== undefined && id !== ""),
+	);
+}
+
+export const openAICodexPreflightAdapter: PreflightAdapter = {
+	id: "openai-codex-preflight",
+	providerId: "openai-codex",
+	name: "OpenAI Codex",
+	cacheTtlMs: 30_000,
+	requestTimeoutMs: 8_000,
+	async fetch(context) {
+		const apiKey = await context.getApiKey();
+		if (!apiKey || apiKey === "proxy-managed") {
+			return { passed: false, checks: ["auth"], updatedAt: context.now() };
+		}
+		const accountId = extractCodexAccountId(apiKey);
+		if (!accountId) {
+			throw new ProviderDataError("OpenAI Codex OAuth token has no account ID", "auth");
+		}
+		const url = `${CODEX_MODELS_URL}?client_version=${encodeURIComponent(CODEX_MODELS_CLIENT_VERSION)}`;
+		const response = await context.fetch(url, {
+			headers: {
+				Accept: "application/json",
+				"Accept-Encoding": "identity",
+				Authorization: `Bearer ${apiKey}`,
+				"chatgpt-account-id": accountId,
+				originator: "pi",
+				"User-Agent": "@hyav/pi-provider",
+			},
+			signal: context.signal,
+		});
+		if (!response.ok) {
+			throw new ProviderDataError(
+				`OpenAI Codex preflight failed: HTTP ${response.status}`,
+				`http${response.status}`,
+				parseRetryAfter(response.headers.get("retry-after"), context.now()),
+				response.status,
+			);
+		}
+		let payload: unknown;
+		try {
+			payload = await response.json();
+		} catch {
+			throw new ProviderDataError("OpenAI Codex preflight returned invalid JSON", "badjson");
+		}
+		const modelIds = codexModelIds(payload);
+		return {
+			passed: modelIds.has(context.model.id),
+			checks: ["endpoint", "auth", "catalog"],
+			updatedAt: context.now(),
+			httpStatus: response.status,
+		};
+	},
+};
+
+export function createOpenAICodexPreflightAdapter(requestTimeoutMs: number): PreflightAdapter {
+	return { ...openAICodexPreflightAdapter, requestTimeoutMs };
+}
+
+const openAICodexPreflightExtension = definePreflightExtension({
+	id: "openai-codex-preflight",
+	providerId: "openai-codex",
+	create: ({ statusRequestTimeoutMs }) => createOpenAICodexPreflightAdapter(statusRequestTimeoutMs),
+});
+
+export default openAICodexPreflightExtension;