pi-meta-oauth 0.7.0 → 0.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-meta-oauth",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Meta Model API OAuth provider for pi",
   "keywords": [
     "pi-package",
@@ -14,7 +14,8 @@
   "files": [
     "LICENSE",
     "README.md",
-    "extensions/"
+    "extensions/",
+    "src/"
   ],
   "repository": {
     "type": "git",
@@ -35,13 +36,18 @@
     "@earendil-works/pi-coding-agent": ">=0.83.0 <0.88.0"
   },
   "devDependencies": {
+    "@biomejs/biome": "2.5.15",
     "@earendil-works/pi-ai": "0.87.1",
     "@earendil-works/pi-coding-agent": "0.87.1",
     "bun-types": "latest",
     "typescript": "^5.9.0"
   },
   "scripts": {
+    "check": "biome check . && bun run typecheck && bun run test",
+    "lint": "biome check .",
+    "format": "biome check --write .",
     "typecheck": "tsc --noEmit",
-    "test": "bun test"
+    "test": "bun run scripts/test.ts",
+    "test:live": "bun run scripts/test.ts --live"
   }
 }

package/src/meta/constants.ts

@@ -0,0 +1,28 @@
+export const META_PROVIDER_ID = "meta";
+export const META_API_BASE_URL = "https://api.meta.ai/v1";
+export const META_MODEL_CATALOG_URL = `${META_API_BASE_URL}/models`;
+export const META_AUTH_BASE_URL = "https://auth.meta.com";
+export const META_CLIENT_ID = "1031625952748946";
+export const META_API_VERSION = "1.0.0";
+export const META_ENV_VAR = "META_API_KEY";
+export const MODEL_API_ENV_VAR = "MODEL_API_KEY";
+
+export const DEVICE_AUTHORIZATION_URL = `${META_AUTH_BASE_URL}/oidc/device/authorization/`;
+export const DEVICE_TOKEN_URL = `${META_AUTH_BASE_URL}/oidc/device/token/`;
+export const API_KEY_MINT_URL = "https://api.meta.ai/muse-code/key";
+export const DEVICE_CODE_GRANT = "urn:ietf:params:oauth:grant-type:device_code";
+export const API_KEY_REFRESH_INTERVAL_MS = 24 * 60 * 60 * 1000;
+/** Bound each OAuth or mint request, matching Pi's built-in Meta flow. */
+export const META_REQUEST_TIMEOUT_MS = 30_000;
+
+/**
+ * Captured Muse CLI fingerprint. Preserve its bytes, including the platform
+ * segment: alternative fingerprints have not been verified. This is an
+ * opt-in compatibility workaround for Contributor `max`, not a supported API
+ * contract; see the README for its account and compatibility implications.
+ */
+export const MUSE_USER_AGENT =
+	"muse-build/1.3.0 (non-interactive; linux-x86_64; build ac7280f2aca67769d1455a8847bb502b617d50f6)";
+/** Set to `1`, `true`, or `yes` to enable the Muse fingerprint. */
+export const MUSE_USER_AGENT_ENV_VAR = "META_MUSE_USER_AGENT";
+export const META_PROMPT_CACHE_RETENTION = "24h";

package/src/meta/environment.ts

@@ -0,0 +1,17 @@
+import { META_ENV_VAR, MODEL_API_ENV_VAR } from "./constants.ts";
+import type { MetaEnv } from "./types.ts";
+
+/** Pi treats an empty $META_API_KEY as unset, and a blank one is never a usable key. */
+function isMissing(value: string | undefined): boolean {
+	return !value?.trim();
+}
+
+/** Pi interpolates $META_API_KEY; Muse tooling may use MODEL_API_KEY. */
+export function synchronizeMetaApiKeyAliases(env: MetaEnv): void {
+	if (isMissing(env[META_ENV_VAR]) && !isMissing(env[MODEL_API_ENV_VAR])) {
+		env[META_ENV_VAR] = env[MODEL_API_ENV_VAR];
+	}
+	if (isMissing(env[MODEL_API_ENV_VAR]) && !isMissing(env[META_ENV_VAR])) {
+		env[MODEL_API_ENV_VAR] = env[META_ENV_VAR];
+	}
+}

package/src/meta/http.ts

