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

package/core/opencode-preflight.ts

@@ -0,0 +1,66 @@
+import { ProviderDataError } from "../core/errors.ts";
+import type { PreflightAdapter } from "../core/preflight-manager.ts";
+import { parseRetryAfter } from "../core/retry-after.ts";
+
+interface OpenCodePreflightConfig {
+	id: string;
+	providerId: string;
+	name: string;
+	modelsUrl: string;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function createOpenCodeCatalogPreflightAdapter(
+	config: OpenCodePreflightConfig,
+	requestTimeoutMs: number,
+): PreflightAdapter {
+	return {
+		id: config.id,
+		providerId: config.providerId,
+		name: config.name,
+		cacheTtlMs: 30_000,
+		requestTimeoutMs,
+		async fetch(context) {
+			const apiKey = await context.getApiKey();
+			const headers: Record<string, string> = {
+				Accept: "application/json",
+				"Accept-Encoding": "identity",
+			};
+			if (apiKey && apiKey !== "proxy-managed") headers.Authorization = `Bearer ${apiKey}`;
+
+			const response = await context.fetch(config.modelsUrl, { headers, signal: context.signal });
+			if (!response.ok) {
+				throw new ProviderDataError(
+					`${config.name} 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(`${config.name} preflight returned invalid JSON`, "badjson");
+			}
+			if (!isRecord(payload) || !Array.isArray(payload.data)) {
+				throw new ProviderDataError(`${config.name} preflight returned invalid catalog data`, "badjson");
+			}
+			const modelIds = new Set(
+				payload.data
+					.filter(isRecord)
+					.map((model) => (typeof model.id === "string" ? model.id.trim() : undefined))
+					.filter((id): id is string => id !== undefined && id !== ""),
+			);
+			return {
+				passed: modelIds.has(context.model.id),
+				checks: ["endpoint", "catalog"],
+				updatedAt: context.now(),
+				httpStatus: response.status,
+			};
+		},
+	};
+}

package/core/preflight-manager.ts

@@ -0,0 +1,251 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { isValidTimeoutMs, withDeadline } from "./deadline.ts";
+import { isProviderDataError, ProviderDataError } from "./errors.ts";
+
+export type PreflightModel = NonNullable<ExtensionContext["model"]>;
+
+type ModelRegistry = ExtensionContext["modelRegistry"];
+
+export interface PreflightContext {
+	fetch: typeof globalThis.fetch;
+	getApiKey: () => Promise<string | undefined>;
+	signal?: AbortSignal;
+	now: () => number;
+	model: PreflightModel;
+}
+
+export interface PreflightSnapshot {
+	passed: boolean;
+	checks: string[];
+	updatedAt: number;
+	httpStatus?: number;
+}
+
+export interface PreflightAdapter {
+	id: string;
+	providerId: string;
+	name: string;
+	cacheTtlMs: number;
+	requestTimeoutMs: number;
+	fetch(context: PreflightContext): Promise<PreflightSnapshot>;
+}
+
+export interface PreflightContextLike {
+	model: PreflightModel;
+	modelRegistry: Pick<ModelRegistry, "getApiKeyForProvider">;
+}
+
+export interface PreflightErrorState {
+	code: string;
+	retryAt?: number;
+	httpStatus?: number;
+}
+
+export interface PreflightDiagnostics {
+	snapshot?: PreflightSnapshot;
+	pending: boolean;
+	lastError?: PreflightErrorState;
+}
+
+export type PreflightUpdateResult = "cached" | "refreshed" | "failed" | "skipped";
+
+interface PendingPreflight {
+	promise: Promise<PreflightSnapshot>;
+	generation: number;
+	cancel: () => void;
+}
+
+interface PreflightState {
+	snapshot?: PreflightSnapshot;
+	pending?: PendingPreflight;
+	lastError?: PreflightErrorState;
+	generation: number;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function isErrorNamed(error: unknown, name: string): boolean {
+	return error !== null && typeof error === "object" && "name" in error && error.name === name;
+}
+
+const MAX_PREFLIGHT_CHECKS = 32;
+const MAX_PREFLIGHT_TEXT_LENGTH = 256;
+
+function hasSafeText(value: unknown): value is string {
+	return (
+		typeof value === "string" &&
+		value.trim() !== "" &&
+		value.length <= MAX_PREFLIGHT_TEXT_LENGTH &&
+		!/[\u0000-\u001f\u007f]/.test(value)
+	);
+}
+
+export function normalizePreflightSnapshot(value: unknown): PreflightSnapshot {
+	if (!isRecord(value) || typeof value.passed !== "boolean" || !Array.isArray(value.checks)) {
+		throw new ProviderDataError("Preflight adapter returned an invalid snapshot", "badjson");
+	}
+	if (typeof value.updatedAt !== "number" || !Number.isFinite(value.updatedAt)) {
+		throw new ProviderDataError("Preflight adapter returned an invalid snapshot", "badjson");
+	}
+	if (value.checks.length > MAX_PREFLIGHT_CHECKS) {
+		throw new ProviderDataError("Preflight adapter returned too many checks", "badjson");
+	}
+	const checks = value.checks.map((check) => {
+		if (!hasSafeText(check)) throw new ProviderDataError("Preflight adapter returned an invalid check", "badjson");
+		return check.trim();
+	});
+	if (new Set(checks).size !== checks.length) {
+		throw new ProviderDataError("Preflight adapter returned duplicate checks", "badjson");
+	}
+	if (value.httpStatus !== undefined) {
+		if (
+			typeof value.httpStatus !== "number" ||
+			!Number.isInteger(value.httpStatus) ||
+			value.httpStatus < 100 ||
+			value.httpStatus > 599
+		) {
+			throw new ProviderDataError("Preflight adapter returned an invalid HTTP status", "badjson");
+		}
+	}
+	return {
+		passed: value.passed,
+		checks,
+		updatedAt: value.updatedAt,
+		...(value.httpStatus !== undefined ? { httpStatus: value.httpStatus } : {}),
+	};
+}
+
+function cloneSnapshot(snapshot: PreflightSnapshot): PreflightSnapshot {
+	return { ...snapshot, checks: [...snapshot.checks] };
+}
+
+function errorState(error: unknown): PreflightErrorState {
+	const dataError = isProviderDataError(error) ? error : undefined;
+	if (dataError) {
+		return {
+			code: dataError.code,
+			...(dataError.httpStatus !== undefined ? { httpStatus: dataError.httpStatus } : {}),
+			...(dataError.retryAt !== undefined && Number.isFinite(dataError.retryAt)
+				? { retryAt: dataError.retryAt }
+				: {}),
+		};
+	}
+	if (isErrorNamed(error, "TimeoutError")) return { code: "timeout" };
+	if (isErrorNamed(error, "AbortError")) return { code: "cancelled" };
+	if (error !== null && typeof error === "object" && "code" in error && typeof error.code === "string") {
+		return { code: error.code };
+	}
+	return { code: "fetch" };
+}
+
+export function getPreflightKey(provider: string, model: string): string {
+	return JSON.stringify([provider, model]);
+}
+
+export class PreflightManager {
+	private readonly states = new Map<string, PreflightState>();
+
+	constructor(
+		private readonly adapters: PreflightAdapter[],
+		private readonly fetchFn: typeof globalThis.fetch,
+		private readonly now: () => number,
+	) {}
+
+	async update(ctx: PreflightContextLike, options: { force?: boolean } = {}): Promise<PreflightUpdateResult> {
+		const adapter = this.adapters.find(({ providerId }) => providerId === ctx.model.provider);
+		if (!adapter) return "skipped";
+
+		const state = this.getState(getPreflightKey(adapter.providerId, ctx.model.id));
+		const now = this.now();
+		const snapshotAge = state.snapshot ? now - state.snapshot.updatedAt : undefined;
+		if (!options.force && snapshotAge !== undefined && snapshotAge >= 0 && snapshotAge < adapter.cacheTtlMs) {
+			return "cached";
+		}
+		const retryAt = state.lastError?.retryAt;
+		if (retryAt !== undefined && Number.isFinite(retryAt) && now < retryAt) return "skipped";
+		if (!isValidTimeoutMs(adapter.requestTimeoutMs)) {
+			state.lastError = { code: "config" };
+			return "failed";
+		}
+
+		let pending = state.pending;
+		if (!pending) {
+			const cancellation = new AbortController();
+			const generation = ++state.generation;
+			const promise = withDeadline(
+				(signal) =>
+					adapter.fetch({
+						fetch: this.fetchFn,
+						getApiKey: () => ctx.modelRegistry.getApiKeyForProvider(adapter.providerId),
+						now: this.now,
+						signal,
+						model: ctx.model,
+					}),
+				adapter.requestTimeoutMs,
+				cancellation.signal,
+			);
+			pending = {
+				promise,
+				generation,
+				cancel: () => cancellation.abort(),
+			};
+			state.pending = pending;
+		}
+
+		const activePending = pending;
+		const { generation } = activePending;
+		try {
+			const snapshot = normalizePreflightSnapshot(await activePending.promise);
+			if (state.generation !== generation) return "skipped";
+			state.snapshot = snapshot;
+			state.lastError = undefined;
+			return "refreshed";
+		} catch (error) {
+			if (state.generation !== generation || isErrorNamed(error, "AbortError")) return "skipped";
+			state.lastError = errorState(error);
+			if (state.lastError.code === "timeout") {
+				state.generation++;
+				if (state.pending === activePending) state.pending = undefined;
+			}
+			return "failed";
+		} finally {
+			if (state.generation === generation && state.pending === activePending) state.pending = undefined;
+		}
+	}
+
+	async refresh(ctx: PreflightContextLike): Promise<PreflightUpdateResult> {
+		return await this.update(ctx, { force: true });
+	}
+
+	cancelAll(): void {
+		for (const state of this.states.values()) {
+			state.generation++;
+			state.pending?.cancel();
+			state.pending = undefined;
+		}
+	}
+
+	clear(): void {
+		this.cancelAll();
+		this.states.clear();
+	}
+
+	getDiagnostics(provider: string, model: string): PreflightDiagnostics {
+		const state = this.states.get(getPreflightKey(provider, model));
+		return {
+			snapshot: state?.snapshot ? cloneSnapshot(state.snapshot) : undefined,
+			pending: state?.pending !== undefined,
+			lastError: state?.lastError ? { ...state.lastError } : undefined,
+		};
+	}
+
+	private getState(key: string): PreflightState {
+		const existing = this.states.get(key);
+		if (existing) return existing;
+		const state: PreflightState = { generation: 0 };
+		this.states.set(key, state);
+		return state;
+	}
+}

package/core/pricing-adjustments.ts

@@ -0,0 +1,118 @@
+import type {
+	ModelPricingDetails,
+	PricingSku,
+	ProviderCost,
+	ProviderPricingAdjustment,
+	ProviderPricingPolicy,
+	ProviderPricingSource,
+} from "./types.ts";
+
+const PRICING_SKUS: readonly PricingSku[] = ["input", "output", "cacheRead", "cacheWrite"];
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function validatePricingAdjustment(
+	value: unknown,
+	label = "Pricing adjustment",
+): asserts value is ProviderPricingAdjustment {
+	if (!isRecord(value)) throw new Error(`${label} must be an object`);
+	if (typeof value.multiplier !== "number" || !Number.isFinite(value.multiplier) || value.multiplier < 0) {
+		throw new Error(`${label}.multiplier must be a finite non-negative number`);
+	}
+	if (typeof value.label !== "string" || value.label.trim() === "") {
+		throw new Error(`${label}.label must be a non-empty string`);
+	}
+	if (value.source !== undefined && (typeof value.source !== "string" || value.source.trim() === "")) {
+		throw new Error(`${label}.source must be a non-empty string`);
+	}
+	if (value.appliesToReference !== undefined && typeof value.appliesToReference !== "boolean") {
+		throw new Error(`${label}.appliesToReference must be a boolean`);
+	}
+	if (value.appliesTo !== undefined) {
+		if (
+			!Array.isArray(value.appliesTo) ||
+			value.appliesTo.length === 0 ||
+			value.appliesTo.some((sku) => !PRICING_SKUS.includes(sku as PricingSku))
+		) {
+			throw new Error(`${label}.appliesTo must contain only known pricing SKUs`);
+		}
+	}
+}
+
+export function validatePricingPolicy(
+	value: unknown,
+	label = "Provider pricing policy",
+): asserts value is ProviderPricingPolicy {
+	if (!isRecord(value)) throw new Error(`${label} must be an object`);
+	if (value.defaultAdjustment !== undefined)
+		validatePricingAdjustment(value.defaultAdjustment, `${label}.defaultAdjustment`);
+	if (value.models !== undefined) {
+		if (!isRecord(value.models)) throw new Error(`${label}.models must be an object`);
+		for (const [modelId, adjustment] of Object.entries(value.models)) {
+			if (modelId.trim() === "") throw new Error(`${label}.models has an empty model ID`);
+			validatePricingAdjustment(adjustment, `${label}.models.${modelId}`);
+		}
+	}
+}
+
+function scaleRate(rate: number, sku: PricingSku, adjustment: ProviderPricingAdjustment): number {
+	const appliesTo = adjustment.appliesTo ?? PRICING_SKUS;
+	return appliesTo.includes(sku) ? rate * adjustment.multiplier : rate;
+}
+
+function cloneCost(cost: ProviderCost): ProviderCost {
+	return {
+		...cost,
+		...(cost.tiers ? { tiers: cost.tiers.map((tier) => ({ ...tier })) } : {}),
+	};
+}
+
+export function resolvePricingDetails(
+	baseCost: ProviderCost | undefined,
+	source: ProviderPricingSource | "none",
+	adjustment?: ProviderPricingAdjustment,
+): ModelPricingDetails {
+	if (baseCost === undefined) {
+		return {
+			known: false,
+			source,
+			...(adjustment ? { adjustment: { ...adjustment } } : {}),
+			...(adjustment ? { note: "discount configured, base price unavailable" } : {}),
+		};
+	}
+
+	const canAdjustReference = source !== "official" || adjustment?.appliesToReference !== false;
+	const effectiveCost =
+		adjustment && canAdjustReference ? applyPricingAdjustment(baseCost, adjustment) : cloneCost(baseCost);
+	return {
+		known: true,
+		source,
+		baseCost: cloneCost(baseCost),
+		effectiveCost,
+		...(adjustment ? { adjustment: { ...adjustment } } : {}),
+		...(adjustment && !canAdjustReference ? { note: "discount not applied to reference price" } : {}),
+	};
+}
+
+/** Apply one explicit static pricing adjustment without changing token thresholds. */
+export function applyPricingAdjustment(cost: ProviderCost, adjustment: ProviderPricingAdjustment): ProviderCost {
+	return {
+		input: scaleRate(cost.input, "input", adjustment),
+		output: scaleRate(cost.output, "output", adjustment),
+		cacheRead: scaleRate(cost.cacheRead, "cacheRead", adjustment),
+		cacheWrite: scaleRate(cost.cacheWrite, "cacheWrite", adjustment),
+		...(cost.tiers
+			? {
+					tiers: cost.tiers.map((tier) => ({
+						inputTokensAbove: tier.inputTokensAbove,
+						input: scaleRate(tier.input, "input", adjustment),
+						output: scaleRate(tier.output, "output", adjustment),
+						cacheRead: scaleRate(tier.cacheRead, "cacheRead", adjustment),
+						cacheWrite: scaleRate(tier.cacheWrite, "cacheWrite", adjustment),
+					})),
+				}
+			: {}),
+	};
+}

package/core/provider-registration.ts

@@ -0,0 +1,261 @@
+import type { ExtensionAPI, ProviderConfig } from "@earendil-works/pi-coding-agent";
+import { applyOfficialModelCosts, findOfficialMeta, type OfficialModelMeta } from "./official-pricing.ts";
+import { resolvePricingDetails } from "./pricing-adjustments.ts";
+import type { ProviderKitDependencies } from "./runtime-config.ts";
+import type {
+	ProviderAdapter,
+	ProviderCost,
+	ProviderModel,
+	ProviderModelDraft,
+	ProviderModelMetadata,
+	ProviderPricingAdjustment,
+	ProviderPricingSource,
+	ProviderRefreshContext,
+} from "./types.ts";
+
+const DEFAULT_CONTEXT_WINDOW = 128_000;
+const DEFAULT_MAX_TOKENS = 16_384;
+
+function finiteNonNegative(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+
+function positiveInteger(value: unknown, fallback: number): number {
+	return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value > 0
+		? value
+		: fallback;
+}
+
+function normalizeCost(cost: ProviderModelDraft["cost"]): ProviderCost {
+	const candidate = cost as Partial<ProviderCost> | undefined;
+	const tiers = Array.isArray(candidate?.tiers)
+		? candidate.tiers
+				.filter(
+					(tier) =>
+						tier &&
+						typeof tier.inputTokensAbove === "number" &&
+						Number.isFinite(tier.inputTokensAbove) &&
+						tier.inputTokensAbove > 0,
+				)
+				.map((tier) => ({
+					inputTokensAbove: tier.inputTokensAbove,
+					input: finiteNonNegative(tier.input),
+					output: finiteNonNegative(tier.output),
+					cacheRead: finiteNonNegative(tier.cacheRead),
+					cacheWrite: finiteNonNegative(tier.cacheWrite),
+				}))
+		: undefined;
+	return {
+		input: finiteNonNegative(candidate?.input),
+		output: finiteNonNegative(candidate?.output),
+		cacheRead: finiteNonNegative(candidate?.cacheRead),
+		cacheWrite: finiteNonNegative(candidate?.cacheWrite),
+		...(tiers && tiers.length > 0 ? { tiers } : {}),
+	};
+}
+
+function normalizeInput(input: ProviderModelDraft["input"]): ("text" | "image")[] {
+	const normalized = Array.isArray(input)
+		? input.filter((value): value is "text" | "image" => value === "text" || value === "image")
+		: [];
+	return normalized.length > 0 ? [...new Set(normalized)] : ["text"];
+}
+
+export function normalizeProviderModel(model: ProviderModelDraft): ProviderModel {
+	const { pricingSource: _pricingSource, pricingAdjustment: _pricingAdjustment, ...modelConfig } = model;
+	void _pricingSource;
+	void _pricingAdjustment;
+	if (typeof model.id !== "string") throw new Error("Provider model ID must be a string");
+	const id = model.id.trim();
+	if (id === "") throw new Error("Provider model ID must not be empty");
+	const contextWindow = positiveInteger(model.contextWindow, DEFAULT_CONTEXT_WINDOW);
+	const maxTokens = Math.min(positiveInteger(model.maxTokens, DEFAULT_MAX_TOKENS), contextWindow);
+	return {
+		...modelConfig,
+		id,
+		name: typeof model.name === "string" && model.name.trim() !== "" ? model.name.trim() : id,
+		reasoning: model.reasoning ?? false,
+		input: normalizeInput(model.input),
+		cost: normalizeCost(model.cost),
+		contextWindow,
+		maxTokens,
+	};
+}
+
+export function normalizeProviderModels(models: ProviderModelDraft[]): ProviderModel[] {
+	const seen = new Set<string>();
+	return models.map((model) => {
+		const normalized = normalizeProviderModel(model);
+		if (seen.has(normalized.id)) throw new Error(`Duplicate model ID: ${normalized.id}`);
+		seen.add(normalized.id);
+		return normalized;
+	});
+}
+
+function cloneQuality(quality: NonNullable<OfficialModelMeta["quality"]>): NonNullable<OfficialModelMeta["quality"]> {
+	return quality.map((score) => ({
+		...score,
+		...(score.confidenceInterval ? { confidenceInterval: { ...score.confidenceInterval } } : {}),
+	}));
+}
+
+function selectPricingAdjustment(
+	adapter: ProviderAdapter,
+	model: ProviderModelDraft,
+	policy = adapter.pricing,
+): ProviderPricingAdjustment | undefined {
+	return model.pricingAdjustment ?? policy?.models?.[model.id.trim()] ?? policy?.defaultAdjustment;
+}
+
+function resolveModelRegistration(
+	adapter: ProviderAdapter,
+	runtime: ProviderKitDependencies,
+	modelDrafts: ProviderModelDraft[],
+	officialPricing: Record<string, OfficialModelMeta>,
+): { models: ProviderModel[]; modelMetadata: Record<string, ProviderModelMetadata> } {
+	const enrichedDrafts = applyOfficialModelCosts(modelDrafts, officialPricing);
+	const pricingPolicy = runtime.pricingPolicies?.[adapter.id] ?? adapter.pricing;
+	const metadata: Record<string, ProviderModelMetadata> = {};
+	const adjustedDrafts = enrichedDrafts.map((model, index) => {
+		const modelId = model.id.trim();
+		const originalDraft = modelDrafts[index];
+		const officialMeta = findOfficialMeta(modelId, officialPricing);
+		const fieldSources = {
+			contextWindow:
+				originalDraft?.contextWindow !== undefined
+					? ("provider" as const)
+					: officialMeta?.contextWindow !== undefined
+						? ("official" as const)
+						: ("default" as const),
+			maxTokens:
+				originalDraft?.maxTokens !== undefined
+					? ("provider" as const)
+					: officialMeta?.maxTokens !== undefined
+						? ("official" as const)
+						: ("default" as const),
+			input:
+				originalDraft?.input !== undefined
+					? ("provider" as const)
+					: officialMeta?.input !== undefined
+						? ("official" as const)
+						: ("default" as const),
+			reasoning:
+				originalDraft?.reasoning !== undefined
+					? ("provider" as const)
+					: officialMeta?.reasoning !== undefined
+						? ("official" as const)
+						: ("default" as const),
+		};
+		const source: ProviderPricingSource | "none" =
+			model.cost === undefined ? "none" : (model.pricingSource ?? "provider");
+		const pricing = resolvePricingDetails(model.cost, source, selectPricingAdjustment(adapter, model, pricingPolicy));
+		metadata[modelId] = {
+			pricing,
+			fieldSources,
+			...(officialMeta?.quality ? { quality: cloneQuality(officialMeta.quality) } : {}),
+		};
+		return {
+			...model,
+			...(pricing.effectiveCost ? { cost: pricing.effectiveCost } : {}),
+		};
+	});
+	return { models: normalizeProviderModels(adjustedDrafts), modelMetadata: metadata };
+}
+
+function isAbortError(error: unknown): boolean {
+	return error !== null && typeof error === "object" && "name" in error && error.name === "AbortError";
+}
+
+function getErrorCode(error: unknown): string {
+	if (isAbortError(error)) return "cancelled";
+	if (error !== null && typeof error === "object" && "code" in error && typeof error.code === "string") {
+		return error.code;
+	}
+	if (error !== null && typeof error === "object" && "name" in error && error.name === "TimeoutError") {
+		return "timeout";
+	}
+	return "fetch";
+}
+
+/**
+ * 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
+ * different module context can apply official metadata later.
+ */
+export function prepareProviderRegistration(
+	adapter: ProviderAdapter,
+	runtime: ProviderKitDependencies,
+	officialPricing: Record<string, OfficialModelMeta> = {},
+	modelDrafts?: ProviderModelDraft[],
+): ProviderConfig {
+	const drafts =
+		modelDrafts ??
+		(adapter.registration?.normalizedModels === adapter.provider.models
+			? adapter.registration.modelDrafts
+			: adapter.provider.models);
+	const resolved = resolveModelRegistration(adapter, runtime, drafts, officialPricing);
+	const models = 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 };
+	adapter.catalog.modelCount = models.length;
+
+	const { models: _draftModels, refreshModels: originalRefresh, ...providerMetadata } = adapter.provider;
+	const registeredProvider: ProviderConfig = { ...providerMetadata, models };
+	if (originalRefresh) {
+		registeredProvider.refreshModels = async (options: ProviderRefreshContext) => {
+			try {
+				const refreshedModels = await originalRefresh(options);
+				const resolved = resolveModelRegistration(adapter, runtime, refreshedModels, officialPricing);
+				const normalizedModels = resolved.models;
+				registration.modelDrafts = refreshedModels;
+				registration.normalizedModels = normalizedModels;
+				registration.modelMetadata = resolved.modelMetadata;
+				adapter.provider.models = normalizedModels;
+				registeredProvider.models = normalizedModels;
+				if (adapterOwnsCatalog && adapter.catalog) {
+					adapter.catalog.modelCount = normalizedModels.length;
+				} else {
+					adapter.catalog = {
+						...(adapter.catalog ?? { source: "live" }),
+						source: "live",
+						modelCount: normalizedModels.length,
+						updatedAt: runtime.now(),
+						lastError: undefined,
+					};
+				}
+				return normalizedModels;
+			} catch (error) {
+				if (adapter.catalog && !isAbortError(error)) adapter.catalog.lastError = getErrorCode(error);
+				throw error;
+			}
+		};
+	}
+	return registeredProvider;
+}
+
+export function refreshProviderRegistrations(
+	pi: Pick<ExtensionAPI, "registerProvider">,
+	providers: readonly ProviderAdapter[],
+	runtime: ProviderKitDependencies,
+	officialPricing: Record<string, OfficialModelMeta>,
+	providerDrafts?: ReadonlyMap<ProviderAdapter, ProviderModelDraft[]>,
+): void {
+	for (const adapter of providers) {
+		registerProviderAdapter(pi, adapter, runtime, officialPricing, providerDrafts?.get(adapter));
+	}
+}
+
+export function registerProviderAdapter(
+	pi: Pick<ExtensionAPI, "registerProvider">,
+	adapter: ProviderAdapter,
+	runtime: ProviderKitDependencies,
+	officialPricing: Record<string, OfficialModelMeta> = {},
+	modelDrafts?: ProviderModelDraft[],
+): ProviderConfig {
+	const registeredProvider = prepareProviderRegistration(adapter, runtime, officialPricing, modelDrafts);
+	pi.registerProvider(adapter.id, registeredProvider);
+	return registeredProvider;
+}