@oh-my-pi/pi-catalog 18.0.3 → 18.0.4

package/src/models.ts

@@ -1,5 +1,5 @@
 import MODELS from "./models.json" with { type: "json" };
-import type { Api, KnownProvider, Model, TokenCost, Usage } from "./types";
+import type { Api, KnownProvider, Model, ModelCost, TokenCost, Usage } from "./types";
 
 /**
  * Static bundled model registry loaded from `models.json`.
@@ -43,23 +43,27 @@ export function getBundledModels(provider: GeneratedProvider): Model<Api>[] {
 	const models = getProviderModels(provider);
 	return models ? (Array.from(models.values()) as Model<Api>[]) : [];
 }
-function resolveTokenCost(cost: Model["cost"], promptInputTokens: number): TokenCost {
+function resolveTokenCost(cost: ModelCost, promptInputTokens: number): TokenCost {
 	const longContext = cost.longContext;
 	if (!longContext) return cost;
-	return promptInputTokens > longContext.inputThreshold ? longContext : cost;
+	const reachesThreshold =
+		promptInputTokens > longContext.inputThreshold ||
+		(longContext.inputThresholdInclusive === true && promptInputTokens === longContext.inputThreshold);
+	return reachesThreshold ? longContext : cost;
 }
 
 /** Price a prompt as fully uncached input under its active context-length tier. */
