@linxiraos/pi-catalog 1.2.0 → 1.3.0

package/src/build.ts

@@ -10,8 +10,16 @@
 import { resolveDiscoveryApi, resolveModelPolicy } from "./compat/resolve";
 import type { ModelIdentity } from "./compat/types";
 import { resolveModelTokenizer } from "./model-tokenizer";
-import { materializeTimeBasedCost } from "./pricing";
-import { type Api, MODEL_KINDS, type Model, type ModelSpec } from "./types";
+import {
+	applyDueDatedCostCard,
+	type DatedCostCard,
+	dueEffectiveRate,
+	EARLIEST_EFFECTIVE_FROM,
+	materializeTimeBasedCost,
+	NO_RECURRING_TARIFF,
+	parseDatedCostCards,
+} from "./pricing";
+import { type Api, type EffectiveTokenCost, MODEL_KINDS, type Model, type ModelCost, type ModelSpec } from "./types";
 import { cleanModelName } from "./utils";
 
 function numberField(source: object, key: string): number | undefined {
@@ -24,41 +32,6 @@ function objectPayload(value: unknown): object | undefined {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
 }
 
-/**
- * Overwrite seeded fallback rates with the latest dated card whose
- * `effectiveFrom` is already due. Leaves the seed unchanged when no card
- * has started, and never attaches a `timeBased` tariff.
- */
-function applyEffectiveFallbackRates(
-	cost: { input: number; output: number; cacheRead: number; cacheWrite: number },
-	effectiveRates: unknown,
-	now = Date.now(),
-): void {
-	const rates = objectPayload(effectiveRates);
-	if (rates === undefined) return;
-	let latestFrom = Number.NEGATIVE_INFINITY;
-	let latest: object | undefined;
-	for (const entry of Object.values(rates)) {
-		const payload = objectPayload(entry);
-		if (payload === undefined) continue;
-		const date = Reflect.get(payload, "effectiveFrom");
-		if (typeof date !== "string") continue;
-		const from = Date.parse(date);
-		if (!Number.isFinite(from) || from > now || from < latestFrom) continue;
-		latestFrom = from;
-		latest = payload;
-	}
-	if (latest === undefined) return;
-	const input = numberField(latest, "input");
-	if (input !== undefined) cost.input = input;
-	const output = numberField(latest, "output");
-	if (output !== undefined) cost.output = output;
-	const cacheRead = numberField(latest, "cacheRead");
-	if (cacheRead !== undefined) cost.cacheRead = cacheRead;
-	const cacheWrite = numberField(latest, "cacheWrite");
-	if (cacheWrite !== undefined) cost.cacheWrite = cacheWrite;
-}
-
 /** Narrow a compiled `input-modalities` axis value to the model input union. */
 function isInputModalities(value: unknown): value is ("text" | "image")[] {
 	return Array.isArray(value) && value.every(entry => entry === "text" || entry === "image");
@@ -81,6 +54,11 @@ function applyCatalogAssignments<TApi extends Api>(model: Model<TApi>, catalog:
 	} else {
 		delete model.contextWindowAuthoritative;
 	}
+	if (catalog.longContextWindowUncapped === true) {
+		model.longContextWindowUncapped = true;
+	} else {
+		delete model.longContextWindowUncapped;
+	}
 	const webSearch = catalog.webSearch;
 	if (
 		webSearch === "gemini" ||
@@ -142,6 +120,11 @@ function applyCatalogAssignments<TApi extends Api>(model: Model<TApi>, catalog:
 	} else {
 		delete model.requiresCursorToolSchemaProjection;
 	}
+	if (catalog.toolSchemasInContext === false) {
+		model.toolSchemasInContext = false;
+	} else {
+		delete model.toolSchemasInContext;
+	}
 	const requiresToolResultImageHoisting = catalog.requiresToolResultImageHoisting;
 	if (requiresToolResultImageHoisting === true) {
 		model.requiresToolResultImageHoisting = true;
@@ -164,52 +147,65 @@ function applyCatalogAssignments<TApi extends Api>(model: Model<TApi>, catalog:
 	}
 }
 
+/** The parsed dated cards of a row's `cost-patch` and `cost-fallback`. */
+interface DatedCostCards {
+	patch: readonly DatedCostCard[];
+	fallback: readonly DatedCostCard[];
+}
+
 /**
- * Applies reviewed catalog-data value corrections (`cost-patch`,
- * `cache-read-at-input-rate`, `limits-patch`, `long-context-cost`,
- * `context-window-floor`, `input-modalities`) onto an upstream-sourced spec. Applied by
- * `buildModel` to every upstream-sourced spec; user-authored overrides are
- * recomposed after building by the override applicators, so explicit user
- * limits and pricing still win.
+ * The row's corrected price card at `now`: `cost-patch`, then `cost-fallback`
+ * (each with its dated card due at `now`), then the long-context tier and
+ * cache-rate derivations, all from the upstream card.
  */
-export function applyCatalogCorrections(
-	model: Pick<ModelSpec<Api>, "cost" | "contextWindow" | "maxTokens" | "input">,
+function correctedCost(
+	upstream: ModelCost,
 	catalog: Record<string, unknown>,
-): void {
+	cards: DatedCostCards,
+	now: number,
+): ModelCost {
+	let cost: ModelCost = { ...upstream };
+	const upstreamCard =
+		upstream.timeBased?.effectiveRates?.[0]?.effectiveFrom === EARLIEST_EFFECTIVE_FROM
+			? dueEffectiveRate(upstream.timeBased, now)
+			: undefined;
+	if (upstreamCard !== undefined) {
+		// A row rebuilt from an already built one (dynamic merges, overrides)
+		// carries the dated schedule compiled below. Its leading card covers all
+		// history, so the scalar legs only ever held the card due at the first
+		// build; start from the card due now instead.
+		const { effectiveFrom: _effectiveFrom, ...card } = upstreamCard;
+		const { longContext: _longContext, ...base } = cost;
+		cost = { ...base, ...card };
+	}
 	const patch = objectPayload(catalog.costPatch);
 	if (patch !== undefined) {
-		model.cost = { ...model.cost };
 		const input = numberField(patch, "input");
-		if (input !== undefined) model.cost.input = input;
+		if (input !== undefined) cost.input = input;
 		const output = numberField(patch, "output");
-		if (output !== undefined) model.cost.output = output;
+		if (output !== undefined) cost.output = output;
 		const cacheRead = numberField(patch, "cacheRead");
-		if (cacheRead !== undefined) model.cost.cacheRead = cacheRead;
+		if (cacheRead !== undefined) cost.cacheRead = cacheRead;
 		const cacheWrite = numberField(patch, "cacheWrite");
-		if (cacheWrite !== undefined) model.cost.cacheWrite = cacheWrite;
+		if (cacheWrite !== undefined) cost.cacheWrite = cacheWrite;
+		applyDueDatedCostCard(cost, cards.patch, now);
 	}
 	const fallback = objectPayload(catalog.costFallback);
 	if (fallback !== undefined) {
-		const base = model.cost;
-		const hasTokenPrice = base.input !== 0 || base.output !== 0 || base.cacheRead !== 0 || base.cacheWrite !== 0;
+		const hasTokenPrice = cost.input !== 0 || cost.output !== 0 || cost.cacheRead !== 0 || cost.cacheWrite !== 0;
 		if (!hasTokenPrice) {
 			// Upstream reported no token price (plan-included or promo-free
 			// rows): seed the reviewed list price instead of overwriting real
 			// discovery data the way `cost-patch` would.
-			model.cost = { ...model.cost };
 			const input = numberField(fallback, "input");
-			if (input !== undefined) model.cost.input = input;
+			if (input !== undefined) cost.input = input;
 			const output = numberField(fallback, "output");
-			if (output !== undefined) model.cost.output = output;
+			if (output !== undefined) cost.output = output;
 			const cacheRead = numberField(fallback, "cacheRead");
-			if (cacheRead !== undefined) model.cost.cacheRead = cacheRead;
+			if (cacheRead !== undefined) cost.cacheRead = cacheRead;
 			const cacheWrite = numberField(fallback, "cacheWrite");
-			if (cacheWrite !== undefined) model.cost.cacheWrite = cacheWrite;
-			// Dated fallback rates overwrite the seeded numbers when they have
-			// already taken effect. They are not a recurring tariff: wrapping
-			// them in `timeBased` with empty peak windows would report
-			// permanent off-peak and never wake at the dated boundary.
-			applyEffectiveFallbackRates(model.cost, Reflect.get(fallback, "effectiveRates"));
+			if (cacheWrite !== undefined) cost.cacheWrite = cacheWrite;
+			applyDueDatedCostCard(cost, cards.fallback, now);
 		}
 	}
 	const longContext = objectPayload(catalog.longContext);
@@ -221,20 +217,19 @@ export function applyCatalogCorrections(
 		const output = numberField(longContext, "output");
 		const cacheRead = numberField(longContext, "cacheRead");
 		const cacheWrite = numberField(longContext, "cacheWrite");
-		const base = model.cost;
-		const hasTokenPrice = base.input !== 0 || base.output !== 0 || base.cacheRead !== 0 || base.cacheWrite !== 0;
+		const hasTokenPrice = cost.input !== 0 || cost.output !== 0 || cost.cacheRead !== 0 || cost.cacheWrite !== 0;
 		if (inputThreshold !== undefined && multiplier !== undefined && hasTokenPrice) {
 			// Multiplier form: tier rates derive from the row's final base card,
 			// after `cost-patch`/`cost-fallback` corrected the live list price.
-			model.cost = {
-				...base,
+			cost = {
+				...cost,
 				longContext: {
 					inputThreshold,
 					...(inclusive && { inputThresholdInclusive: true }),
-					input: base.input * multiplier,
-					output: base.output * multiplier,
-					cacheRead: base.cacheRead * multiplier,
-					cacheWrite: base.cacheWrite * multiplier,
+					input: cost.input * multiplier,
+					output: cost.output * (numberField(longContext, "outputMultiplier") ?? multiplier),
+					cacheRead: cost.cacheRead * multiplier,
+					cacheWrite: cost.cacheWrite * multiplier,
 				},
 			};
 		} else if (
@@ -244,19 +239,94 @@ export function applyCatalogCorrections(
 			cacheRead !== undefined &&
 			cacheWrite !== undefined
 		) {
-			model.cost = { ...model.cost, longContext: { inputThreshold, input, output, cacheRead, cacheWrite } };
+			cost = { ...cost, longContext: { inputThreshold, input, output, cacheRead, cacheWrite } };
 		}
 	}
 	if (catalog.cacheReadAtInputRate === true) {
-		const { longContext } = model.cost;
-		model.cost = {
-			...model.cost,
-			cacheRead: model.cost.input,
+		const { longContext } = cost;
+		cost = {
+			...cost,
+			cacheRead: cost.input,
 			...(longContext && { longContext: { ...longContext, cacheRead: longContext.input } }),
 		};
 	}
-	if (catalog.timeBased !== undefined) {
-		model.cost = { ...model.cost, timeBased: materializeTimeBasedCost(catalog.timeBased) };
+	const cacheWriteRate = catalog.cacheWriteRate;
+	if (typeof cacheWriteRate === "number") {
+		const { longContext } = cost;
+		cost = {
+			...cost,
+			cacheWrite: cost.input * cacheWriteRate,
+			...(longContext && { longContext: { ...longContext, cacheWrite: longContext.input * cacheWriteRate } }),
+		};
+	}
+	return cost;
+}
+
+/**
+ * Every price period the dated `cost-patch`/`cost-fallback` cards define, for
+ * request-time selection (`calculateUsageCost`): a row built before a change
+ * still bills requests after it at the new price, and a leading card keeps
+ * earlier requests at the old one on rows built after it. Undefined when no
+ * card changes the price (no cards, or a fallback the upstream price outranks).
+ */
+function scheduledRates(
+	upstream: ModelCost,
+	catalog: Record<string, unknown>,
+	cards: DatedCostCards,
+): EffectiveTokenCost[] | undefined {
+	const dates = [...cards.patch, ...cards.fallback].map(card => card.effectiveFrom).sort((a, b) => a - b);
+	if (dates.length === 0) return undefined;
+	const periods: EffectiveTokenCost[] = [];
+	let previousPrice: string | undefined;
+	for (const effectiveFrom of [EARLIEST_EFFECTIVE_FROM, ...dates]) {
+		const { input, output, cacheRead, cacheWrite, longContext } = correctedCost(
+			upstream,
+			catalog,
+			cards,
+			effectiveFrom,
+		);
+		const price = { input, output, cacheRead, cacheWrite, ...(longContext && { longContext }) };
+		const key = JSON.stringify(price);
+		if (key === previousPrice) continue;
+		previousPrice = key;
+		periods.push({ effectiveFrom, ...price });
+	}
+	return periods.length > 1 ? periods : undefined;
+}
+
+/**
+ * Applies reviewed catalog-data value corrections (`cost-patch`,
+ * `cache-read-at-input-rate`, `cache-write-rate`, `limits-patch`,
+ * `long-context-cost`, `context-window-floor`, `input-modalities`) onto an
+ * upstream-sourced spec. Applied by
+ * `buildModel` to every upstream-sourced spec; user-authored overrides are
+ * recomposed after building by the override applicators, so explicit user
+ * limits and pricing still win.
+ */
+export function applyCatalogCorrections(
+	model: Pick<ModelSpec<Api>, "cost" | "contextWindow" | "maxTokens" | "input">,
+	catalog: Record<string, unknown>,
+): void {
+	const upstream = model.cost;
+	const cards: DatedCostCards = {
+		patch: parseDatedCostCards(catalog.costPatch, "cost-patch"),
+		fallback: parseDatedCostCards(catalog.costFallback, "cost-fallback"),
+	};
+	// The card due now is the row's displayed price; the dated schedule rides
+	// along so rows reused past a change (bundles, caches, long sessions) still
+	// bill each request at the card in force when it was made.
+	model.cost = correctedCost(upstream, catalog, cards, Date.now());
+	const recurring = catalog.timeBased === undefined ? undefined : materializeTimeBasedCost(catalog.timeBased);
+	const dated = scheduledRates(upstream, catalog, cards);
+	if (dated !== undefined) {
+		if (recurring?.effectiveRates !== undefined) {
+			throw new Error(
+				"Dated cost-patch/cost-fallback effective-rates cannot combine with time-based-cost effective-rates",
+			);
+		}
+		model.cost = { ...model.cost, timeBased: { ...(recurring ?? NO_RECURRING_TARIFF), effectiveRates: dated } };
+	} else if (recurring !== undefined) {
+		model.cost = { ...model.cost, timeBased: recurring };
 	}
 	const limitsPatch = objectPayload(catalog.limitsPatch);
 	if (limitsPatch !== undefined) {
@@ -265,6 +335,14 @@ export function applyCatalogCorrections(
 		const maxTokens = numberField(limitsPatch, "maxTokens");
 		if (maxTokens !== undefined) model.maxTokens = maxTokens;
 	}
+	const maxTokensFallback = catalog.maxTokensFallback;
+	if (typeof maxTokensFallback === "number" && model.maxTokens === null) {
+		model.maxTokens = maxTokensFallback;
+	}
+	const maxTokensCeiling = catalog.maxTokensCeiling;
+	if (typeof maxTokensCeiling === "number" && model.maxTokens !== null && model.maxTokens > maxTokensCeiling) {
+		model.maxTokens = maxTokensCeiling;
+	}
 	const contextWindowFloor = catalog.contextWindowFloor;
 	if (typeof contextWindowFloor === "number") {
 		model.contextWindow = Math.max(model.contextWindow ?? 0, contextWindowFloor);
@@ -351,8 +429,9 @@ export function buildModel<TApi extends Api>(spec: ModelSpec<TApi>): Model<TApi>
 	const model: Model<TApi> = {
 		...spec,
 		// A reviewed `thinking-upgrade-neutral` policy can repair a stale
-		// `reasoning: false` discovery default (see `resolveThinkingPolicy`);
-		// materialize the correction for transports and the picker.
+		// `reasoning: false` discovery default, and an unclassified neutral spec
+		// gets an unverified ladder (see `resolveThinkingPolicy`); materialize
+		// either for transports and the picker.
 		reasoning: spec.reasoning || policy.thinking !== undefined,
 		name: cleanModelName(spec.name),
 		identity: policy.identity,

package/src/compat/auth-ids.ts

@@ -70,6 +70,7 @@ export type AuthProviderId =
 	| "qianfan"
 	| "qwen-portal"
 	| "sakana"
+	| "sambanova"
 	| "siliconflow"
 	| "siliconflow-cn"
 	| "singularityapi-dev"
@@ -157,6 +158,7 @@ export type LoginProviderId =
 	| "qianfan"
 	| "qwen-portal"
 	| "sakana"
+	| "sambanova"
 	| "siliconflow"
 	| "siliconflow-cn"
 	| "singularityapi-dev"

package/src/compat/axes.d.ts

@@ -16,7 +16,7 @@ export type AxisShape = "scalar" | "array" | "object";
 /** Axis namespace: request-wire compat, thinking control surface, or catalog metadata. */
 export type AxisSet = "wire" | "thinking" | "catalog";
 /** Resolved compat record families a wire axis may be assigned onto. */
-export type CompatRecordName = "openai" | "openai-responses" | "anthropic" | "bedrock" | "devin" | "google" | "request";
+export type CompatRecordName = "openai" | "openai-responses" | "anthropic" | "bedrock" | "devin" | "google" | "request" | "ollama";
 /** One axis definition: resolved key, namespace, shape, and applicability. */
 export interface AxisDef {
     /** Resolved camelCase field the directive assigns. */

package/src/compat/axes.ts

@@ -20,7 +20,15 @@ export type AxisShape = "scalar" | "array" | "object";
 export type AxisSet = "wire" | "thinking" | "catalog";
 
 /** Resolved compat record families a wire axis may be assigned onto. */
-export type CompatRecordName = "openai" | "openai-responses" | "anthropic" | "bedrock" | "devin" | "google" | "request";
+export type CompatRecordName =
+	| "openai"
+	| "openai-responses"
+	| "anthropic"
+	| "bedrock"
+	| "devin"
+	| "google"
+	| "request"
+	| "ollama";
 
 /** One axis definition: resolved key, namespace, shape, and applicability. */
 export interface AxisDef {
@@ -242,15 +250,16 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	"escape-builtin-tool-names": wire("escapeBuiltinToolNames", ["anthropic"]),
 	"fast-mode": wire("fastMode", ["anthropic"]),
 	"first-party-provider": wire("firstPartyProvider", ["anthropic"]),
+	"honors-claude-code-beta-kill-switch": wire("honorsClaudeCodeBetaKillSwitch", ["anthropic"]),
 	"inject-claude-code-instruction": wire("injectClaudeCodeInstruction", ["anthropic"]),
-	"max-image-dimension": wire("maxImageDimension", ["anthropic"]),
-	"max-image-payload-bytes": wire("maxImagePayloadBytes", ["anthropic"]),
+	"max-image-dimension": wire("maxImageDimension", ["anthropic", "google"]),
+	"max-image-payload-bytes": wire("maxImagePayloadBytes", ["anthropic", "google"]),
 	"official-endpoint": wire("officialEndpoint", ["anthropic", "openai-responses"]),
 	"replay-unsigned-thinking": wire("replayUnsignedThinking", ["anthropic"]),
 	"requires-thinking-enabled": wire("requiresThinkingEnabled", ["anthropic"]),
 	"requires-tool-result-id": wire("requiresToolResultId", ["anthropic"]),
 	"signing-endpoint": wire("signingEndpoint", ["anthropic"]),
-	"strip-thinking-history": wire("stripThinkingHistory", ["anthropic"]),
+	"strip-thinking-history": wire("stripThinkingHistory", ["openai", "anthropic", "ollama"]),
 	"supports-context-management": wire("supportsContextManagement", ["anthropic"]),
 	"supports-output-effort": wire("supportsOutputEffort", ["anthropic"]),
 	"supports-eager-tool-input-streaming": wire("supportsEagerToolInputStreaming", ["anthropic"]),
@@ -328,6 +337,8 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	"thinking-suppress-when-off": { key: "suppressWhenOff", set: "thinking", shape: "scalar" },
 	"thinking-supports-display": { key: "supportsDisplay", set: "thinking", shape: "scalar" },
 	"thinking-upgrade-neutral": { key: "upgradeNeutral", set: "thinking", shape: "scalar" },
+	/** Unclassified neutral ids here are capability-unknown: offer the ladder as opt-in. */
+	"thinking-unverified": { key: "unverified", set: "thinking", shape: "scalar" },
 
 	// ── catalog metadata ──
 	"apply-patch-tool-type": {
@@ -337,12 +348,21 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 		values: ["freeform", "function"],
 	},
 	"requires-native-tools": { key: "requiresNativeTools", set: "catalog", shape: "scalar", values: [true, false] },
+	"tool-schemas-in-context": { key: "toolSchemasInContext", set: "catalog", shape: "scalar", values: [true, false] },
 	"requires-tool-free-history-for-tool-opt-out": {
 		key: "requiresToolFreeHistoryForToolOptOut",
 		set: "catalog",
 		shape: "scalar",
 		values: [true, false],
 	},
+	/** Replayed tool calls must satisfy the target wire's declaration charset and length. */
+	"tool-call-name-charset": {
+		key: "toolCallNameCharset",
+		set: "catalog",
+		shape: "scalar",
+		values: ["ascii", "google"],
+	},
+	"tool-call-name-max-length": { key: "toolCallNameMaxLength", set: "catalog", shape: "scalar" },
 	"preserves-max-output-tokens": {
 		key: "preservesMaxOutputTokens",
 		set: "catalog",
@@ -367,6 +387,19 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 		shape: "scalar",
 		values: [true, false],
 	},
+	/**
+	 * The model's input classifier refuses requests that reproduce assistant
+	 * reasoning as quoted text (`reasoning_extraction`), so reasoning must not
+	 * be replayed as text into its input: compaction archives, summarizer
+	 * transcripts and demoted interrupted turns leave it out. Declared per class
+	 * in `classes/*.kdl`.
+	 */
+	"classifier-cot-extraction": {
+		key: "classifierCotExtraction",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false],
+	},
 	"clamp-context-override": { key: "clampContextOverride", set: "catalog", shape: "scalar" },
 	"context-promotion-target": { key: "contextPromotionTarget", set: "catalog", shape: "scalar" },
 	"context-window-floor": { key: "contextWindowFloor", set: "catalog", shape: "scalar" },
@@ -376,6 +409,19 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 		shape: "scalar",
 		values: [true, false],
 	},
+	/**
+	 * The model's long-context price tier does not bound its runtime context
+	 * window: with extended context off, the window is not capped at the
+	 * tier's input threshold (subscription hosts carrying API-equivalent tier
+	 * prices, or a model served at its full window). Explicit user context
+	 * overrides still apply.
+	 */
+	"long-context-window-uncapped": {
+		key: "longContextWindowUncapped",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false],
+	},
 	"cost-patch": { key: "costPatch", set: "catalog", shape: "object" },
 	"cost-fallback": { key: "costFallback", set: "catalog", shape: "object" },
 	/**
@@ -388,6 +434,26 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 		shape: "scalar",
 		values: [true, false],
 	},
+	/**
+	 * The host bills cache writes at this multiple of the row's live `input`
+	 * price, for hosts whose discovery reports cache-write tokens but no
+	 * cache-write rate. It replaces any `cacheWrite` the row carries, including
+	 * a `cost-patch`/`cost-fallback` value and an absolute long-context tier's
+	 * `cacheWrite` (rebased on the tier's `input`).
+	 */
+	"cache-write-rate": { key: "cacheWriteRate", set: "catalog", shape: "scalar" },
+	/**
+	 * How the model line bills a replayed signed thinking block as input:
+	 * `output` bills the reasoning its signature carries, at the size the turn
+	 * billed as output, and not the signature's bytes. Unassigned: estimated
+	 * from the signature's bytes. Read through `./thinking-replay`.
+	 */
+	"thinking-replay-tokens": {
+		key: "thinkingReplayTokens",
+		set: "catalog",
+		shape: "scalar",
+		values: ["output", "signature"],
+	},
 	"delegation-bias": { key: "delegationBias", set: "catalog", shape: "scalar", values: DELEGATION_BIASES },
 	"discovery-api": { key: "discoveryApi", set: "catalog", shape: "scalar" },
 	"edit-prompt-variant": { key: "editPromptVariant", set: "catalog", shape: "scalar", values: ["full", "compact"] },
@@ -404,16 +470,74 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	"hosted-image": { key: "hostedImage", set: "catalog", shape: "scalar", values: [true, false] },
 	/** How the model line bills an input image; shape and formulas in `./image-tokenization`. */
 	"image-tokenization": { key: "imageTokenization", set: "catalog", shape: "object" },
+	/**
+	 * Most images one request may carry, documents included where the host
+	 * counts them. Unassigned: unknown host, held to a conservative floor.
+	 */
+	"image-count-budget": { key: "imageCountBudget", set: "catalog", shape: "scalar" },
+	/**
+	 * Replaces `image-count-budget` while the request reaches the official
+	 * endpoint (pi-ai `reachesOfficialEndpoint`): a limit measured or documented
+	 * for the host's own endpoint, which a custom `baseUrl` or an
+	 * `ANTHROPIC_BASE_URL`/`FOUNDRY_BASE_URL` reroute (proxy, gateway) need not share.
+	 */
+	"official-image-count-budget": { key: "officialImageCountBudget", set: "catalog", shape: "scalar" },
+	/**
+	 * Opt-in: the reader may get a fresh `read` result as snapcompact frames
+	 * (`snapcompact.toolResults`), because it edits as exactly from frames as
+	 * from text. Unassigned: `read` results stay text, since a reader that
+	 * misreads indentation in frames makes inexact edits.
+	 */
+	"snapcompact-image-reads": { key: "snapcompactImageReads", set: "catalog", shape: "scalar", values: [true, false] },
 	"image-model": { key: "imageModel", set: "catalog", shape: "scalar" },
+	/** Longest image edge the host passes to the model: it downscales larger images to fit first. */
+	"image-max-edge": { key: "imageMaxEdge", set: "catalog", shape: "scalar" },
 	"inline-image-byte-budget": { key: "inlineImageByteBudget", set: "catalog", shape: "scalar" },
+	/**
+	 * Supported formats and size bounds for judgment-request images; `mime-types`
+	 * is comma-separated because object payloads have no array shape.
+	 */
+	"judgment-image-input": { key: "judgmentImageInput", set: "catalog", shape: "object" },
+	/**
+	 * `Content-Encoding`s the host decodes on request bodies, most preferred
+	 * first. Applied only while the request reaches the provider's own endpoint
+	 * (see `endpoint-hosts`), so a proxy or rerouted endpoint never receives
+	 * bytes it cannot read. Unassigned: bodies are sent uncompressed.
+	 */
+	"request-encodings": { key: "requestEncodings", set: "catalog", shape: "array", values: ["zstd", "gzip"] },
+	/**
+	 * HTTPS hostnames the provider itself serves besides its bundled base URL's
+	 * host — per-account endpoints such as Copilot's plan hosts. Together with
+	 * that host they define the provider's own endpoint, which tells first-party
+	 * traffic from a custom gateway that reuses the provider id.
+	 */
+	"endpoint-hosts": { key: "endpointHosts", set: "catalog", shape: "array" },
+	/**
+	 * Pattern of the JSON 400/415 error body the host returns when it cannot
+	 * decode a compressed request body. Unassigned: every JSON 400/415 is a
+	 * possible rejection and is re-checked with an uncompressed resend. Either
+	 * way, a 400/403/415 whose body is not JSON (presumed a proxy's answer, not
+	 * the host's) is re-checked too.
+	 */
+	"request-encoding-rejection": { key: "requestEncodingRejection", set: "catalog", shape: "scalar" },
 	/**
 	 * Most questions one System One judgment request may carry; the judge
 	 * splits larger requests. Unassigned: the endpoint takes any batch size.
 	 */
 	"judgment-questions-max": { key: "judgmentQuestionsMax", set: "catalog", shape: "scalar" },
 	"limits-patch": { key: "limitsPatch", set: "catalog", shape: "object" },
+	/** Seeds `maxTokens` only when the row reports none; applied after `limits-patch`. */
+	"max-tokens-fallback": { key: "maxTokensFallback", set: "catalog", shape: "scalar" },
+	/** Most output tokens the host serves: a larger reported `maxTokens` is lowered to it; an unknown one stays unknown. */
+	"max-tokens-ceiling": { key: "maxTokensCeiling", set: "catalog", shape: "scalar" },
 	"long-context-cost": { key: "longContext", set: "catalog", shape: "object" },
 	"prompt-cache": { key: "promptCache", set: "catalog", shape: "object" },
+	"task-sibling-prompt-cache": {
+		key: "taskSiblingPromptCache",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false],
+	},
 	/**
 	 * Prompt-cache lookback in block positions: how far back from a cache
 	 * breakpoint the provider looks for an earlier request's cache entry.
@@ -532,6 +656,7 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 
 /** Records applicable to each API family; used by `resolve.ts` when applying wire axes. */
 export const API_COMPAT_RECORDS: Readonly<Record<string, readonly CompatRecordName[]>> = {
+	"ollama-chat": ["ollama"],
 	"openai-completions": ["openai"],
 	openrouter: ["openai", "openai-responses"],
 	"openai-responses": ["openai-responses"],

package/src/compat/behavior.d.ts

@@ -78,3 +78,8 @@ export declare function pricingPeerFor(provider: string, model: string): {
     peers: readonly string[];
     peerId: string;
 } | undefined;
+/**
+ * Built-in default model selector chains per agent role (`smol`, `slow`,
+ * `image`, …), most preferred first, in declaration order.
+ */
+export declare function roleDefaultModels(): Readonly<Record<string, readonly string[]>>;

package/src/compat/behavior.ts

@@ -3,7 +3,7 @@
  * (`rules/runtime/behavior.kdl`): provider/model heuristics that run before
  * or outside exact bundled-model lookup — responses routing, API routing,
  * quota tiers, plan requirements, model limits, roster and discovery-mode
- * exclusions, hosted defaults, and pricing peers.
+ * exclusions, hosted defaults, pricing peers, and per-role default models.
  */
 import { globMatch } from "./cascade";
 import rules from "./rules.json";
@@ -225,3 +225,11 @@ export function pricingPeerFor(
 	const alias = rule.aliases.find(candidate => candidate.model === model);
 	return { peers: rule.peers, peerId: alias?.peerId ?? model };
 }
+
+/**
+ * Built-in default model selector chains per agent role (`smol`, `slow`,
+ * `image`, …), most preferred first, in declaration order.
+ */
+export function roleDefaultModels(): Readonly<Record<string, readonly string[]>> {
+	return behavior.roleDefaults;
+}

package/src/compat/cascade.ts

@@ -409,13 +409,16 @@ function resolveOverIndex(index: RuleIndex, target: ResolveTarget): ResolvedAxes
 			reasoning = true;
 		}
 	}
+	// Unclassified targets get their provider's ladder too: it is offered as
+	// unverified thinking (`resolveThinkingPolicy`), never as reasoning capability.
+	const offersThinking = reasoning || target.class === "unknown";
 	const wire: WinnerTable = {};
 	const thinking: WinnerTable = {};
 	const catalog: WinnerTable = {};
 	for (const { rule, rank } of ranked) {
 		contest(wire, rule.compiled.wire, rank, rule, target);
 		contest(catalog, rule.compiled.catalog, rank, rule, target);
-		if (reasoning) contest(thinking, rule.compiled.thinking, rank, rule, target);
+		if (offersThinking) contest(thinking, rule.compiled.thinking, rank, rule, target);
 	}
 	return {
 		wire: collect(wire, rule => rule.wire),