@hyav/pi-provider 0.1.3 → 0.1.5

package/index.ts

@@ -17,7 +17,16 @@ export {
 	defineStatusExtension,
 	defineTunerExtension,
 } from "./core/adapter-extensions.ts";
+export { MAX_PROVIDER_MODEL_COUNT } from "./core/adapter-validation.ts";
+export { createCatalogPreflightAdapter } from "./core/catalog-preflight.ts";
 export { withDeadline } from "./core/deadline.ts";
+export {
+	appendBaseUrlPath,
+	authDefinesHeader,
+	getContextAuth,
+	hasBaseUrlOrigin,
+	mergeDiagnosticHeaders,
+} from "./core/diagnostic-auth.ts";
 export type { ProviderDataErrorLike } from "./core/errors.ts";
 export { isProviderDataError, ProviderDataError } from "./core/errors.ts";
 export type {
@@ -74,6 +83,7 @@ export type {
 export { getPreflightKey, normalizePreflightSnapshot, PreflightManager } from "./core/preflight-manager.ts";
 export { applyPricingAdjustment, resolvePricingDetails } from "./core/pricing-adjustments.ts";
 export { normalizeProviderModels } from "./core/provider-registration.ts";
+export type { RateLimitWindow } from "./core/ratelimit-headers.ts";
 export { parseRetryAfter } from "./core/retry-after.ts";
 export type { StatusDiagnostics, StatusErrorState } from "./core/status-manager.ts";
 export { normalizeStatusSnapshot, StatusManager } from "./core/status-manager.ts";
@@ -101,6 +111,7 @@ export type {
 	ProviderPricingPolicy,
 	ProviderPricingSource,
 	ProviderRefreshContext,
+	ProviderRequestAuth,
 	StatusAdapter,
 	StatusAmountEntry,
 	StatusContext,
@@ -114,7 +125,7 @@ export type {
 } from "./core/types.ts";
 
 export interface PiProviderExtensionOptions {
-	/** User adapter root; replaces the default `<agentDir>/pi-provider` directory. */
+	/** User adapter root; replaces the default `<agentDir>/extensions/pi-provider` directory. */
 	adapterRoot?: string;
 	/** Host runtime dependency overrides. */
 	dependencies?: Partial<PiProviderDependencies>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyav/pi-provider",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "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",

package/preflight/anthropic.ts

@@ -0,0 +1,42 @@
+import type { PreflightAdapter } from "@hyav/pi-provider";
+import { definePreflightExtension } from "@hyav/pi-provider";
+import { createCatalogPreflightAdapter } from "../core/catalog-preflight.ts";
+import { isAnthropicApiKey, isAnthropicOAuthToken } from "../status/anthropic.ts";
+
+export const ANTHROPIC_MODELS_URL = "https://api.anthropic.com/v1/models";
+export const ANTHROPIC_API_VERSION = "2023-06-01";
+
+/**
+ * Anthropic accepts API keys via x-api-key and short-lived OAuth/WIF tokens via
+ * Authorization Bearer. Only the user's own default clause receives the key, no
+ * unknown/third-party endpoint.
+ */
+function anthropicAuthHeaders(apiKey: string, credential: string | undefined): Record<string, string> {
+	const isOAuth = credential === "oauth" ? !isAnthropicApiKey(apiKey) : isAnthropicOAuthToken(apiKey);
+	if (isOAuth) return { Authorization: `Bearer ${apiKey}` };
+	return { "x-api-key": apiKey };
+}
+
+export const anthropicPreflightAdapter: PreflightAdapter = createCatalogPreflightAdapter(
+	{
+		id: "anthropic-preflight",
+		providerId: "anthropic",
+		name: "Anthropic",
+		modelsUrl: ANTHROPIC_MODELS_URL,
+		headers: { "anthropic-version": ANTHROPIC_API_VERSION },
+		authHeaders: anthropicAuthHeaders,
+	},
+	8_000,
+);
+
+export function createAnthropicPreflightAdapter(requestTimeoutMs: number): PreflightAdapter {
+	return { ...anthropicPreflightAdapter, requestTimeoutMs };
+}
+
+const anthropicPreflightExtension = definePreflightExtension({
+	id: "anthropic-preflight",
+	providerId: "anthropic",
+	create: ({ statusRequestTimeoutMs }) => createAnthropicPreflightAdapter(statusRequestTimeoutMs),
+});
+
+export default anthropicPreflightExtension;

package/preflight/cerebras.ts

@@ -0,0 +1,27 @@
+import type { PreflightAdapter } from "@hyav/pi-provider";
+import { definePreflightExtension } from "@hyav/pi-provider";
+import { createCatalogPreflightAdapter } from "../core/catalog-preflight.ts";
+
+export const CEREBRAS_MODELS_URL = "https://api.cerebras.ai/v1/models";
+
+export const cerebrasPreflightAdapter: PreflightAdapter = createCatalogPreflightAdapter(
+	{
+		id: "cerebras-preflight",
+		providerId: "cerebras",
+		name: "Cerebras",
+		modelsUrl: CEREBRAS_MODELS_URL,
+	},
+	8_000,
+);
+
+export function createCerebrasPreflightAdapter(requestTimeoutMs: number): PreflightAdapter {
+	return { ...cerebrasPreflightAdapter, requestTimeoutMs };
+}
+
+const cerebrasPreflightExtension = definePreflightExtension({
+	id: "cerebras-preflight",
+	providerId: "cerebras",
+	create: ({ statusRequestTimeoutMs }) => createCerebrasPreflightAdapter(statusRequestTimeoutMs),
+});
+
+export default cerebrasPreflightExtension;

package/preflight/charm-hyper.ts

@@ -1,5 +1,5 @@
 import type { PreflightAdapter } from "@hyav/pi-provider";
-import { definePreflightExtension, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+import { definePreflightExtension, hasBaseUrlOrigin, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
 import { hyperJsonHeaders } from "../providers/charm-hyper/constants.ts";
 import { HYPER_MODELS_URL, HYPER_PROVIDER_URL, parseHyperModels } from "../providers/charm-hyper.ts";
 
@@ -10,6 +10,7 @@ export function createCharmHyperPreflightAdapter(requestTimeoutMs: number): Pref
 		name: "Charm Hyper",
 		cacheTtlMs: 30_000,
 		requestTimeoutMs,
+		supportsModel: (model) => hasBaseUrlOrigin(model.baseUrl, HYPER_PROVIDER_URL),
 		async fetch(context) {
 			const apiKey = await context.getApiKey();
 			if (!apiKey) return { passed: false, checks: ["auth"], updatedAt: context.now() };

package/preflight/deepseek.ts

@@ -1,5 +1,5 @@
 import type { PreflightAdapter } from "@hyav/pi-provider";
-import { definePreflightExtension, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+import { definePreflightExtension, hasBaseUrlOrigin, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
 
 export const DEEPSEEK_MODELS_URL = "https://api.deepseek.com/models";
 
@@ -13,6 +13,7 @@ export const deepSeekPreflightAdapter: PreflightAdapter = {
 	name: "DeepSeek",
 	cacheTtlMs: 30_000,
 	requestTimeoutMs: 8_000,
+	supportsModel: (model) => hasBaseUrlOrigin(model.baseUrl, DEEPSEEK_MODELS_URL),
 	async fetch(context) {
 		const apiKey = await context.getApiKey();
 		if (!apiKey || apiKey === "proxy-managed") {

package/preflight/github-copilot.ts

@@ -0,0 +1,87 @@
+import type { PreflightAdapter } from "@hyav/pi-provider";
+import {
+	appendBaseUrlPath,
+	authDefinesHeader,
+	definePreflightExtension,
+	getContextAuth,
+	mergeDiagnosticHeaders,
+	ProviderDataError,
+	parseRetryAfter,
+} from "@hyav/pi-provider";
+
+export const COPILOT_BASE_URL = "https://api.individual.githubcopilot.com";
+export const COPILOT_MODELS_URL = `${COPILOT_BASE_URL}/models`;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export const githubCopilotPreflightAdapter: PreflightAdapter = {
+	id: "github-copilot-preflight",
+	providerId: "github-copilot",
+	name: "GitHub Copilot",
+	cacheTtlMs: 30_000,
+	requestTimeoutMs: 8_000,
+	async fetch(context) {
+		const auth = await getContextAuth(context);
+		const apiKey = auth.apiKey;
+		if (!apiKey || apiKey === "proxy-managed") {
+			return { passed: false, checks: ["auth"], updatedAt: context.now() };
+		}
+		const url = appendBaseUrlPath(context.model.baseUrl ?? auth.baseUrl, "models", COPILOT_BASE_URL);
+		if (!url) throw new ProviderDataError("GitHub Copilot model endpoint is unavailable", "unsupported");
+		const headers = mergeDiagnosticHeaders(auth, {
+			Accept: "application/json",
+			"Accept-Encoding": "identity",
+			"User-Agent": "@hyav/pi-provider",
+		});
+		if (!authDefinesHeader(auth, "Authorization")) headers.set("Authorization", `Bearer ${apiKey}`);
+		const response = await context.fetch(url, {
+			headers,
+			signal: context.signal,
+		});
+		if (!response.ok) {
+			throw new ProviderDataError(
+				`GitHub Copilot 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("GitHub Copilot preflight returned invalid JSON", "badjson");
+		}
+		if (!isRecord(payload) || !Array.isArray(payload.data)) {
+			throw new ProviderDataError("GitHub Copilot preflight returned invalid catalog data", "badjson");
+		}
+		const modelIds = new Set(
+			payload.data.flatMap((model) => {
+				if (!isRecord(model) || typeof model.id !== "string") return [];
+				const id = model.id.trim();
+				if (id === "") return [];
+				return [id];
+			}),
+		);
+		return {
+			passed: modelIds.has(context.model.id),
+			checks: ["endpoint", "catalog", "auth"],
+			updatedAt: context.now(),
+			httpStatus: response.status,
+		};
+	},
+};
+
+export function createGithubCopilotPreflightAdapter(requestTimeoutMs: number): PreflightAdapter {
+	return { ...githubCopilotPreflightAdapter, requestTimeoutMs };
+}
+
+const githubCopilotPreflightExtension = definePreflightExtension({
+	id: "github-copilot-preflight",
+	providerId: "github-copilot",
+	create: ({ statusRequestTimeoutMs }) => createGithubCopilotPreflightAdapter(statusRequestTimeoutMs),
+});
+
+export default githubCopilotPreflightExtension;

package/preflight/google.ts

@@ -1,5 +1,5 @@
 import type { PreflightAdapter } from "@hyav/pi-provider";
-import { definePreflightExtension, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+import { definePreflightExtension, hasBaseUrlOrigin, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
 
 export const GOOGLE_MODELS_URL = "https://generativelanguage.googleapis.com/v1beta/models";
 
@@ -28,6 +28,7 @@ export const googlePreflightAdapter: PreflightAdapter = {
 	name: "Google Gemini",
 	cacheTtlMs: 30_000,
 	requestTimeoutMs: 8_000,
+	supportsModel: (model) => hasBaseUrlOrigin(model.baseUrl, GOOGLE_MODELS_URL),
 	async fetch(context) {
 		const apiKey = await context.getApiKey();
 		if (!apiKey || apiKey === "proxy-managed") {

package/preflight/groq.ts

@@ -0,0 +1,73 @@
+import type { PreflightAdapter } from "@hyav/pi-provider";
+import { definePreflightExtension, hasBaseUrlOrigin, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+import { GROQ_MODELS_URL } from "../status/groq.ts";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export const groqPreflightAdapter: PreflightAdapter = {
+	id: "groq-preflight",
+	providerId: "groq",
+	name: "Groq",
+	cacheTtlMs: 30_000,
+	requestTimeoutMs: 8_000,
+	supportsModel: (model) => hasBaseUrlOrigin(model.baseUrl, GROQ_MODELS_URL),
+	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(GROQ_MODELS_URL, {
+			headers: {
+				Accept: "application/json",
+				"Accept-Encoding": "identity",
+				Authorization: `Bearer ${apiKey}`,
+			},
+			signal: context.signal,
+		});
+		if (!response.ok) {
+			throw new ProviderDataError(
+				`Groq 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("Groq preflight returned invalid JSON", "badjson");
+		}
+		if (!isRecord(payload) || !Array.isArray(payload.data)) {
+			throw new ProviderDataError("Groq preflight returned invalid catalog data", "badjson");
+		}
+		const activeIds = new Set(
+			payload.data.flatMap((model) => {
+				if (!isRecord(model) || typeof model.id !== "string") return [];
+				const id = model.id.trim();
+				if (id === "" || model.active === false) return [];
+				return [id];
+			}),
+		);
+		return {
+			passed: activeIds.has(context.model.id),
+			checks: ["endpoint", "auth", "catalog"],
+			updatedAt: context.now(),
+			httpStatus: response.status,
+		};
+	},
+};
+
+export function createGroqPreflightAdapter(requestTimeoutMs: number): PreflightAdapter {
+	return { ...groqPreflightAdapter, requestTimeoutMs };
+}
+
+const groqPreflightExtension = definePreflightExtension({
+	id: "groq-preflight",
+	providerId: "groq",
+	create: ({ statusRequestTimeoutMs }) => createGroqPreflightAdapter(statusRequestTimeoutMs),
+});
+
+export default groqPreflightExtension;

package/preflight/huggingface.ts

@@ -0,0 +1,27 @@
+import type { PreflightAdapter } from "@hyav/pi-provider";
+import { definePreflightExtension } from "@hyav/pi-provider";
+import { createCatalogPreflightAdapter } from "../core/catalog-preflight.ts";
+
+export const HF_ROUTER_MODELS_URL = "https://router.huggingface.co/v1/models";
+
+export const huggingFacePreflightAdapter: PreflightAdapter = createCatalogPreflightAdapter(
+	{
+		id: "huggingface-preflight",
+		providerId: "huggingface",
+		name: "Hugging Face",
+		modelsUrl: HF_ROUTER_MODELS_URL,
+	},
+	8_000,
+);
+
+export function createHuggingFacePreflightAdapter(requestTimeoutMs: number): PreflightAdapter {
+	return { ...huggingFacePreflightAdapter, requestTimeoutMs };
+}
+
+const huggingFacePreflightExtension = definePreflightExtension({
+	id: "huggingface-preflight",
+	providerId: "huggingface",
+	create: ({ statusRequestTimeoutMs }) => createHuggingFacePreflightAdapter(statusRequestTimeoutMs),
+});
+
+export default huggingFacePreflightExtension;

package/preflight/mistral.ts

@@ -0,0 +1,27 @@
+import type { PreflightAdapter } from "@hyav/pi-provider";
+import { definePreflightExtension } from "@hyav/pi-provider";
+import { createCatalogPreflightAdapter } from "../core/catalog-preflight.ts";
+
+export const MISTRAL_MODELS_URL = "https://api.mistral.ai/v1/models";
+
+export const mistralPreflightAdapter: PreflightAdapter = createCatalogPreflightAdapter(
+	{
+		id: "mistral-preflight",
+		providerId: "mistral",
+		name: "Mistral",
+		modelsUrl: MISTRAL_MODELS_URL,
+	},
+	8_000,
+);
+
+export function createMistralPreflightAdapter(requestTimeoutMs: number): PreflightAdapter {
+	return { ...mistralPreflightAdapter, requestTimeoutMs };
+}
+
+const mistralPreflightExtension = definePreflightExtension({
+	id: "mistral-preflight",
+	providerId: "mistral",
+	create: ({ statusRequestTimeoutMs }) => createMistralPreflightAdapter(statusRequestTimeoutMs),
+});
+
+export default mistralPreflightExtension;

package/preflight/moonshotai-cn.ts

@@ -0,0 +1,27 @@
+import type { PreflightAdapter } from "@hyav/pi-provider";
+import { definePreflightExtension } from "@hyav/pi-provider";
+import { createMoonshotPreflightAdapter, MOONSHOT_CN_MODELS_URL } from "./moonshotai.ts";
+
+export const moonshotaiCnPreflightAdapter: PreflightAdapter = createMoonshotPreflightAdapter(
+	MOONSHOT_CN_MODELS_URL,
+	8_000,
+	"moonshotai-cn-preflight",
+	"moonshotai-cn",
+);
+
+export function createMoonshotaiCnPreflightAdapter(requestTimeoutMs: number): PreflightAdapter {
+	return createMoonshotPreflightAdapter(
+		MOONSHOT_CN_MODELS_URL,
+		requestTimeoutMs,
+		"moonshotai-cn-preflight",
+		"moonshotai-cn",
+	);
+}
+
+const moonshotaiCnPreflightExtension = definePreflightExtension({
+	id: "moonshotai-cn-preflight",
+	providerId: "moonshotai-cn",
+	create: ({ statusRequestTimeoutMs }) => createMoonshotaiCnPreflightAdapter(statusRequestTimeoutMs),
+});
+
+export default moonshotaiCnPreflightExtension;

package/preflight/moonshotai.ts

@@ -0,0 +1,37 @@
+import type { PreflightAdapter } from "@hyav/pi-provider";
+import { definePreflightExtension } from "@hyav/pi-provider";
+import { createCatalogPreflightAdapter } from "../core/catalog-preflight.ts";
+
+export const MOONSHOT_MODELS_URL = "https://api.moonshot.ai/v1/models";
+export const MOONSHOT_CN_MODELS_URL = "https://api.moonshot.cn/v1/models";
+
+export function createMoonshotPreflightAdapter(
+	modelsUrl: string,
+	requestTimeoutMs: number,
+	id: "moonshotai-preflight" | "moonshotai-cn-preflight" = "moonshotai-preflight",
+	providerId: "moonshotai" | "moonshotai-cn" = "moonshotai",
+): PreflightAdapter {
+	return createCatalogPreflightAdapter(
+		{
+			id,
+			providerId,
+			name: providerId === "moonshotai-cn" ? "Moonshot CN (Kimi)" : "Moonshot (Kimi)",
+			modelsUrl,
+		},
+		requestTimeoutMs,
+	);
+}
+
+export const moonshotaiPreflightAdapter = createMoonshotPreflightAdapter(MOONSHOT_MODELS_URL, 8_000);
+
+export function createMoonshotaiPreflightAdapter(requestTimeoutMs: number): PreflightAdapter {
+	return { ...moonshotaiPreflightAdapter, requestTimeoutMs };
+}
+
+const moonshotaiPreflightExtension = definePreflightExtension({
+	id: "moonshotai-preflight",
+	providerId: "moonshotai",
+	create: ({ statusRequestTimeoutMs }) => createMoonshotPreflightAdapter(MOONSHOT_MODELS_URL, statusRequestTimeoutMs),
+});
+
+export default moonshotaiPreflightExtension;

package/preflight/nvidia.ts

@@ -0,0 +1,27 @@
+import type { PreflightAdapter } from "@hyav/pi-provider";
+import { definePreflightExtension } from "@hyav/pi-provider";
+import { createCatalogPreflightAdapter } from "../core/catalog-preflight.ts";
+
+export const NVIDIA_MODELS_URL = "https://integrate.api.nvidia.com/v1/models";
+
+export const nvidiaPreflightAdapter: PreflightAdapter = createCatalogPreflightAdapter(
+	{
+		id: "nvidia-preflight",
+		providerId: "nvidia",
+		name: "NVIDIA NIM",
+		modelsUrl: NVIDIA_MODELS_URL,
+	},
+	8_000,
+);
+
+export function createNvidiaPreflightAdapter(requestTimeoutMs: number): PreflightAdapter {
+	return { ...nvidiaPreflightAdapter, requestTimeoutMs };
+}
+
+const nvidiaPreflightExtension = definePreflightExtension({
+	id: "nvidia-preflight",
+	providerId: "nvidia",
+	create: ({ statusRequestTimeoutMs }) => createNvidiaPreflightAdapter(statusRequestTimeoutMs),
+});
+
+export default nvidiaPreflightExtension;

package/preflight/openai-codex.ts

@@ -1,5 +1,5 @@
 import type { PreflightAdapter } from "@hyav/pi-provider";
-import { definePreflightExtension, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+import { definePreflightExtension, hasBaseUrlOrigin, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
 import { extractCodexAccountId } from "../status/openai-codex.ts";
 
 export const CODEX_MODELS_URL = "https://chatgpt.com/backend-api/codex/models";
@@ -28,6 +28,7 @@ export const openAICodexPreflightAdapter: PreflightAdapter = {
 	name: "OpenAI Codex",
 	cacheTtlMs: 30_000,
 	requestTimeoutMs: 8_000,
+	supportsModel: (model) => hasBaseUrlOrigin(model.baseUrl, CODEX_MODELS_URL),
 	async fetch(context) {
 		const apiKey = await context.getApiKey();
 		if (!apiKey || apiKey === "proxy-managed") {

package/preflight/openai.ts

@@ -0,0 +1,27 @@
+import type { PreflightAdapter } from "@hyav/pi-provider";
+import { definePreflightExtension } from "@hyav/pi-provider";
+import { createCatalogPreflightAdapter } from "../core/catalog-preflight.ts";
+
+export const OPENAI_MODELS_URL = "https://api.openai.com/v1/models";
+
+export const openAIPreflightAdapter: PreflightAdapter = createCatalogPreflightAdapter(
+	{
+		id: "openai-preflight",
+		providerId: "openai",
+		name: "OpenAI",
+		modelsUrl: OPENAI_MODELS_URL,
+	},
+	8_000,
+);
+
+export function createOpenAIPreflightAdapter(requestTimeoutMs: number): PreflightAdapter {
+	return { ...openAIPreflightAdapter, requestTimeoutMs };
+}
+
+const openAIPreflightExtension = definePreflightExtension({
+	id: "openai-preflight",
+	providerId: "openai",
+	create: ({ statusRequestTimeoutMs }) => createOpenAIPreflightAdapter(statusRequestTimeoutMs),
+});
+
+export default openAIPreflightExtension;

package/preflight/openrouter.ts

@@ -0,0 +1,112 @@
+import type { PreflightAdapter } from "@hyav/pi-provider";
+import { definePreflightExtension, hasBaseUrlOrigin, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+import { OPENROUTER_KEY_URL } from "../status/openrouter.ts";
+
+export const OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+async function collectModelIds(context: Parameters<PreflightAdapter["fetch"]>[0]): Promise<Set<string>> {
+	const response = await context.fetch(OPENROUTER_MODELS_URL, {
+		headers: {
+			Accept: "application/json",
+			"Accept-Encoding": "identity",
+			"User-Agent": "@hyav/pi-provider",
+		},
+		signal: context.signal,
+	});
+	if (!response.ok) {
+		throw new ProviderDataError(
+			`OpenRouter 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("OpenRouter preflight returned invalid JSON", "badjson");
+	}
+	if (!isRecord(payload) || !Array.isArray(payload.data)) {
+		throw new ProviderDataError("OpenRouter preflight returned invalid catalog data", "badjson");
+	}
+	return new Set(
+		payload.data
+			.filter(isRecord)
+			.map((model) => (typeof model.id === "string" ? model.id.trim() : undefined))
+			.filter((id): id is string => id !== undefined && id !== ""),
+	);
+}
+
+async function checkCredential(context: Parameters<PreflightAdapter["fetch"]>[0], apiKey: string): Promise<number> {
+	const response = await context.fetch(OPENROUTER_KEY_URL, {
+		headers: {
+			Accept: "application/json",
+			"Accept-Encoding": "identity",
+			Authorization: `Bearer ${apiKey}`,
+			"User-Agent": "@hyav/pi-provider",
+		},
+		signal: context.signal,
+	});
+	if (response.status === 404) return response.status;
+	if (!response.ok) {
+		throw new ProviderDataError(
+			`OpenRouter 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("OpenRouter preflight returned invalid JSON", "badjson");
+	}
+	if (!isRecord(payload) || !isRecord(payload.data) || typeof payload.data.label !== "string") {
+		throw new ProviderDataError("OpenRouter preflight returned an invalid key response", "badjson");
+	}
+	return response.status;
+}
+
+export const openRouterPreflightAdapter: PreflightAdapter = {
+	id: "openrouter-preflight",
+	providerId: "openrouter",
+	name: "OpenRouter",
+	cacheTtlMs: 30_000,
+	requestTimeoutMs: 8_000,
+	supportsModel: (model) => hasBaseUrlOrigin(model.baseUrl, OPENROUTER_MODELS_URL),
+	async fetch(context) {
+		const modelIds = await collectModelIds(context);
+		const apiKey = await context.getApiKey();
+		const checks: string[] = ["endpoint", "catalog"];
+		if (!apiKey || apiKey === "proxy-managed") {
+			return { passed: modelIds.has(context.model.id), checks: [...checks, "auth"], updatedAt: context.now() };
+		}
+		// Management keys use /api/v1/credits as the only key endpoint and get 404 here.
+		const authStatus = await checkCredential(context, apiKey);
+		const authPassed = authStatus !== 404;
+		checks.push("auth");
+		return {
+			passed: modelIds.has(context.model.id) && authPassed,
+			checks,
+			updatedAt: context.now(),
+		};
+	},
+};
+
+export function createOpenRouterPreflightAdapter(requestTimeoutMs: number): PreflightAdapter {
+	return { ...openRouterPreflightAdapter, requestTimeoutMs };
+}
+
+const openRouterPreflightExtension = definePreflightExtension({
+	id: "openrouter-preflight",
+	providerId: "openrouter",
+	create: ({ statusRequestTimeoutMs }) => createOpenRouterPreflightAdapter(statusRequestTimeoutMs),
+});
+
+export default openRouterPreflightExtension;