-export function calculateUncachedInputCost(cost: Model["cost"], promptInputTokens: number): number {
+export function calculateUncachedInputCost(cost: ModelCost, promptInputTokens: number): number {
 	const rates = resolveTokenCost(cost, promptInputTokens);
 	return (rates.input / 1_000_000) * promptInputTokens;
 }
 
-export function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage): Usage["cost"] {
+/** Price one usage record from a token rate card, including active context tiers. */
+export function calculateUsageCost(cost: ModelCost, usage: Usage): Usage["cost"] {
 	const orchestration = usage.orchestration;
 	const promptInputTokens =
 		usage.input + usage.cacheRead + usage.cacheWrite + (orchestration?.input ?? 0) + (orchestration?.cacheRead ?? 0);
-	const rates = resolveTokenCost(model.cost, promptInputTokens);
+	const rates = resolveTokenCost(cost, promptInputTokens);
 	usage.cost.input = (rates.input / 1000000) * (usage.input + (orchestration?.input ?? 0));
 	usage.cost.output = (rates.output / 1000000) * (usage.output + (orchestration?.output ?? 0));
 	usage.cost.cacheRead = (rates.cacheRead / 1000000) * (usage.cacheRead + (orchestration?.cacheRead ?? 0));
@@ -68,6 +72,11 @@ export function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage
 	return usage.cost;
 }
 
+/** Price one usage record from its model's token rate card. */
+export function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage): Usage["cost"] {
+	return calculateUsageCost(model.cost, usage);
+}
+
 /**
  * Price cache-write tokens, honoring the TTL breakdown when the provider reports one.
  *

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

@@ -54,9 +54,10 @@ export function resolveModelCacheProviderId(providerId: string, options: ModelCa
 		case "ollama":
 			return resolveOllamaModelCacheProviderId(providerId, options.baseUrl);
 		case "cursor":
-			// v3: max-mode Claude/Gemini rows cached before the 1M context-window
-			// discovery fix carry a stale 200k window and must be refetched.
-			return "cursor:max-mode-v3";
+			// 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 "litellm": {
 			const baseUrl = options.baseUrl ?? getDefaultModelDiscoveryBaseUrl(providerId)!;
 			return `litellm:rich-v6:${Bun.hash(baseUrl).toString(36)}`;

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

@@ -1315,6 +1315,68 @@ export interface XaiModelManagerConfig {
 	fetch?: FetchImpl;
 }
 
+// xAI bills the whole request at 2x the base rates once the prompt reaches
+// 200K tokens, for every current Grok SKU that carries the two-tier card
+// (grok-4.3/4.5/4.6, every grok-4.20 variant, grok-build-0.1). Source:
+// docs.x.ai/developers/models. Computing the tier from the base keeps it in
+// lockstep with stencil.so price updates instead of a hand-maintained table.
+const XAI_LONG_CONTEXT_THRESHOLD = 200_000;
+const XAI_LONG_CONTEXT_MULTIPLIER = 2;
+
+// SuperGrok surfaces a few models under IDs that differ from their public
+// `xai` catalog equivalent, so the exact-ID price fallback misses them. Map
+// the OAuth ID to the paid ID it mirrors.
+const XAI_OAUTH_PRICE_ALIASES: Record<string, string> = {
+	"grok-4.20-multi-agent-0309": "grok-4.20-multi-agent-beta-latest",
+};
+
+function xaiHasLongContextTier(modelId: string): boolean {
+	return (
+		modelId === "grok-4.3" ||
+		modelId === "grok-4.5" ||
+		modelId === "grok-4.6" ||
+		modelId === "grok-build-0.1" ||
+		modelId.startsWith("grok-4.20")
+	);
+}
+
+function hasTokenPrice(cost: ModelSpec["cost"]): boolean {
+	return cost.input !== 0 || cost.output !== 0 || cost.cacheRead !== 0 || cost.cacheWrite !== 0;
+}
+
+function withXaiLongContextTier(model: ModelSpec): ModelSpec {
+	if (!xaiHasLongContextTier(model.id) || !hasTokenPrice(model.cost)) return model;
+	const longContext: LongContextTokenCost = {
+		inputThreshold: XAI_LONG_CONTEXT_THRESHOLD,
+		inputThresholdInclusive: true,
+		input: model.cost.input * XAI_LONG_CONTEXT_MULTIPLIER,
+		output: model.cost.output * XAI_LONG_CONTEXT_MULTIPLIER,
+		cacheRead: model.cost.cacheRead * XAI_LONG_CONTEXT_MULTIPLIER,
+		cacheWrite: model.cost.cacheWrite * XAI_LONG_CONTEXT_MULTIPLIER,
+	};
+	return { ...model, cost: { ...model.cost, longContext } };
+}
+
+/**
+ * Applies xAI's long-context rate card and mirrors exact public-model prices
+ * onto matching SuperGrok catalog rows.
+ */
+export function applyXaiCatalogPricing(models: readonly ModelSpec[]): ModelSpec[] {
+	const pricedModels = models.map(model => (model.provider === "xai" ? withXaiLongContextTier(model) : model));
+	const publicCosts = new Map(
+		pricedModels
+			.filter(model => model.provider === "xai" && hasTokenPrice(model.cost))
+			.map(model => [model.id, model.cost]),
+	);
+
+	return pricedModels.map(model => {
+		if (model.provider !== "xai-oauth" || hasTokenPrice(model.cost)) return model;
+		const alias = XAI_OAUTH_PRICE_ALIASES[model.id];
+		const publicCost = publicCosts.get(model.id) ?? (alias ? publicCosts.get(alias) : undefined);
+		return publicCost ? { ...model, cost: { ...publicCost } } : model;
+	});
+}
+
 export function xaiModelManagerOptions(config?: XaiModelManagerConfig): ModelManagerOptions<"openai-responses"> {
 	return {
 		...createOpenAICompatibleModelManagerOptions({

package/src/types.ts

@@ -847,12 +847,15 @@ export interface TokenCost {
 }
 
 /**
- * Rates applied to the full request when its prompt exceeds `inputThreshold`.
- * Prompt input is the sum of uncached, cached-read, cache-write, and
- * provider-orchestration input tokens.
+ * Rates applied to the full request when its prompt exceeds `inputThreshold`,
+ * or reaches it when `inputThresholdInclusive` is true. Prompt input is the
+ * sum of uncached, cached-read, cache-write, and provider-orchestration input
+ * tokens.
  */
 export interface LongContextTokenCost extends TokenCost {
 	inputThreshold: number;
+	/** Whether the long-context tier starts exactly at `inputThreshold`. */
+	inputThresholdInclusive?: boolean;
 }
 
 /** Base token rates plus an optional long-context tier. */

package/src/variant-collapse.ts

@@ -57,6 +57,15 @@ export interface EffortVariantFamily {
 	 * when it equals the logical id).
 	 */
 	members: readonly string[];
+	/**
+	 * Preferred default wire id: overrides the member-order default for the
+	 * collapsed spec's `requestModelId` when this member is live. Lets a
+	 * mandatory-reasoning family advertise a canonical tier that is not its
+	 * numeric floor (Cursor Grok 4.5/4.6 default to `-medium`, the only tier the
+	 * Start plan serves; the `-low` floor is refused). Ignored when absent from
+	 * the input or retired.
+	 */
+	defaultMember?: string;
 	/**
 	 * Wire ids upstream no longer serves (e.g. a deployment killed while
 	 * discovery still advertises it). Fresh collapsing never routes to them,
@@ -124,7 +133,13 @@ const DEVIN_FOUR_TIER_EFFORTS: readonly Effort[] = [Effort.Low, Effort.Medium, E
  * `mode: "effort"` (mandatory when the family has no `off` route). Shared by the
  * Devin and Cursor tables, whose per-effort siblings follow the same shape.
  */
-function tierFamily(id: string, name: string, routes: TierRoutes, efforts: readonly Effort[]): EffortVariantFamily {
+function tierFamily(
+	id: string,
+	name: string,
+	routes: TierRoutes,
+	efforts: readonly Effort[],
+	defaultMember?: string,
+): EffortVariantFamily {
 	const routing: Partial<Record<Effort | "off", string>> = {};
 	if (routes.off) routing.off = routes.off;
 	for (const effort of efforts) {
@@ -168,6 +183,7 @@ function tierFamily(id: string, name: string, routes: TierRoutes, efforts: reado
 			efforts,
 			...(routes.off ? undefined : { requiresEffort: true }),
 		},
+		...(defaultMember !== undefined ? { defaultMember } : undefined),
 	};
 }
 
@@ -719,7 +735,9 @@ const CURSOR_GPT_56_EFFORTS: readonly Effort[] = [Effort.Low, Effort.Medium, Eff
  * (`cursor-grok-4.6-low|-medium|-high|-xhigh`) alongside a parallel `-fast`
  * service-tier lane (`-low-fast`, …). Each lane collapses into its own logical
  * model — the `-fast` axis is a sibling family, never a second routing
- * dimension — with effort routing onto the live sibling wire ids.
+ * dimension — with effort routing onto the live sibling wire ids. The mandatory
+ * `-medium` default is the tier Cursor's Start plan serves at fixed settings;
+ * the `-low` floor is refused there (issue #9478).
  */
 function cursorGrokFamilies(version: "4.5" | "4.6", efforts: readonly Effort[]): readonly EffortVariantFamily[] {
 	const build = (fast: boolean): EffortVariantFamily => {
@@ -728,7 +746,13 @@ function cursorGrokFamilies(version: "4.5" | "4.6", efforts: readonly Effort[]):
 		for (const effort of efforts) {
 			routes[effort] = `cursor-grok-${version}-${effort}${suffix}`;
 		}
-		return tierFamily(`cursor-grok-${version}${suffix}`, `Grok ${version}${fast ? " Fast" : ""}`, routes, efforts);
+		return tierFamily(
+			`cursor-grok-${version}${suffix}`,
+			`Grok ${version}${fast ? " Fast" : ""}`,
+			routes,
+			efforts,
+			`cursor-grok-${version}-${Effort.Medium}${suffix}`,
+		);
 	};
 	return [build(false), build(true)];
 }
@@ -1142,6 +1166,37 @@ function refreshCollapsedThinking<TSpec extends VariantSpecLike>(
 	return { ...spec, thinking, ...(requestModelId !== undefined ? { requestModelId } : {}) };
 }
 
+/**
+ * Re-point a collapsed snapshot's default wire id to the family's declared
+ * {@link EffortVariantFamily.defaultMember} when the snapshot still advertises a
+ * different default. Bundled catalog and cache rows freeze `requestModelId` from
+ * before a family gained a preferred default (Cursor Grok 4.5/4.6 → `-medium`),
+ * and neither the existing-collapsed pass-through nor `refreshCollapsedThinking`
+ * (scoped to `effortBudgets` families) would otherwise correct them — leaving an
+ * effort-less request clamped to the refused `-low` tier (issue #9478). Only
+ * re-points when the target is a live route in the snapshot's own
+ * `effortRouting`. Returns `spec` by reference when unchanged.
+ */
+function reconcileDefaultMember<TSpec extends VariantSpecLike>(
+	spec: TSpec,
+	family: EffortVariantFamily,
+	presentMembers?: ReadonlySet<string>,
+): TSpec {
+	const defaultMember = family.defaultMember;
+	if (defaultMember === undefined || defaultMember === spec.id) return spec;
+	const target =
+		presentMembers === undefined || presentMembers.has(defaultMember)
+			? defaultMember
+			: family.members.find(id => presentMembers.has(id));
+	if (target === undefined || spec.requestModelId === target) return spec;
+	const routing = spec.thinking?.effortRouting;
+	if (routing === undefined) return spec;
+	for (const key in routing) {
+		if (routing[key as Effort | "off"] === target) return { ...spec, requestModelId: target };
+	}
+	return spec;
+}
+
 /**
  * Collapse every family in `table` found in `specs`. Non-member specs pass
  * through verbatim (by reference), order preserved; the collapsed spec
@@ -1182,7 +1237,7 @@ export function collapseEffortVariants<TSpec extends VariantSpecLike>(
 			// Recycled extraAliases rows are healed in a later pass.
 			const refreshed =
 				existing !== undefined && existingCollapsed
-					? refreshCollapsedThinking(reconciled ?? existing, family, retired)
+					? reconcileDefaultMember(refreshCollapsedThinking(reconciled ?? existing, family, retired), family)
 					: reconciled;
 			if (refreshed !== undefined && refreshed !== existing) {
 				familyIdBySpecId.set(family.id, family.id);
@@ -1195,9 +1250,11 @@ export function collapseEffortVariants<TSpec extends VariantSpecLike>(
 		if (existing) familyIdBySpecId.set(family.id, family.id);
 
 		if (existingCollapsed) {
-			// Mixed input: the collapsed entry (live truth) wins; stale raw
-			// members are deduped away. Retired targets are re-pointed first.
-			replacement.set(family.id, reconciled as TSpec);
+			// Mixed input: the collapsed entry wins; stale raw members are deduped
+			// away. Retired targets are re-pointed first, then the default wire id
+			// prefers the family's declared member when live and otherwise falls
+			// back to the first member the account actually advertised.
+			replacement.set(family.id, reconcileDefaultMember(reconciled as TSpec, family, new Set(rawPresent)));
 			continue;
 		}
 
@@ -1241,10 +1298,17 @@ export function collapseEffortVariants<TSpec extends VariantSpecLike>(
 			contextWindow: maxOrNull(memberSpecs.map(spec => spec.contextWindow)),
 			maxTokens: maxOrNull(memberSpecs.map(spec => spec.maxTokens)),
 		};
-		// The default wire id is the highest-priority live member; omit when it
-		// equals the logical id (bare/thinking pairs) — `resolveWireModelId`
-		// falls back. Retired members never become the default.
-		const defaultWireId = rawPresent.find(id => !retired?.has(id)) ?? rawPresent[0];
+		// The default wire id is the family's declared `defaultMember` when live,
+		// else the highest-priority live member. Omitted when it equals the
+		// logical id (bare/thinking pairs) — `resolveWireModelId` falls back.
+		// Retired members never become the default.
+		const preferredDefault =
+			family.defaultMember !== undefined &&
+			presentSet.has(family.defaultMember) &&
+			!retired?.has(family.defaultMember)
+				? family.defaultMember
+				: undefined;
+		const defaultWireId = preferredDefault ?? rawPresent.find(id => !retired?.has(id)) ?? rawPresent[0];
 		if (defaultWireId === family.id) {
 			if (usedAbsentEffortRoute) {
 				collapsed.requestModelId = defaultWireId as string;