@@ -0,0 +1,83 @@
+import { META_REQUEST_TIMEOUT_MS } from "./constants.ts";
+import type { Fetch } from "./types.ts";
+
+/** A request outlived its own timeout while the caller's signal stayed live. */
+export class RequestTimeoutError extends Error {
+	override name = "RequestTimeoutError";
+}
+
+/** Keep untrusted JSON as unknown until its fields have been validated. */
+export function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value !== null && typeof value === "object" && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+export async function responseBody(
+	response: Response,
+): Promise<Record<string, unknown>> {
+	const text = await response.text();
+	if (!text) return {};
+	try {
+		return asRecord(JSON.parse(text)) ?? {};
+	} catch {
+		return {};
+	}
+}
+
+export function errorDetail(body: Record<string, unknown>): string | undefined {
+	for (const key of ["error_description", "detail", "message", "error"]) {
+		const value = body[key];
+		if (typeof value === "string" && value.trim()) return value.trim();
+	}
+	return undefined;
+}
+
+/**
+ * Run one request under the caller's signal and its own timeout, so a stalled
+ * connection cannot hang a login or refresh. Only a timeout the caller did not
+ * cause becomes a RequestTimeoutError; caller cancellation passes through.
+ */
+export async function withRequestTimeout<T>(
+	signal: AbortSignal | undefined,
+	timeoutMs: number,
+	request: (signal: AbortSignal) => Promise<T>,
+): Promise<T> {
+	const timeout = AbortSignal.timeout(timeoutMs);
+	try {
+		return await request(signal ? AbortSignal.any([signal, timeout]) : timeout);
+	} catch (error) {
+		if (timeout.aborted && !signal?.aborted) {
+			throw new RequestTimeoutError(`Request timed out after ${timeoutMs} ms`, {
+				cause: error,
+			});
+		}
+		throw error;
+	}
+}
+
+export async function postForm(
+	url: string,
+	fields: Record<string, string>,
+	fetchImpl: Fetch,
+	signal?: AbortSignal,
+	timeoutMs = META_REQUEST_TIMEOUT_MS,
+): Promise<{ response: Response; body: Record<string, unknown> }> {
+	return withRequestTimeout(signal, timeoutMs, async (requestSignal) => {
+		const response = await fetchImpl(url, {
+			method: "POST",
+			headers: {
+				Accept: "application/json",
+				"Content-Type": "application/x-www-form-urlencoded",
+			},
+			body: new URLSearchParams(fields),
+			redirect: "manual",
+			signal: requestSignal,
+		});
+		return { response, body: await responseBody(response) };
+	});
+}
+
+export function delay(milliseconds: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}

package/src/meta/model-store.ts

