@hyav/pi-provider 0.1.4 → 0.1.6

package/core/provider-registration.ts

@@ -1,4 +1,5 @@
-import type { ExtensionAPI, ProviderConfig } from "@earendil-works/pi-coding-agent";
+import type { ProviderConfig } from "@earendil-works/pi-coding-agent";
+import { validateProviderModelDrafts } from "./adapter-validation.ts";
 import { applyOfficialModelCosts, findOfficialMeta, type OfficialModelMeta } from "./official-pricing.ts";
 import { resolvePricingDetails } from "./pricing-adjustments.ts";
 import type { PiProviderDependencies } from "./runtime-config.ts";
@@ -16,6 +17,11 @@ import type {
 const DEFAULT_CONTEXT_WINDOW = 128_000;
 const DEFAULT_MAX_TOKENS = 16_384;
 
+type ProviderRegistrationApi = {
+	registerProvider(name: string, config: ProviderConfig): void;
+	unregisterProvider?(name: string): void;
+};
+
 function finiteNonNegative(value: unknown): number {
 	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
 }
@@ -83,6 +89,7 @@ export function normalizeProviderModel(model: ProviderModelDraft): ProviderModel
 }
 
 export function normalizeProviderModels(models: ProviderModelDraft[]): ProviderModel[] {
+	validateProviderModelDrafts(models);
 	const seen = new Set<string>();
 	return models.map((model) => {
 		const normalized = normalizeProviderModel(model);
@@ -113,6 +120,7 @@ function resolveModelRegistration(
 	modelDrafts: ProviderModelDraft[],
 	officialPricing: Record<string, OfficialModelMeta>,
 ): { models: ProviderModel[]; modelMetadata: Record<string, ProviderModelMetadata> } {
+	validateProviderModelDrafts(modelDrafts, `Provider ${adapter.id}`);
 	const enrichedDrafts = applyOfficialModelCosts(modelDrafts, officialPricing);
 	const pricingPolicy = runtime.pricingPolicies?.[adapter.id] ?? adapter.pricing;
 	const metadata: Record<string, ProviderModelMetadata> = {};
@@ -177,6 +185,76 @@ function getErrorCode(error: unknown): string {
 	return "fetch";
 }
 
+const ENVIRONMENT_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const ENVIRONMENT_NAME_PREFIX = /^[A-Za-z_][A-Za-z0-9_]*/;
+
+/** Match Pi's `$NAME` / `${NAME}` interpolation without executing API-key commands. */
+function getEnvironmentReferences(value: string): string[] {
+	if (value.startsWith("!")) return [];
+	const names = new Set<string>();
+	let index = 0;
+	while (index < value.length) {
+		const dollarIndex = value.indexOf("$", index);
+		if (dollarIndex < 0) break;
+		const next = value[dollarIndex + 1];
+		if (next === "$" || next === "!") {
+			index = dollarIndex + 2;
+			continue;
+		}
+		if (next === "{") {
+			const endIndex = value.indexOf("}", dollarIndex + 2);
+			if (endIndex < 0) {
+				index = dollarIndex + 1;
+				continue;
+			}
+			const name = value.slice(dollarIndex + 2, endIndex);
+			if (ENVIRONMENT_NAME.test(name)) names.add(name);
+			index = endIndex + 1;
+			continue;
+		}
+		const match = value.slice(dollarIndex + 1).match(ENVIRONMENT_NAME_PREFIX);
+		if (match) {
+			names.add(match[0]);
+			index = dollarIndex + 1 + match[0].length;
+		} else {
+			index = dollarIndex + 1;
+		}
+	}
+	return [...names];
+}
+
+function getRegistrationState(adapter: ProviderAdapter): NonNullable<ProviderAdapter["registration"]> | undefined {
+	const registration = adapter.registration;
+	if (!registration) return undefined;
+	registration.normalizedModels ??= [];
+	registration.modelMetadata ??= {};
+	registration.officialPricing ??= {};
+	registration.activeRefreshes ??= 0;
+	return registration;
+}
+
+function replaceModels(target: ProviderModel[], source: ProviderModel[]): ProviderModel[] {
+	target.splice(0, target.length, ...source);
+	return target;
+}
+
+function hasMissingEnvironmentReference(apiKey: string): boolean {
+	const environmentNames = getEnvironmentReferences(apiKey);
+	return environmentNames.length > 0 && environmentNames.some((name) => !process.env[name]);
+}
+
+function lacksCatalogRefreshCredential(apiKey: string, context: ProviderRefreshContext): boolean {
+	return context.allowNetwork === true && context.credential === undefined && hasMissingEnvironmentReference(apiKey);
+}
+
+function shouldOmitOptionalApiKey(adapter: ProviderAdapter, runtime: PiProviderDependencies): boolean {
+	return (
+		adapter.provider.oauth !== undefined &&
+		hasMissingEnvironmentReference(adapter.provider.apiKey) &&
+		runtime.readStoredCredential(adapter.id)?.type !== "api_key"
+	);
+}
+
 /**
  * Register a normalized Provider before the Host has assembled its final
  * registry. The original drafts remain attached to the adapter so a Host in a
@@ -194,9 +272,19 @@ export function prepareProviderRegistration(
 			? adapter.registration.modelDrafts
 			: adapter.provider.models);
 	const resolved = resolveModelRegistration(adapter, runtime, drafts, officialPricing);
-	const models = resolved.models;
+	const existingRegistration = getRegistrationState(adapter);
+	const registration: NonNullable<ProviderAdapter["registration"]> = existingRegistration ?? {
+		modelDrafts: drafts,
+		normalizedModels: [],
+		modelMetadata: {},
+		officialPricing,
+		activeRefreshes: 0,
+	};
+	registration.modelDrafts = drafts;
+	registration.modelMetadata = resolved.modelMetadata;
+	registration.officialPricing = officialPricing;
+	const models = replaceModels(registration.normalizedModels, resolved.models);
 	const adapterOwnsCatalog = adapter.catalog !== undefined;
-	const registration = { modelDrafts: drafts, normalizedModels: models, modelMetadata: resolved.modelMetadata };
 	adapter.registration = registration;
 	adapter.provider.models = models;
 	adapter.catalog ??= { source: "static", modelCount: models.length };
@@ -204,14 +292,24 @@ export function prepareProviderRegistration(
 
 	const { models: _draftModels, refreshModels: originalRefresh, ...providerMetadata } = adapter.provider;
 	const registeredProvider: ProviderConfig = { ...providerMetadata, models };
+	// Pi 0.84.2 resolves a declared environment API key before it can skip an
+	// unauthenticated catalog refresh. Register OAuth-only until the optional
+	// key exists, while preserving API-key credentials already stored by Pi.
+	if (shouldOmitOptionalApiKey(adapter, runtime)) delete registeredProvider.apiKey;
 	if (originalRefresh) {
 		registeredProvider.refreshModels = async (options: ProviderRefreshContext) => {
+			// Pi may ask every dynamic Provider to refresh. Keep the current catalog
+			// when this Provider's environment-backed key is absent instead of
+			// attempting an unauthenticated request that becomes a global refresh error.
+			if (lacksCatalogRefreshCredential(adapter.provider.apiKey, options)) {
+				return [...registration.normalizedModels];
+			}
+			registration.activeRefreshes++;
 			try {
 				const refreshedModels = await originalRefresh(options);
-				const resolved = resolveModelRegistration(adapter, runtime, refreshedModels, officialPricing);
-				const normalizedModels = resolved.models;
+				const resolved = resolveModelRegistration(adapter, runtime, refreshedModels, registration.officialPricing);
+				const normalizedModels = replaceModels(registration.normalizedModels, resolved.models);
 				registration.modelDrafts = refreshedModels;
-				registration.normalizedModels = normalizedModels;
 				registration.modelMetadata = resolved.modelMetadata;
 				adapter.provider.models = normalizedModels;
 				registeredProvider.models = normalizedModels;
@@ -226,36 +324,60 @@ export function prepareProviderRegistration(
 						lastError: undefined,
 					};
 				}
-				return normalizedModels;
+				return [...normalizedModels];
 			} catch (error) {
 				if (adapter.catalog && !isAbortError(error)) adapter.catalog.lastError = getErrorCode(error);
 				throw error;
+			} finally {
+				registration.activeRefreshes = Math.max(0, registration.activeRefreshes - 1);
+				if (registration.activeRefreshes === 0 && registration.deferredRegistration) {
+					const deferred = registration.deferredRegistration;
+					registration.deferredRegistration = undefined;
+					queueMicrotask(deferred);
+				}
 			}
 		};
 	}
 	return registeredProvider;
 }
 
+export function cancelDeferredProviderRegistrations(providers: readonly ProviderAdapter[]): void {
+	for (const adapter of providers) {
+		const registration = getRegistrationState(adapter);
+		if (registration) registration.deferredRegistration = undefined;
+	}
+}
+
 export function refreshProviderRegistrations(
-	pi: Pick<ExtensionAPI, "registerProvider">,
+	pi: ProviderRegistrationApi,
 	providers: readonly ProviderAdapter[],
 	runtime: PiProviderDependencies,
 	officialPricing: Record<string, OfficialModelMeta>,
 	providerDrafts?: ReadonlyMap<ProviderAdapter, ProviderModelDraft[]>,
 ): void {
 	for (const adapter of providers) {
+		const registration = getRegistrationState(adapter);
+		if (registration) registration.officialPricing = officialPricing;
+		if (registration && registration.activeRefreshes > 0) {
+			registration.deferredRegistration = () =>
+				registerProviderAdapter(pi, adapter, runtime, officialPricing, providerDrafts?.get(adapter));
+			continue;
+		}
 		registerProviderAdapter(pi, adapter, runtime, officialPricing, providerDrafts?.get(adapter));
 	}
 }
 
 export function registerProviderAdapter(
-	pi: Pick<ExtensionAPI, "registerProvider">,
+	pi: ProviderRegistrationApi,
 	adapter: ProviderAdapter,
 	runtime: PiProviderDependencies,
 	officialPricing: Record<string, OfficialModelMeta> = {},
 	modelDrafts?: ProviderModelDraft[],
 ): ProviderConfig {
 	const registeredProvider = prepareProviderRegistration(adapter, runtime, officialPricing, modelDrafts);
+	// Pi merges re-registrations, so omission alone cannot clear a raw API key
+	// left by the previous extension instance during /reload.
+	if (registeredProvider.apiKey === undefined) pi.unregisterProvider?.(adapter.id);
 	pi.registerProvider(adapter.id, registeredProvider);
 	return registeredProvider;
 }

package/core/public-adapters.ts

@@ -18,8 +18,16 @@ export {
 	defineStatusExtension,
 	defineTunerExtension,
 } from "./adapter-extensions.ts";
+export { MAX_PROVIDER_MODEL_COUNT } from "./adapter-validation.ts";
 export { createCatalogPreflightAdapter } from "./catalog-preflight.ts";
 export { withDeadline } from "./deadline.ts";
+export {
+	appendBaseUrlPath,
+	authDefinesHeader,
+	getContextAuth,
+	hasBaseUrlOrigin,
+	mergeDiagnosticHeaders,
+} from "./diagnostic-auth.ts";
 export { isProviderDataError, ProviderDataError } from "./errors.ts";
 export { createOpenCodeCatalogPreflightAdapter } from "./opencode-preflight.ts";
 export type {
@@ -38,6 +46,7 @@ export type {
 	ProviderModel,
 	ProviderModelDraft,
 	ProviderRefreshContext,
+	ProviderRequestAuth,
 	StatusAdapter,
 	StatusContext,
 	StatusEntry,

package/core/runtime-config.ts

@@ -173,6 +173,9 @@ export function resolvePiProviderDependencies(
 	dependencies: Partial<PiProviderDependencies> = {},
 ): PiProviderDependencies {
 	const runtime = { ...getDefaultPiProviderDependencies(), ...dependencies };
+	if (!Object.hasOwn(dependencies, "openRouterMetadataCachePath")) {
+		runtime.openRouterMetadataCachePath = getDefaultOpenRouterMetadataCachePath(runtime.agentDir);
+	}
 	if (runtime.pricingPolicies === undefined) runtime.pricingPolicies = {};
 	validatePiProviderDependencies(runtime);
 	return runtime;

package/core/runtime.ts

@@ -11,7 +11,11 @@ import {
 } from "./official-pricing.ts";
 import type { PreflightContextLike } from "./preflight-manager.ts";
 import { PreflightManager } from "./preflight-manager.ts";
-import { refreshProviderRegistrations, registerProviderAdapter } from "./provider-registration.ts";
+import {
+	cancelDeferredProviderRegistrations,
+	refreshProviderRegistrations,
+	registerProviderAdapter,
+} from "./provider-registration.ts";
 import type { PiProviderDependencies, PiProviderLoader } from "./runtime-config.ts";
 import { resolvePiProviderDependencies } from "./runtime-config.ts";
 import type { StatusContextLike } from "./status-manager.ts";
@@ -392,6 +396,7 @@ export function installPiProviderRuntime(
 		lifecycleGeneration++;
 		statusPresentationGeneration++;
 		statusPresentationVisible = false;
+		cancelDeferredProviderRegistrations(providers);
 		statusManager.cancelAll();
 		statusManager.clear();
 		preflightManager.cancelAll();
@@ -444,43 +449,52 @@ export function createPiProviderRuntime(
 ): (pi: ExtensionAPI) => Promise<void> {
 	const runtime = resolvePiProviderDependencies(dependencies);
 	return async (pi) => {
-		let latestBackgroundPricing: Record<string, OfficialModelMeta> | undefined;
-		let installedDefinition: PiProviderDefinition | undefined;
 		let installedController: PiProviderRuntimeController | undefined;
 		let disposed = false;
-		const onBackgroundRefresh = (snapshot: Record<string, OfficialModelMeta>): void => {
-			latestBackgroundPricing = snapshot;
-			if (disposed) return;
-			installedController?.updateOfficialPricing?.(snapshot);
-			if (installedDefinition === undefined) return;
-			refreshProviderRegistrations(pi, installedDefinition.providers, runtime, snapshot);
-		};
+		let pricingRefreshController: AbortController | undefined;
+		const cachePath =
+			runtime.officialPricingUrl === OPENROUTER_MODELS_URL ? runtime.openRouterMetadataCachePath : undefined;
+		const fetchPricing = (options: { allowNetwork?: boolean; signal?: AbortSignal } = {}) =>
+			fetchOfficialPricing(
+				runtime.fetch,
+				runtime.officialPricingUrl,
+				runtime.officialPricingTimeoutMs,
+				runtime.officialPricingCacheTtlMs,
+				runtime.officialPricingMaxStaleMs,
+				runtime.now,
+				{ cachePath, ...options },
+			);
 		const officialPricingPromise = runtime.enableOfficialPricingFallback
-			? fetchOfficialPricing(
-					runtime.fetch,
-					runtime.officialPricingUrl,
-					runtime.officialPricingTimeoutMs,
-					runtime.officialPricingCacheTtlMs,
-					runtime.officialPricingMaxStaleMs,
-					runtime.now,
-					{
-						cachePath:
-							runtime.officialPricingUrl === OPENROUTER_MODELS_URL
-								? runtime.openRouterMetadataCachePath
-								: undefined,
-						background: runtime.officialPricingUrl === OPENROUTER_MODELS_URL,
-						onBackgroundRefresh: onBackgroundRefresh,
-					},
-				)
+			? fetchPricing({ allowNetwork: false })
 			: Promise.resolve({});
 		const definitionPromise = loadDefinition(runtime);
 		const [officialPricing, definition] = await Promise.all([officialPricingPromise, definitionPromise]);
 		validatePiProviderDefinition(definition);
-		installedController = installPiProviderRuntime(pi, runtime, definition, officialPricing);
-		installedDefinition = definition;
-		if (latestBackgroundPricing !== undefined) onBackgroundRefresh(latestBackgroundPricing);
+
+		pi.on("session_start", () => {
+			pricingRefreshController?.abort();
+			pricingRefreshController = undefined;
+			if (!runtime.enableOfficialPricingFallback || disposed) {
+				return;
+			}
+			const controller = new AbortController();
+			pricingRefreshController = controller;
+			void fetchPricing({ signal: controller.signal })
+				.then((snapshot) => {
+					if (disposed || controller.signal.aborted) return;
+					installedController?.updateOfficialPricing?.(snapshot);
+					refreshProviderRegistrations(pi, definition.providers, runtime, snapshot);
+				})
+				.catch(() => undefined)
+				.finally(() => {
+					if (pricingRefreshController === controller) pricingRefreshController = undefined;
+				});
+		});
 		pi.on("session_shutdown", () => {
 			disposed = true;
+			pricingRefreshController?.abort();
+			pricingRefreshController = undefined;
 		});
+		installedController = installPiProviderRuntime(pi, runtime, definition, officialPricing);
 	};
 }

package/core/status-manager.ts

@@ -1,5 +1,7 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { deriveCredentialType } from "./credential-type.ts";
 import { isValidTimeoutMs, withDeadline } from "./deadline.ts";
+import { applyDiagnosticBaseUrl, type DiagnosticModelRegistry, resolveDiagnosticAuth } from "./diagnostic-auth.ts";
 import { isProviderDataError, ProviderDataError } from "./errors.ts";
 import type {
 	StatusAdapter,
@@ -10,11 +12,11 @@ import type {
 	StatusWindowEntry,
 } from "./types.ts";
 
+type StatusModel = NonNullable<ExtensionContext["model"]>;
+
 export interface StatusContextLike {
-	model?: { provider?: string };
-	modelRegistry: {
-		getApiKeyForProvider(provider: string): Promise<string | undefined>;
-	};
+	model?: { provider?: string; id?: string; baseUrl?: string };
+	modelRegistry: DiagnosticModelRegistry;
 	/** Optional credential identity used to isolate cached account data. */
 	getCredentialKey?: () => Promise<string | undefined>;
 	/** Optional non-secret credential metadata for provider-specific account labels. */
@@ -223,10 +225,21 @@ export class StatusManager {
 			const cancellation = new AbortController();
 			const generation = ++state.generation;
 			const promise = withDeadline(
-				(signal) =>
-					adapter.fetch({
+				async (signal) => {
+					const sourceModel = ctx.model as StatusModel;
+					const auth = await resolveDiagnosticAuth(sourceModel, ctx.modelRegistry);
+					const model = applyDiagnosticBaseUrl(sourceModel, auth);
+					if (adapter.supportsModel && !adapter.supportsModel(model)) {
+						throw new ProviderDataError(
+							"Status endpoint is unavailable for the effective model URL",
+							"unsupported",
+						);
+					}
+					return await adapter.fetch({
 						fetch: this.fetchFn,
-						getApiKey: () => ctx.modelRegistry.getApiKeyForProvider(adapter.providerId),
+						getApiKey: async () => auth.apiKey,
+						getAuth: async () => auth,
+						model,
 						...(ctx.getCredentialMetadata === undefined
 							? {}
 							: {
@@ -235,7 +248,8 @@ export class StatusManager {
 								}),
 						now: this.now,
 						signal,
-					}),
+					});
+				},
 				adapter.requestTimeoutMs,
 				cancellation.signal,
 			);
@@ -262,6 +276,11 @@ export class StatusManager {
 		} catch (error) {
 			if (state.generation !== generation || isErrorNamed(error, "AbortError")) return "skipped";
 			const dataError = isProviderDataError(error) ? error : undefined;
+			if (dataError?.code === "unsupported") {
+				state.snapshot = undefined;
+				state.lastError = undefined;
+				return "skipped";
+			}
 			const code = dataError?.code ?? (isErrorNamed(error, "TimeoutError") ? "timeout" : "fetch");
 			const retryAt =
 				dataError?.retryAt !== undefined && Number.isFinite(dataError.retryAt) ? dataError.retryAt : undefined;

package/core/types.ts

@@ -4,6 +4,7 @@ import type {
 	ProviderConfig,
 	ProviderModelConfig,
 } from "@earendil-works/pi-coding-agent";
+import type { OfficialModelMeta } from "./official-pricing.ts";
 
 export type ThinkingLevel = ReturnType<ExtensionAPI["getThinkingLevel"]>;
 
@@ -32,6 +33,14 @@ export interface StoredCredentialLike {
 	readonly teamName?: string;
 }
 
+/** Model-scoped authentication resolved by Pi for one diagnostic request. */
+export interface ProviderRequestAuth {
+	apiKey?: string;
+	headers?: Record<string, string | null>;
+	baseUrl?: string;
+	env?: Record<string, string>;
+}
+
 export interface ModelFieldSources {
 	contextWindow?: ModelFieldSource;
 	maxTokens?: ModelFieldSource;
@@ -145,6 +154,10 @@ export interface StatusSnapshot {
 export interface StatusContext {
 	fetch: typeof globalThis.fetch;
 	getApiKey: () => Promise<string | undefined>;
+	/** Complete model-scoped request authentication resolved by Pi. */
+	getAuth?: () => Promise<ProviderRequestAuth>;
+	/** Effective model, including any credential-specific base URL. */
+	model?: ActiveModel;
 	/** 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. */
@@ -159,6 +172,8 @@ export interface StatusAdapter {
 	name: string;
 	cacheTtlMs: number;
 	requestTimeoutMs: number;
+	/** Return false when this account endpoint cannot safely serve the effective model URL. */
+	supportsModel?: (model: ActiveModel) => boolean;
 	fetch(context: StatusContext): Promise<StatusSnapshot>;
 }
 
@@ -179,8 +194,11 @@ export interface ProviderAdapter {
 	/** @internal Draft state shared across isolated Adapter and Host contexts. */
 	registration?: {
 		modelDrafts: ProviderModelDraft[];
-		normalizedModels?: ProviderModel[];
-		modelMetadata?: Record<string, ProviderModelMetadata>;
+		normalizedModels: ProviderModel[];
+		modelMetadata: Record<string, ProviderModelMetadata>;
+		officialPricing: Record<string, OfficialModelMeta>;
+		activeRefreshes: number;
+		deferredRegistration?: () => void;
 	};
 }
 

package/index.ts

@@ -17,8 +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 {
@@ -103,6 +111,7 @@ export type {
 	ProviderPricingPolicy,
 	ProviderPricingSource,
 	ProviderRefreshContext,
+	ProviderRequestAuth,
 	StatusAdapter,
 	StatusAmountEntry,
 	StatusContext,
@@ -116,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.4",
+  "version": "0.1.6",
   "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/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

@@ -1,7 +1,16 @@
 import type { PreflightAdapter } from "@hyav/pi-provider";
-import { definePreflightExtension, ProviderDataError, parseRetryAfter } from "@hyav/pi-provider";
+import {
+	appendBaseUrlPath,
+	authDefinesHeader,
+	definePreflightExtension,
+	getContextAuth,
+	mergeDiagnosticHeaders,
+	ProviderDataError,
+	parseRetryAfter,
+} from "@hyav/pi-provider";
 
-export const COPILOT_MODELS_URL = "https://api.individual.githubcopilot.com/models";
+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);
@@ -14,17 +23,21 @@ export const githubCopilotPreflightAdapter: PreflightAdapter = {
 	cacheTtlMs: 30_000,
 	requestTimeoutMs: 8_000,
 	async fetch(context) {
-		const apiKey = await context.getApiKey();
+		const auth = await getContextAuth(context);
+		const apiKey = auth.apiKey;
 		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",
-			},
+		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) {

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

@@ -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 { GROQ_MODELS_URL } from "../status/groq.ts";
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -12,6 +12,7 @@ export const groqPreflightAdapter: PreflightAdapter = {
 	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") {

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") {