@linxiraos/pi-catalog 1.1.27 → 1.2.0

package/src/provider-models/account-access.d.ts

@@ -0,0 +1,11 @@
+import type { Api, ModelSpec } from "../types";
+/**
+ * Merge per-account discovery catalogs into one list, deduped by model id.
+ *
+ * The first catalog to list an id supplies its spec; {@link ModelSpec.accountAccess}
+ * is merged from every catalog listing that id, so credential selection can
+ * route account-gated models to the accounts that serve them. Used by
+ * multi-account discovery for Codex and Antigravity, whose rosters differ per
+ * account.
+ */
+export declare function unionAccountCatalogs<TApi extends Api>(catalogs: readonly (readonly ModelSpec<TApi>[])[]): ModelSpec<TApi>[];

package/src/provider-models/account-access.ts

@@ -0,0 +1,30 @@
+import type { Api, ModelSpec } from "../types";
+
+/**
+ * Merge per-account discovery catalogs into one list, deduped by model id.
+ *
+ * The first catalog to list an id supplies its spec; {@link ModelSpec.accountAccess}
+ * is merged from every catalog listing that id, so credential selection can
+ * route account-gated models to the accounts that serve them. Used by
+ * multi-account discovery for Codex and Antigravity, whose rosters differ per
+ * account.
+ */
+export function unionAccountCatalogs<TApi extends Api>(
+	catalogs: readonly (readonly ModelSpec<TApi>[])[],
+): ModelSpec<TApi>[] {
+	const byId = new Map<string, ModelSpec<TApi>>();
+	for (const catalog of catalogs) {
+		for (const model of catalog) {
+			const existing = byId.get(model.id);
+			if (!existing) {
+				byId.set(model.id, model);
+			} else if (model.accountAccess) {
+				byId.set(model.id, {
+					...existing,
+					accountAccess: { ...existing.accountAccess, ...model.accountAccess },
+				});
+			}
+		}
+	}
+	return [...byId.values()];
+}

package/src/provider-models/cache-provider-id.ts