@@ -0,0 +1,183 @@
+import type {
+	Model,
+	ModelsStoreEntry,
+	RefreshModelsContext,
+} from "@earendil-works/pi-ai";
+import {
+	META_API_BASE_URL,
+	META_API_VERSION,
+	META_MODEL_CATALOG_URL,
+	META_PROVIDER_ID,
+} from "./constants.ts";
+import { asRecord, errorDetail, responseBody } from "./http.ts";
+import {
+	fallbackModels,
+	restoreProviderModels,
+	toProviderModels,
+} from "./models.ts";
+import type { Fetch, MetaProviderModel } from "./types.ts";
+
+/**
+ * Pi >=0.86.1 refreshes its built-in pi.dev `meta` overlay before this extension, through the same
+ * models-store key, so persisted entries carry a provenance marker.
+ */
+const STORE_SOURCE = "pi-meta-oauth";
+
+type OwnedStoreEntry = ModelsStoreEntry & { source: typeof STORE_SOURCE };
+
+interface LegacyCatalogStore {
+	read(): Promise<unknown>;
+	write(entry: ModelsStoreEntry): Promise<void>;
+}
+
+/** The runtime adapter spans Pi 0.83's store and Pi 0.84+'s snapshot/publication API. */
+interface CompatibleRefreshContext {
+	credential?: RefreshModelsContext["credential"];
+	allowNetwork: boolean;
+	signal?: AbortSignal;
+	store?: LegacyCatalogStore;
+	stored?: Readonly<ModelsStoreEntry>;
+	publish?(publication: {
+		persist?: ModelsStoreEntry | null;
+	}): Promise<boolean>;
+}
+
+/** Accept marked entries and unmarked ones from older releases; pi.dev overlays set lastModified whenever they persist a catalog. */
+function isOwnedEntry(value: unknown): boolean {
+	const entry = asRecord(value);
+	if (!entry) return false;
+	if (entry.source === STORE_SOURCE) return true;
+	return (
+		entry.source === undefined &&
+		entry.lastModified === undefined &&
+		entry.etag === undefined
+	);
+}
+
+async function cachedOrFallbackModels(
+	context: CompatibleRefreshContext,
+): Promise<MetaProviderModel[]> {
+	try {
+		const stored = context.stored ?? (await context.store?.read());
+		if (isOwnedEntry(stored)) {
+			const models = restoreProviderModels(asRecord(stored)?.models);
+			if (models.length > 0) return models;
+		}
+	} catch {
+		// Persistence is best-effort; an unreadable cache must not disable the provider.
+	}
+	return fallbackModels();
+}
+
+/** Undo a pi.dev overlay write from this refresh so the last good Meta catalog stays persisted. */
+async function republishOwnedEntry(
+	context: CompatibleRefreshContext,
+): Promise<void> {
+	const stored = context.stored;
+	if (context.signal?.aborted || !context.publish || !stored) return;
+	if (!isOwnedEntry(stored)) return;
+	// Keep the original checkedAt: this refresh did not validate the catalog.
+	const entry: OwnedStoreEntry = {
+		...stored,
+		lastModified: 0,
+		source: STORE_SOURCE,
+	};
+	try {
+		await context.publish({ persist: entry });
+	} catch {
+		// The restored catalog remains usable when its persistence fails.
+	}
+}
+
+async function restoreAfterFailedRefresh(
+	context: CompatibleRefreshContext,
+): Promise<MetaProviderModel[]> {
+	await republishOwnedEntry(context);
+	return cachedOrFallbackModels(context);
+}
+
+function modelsForStore(
+	models: MetaProviderModel[],
+): Model<"openai-responses">[] {
+	return models.map((model) => {
+		const detached = structuredClone(model);
+		return {
+			...detached,
+			api: "openai-responses",
+			provider: META_PROVIDER_ID,
+			baseUrl: detached.baseUrl ?? META_API_BASE_URL,
+		};
+	});
+}
+
+async function persistModels(
+	context: CompatibleRefreshContext,
+	models: MetaProviderModel[],
+): Promise<void> {
+	const entry: OwnedStoreEntry = {
+		models: modelsForStore(models),
+		checkedAt: Date.now(),
+		// Pi's overlay reads lastModified 0 as "no pi.dev catalog" and skips pi.dev while this entry is fresh.
+		lastModified: 0,
+		source: STORE_SOURCE,
+	};
+	if (context.publish) {
+		// A false result means this generation was superseded; never bypass that check with a legacy write.
+		await context.publish({ persist: entry });
+	} else {
+		await context.store?.write(entry);
+	}
+}
+
+function modelApiKey(context: CompatibleRefreshContext): string | undefined {
+	const credential = context.credential;
+	if (credential?.type === "oauth") return credential.access;
+	if (credential?.type === "api_key") return credential.key;
+	return undefined;
+}
+
+/** Restore an offline catalog or refresh it using the effective OAuth/API-key credential. */
+export async function refreshMetaModels(
+	context: RefreshModelsContext,
+	fetchImpl: Fetch = fetch,
+): Promise<MetaProviderModel[]> {
+	// Pi 0.83 is outside the installed type declarations, but shares these runtime fields.
+	const compatibleContext = context as unknown as CompatibleRefreshContext;
+	const apiKey = modelApiKey(compatibleContext);
+	if (!context.allowNetwork || context.signal?.aborted || !apiKey) {
+		return cachedOrFallbackModels(compatibleContext);
+	}
+
+	try {
+		const response = await fetchImpl(META_MODEL_CATALOG_URL, {
+			headers: {
+				Accept: "application/json",
+				Authorization: `Bearer ${apiKey}`,
+				"x-api-version": META_API_VERSION,
+			},
+			signal: context.signal,
+		});
+		const body = await responseBody(response);
+		if (!response.ok) {
+			const detail = errorDetail(body);
+			throw new Error(
+				`Meta model catalog failed (HTTP ${response.status})${detail ? `: ${detail}` : ""}`,
+			);
+		}
+		const models = toProviderModels(body);
+		if (models.length === 0)
+			return restoreAfterFailedRefresh(compatibleContext);
+		if (!context.signal?.aborted) {
+			try {
+				await persistModels(compatibleContext, models);
+			} catch {
+				// The fresh catalog remains usable when its persistence fails.
+			}
+		}
+		return models;
+	} catch (error) {
+		// An in-flight cancellation belongs to the host; do not disguise it as a successful refresh.
+		if (context.signal?.aborted) throw error;
+		return restoreAfterFailedRefresh(compatibleContext);
+	}
+}

