@linxiraos/pi-catalog 1.2.1 → 1.3.0

package/src/models.ts

@@ -1,5 +1,6 @@
 import { classifyModel } from "./compat/taxonomy";
 import MODELS from "./models.json" with { type: "json" };
+import { dueEffectiveRate } from "./pricing";
 import type {
 	Api,
 	EffectiveTokenCost,
@@ -65,22 +66,25 @@ export function getBundledModels(provider: GeneratedProvider): 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;
+	const cost = getEffectiveTokenCost(model.cost);
 	if (cost.input !== 0 || cost.output !== 0 || cost.cacheRead !== 0 || cost.cacheWrite !== 0) return "fixed";
 	return model.pricingStatus ?? "unknown";
 }
 
+/**
+ * The base token card in force at `timestamp` (Unix ms, default now): the
+ * latest due `timeBased` effective rate, else the row's own legs. Price
+ * displays read this rather than the scalar legs, which keep the card current
+ * when the row was built while bundles, caches, and long sessions outlive it.
+ * Applies no long-context tier or peak/off-peak multiplier.
+ */
+export function getEffectiveTokenCost(cost: ModelCost, timestamp = Date.now()): TokenCost {
+	return resolveTokenCost(cost, 0, timestamp);
+}
+
 function resolveTokenCost(cost: ModelCost, promptInputTokens: number, timestamp: number | undefined): TokenCost {
-	let rates: ModelCost | EffectiveTokenCost = cost;
-	let effectiveFrom = -Infinity;
-	if (timestamp !== undefined && cost.timeBased?.effectiveRates) {
-		for (const candidate of cost.timeBased.effectiveRates) {
-			if (candidate.effectiveFrom <= timestamp && candidate.effectiveFrom > effectiveFrom) {
-				rates = candidate;
-				effectiveFrom = candidate.effectiveFrom;
-			}
-		}
-	}
+	const rates: ModelCost | EffectiveTokenCost =
+		(timestamp === undefined ? undefined : dueEffectiveRate(cost.timeBased, timestamp)) ?? cost;
 	const longContext = rates.longContext;
 	if (!longContext) return rates;
 	const reachesThreshold =
@@ -105,10 +109,20 @@ function timeBasedMultiplier(schedule: TimeBasedCost | undefined, timestamp: num
 	return isPeakPricingPeriod(schedule, timestamp) ? 1 : schedule.offPeakMultiplier;
 }
 
+/**
+ * Whether a schedule carries a recurring peak/off-peak tariff. A schedule with
+ * no peak windows at a 1x off-peak multiplier only carries dated rate cards
+ * (`cost-patch`/`cost-fallback` `effective-rates`): its price changes on a
+ * date, never by time of day.
+ */
+export function hasRecurringTariff(schedule: TimeBasedCost): boolean {
+	return schedule.peakWindows.length > 0 || schedule.offPeakMultiplier !== 1;
+}
+
 /** Return the recurring UTC tariff period, independently of its monetary multiplier. */
 export function getTimeBasedPricingPeriod(cost: ModelCost, timestamp?: number): "peak" | "off-peak" | undefined {
 	const schedule = cost.timeBased;
-	if (!schedule) return undefined;
+	if (!schedule || !hasRecurringTariff(schedule)) return undefined;
 	return isPeakPricingPeriod(schedule, timestamp ?? Date.now()) ? "peak" : "off-peak";
 }
 

package/src/pricing.d.ts

@@ -1,5 +1,41 @@
-import type { TimeBasedCost } from "./types";
+import type { EffectiveTokenCost, ModelCost, TimeBasedCost, TokenCost } from "./types";
 /** Validate serialized schedules before admitting cached model rows. */
 export declare function isTimeBasedCost(value: unknown): value is TimeBasedCost;
 /** KDL object children are named records; normalize them once while constructing the model. */
 export declare function materializeTimeBasedCost(value: unknown): TimeBasedCost;
+/**
+ * The latest `effectiveRates` card of a materialized schedule due at
+ * `timestamp`, or undefined before the first one (or without a schedule).
+ */
+export declare function dueEffectiveRate(schedule: TimeBasedCost | undefined, timestamp: number): EffectiveTokenCost | undefined;
+/** A `cost-patch`/`cost-fallback` dated card: the legs it overwrites from `effectiveFrom` (Unix ms). */
+export interface DatedCostCard extends Partial<TokenCost> {
+    effectiveFrom: number;
+}
+/**
+ * Parse the compiled `effective-rates` block of a `cost-patch` or
+ * `cost-fallback` payload into dated cards, ascending by date. Throws on a
+ * malformed card, so a typo in a rule fails the build instead of silently
+ * leaving the old price in force.
+ */
+export declare function parseDatedCostCards(costAxis: unknown, axis: "cost-patch" | "cost-fallback"): DatedCostCard[];
+/**
+ * Earliest instant a rate card can name (the `Date` range minimum). A leading
+ * card from here holds the price in force before the first dated change.
+ */
+export declare const EARLIEST_EFFECTIVE_FROM = -8640000000000000;
+/** A schedule of dated rate cards alone: no peak windows, no off-peak discount. */
+export declare const NO_RECURRING_TARIFF: TimeBasedCost;
+/**
+ * A flat card plus its dated overrides as a request-time `ModelCost`: the
+ * card due at `now` in the scalar legs, and every period (a leading card for
+ * the base price, then each dated card over the previous one) in a
+ * `timeBased` schedule without a recurring tariff. The plain card when no
+ * dated card exists.
+ */
+export declare function datedCost(base: TokenCost, cards: readonly DatedCostCard[], now?: number): ModelCost;
+/**
+ * Overwrite `cost` legs with the latest dated card due at `now`. Leaves
+ * `cost` unchanged before the first card.
+ */
+export declare function applyDueDatedCostCard(cost: TokenCost, cards: readonly DatedCostCard[], now?: number): void;

package/src/pricing.ts

@@ -1,4 +1,11 @@
-import type { EffectiveTokenCost, LongContextTokenCost, PeakPricingWindow, TimeBasedCost, TokenCost } from "./types";
+import type {
+	EffectiveTokenCost,
+	LongContextTokenCost,
+	ModelCost,
+	PeakPricingWindow,
+	TimeBasedCost,
+	TokenCost,
+} from "./types";
 import { isRecord } from "./utils";
 
 function nonnegative(value: unknown): value is number {
@@ -86,6 +93,21 @@ function namedEntries(value: unknown, field: string): unknown[] {
 	return Object.values(value);
 }
 
+/** Parse a KDL ISO UTC instant (`YYYY-MM-DDTHH:mm:ssZ`, optional milliseconds) to Unix ms. */
+function parseUtcInstant(date: unknown, axis: string): number {
+	if (typeof date !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/.test(date)) {
+		throw new Error(`Invalid ${axis} effective-from: expected an ISO UTC timestamp`);
+	}
+	const instant = Date.parse(date);
+	if (
+		!Number.isFinite(instant) ||
+		new Date(instant).toISOString() !== (date.includes(".") ? date : date.replace("Z", ".000Z"))
+	) {
+		throw new Error(`Invalid ${axis} effective-from: invalid UTC date`);
+	}
+	return instant;
+}
+
 /** KDL object children are named records; normalize them once while constructing the model. */
 export function materializeTimeBasedCost(value: unknown): TimeBasedCost {
 	const source = payload(value, ["offPeakMultiplier", "peakWindows", "effectiveRates"], "schedule");
@@ -105,17 +127,7 @@ export function materializeTimeBasedCost(value: unknown): TimeBasedCost {
 						["effectiveFrom", "input", "output", "cacheRead", "cacheWrite", "longContext"],
 						"effective-rate",
 					);
-					const date = rate.effectiveFrom;
-					if (typeof date !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/.test(date)) {
-						throw new Error("Invalid time-based-cost effective-from: expected an ISO UTC timestamp");
-					}
-					const effectiveFrom = Date.parse(date);
-					if (
-						!Number.isFinite(effectiveFrom) ||
-						new Date(effectiveFrom).toISOString() !== (date.includes(".") ? date : date.replace("Z", ".000Z"))
-					) {
-						throw new Error("Invalid time-based-cost effective-from: invalid UTC date");
-					}
+					const effectiveFrom = parseUtcInstant(rate.effectiveFrom, "time-based-cost");
 					if (rate.longContext !== undefined) {
 						payload(
 							rate.longContext,
@@ -134,3 +146,102 @@ export function materializeTimeBasedCost(value: unknown): TimeBasedCost {
 		throw new Error("Invalid time-based-cost schedule: invalid windows, rates, or multiplier");
 	return schedule;
 }
+
+/**
+ * The latest `effectiveRates` card of a materialized schedule due at
+ * `timestamp`, or undefined before the first one (or without a schedule).
+ */
+export function dueEffectiveRate(
+	schedule: TimeBasedCost | undefined,
+	timestamp: number,
+): EffectiveTokenCost | undefined {
+	let due: EffectiveTokenCost | undefined;
+	for (const candidate of schedule?.effectiveRates ?? []) {
+		if (candidate.effectiveFrom <= timestamp && (due === undefined || candidate.effectiveFrom > due.effectiveFrom)) {
+			due = candidate;
+		}
+	}
+	return due;
+}
+
+const TOKEN_COST_LEGS = ["input", "output", "cacheRead", "cacheWrite"] as const;
+const DATED_CARD_KEYS: readonly string[] = ["effectiveFrom", ...TOKEN_COST_LEGS];
+
+/** A `cost-patch`/`cost-fallback` dated card: the legs it overwrites from `effectiveFrom` (Unix ms). */
+export interface DatedCostCard extends Partial<TokenCost> {
+	effectiveFrom: number;
+}
+
+/**
+ * Parse the compiled `effective-rates` block of a `cost-patch` or
+ * `cost-fallback` payload into dated cards, ascending by date. Throws on a
+ * malformed card, so a typo in a rule fails the build instead of silently
+ * leaving the old price in force.
+ */
+export function parseDatedCostCards(costAxis: unknown, axis: "cost-patch" | "cost-fallback"): DatedCostCard[] {
+	const effectiveRates = isRecord(costAxis) ? costAxis.effectiveRates : undefined;
+	if (effectiveRates === undefined) return [];
+	if (!isRecord(effectiveRates)) throw new Error(`Invalid ${axis} effective-rates: expected named objects`);
+	const cards = Object.values(effectiveRates).map(entry => {
+		if (!isRecord(entry) || Object.keys(entry).some(key => !DATED_CARD_KEYS.includes(key))) {
+			throw new Error(`Invalid ${axis} effective-rate: unknown or malformed fields`);
+		}
+		const card: DatedCostCard = { effectiveFrom: parseUtcInstant(entry.effectiveFrom, axis) };
+		for (const leg of TOKEN_COST_LEGS) {
+			const value = entry[leg];
+			if (value === undefined) continue;
+			if (!nonnegative(value))
+				throw new Error(`Invalid ${axis} effective-rate ${leg}: expected a nonnegative number`);
+			card[leg] = value;
+		}
+		return card;
+	});
+	cards.sort((a, b) => a.effectiveFrom - b.effectiveFrom);
+	for (let index = 1; index < cards.length; index++) {
+		if (cards[index]!.effectiveFrom === cards[index - 1]!.effectiveFrom) {
+			throw new Error(`Invalid ${axis} effective-rates: duplicate effective-from`);
+		}
+	}
+	return cards;
+}
+
+/**
+ * Earliest instant a rate card can name (the `Date` range minimum). A leading
+ * card from here holds the price in force before the first dated change.
+ */
+export const EARLIEST_EFFECTIVE_FROM = -8_640_000_000_000_000;
+
+/** A schedule of dated rate cards alone: no peak windows, no off-peak discount. */
+export const NO_RECURRING_TARIFF: TimeBasedCost = { offPeakMultiplier: 1, peakWindows: [] };
+
+/**
+ * A flat card plus its dated overrides as a request-time `ModelCost`: the
+ * card due at `now` in the scalar legs, and every period (a leading card for
+ * the base price, then each dated card over the previous one) in a
+ * `timeBased` schedule without a recurring tariff. The plain card when no
+ * dated card exists.
+ */
+export function datedCost(base: TokenCost, cards: readonly DatedCostCard[], now = Date.now()): ModelCost {
+	if (cards.length === 0) return base;
+	const effectiveRates: EffectiveTokenCost[] = [{ effectiveFrom: EARLIEST_EFFECTIVE_FROM, ...base }];
+	for (const card of cards) effectiveRates.push({ ...effectiveRates.at(-1)!, ...card });
+	const timeBased = { ...NO_RECURRING_TARIFF, effectiveRates };
+	const { effectiveFrom: _effectiveFrom, ...due } = dueEffectiveRate(timeBased, now)!;
+	return { ...due, timeBased };
+}
+
+/**
+ * Overwrite `cost` legs with the latest dated card due at `now`. Leaves
+ * `cost` unchanged before the first card.
+ */
+export function applyDueDatedCostCard(cost: TokenCost, cards: readonly DatedCostCard[], now = Date.now()): void {
+	let due: DatedCostCard | undefined;
+	for (const card of cards) {
+		if (card.effectiveFrom <= now) due = card;
+	}
+	if (due === undefined) return;
+	for (const leg of TOKEN_COST_LEGS) {
+		const value = due[leg];
+		if (value !== undefined) cost[leg] = value;
+	}
+}

package/src/provider-models/bundled-references.ts

@@ -1,5 +1,6 @@
 import { isBareIdReferenceProvider } from "../compat/behavior";
 import { isZeroCostXaiOAuthReference } from "../identity/reference";
+import { withoutUnverifiedThinking } from "../model-thinking";
 import { getBundledModels, getBundledProviders } from "../models";
 import type { Api, Model, ModelSpec } from "../types";
 
@@ -17,11 +18,13 @@ export function toModelSpec<TApi extends Api>(model: Model<TApi>): ModelSpec<TAp
 		supportsComputerUseConfig,
 		...rest
 	} = model;
-	return {
+	// Unverified thinking is derived output too: references must not carry it to
+	// another host as reasoning capability.
+	return withoutUnverifiedThinking({
 		...rest,
 		...(supportsComputerUseConfig !== undefined ? { supportsComputerUse: supportsComputerUseConfig } : {}),
 		compat: compatConfig,
-	} as ModelSpec<TApi>;
+	} as ModelSpec<TApi>);
 }
 
 export function createBundledReferenceMap<TApi extends Api>(

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

@@ -45,7 +45,7 @@ export function getDefaultModelDiscoveryBaseUrl(providerId: string): string | un
 		case "litellm":
 			return Bun.env.LITELLM_BASE_URL ?? "http://localhost:4000/v1";
 		case "opencode-go":
-			return "https://opencode.ai/zen/go/v1";
+			return "https://opencode.ai/inference/go/v1";
 		case "opencode-zen":
 			return "https://opencode.ai/zen/v1";
 		case "vllm":

package/src/provider-models/descriptors.ts

@@ -59,6 +59,7 @@ import {
 	qianfanModelManagerOptions,
 	qwenPortalModelManagerOptions,
 	sakanaModelManagerOptions,
+	sambanovaModelManagerOptions,
 	siliconflowCnModelManagerOptions,
 	siliconflowModelManagerOptions,
 	singularityApiDevModelManagerOptions,
@@ -146,6 +147,7 @@ const MODEL_MANAGER_FACTORIES: Readonly<Partial<Record<KnownProvider, ModelManag
 	qianfan: config => qianfanModelManagerOptions(config),
 	"qwen-portal": config => qwenPortalModelManagerOptions(config),
 	sakana: config => sakanaModelManagerOptions(config),
+	sambanova: config => sambanovaModelManagerOptions(config),
 	siliconflow: config => siliconflowModelManagerOptions(config),
 	"siliconflow-cn": config => siliconflowCnModelManagerOptions(config),
 	"singularityapi-dev": config => singularityApiDevModelManagerOptions(config),

package/src/provider-models/google.ts

@@ -1,4 +1,5 @@
 import { logger } from "@linxiraos/pi-utils";
+import { isExcludedModel } from "../compat/behavior";
 import { reviewedCollapseTable } from "../compat/collapse";
 import { classifyModel } from "../compat/taxonomy";
 import { providerEntry } from "../compat/providers";
@@ -127,7 +128,12 @@ export function googleAntigravityModelManagerOptions(
 								});
 								continue;
 							}
-							catalogs.push({ accountKey, models: result.models });
+							// Caches written under older rules fail the compiled-rules hash in
+							// the model cache, so filtering fresh rosters covers every source.
+							catalogs.push({
+								accountKey,
+								models: result.models.filter(model => !isExcludedModel("google-antigravity", model.id)),
+							});
 						}
 						if (catalogs.length === 0) return null;
 						const tagAccess = catalogs.every(catalog => catalog.accountKey !== undefined);

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

@@ -100,6 +100,19 @@ export interface CerebrasModelManagerConfig {
     fetch?: FetchImpl;
 }
 export declare function cerebrasModelManagerOptions(config?: CerebrasModelManagerConfig): ModelManagerOptions<"openai-completions">;
+/** SambaNova discovery inputs: `apiKey` enables the live roster; `baseUrl` defaults to SambaNova Cloud. */
+export interface SambaNovaModelManagerConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    fetch?: FetchImpl;
+}
+/**
+ * SambaNova Cloud's model manager. `/v1/models` requires a key, so a keyless
+ * manager serves only the bundled seed; with a key the live roster replaces
+ * it. Rows carry pricing and limits but no capability metadata: reasoning,
+ * thinking wire format, and image input come from `providers/sambanova.kdl`.
+ */
+export declare function sambanovaModelManagerOptions(config?: SambaNovaModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface HuggingfaceModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
@@ -232,52 +245,6 @@ export interface ZhipuCodingPlanModelManagerConfig {
     fetch?: FetchImpl;
 }
 export declare function zhipuCodingPlanModelManagerOptions(config?: ZhipuCodingPlanModelManagerConfig): ModelManagerOptions<"openai-completions">;
-/**
- * Fireworks-published cap for the Kimi K2 family. Fireworks' `/v1/models`
- * envelope generically reports `max_completion_tokens: 65536` for every Kimi
- * deployment, but Kimi K2 (instruct / thinking / turbo) on Fireworks is
- * documented to ship long reasoning traces that should be bounded — capping
- * at 32,768 prevents handing callers a budget the router cannot honor.
- * See https://github.com/can1357/oh-my-pi/issues/1849.
- */
-export declare const FIREWORKS_KIMI_MAX_TOKENS = 32768;
-/**
- * Fireworks' output ceiling for Kimi K2.7-Code specifically. Its `/v1/models`
- * generic `max_completion_tokens` is 65,536 and Fireworks serves it in full —
- * verified with a single completion emitting 58,971 output tokens and
- * `max_tokens: 200000` accepted without error. Unlike the older K2.5/K2.6
- * family (see {@link FIREWORKS_KIMI_MAX_TOKENS}), K2.7-Code is not clamped to
- * 32,768; that ceiling only truncated it.
- */
-export declare const FIREWORKS_KIMI_K27_CODE_MAX_TOKENS = 65536;
-/**
- * Returns true for the Kimi K2.5 / K2.6 family served by Fireworks-backed
- * providers (`fireworks` direct, `firepass` router) that share the 32,768
- * `maxTokens` ceiling. Matches both the public catalog id (`kimi-k2.5`,
- * `kimi-k2.6`, `kimi-k2.6-turbo`) and the canonical Fireworks wire id
- * (`accounts/fireworks/{models,routers}/kimi-k2…`).
- *
- * K2.7-Code (incl. `-fast` / `-highspeed`) is deliberately excluded: unlike the
- * earlier K2 family it serves its full context on Fireworks — verified with a
- * single completion emitting 58,971 output tokens and `max_tokens: 200000`
- * accepted without error — so the 32,768 cap would only truncate it. It inherits
- * Fireworks' reported `max_completion_tokens` (65,536) instead.
- */
-export declare function isFireworksKimiK2ModelId(modelId: string): boolean;
-/**
- * Clamp the Kimi K2 family's `maxTokens` to {@link FIREWORKS_KIMI_MAX_TOKENS}
- * on Fireworks-backed providers, leaving every other model untouched.
- */
-export declare function clampFireworksKimiMaxTokens(modelId: string, candidate: number): number;
-export declare function clampFireworksKimiMaxTokens(modelId: string, candidate: number | null): number | null;
-/**
- * Kimi K2.7 Code's documented recommended output budget. Some provider
- * discovery rows report the context-sized `max_completion_tokens` instead.
- */
-export declare const KIMI_K27_CODE_RECOMMENDED_MAX_TOKENS = 32768;
-export declare function isKimiK27CodeModelId(modelId: string): boolean;
-export declare function clampKimiK27CodeMaxTokens(modelId: string, candidate: number): number;
-export declare function clampKimiK27CodeMaxTokens(modelId: string, candidate: number | null): number | null;
 /**
  * Build the Fireworks Fast seed by projecting each base bundled spec into a
  * `<id>-fast` variant. Pushed into the generated catalog (Fast routers never
@@ -655,6 +622,11 @@ export interface ModelsDevProviderDescriptor {
 }
 /** Generic mapper that converts models.dev data using provider descriptors. */
 export declare function mapModelsDevToModels(data: Record<string, unknown>, descriptors: readonly ModelsDevProviderDescriptor[]): ModelSpec<Api>[];
+/**
+ * OpenCode Go endpoint for one request API. The model generator re-bases
+ * previous-snapshot rows with it so retained rows follow endpoint moves.
+ */
+export declare function openCodeGoBaseUrlForApi(api: Api): string;
 /** Resolves the transport and endpoint for one Z.AI model catalog entry. */
 export declare function resolveZaiApi(modelId: string): {
     api: "anthropic-messages" | "openai-completions";