@hyav/pi-provider 0.1.3 → 0.1.5

package/core/preflight-manager.ts

@@ -1,17 +1,24 @@
 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 { ProviderRequestAuth } from "./types.ts";
 
 export type PreflightModel = NonNullable<ExtensionContext["model"]>;
 
-type ModelRegistry = ExtensionContext["modelRegistry"];
-
 export interface PreflightContext {
 	fetch: typeof globalThis.fetch;
 	getApiKey: () => Promise<string | undefined>;
+	/** Complete model-scoped request authentication resolved by Pi. */
+	getAuth?: () => Promise<ProviderRequestAuth>;
 	signal?: AbortSignal;
 	now: () => number;
 	model: PreflightModel;
+	/** 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>;
 }
 
 export interface PreflightSnapshot {
@@ -27,12 +34,16 @@ export interface PreflightAdapter {
 	name: string;
 	cacheTtlMs: number;
 	requestTimeoutMs: number;
+	/** Return false when this endpoint cannot safely serve the effective model URL. */
+	supportsModel?: (model: PreflightModel) => boolean;
 	fetch(context: PreflightContext): Promise<PreflightSnapshot>;
 }
 
 export interface PreflightContextLike {
 	model: PreflightModel;
-	modelRegistry: Pick<ModelRegistry, "getApiKeyForProvider">;
+	modelRegistry: DiagnosticModelRegistry;
+	/** Optional non-secret credential metadata for provider-specific account labels. */
+	getCredentialMetadata?: () => unknown;
 }
 
 export interface PreflightErrorState {
@@ -175,14 +186,30 @@ export class PreflightManager {
 			const cancellation = new AbortController();
 			const generation = ++state.generation;
 			const promise = withDeadline(
-				(signal) =>
-					adapter.fetch({
+				async (signal) => {
+					const auth = await resolveDiagnosticAuth(ctx.model, ctx.modelRegistry);
+					const model = applyDiagnosticBaseUrl(ctx.model, auth);
+					if (adapter.supportsModel && !adapter.supportsModel(model)) {
+						throw new ProviderDataError(
+							"Preflight 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,
 						now: this.now,
 						signal,
-						model: ctx.model,
-					}),
+						model,
+						...(ctx.getCredentialMetadata === undefined
+							? {}
+							: {
+									getCredentialMetadata: ctx.getCredentialMetadata,
+									getCredentialType: async () => deriveCredentialType(ctx.getCredentialMetadata?.()),
+								}),
+					});
+				},
 				adapter.requestTimeoutMs,
 				cancellation.signal,
 			);
@@ -204,6 +231,11 @@ export class PreflightManager {
 			return "refreshed";
 		} catch (error) {
 			if (state.generation !== generation || isErrorNamed(error, "AbortError")) return "skipped";
+			if (isProviderDataError(error) && error.code === "unsupported") {
+				state.snapshot = undefined;
+				state.lastError = undefined;
+				return "skipped";
+			}
 			state.lastError = errorState(error);
 			if (state.lastError.code === "timeout") {
 				state.generation++;

package/core/provider-registration.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI, 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";
@@ -83,6 +84,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 +115,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 +180,65 @@ 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 lacksCatalogRefreshCredential(apiKey: string, context: ProviderRefreshContext): boolean {
+	if (context.allowNetwork !== true || context.credential !== undefined) return false;
+	const environmentNames = getEnvironmentReferences(apiKey);
+	return environmentNames.length > 0 && environmentNames.some((name) => !process.env[name]);
+}
+
 /**
  * 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 +256,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 };
@@ -206,12 +278,18 @@ export function prepareProviderRegistration(
 	const registeredProvider: ProviderConfig = { ...providerMetadata, models };
 	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,16 +304,30 @@ 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">,
 	providers: readonly ProviderAdapter[],
@@ -244,6 +336,13 @@ export function refreshProviderRegistrations(
 	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));
 	}
 }

package/core/public-adapters.ts

@@ -18,7 +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 {
@@ -37,6 +46,7 @@ export type {
 	ProviderModel,
 	ProviderModelDraft,
 	ProviderRefreshContext,
+	ProviderRequestAuth,
 	StatusAdapter,
 	StatusContext,
 	StatusEntry,

package/core/ratelimit-headers.ts

@@ -0,0 +1,72 @@
+/** Shared parsing for OpenAI-style `x-ratelimit-*` response headers. */
+
+export interface RateLimitWindow {
+	limit: number;
+	remaining: number;
+	resetAt?: number;
+}
+
+function numberValue(value: unknown): number | undefined {
+	if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
+	if (typeof value === "string" && value.trim() !== "") {
+		const parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : undefined;
+	}
+	return undefined;
+}
+
+const DURATION_PATTERN = /^((?:\d+(?:\.\d+)?(?:ms|[smhd]))+)$/i;
+const DURATION_PARTS = /(\d+(?:\.\d+)?)(ms|[smhd])/gi;
+const UNIT_SECONDS: Record<string, number> = { ms: 0.001, s: 1, m: 60, h: 3_600, d: 86_400 };
+
+export function durationSeconds(value: string): number | undefined {
+	const matched = DURATION_PATTERN.exec(value.trim());
+	if (!matched?.[1]) return undefined;
+	let total = 0;
+	for (const match of value.matchAll(DURATION_PARTS)) {
+		const amount = Number(match[1]);
+		if (!Number.isFinite(amount)) return undefined;
+		total += amount * (UNIT_SECONDS[match[2]!.toLowerCase()] ?? Number.NaN);
+		if (!Number.isFinite(total)) return undefined;
+	}
+	return total;
+}
+
+/**
+ * Reset hint in seconds. Providers use bare numbers, `7.66s`, and compound
+ * durations like Groq's `2m59.56s`; reset windows like `1d` also appear.
+ */
+export function resetSecondsFromHeader(value: string | null): number | undefined {
+	if (value === null || value.trim() === "") return undefined;
+	const trimmed = value.trim();
+	const duration = durationSeconds(trimmed);
+	if (duration === undefined) {
+		const bare = numberValue(trimmed);
+		if (bare === undefined || bare <= 0) return undefined;
+		return bare;
+	}
+	if (duration <= 0) return undefined;
+	return duration;
+}
+
+function parseWindow(headers: Headers, kind: "requests" | "tokens", now: number): RateLimitWindow | undefined {
+	const limit = numberValue(headers.get(`x-ratelimit-limit-${kind}`));
+	const remaining = numberValue(headers.get(`x-ratelimit-remaining-${kind}`));
+	if (limit === undefined || remaining === undefined || limit <= 0) return undefined;
+	const reset = resetSecondsFromHeader(headers.get(`x-ratelimit-reset-${kind}`) ?? headers.get("x-ratelimit-reset"));
+	return {
+		limit,
+		remaining,
+		...(reset !== undefined ? { resetAt: now + Math.round(reset * 1_000) } : {}),
+	};
+}
+
+export function parseRateLimitWindows(
+	headers: Headers,
+	now: number,
+): { requests?: RateLimitWindow; tokens?: RateLimitWindow } {
+	return {
+		requests: parseWindow(headers, "requests", now),
+		tokens: parseWindow(headers, "tokens", now),
+	};
+}

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";
@@ -46,10 +50,11 @@ function readProviderCredentialMetadata(
 ): 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;
@@ -337,13 +342,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, runtime.readStoredCredential),
+				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 }));
@@ -385,6 +396,7 @@ export function installPiProviderRuntime(
 		lifecycleGeneration++;
 		statusPresentationGeneration++;
 		statusPresentationVisible = false;
+		cancelDeferredProviderRegistrations(providers);
 		statusManager.cancelAll();
 		statusManager.clear();
 		preflightManager.cancelAll();
@@ -437,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,4 +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,
@@ -9,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. */
@@ -222,14 +225,31 @@ 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),
-						...(ctx.getCredentialMetadata ? { getCredentialMetadata: ctx.getCredentialMetadata } : {}),
+						getApiKey: async () => auth.apiKey,
+						getAuth: async () => auth,
+						model,
+						...(ctx.getCredentialMetadata === undefined
+							? {}
+							: {
+									getCredentialMetadata: ctx.getCredentialMetadata,
+									getCredentialType: async () => deriveCredentialType(ctx.getCredentialMetadata?.()),
+								}),
 						now: this.now,
 						signal,
-					}),
+					});
+				},
 				adapter.requestTimeoutMs,
 				cancellation.signal,
 			);
@@ -256,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,8 +154,14 @@ 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. */
+	getCredentialType?: () => Promise<string | undefined>;
 	signal?: AbortSignal;
 	now: () => number;
 }
@@ -157,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>;
 }
 
@@ -177,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;
 	};
 }