package/src/meta/models.ts

@@ -0,0 +1,355 @@
+import { META_API_BASE_URL, META_PROVIDER_ID } from "./constants.ts";
+import { asRecord } from "./http.ts";
+import { gateMuseMaxEffort } from "./muse-policy.ts";
+import type {
+	MetaEnv,
+	MetaProviderModel,
+	MetaResponsesCompat,
+} from "./types.ts";
+
+const DEFAULT_CONTEXT_WINDOW = 1_048_576;
+const DEFAULT_MAX_TOKENS = 256_000;
+const STANDARD_COST = {
+	input: 1.25,
+	output: 4.25,
+	cacheRead: 0.15,
+	cacheWrite: 0,
+};
+const CONTRIBUTOR_COST = {
+	input: 0.1,
+	output: 0.2,
+	cacheRead: 0.002,
+	cacheWrite: 0,
+};
+const UNKNOWN_MODEL_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+const THINKING_LEVELS = [
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max",
+] as const;
+type ThinkingLevelMap = NonNullable<MetaProviderModel["thinkingLevelMap"]>;
+
+/** Data-only definitions; callers always receive fresh model objects. */
+const FALLBACK_DEFINITIONS = [
+	{
+		id: "muse-spark-1.3",
+		name: "Muse Spark 1.3",
+		cost: STANDARD_COST,
+		max: true,
+	},
+	{
+		id: "muse-spark-1.3-contributor",
+		name: "Muse Spark 1.3 Contributor",
+		cost: CONTRIBUTOR_COST,
+		max: false,
+	},
+	{
+		id: "muse-spark-1.2",
+		name: "Muse Spark 1.2",
+		cost: STANDARD_COST,
+		max: false,
+	},
+	{
+		id: "muse-spark-1.2-contributor",
+		name: "Muse Spark 1.2 Contributor",
+		cost: CONTRIBUTOR_COST,
+		max: false,
+	},
+	{
+		id: "muse-spark-1.1",
+		name: "Muse Spark 1.1",
+		cost: STANDARD_COST,
+		max: false,
+	},
+] as const;
+
+function nonemptyString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function positiveInteger(value: unknown, fallback: number): number {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0
+		? value
+		: fallback;
+}
+
+function numericCost(value: unknown, fallback: number): number {
+	const number =
+		typeof value === "number"
+			? value
+			: typeof value === "string" && value.trim()
+				? Number(value)
+				: Number.NaN;
+	return Number.isFinite(number) && number >= 0 ? number : fallback;
+}
+
+function defaultThinkingLevels(max: boolean): ThinkingLevelMap {
+	return {
+		off: null,
+		minimal: "minimal",
+		low: "low",
+		medium: "medium",
+		high: "high",
+		xhigh: "xhigh",
+		max: max ? "max" : null,
+	};
+}
+
+function displayName(id: string): string {
+	return id
+		.split("-")
+		.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+		.join(" ");
+}
+
+function defaultModel(id: string): MetaProviderModel {
+	const definition = FALLBACK_DEFINITIONS.find((model) => model.id === id);
+	const cost = definition?.cost ?? UNKNOWN_MODEL_COST;
+	return {
+		id,
+		name: definition?.name ?? displayName(id),
+		reasoning: true,
+		thinkingLevelMap: defaultThinkingLevels(definition?.max ?? false),
+		input: definition ? ["text", "image"] : ["text"],
+		cost: { ...cost },
+		contextWindow: DEFAULT_CONTEXT_WINDOW,
+		maxTokens: DEFAULT_MAX_TOKENS,
+		compat: { supportsReasoningEffort: true, supportsToolSearch: true },
+	};
+}
+
+export function fallbackModels(
+	env: MetaEnv = process.env,
+): MetaProviderModel[] {
+	return FALLBACK_DEFINITIONS.map(({ id }) =>
+		gateMuseMaxEffort(defaultModel(id), env),
+	);
+}
+
+export function metaFallbackCost(
+	modelId: string,
+): MetaProviderModel["cost"] | undefined {
+	const definition = FALLBACK_DEFINITIONS.find((model) => model.id === modelId);
+	return definition ? { ...definition.cost } : undefined;
+}
+
+function modelInput(
+	value: unknown,
+	fallback: MetaProviderModel["input"],
+): MetaProviderModel["input"] {
+	if (!Array.isArray(value)) return [...fallback];
+	return value.includes("image") ? ["text", "image"] : ["text"];
+}
+
+function catalogThinkingLevels(
+	variants: unknown,
+	fallback: ThinkingLevelMap,
+): ThinkingLevelMap {
+	const entries = asRecord(variants);
+	const map: ThinkingLevelMap = { ...fallback };
+	for (const level of THINKING_LEVELS) {
+		const effort = nonemptyString(asRecord(entries?.[level])?.reasoningEffort);
+		if (effort !== undefined) map[level] = effort;
+	}
+	return map;
+}
+
+/** Validate each remote field independently so one malformed entry cannot discard the catalog. */
+export function toProviderModels(catalog: unknown): MetaProviderModel[] {
+	const data = asRecord(catalog)?.data;
+	if (!Array.isArray(data)) return [];
+	const models: MetaProviderModel[] = [];
+	const seen = new Set<string>();
+	for (const value of data) {
+		const entry = asRecord(value);
+		const id = nonemptyString(entry?.id);
+		if (!id || seen.has(id)) continue;
+		const metadata = asRecord(asRecord(entry?.metadata)?.["muse-code"]);
+		if (metadata?.is_hidden === true) continue;
+		const fallback = defaultModel(id);
+		const name = nonemptyString(metadata?.name);
+		const cost = asRecord(metadata?.cost);
+		const limit = asRecord(metadata?.limit);
+		models.push(
+			gateMuseMaxEffort({
+				...fallback,
+				name: name && name !== id ? name : fallback.name,
+				reasoning:
+					typeof metadata?.reasoning === "boolean"
+						? metadata.reasoning
+						: fallback.reasoning,
+				thinkingLevelMap: catalogThinkingLevels(
+					metadata?.variants,
+					fallback.thinkingLevelMap ?? {},
+				),
+				input: modelInput(
+					asRecord(metadata?.modalities)?.input,
+					fallback.input,
+				),
+				cost: {
+					input: numericCost(cost?.input, fallback.cost.input),
+					output: numericCost(cost?.output, fallback.cost.output),
+					cacheRead: numericCost(cost?.cached, fallback.cost.cacheRead),
+					cacheWrite: 0,
+				},
+				contextWindow: positiveInteger(limit?.context, fallback.contextWindow),
+				maxTokens: positiveInteger(limit?.output, fallback.maxTokens),
+			}),
+		);
+		seen.add(id);
+	}
+	return models;
+}
+
+function storedThinkingLevels(
+	value: unknown,
+	fallback: ThinkingLevelMap,
+): ThinkingLevelMap {
+	const entries = asRecord(value);
+	const map: ThinkingLevelMap = { ...fallback };
+	for (const level of ["off", ...THINKING_LEVELS] as const) {
+		if (entries?.[level] === null) map[level] = null;
+		else {
+			const effort = nonemptyString(entries?.[level]);
+			if (effort !== undefined) map[level] = effort;
+		}
+	}
+	return map;
+}
+
+const COMPAT_BOOLEAN_KEYS = [
+	"supportsReasoningEffort",
+	"supportsToolSearch",
+	"supportsDeveloperRole",
+	"supportsMidConvoSystemMessages",
+	"supportsLongCacheRetention",
+	"supportsStrictMode",
+	"supportsOpenAIGrammarTools",
+	"supportsAdditionalTools",
+	"supportsExplicitPromptCacheMode",
+	"supportsMaxOutputTokens",
+] as const satisfies readonly (keyof MetaResponsesCompat)[];
+
+function storedCompat(value: unknown): MetaResponsesCompat {
+	const entries = asRecord(value);
+	const compat: MetaResponsesCompat = {
+		supportsReasoningEffort: true,
+		supportsToolSearch: true,
+	};
+	for (const key of COMPAT_BOOLEAN_KEYS) {
+		if (typeof entries?.[key] === "boolean") compat[key] = entries[key];
+	}
+	const sessionAffinity = entries?.sessionAffinityFormat;
+	if (
+		sessionAffinity === "openai" ||
+		sessionAffinity === "openai-nosession" ||
+		sessionAffinity === "openrouter"
+	) {
+		compat.sessionAffinityFormat = sessionAffinity;
+	}
+	return compat;
+}
+
+function storedHeaders(value: unknown): Record<string, string> | undefined {
+	const entries = asRecord(value);
+	if (!entries) return undefined;
+	const headers = Object.fromEntries(
+		Object.entries(entries).filter(
+			(entry): entry is [string, string] => typeof entry[1] === "string",
+		),
+	);
+	return Object.keys(headers).length ? headers : undefined;
+}
+
+type CachedCostTier = Pick<
+	MetaProviderModel["cost"],
+	"input" | "output" | "cacheRead" | "cacheWrite"
+> & {
+	inputTokensAbove: number;
+};
+type CachedCost = MetaProviderModel["cost"] & { tiers?: CachedCostTier[] };
+
+function storedCost(
+	value: unknown,
+	fallback: MetaProviderModel["cost"],
+): CachedCost {
+	const entries = asRecord(value);
+	const cost: CachedCost = {
+		input: numericCost(entries?.input, fallback.input),
+		output: numericCost(entries?.output, fallback.output),
+		cacheRead: numericCost(entries?.cacheRead, fallback.cacheRead),
+		cacheWrite: numericCost(entries?.cacheWrite, fallback.cacheWrite),
+	};
+	if (Array.isArray(entries?.tiers)) {
+		const tiers: CachedCostTier[] = [];
+		for (const valueTier of entries.tiers) {
+			const tier = asRecord(valueTier);
+			const inputTokensAbove = tier?.inputTokensAbove;
+			if (
+				typeof inputTokensAbove !== "number" ||
+				!Number.isSafeInteger(inputTokensAbove) ||
+				inputTokensAbove < 0
+			)
+				continue;
+			const rates = {
+				input: numericCost(tier?.input, Number.NaN),
+				output: numericCost(tier?.output, Number.NaN),
+				cacheRead: numericCost(tier?.cacheRead, Number.NaN),
+				cacheWrite: numericCost(tier?.cacheWrite, Number.NaN),
+			};
+			if (Object.values(rates).every(Number.isFinite))
+				tiers.push({ ...rates, inputTokensAbove });
+		}
+		if (tiers.length > 0) cost.tiers = tiers;
+	}
+	return cost;
+}
+
+/** Cache contents cross the same untrusted-data boundary as the remote catalog. */
+export function restoreProviderModels(value: unknown): MetaProviderModel[] {
+	if (!Array.isArray(value)) return [];
+	const models: MetaProviderModel[] = [];
+	const seen = new Set<string>();
+	for (const valueEntry of value) {
+		const entry = asRecord(valueEntry);
+		if (
+			entry?.provider !== META_PROVIDER_ID ||
+			entry.api !== "openai-responses"
+		)
+			continue;
+		const id = nonemptyString(entry.id);
+		if (!id || seen.has(id)) continue;
+		const fallback = defaultModel(id);
+		models.push(
+			gateMuseMaxEffort({
+				...fallback,
+				name: nonemptyString(entry.name) ?? fallback.name,
+				api: "openai-responses",
+				// The extension only persists the direct endpoint; a cached URL must never redirect the key.
+				baseUrl: META_API_BASE_URL,
+				reasoning:
+					typeof entry.reasoning === "boolean"
+						? entry.reasoning
+						: fallback.reasoning,
+				thinkingLevelMap: storedThinkingLevels(
+					entry.thinkingLevelMap,
+					fallback.thinkingLevelMap ?? {},
+				),
+				input: modelInput(entry.input, fallback.input),
+				cost: storedCost(entry.cost, fallback.cost),
+				contextWindow: positiveInteger(
+					entry.contextWindow,
+					fallback.contextWindow,
+				),
+				maxTokens: positiveInteger(entry.maxTokens, fallback.maxTokens),
+				headers: storedHeaders(entry.headers),
+				compat: storedCompat(entry.compat),
+			}),
+		);
+		seen.add(id);
+	}
+	return models;
+}