@linxiraos/pi-catalog 1.1.26 → 1.2.0

package/src/compat/axes.ts

@@ -140,6 +140,7 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	"qwen-preserve-thinking": wire("qwenPreserveThinking", ["openai"]),
 	"reject-root-object-union": wire("rejectRootObjectUnion", OAI),
 	"retry-without-strict-on-grammar-error": wire("retryWithoutStrictOnGrammarError", OAI),
+	"session-header": wire("sessionHeader", OAI, "scalar", ["x-litellm-session-id"]),
 	"reasoning-content-field": wire("reasoningContentField", OAI, "scalar", [
 		"reasoning_content",
 		"reasoning",
@@ -169,6 +170,8 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	"requires-thinking-as-text": wire("requiresThinkingAsText", ["openai"]),
 	"requires-tool-result-name": wire("requiresToolResultName", ["openai"]),
 	"strict-responses-pairing": wire("strictResponsesPairing", ["openai-responses"]),
+	"connection-bound-native-history": wire("connectionBoundNativeHistory", ["openai-responses"]),
+	"stateful-responses": wire("statefulResponses", ["openai-responses"]),
 	"requires-reasoning-off-juice-instruction": wire("requiresReasoningOffJuiceInstruction", ["openai-responses"]),
 	"supports-all-turns-reasoning-context": wire("supportsAllTurnsReasoningContext", ["openai-responses"]),
 	"supports-configuration-update": wire("supportsConfigurationUpdate", ["openai-responses"]),
@@ -194,6 +197,7 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	"supports-reasoning-effort": wire("supportsReasoningEffort", OAI),
 	"supports-reasoning-params": wire("supportsReasoningParams", OAI),
 	"supports-reasoning-summary": wire("supportsReasoningSummary", ["openai-responses"]),
+	"store-responses": wire("storeResponses", ["openai-responses"]),
 	"supports-store": wire("supportsStore", ["openai"]),
 	"supports-strict-mode": wire("supportsStrictMode", OAI),
 	"supports-tool-choice": wire("supportsToolChoice", OAI),
@@ -227,12 +231,20 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	"allow-anthropic-header-overrides": wire("allowAnthropicHeaderOverrides", ["anthropic"]),
 	"disable-adaptive-thinking": wire("disableAdaptiveThinking", ["anthropic"]),
 	"disable-strict-tools": wire("disableStrictTools", ["anthropic"]),
-	"disabled-thinking": wire("disabledThinking", ["anthropic"], "scalar", ["omit", "disabled", "adaptive"]),
+	"between-tools-effort": wire("betweenToolsEffort", ["anthropic"], "scalar", ["low", "medium", "high"]),
+	"disabled-thinking": wire("disabledThinking", ["anthropic", "bedrock"], "scalar", [
+		"omit",
+		"disabled",
+		"adaptive",
+		"between-tools",
+	]),
 	"effort-beta": wire("effortBeta", ["anthropic"]),
 	"escape-builtin-tool-names": wire("escapeBuiltinToolNames", ["anthropic"]),
 	"fast-mode": wire("fastMode", ["anthropic"]),
 	"first-party-provider": wire("firstPartyProvider", ["anthropic"]),
 	"inject-claude-code-instruction": wire("injectClaudeCodeInstruction", ["anthropic"]),
+	"max-image-dimension": wire("maxImageDimension", ["anthropic"]),
+	"max-image-payload-bytes": wire("maxImagePayloadBytes", ["anthropic"]),
 	"official-endpoint": wire("officialEndpoint", ["anthropic", "openai-responses"]),
 	"replay-unsigned-thinking": wire("replayUnsignedThinking", ["anthropic"]),
 	"requires-thinking-enabled": wire("requiresThinkingEnabled", ["anthropic"]),
@@ -248,7 +260,7 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	"supports-per-message-effort": wire("supportsPerMessageEffort", ["anthropic"]),
 	"supports-server-compaction": wire("supportsServerCompaction", ["anthropic"]),
 	"supports-between-tools-thinking": wire("supportsBetweenToolsThinking", ["anthropic"]),
-	"supports-thinking-binding-controls": wire("supportsThinkingBindingControls", ["anthropic"]),
+	"supports-thinking-binding-controls": wire("supportsThinkingBindingControls", ["anthropic", "bedrock"]),
 	"supports-turn-scoped-system": wire("supportsTurnScopedSystem", ["anthropic"]),
 
 	// ── wire: bedrock-converse-stream ──
@@ -259,7 +271,7 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	// ── wire: devin-agent ──
 	"model-router": wire("modelRouter", ["devin"]),
 	"supports-parallel-tool-calls": wire("supportsParallelToolCalls", ["devin"]),
-	"trust-explicit-thinking-only": wire("trustExplicitThinkingOnly", ["devin"]),
+	"trust-explicit-thinking-only": wire("trustExplicitThinkingOnly", [...OAI, "devin"]),
 
 	// ── wire: google APIs ──
 	"antigravity-claude-tool-mode": wire("antigravityClaudeToolMode", ["google"]),
@@ -293,7 +305,7 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	"stream-idle-timeout-ms": wire("streamIdleTimeoutMs", [...OAI, "anthropic", "bedrock", "google"]),
 	"strip-image-input": wire("stripImageInput", [...OAI, "anthropic", "google"]),
 	"supports-forced-tool-choice": wire("supportsForcedToolChoice", [...OAI, "anthropic", "bedrock"]),
-	"supports-sampling-params": wire("supportsSamplingParams", [...OAI, "anthropic"]),
+	"supports-sampling-params": wire("supportsSamplingParams", [...OAI, "anthropic", "bedrock", "devin", "google"]),
 	"thinking-loop-guard": wire("thinkingLoopGuard", [...OAI, "anthropic", "google"], "scalar", [
 		"gemini",
 		"deepseek",
@@ -304,7 +316,7 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	"thinking-default-level": { key: "defaultLevel", set: "thinking", shape: "scalar", values: EFFORTS },
 	"thinking-effort-budgets": { key: "effortBudgets", set: "thinking", shape: "object" },
 	"thinking-effort-map": { key: "effortMap", set: "thinking", shape: "object" },
-	"thinking-efforts": { key: "efforts", set: "thinking", shape: "array", values: EFFORTS },
+	"thinking-efforts": { key: "efforts", set: "thinking", shape: "array", values: EFFORTS, emptyArray: true },
 	"thinking-mode": {
 		key: "mode",
 		set: "thinking",
@@ -390,12 +402,38 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	},
 	"web-search-model": { key: "webSearchModel", set: "catalog", shape: "scalar" },
 	"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" },
 	"image-model": { key: "imageModel", set: "catalog", shape: "scalar" },
+	"inline-image-byte-budget": { key: "inlineImageByteBudget", 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" },
 	"long-context-cost": { key: "longContext", set: "catalog", shape: "object" },
 	"prompt-cache": { key: "promptCache", set: "catalog", shape: "object" },
+	/**
+	 * Prompt-cache lookback in block positions: how far back from a cache
+	 * breakpoint the provider looks for an earlier request's cache entry.
+	 * Unassigned: no known lookback bound.
+	 */
+	"prompt-cache-lookback": { key: "promptCacheLookback", set: "catalog", shape: "scalar" },
 	"long-usage-limit-fallback": { key: "longUsageLimitFallback", set: "catalog", shape: "scalar" },
 	"max-context-window": { key: "maxContextWindow", set: "catalog", shape: "scalar" },
+	/**
+	 * Every host of the model returns its full plaintext trace wherever the
+	 * wire does not mark reasoning as a summary (`ThinkingContent.summary ===
+	 * false` vouches for nothing more), and its identity (class + family +
+	 * revision) pins one set of weights, so a turn's reasoning may replay
+	 * natively on another host serving the same model. Marked summaries never
+	 * carry; do not declare it where a host serves summaries unmarked.
+	 * Declared per family in `classes/*.kdl`; a host whose reasoning must not be
+	 * carried in or out sets `#false` in its `providers/*.kdl`. Read through
+	 * `compat/reasoning-carry.ts`.
+	 */
+	"portable-reasoning": { key: "portableReasoning", set: "catalog", shape: "scalar", values: [true, false] },
 	"pricing-status": {
 		key: "pricingStatus",
 		set: "catalog",

package/src/compat/cascade.ts

@@ -288,7 +288,12 @@ function collect(winners: WinnerTable, pick: (rule: CompiledRule) => Record<stri
 	return out;
 }
 
-const resolveCache = new LRUCache<string, ResolvedAxes>({ max: 512 });
+/**
+ * Sized above the bundled catalog (~5.6k targets) plus discovered rows so a
+ * catalog-wide buildModel pass (discovery, then merge rebuilding the same ids)
+ * hits instead of thrashing. Entries share rule values: a few hundred bytes each.
+ */
+const resolveCache = new LRUCache<string, ResolvedAxes>({ max: 16384 });
 
 function keyPart(value: string | undefined): string {
 	return value === undefined ? "-1:" : `${value.length}:${value}`;

package/src/compat/collapse.d.ts

@@ -102,6 +102,13 @@ export interface VariantCollapseTable {
  * Discovery uses this accessor to preserve injectable table seams.
  */
 export declare function reviewedCollapseTable(provider: string): VariantCollapseTable | undefined;
+/**
+ * Logical id of the reviewed `provider` family claiming `memberId` as a member
+ * or extra alias, or `undefined` when no reviewed family owns it. Cursor's rich
+ * discovery names lanes with it so they keep the id the legacy-slug collapse
+ * (and the bundled catalog) assigns.
+ */
+export declare function reviewedVariantFamilyId(provider: string, memberId: string): string | undefined;
 /**
  * The global automatic rule: derive an `X` + `X-thinking` family for every
  * pair where both ids are live in `specs` (trailing or infix token). Gates:

package/src/compat/collapse.ts

@@ -492,6 +492,17 @@ export function reviewedCollapseTable(provider: string): VariantCollapseTable |
 	return REVIEWED_COLLAPSE_TABLES[provider] ?? REVIEWED_COLLAPSE_TABLES[provider.toLowerCase()];
 }
 
+/**
+ * Logical id of the reviewed `provider` family claiming `memberId` as a member
+ * or extra alias, or `undefined` when no reviewed family owns it. Cursor's rich
+ * discovery names lanes with it so they keep the id the legacy-slug collapse
+ * (and the bundled catalog) assigns.
+ */
+export function reviewedVariantFamilyId(provider: string, memberId: string): string | undefined {
+	const table = reviewedCollapseTable(provider);
+	return table ? getAliasIndex(table).resolve(memberId.trim()) : undefined;
+}
+
 /**
  * The global automatic rule: derive an `X` + `X-thinking` family for every
  * pair where both ids are live in `specs` (trailing or infix token). Gates:

package/src/compat/image-tokenization.ts

@@ -0,0 +1,166 @@
+/**
+ * Billed input tokens per image, from the `image-tokenization` rules in the
+ * compat cascade: a model line's lineage rule (`rules/classes/*.kdl`) applies
+ * on every host, and readers without one fall back to the rule for the wire
+ * API carrying the request (`rules/providers/image-tokenization.kdl`).
+ */
+import { isRecord } from "@linxiraos/pi-utils/type-guards";
+import { classifyModel } from "../identity";
+import { resolveCascade } from "./cascade";
+import type { ModelIdentity } from "./types";
+
+/** OpenAI image `detail` levels; `undefined` means the provider default (`auto`). */
+export type ImageDetail = "auto" | "low" | "high" | "original";
+
+export interface ImageSize {
+	width: number;
+	height: number;
+}
+
+/** One OpenAI `detail` level's sizing: a pixel-dimension limit, then an optional patch budget. */
+export interface PatchSizing {
+	/** Longest side after the pixel-dimension fit. */
+	maxEdge: number;
+	/** Resizing patch budget; absent when the level keeps the image's size. */
+	patchBudget?: number;
+}
+
+/** OpenAI 32px patches × a per-model multiplier, sized per `detail` level. */
+export interface OpenAiPatchTokenization {
+	regime: "openai-patch";
+	multiplier: number;
+	low: PatchSizing;
+	high: PatchSizing;
+	original: PatchSizing;
+	/** The level `auto` (and an omitted `detail`) sizes like. */
+	auto: "high" | "original";
+}
+
+/** One model line's image billing rule: the vendor formula and its per-model numbers. */
+export type ImageTokenization =
+	| OpenAiPatchTokenization
+	/** Anthropic 28px patches, resized to fit a padded-edge limit and a visual-token budget. */
+	| { regime: "anthropic-patch"; maxEdge: number; maxTokens: number }
+	/** A fixed per-image budget regardless of pixels (Gemini 3 `media_resolution`). */
+	| { regime: "fixed"; tokens: number };
+
+/** A `class: "unknown"` identity for targets resolved by wire API alone. */
+const UNCLASSIFIED: Pick<ModelIdentity, "class"> = { class: "unknown" };
+
+function isImageTokenization(value: unknown): value is ImageTokenization {
+	return (
+		isRecord(value) &&
+		(value.regime === "openai-patch" || value.regime === "anthropic-patch" || value.regime === "fixed")
+	);
+}
+
+/** What reads the image: a built model, any `{ id }` with optional host and identity, or just a wire `{ api }`. */
+export interface ImageTokenizationTarget {
+	id?: string;
+	provider?: string;
+	api?: string;
+	identity?: Pick<ModelIdentity, "class" | "family" | "revision">;
+}
+
+/**
+ * The reader's image billing rule: its lineage rule, else its wire API's
+ * fallback; undefined when neither covers it (an unclassified model on an
+ * unregistered API).
+ */
+export function resolveImageTokenization(target: ImageTokenizationTarget): ImageTokenization | undefined {
+	const provider = target.provider ?? "";
+	const model = target.id ?? "";
+	const identity: Pick<ModelIdentity, "class" | "family" | "revision"> =
+		target.identity ?? (model ? classifyModel(provider, model, { lenient: true }) : UNCLASSIFIED);
+	const rule = resolveCascade({
+		provider,
+		api: target.api ?? "",
+		class: identity.class,
+		model,
+		reasoning: false,
+		...(identity.family !== undefined && { family: identity.family }),
+		...(identity.revision !== undefined && { revision: identity.revision }),
+	}).catalog.imageTokenization;
+	return isImageTokenization(rule) ? rule : undefined;
+}
+
+/** Scale `size` down (never up) so its longest side is at most `maxEdge`. */
+function fitLongEdge(size: ImageSize, maxEdge: number): ImageSize {
+	const longest = Math.max(size.width, size.height);
+	if (longest <= maxEdge) return size;
+	const scale = maxEdge / longest;
+	return {
+		width: Math.max(1, Math.round(size.width * scale)),
+		height: Math.max(1, Math.round(size.height * scale)),
+	};
+}
+
+const OPENAI_PATCH_PX = 32;
+
+/** <https://developers.openai.com/api/docs/guides/images-vision#patch-based-image-tokenization> */
+function openAiPatches(size: ImageSize, sizing: PatchSizing): number {
+	const { width, height } = fitLongEdge(size, sizing.maxEdge);
+	const patches = Math.ceil(width / OPENAI_PATCH_PX) * Math.ceil(height / OPENAI_PATCH_PX);
+	const budget = sizing.patchBudget;
+	if (budget === undefined || patches <= budget) return patches;
+
+	const shrink = Math.sqrt((OPENAI_PATCH_PX * OPENAI_PATCH_PX * budget) / (width * height));
+	const scaledW = (width * shrink) / OPENAI_PATCH_PX;
+	const scaledH = (height * shrink) / OPENAI_PATCH_PX;
+	const adjusted = shrink * Math.min(Math.floor(scaledW) / scaledW, Math.floor(scaledH) / scaledH);
+	const resizedW = Math.floor(width * adjusted);
+	const resizedH = Math.floor(height * adjusted);
+	if (resizedW <= 0 || resizedH <= 0) return budget;
+	return Math.min(budget, Math.ceil(resizedW / OPENAI_PATCH_PX) * Math.ceil(resizedH / OPENAI_PATCH_PX));
+}
+
+const ANTHROPIC_PATCH_PX = 28;
+
+/** Round half to even, like the API's resize (and Python's `round`). */
+function roundTiesToEven(value: number): number {
+	const floor = Math.floor(value);
+	if (value - floor !== 0.5) return Math.round(value);
+	return floor % 2 === 0 ? floor : floor + 1;
+}
+
+/**
+ * Anthropic visual tokens after the API's resize: the largest
+ * aspect-preserving size whose 28px-padded edges fit `maxEdge` and whose
+ * patch count fits `maxTokens`, found by bisecting the long edge. Port of the
+ * reference implementation:
+ * <https://platform.claude.com/docs/en/build-with-claude/vision-coordinates#resize-your-image-before-uploading>
+ */
+function anthropicTokens(size: ImageSize, maxEdge: number, maxTokens: number): number {
+	const long = Math.max(size.width, size.height);
+	const shortSide = Math.min(size.width, size.height);
+	const aspect = long / shortSide;
+	const patches = (l: number, s: number) => Math.ceil(l / ANTHROPIC_PATCH_PX) * Math.ceil(s / ANTHROPIC_PATCH_PX);
+	const fits = (l: number, s: number) =>
+		Math.ceil(l / ANTHROPIC_PATCH_PX) * ANTHROPIC_PATCH_PX <= maxEdge &&
+		Math.ceil(s / ANTHROPIC_PATCH_PX) * ANTHROPIC_PATCH_PX <= maxEdge &&
+		patches(l, s) <= maxTokens;
+	const short = (l: number) => Math.max(roundTiesToEven(l / aspect), 1);
+	if (fits(long, shortSide)) return patches(long, shortSide);
+	let lo = 1; // always fits
+	let hi = long; // never fits
+	while (lo + 1 < hi) {
+		const mid = Math.floor((lo + hi) / 2);
+		if (fits(mid, short(mid))) lo = mid;
+		else hi = mid;
+	}
+	return patches(lo, short(lo));
+}
+
+/** Billed input tokens for one image of `size` under `rule`; only `openai-patch` reads `detail`. */
+export function imageTokens(rule: ImageTokenization, size: ImageSize, detail?: ImageDetail): number {
+	switch (rule.regime) {
+		case "fixed":
+			return rule.tokens;
+		case "openai-patch": {
+			const level = detail === "low" || detail === "high" || detail === "original" ? detail : rule.auto;
+			return Math.ceil(openAiPatches(size, rule[level]) * rule.multiplier);
+		}
+		case "anthropic-patch":
+			return anthropicTokens(size, rule.maxEdge, rule.maxTokens);
+	}
+}

package/src/compat/judgment-questions.ts

@@ -0,0 +1,12 @@
+import type { Model } from "../types";
+import { resolveCatalogPolicy } from "./catalog-policy";
+
+/**
+ * Most questions one System One judgment request to this model may carry
+ * (`judgment-questions-max` axis), or `undefined` when the endpoint takes any
+ * batch size.
+ */
+export function resolveJudgmentQuestionsMax(model: Model): number | undefined {
+	const value = resolveCatalogPolicy(model).judgmentQuestionsMax;
+	return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : undefined;
+}

package/src/compat/prompt-cache-lookback.ts

@@ -0,0 +1,23 @@
+import { toModelSpec } from "../provider-models/bundled-references";
+import type { Model } from "../types";
+import { resolveCatalogAxes } from "./resolve";
+
+const lookbackCache = new Map<string, number | null>();
+const LOOKBACK_CACHE_MAX = 8192;
+
+/**
+ * Block positions the provider's prompt cache checks back from a breakpoint for
+ * an earlier request's entry (`prompt-cache-lookback` axis), or `undefined` when
+ * the model has no known lookback bound.
+ */
+export function resolvePromptCacheLookback(model: Model): number | undefined {
+	const key = `${model.provider} ${model.id} ${model.api}`;
+	let lookback = lookbackCache.get(key);
+	if (lookback === undefined) {
+		const value = resolveCatalogAxes(toModelSpec(model)).promptCacheLookback;
+		lookback = typeof value === "number" && Number.isInteger(value) && value > 0 ? value : null;
+		if (lookbackCache.size >= LOOKBACK_CACHE_MAX) lookbackCache.clear();
+		lookbackCache.set(key, lookback);
+	}
+	return lookback ?? undefined;
+}

package/src/compat/provider-ids.d.ts

@@ -1,2 +1,2 @@
 /** Every chat-model provider with a catalog entry (`default-model` in its provider rules). */
-export type KnownProvider = "abliteration" | "aiand" | "aimlapi" | "alibaba-coding-plan" | "alibaba-token-plan" | "amazon-bedrock" | "anthropic" | "apple" | "azure" | "baseten" | "bedrock-mantle" | "cerebras" | "charm-hyper" | "cline-pass" | "cloudflare-ai-gateway" | "commandcode" | "coreweave" | "cursor" | "deepinfra" | "deepseek" | "devin" | "factory-droid" | "firepass" | "fireworks" | "github-copilot" | "gitlab-duo" | "gitlab-duo-agent" | "gmi-cloud" | "google" | "google-antigravity" | "google-gemini-cli" | "google-vertex" | "groq" | "helmcode" | "huggingface" | "kilo" | "kimi-code" | "litellm" | "lm-studio" | "local" | "meta" | "minimax" | "minimax-code" | "minimax-code-cn" | "mistral" | "moonshot" | "muse-code" | "nanogpt" | "novita" | "nvidia" | "ollama" | "ollama-cloud" | "openai" | "openai-codex" | "opencode-go" | "opencode-zen" | "openrouter" | "qianfan" | "qwen-portal" | "sakana" | "siliconflow" | "siliconflow-cn" | "singularityapi-dev" | "singularityapi-tech" | "stepfun" | "synthetic" | "together" | "typesafe" | "umans" | "venice" | "vercel-ai-gateway" | "vllm" | "wafer-serverless" | "web" | "xai" | "xai-oauth" | "xiaomi" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-cn" | "xiaomi-token-plan-sgp" | "yolo-auto" | "zai" | "zenmux" | "zhipu-coding-plan";
+export type KnownProvider = "abliteration" | "aiand" | "aimlapi" | "alibaba-coding-plan" | "alibaba-token-plan" | "amazon-bedrock" | "anthropic" | "apple" | "azure" | "baseten" | "bedrock-mantle" | "cerebras" | "charm-hyper" | "cline-pass" | "cloudflare-ai-gateway" | "cloudflare-workers-ai" | "commandcode" | "coralbricks" | "coreweave" | "cursor" | "deepinfra" | "deepseek" | "devin" | "factory-droid" | "firepass" | "fireworks" | "github-copilot" | "gitlab-duo" | "gitlab-duo-agent" | "gmi-cloud" | "google" | "google-antigravity" | "google-gemini-cli" | "google-vertex" | "groq" | "helmcode" | "huggingface" | "kilo" | "kimi-code" | "litellm" | "lm-studio" | "local" | "meta" | "minimax" | "minimax-code" | "minimax-code-cn" | "mistral" | "moonshot" | "muse-code" | "nanogpt" | "novita" | "nvidia" | "ollama" | "ollama-cloud" | "openai" | "openai-codex" | "opencode-go" | "opencode-zen" | "openrouter" | "qianfan" | "qwen-portal" | "sakana" | "siliconflow" | "siliconflow-cn" | "singularityapi-dev" | "singularityapi-tech" | "snowflake" | "stepfun" | "synthetic" | "together" | "typesafe" | "umans" | "venice" | "vercel-ai-gateway" | "vllm" | "wafer-serverless" | "web" | "xai" | "xai-oauth" | "xiaomi" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-cn" | "xiaomi-token-plan-sgp" | "yolo-auto" | "zai" | "zenmux" | "zhipu-coding-plan";

package/src/compat/provider-ids.ts

@@ -17,7 +17,9 @@ export type KnownProvider =
 	| "charm-hyper"
 	| "cline-pass"
 	| "cloudflare-ai-gateway"
+	| "cloudflare-workers-ai"
 	| "commandcode"
+	| "coralbricks"
 	| "coreweave"
 	| "cursor"
 	| "deepinfra"
@@ -66,6 +68,7 @@ export type KnownProvider =
 	| "siliconflow-cn"
 	| "singularityapi-dev"
 	| "singularityapi-tech"
+	| "snowflake"
 	| "stepfun"
 	| "synthetic"
 	| "together"

package/src/compat/reasoning-carry.ts

@@ -0,0 +1,64 @@
+/**
+ * Reasoning carry: whether reasoning a model produced on one host may replay
+ * natively on another host serving the same model.
+ *
+ * The model-side half is declared with the `portable-reasoning` catalog axis
+ * per family in `rules/classes/*.kdl`: the family's stored reasoning is its own
+ * full plaintext trace, and its identity pins one set of weights. A host whose
+ * reasoning must neither be carried in nor out overrides it to `#false` in its
+ * `rules/providers/*.kdl`. Whether the target host has a native slot for
+ * earlier reasoning is derived by the request encoders in `@linxiraos/pi-ai`,
+ * not declared here.
+ *
+ * Resolved through the cascade on demand (like delegation bias) because
+ * bundled rows are frozen by the generator; results are memoized per
+ * deployment.
+ */
+import { resolveCascade } from "./cascade";
+import { classifyModel } from "./taxonomy";
+import type { ModelIdentity } from "./types";
+
+/** `null` records a deployment that does not carry reasoning. */
+const portableIdentityMemo = new Map<string, ModelIdentity | null>();
+
+/**
+ * The identity a deployment's reasoning is carried under, or `undefined` when
+ * the deployment's model family is not declared portable there. Class-only
+ * identities never qualify: they name a lineage, not a set of weights.
+ */
+export function portableReasoningIdentity(provider: string, api: string, modelId: string): ModelIdentity | undefined {
+	const key = `${provider}\0${api}\0${modelId}`;
+	const memo = portableIdentityMemo.get(key);
+	if (memo !== undefined) return memo ?? undefined;
+	const identity = classifyModel(provider, modelId, { lenient: true });
+	let portable: ModelIdentity | null = null;
+	if (identity.family !== undefined || identity.revision !== undefined) {
+		const declared = resolveCascade({
+			provider,
+			api,
+			class: identity.class,
+			model: modelId,
+			reasoning: true,
+			...(identity.family !== undefined && { family: identity.family }),
+			...(identity.revision !== undefined && { revision: identity.revision }),
+		}).catalog.portableReasoning;
+		if (declared === true) portable = identity;
+	}
+	portableIdentityMemo.set(key, portable);
+	return portable ?? undefined;
+}
+
+/**
+ * Whether reasoning recorded on `source` may replay natively on `target`:
+ * both deployments declare the family portable and classify to the same
+ * class, family, and revision.
+ */
+export function carriesReasoning(
+	source: { provider: string; api: string; model: string },
+	target: { provider: string; api: string; id: string },
+): boolean {
+	const to = portableReasoningIdentity(target.provider, target.api, target.id);
+	if (!to) return false;
+	const from = portableReasoningIdentity(source.provider, source.api, source.model);
+	return from !== undefined && from.class === to.class && from.family === to.family && from.revision === to.revision;
+}

package/src/compat/request-size.ts

@@ -0,0 +1,25 @@
+import { toModelSpec } from "../provider-models/bundled-references";
+import type { Model } from "../types";
+import { resolveCatalogAxes } from "./resolve";
+
+const imageBudgetCache = new Map<string, number | null>();
+const IMAGE_BUDGET_CACHE_MAX = 8192;
+
+/**
+ * Maximum encoded inline-image bytes retained per request for a deployment with a documented body-size limit.
+ * The axis is a host contract: a rerouted `baseUrl` (proxy, gateway) imposes its own limit, so the budget
+ * applies only while the model targets its official endpoint.
+ */
+export function resolveInlineImageByteBudget(model: Model): number | undefined {
+	const compat = model.compat;
+	if (!compat || !("officialEndpoint" in compat) || !compat.officialEndpoint) return undefined;
+	const key = `${model.provider} ${model.id} ${model.api}`;
+	let budget = imageBudgetCache.get(key);
+	if (budget === undefined) {
+		const value = resolveCatalogAxes(toModelSpec(model)).inlineImageByteBudget;
+		budget = typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
+		if (imageBudgetCache.size >= IMAGE_BUDGET_CACHE_MAX) imageBudgetCache.clear();
+		imageBudgetCache.set(key, budget);
+	}
+	return budget ?? undefined;
+}