@@ -108,11 +108,12 @@ export function resolveModelCacheProviderId(providerId: string, options: ModelCa
 			// authoritative model rows.
 			// v3 invalidates zero-price rows written before rich lanes were priced
 			// from the KDL rate card; v4 keys the scope on the token's stable
-			// account subject instead of the rotating JWT.
+			// account subject instead of the rotating JWT; v5 drops rows that still
+			// mark the account default `isProviderDefault`, which startup now honors.
 			const baseUrl = (options.baseUrl ?? CURSOR_DEFAULT_BASE_URL).replace(/\/+$/, "");
 			const apiKey = options.apiKey ?? "";
 			const scope = `${cursorCredentialSubject(apiKey) ?? apiKey}\u0000${baseUrl}`;
-			return `cursor:rich-models-v4:${Bun.hash(scope).toString(36)}`;
+			return `cursor:rich-models-v5:${Bun.hash(scope).toString(36)}`;
 		}
 		case "charm-hyper": {
 			// Discovery is authoritative for this gateway, so a warm cache is served

package/src/provider-models/descriptors.ts

@@ -29,6 +29,7 @@ import {
 	clinePassModelManagerOptions,
 	cloudflareAiGatewayModelManagerOptions,
 	commandCodeModelManagerOptions,
+	coralbricksModelManagerOptions,
 	coreWeaveModelManagerOptions,
 	deepinfraModelManagerOptions,
 	deepseekModelManagerOptions,
@@ -78,6 +79,7 @@ import {
 	zhipuCodingPlanModelManagerOptions,
 } from "./openai-compat";
 import {
+	cloudflareWorkersAiModelManagerOptions,
 	cursorModelManagerOptions,
 	devinModelManagerOptions,
 	factoryDroidModelManagerOptions,
@@ -104,7 +106,9 @@ const MODEL_MANAGER_FACTORIES: Readonly<Partial<Record<KnownProvider, ModelManag
 	cerebras: config => cerebrasModelManagerOptions(config),
 	"charm-hyper": config => charmHyperModelManagerOptions(config),
 	"cloudflare-ai-gateway": config => cloudflareAiGatewayModelManagerOptions(config),
+	"cloudflare-workers-ai": () => cloudflareWorkersAiModelManagerOptions(),
 	commandcode: config => commandCodeModelManagerOptions(config),
+	coralbricks: config => coralbricksModelManagerOptions(config),
 	cursor: config => cursorModelManagerOptions(config),
 	deepinfra: config => deepinfraModelManagerOptions(config),
 	deepseek: config => deepseekModelManagerOptions(config),

package/src/provider-models/google.d.ts

@@ -11,8 +11,30 @@ export interface GoogleVertexModelManagerConfig {
     signal?: AbortSignal;
     fetch?: FetchImpl;
 }
+/** One Antigravity OAuth account whose `fetchAvailableModels` roster discovery reads. */
+export interface GoogleAntigravityAccount {
+    /** OAuth access token used for `Authorization: Bearer ...`. */
+    accessToken: string;
+    /**
+     * Credential identity recorded in {@link ModelSpec.accountAccess} for every
+     * model this account serves (see `oauthAccountKey` in `@linxiraos/pi-ai`).
+     * When any account lacks one, no model records per-account access.
+     */
+    accountKey?: string;
+}
 export interface GoogleAntigravityModelManagerConfig {
-    oauthToken?: string;
+    /**
+     * Resolves every configured Antigravity account at discovery time. Rosters
+     * are plan-scoped (Claude 5.5 is served to some accounts only) and
+     * authoritative, so each account's roster is fetched and the results are
+     * unioned; reading one account's roster would prune models only its
+     * siblings serve (#14924).
+     *
+     * Returns `null` to abort discovery (e.g. an account's credential failed to
+     * refresh), keeping the previous/bundled catalog instead of caching a
+     * partial one.
+     */
+    resolveAccounts?: () => Promise<readonly GoogleAntigravityAccount[] | null>;
     endpoint?: string;
     fetch?: FetchImpl;
 }

package/src/provider-models/google.ts

@@ -1,3 +1,4 @@
+import { logger } from "@linxiraos/pi-utils";
 import { reviewedCollapseTable } from "../compat/collapse";
 import { classifyModel } from "../compat/taxonomy";
 import { providerEntry } from "../compat/providers";
@@ -5,7 +6,8 @@ import { fetchAntigravityDiscoveryModels } from "../discovery/antigravity";
 import { fetchGeminiModels } from "../discovery/gemini";
 import { fetchGeminiCliQuotaModels } from "../discovery/gemini-cli";
 import type { ModelManagerOptions } from "../model-manager";
-import type { FetchImpl } from "../types";
+import type { FetchImpl, ModelSpec } from "../types";
+import { unionAccountCatalogs } from "./account-access";
 
 export interface GoogleModelManagerConfig {
 	apiKey?: string;
@@ -20,8 +22,31 @@ export interface GoogleVertexModelManagerConfig {
 	fetch?: FetchImpl;
 }
 
+/** One Antigravity OAuth account whose `fetchAvailableModels` roster discovery reads. */
+export interface GoogleAntigravityAccount {
+	/** OAuth access token used for `Authorization: Bearer ...`. */
+	accessToken: string;
+	/**
+	 * Credential identity recorded in {@link ModelSpec.accountAccess} for every
+	 * model this account serves (see `oauthAccountKey` in `@linxiraos/pi-ai`).
+	 * When any account lacks one, no model records per-account access.
+	 */
+	accountKey?: string;
+}
+
 export interface GoogleAntigravityModelManagerConfig {
-	oauthToken?: string;
+	/**
+	 * Resolves every configured Antigravity account at discovery time. Rosters
+	 * are plan-scoped (Claude 5.5 is served to some accounts only) and
+	 * authoritative, so each account's roster is fetched and the results are
+	 * unioned; reading one account's roster would prune models only its
+	 * siblings serve (#14924).
+	 *
+	 * Returns `null` to abort discovery (e.g. an account's credential failed to
+	 * refresh), keeping the previous/bundled catalog instead of caching a
+	 * partial one.
+	 */
+	resolveAccounts?: () => Promise<readonly GoogleAntigravityAccount[] | null>;
 	endpoint?: string;
 	fetch?: FetchImpl;
 }
@@ -71,18 +96,49 @@ export function googleVertexModelManagerOptions(_config?: GoogleVertexModelManag
 export function googleAntigravityModelManagerOptions(
 	config?: GoogleAntigravityModelManagerConfig,
 ): ModelManagerOptions<"google-gemini-cli"> {
-	const token = config?.oauthToken;
+	const resolveAccounts = config?.resolveAccounts;
 	return {
 		providerId: "google-antigravity",
 		dynamicModelsAuthoritative: providerEntry("google-antigravity")?.dynamicModelsAuthoritative === true,
-		...(token
+		...(resolveAccounts
 			? {
-					fetchDynamicModels: () =>
-						fetchAntigravityDiscoveryModels({
-							token,
-							endpoint: config?.endpoint,
-							fetcher: toDiscoveryFetch(config?.fetch),
-						}),
+					fetchDynamicModels: async () => {
+						const accounts = await resolveAccounts();
+						if (!accounts || accounts.length === 0) return null;
+						const fetcher = toDiscoveryFetch(config?.fetch);
+						const rosters = await Promise.all(
+							accounts.map(async account => ({
+								accountKey: account.accountKey,
+								result: await fetchAntigravityDiscoveryModels({
+									token: account.accessToken,
+									endpoint: config?.endpoint,
+									fetcher,
+								}),
+							})),
+						);
+						const catalogs: { accountKey: string | undefined; models: ModelSpec<"google-gemini-cli">[] }[] = [];
+						for (const { accountKey, result } of rosters) {
+							// A transient failure would leave the union partial; keep the previous catalog.
+							if (!result) return null;
+							if (result.rejectedStatus !== undefined) {
+								logger.warn("Antigravity model discovery skipped an account whose credential was rejected", {
+									accountKey,
+									status: result.rejectedStatus,
+								});
+								continue;
+							}
+							catalogs.push({ accountKey, models: result.models });
+						}
+						if (catalogs.length === 0) return null;
+						const tagAccess = catalogs.every(catalog => catalog.accountKey !== undefined);
+						return unionAccountCatalogs(
+							catalogs.map(({ accountKey, models }) =>
+								tagAccess && accountKey !== undefined
+									? models.map(model => ({ ...model, accountAccess: { [accountKey]: {} } }))
+									: models,
+							),
+						);
+					},
 				}
 			: undefined),
 	};
@@ -103,19 +159,19 @@ export function googleGeminiCliModelManagerOptions(
 						if (collapseTable === undefined) {
 							throw new Error("missing reviewed collapse table for google-gemini-cli");
 						}
-						const models = await fetchAntigravityDiscoveryModels({
+						const result = await fetchAntigravityDiscoveryModels({
 							token,
 							fetcher,
-							collapseTable: collapseTable,
+							collapseTable,
 						});
 						// Antigravity's fetchAvailableModels is unreachable for
 						// credentials without Antigravity entitlement (Code Assist
 						// Standard returns HTTP 403). Fall back to the account's own
 						// retrieveUserQuota list on Cloud Code Assist.
-						if (models === null) {
+						if (result === null || result.rejectedStatus !== undefined) {
 							return fetchGeminiCliQuotaModels({ token, projectId: config?.projectId, endpoint, fetcher });
 						}
-						return models
+						return result.models
 							.filter(m => classifyModel("google-gemini-cli", m.id, { lenient: true }).class === "gemini")
 							.map(m => ({
 								...m,

package/src/provider-models/openai-compat.d.ts

@@ -69,7 +69,7 @@ export interface OpenAIModelManagerConfig {
     baseUrl?: string;
     fetch?: FetchImpl;
 }
-export declare function openaiModelManagerOptions(config?: OpenAIModelManagerConfig): ModelManagerOptions<"openai-responses">;
+export declare function openaiModelManagerOptions(config?: OpenAIModelManagerConfig): ModelManagerOptions<Api>;
 /**
  * Re-derive the generated pro-reasoning aliases (`gpt-5.6-*-pro`) for the
  * first-party `openai` gpt-5.6 rows. Each alias inherits the base row's
@@ -154,6 +154,19 @@ export interface DeepinfraModelManagerConfig {
  * model availability at runtime is still gated on credentials by the registry.
  */
 export declare function deepinfraModelManagerOptions(config?: DeepinfraModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export declare const CORALBRICKS_BASE_URL = "https://inference.coralbricks.ai/v1";
+/** CoralBricks OpenAI-compatible discovery configuration. */
+export interface CoralbricksModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    fetch?: FetchImpl;
+}
+/**
+ * Builds CoralBricks' model-discovery manager. `/v1/models` is key-protected
+ * (401 without a bearer key), so a keyless config serves only the bundled
+ * reviewed seed rows; with a key, live rows are authoritative over the bundle.
+ */
+export declare function coralbricksModelManagerOptions(config?: CoralbricksModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface XaiModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
@@ -339,6 +352,11 @@ export interface OpenRouterModelManagerConfig {
     baseUrl?: string;
     fetch?: FetchImpl;
 }
+/**
+ * OpenRouter's Decisions API lives at `/api/alpha`, a sibling of the `/api/v1`
+ * chat root; derive it so a custom gateway base URL keeps both aligned.
+ */
+export declare function openrouterDecisionsBaseUrl(chatBaseUrl: string): string;
 export declare function openrouterModelManagerOptions(config?: OpenRouterModelManagerConfig): ModelManagerOptions<Api>;
 export interface ZenMuxModelManagerConfig {
     apiKey?: string;

package/src/provider-models/openai-compat.ts

@@ -1071,8 +1071,8 @@ export interface OpenAIModelManagerConfig {
 	fetch?: FetchImpl;
 }
 
-export function openaiModelManagerOptions(config?: OpenAIModelManagerConfig): ModelManagerOptions<"openai-responses"> {
-	return createOpenAICompatibleModelManagerOptions({
+export function openaiModelManagerOptions(config?: OpenAIModelManagerConfig): ModelManagerOptions<Api> {
+	const options = createOpenAICompatibleModelManagerOptions({
 		api: "openai-responses",
 		providerId: "openai",
 		defaultBaseUrl: OPENAI_API_BASE_URL,
@@ -1081,6 +1081,30 @@ export function openaiModelManagerOptions(config?: OpenAIModelManagerConfig): Mo
 		filterModel: (_entry, model, references) => isLikelyOpenAIResponsesModelId(model.id, references),
 		mapModel: mapWithBundledReference,
 	});
+	const fetchDiscovered = options.fetchDynamicModels;
+	if (!fetchDiscovered) return options;
+	return {
+		...options,
+		fetchDynamicModels: async () => appendUnbundledSeedModels("openai", await fetchDiscovered()),
+	};
+}
+
+/**
+ * Append the authored seed rows that neither discovery nor the bundled catalog
+ * carries yet: a seed added since the last models.json regeneration (the
+ * Decisions judge row) reaches runtime through a successful discovery. Seeds
+ * already bundled keep resolving through the bundled slice, and the static
+ * catalog (and with it the cache fingerprint) stays the bundled one.
+ */
+function appendUnbundledSeedModels(
+	providerId: GeneratedProvider,
+	discovered: readonly ModelSpec<Api>[] | null,
+): readonly ModelSpec<Api>[] | null {
+	if (!discovered) return null;
+	const known = new Set(getBundledModels(providerId).map(model => model.id));
+	for (const model of discovered) known.add(model.id);
+	const seeds = seedModels(providerId).filter(seed => !known.has(seed.id));
+	return seeds.length === 0 ? discovered : [...discovered, ...seeds.map(seed => ({ ...seed }))];
 }
 
 /**
@@ -1618,10 +1642,171 @@ export function deepinfraModelManagerOptions(
 	return {
 		providerId: "deepinfra",
 		dynamicModelsAuthoritative: true,
+		// `vision`/`vlm` tags are the whole truth for modality on this host.
+		dynamicInputAuthoritative: true,
 		fetchDynamicModels: () => fetchDeepinfraModels({ baseUrl, apiKey, fetch: config?.fetch, references }),
 	};
 }
 
+// ---------------------------------------------------------------------------
+// CoralBricks
+// ---------------------------------------------------------------------------
+
+export const CORALBRICKS_BASE_URL = "https://inference.coralbricks.ai/v1";
+
+/** CoralBricks OpenAI-compatible discovery configuration. */
+export interface CoralbricksModelManagerConfig {
+	apiKey?: string;
+	baseUrl?: string;
+	fetch?: FetchImpl;
+}
+
+/**
+ * The CoralBricks-specific fields of a `GET /v1/models` row: per-million USD
+ * pricing and the capability flags Coral documents as authoritative
+ * (https://www.coralbricks.ai/docs.md).
+ */
+interface CoralbricksModelRecord extends OpenAICompatibleModelRecord {
+	context_length?: unknown;
+	pricing?: unknown;
+	supports_chat?: unknown;
+	supports_image_input?: unknown;
+	supports_tools?: unknown;
+	supports_reasoning?: unknown;
+	reasoning?: unknown;
+}
+
+/**
+ * Read one live per-million price; a missing or negative field falls back to
+ * the bundled reference. An explicit `0` is a real price: the manager keeps it
+ * because `coralbricksModelManagerOptions` declares `dynamicCostAuthoritative`.
+ */
+function coralRate(value: unknown, fallback: number): number {
+	const parsed = toNumber(value);
+	return parsed !== undefined && parsed >= 0 ? parsed : fallback;
+}
+
+/**
+ * Map one CoralBricks catalog row to a chat model spec; non-chat rows
+ * (`supports_chat: false`) are dropped. Pricing arrives in Coral's own
+ * per-million field names; `cached_input_per_m` is $0 on every model and a
+ * missing field falls back to the bundled reference.
+ * Live reasoning capabilities and controls override the bundled fallback.
+ * The endpoint publishes no output cap, so `maxTokens` keeps its reference
+ * value rather than being invented from the context window.
+ */
+function mapCoralbricksModel(
+	entry: CoralbricksModelRecord,
+	defaults: ModelSpec<"openai-completions">,
+	reference: ModelSpec<"openai-completions"> | undefined,
+): ModelSpec<"openai-completions"> | null {
+	if (entry.supports_chat === false) {
+		return null;
+	}
+	const pricing = isRecord(entry.pricing) ? entry.pricing : {};
+	// A bundled reference may lend metadata, but its runner kind is not
+	// evidence the chat roster advertised it.
+	const { kind: _inheritedKind, ...chatReference } = reference ?? {};
+	const hasReasoningFlag = typeof entry.supports_reasoning === "boolean";
+	const reasoning = hasReasoningFlag
+		? entry.supports_reasoning === true
+		: (reference?.reasoning ?? defaults.reasoning);
+	const controls = isRecord(entry.reasoning) ? entry.reasoning : undefined;
+	const wireEfforts = controls?.supported_efforts;
+	let thinking = reasoning ? reference?.thinking : undefined;
+	let compat = reference?.compat;
+	if (reasoning && Array.isArray(wireEfforts)) {
+		const efforts = THINKING_EFFORTS.filter(effort => wireEfforts.includes(effort));
+		// `none` is the server's off default, not an Effort (nor `minimal`).
+		const defaultLevel = efforts.find(effort => effort === controls?.default_effort);
+		thinking =
+			efforts.length > 0
+				? {
+						mode: "effort",
+						efforts,
+						...(defaultLevel !== undefined && { defaultLevel }),
+						...(typeof controls?.mandatory === "boolean" && { requiresEffort: controls.mandatory }),
+					}
+				: undefined;
+	}
+	if (hasReasoningFlag || Array.isArray(wireEfforts)) {
+		// An explicit empty/unknown vocabulary must not regrow a guessed dial
+		// from identity or KDL. Missing legacy metadata still uses the reference.
+		compat = { ...compat, trustExplicitThinkingOnly: true };
+	}
+	if (reasoning && controls) {
+		if (controls.mandatory === true || controls.disable === null) {
+			compat = { ...compat, reasoningDisableMode: "lowest-effort" };
+		} else if (isRecord(controls.disable) && controls.disable.reasoning_effort === "none") {
+			compat = { ...compat, reasoningDisableMode: "none-effort" };
+		}
+	}
+	const input: ("text" | "image")[] =
+		entry.supports_image_input === true
+			? ["text", "image"]
+			: entry.supports_image_input === false
+				? ["text"]
+				: (reference?.input ?? defaults.input);
+	return {
+		...defaults,
+		...chatReference,
+		id: defaults.id,
+		name: reference?.name ?? defaults.name,
+		api: defaults.api,
+		provider: defaults.provider,
+		baseUrl: defaults.baseUrl,
+		reasoning,
+		thinking,
+		compat,
+		input,
+		...(typeof entry.supports_tools === "boolean" ? { supportsTools: entry.supports_tools } : {}),
+		cost: {
+			input: coralRate(pricing.input_per_m, reference?.cost.input ?? 0),
+			output: coralRate(pricing.output_per_m, reference?.cost.output ?? 0),
+			cacheRead: coralRate(pricing.cached_input_per_m, reference?.cost.cacheRead ?? 0),
+			cacheWrite: coralRate(pricing.cache_write_per_m, reference?.cost.cacheWrite ?? 0),
+		},
+		contextWindow: toPositiveNumber(entry.context_length, reference?.contextWindow ?? null),
+		maxTokens: reference?.maxTokens ?? null,
+	};
+}
+
+/**
+ * Builds CoralBricks' model-discovery manager. `/v1/models` is key-protected
+ * (401 without a bearer key), so a keyless config serves only the bundled
+ * reviewed seed rows; with a key, live rows are authoritative over the bundle.
+ */
+export function coralbricksModelManagerOptions(
+	config?: CoralbricksModelManagerConfig,
+): ModelManagerOptions<"openai-completions"> {
+	const apiKey = config?.apiKey;
+	const baseUrl = config?.baseUrl ?? CORALBRICKS_BASE_URL;
+	const references = createBundledReferenceMap<"openai-completions">("coralbricks");
+	return {
+		providerId: "coralbricks",
+		dynamicModelsAuthoritative: true,
+		dynamicReasoningAuthoritative: true,
+		// `supports_image_input` is the row's whole truth for modality (Coral
+		// answers unsupported content with `400 unsupported_content_type`).
+		dynamicInputAuthoritative: true,
+		// Coral's `pricing` block is the deployment tariff; an explicit live `0`
+		// (a free model or no cache-write charge) must not revert to the bundle.
+		dynamicCostAuthoritative: true,
+		...(apiKey && {
+			fetchDynamicModels: () =>
+				fetchOpenAICompatibleModels({
+					api: "openai-completions",
+					provider: "coralbricks",
+					baseUrl,
+					apiKey,
+					fetch: config?.fetch,
+					mapModel: (entry, defaults) =>
+						mapCoralbricksModel(entry as CoralbricksModelRecord, defaults, references.get(defaults.id)),
+				}),
+		}),
+	};
+}
+
 // ---------------------------------------------------------------------------
 // 6. xAI
 // ---------------------------------------------------------------------------
@@ -3138,8 +3323,8 @@ function openCodeModelManagerOptions(
 			},
 		},
 		...(apiKey && {
-			fetchDynamicModels: () =>
-				fetchOpenAICompatibleModels<Api>({
+			fetchDynamicModels: async () => {
+				const discovered = await fetchOpenAICompatibleModels<Api>({
 					api: "openai-completions",
 					provider: providerId,
 					baseUrl: discoveryBaseUrl,
@@ -3197,7 +3382,12 @@ function openCodeModelManagerOptions(
 						};
 					},
 					fetch: config?.fetch,
-				}),
+				});
+				if (!discovered) return null;
+				const seeds = seedModels(providerId).map(seed => ({ ...seed, baseUrl: basePath }));
+				const seedIds = new Set(seeds.map(seed => seed.id));
+				return [...discovered.filter(model => !seedIds.has(model.id)), ...seeds];
+			},
 		}),
 	};
 }
@@ -3290,8 +3480,9 @@ export interface OpenRouterModelManagerConfig {
  * OpenRouter's Decisions API lives at `/api/alpha`, a sibling of the `/api/v1`
  * chat root; derive it so a custom gateway base URL keeps both aligned.
  */
-function openrouterDecisionsBaseUrl(chatBaseUrl: string): string {
-	return chatBaseUrl.endsWith("/v1") ? `${chatBaseUrl.slice(0, -"/v1".length)}/alpha` : `${chatBaseUrl}/alpha`;
+export function openrouterDecisionsBaseUrl(chatBaseUrl: string): string {
+	const base = chatBaseUrl.replace(/\/+$/g, "");
+	return base.endsWith("/v1") ? `${base.slice(0, -"/v1".length)}/alpha` : `${base}/alpha`;
 }
 
 function mapOpenRouterThinking(entry: OpenAICompatibleModelRecord): ThinkingConfig | undefined {
@@ -4264,6 +4455,7 @@ export function syntheticModelManagerOptions(
 	return {
 		providerId: "synthetic",
 		dynamicModelsAuthoritative: true,
+		dynamicReasoningAuthoritative: true,
 		...(apiKey && {
 			fetchDynamicModels: () =>
 				fetchOpenAICompatibleModels({
@@ -6187,7 +6379,7 @@ function parseCopilotTokenPriceTier(value: unknown): CopilotTokenPriceTier | und
 		return undefined;
 	}
 	return {
-		contextMax: toNumber(value.context_max),
+		contextMax: toNumber(value.max_prompt_tokens) ?? toNumber(value.context_max),
 		inputPrice: toNumber(value.input_price),
 		outputPrice: toNumber(value.output_price),
 		cachePrice: toNumber(value.cache_price),
@@ -6303,6 +6495,9 @@ export function githubCopilotModelManagerOptions(config?: GithubCopilotModelMana
 	return {
 		providerId: "github-copilot",
 		cacheProviderId: resolveModelCacheProviderId("github-copilot", { apiKey: rawApiKey, baseUrl }),
+		// Copilot discovery pre-applies the correct image fallback for omitted
+		// `supports.vision`; the live row's modality is authoritative.
+		dynamicInputAuthoritative: true,
 		dropCachedModelIdsOnStaticMismatch: COPILOT_CACHE_INVALIDATED_MODEL_IDS,
 		// COPILOT_API_HEADERS are compile-time wire identity constants, not
 		// credentials. The cache omits all request headers for
@@ -6373,12 +6568,12 @@ export function githubCopilotModelManagerOptions(config?: GithubCopilotModelMana
 									? ["text"]
 									: (reference?.input ?? defaults.input);
 						// With COPILOT_API_HEADERS the served window is the long-context
-						// ceiling; the default tier ends at token_prices.default.context_max
-						// prompt tokens. Cap the base entry to the default tier — the long
-						// tier is the opt-in `-1m` sibling below. On tiered rows
-						// max_prompt_tokens is the default lane's prompt budget, and the
-						// billed default ceiling can overlap the long lane (#13912), so the
-						// tighter of the two bounds the base entry.
+						// ceiling; the default tier reports its prompt boundary in
+						// token_prices.default.max_prompt_tokens (or legacy context_max).
+						// Cap the base entry to the default tier — the long tier is
+						// the opt-in `-1m` sibling below. On tiered legacy rows the
+						// model-wide max_prompt_tokens may be tighter than the billed
+						// default ceiling (#13912), so use the smaller bound.
 						const tokenPrices = extractCopilotTokenPrices(entry);
 						const billedDefaultMax = tokenPrices.defaultTier?.contextMax;
 						const tieredPromptBudget =
@@ -7132,23 +7327,12 @@ const MODELS_DEV_PROVIDER_DESCRIPTORS_CODING_PLANS: readonly ModelsDevProviderDe
 			allowsSyntheticReasoningContentForToolCalls: false,
 		},
 	}),
-	// --- MiniMax Coding Plan ---
-	openAiCompletionsDescriptor("minimax-coding-plan", "minimax-code", "https://api.minimax.io/v1", {
-		compat: {
-			supportsStore: false,
-			supportsDeveloperRole: false,
-			supportsReasoningEffort: false,
-			reasoningContentField: "reasoning_content",
-		},
-	}),
-	openAiCompletionsDescriptor("minimax-cn-coding-plan", "minimax-code-cn", "https://api.minimaxi.com/v1", {
-		compat: {
-			supportsStore: false,
-			supportsDeveloperRole: false,
-			supportsReasoningEffort: false,
-			reasoningContentField: "reasoning_content",
-		},
-	}),
+	// --- MiniMax Token Plan ---
+	// MiniMax documents its Anthropic-compatible API as the recommended
+	// protocol: signed thinking blocks, `output_config.effort` depth control,
+	// and prompt-cache usage reporting.
+	anthropicMessagesDescriptor("minimax-coding-plan", "minimax-code", "https://api.minimax.io/anthropic"),
+	anthropicMessagesDescriptor("minimax-cn-coding-plan", "minimax-code-cn", "https://api.minimaxi.com/anthropic"),
 	// --- Alibaba Coding Plan ---
 	openAiCompletionsDescriptor(
 		"alibaba-coding-plan",

package/src/provider-models/special.d.ts

@@ -65,6 +65,8 @@ export declare function devinModelManagerOptions(config?: DevinModelManagerConfi
 export declare function factoryDroidModelManagerOptions(config?: FactoryDroidModelDiscoveryOptions): ModelManagerOptions<"factory-droid-agent">;
 export declare function localModelManagerOptions(): ModelManagerOptions<"local-inference">;
 export declare function webModelManagerOptions(): ModelManagerOptions<"web-search">;
+/** Cloudflare Workers AI judges: the authored Clef rows; the account id resolves per request. */
+export declare function cloudflareWorkersAiModelManagerOptions(): ModelManagerOptions<"workers-ai-systemone">;
 /** Credentials and endpoint overrides for the TypeSafe catalog manager. */
 export interface TypeSafeModelManagerConfig {
     apiKey?: string;