@linxiraos/pi-catalog 1.1.26 → 1.2.0

package/src/compat/resolve.ts

@@ -107,11 +107,12 @@ class IdentityFacts {
 		return this.is("kimi") && this.family("k2.7-code", "k3");
 	}
 
-	/** Adaptive-thinking Claude generation floor (Opus ≥ min; Sonnet/Fable/Mythos ≥ 5). */
+	/** Adaptive-thinking Claude generation floor (Opus ≥ min; Sonnet/Fable/Mythos ≥ 5; Haiku ≥ 5.5). */
 	anthropicAdaptiveGenAtLeast(opusMin: string): boolean {
 		if (!this.is("anthropic")) return false;
 		if (this.family("opus")) return this.revGte(opusMin);
 		if (this.family("sonnet", "fable", "mythos")) return this.revGte("5");
+		if (this.family("haiku")) return this.revGte("5.5");
 		return false;
 	}
 }
@@ -179,7 +180,7 @@ function overlayEffortMapAxis(
 }
 
 function effortList(value: unknown): readonly Effort[] | undefined {
-	if (!Array.isArray(value) || value.length === 0) return undefined;
+	if (!Array.isArray(value)) return undefined;
 	const out: Effort[] = [];
 	for (const entry of value) {
 		const effort = THINKING_EFFORTS.find(candidate => candidate === entry);
@@ -502,10 +503,11 @@ function detectOpenAICompat(
 		supportsDeveloperRole: isOpenAIHost || isAzureHost,
 		supportsMultipleSystemMessages: supportsMultipleSystemMessagesDefault,
 		supportsReasoningEffort: !isGrok && !d.isXiaomiMimo && (!(d.isZai || d.isZhipu) || supportsZaiReasoningEffort),
+		trustExplicitThinkingOnly: undefined,
 		// API-conditional: this completions-only Copilot exclusion cannot be a
 		// provider rule without changing Copilot Responses rows.
 		supportsReasoningParams: provider !== "github-copilot",
-		supportsSamplingParams: !(facts.is("openai") && (facts.family("o-series") || facts.revGte("5"))),
+		supportsSamplingParams: true,
 		supportsPenaltyAndStopParams: !(isGrok && reasoningCapable),
 		reasoningEffortMap: {},
 		supportsUsageInStreaming: !isCerebrasHost,
@@ -598,26 +600,12 @@ function detectOpenAICompat(
 	};
 }
 
-const DSML_HEALING_PROVIDERS: Record<string, true> = {
-	ollama: true,
-	"ollama-cloud": true,
-	nvidia: true,
-	deepseek: true,
-	fireworks: true,
-	nanogpt: true,
-	"opencode-go": true,
-	openrouter: true,
-	// Transparent gateways / user-configured hosts forward the upstream model's
-	// native chat template unchanged, so a deepseek-classed model behind them
-	// still emits DSML tool-call envelopes and needs the DSML healer.
-	litellm: true,
-	nous: true,
-};
-
 /**
  * Default leaked-markup healer. Kimi/DeepSeek dedicated grammars are keyed on
  * identity class; official OpenAI heals nothing; everything else defaults to
- * the generic `thinking` healer.
+ * the generic `thinking` healer. DSML is DeepSeek's own tool-call grammar, so
+ * every host serving a DeepSeek model gets it — gateways, local backends, and
+ * custom providers alike.
  */
 function detectStreamMarkupHealing(
 	provider: string,
@@ -628,7 +616,7 @@ function detectStreamMarkupHealing(
 	// Kimi ids keep the generic healer, matching the census.
 	const isKimiK2 = facts.is("kimi") && facts.identity.family?.startsWith("k2") === true;
 	if (provider === "kimi-code" || provider === "moonshot" || isKimiK2) return "kimi";
-	if (facts.is("deepseek") && DSML_HEALING_PROVIDERS[provider] === true) return "dsml";
+	if (facts.is("deepseek")) return "dsml";
 	if (isOfficialOpenAIEndpoint(provider, baseUrl)) return undefined;
 	return "thinking";
 }
@@ -745,12 +733,20 @@ function resolveOpenAIResponsesPolicy(
 			hostMatchesUrl(baseUrl, "openrouter") ||
 			hostMatchesUrl(baseUrl, "deepseekFamily"),
 		supportsReasoningEffort: !isXaiHost,
+		trustExplicitThinkingOnly: undefined,
 		supportsLongPromptCacheRetention: isOpenAIUrl,
 		supportsPromptCacheBreakpoints,
 		promptCacheBreakpointTtl: supportsPromptCacheBreakpoints ? "30m" : undefined,
 		strictResponsesPairing: isAzure || provider === "github-copilot",
-		supportsImageDetailOriginal: !isXaiHost && !modelMatchesHost(hostModel, "githubCopilot"),
+		// Azure's provider id alone only implies support while its endpoint is
+		// resolved at runtime; an explicit non-Azure baseUrl is a proxy, like Codex.
+		supportsImageDetailOriginal:
+			isOpenAIUrl ||
+			hostMatchesUrl(baseUrl, "azureOpenAI") ||
+			(isAzure && !baseUrl) ||
+			hostMatchesUrl(baseUrl, "openaiCodex"),
 		supportsReasoningSummary: !isXaiHost,
+		statefulResponses: undefined,
 		supportsAllTurnsReasoningContext: false,
 		supportsConfigurationUpdate: false,
 		supportsSteering: false,
@@ -759,7 +755,7 @@ function resolveOpenAIResponsesPolicy(
 		thinkingLoopGuard: undefined,
 		reasoningEffortMap: {},
 		supportsReasoningParams: true,
-		supportsSamplingParams: !(facts.is("openai") && (facts.family("o-series") || facts.revGte("5"))),
+		supportsSamplingParams: true,
 		supportsPenaltyAndStopParams: !isXaiHost,
 		thinkingFormat,
 		reasoningDisableMode: resolveReasoningDisableMode(thinkingFormat),
@@ -798,6 +794,8 @@ function resolveOpenAIResponsesPolicy(
 			PROXY_OPENAI_COMPAT_PROVIDERS[backendProvider] !== true &&
 			(LOCAL_OPENAI_COMPAT_PROVIDERS[backendProvider] === true || hasLocalLoopbackBaseUrl(baseUrl)),
 		supportsObfuscationOptOut: isOpenAIUrl || provider === "openai",
+		storeResponses: false,
+		connectionBoundNativeHistory: false,
 		officialEndpoint: isOfficialOpenAIEndpoint(provider, baseUrl),
 		harmonyLeakMitigation: false,
 		rejectRootObjectUnion: false,
@@ -859,6 +857,8 @@ function pickResponsesOnly(compat: ResolvedOpenAIResponsesCompat): ResponsesOnly
 		strictResponsesPairing: compat.strictResponsesPairing,
 		supportsImageDetailOriginal: compat.supportsImageDetailOriginal,
 		supportsObfuscationOptOut: compat.supportsObfuscationOptOut,
+		storeResponses: compat.storeResponses,
+		connectionBoundNativeHistory: compat.connectionBoundNativeHistory,
 		supportsAllTurnsReasoningContext: compat.supportsAllTurnsReasoningContext,
 		supportsConfigurationUpdate: compat.supportsConfigurationUpdate,
 		supportsSteering: compat.supportsSteering,
@@ -867,6 +867,7 @@ function pickResponsesOnly(compat: ResolvedOpenAIResponsesCompat): ResponsesOnly
 		cacheControlFormat: compat.cacheControlFormat,
 		requiresReasoningOffJuiceInstruction: compat.requiresReasoningOffJuiceInstruction,
 		supportsReasoningSummary: compat.supportsReasoningSummary,
+		statefulResponses: compat.statefulResponses,
 		isVercelGatewayHost: compat.isVercelGatewayHost,
 	} satisfies ResponsesOnlyCompat;
 }
@@ -906,7 +907,7 @@ function resolveAnthropicPolicy(
 		supportsThinkingBindingControls: false,
 		supportsBetweenToolsThinking: false,
 		supportsForcedToolChoice: !requiresThinkingEnabled && !facts.family("fable", "mythos"),
-		supportsSamplingParams: !facts.anthropicAdaptiveGenAtLeast("4.7"),
+		supportsSamplingParams: true,
 		requiresToolResultId: false,
 		requiresThinkingEnabled,
 		replayUnsignedThinking:
@@ -914,6 +915,11 @@ function resolveAnthropicPolicy(
 		escapeBuiltinToolNames: false,
 		injectClaudeCodeInstruction: true,
 		stripImageInput: false,
+		// Unset means "canonical Anthropic image contract"; the request builder
+		// owns those numbers. The keys must exist for a KDL rule or a
+		// user-authored `compat` block to override them.
+		maxImageDimension: undefined,
+		maxImagePayloadBytes: undefined,
 		thinkingLoopGuard: undefined,
 		// Present as keys so models.yml `compat` can set them; unset unless a rule assigns them.
 		stripThinkingHistory: undefined,
@@ -936,6 +942,9 @@ function resolveBedrockPolicy(spec: ModelSpec<"bedrock-converse-stream">, axes:
 		promptCacheMinimumTokens: 0,
 		promptCacheMaximumCheckpoints: 0,
 		supportsForcedToolChoice: true,
+		// Opt-out: every prefix-bound Claude line on Converse takes the controls,
+		// including custom Bedrock-wire providers; KDL or models.yml sets `false`.
+		supportsThinkingBindingControls: true,
 	};
 	// Reasoning capability is a mechanism gate; adaptive-lineage duration is rule-owned.
 	compat.streamIdleTimeoutMs = compatReasoning(spec, axes) ? BEDROCK_REASONING_STREAM_IDLE_TIMEOUT_MS : undefined;
@@ -1013,7 +1022,8 @@ function defaultThinkingMode<TApi extends Api>(spec: ModelSpec<TApi>, facts: Ide
 				return "anthropic-budget-effort";
 			}
 			if (facts.is("anthropic")) {
-				if (facts.revGte("4.6") && !facts.family("haiku")) return "anthropic-adaptive";
+				// Haiku stays on budget thinking until 5.5, its first adaptive generation.
+				if (facts.revGte(facts.family("haiku") ? "5.5" : "4.6")) return "anthropic-adaptive";
 				if (facts.family("opus") && facts.revGte("4.5")) return "anthropic-budget-effort";
 			}
 			return "budget";
@@ -1162,6 +1172,7 @@ function resolveThinkingPolicy<TApi extends Api>(
 	if (compat !== undefined && "trustExplicitThinkingOnly" in compat && compat.trustExplicitThinkingOnly === true) {
 		return undefined;
 	}
+	if (rule.efforts?.length === 0) return undefined;
 	const config: ThinkingConfig = {
 		mode: rule.mode ?? defaultThinkingMode(spec, facts),
 		efforts: rule.efforts ?? fallbackEfforts(spec, compat),

package/src/compat/rules/README.md

@@ -209,14 +209,20 @@ The directive vocabulary is closed and lives in **`src/compat/axes.ts`** — one
 The three value shapes are:
 
 - **Scalar**: exactly one KDL boolean, integer, float, or string argument and no children. `#null` is rejected.
-- **Array**: one or more scalar arguments and no children; it resolves to a JSON array. Axes marked `emptyArray` in `axes.ts` also accept a bare directive, which assigns an explicit empty list (`region-upstreams-eu` with no arguments: the region never serves the model).
+- **Array**: one or more scalar arguments and no children; it resolves to a JSON array. Axes marked `emptyArray` in `axes.ts` also accept a bare directive, which assigns an explicit empty list (`region-upstreams-eu` with no arguments: the region never serves the model). Bare `thinking-efforts` keeps a reasoning-capable deployment without selectable effort tiers off the effort dial.
 - **Object**: no arguments and a child block, including an empty block. Child names are kebab-case: an axis-directive spelling compiles to its resolved axis key (`template-reasoning-effort` → `qwenTemplateReasoningEffort`), anything else converts mechanically (`input-threshold` → `inputThreshold`); camelCase names are a compile error. `extra-body` payloads (top-level or nested) are the exception — their child names are literal wire JSON keys copied verbatim (`enable_thinking`). Each child is either one scalar or another object; arrays are not representable inside an object payload.
 
 A rule cannot assign the same resolved axis twice in one block.
-One object axis carries a computed form: `long-context-cost` accepts either the absolute rates (`input-threshold` + `input`/`output`/`cache-read`/`cache-write`) or `input-threshold` + `multiplier` (with optional `input-threshold-inclusive`), which derives the tier from the row's live base price at build time so the rule tracks upstream list-price updates (xAI's SuperGrok 200K tier). Rows without a token price carry no tier.
+One object axis carries a computed form: `long-context-cost` accepts either the absolute rates (`input-threshold` + `input`/`output`/`cache-read`/`cache-write`) or `input-threshold` + `multiplier` (with optional `input-threshold-inclusive`), which derives the tier from the row's base price at build time, after `cost-patch` and `cost-fallback`, so the rule tracks upstream list-price updates (xAI's SuperGrok 200K tier). Rows without a token price carry no tier. An empty `long-context-cost {}` adds no tier; a more specific rule uses it to opt a host out of a broader rule's band (GitHub Copilot's Haiku 5.5 rows, whose long tier is the `-1m` sibling).
 
 `context-window-authoritative #true` preserves a host's supplied context window through runtime model selection instead of applying inferred expansion or reference-price-tier caps. Explicit user context overrides still apply afterward. It applies to rows materialized through `buildModel` (discovery and regenerated bundles). See [`providers/factory-droid.kdl`](providers/factory-droid.kdl).
 
+`inline-image-byte-budget` caps retained base64 image characters for a deployment's request body. It leaves room for tool schemas and text beneath the provider's body-size limit; the coding agent reads it through `resolveInlineImageByteBudget` before sending live history. The budget applies only while `compat.officialEndpoint` holds: a custom `baseUrl` imposes its own body limit.
+
+`judgment-questions-max` is the most questions one System One judgment request may carry (razorback16/openjev: 256; Cloudflare Clef on Workers AI and through OpenRouter Decisions: 64; unidentified `*openjev*` deployments: 16). The coding agent reads it through `resolveJudgmentQuestionsMax` and `NativeJudge` splits larger requests into parallel chunks; unassigned means the endpoint takes any batch size. [`providers/judgment-questions.kdl`](providers/judgment-questions.kdl) lists the servers verified uncapped or not isolatable.
+
+`prompt-cache-lookback` is how many block positions back from a cache breakpoint the model's prompt cache looks for an earlier request's entry (Claude: 20, counting the breakpoint; a run of consecutive `tool_use` or `tool_result` blocks is one position). The coding agent reads it through `resolvePromptCacheLookback` and keeps warm-cache tool-result pruning inside the window; unassigned means no known bound.
+
 The routed-subscription registry axes (`upstream-rotation`, `region-upstreams-global|us|eu`, `region-limits-eu`, `credit-rates`, `list-price-from`, `routing-family`, `policy-aliases`, `entitlement`, `default-reasoning-off`) describe a gateway whose proxy fans one model out to several upstreams. They are read through `src/compat/factory-droid.ts` by Factory Droid discovery and its request provider, not materialized by `buildModel`. A provider-wide `region-upstreams-*` rule is the upstream serving table and a model rule replaces it for that region. `list-price-from "<provider>" ["<id>"]` shows a bundled row's list price beside the subscription's own billing; unlike seed values it is resolved at runtime and degrades to the seed's zero cost when the row is gone. See [`providers/factory-droid.kdl`](providers/factory-droid.kdl), whose wire and billing pool per model are `api-routes` and `quota-tiers` rules in `runtime/behavior.kdl`.
 
 ### Time-based pricing
@@ -468,11 +474,15 @@ provider "muse-code" {
 
 Only `discovery` enrolls a provider in `generate-models.ts`; providers without it are never fetched at generation time (see the `charm-hyper` entry for why a live gateway deliberately omits it).
 
+`automatic-default #false` keeps a provider available for explicit selection but excludes it from startup fallback and automatic model presets. The default is `#true`; `apple` opts out because its on-device context cannot accommodate the standard coding-agent prompt in many projects.
+
+`kind-apis { <kind> "<api>" }` maps each non-chat kind (`image`, `tts`, `stt`, `embedding`, `rerank`, `video`) to the API discovery assigns rows of that kind. A runner API must sit under the kind it serves (`RUNNER_API_KINDS` in `src/types.ts`); chat APIs, which serve hosted image generation, and multi-kind `local-inference` may back any kind.
+
 ### Seed rows
 
 A `seed` _defines_ bundled rows for providers whose catalog cannot be discovered at generation time — credential-scoped rosters, unauthenticated regens, or models ahead of upstream catalogs. Every other stratum patches rows; this one authors them. Runtime model managers hand the rows to `staticModels` through `seedModels(provider)`; the generator bundles them per the seed's `bundle` policy. Values are literal — a seed never derives from another provider's row, and pricing is never borrowed.
 
-`seed` properties: `api` and `base-url` are per-row defaults (a `model` may override either with the same property names); `bundle` defaults to `always`; `precedence="seed"` is optional. `model` takes the wire id positionally, requires `name=`, and its body MUST declare `reasoning`, `input` (`"text"` and/or `"image"`), `cost` (all four per-million rates), and `limits` (`context=` / `max-tokens=`, an omitted limit is `null`); `supports-tools #true` is optional. Any other directive is an axis from the cascade vocabulary: thinking axes become the row's explicit `thinking` (then `thinking-mode` and `thinking-efforts` are both required), wire axes become its explicit `compat` and must apply to the row's API, and catalog axes are rejected because they stay rule-owned in the cascade block. Explicit `thinking`/`compat` on a seed row win over the cascade exactly as they do for any authored spec.
+`seed` properties: `api` and `base-url` are per-row defaults (a `model` may override either with the same property names); `bundle` defaults to `always`; `precedence="seed"` is optional. `model` takes the row id positionally, requires `name=`, and its body MUST declare `reasoning`, `input` (`"text"` and/or `"image"`), `cost` (all four per-million rates), and `limits` (`context=` / `max-tokens=`, an omitted limit is `null`); `supports-tools #true` is optional, and `request-model-id "<wire id>"` sets the row's `requestModelId` when the upstream id differs from the row id (an OpenAI Decisions judge row beside the same-id chat model). Any other directive is an axis from the cascade vocabulary: thinking axes become the row's explicit `thinking` (then `thinking-mode` and `thinking-efforts` are both required), wire axes become its explicit `compat` and must apply to the row's API, and catalog axes are rejected because they stay rule-owned in the cascade block. Explicit `thinking`/`compat` on a seed row win over the cascade exactly as they do for any authored spec.
 
 `bundle` decides when the generator includes the rows:
 

package/src/compat/rules/auth/_order.kdl

@@ -8,6 +8,6 @@ login-order "openai-codex" "anthropic" "zai" "zai-coding-plan" "kimi-code" "open
 	"xiaomi-token-plan-ams" "xiaomi-token-plan-cn" "firepass" "cline-pass" "factory-droid" "commandcode" "charm-hyper" "deepseek" "stepfun" "muse-code" "meta" "moonshot" \
 	"cerebras" "baseten" "helmcode" "fireworks" "together" "nvidia" "novita" "deepinfra" "huggingface" "perplexity" \
 	"qianfan" "venice" "siliconflow" "siliconflow-cn" "synthetic" "nanogpt" "wafer-serverless" "coreweave" \
-	"vercel-ai-gateway" "cloudflare-ai-gateway" "litellm" "kilo" "zenmux" "opencode-zen" "opencode-go" \
+	"vercel-ai-gateway" "cloudflare-ai-gateway" "cloudflare-workers-ai" "snowflake" "litellm" "kilo" "zenmux" "opencode-zen" "opencode-go" \
 	"yolo-auto" "tavily" "kagi" "exa" "parallel" "typesafe" "ollama" "ollama-cloud" "lm-studio" "llama.cpp" "vllm" \
-	"gmi-cloud" "stencil" "singularityapi-dev" "singularityapi-tech"
+	"gmi-cloud" "stencil" "singularityapi-dev" "singularityapi-tech" "coralbricks"

package/src/compat/rules/auth/cloudflare-workers-ai.kdl

@@ -0,0 +1,9 @@
+// Cloudflare Workers AI runs the Clef decision models under
+// `/client/v4/accounts/{account_id}/ai/run`. Login stores the API token with
+// the account id (the shared Cloudflare credential); an env-supplied token
+// takes its account from `CLOUDFLARE_ACCOUNT_ID`.
+auth "cloudflare-workers-ai" {
+	name "Cloudflare Workers AI"
+	env "CLOUDFLARE_API_TOKEN" "CLOUDFLARE_AUTH_TOKEN"
+	login "custom" hook="cloudflare-workers-ai"
+}

package/src/compat/rules/auth/coralbricks.kdl

@@ -0,0 +1,13 @@
+// `/v1/models` is key-protected — it answers `401 missing_api_key` without a
+// bearer key and `401 invalid_api_key` to a rejected one (verified
+// 2026-10-02) — so login validates the pasted key there. The probe bills
+// nothing, unlike a chat-completions ping against a prepaid balance.
+auth "coralbricks" {
+	name "CoralBricks"
+	login "api-key" {
+		auth-url "https://www.coralbricks.ai/api-keys"
+		instructions "Create or copy your API key from the CoralBricks dashboard (keys look like cb_...)"
+		prompt "Paste your CoralBricks API key" placeholder="cb_..."
+		validate "models-endpoint" label="CoralBricks" url="https://inference.coralbricks.ai/v1/models"
+	}
+}

package/src/compat/rules/auth/minimax-code-cn.kdl

@@ -4,6 +4,6 @@ auth "minimax-code-cn" {
 		auth-url "https://platform.minimaxi.com/subscribe/token-plan"
 		instructions "Subscribe to Token Plan and copy your API key"
 		prompt "Paste your MiniMax Token Plan API key" placeholder="sk-..."
-		validate "chat-completions" base-url="https://api.minimaxi.com/v1" model="MiniMax-M3"
+		validate "anthropic-messages" base-url="https://api.minimaxi.com/anthropic" model="MiniMax-M3"
 	}
 }

package/src/compat/rules/auth/minimax-code.kdl

@@ -4,6 +4,6 @@ auth "minimax-code" {
 		auth-url "https://platform.minimax.io/subscribe/token-plan"
 		instructions "Subscribe to Token Plan and copy your API key"
 		prompt "Paste your MiniMax Token Plan API key" placeholder="sk-..."
-		validate "chat-completions" label="MiniMax Token Plan" base-url="https://api.minimax.io/v1" model="MiniMax-M3"
+		validate "anthropic-messages" label="MiniMax Token Plan" base-url="https://api.minimax.io/anthropic" model="MiniMax-M3"
 	}
 }

package/src/compat/rules/auth/openai-codex.kdl

@@ -9,7 +9,7 @@ auth "openai-codex" {
 		authorize-params {
 			id_token_add_organizations "true"
 			codex_cli_simplified_flow "true"
-			originator "omp"
+			originator "zeta"
 		}
 		instructions "A browser window should open. Complete login to finish."
 		// OpenAI only allowlists this exact URI; a busy port must fail rather than fall back.

package/src/compat/rules/auth/snowflake.kdl

@@ -0,0 +1,11 @@
+// Snowflake Cortex REST API. Login runs Snowflake OAuth for local applications
+// (built-in SNOWFLAKE$LOCAL_APPLICATION client, PKCE, loopback); the account
+// host is prompted first, so the flow is a custom hook.
+auth "snowflake" {
+	name "Snowflake Cortex"
+	login "custom" hook="snowflake"
+	refresh hook="snowflake"
+	api-key-format "structured"
+	callback-port 54551
+	paste-code #true
+}

package/src/compat/rules/auth/stencil.kdl

@@ -1,5 +1,5 @@
 // stencil.so account. Not a model provider: the credential authorizes
-// omp-hosted Stencil services such as `omp stream` (live.omp.sh).
+// Zeta-hosted Stencil services such as `zetacode stream` (live.omp.sh).
 //
 // Two hosts: the Stencil API at api.stencil.so (`{base}`, STENCIL_BASE_URL)
 // and the OIDC issuer at auth.stencil.so (`{auth}`, STENCIL_AUTH_URL) which

package/src/compat/rules/classes/anthropic.kdl

@@ -1,5 +1,76 @@
 // Model-lineage compat for "anthropic"; regenerated from the frozen census using class taxonomy selectors.
 
+// Images bill ⌈w/28⌉·⌈h/28⌉ visual tokens on every host. Claude 4.7+ and
+// Fable/Mythos read up to 2576px and 4,784 tokens; older lines fit 1568px and
+// cap at 1,568 tokens, downscaling past it.
+// https://platform.claude.com/docs/en/build-with-claude/vision#evaluate-image-size
+// The class default is the high-res tier, so ids without a revision
+// (`claude-opus-latest`, `~anthropic/claude-sonnet-latest`) and future lines
+// are never undercounted; only Opus/Sonnet/Haiku revisions known to predate
+// 4.7 take the standard tier. Separator-collapsed revisions parse as two
+// digits (`claude-opus-45` is Opus 4.5 → 45), so 10–46 is standard too.
+// Claude's prompt cache finds an earlier request's entry only within 20 block
+// positions back from a breakpoint, counting the breakpoint; a run of
+// consecutive tool_use or tool_result blocks is one position. Warm-cache
+// tool-result pruning keeps its rewrites inside this window.
+// https://platform.claude.com/docs/en/build-with-claude/prompt-caching
+class "anthropic" {
+	prompt-cache-lookback 20
+	image-tokenization {
+		regime "anthropic-patch"
+		max-edge 2576
+		max-tokens 4784
+	}
+	family "opus" {
+		revision "<4.7" {
+			image-tokenization {
+				regime "anthropic-patch"
+				max-edge 1568
+				max-tokens 1568
+			}
+		}
+		revision ">=10 <47" {
+			image-tokenization {
+				regime "anthropic-patch"
+				max-edge 1568
+				max-tokens 1568
+			}
+		}
+	}
+	family "sonnet" {
+		revision "<4.7" {
+			image-tokenization {
+				regime "anthropic-patch"
+				max-edge 1568
+				max-tokens 1568
+			}
+		}
+		revision ">=10 <47" {
+			image-tokenization {
+				regime "anthropic-patch"
+				max-edge 1568
+				max-tokens 1568
+			}
+		}
+	}
+	family "haiku" {
+		revision "<4.7" {
+			image-tokenization {
+				regime "anthropic-patch"
+				max-edge 1568
+				max-tokens 1568
+			}
+		}
+		revision ">=10 <47" {
+			image-tokenization {
+				regime "anthropic-patch"
+				max-edge 1568
+				max-tokens 1568
+			}
+		}
+	}
+}
+
 class "anthropic" {
 	family "fable" {
 		revision ">=5.1" {
@@ -7,6 +78,46 @@ class "anthropic" {
 			thinking-prefix-binding #true
 		}
 	}
+	// Adaptive Claude (Opus 4.7+, Sonnet/Fable/Mythos 5+, Haiku 5.5+) rejects explicit
+	// sampling params (`temperature`, `top_p`, `top_k`) with a 400 on every
+	// serving host. The `<10` bound keeps whole-number revisions such as
+	// `claude-opus-45` (Opus 4.5) out of the range.
+	family "opus" {
+		revision ">=4.7 <10" {
+			supports-sampling-params #false
+		}
+	}
+	family "sonnet" {
+		revision ">=5 <10" {
+			supports-sampling-params #false
+		}
+	}
+	family "fable" {
+		revision ">=5 <10" {
+			supports-sampling-params #false
+		}
+	}
+	family "mythos" {
+		revision ">=5 <10" {
+			supports-sampling-params #false
+		}
+	}
+	family "haiku" {
+		revision ">=5.5 <10" {
+			supports-sampling-params #false
+		}
+		// Haiku 5.5 bills every rate 5x for prompts over 100K. Derived from each
+		// host's list price so non-Anthropic hosts get the band too; the Claude
+		// API and Cursor pin absolute rates, and GitHub Copilot opts out because
+		// its long tier is the `-1m` sibling row.
+		// https://platform.claude.com/docs/en/models/haiku-5-5/overview#pricing
+		revision ">=5.5 <6" {
+			long-context-cost {
+				input-threshold 100000
+				multiplier 5.0
+			}
+		}
+	}
 	// On-demand compaction (compact-2026-09-04) works on the Claude API, Vertex,
 	// and Amazon Bedrock's `/anthropic` routes, not Bedrock Converse.
 	// Foundry / Claude Platform on AWS are first-party Anthropic routes whose
@@ -32,6 +143,11 @@ class "anthropic" {
 				supports-server-compaction #true
 			}
 		}
+		family "haiku" {
+			revision ">=5.5 <6" {
+				supports-server-compaction #true
+			}
+		}
 		models "claude-mythos-preview" {
 			supports-server-compaction #true
 		}
@@ -84,6 +200,15 @@ class "anthropic" {
 			thinking-prefix-binding #true
 		}
 	}
+	// Haiku 5.5 binds signed thinking to the exact preceding conversation like
+	// Sonnet 5.5. It accepts a forced `tool_choice` (the response just skips
+	// thinking), so it keeps forced tool selection.
+	// https://platform.claude.com/docs/en/models/haiku-5-5/migration-guide
+	family "haiku" {
+		revision ">=5.5 <6" {
+			thinking-prefix-binding #true
+		}
+	}
 	on "anthropic" "cloudflare-ai-gateway" "google-vertex" {
 		family "fable" {
 			revision ">=5" {
@@ -111,6 +236,13 @@ class "anthropic" {
 				supports-turn-scoped-system #true
 			}
 		}
+		family "haiku" {
+			revision ">=5.5 <6" {
+				supports-mid-conversation-system #true
+				supports-mid-conversation-tool-changes #true
+				supports-turn-scoped-system #true
+			}
+		}
 		family "opus" {
 			revision ">=4.8" {
 				supports-mid-conversation-system #true
@@ -141,17 +273,30 @@ class "anthropic" {
 				supports-per-message-effort #true
 			}
 		}
+		// Haiku 5.5 mirrors Sonnet 5.5; Vertex stays off until verified.
+		family "haiku" {
+			revision ">=5.5 <6" {
+				supports-thinking-binding-controls #true
+				supports-per-message-effort #true
+			}
+		}
 		family "opus" {
 			revision ">=5" {
 				supports-per-message-effort #true
 			}
+			// Opus 5.5 is prefix-bound like Sonnet 5.5; without `drop_block` a
+			// changed system prompt or tool set fails the replay with a 400.
+			// Bounded for the same reason as the forced-tool-choice rule above.
+			revision ">=5.5 <6" {
+				supports-thinking-binding-controls #true
+			}
 		}
 	}
 	on "aimlapi" "gitlab-duo" "kilo" "nanogpt" "venice" {
 		thinking-efforts "minimal" "low" "medium" "high" "xhigh"
 	}
 	on "amazon-bedrock" "anthropic" "cloudflare-ai-gateway" "github-copilot" "gitlab-duo" \
-		"google-antigravity" "google-vertex" "opencode-zen" "vercel-ai-gateway" "zenmux" {
+		"google-antigravity" "google-vertex" "opencode-zen" "snowflake" "vercel-ai-gateway" "zenmux" {
 		family "sonnet" {
 			revision ">=3.7 <4.6" {
 				thinking-mode "budget"
@@ -159,13 +304,21 @@ class "anthropic" {
 		}
 	}
 	on "amazon-bedrock" "anthropic" "cloudflare-ai-gateway" "github-copilot" "gitlab-duo" \
-		"google-vertex" "opencode-zen" "vercel-ai-gateway" {
+		"google-vertex" "opencode-zen" "snowflake" "vercel-ai-gateway" {
 		family "haiku" {
 			thinking-mode "budget"
+			// Haiku 5.5 is the first adaptive Haiku: `budget_tokens` is a 400.
+			// An omitted `thinking` is adaptive, but unlike Sonnet/Opus 5.5 it
+			// accepts `disabled` at effort `high` or below, so Off is explicit.
+			// https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#use-effort-to-control-thinking
+			revision ">=5.5 <6" {
+				thinking-mode "anthropic-adaptive"
+				disabled-thinking "disabled"
+			}
 		}
 	}
 	on "amazon-bedrock" "anthropic" "cloudflare-ai-gateway" "github-copilot" "gitlab-duo" \
-		"google-vertex" "opencode-zen" "vercel-ai-gateway" "zenmux" {
+		"google-vertex" "opencode-zen" "snowflake" "vercel-ai-gateway" "zenmux" {
 		family "opus" {
 			revision ">=4.5 <4.6" {
 				thinking-mode "anthropic-budget-effort"
@@ -173,7 +326,7 @@ class "anthropic" {
 		}
 	}
 	on "amazon-bedrock" "anthropic" "cloudflare-ai-gateway" "github-copilot" "google-vertex" \
-		"opencode-zen" "openrouter" "vercel-ai-gateway" "zenmux" {
+		"opencode-zen" "openrouter" "snowflake" "vercel-ai-gateway" "zenmux" {
 		family "opus" {
 			revision ">=4.6 <4.7" {
 				thinking-efforts "low" "medium" "high" "max"
@@ -181,7 +334,7 @@ class "anthropic" {
 		}
 	}
 	on "amazon-bedrock" "anthropic" "cloudflare-ai-gateway" "github-copilot" "google-vertex" \
-		"opencode-zen" "vercel-ai-gateway" "zenmux" {
+		"opencode-zen" "snowflake" "vercel-ai-gateway" "zenmux" {
 		revision ">=4.7 <45.1" {
 			thinking-mode "anthropic-adaptive"
 		}
@@ -212,13 +365,13 @@ class "anthropic" {
 		}
 	}
 	on "anthropic" "cloudflare-ai-gateway" "github-copilot" "google-vertex" "opencode-zen" \
-		"openrouter" "vercel-ai-gateway" "zenmux" {
+		"openrouter" "snowflake" "vercel-ai-gateway" "zenmux" {
 		revision ">=4.7 <45.1" {
 			thinking-efforts "low" "medium" "high" "xhigh" "max"
 		}
 	}
 	on "anthropic" "cloudflare-ai-gateway" "github-copilot" "google-vertex" "opencode-zen" \
-		"vercel-ai-gateway" "zenmux" {
+		"snowflake" "vercel-ai-gateway" "zenmux" {
 		family "sonnet" {
 			revision ">=4.6 <5" {
 				thinking-efforts "low" "medium" "high"
@@ -270,6 +423,34 @@ class "anthropic" {
 				max-tokens 128000
 			}
 		}
+		// /v1/models reports neither reasoning, vision, pricing nor limits for
+		// Haiku 5.5, so a discovered row would materialize as a text-only,
+		// unpriced, non-reasoning model; pin the model card. Prompts over 100K
+		// input tokens bill the whole request at the long-context rates.
+		// https://platform.claude.com/docs/en/models/haiku-5-5/overview
+		family "haiku" {
+			revision ">=5.5 <6" {
+				thinking-upgrade-neutral #true
+				input-modalities "text" "image"
+				cost-patch {
+					input 0.1
+					output 0.5
+					cache-read 0.01
+					cache-write 0.125
+				}
+				long-context-cost {
+					input-threshold 100000
+					input 0.5
+					output 2.5
+					cache-read 0.05
+					cache-write 0.625
+				}
+				limits-patch {
+					context-window 1000000
+					max-tokens 128000
+				}
+			}
+		}
 		family "mythos" {
 			cost-patch {
 				input 10.0

package/src/compat/rules/classes/deepseek.kdl

@@ -92,8 +92,16 @@ class "deepseek" {
 	models "deepseek-flash" priority=10 {
 		strip-image-input #false
 	}
-	on "ollama-cloud" "nvidia" "deepseek" "fireworks" "nanogpt" "opencode-go" "openrouter" "litellm" "nous" {
-		stream-markup-healing-pattern "dsml"
-	}
+	// DSML is the model's own tool-call grammar, not a host quirk: any server
+	// running DeepSeek's chat template without (or with a broken) tool parser
+	// leaks it into content — hosted gateways, local backends, and custom
+	// providers alike. On hosts that parse it the healer sees no markup.
+	stream-markup-healing-pattern "dsml"
 	thinking-loop-guard "deepseek"
+	// V4 reasoning reaches omp as its plaintext trace on every host, and the
+	// revision pins the weights (flash 4.0 / 4.1, pro 4.0). Earlier lineages
+	// classify too coarsely to carry: `r1` also matches the R1 distills.
+	revision ">=4" {
+		portable-reasoning #true
+	}
 }

package/src/compat/rules/classes/gemini.kdl

@@ -118,3 +118,15 @@ class "gemini" {
 		}
 	}
 }
+
+// Gemini 3+ bills a fixed `media_resolution` budget per image regardless of
+// pixels; the default for images is HIGH, 1,120 tokens.
+// https://ai.google.dev/gemini-api/docs/media-resolution
+class "gemini" {
+	revision ">=3" {
+		image-tokenization {
+			regime "fixed"
+			tokens 1120
+		}
+	}
+}