@hyav/pi-provider 0.1.2 → 0.1.4

package/core/runtime-config.ts

@@ -1,8 +1,10 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
 import { isValidTimeoutMs } from "./deadline.ts";
 import type { PiProviderDefinition } from "./definition.ts";
 import { getDefaultOpenRouterMetadataCachePath, OPENROUTER_MODELS_URL } from "./official-pricing.ts";
 import { validatePricingPolicy } from "./pricing-adjustments.ts";
-import type { ProviderPricingPolicy } from "./types.ts";
+import type { ProviderPricingPolicy, StoredCredentialLike } from "./types.ts";
 
 export interface PiProviderDependencies {
 	fetch: typeof globalThis.fetch;
@@ -14,8 +16,14 @@ export interface PiProviderDependencies {
 	officialPricingTimeoutMs: number;
 	officialPricingCacheTtlMs: number;
 	officialPricingMaxStaleMs: number;
+	/** Resolved Pi agent directory; empty disables disk persistence of pricing metadata. */
+	agentDir: string;
 	/** Persistent cache for OpenRouter metadata used by the pricing fallback. */
 	openRouterMetadataCachePath: string;
+	/** Read Pi's stored credential metadata; injected by the Pi entrypoint. */
+	readStoredCredential: (providerId: string) => StoredCredentialLike | undefined;
+	/** Wrap ANSI-aware text to a render width; injected by the Pi entrypoint. */
+	wrapTextWithAnsi: (text: string, width: number) => string[];
 	enableOfficialPricingFallback: boolean;
 	/** Optional Pi Provider-level price policies keyed by Provider ID. */
 	pricingPolicies?: Record<string, ProviderPricingPolicy>;
@@ -23,7 +31,68 @@ export interface PiProviderDependencies {
 
 export type PiProviderLoader = (runtime: PiProviderDependencies) => Promise<PiProviderDefinition>;
 
-const defaultDependencies: PiProviderDependencies = {
+/**
+ * Resolve Pi's agent directory without importing Pi's bundled packages, so the
+ * Jiti module graph and programmatic consumers share the same default. Mirrors
+ * Pi's `getAgentDir()`: `PI_CODING_AGENT_DIR` wins, `~/` expands to the home
+ * directory, and the fallback is `~/.pi/agent`.
+ */
+export function resolveDefaultAgentDir(): string {
+	const configured = process.env.PI_CODING_AGENT_DIR;
+	const raw =
+		configured !== undefined && configured.trim() !== "" ? configured.trim() : join(homedir(), ".pi", "agent");
+	if (raw === "~") return homedir();
+	if (raw.startsWith("~/")) return join(homedir(), raw.slice(2));
+	return raw;
+}
+
+/** Degraded fallback used only when the Pi entrypoint does not inject the real wrapper. */
+const WIDE_CHAR_RANGES: Array<[number, number]> = [
+	[0x1100, 0x115f],
+	[0x2329, 0x232a],
+	[0x2e80, 0xa4cf],
+	[0xac00, 0xd7a3],
+	[0xf900, 0xfaff],
+	[0xfe30, 0xfe4f],
+	[0xff00, 0xff60],
+	[0xffe0, 0xffe6],
+	[0x1f300, 0x1f64f],
+	[0x1f900, 0x1f9ff],
+	[0x20000, 0x2fffd],
+	[0x30000, 0x3fffd],
+];
+
+function displayWidth(text: string): number {
+	let width = 0;
+	for (const ch of text) {
+		const code = ch.codePointAt(0) ?? 0;
+		const wide = WIDE_CHAR_RANGES.some(([start, end]) => code >= start && code <= end);
+		width += wide ? 2 : 1;
+	}
+	return width;
+}
+
+function defaultWrapTextWithAnsi(text: string, width: number): string[] {
+	if (width <= 0) return [text];
+	const plain = text.replace(/\u001b\[[0-9;]*m/g, "");
+	if (displayWidth(plain) <= width) return [text];
+	const chunks: string[] = [];
+	let chunk = "";
+	for (const ch of plain) {
+		if (chunk !== "" && displayWidth(chunk) + displayWidth(ch) > width) {
+			chunks.push(chunk);
+			chunk = ch;
+		} else {
+			chunk += ch;
+		}
+	}
+	if (chunk !== "") chunks.push(chunk);
+	return chunks;
+}
+
+type DefaultDependencies = Omit<PiProviderDependencies, "agentDir" | "openRouterMetadataCachePath">;
+
+const defaultDependencies: DefaultDependencies = {
 	fetch: globalThis.fetch,
 	now: Date.now,
 	modelDiscoveryTimeoutMs: 3_000,
@@ -33,13 +102,22 @@ const defaultDependencies: PiProviderDependencies = {
 	officialPricingTimeoutMs: 3_000,
 	officialPricingCacheTtlMs: 60 * 60 * 1_000,
 	officialPricingMaxStaleMs: 24 * 60 * 60 * 1_000,
-	openRouterMetadataCachePath: getDefaultOpenRouterMetadataCachePath(),
+	readStoredCredential: () => undefined,
+	wrapTextWithAnsi: defaultWrapTextWithAnsi,
 	enableOfficialPricingFallback: true,
 	pricingPolicies: {},
 };
 
-export function getDefaultPiProviderDependencies(): PiProviderDependencies {
-	return { ...defaultDependencies };
+/**
+ * Programmatic defaults keep the resolved agent directory and its pricing cache
+ * path. The Pi entrypoint overrides `agentDir` with Pi's own resolution.
+ */
+export function getDefaultPiProviderDependencies(agentDir = resolveDefaultAgentDir()): PiProviderDependencies {
+	return {
+		...defaultDependencies,
+		agentDir,
+		openRouterMetadataCachePath: getDefaultOpenRouterMetadataCachePath(agentDir),
+	};
 }
 
 export function validatePiProviderDependencies(runtime: PiProviderDependencies): void {
@@ -64,8 +142,14 @@ export function validatePiProviderDependencies(runtime: PiProviderDependencies):
 	if (typeof runtime.officialPricingUrl !== "string" || runtime.officialPricingUrl.trim() === "") {
 		throw new Error("Pi Provider officialPricingUrl must be a non-empty string");
 	}
-	if (typeof runtime.openRouterMetadataCachePath !== "string" || runtime.openRouterMetadataCachePath.trim() === "") {
-		throw new Error("Pi Provider openRouterMetadataCachePath must be a non-empty path");
+	if (typeof runtime.openRouterMetadataCachePath !== "string") {
+		throw new Error("Pi Provider openRouterMetadataCachePath must be a string");
+	}
+	if (typeof runtime.readStoredCredential !== "function") {
+		throw new Error("Pi Provider readStoredCredential must be a function");
+	}
+	if (typeof runtime.wrapTextWithAnsi !== "function") {
+		throw new Error("Pi Provider wrapTextWithAnsi must be a function");
 	}
 	if (typeof runtime.enableOfficialPricingFallback !== "boolean") {
 		throw new Error("Pi Provider enableOfficialPricingFallback must be a boolean");
@@ -88,7 +172,7 @@ export function validatePiProviderDependencies(runtime: PiProviderDependencies):
 export function resolvePiProviderDependencies(
 	dependencies: Partial<PiProviderDependencies> = {},
 ): PiProviderDependencies {
-	const runtime = { ...defaultDependencies, ...dependencies };
+	const runtime = { ...getDefaultPiProviderDependencies(), ...dependencies };
 	if (runtime.pricingPolicies === undefined) runtime.pricingPolicies = {};
 	validatePiProviderDependencies(runtime);
 	return runtime;

package/core/runtime-entry.ts

@@ -0,0 +1,26 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { loadPackageAdapterExtensions } from "./adapter-loader.ts";
+import { createPiProviderHost } from "./host.ts";
+import type { PiProviderDependencies } from "./runtime-config.ts";
+import type { StoredCredentialLike } from "./types.ts";
+
+/** Runtime values resolved by the Pi-loaded entrypoint and injected into the Jiti graph. */
+export interface PiProviderEntry {
+	agentDir: string;
+	readStoredCredential: (providerId: string) => StoredCredentialLike | undefined;
+	wrapTextWithAnsi: (text: string, width: number) => string[];
+	adapterRoot?: string;
+	dependencies?: Partial<PiProviderDependencies>;
+}
+
+/** Runs the Pi Provider host and adapter discovery inside a single Jiti module graph. */
+export async function runPiProviderEntry(pi: ExtensionAPI, entry: PiProviderEntry): Promise<void> {
+	const piProviderHost = createPiProviderHost({
+		agentDir: entry.agentDir,
+		readStoredCredential: entry.readStoredCredential,
+		wrapTextWithAnsi: entry.wrapTextWithAnsi,
+		...entry.dependencies,
+	});
+	piProviderHost(pi);
+	await loadPackageAdapterExtensions(pi, { agentDir: entry.agentDir, userRoot: entry.adapterRoot });
+}

package/core/runtime.ts

@@ -1,6 +1,4 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { readStoredCredential } from "@earendil-works/pi-coding-agent";
-import { wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import type { PiProviderDefinition } from "./definition.ts";
 import { validatePiProviderDefinition } from "./definition.ts";
 import { LiveCheckManager, type LiveCheckResult } from "./live-check-manager.ts";
@@ -33,6 +31,7 @@ import type {
 	ProviderCost,
 	ProviderModelDraft,
 	ProviderModelMetadata,
+	StoredCredentialLike,
 } from "./types.ts";
 
 type ActiveModel = NonNullable<ExtensionContext["model"]>;
@@ -41,13 +40,17 @@ type StatusNotificationContext = Pick<ExtensionContext, "modelRegistry" | "ui">
 };
 const STATUS_WIDGET_KEY = "pi-provider-status";
 
-function readProviderCredentialMetadata(provider: string): unknown {
+function readProviderCredentialMetadata(
+	provider: string,
+	readStoredCredential: (providerId: string) => StoredCredentialLike | undefined,
+): unknown {
 	try {
 		const credential = readStoredCredential(provider);
-		if (credential?.type !== "oauth") return undefined;
+		const type = credential?.type;
+		if (type !== "oauth" && type !== "api_key") return undefined;
 		return {
-			type: "oauth",
-			...(typeof credential.teamName === "string" ? { teamName: credential.teamName } : {}),
+			type,
+			...(type === "oauth" && typeof credential?.teamName === "string" ? { teamName: credential.teamName } : {}),
 		};
 	} catch {
 		return undefined;
@@ -59,7 +62,11 @@ function clearTransientStatus(ctx: Pick<ExtensionContext, "ui">): void {
 	ctx.ui.setWidget(STATUS_WIDGET_KEY, undefined);
 }
 
-function showTransientStatus(message: string, ctx: StatusNotificationContext): boolean {
+function showTransientStatus(
+	message: string,
+	ctx: StatusNotificationContext,
+	wrapTextWithAnsi: (text: string, width: number) => string[],
+): boolean {
 	if ((ctx.mode !== "tui" && ctx.mode !== "rpc") || typeof ctx.ui.setWidget !== "function") return false;
 	// RPC cannot render component factories, so keep its plain text protocol unchanged.
 	if (ctx.mode === "rpc") {
@@ -301,7 +308,7 @@ export function installPiProviderRuntime(
 		);
 		const message = report.report;
 		if (report.warningLevel !== "hard") {
-			statusPresentationVisible = showTransientStatus(message, ctx);
+			statusPresentationVisible = showTransientStatus(message, ctx, runtime.wrapTextWithAnsi);
 			if (!statusPresentationVisible) ctx.ui.notify(message, "info");
 			return;
 		}
@@ -331,13 +338,19 @@ export function installPiProviderRuntime(
 		const { status, preflight, auth } = getStatusDetails(model, ctx);
 		let liveCheckRequested = false;
 		if ((mode === "refresh" || mode === "check") && auth.configured) {
+			const getCredentialMetadata = () =>
+				readProviderCredentialMetadata(model.provider, runtime.readStoredCredential);
 			const statusContext: StatusContextLike = {
 				model,
 				modelRegistry: ctx.modelRegistry,
 				getCredentialKey: () => ctx.modelRegistry.getApiKeyForProvider(model.provider),
-				getCredentialMetadata: () => readProviderCredentialMetadata(model.provider),
+				getCredentialMetadata,
+			};
+			const preflightContext: PreflightContextLike = {
+				model,
+				modelRegistry: ctx.modelRegistry,
+				getCredentialMetadata,
 			};
-			const preflightContext: PreflightContextLike = { model, modelRegistry: ctx.modelRegistry };
 			const refreshChecks: Array<Promise<unknown>> = [];
 			if (status) refreshChecks.push(statusManager.update(statusContext, { force: true }));
 			if (preflight) refreshChecks.push(preflightManager.update(preflightContext, { force: true }));

package/core/status-manager.ts

@@ -1,3 +1,4 @@
+import { deriveCredentialType } from "./credential-type.ts";
 import { isValidTimeoutMs, withDeadline } from "./deadline.ts";
 import { isProviderDataError, ProviderDataError } from "./errors.ts";
 import type {
@@ -226,7 +227,12 @@ export class StatusManager {
 					adapter.fetch({
 						fetch: this.fetchFn,
 						getApiKey: () => ctx.modelRegistry.getApiKeyForProvider(adapter.providerId),
-						...(ctx.getCredentialMetadata ? { getCredentialMetadata: ctx.getCredentialMetadata } : {}),
+						...(ctx.getCredentialMetadata === undefined
+							? {}
+							: {
+									getCredentialMetadata: ctx.getCredentialMetadata,
+									getCredentialType: async () => deriveCredentialType(ctx.getCredentialMetadata?.()),
+								}),
 						now: this.now,
 						signal,
 					}),

package/core/types.ts

@@ -22,6 +22,16 @@ export interface ModelMetadataStatus {
 	source?: string;
 }
 
+/**
+ * Narrow credential shape shared across Pi's isolated extension module contexts.
+ * The full Credential type comes from Pi's bundled AI package; consumers of
+ * injected credential readers must not rely on `instanceof` or extra fields.
+ */
+export interface StoredCredentialLike {
+	readonly type?: string;
+	readonly teamName?: string;
+}
+
 export interface ModelFieldSources {
 	contextWindow?: ModelFieldSource;
 	maxTokens?: ModelFieldSource;
@@ -137,6 +147,8 @@ export interface StatusContext {
 	getApiKey: () => Promise<string | undefined>;
 	/** Optional non-secret credential metadata for provider-specific account labels. */
 	getCredentialMetadata?: () => unknown;
+	/** Optional non-secret credential type ("oauth" vs "api_key") for providers with dual auth modes. */
+	getCredentialType?: () => Promise<string | undefined>;
 	signal?: AbortSignal;
 	now: () => number;
 }

package/index.ts

@@ -1,6 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { loadPackageAdapterExtensions } from "./core/adapter-loader.ts";
-import { createPiProviderHost } from "./core/host.ts";
+import { getAgentDir, readStoredCredential } from "@earendil-works/pi-coding-agent";
+import { wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { createJiti } from "jiti";
 import type { PiProviderDependencies } from "./core/runtime-config.ts";
 
 export type {
@@ -16,6 +17,8 @@ export {
 	defineStatusExtension,
 	defineTunerExtension,
 } from "./core/adapter-extensions.ts";
+export { createCatalogPreflightAdapter } from "./core/catalog-preflight.ts";
+export { withDeadline } from "./core/deadline.ts";
 export type { ProviderDataErrorLike } from "./core/errors.ts";
 export { isProviderDataError, ProviderDataError } from "./core/errors.ts";
 export type {
@@ -59,6 +62,7 @@ export {
 	parseOpenRouterPricing,
 	setPricingCache,
 } from "./core/official-pricing.ts";
+export { createOpenCodeCatalogPreflightAdapter } from "./core/opencode-preflight.ts";
 export type {
 	PreflightAdapter,
 	PreflightContext,
@@ -70,6 +74,9 @@ export type {
 } from "./core/preflight-manager.ts";
 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";
 export { applyTunerAdapters, sortTunerAdapters } from "./core/tuner-manager.ts";
@@ -109,7 +116,7 @@ export type {
 } from "./core/types.ts";
 
 export interface PiProviderExtensionOptions {
-	/** Package root containing providers, status, preflight, and tuners directories. */
+	/** User adapter root; replaces the default `<agentDir>/pi-provider` directory. */
 	adapterRoot?: string;
 	/** Host runtime dependency overrides. */
 	dependencies?: Partial<PiProviderDependencies>;
@@ -119,10 +126,27 @@ export interface PiProviderExtensionOptions {
 export function createPiProviderExtension(
 	options: PiProviderExtensionOptions = {},
 ): (pi: ExtensionAPI) => Promise<void> {
-	const piProviderHost = createPiProviderHost(options.dependencies);
 	return async (pi) => {
-		piProviderHost(pi);
-		await loadPackageAdapterExtensions(pi, options.adapterRoot);
+		const jiti = createJiti(import.meta.url, { moduleCache: true, tryNative: false });
+		const { runPiProviderEntry } = (await jiti.import("./core/runtime-entry.ts")) as {
+			runPiProviderEntry: (
+				pi: ExtensionAPI,
+				entry: {
+					agentDir: string;
+					readStoredCredential: typeof readStoredCredential;
+					wrapTextWithAnsi: typeof wrapTextWithAnsi;
+					adapterRoot?: string;
+					dependencies?: Partial<PiProviderDependencies>;
+				},
+			) => Promise<void>;
+		};
+		await runPiProviderEntry(pi, {
+			agentDir: getAgentDir(),
+			readStoredCredential,
+			wrapTextWithAnsi,
+			adapterRoot: options.adapterRoot,
+			dependencies: options.dependencies,
+		});
 	};
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyav/pi-provider",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "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,7 +1,5 @@
-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 type { PreflightAdapter } from "@hyav/pi-provider";
+import { definePreflightExtension, 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";
 

package/preflight/deepseek.ts

@@ -1,7 +1,5 @@
-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 type { PreflightAdapter } from "@hyav/pi-provider";
+import { definePreflightExtension, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
 
 export const DEEPSEEK_MODELS_URL = "https://api.deepseek.com/models";
 

package/preflight/github-copilot.ts

@@ -0,0 +1,74 @@
+import type { PreflightAdapter } from "@hyav/pi-provider";
+import { definePreflightExtension, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+
+export const COPILOT_MODELS_URL = "https://api.individual.githubcopilot.com/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 apiKey = await context.getApiKey();
+		if (!apiKey || apiKey === "proxy-managed") {
+			return { passed: false, checks: ["auth"], updatedAt: context.now() };
+		}
+		const response = await context.fetch(COPILOT_MODELS_URL, {
+			headers: {
+				Accept: "application/json",
+				"Accept-Encoding": "identity",
+				Authorization: `Bearer ${apiKey}`,
+				"User-Agent": "@hyav/pi-provider",
+			},
+			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,7 +1,5 @@
-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 type { PreflightAdapter } from "@hyav/pi-provider";
+import { definePreflightExtension, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
 
 export const GOOGLE_MODELS_URL = "https://generativelanguage.googleapis.com/v1beta/models";
 

package/preflight/groq.ts

@@ -0,0 +1,72 @@
+import type { PreflightAdapter } from "@hyav/pi-provider";
+import { definePreflightExtension, 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,
+	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;