@linxiraos/pi-catalog 1.1.13 → 1.1.15

package/src/models.ts

@@ -1,6 +1,15 @@
 import { classifyModel } from "./compat/taxonomy";
 import MODELS from "./models.json" with { type: "json" };
-import type { Api, KnownProvider, Model, ModelCost, TokenCost, Usage } from "./types";
+import type {
+	Api,
+	EffectiveTokenCost,
+	KnownProvider,
+	Model,
+	ModelCost,
+	TimeBasedCost,
+	TokenCost,
+	Usage,
+} from "./types";
 
 /**
  * Static bundled model registry loaded from `models.json`.
@@ -48,38 +57,103 @@ export function getBundledModels(provider: GeneratedProvider): Model<Api>[] {
 	const models = getProviderModels(provider);
 	return models ? (Array.from(models.values()) as Model<Api>[]) : [];
 }
-function resolveTokenCost(cost: ModelCost, promptInputTokens: number): TokenCost {
-	const longContext = cost.longContext;
-	if (!longContext) return cost;
+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 longContext = rates.longContext;
+	if (!longContext) return rates;
 	const reachesThreshold =
 		promptInputTokens > longContext.inputThreshold ||
 		(longContext.inputThresholdInclusive === true && promptInputTokens === longContext.inputThreshold);
-	return reachesThreshold ? longContext : cost;
+	return reachesThreshold ? longContext : rates;
+}
+
+function isPeakPricingPeriod(schedule: TimeBasedCost, timestamp: number): boolean {
+	// Unix epoch was Thursday. Arithmetic keeps this UTC-only without allocating a Date.
+	const day = Math.floor(timestamp / 86_400_000);
+	const weekday = (((day + 4) % 7) + 7) % 7;
+	const minute = Math.floor((timestamp - day * 86_400_000) / 60_000);
+	for (const window of schedule.peakWindows) {
+		if (minute >= window.startMinute && minute < window.endMinute && window.weekdays.includes(weekday)) return true;
+	}
+	return false;
+}
+
+function timeBasedMultiplier(schedule: TimeBasedCost | undefined, timestamp: number | undefined): number {
+	if (!schedule || timestamp === undefined) return 1;
+	return isPeakPricingPeriod(schedule, timestamp) ? 1 : schedule.offPeakMultiplier;
+}
+
+/** 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;
+	return isPeakPricingPeriod(schedule, timestamp ?? Date.now()) ? "peak" : "off-peak";
+}
+
+/** Return the next actual peak/off-peak change strictly after the Unix-ms timestamp. */
+export function getNextTimeBasedPricingTransition(cost: ModelCost, timestamp?: number): number | undefined {
+	const schedule = cost.timeBased;
+	if (!schedule) return undefined;
+	const now = timestamp ?? Date.now();
+	const firstDay = Math.floor(now / 86_400_000);
+	const horizon = now + 7 * 86_400_000;
+	let next = Infinity;
+	// All changes occur at window edges; one UTC week covers the entire recurrence.
+	for (let offset = 0; offset <= 7; offset++) {
+		const day = firstDay + offset;
+		const weekday = (((day + 4) % 7) + 7) % 7;
+		for (const window of schedule.peakWindows) {
+			if (!window.weekdays.includes(weekday)) continue;
+			for (let edge = 0; edge < 2; edge++) {
+				const minute = edge === 0 ? window.startMinute : window.endMinute;
+				const candidate = day * 86_400_000 + minute * 60_000;
+				if (candidate <= now || candidate > horizon || candidate >= next) continue;
+				// Overlapping/touching windows can hide an edge, including at midnight.
+				if (isPeakPricingPeriod(schedule, candidate - 1) !== isPeakPricingPeriod(schedule, candidate)) {
+					next = candidate;
+				}
+			}
+		}
+	}
+	return next === Infinity ? undefined : next;
 }
 
