@oh-my-pi/pi-catalog 18.4.4 → 18.4.6

package/src/models.ts

@@ -6,6 +6,7 @@ import type {
 	KnownProvider,
 	Model,
 	ModelCost,
+	ModelPricingStatus,
 	TimeBasedCost,
 	TokenCost,
 	Usage,
@@ -44,6 +45,11 @@ function getProviderModels(provider: string): Map<string, Model<Api>> | undefine
 
 export type GeneratedProvider = keyof typeof MODELS;
 
+/** Whether `provider` has bundled rows in models.json (e.g. a provider id authored in KDL). */
+export function isGeneratedProvider(provider: string): provider is GeneratedProvider {
+	return Object.hasOwn(MODELS, provider);
+}
+
 export function getBundledModel<TApi extends Api = Api>(provider: GeneratedProvider, modelId: string): Model<TApi> {
 	const providerModels = getProviderModels(provider);
 	return providerModels?.get(modelId) as Model<TApi>;
@@ -57,6 +63,13 @@ export function getBundledModels(provider: GeneratedProvider): Model<Api>[] {
 	const models = getProviderModels(provider);
 	return models ? (Array.from(models.values()) as Model<Api>[]) : [];
 }
+/** Resolve display semantics without mistaking an absent rate card for a free model. */
+export function getModelPricingStatus(model: Pick<Model<Api>, "cost" | "pricingStatus">): ModelPricingStatus {
+	const cost = model.cost;
+	if (cost.input !== 0 || cost.output !== 0 || cost.cacheRead !== 0 || cost.cacheWrite !== 0) return "fixed";
+	return model.pricingStatus ?? "unknown";
+}
+
 function resolveTokenCost(cost: ModelCost, promptInputTokens: number, timestamp: number | undefined): TokenCost {
 	let rates: ModelCost | EffectiveTokenCost = cost;
 	let effectiveFrom = -Infinity;

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

@@ -1,5 +1,7 @@
 import { CHARM_HYPER_API_BASE_URL, normalizeCharmHyperBaseUrl } from "../wire/charm-hyper";
 import { CODEX_CLIENT_VERSION } from "../wire/codex";
+import { CURSOR_DEFAULT_BASE_URL } from "../wire/cursor";
+import { type AccountScope, factoryDroidModelCacheProviderId } from "../wire/factory-droid";
 import { PERSONAL_GITHUB_COPILOT_BASE_URL } from "../wire/github-copilot";
 import {
 	SINGULARITYAPI_DEV_API_BASE_URL,
@@ -7,7 +9,7 @@ import {
 	normalizeSingularityApiBaseUrl,
 } from "../wire/singularityapi";
 
-export interface ModelCacheProviderIdOptions {
+export interface ModelCacheProviderIdOptions extends AccountScope {
 	apiKey?: string;
 	baseUrl?: string;
 }
@@ -17,6 +19,8 @@ const CREDENTIAL_SCOPED_MODEL_CACHE_PROVIDERS: Readonly<Record<string, true>> =
 	"opencode-zen": true,
 	"github-copilot": true,
 	"muse-code": true,
+	cursor: true,
+	"factory-droid": true,
 	// Both SingularityAPI rosters are issued per key, so the namespace must be
 	// resolved with the credential (`hydrateCredentialScopedModelCaches`) rather
 	// than from the synchronous, credential-less startup read.
@@ -66,6 +70,24 @@ export function resolveOllamaModelCacheProviderId(providerId: string, baseUrl?:
 	return `${providerId}:ollama-models-v1:${Bun.hash(endpoint).toString(36)}`;
 }
 
+/**
+ * The `sub` claim of a Cursor access token. Cursor access tokens are JWTs
+ * that `refreshCursorToken` rotates (new `exp`/`iat`) for the same account,
+ * so the subject is the stable account scope. Non-JWT keys return undefined.
+ */
+function cursorCredentialSubject(apiKey: string): string | undefined {
+	const parts = apiKey.split(".");
+	if (parts.length !== 3 || !parts[1]) return undefined;
+	try {
+		const payload: unknown = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf-8"));
+		if (typeof payload !== "object" || payload === null) return undefined;
+		const subject = Reflect.get(payload, "sub");
+		return typeof subject === "string" && subject.length > 0 ? `sub:${subject}` : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
 /** Resolve the cache namespace used by a provider's model-manager options without constructing those options. */
 export function resolveModelCacheProviderId(providerId: string, options: ModelCacheProviderIdOptions = {}): string {
 	switch (providerId) {
@@ -74,11 +96,18 @@ export function resolveModelCacheProviderId(providerId: string, options: ModelCa
 			return `${providerId}:${CODEX_CLIENT_VERSION}`;
 		case "ollama":
 			return resolveOllamaModelCacheProviderId(providerId, options.baseUrl);
-		case "cursor":
-			// v4: Grok 4.5/4.6 rows cached before the effort-less default-tier fix
-			// carry `requestModelId: *-low`, which the Start plan refuses; refetch
-			// so the collapsed default is re-pointed to `-medium` (issue #9478).
-			return "cursor:default-effort-v4";
+		case "cursor": {
+			// Cursor catalogs are entitlement-, admin-policy-, and privacy-mode
+			// scoped. A credential switch must never reuse another account's
+			// 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.
+			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)}`;
+		}
 		case "charm-hyper": {
 			// Discovery is authoritative for this gateway, so a warm cache is served
 			// for its full TTL without re-probing: the namespace must follow the
@@ -167,6 +196,8 @@ export function resolveModelCacheProviderId(providerId: string, options: ModelCa
 			const scope = `${options.apiKey ?? ""}\u0000${baseUrl}`;
 			return `github-copilot:models-v2:${Bun.hash(scope).toString(36)}`;
 		}
+		case "factory-droid":
+			return factoryDroidModelCacheProviderId(options);
 		case "openrouter":
 			return "openrouter:pseudo-api";
 		case "vllm": {

package/src/provider-models/descriptor-types.ts

@@ -1,9 +1,10 @@
 import type { CompiledProviderDiscovery } from "../compat/types";
 import type { ModelManagerOptions } from "../model-manager";
 import type { Api, FetchImpl } from "../types";
+import type { AccountScope } from "../wire/factory-droid";
 
 /** Config passed to a provider's runtime model-manager factory. */
-export type ModelManagerConfig = {
+export type ModelManagerConfig = AccountScope & {
 	apiKey?: string;
 	baseUrl?: string;
 	fetch?: FetchImpl;

package/src/provider-models/descriptors.ts

@@ -37,6 +37,7 @@ import {
 	githubCopilotModelManagerOptions,
 	gmiCloudModelManagerOptions,
 	groqModelManagerOptions,
+	helmcodeModelManagerOptions,
 	huggingfaceModelManagerOptions,
 	kiloModelManagerOptions,
 	kimiCodeModelManagerOptions,
@@ -79,6 +80,7 @@ import {
 import {
 	cursorModelManagerOptions,
 	devinModelManagerOptions,
+	factoryDroidModelManagerOptions,
 	gitLabDuoWorkflowModelManagerOptions,
 	localModelManagerOptions,
 	typesafeModelManagerOptions,
@@ -107,6 +109,7 @@ const MODEL_MANAGER_FACTORIES: Readonly<Partial<Record<KnownProvider, ModelManag
 	deepinfra: config => deepinfraModelManagerOptions(config),
 	deepseek: config => deepseekModelManagerOptions(config),
 	devin: config => devinModelManagerOptions(config),
+	"factory-droid": config => factoryDroidModelManagerOptions(config),
 	"cline-pass": config => clinePassModelManagerOptions(config),
 	firepass: config => firepassModelManagerOptions(config),
 	fireworks: config => fireworksModelManagerOptions(config),
@@ -116,6 +119,7 @@ const MODEL_MANAGER_FACTORIES: Readonly<Partial<Record<KnownProvider, ModelManag
 	google: config => googleModelManagerOptions(config),
 	"google-vertex": config => googleVertexModelManagerOptions(config),
 	groq: config => groqModelManagerOptions(config),
+	helmcode: config => helmcodeModelManagerOptions(config),
 	huggingface: config => huggingfaceModelManagerOptions(config),
 	kilo: config => kiloModelManagerOptions(config),
 	"kimi-code": config => kimiCodeModelManagerOptions(config),

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

@@ -1257,6 +1257,81 @@ export function huggingfaceModelManagerOptions(
 	return createSimpleOpenAICompletionsOptions("huggingface", "https://router.huggingface.co/v1", config);
 }
 
+// ---------------------------------------------------------------------------
+// 4.5 Helmcode
+// ---------------------------------------------------------------------------
+
+export interface HelmcodeModelManagerConfig {
+	apiKey?: string;
+	baseUrl?: string;
+	fetch?: FetchImpl;
+}
+
+/**
+ * First-party hosts of the models Helmcode resells (helmcode.com/docs/models,
+ * "Frontier models"). Resold ids resolve only against these rows: the global
+ * bare-id index picks whichever gateway row wins a context/output tie, which
+ * can carry a zero or marked-up price instead of the vendor list price.
+ */
+const HELMCODE_RESOLD_VENDORS = ["anthropic", "openai", "google"] as const satisfies readonly GeneratedProvider[];
+
+function createHelmcodeVendorReferenceMap(): Map<string, ModelSpec<"openai-completions">> {
+	const references = new Map<string, ModelSpec<"openai-completions">>();
+	for (const vendor of HELMCODE_RESOLD_VENDORS) {
+		for (const [id, reference] of createBundledReferenceMap<"openai-completions">(vendor)) {
+			if (!references.has(id)) references.set(id, reference);
+		}
+	}
+	return references;
+}
+
+/**
+ * Helmcode model manager: OpenAI-compatible chat completions at
+ * `api.helmcode.com/v1`. `/v1/models` also lists embedding, rerank, TTS, and
+ * STT models; the exclusion policy lives in `runtime/behavior.kdl`
+ * (`exclude-models provider="helmcode"`).
+ *
+ * `/v1/models` carries no capability data. Resold frontier ids (Claude, GPT,
+ * Gemini) take only capability facts from the first-party vendor's bundled
+ * row: reasoning, modalities, context window, output cap, and list price. The
+ * rest of that row (thinking shape, compat, native web search, tool dialects,
+ * cache semantics) describes the vendor's own API, not this chat-completions
+ * proxy; the host's `reasoning_effort` ladders and cache-write pricing live in
+ * `providers/helmcode.kdl`. Ids with no Helmcode or vendor row (e.g. a new
+ * open-weight model) inherit nothing from other gateways.
+ */
+export function helmcodeModelManagerOptions(
+	config?: HelmcodeModelManagerConfig,
+): ModelManagerOptions<"openai-completions"> {
+	let vendorReferences: Map<string, ModelSpec<"openai-completions">> | undefined;
+	const resolveVendorReference = (id: string) => (vendorReferences ??= createHelmcodeVendorReferenceMap()).get(id);
+	return createOpenAICompatibleModelManagerOptions({
+		api: "openai-completions",
+		providerId: "helmcode",
+		defaultBaseUrl: "https://api.helmcode.com/v1",
+		config,
+		requireApiKey: true,
+		filterModel: (_entry, model) => !isExcludedModel("helmcode", model.id),
+		mapModel: (entry, defaults, helmcodeReference) => {
+			if (helmcodeReference) return mapWithBundledReference(entry, defaults, helmcodeReference);
+			const vendor = resolveVendorReference(defaults.id);
+			if (!vendor) return mapWithBundledReference(entry, defaults, undefined);
+			return {
+				...defaults,
+				name: toModelName(entry.name, vendor.name),
+				reasoning: vendor.reasoning,
+				input: vendor.input,
+				cost: vendor.cost,
+				contextWindow: toPositiveNumber(entry.context_length, vendor.contextWindow),
+				maxTokens: toPositiveNumber(entry.max_completion_tokens, vendor.maxTokens),
+			};
+		},
+		// Must live on the manager options, not only the KDL descriptor:
+		// `createModelManager()` prunes the bundled slice from this flag.
+		dynamicModelsAuthoritative: true,
+	});
+}
+
 // ---------------------------------------------------------------------------
 // 5. NVIDIA
 // ---------------------------------------------------------------------------
@@ -3277,12 +3352,8 @@ export function openrouterModelManagerOptions(config?: OpenRouterModelManagerCon
 									cacheRead: parseFloat(String(pricing?.input_cache_read ?? "0")) * 1_000_000,
 									cacheWrite: parseFloat(String(pricing?.input_cache_write ?? "0")) * 1_000_000,
 								},
-								contextWindow:
-									typeof entry.context_length === "number" ? entry.context_length : baseModel.contextWindow,
-								maxTokens:
-									typeof topProvider?.max_completion_tokens === "number"
-										? topProvider.max_completion_tokens
-										: baseModel.maxTokens,
+								contextWindow: toPositiveNumber(entry.context_length, baseModel.contextWindow),
+								maxTokens: toPositiveNumber(topProvider?.max_completion_tokens, baseModel.maxTokens),
 								...(!supportsToolChoice && {
 									compat: { ...baseModel.compat, supportsToolChoice: false },
 								}),
@@ -3346,11 +3417,9 @@ export function openrouterModelManagerOptions(config?: OpenRouterModelManagerCon
 									cacheRead: 0,
 									cacheWrite: 0,
 								},
-								contextWindow: typeof entry.context_length === "number" ? entry.context_length : null,
-								maxTokens:
-									typeof topProvider?.max_completion_tokens === "number"
-										? topProvider.max_completion_tokens
-										: null,
+								// Some rows (e.g. respan/span-01) advertise `0` for unknown limits.
+								contextWindow: toPositiveNumber(entry.context_length, null),
+								maxTokens: toPositiveNumber(topProvider?.max_completion_tokens, null),
 							};
 						},
 						fetch: config?.fetch,
@@ -3382,11 +3451,8 @@ export function openrouterModelManagerOptions(config?: OpenRouterModelManagerCon
 								supportsTools: false,
 								// OpenRouter bills reranking per search; ModelCost has no search-unit axis.
 								cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-								contextWindow: typeof entry.context_length === "number" ? entry.context_length : null,
-								maxTokens:
-									typeof topProvider?.max_completion_tokens === "number"
-										? topProvider.max_completion_tokens
-										: null,
+								contextWindow: toPositiveNumber(entry.context_length, null),
+								maxTokens: toPositiveNumber(topProvider?.max_completion_tokens, null),
 							};
 						},
 						fetch: config?.fetch,
@@ -3430,7 +3496,7 @@ export function openrouterModelManagerOptions(config?: OpenRouterModelManagerCon
 									cacheRead: 0,
 									cacheWrite: 0,
 								},
-								contextWindow: typeof entry.context_length === "number" ? entry.context_length : null,
+								contextWindow: toPositiveNumber(entry.context_length, null),
 								maxTokens: null,
 							};
 						},

package/src/provider-models/special.ts

@@ -4,6 +4,11 @@ import { apiRouteFor } from "../compat/behavior";
 import { seedModels } from "../compat/providers";
 import { type CodexModelDiscoveryResult, fetchCodexModels } from "../discovery/codex";
 import type { DevinModelDiscoveryOptions } from "../discovery/devin";
+import {
+	type FactoryDroidModelDiscoveryOptions,
+	factoryDroidSeedModels,
+	fetchFactoryDroidModels,
+} from "../discovery/factory-droid";
 import { fetchTypeSafeModels, TYPESAFE_DEFAULT_BASE_URL } from "../discovery/typesafe";
 import { buildGitLabDuoWorkflowFallbackModel, fetchGitLabDuoWorkflowModels } from "../discovery/gitlab-duo-workflow";
 import type { ModelManagerOptions } from "../model-manager";
@@ -131,7 +136,8 @@ export function cursorModelManagerOptions(config: CursorModelManagerConfig = {})
 	const { apiKey, baseUrl, clientVersion } = config;
 	return {
 		providerId: "cursor",
-		cacheProviderId: resolveModelCacheProviderId("cursor"),
+		dynamicModelsAuthoritative: true,
+		cacheProviderId: resolveModelCacheProviderId("cursor", { apiKey, baseUrl }),
 		...(apiKey
 			? {
 					fetchDynamicModels: async () => {
@@ -365,6 +371,25 @@ export function devinModelManagerOptions(config: DevinModelManagerConfig = {}):
 
 const devinDiscovery = once(() => import("../discovery/devin"));
 
+// ---------------------------------------------------------------------------
+// Factory Droid
+// ---------------------------------------------------------------------------
+
+export function factoryDroidModelManagerOptions(
+	config: FactoryDroidModelDiscoveryOptions = {},
+): ModelManagerOptions<"factory-droid-agent"> {
+	return {
+		providerId: "factory-droid",
+		cacheProviderId: resolveModelCacheProviderId("factory-droid", config),
+		// No model-listing endpoint exists; the registry narrowed offline is the seed.
+		staticModels: factoryDroidSeedModels(config),
+		dynamicModelsAuthoritative: true,
+		fetchDynamicModels: () => fetchFactoryDroidModels(config),
+		// Refresh current policy online; cached eligibility is not current entitlement.
+		alwaysRefetchDynamicModels: true,
+	};
+}
+
 // ---------------------------------------------------------------------------
 // Synthetic role providers
 // ---------------------------------------------------------------------------
@@ -415,7 +440,6 @@ export function typesafeModelManagerOptions(config: TypeSafeModelManagerConfig =
 			: undefined),
 	};
 }
-
 // ---------------------------------------------------------------------------
 // Zai
 // ---------------------------------------------------------------------------

package/src/types.ts

@@ -19,6 +19,7 @@ export type KnownApi =
 	| "google-vertex"
 	| "ollama-chat"
 	| "cursor-agent"
+	| "factory-droid-agent"
 	| "gitlab-duo-agent"
 	| "devin-agent"
 	| "apple-foundation-models";
@@ -284,12 +285,21 @@ export interface OpenAICompat {
 	thinkingKeep?: "all" | false;
 	/** Which reasoning content field to emit on assistant messages. Default: auto-detected. */
 	reasoningContentField?: "reasoning_content" | "reasoning" | "reasoning_text";
+	/** Decode Mistral thinking parts in streamed content and replay them as typed assistant content. */
+	mistralReasoningContentParts?: boolean;
 	/** Whether assistant tool-call messages must include reasoning content. Default: false. */
 	requiresReasoningContentForToolCalls?: boolean;
 	/** Whether all assistant messages must include reasoning content. Default: false. */
 	requiresReasoningContentForAllAssistantTurns?: boolean;
 	/** Whether the provider accepts a synthetic placeholder (e.g. ".") for missing reasoning_content on tool-call turns. Default: true. Set to false for providers like DeepSeek that validate the exact reasoning_content value. */
 	allowsSyntheticReasoningContentForToolCalls?: boolean;
+	/**
+	 * Value emitted for the reasoning field on tool-call turns when the provider
+	 * requires it (`requiresReasoningContentForToolCalls`) but no reasoning was
+	 * captured. Default: "". Some upstreams validate the exact value — the droid
+	 * proxy's DeepSeek family requires a single space.
+	 */
+	syntheticReasoningContentFallback?: string;
 	/**
 	 * Replay preserved thinking blocks as `reasoning_content` (or the configured
 	 * `reasoningContentField`) on EVERY assistant turn that carried reasoning,
@@ -673,6 +683,25 @@ export interface AnthropicCompat {
 	stripImageInput?: boolean;
 	/** Thinking-loop watchdog guard family applied to streamed reasoning. */
 	thinkingLoopGuard?: "gemini" | "deepseek" | "xai";
+	/**
+	 * Drop the enabled `thinking` config and replayed thinking blocks when the
+	 * conversation is not thinking-led (a proxy contract for non-interleaved
+	 * budget models). Default: false.
+	 */
+	stripThinkingHistory?: boolean;
+	/**
+	 * Send the `effort-2025-11-24` beta exactly when `output_config.effort`
+	 * rides the request. Unset keeps the transport's legacy heuristic.
+	 */
+	effortBeta?: boolean;
+	/**
+	 * Wire form of a disabled-thinking turn: omit the field, send
+	 * `{ type: "disabled" }`, or keep adaptive thinking. Unset keeps the
+	 * direct-provider behavior.
+	 */
+	disabledThinking?: "omit" | "disabled" | "adaptive";
+	/** The model is a fast-mode SKU: send `speed: "fast"` with the fast-mode beta. Default: false. */
+	fastMode?: boolean;
 }
 
 /**
@@ -703,6 +732,12 @@ export interface BedrockCompat {
 	 * `PI_OPENAI_STREAM_IDLE_TIMEOUT_MS` alias, then the 300s default.
 	 */
 	streamIdleTimeoutMs?: number;
+	/**
+	 * Whether the model accepts a forced `toolChoice` (`any` / `tool`). Claude
+	 * Opus/Sonnet 5.5 reject it outright; the request builder downgrades forced
+	 * choices to `auto` when this is false. Default: true.
+	 */
+	supportsForcedToolChoice?: boolean;
 }
 
 /** Fully-resolved Bedrock Converse prompt-cache capabilities, materialized once by `buildModel`. */
@@ -713,6 +748,7 @@ export interface ResolvedBedrockCompat {
 	supportsLongPromptCacheRetention: boolean;
 	promptCacheMinimumTokens: number;
 	promptCacheMaximumCheckpoints: number;
+	supportsForcedToolChoice: boolean;
 	/**
 	 * Stream-watchdog idle-timeout fallback in ms for hosts with no keepalive
 	 * events; 0 disables the idle watchdog. Undefined defers to
@@ -780,9 +816,12 @@ export interface ResolvedOpenAISharedCompat {
 	supportsForcedToolChoice: boolean;
 	supportsNamedToolChoice: boolean;
 	reasoningContentField?: OpenAICompat["reasoningContentField"];
+	mistralReasoningContentParts?: boolean;
 	requiresReasoningContentForToolCalls: boolean;
 	requiresReasoningContentForAllAssistantTurns: boolean;
 	allowsSyntheticReasoningContentForToolCalls: boolean;
+	/** See {@link OpenAICompat.syntheticReasoningContentFallback}. */
+	syntheticReasoningContentFallback?: string;
 	replayReasoningContent: boolean;
 	qwenPreserveThinking: boolean;
 	qwenTemplateReasoningEffort: boolean;
@@ -860,9 +899,11 @@ export type ResolvedOpenAICompat = ResolvedOpenAISharedCompat &
 			| "supportsForcedToolChoice"
 			| "supportsNamedToolChoice"
 			| "reasoningContentField"
+			| "mistralReasoningContentParts"
 			| "requiresReasoningContentForToolCalls"
 			| "requiresReasoningContentForAllAssistantTurns"
 			| "allowsSyntheticReasoningContentForToolCalls"
+			| "syntheticReasoningContentFallback"
 			| "replayReasoningContent"
 			| "qwenPreserveThinking"
 			| "qwenTemplateReasoningEffort"
@@ -977,8 +1018,25 @@ export type ResolvedOpenRouterCompat = ResolvedOpenAICompat & ResolvedOpenAIResp
 
 /** Fully-resolved anthropic-messages compat view (same contract as `ResolvedOpenAICompat`). */
 export type ResolvedAnthropicCompat = Required<
-	Omit<AnthropicCompat, "streamIdleTimeoutMs" | "thinkingLoopGuard" | "bedrockMessagesApi">
+	Omit<
+		AnthropicCompat,
+		| "streamIdleTimeoutMs"
+		| "thinkingLoopGuard"
+		| "bedrockMessagesApi"
+		| "effortBeta"
+		| "disabledThinking"
+		| "stripThinkingHistory"
+		| "fastMode"
+	>
 > & {
+	/** Effort-beta override; undefined keeps the transport's legacy heuristic. */
+	effortBeta?: AnthropicCompat["effortBeta"];
+	/** Disabled-thinking wire form; undefined keeps the direct-provider behavior. */
+	disabledThinking?: AnthropicCompat["disabledThinking"];
+	/** Strip thinking history on non-thinking-led turns; undefined behaves as false. */
+	stripThinkingHistory?: AnthropicCompat["stripThinkingHistory"];
+	/** Fast-mode SKU; undefined behaves as false. */
+	fastMode?: AnthropicCompat["fastMode"];
 	/** Thinking-loop watchdog guard family applied to streamed reasoning. */
 	thinkingLoopGuard?: AnthropicCompat["thinkingLoopGuard"];
 	/**
@@ -1145,6 +1203,9 @@ export interface TokenCost {
 	cacheWrite: number;
 }
 
+/** User-facing interpretation of a model's token-rate card. */
+export type ModelPricingStatus = "fixed" | "free" | "included" | "variable" | "unknown";
+
 /**
  * Rates applied to the full request when its prompt exceeds `inputThreshold`,
  * or reaches it when `inputThresholdInclusive` is true. Prompt input is the
@@ -1218,6 +1279,18 @@ export interface ModelAccountAccess {
 	cyberPrograms?: readonly string[];
 }
 
+/** One Cursor `RequestedModel.parameters` entry recovered from rich discovery. */
+export interface CursorModelParameter {
+	id: string;
+	value: string;
+}
+
+/** Cursor wire target selected after local effort/variant routing. */
+export interface CursorModelRoute {
+	modelId: string;
+	parameters: readonly CursorModelParameter[];
+	maxMode?: boolean;
+}
 // Model interface for the unified model system
 export interface Model<TApi extends Api = Api> {
 	id: string;
@@ -1327,6 +1400,29 @@ export interface Model<TApi extends Api = Api> {
 	 * bundled/config rows and on single-account discovery.
 	 */
 	accountAccess?: Readonly<Record<string, ModelAccountAccess>>;
+	/** Cursor `RequestedModel.parameters` for this model's default variant. */
+	cursorModelParameters?: readonly CursorModelParameter[];
+	/**
+	 * Per-wire-id Cursor routes recovered from `AvailableModels`. Generic effort
+	 * collapse retains these while routing selects one key at request time.
+	 */
+	cursorModelRoutes?: Readonly<Record<string, CursorModelRoute>>;
+	/** Cursor's account-relative model price/multiplier; not a per-token USD rate. */
+	cursorPrice?: number;
+	/** Cursor requires data retention to invoke this model. */
+	cursorRequiresDataRetention?: boolean;
+	/** Cursor explicitly reports support for its Agent surface. */
+	cursorSupportsAgent?: boolean;
+	/** Cursor explicitly reports support for sandboxed execution. */
+	cursorSupportsSandboxing?: boolean;
+	/** Factory Droid: account-resolved upstream rotation (first entry is the default `x-api-provider`). */
+	factoryDroidApiProviders?: string[];
+	/** Factory Droid: `configured_order` when live routing chose the rotation; absent means registry order. */
+	factoryDroidRoutingSource?: "configured_order";
+	/** Factory Droid Standard Credits base rate (relative per-token weight, not dollars). */
+	factoryDroidCredits?: number;
+	/** Canonical organization resolved during Factory discovery. */
+	factoryDroidOrgId?: string;
 	cost: ModelCost;
 	/**
 	 * Prompt-cache entry lifetime per retention tier, in seconds. Populated only
@@ -1336,9 +1432,22 @@ export interface Model<TApi extends Api = Api> {
 	 * Custom models and provider overrides opt in via models.yml `promptCache`.
 	 */
 	promptCache?: ModelPromptCache;
+	/**
+	 * Verbatim configured lifetimes (models.yml, `modelOverrides`, runtime
+	 * registrations). `buildModel` applies them over catalog `prompt-cache`
+	 * rules on every rebuild; `{}` keeps warming disabled.
+	 */
+	promptCacheConfig?: ModelPromptCache;
+	/**
+	 * Interpretation of an all-zero token-rate card. Omitted zero-rate cards
+	 * are unknown; any non-zero rate is always treated as fixed pricing.
+	 */
+	pricingStatus?: Exclude<ModelPricingStatus, "fixed">;
 	/** Premium Copilot requests charged per user-initiated request (defaults to 1). */
 	premiumMultiplier?: number;
 	contextWindow: number | null;
+	/** Preserve the host's supplied window instead of applying inferred expansion or reference-price caps. */
+	contextWindowAuthoritative?: boolean;
 	/** Optional larger prompt window available when extended context is enabled. */
 	maxContextWindow?: number;
 	maxTokens: number | null;
@@ -1411,6 +1520,8 @@ export interface Model<TApi extends Api = Api> {
 	isNew?: boolean;
 	/** Upstream marks this model as beta / preview quality. */
 	isBeta?: boolean;
+	/** Authenticated provider catalog marks this as the account's default model. */
+	isProviderDefault?: boolean;
 	/** Upstream marks this model as one of its recommended picks. */
 	isRecommended?: boolean;
 	/** Canonical thinking capability metadata for this model. */

package/src/wire/cursor.ts

@@ -0,0 +1,32 @@
+/**
+ * Cursor wire constants shared by authenticated catalog discovery, the pi-ai
+ * provider, and account usage. Keep the announced client build aligned with the
+ * released Cursor agent CLI because the service gates protocol features on it.
+ */
+
+/** Default host for Cursor's Connect RPCs and account API. */
+export const CURSOR_DEFAULT_BASE_URL = "https://api2.cursor.sh";
+
+/** Released Cursor agent CLI build whose protocol surface this client mirrors. */
+export const CURSOR_CLIENT_VERSION = "cli-2026.09.02-c22c1a3";
+
+export const CURSOR_RUN_PATH = "/agent.v1.AgentService/Run";
+export const CURSOR_RUN_SSE_PATH = "/agent.v1.AgentService/RunSSE";
+export const CURSOR_BIDI_APPEND_PATH = "/aiserver.v1.BidiService/BidiAppend";
+export const CURSOR_GET_USABLE_MODELS_PATH = "/agent.v1.AgentService/GetUsableModels";
+export const CURSOR_GET_DEFAULT_MODEL_PATH = "/agent.v1.AgentService/GetDefaultModelForCli";
+export const CURSOR_AVAILABLE_MODELS_PATH = "/aiserver.v1.AiService/AvailableModels";
+
+/** Headers shared by Cursor's authenticated CLI RPCs. */
+export function cursorClientHeaders(
+	apiKey: string,
+	options: { clientVersion?: string; contentType?: "application/proto" | "application/connect+proto" } = {},
+): Record<string, string> {
+	return {
+		"content-type": options.contentType ?? "application/proto",
+		authorization: `Bearer ${apiKey}`,
+		"x-cursor-client-type": "cli",
+		"x-cursor-client-version": options.clientVersion ?? CURSOR_CLIENT_VERSION,
+		"x-ghost-mode": "true",
+	};
+}