-/** Price a prompt as fully uncached input under its active context-length tier. */
-export function calculateUncachedInputCost(cost: ModelCost, promptInputTokens: number): number {
-	const rates = resolveTokenCost(cost, promptInputTokens);
-	return (rates.input / 1_000_000) * promptInputTokens;
+/** Price a fully uncached prompt at its request timestamp (Unix ms); scheduled prices default to now. */
+export function calculateUncachedInputCost(cost: ModelCost, promptInputTokens: number, timestamp?: number): number {
+	const pricingTimestamp = cost.timeBased ? (timestamp ?? Date.now()) : undefined;
+	const rates = resolveTokenCost(cost, promptInputTokens, pricingTimestamp);
+	return (rates.input / 1_000_000) * promptInputTokens * timeBasedMultiplier(cost.timeBased, pricingTimestamp);
 }
 
-/** Price one usage record from a token rate card, including active context tiers. */
-export function calculateUsageCost(cost: ModelCost, usage: Usage): Usage["cost"] {
+/** Price usage at its request timestamp (Unix ms); only scheduled prices default to now. */
+export function calculateUsageCost(cost: ModelCost, usage: Usage, timestamp?: number): Usage["cost"] {
 	const orchestration = usage.orchestration;
 	const promptInputTokens =
 		usage.input + usage.cacheRead + usage.cacheWrite + (orchestration?.input ?? 0) + (orchestration?.cacheRead ?? 0);
-	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));
-	usage.cost.cacheWrite = cacheWriteCost(rates, usage);
+	const pricingTimestamp = cost.timeBased ? (timestamp ?? Date.now()) : undefined;
+	const rates = resolveTokenCost(cost, promptInputTokens, pricingTimestamp);
+	const multiplier = timeBasedMultiplier(cost.timeBased, pricingTimestamp);
+	usage.cost.input = (rates.input / 1000000) * (usage.input + (orchestration?.input ?? 0)) * multiplier;
+	usage.cost.output = (rates.output / 1000000) * (usage.output + (orchestration?.output ?? 0)) * multiplier;
+	usage.cost.cacheRead =
+		(rates.cacheRead / 1000000) * (usage.cacheRead + (orchestration?.cacheRead ?? 0)) * multiplier;
+	usage.cost.cacheWrite = cacheWriteCost(rates, usage) * multiplier;
 	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
 	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 usage at its request timestamp (Unix ms); preserve the resulting monetary amounts for display. */
+export function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage, timestamp?: number): Usage["cost"] {
+	return calculateUsageCost(model.cost, usage, timestamp);
 }
 
 /**

package/src/pricing.ts

@@ -0,0 +1,136 @@
+import type { EffectiveTokenCost, LongContextTokenCost, PeakPricingWindow, TimeBasedCost, TokenCost } from "./types";
+import { isRecord } from "./utils";
+
+function nonnegative(value: unknown): value is number {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+
+function isRates(value: unknown): value is TokenCost {
+	return (
+		isRecord(value) &&
+		nonnegative(value.input) &&
+		nonnegative(value.output) &&
+		nonnegative(value.cacheRead) &&
+		nonnegative(value.cacheWrite)
+	);
+}
+
+function isLongContext(value: unknown): value is LongContextTokenCost {
+	return (
+		isRecord(value) &&
+		isRates(value) &&
+		typeof value.inputThreshold === "number" &&
+		Number.isFinite(value.inputThreshold) &&
+		value.inputThreshold > 0 &&
+		(value.inputThresholdInclusive === undefined || typeof value.inputThresholdInclusive === "boolean")
+	);
+}
+
+function isPeakWindow(value: unknown): value is PeakPricingWindow {
+	return (
+		isRecord(value) &&
+		Array.isArray(value.weekdays) &&
+		value.weekdays.length > 0 &&
+		value.weekdays.every(day => Number.isInteger(day) && day >= 0 && day <= 6) &&
+		new Set(value.weekdays).size === value.weekdays.length &&
+		typeof value.startMinute === "number" &&
+		Number.isInteger(value.startMinute) &&
+		typeof value.endMinute === "number" &&
+		Number.isInteger(value.endMinute) &&
+		value.startMinute >= 0 &&
+		value.endMinute <= 1440 &&
+		value.startMinute < value.endMinute
+	);
+}
+
+function isEffectiveRate(value: unknown): value is EffectiveTokenCost {
+	return (
+		isRecord(value) &&
+		isRates(value) &&
+		typeof value.effectiveFrom === "number" &&
+		Number.isSafeInteger(value.effectiveFrom) &&
+		Math.abs(value.effectiveFrom) <= 8_640_000_000_000_000 &&
+		(value.longContext === undefined || isLongContext(value.longContext))
+	);
+}
+
+/** Validate serialized schedules before admitting cached model rows. */
+export function isTimeBasedCost(value: unknown): value is TimeBasedCost {
+	if (
+		!isRecord(value) ||
+		!nonnegative(value.offPeakMultiplier) ||
+		!Array.isArray(value.peakWindows) ||
+		!value.peakWindows.every(isPeakWindow)
+	) {
+		return false;
+	}
+	if (value.effectiveRates === undefined) return true;
+	if (!Array.isArray(value.effectiveRates) || !value.effectiveRates.every(isEffectiveRate)) return false;
+	const dates = new Set<number>();
+	for (const rate of value.effectiveRates) {
+		if (dates.has(rate.effectiveFrom)) return false;
+		dates.add(rate.effectiveFrom);
+	}
+	return true;
+}
+
+function payload(value: unknown, keys: readonly string[], field: string): Record<string, unknown> {
+	if (!isRecord(value) || Object.keys(value).some(key => !keys.includes(key))) {
+		throw new Error(`Invalid time-based-cost ${field}`);
+	}
+	return value;
+}
+
+function namedEntries(value: unknown, field: string): unknown[] {
+	if (!isRecord(value)) throw new Error(`Invalid time-based-cost ${field}: expected named objects`);
+	return Object.values(value);
+}
+
+/** 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");
+	const peakWindows = namedEntries(source.peakWindows, "peak-windows").map(entry => {
+		const window = payload(entry, ["weekdays", "startMinute", "endMinute"], "peak-window");
+		if (typeof window.weekdays !== "string" || !/^[0-6](,[0-6])*$/.test(window.weekdays)) {
+			throw new Error("Invalid time-based-cost weekdays: expected comma-separated UTC weekday numbers");
+		}
+		return { ...window, weekdays: window.weekdays.split(",").map(Number) };
+	});
+	const effectiveRates =
+		source.effectiveRates === undefined
+			? undefined
+			: namedEntries(source.effectiveRates, "effective-rates").map(entry => {
+					const rate = payload(
+						entry,
+						["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");
+					}
+					if (rate.longContext !== undefined) {
+						payload(
+							rate.longContext,
+							["inputThreshold", "inputThresholdInclusive", "input", "output", "cacheRead", "cacheWrite"],
+							"long-context",
+						);
+					}
+					return { ...rate, effectiveFrom };
+				});
+	const schedule = {
+		offPeakMultiplier: source.offPeakMultiplier,
+		peakWindows,
+		...(effectiveRates && { effectiveRates }),
+	};
+	if (!isTimeBasedCost(schedule))
+		throw new Error("Invalid time-based-cost schedule: invalid windows, rates, or multiplier");
+	return schedule;
+}

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

@@ -1,3 +1,4 @@
+import { CHARM_HYPER_API_BASE_URL, normalizeCharmHyperBaseUrl } from "../wire/charm-hyper";
 import { PERSONAL_GITHUB_COPILOT_BASE_URL } from "../wire/github-copilot";
 
 export interface ModelCacheProviderIdOptions {
@@ -19,6 +20,8 @@ export function isCredentialScopedModelCacheProvider(providerId: string): boolea
 
 export function getDefaultModelDiscoveryBaseUrl(providerId: string): string | undefined {
 	switch (providerId) {
+		case "charm-hyper":
+			return CHARM_HYPER_API_BASE_URL;
 		case "meta":
 		case "muse-code":
 			return "https://api.meta.ai/v1";
@@ -62,6 +65,23 @@ export function resolveModelCacheProviderId(providerId: string, options: ModelCa
 			// 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 "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
+			// configured endpoint, or a self-hosted proxy keeps serving the canonical
+			// host's roster, capabilities and tariffs until expiry.
+			//
+			// Endpoint-only scope is deliberate. `/v1/models` is public here, so the
+			// roster does not vary by key, and `charm-hyper` is absent from
+			// CREDENTIAL_SCOPED_MODEL_CACHE_PROVIDERS — `ModelRegistry` resolves this
+			// namespace with no credential at all, so hashing one would split it
+			// against the namespace discovery computes and miss forever.
+			//
+			// Normalized through the shared helper because the registry passes the
+			// raw configured value while `charmHyperModelManagerOptions` passes a
+			// `/v1`-suffixed one; both must land on one namespace.
+			return `charm-hyper:models-v1:${Bun.hash(normalizeCharmHyperBaseUrl(options.baseUrl)).toString(36)}`;
+		}
 		case "muse-code": {
 			const baseUrl = options.baseUrl ?? getDefaultModelDiscoveryBaseUrl(providerId)!;
 			const scope = `${options.apiKey ?? ""}\u0000${baseUrl}`;
@@ -69,10 +89,14 @@ export function resolveModelCacheProviderId(providerId: string, options: ModelCa
 		}
 		case "litellm": {
 			const baseUrl = options.baseUrl ?? getDefaultModelDiscoveryBaseUrl(providerId)!;
-			// rich-v8 invalidates rows whose `compatConfig` retained a colliding
-			// bundled model's provider-specific transport (e.g. Fireworks
-			// `wireModelIdMode`) before that leak was fixed (issue #9938).
-			return `litellm:rich-v8:${Bun.hash(baseUrl).toString(36)}`;
+			// rich-v9 unions compat across the management endpoints and keys the
+			// deployment's `supports_vision` declaration into it, so a warm
+			// rich-v8 row would keep retracting axes an earlier endpoint reported
+			// (issue #11982). rich-v8 invalidated rows whose `compatConfig`
+			// retained a colliding bundled model's provider-specific transport
+			// (e.g. Fireworks `wireModelIdMode`) before that leak was fixed
+			// (issue #9938).
+			return `litellm:rich-v9:${Bun.hash(baseUrl).toString(36)}`;
 		}
 		case "opencode-go":
 		case "opencode-zen": {

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

@@ -37,6 +37,14 @@ export interface ProviderDescriptor {
 	dynamicModelsAuthoritative?: boolean;
 	/** Catalog discovery configuration. Only providers with this field participate in generate-models.ts. */
 	catalogDiscovery?: CatalogDiscoveryConfig;
+	/**
+	 * When true, generator backfills never copy reasoning/input/limits from
+	 * same-id rows on other providers into this provider's rows. Set for
+	 * providers whose endpoint discovery is the deployment truth and whose
+	 * corrections live in KDL, so a stencil.so or canonical-family reference
+	 * cannot reintroduce foreign metadata.
+	 */
+	skipCrossProviderReferenceFills?: boolean;
 }
 
 /** A provider descriptor that has catalog discovery configured. */
@@ -77,6 +85,13 @@ export interface ProviderCatalogEntry {
 	readonly dynamicModelsAuthoritative?: boolean;
 	/** Catalog discovery configuration for generate-models.ts. */
 	readonly catalogDiscovery?: CatalogDiscoveryConfig;
+	/**
+	 * When true, generator backfills never copy reasoning/input/limits from
+	 * same-id rows on other providers into this provider's rows. Set for
+	 * providers whose endpoint discovery is the deployment truth and whose
+	 * corrections live in KDL.
+	 */
+	readonly skipCrossProviderReferenceFills?: boolean;
 	/**
 	 * Built bespoke by the coding-agent runtime (OAuth-token-driven managers);
 	 * excluded from `PROVIDER_DESCRIPTORS` even though models are discoverable.

package/src/provider-models/descriptors.ts

@@ -18,8 +18,10 @@ import {
 	basetenModelManagerOptions,
 	bedrockMantleModelManagerOptions,
 	cerebrasModelManagerOptions,
+	charmHyperModelManagerOptions,
 	clinePassModelManagerOptions,
 	cloudflareAiGatewayModelManagerOptions,
+	commandCodeModelManagerOptions,
 	coreWeaveModelManagerOptions,
 	deepinfraModelManagerOptions,
 	deepseekModelManagerOptions,
@@ -149,6 +151,26 @@ export const CATALOG_PROVIDERS = [
 		createModelManagerOptions: (config: ModelManagerConfig) => cerebrasModelManagerOptions(config),
 		catalogDiscovery: { label: "Cerebras" },
 	},
+	{
+		id: "charm-hyper",
+		defaultModel: "glm-5.3",
+		envVars: ["CHARM_HYPER_API_KEY", "HYPER_API_KEY"],
+		createModelManagerOptions: (config: ModelManagerConfig) => charmHyperModelManagerOptions(config),
+		allowUnauthenticated: true,
+		dynamicModelsAuthoritative: true,
+		// The gateway row is the whole truth for a Hyper deployment. Same-id rows
+		// on other hosts disagree with it in both directions (it serves
+		// non-thinking Kimi K2.5/K2.7-Code and a text-only Gemma 4 that their
+		// upstream homes list as reasoning/vision), so foreign backfills would
+		// advertise capabilities this deployment does not have.
+		skipCrossProviderReferenceFills: true,
+		// Deliberately NO `catalogDiscovery`: that field is what enrolls a provider
+		// in generate-models.ts. This gateway's catalog is live deployment truth,
+		// so generating would freeze one hyper.charm.land snapshot into
+		// models.json — and since discovery here needs no credentials, it would
+		// happen on every regen, contradicting the runtime-only contract
+		// compat-conformance.test.ts pins for this provider.
+	},
 	{
 		id: "cloudflare-ai-gateway",
 		defaultModel: "anthropic/claude-opus-4-8",
@@ -156,6 +178,19 @@ export const CATALOG_PROVIDERS = [
 		createModelManagerOptions: (config: ModelManagerConfig) => cloudflareAiGatewayModelManagerOptions(config),
 		catalogDiscovery: { label: "Cloudflare AI Gateway" },
 	},
+	{
+		id: "commandcode",
+		defaultModel: "claude-sonnet-4-6",
+		envVars: ["COMMAND_CODE_API_KEY", "COMMANDCODE_API_KEY"],
+		createModelManagerOptions: (config: ModelManagerConfig) => commandCodeModelManagerOptions(config),
+		allowUnauthenticated: true,
+		dynamicModelsAuthoritative: true,
+		catalogDiscovery: { label: "Command Code", allowUnauthenticated: true },
+		// The Provider API rows carry no reasoning/modality metadata and KDL
+		// owns the deployment policy: same-id references on other hosts must
+		// not backfill reasoning, input, or limits during generation.
+		skipCrossProviderReferenceFills: true,
+	},
 	{
 		id: "cursor",
 		defaultModel: "claude-4.6-opus-high",
@@ -611,6 +646,7 @@ export const PROVIDER_DESCRIPTORS: readonly ProviderDescriptor[] = CATALOG_ENTRY
 			createModelManagerOptions: provider.createModelManagerOptions,
 			allowUnauthenticated: provider.allowUnauthenticated,
 			dynamicModelsAuthoritative: provider.dynamicModelsAuthoritative,
+			skipCrossProviderReferenceFills: provider.skipCrossProviderReferenceFills,
 			catalogDiscovery: provider.catalogDiscovery
 				? { ...provider.catalogDiscovery, envVars: provider.catalogDiscovery.envVars ?? provider.envVars ?? [] }
 				: undefined,