@oh-my-pi/pi-catalog 18.11.2 → 18.12.0

package/src/compat/resolve.ts

@@ -330,7 +330,6 @@ function isOfficialOpenAIEndpoint(provider: string, baseUrl: string): boolean {
 
 interface OpenAIDetection {
 	facts: IdentityFacts;
-	isClinePass: boolean;
 	isZai: boolean;
 	isZhipu: boolean;
 	isMoonshotNative: boolean;
@@ -368,7 +367,6 @@ function detectOpenAI(
 		(LOCAL_OPENAI_COMPAT_PROVIDERS[backendProvider] === true || hasLocalLoopbackBaseUrl(baseUrl));
 	return {
 		facts,
-		isClinePass: provider === "cline-pass",
 		isZai,
 		isZhipu,
 		isMoonshotNative,
@@ -474,7 +472,9 @@ function detectOpenAICompat(
 			provider === "github-copilot" ||
 			provider === "zenmux");
 
-	// Endpoint-only watchdogs remain here; provider and lineage policy lives in KDL.
+	// URL-keyed watchdogs: they also cover custom provider ids pointed at these
+	// hosts, which provider-keyed rules (`stream-idle-timeout-ms` in
+	// classes/{glm,kimi,mimo}.kdl) cannot match. KDL rules override them.
 	const streamIdleTimeoutMs =
 		facts.is("glm") &&
 		facts.revGte("5") &&
@@ -521,21 +521,17 @@ function detectOpenAICompat(
 		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",
+		supportsReasoningParams: true,
 		supportsSamplingParams: true,
 		supportsPenaltyAndStopParams: !(isGrok && reasoningCapable),
 		reasoningEffortMap: {},
 		supportsUsageInStreaming: !isCerebrasHost,
 		alwaysSendMaxTokens: facts.is("kimi"),
-		disableReasoningOnForcedToolChoice:
-			!d.isClinePass && ((facts.is("kimi") && !isMoonshotKimiK3) || isAnthropicModel),
-		disableReasoningOnToolChoice: !d.isClinePass && isDeepseekFamily && reasoningCapable && !d.isOpenRouter,
+		disableReasoningOnForcedToolChoice: (facts.is("kimi") && !isMoonshotKimiK3) || isAnthropicModel,
+		disableReasoningOnToolChoice: isDeepseekFamily && reasoningCapable && !d.isOpenRouter,
 		disableReasoningWithTools: false,
-		supportsToolChoice: d.isClinePass || !d.isDirectDeepseekReasoning,
-		supportsForcedToolChoice:
-			!d.requiresEnabledThinking && !(d.isOpenCodeHost && d.isDeepseekReasoning) && !(d.isClinePass && isQwen),
+		supportsToolChoice: !d.isDirectDeepseekReasoning,
+		supportsForcedToolChoice: !d.requiresEnabledThinking && !(d.isOpenCodeHost && d.isDeepseekReasoning),
 		supportsNamedToolChoice: true,
 		maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
 		requiresToolResultName: isMistral,
@@ -544,16 +540,12 @@ function detectOpenAICompat(
 		requiresMistralToolIds: isMistral,
 		thinkingFormat,
 		kimiApiFormat: undefined,
-		reasoningDisableMode: d.isClinePass
-			? "cline-enabled-false"
-			: d.isVenice
-				? "venice-disable-thinking"
-				: resolveReasoningDisableMode(thinkingFormat),
+		reasoningDisableMode: d.isVenice ? "venice-disable-thinking" : resolveReasoningDisableMode(thinkingFormat),
 		omitReasoningEffort: false,
 		includeEncryptedReasoning: true,
 		filterReasoningHistory: d.isOpenRouter && isAnthropicModel,
 		thinkingKeep: usesMoonshotKimiPreservedThinking ? "all" : undefined,
-		reasoningContentField: d.isClinePass ? "reasoning" : "reasoning_content",
+		reasoningContentField: "reasoning_content",
 		mistralReasoningContentParts: undefined,
 		requiresReasoningContentForToolCalls:
 			(facts.is("kimi") && !d.isOpenCodeProvider) ||
@@ -571,10 +563,7 @@ function detectOpenAICompat(
 		// Template effort support is a reviewed backend × model contract in KDL.
 		qwenTemplateReasoningEffort: false,
 		requiresAssistantContentForToolCalls: facts.is("kimi") || d.isDirectDeepseekReasoning,
-		cacheControlFormat:
-			(d.isClinePass && (isQwen || isAnthropicModel)) || (d.isOpenRouter && isAnthropicModel)
-				? "anthropic"
-				: undefined,
+		cacheControlFormat: d.isOpenRouter && isAnthropicModel ? "anthropic" : undefined,
 		supportsPromptCacheBreakpoints,
 		promptCacheBreakpointTtl: supportsPromptCacheBreakpoints ? "30m" : undefined,
 		openRouterRouting: undefined,
@@ -599,7 +588,11 @@ function detectOpenAICompat(
 					: undefined,
 		streamFirstEventTimeoutMs: d.isLocalServingBackend ? 0 : undefined,
 		streamIdleTimeoutMs,
-		stripDeepseekSpecialTokens: facts.is("deepseek") && (provider === "nvidia" || provider === "deepseek"),
+		stripDeepseekSpecialTokens: false,
+		// Present as a key so models.yml `compat` can set it; unset unless a rule assigns it.
+		stripThinkingHistory: undefined,
+		// URL-derived like the Responses field; unset off the official OpenAI API.
+		officialEndpoint: isOfficialOpenAIEndpoint(spec.provider, baseUrl) || undefined,
 		streamMarkupHealingPattern: detectStreamMarkupHealing(spec.provider, facts, baseUrl),
 		reasoningDeltasMayBeCumulative: false,
 		emptyLengthFinishIsContextError: false,
@@ -657,15 +650,13 @@ function fixupOpenAICompat(
 		compat.extraBody = Object.keys(extraBody).length > 0 ? extraBody : undefined;
 	}
 	if (spec.compat?.reasoningDisableMode === undefined && !("reasoningDisableMode" in axes.wire)) {
-		compat.reasoningDisableMode = d.isClinePass
-			? "cline-enabled-false"
-			: d.requiresEnabledThinking
-				? "omit"
-				: d.isDirectDeepseekReasoning
-					? "zai-thinking-disabled"
-					: d.isVenice
-						? "venice-disable-thinking"
-						: resolveReasoningDisableMode(compat.thinkingFormat);
+		compat.reasoningDisableMode = d.requiresEnabledThinking
+			? "omit"
+			: d.isDirectDeepseekReasoning
+				? "zai-thinking-disabled"
+				: d.isVenice
+					? "venice-disable-thinking"
+					: resolveReasoningDisableMode(compat.thinkingFormat);
 	}
 	if (
 		spec.compat?.omitReasoningEffort === undefined &&
@@ -754,7 +745,8 @@ function resolveOpenAIResponsesPolicy(
 		supportsLongPromptCacheRetention: isOpenAIUrl,
 		supportsPromptCacheBreakpoints,
 		promptCacheBreakpointTtl: supportsPromptCacheBreakpoints ? "30m" : undefined,
-		strictResponsesPairing: isAzure || provider === "github-copilot",
+		// Provider ids are rule-owned; the URL arm keeps custom Azure endpoints paired.
+		strictResponsesPairing: hostMatchesUrl(baseUrl, "azureOpenAI"),
 		// 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:
@@ -783,7 +775,7 @@ function resolveOpenAIResponsesPolicy(
 		disableReasoningOnToolChoice: isDeepseekFamily && reasoningCapable && !isOpenRouter,
 		disableReasoningWithTools: false,
 		supportsToolChoice: true,
-		supportsForcedToolChoice: provider !== "opencode-go" && provider !== "opencode-zen",
+		supportsForcedToolChoice: true,
 		supportsNamedToolChoice: true,
 		reasoningContentField: "reasoning_content",
 		requiresReasoningContentForToolCalls:
@@ -822,7 +814,7 @@ function resolveOpenAIResponsesPolicy(
 		rejectRootObjectUnion: false,
 		retryWithoutStrictOnGrammarError: false,
 		cacheControlFormat: isOpenRouter && isAnthropicModel ? "anthropic" : undefined,
-		stripDeepseekSpecialTokens: facts.is("deepseek") && (provider === "nvidia" || provider === "deepseek"),
+		stripDeepseekSpecialTokens: false,
 		streamMarkupHealingPattern: detectStreamMarkupHealing(provider, facts, baseUrl),
 		reasoningDeltasMayBeCumulative: false,
 		emptyLengthFinishIsContextError: false,
@@ -984,7 +976,8 @@ function resolveOllamaPolicy(spec: ModelSpec<"ollama-chat">, axes: ResolvedAxes)
 
 function resolveDevinPolicy(spec: ModelSpec<"devin-agent">, axes: ResolvedAxes): ResolvedDevinCompat {
 	const compat: ResolvedDevinCompat = {
-		trustExplicitThinkingOnly: true,
+		// Rule-owned: `on-api "devin-agent"` in providers/devin.kdl opts in.
+		trustExplicitThinkingOnly: false,
 		modelRouter: false,
 		supportsParallelToolCalls: false,
 	};
@@ -1037,7 +1030,11 @@ function readCompatEffortMap(compat: CompatOf<Api>): Partial<Record<Effort, stri
 	const map = compat.reasoningEffortMap;
 	return map && Object.keys(map).length > 0 ? map : undefined;
 }
-/** Host-quirk effort remaps detected outside the rules (URL/API compounds). */
+/**
+ * URL-keyed Fireworks effort remap: covers custom provider ids pointed at the
+ * Fireworks host, which the `fireworks`/`firepass` `thinking-effort-map`
+ * rules cannot match. Rule and configured maps override it.
+ */
 const FIREWORKS_THINKING_EFFORT_MAP: Readonly<Partial<Record<Effort, string>>> = {
 	[Effort.Minimal]: "none",
 };
@@ -1051,10 +1048,6 @@ function defaultThinkingMode<TApi extends Api>(spec: ModelSpec<TApi>, facts: Ide
 			// Gemini 3+ `google-level` is a `thinking-mode` rule in classes/gemini.kdl.
 			return "budget";
 		case "anthropic-messages":
-			if (facts.is("minimax") && facts.family("m2", "m3")) return "anthropic-adaptive";
-			if (facts.is("glm") && facts.revGte("5.2") && (spec.provider === "umans" || spec.provider === "zai")) {
-				return "anthropic-budget-effort";
-			}
 			if (facts.is("anthropic")) {
 				// 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";
@@ -1201,14 +1194,6 @@ function resolveThinkingPolicy<TApi extends Api>(
 	) {
 		return undefined;
 	}
-	if (
-		spec.provider === "cline-pass" &&
-		compat !== undefined &&
-		"supportsReasoningEffort" in compat &&
-		compat.supportsReasoningEffort === false
-	) {
-		return undefined;
-	}
 	if (omitsWireReasoningEffort(spec.api, compat)) return undefined;
 	if (explicitThinking !== undefined) {
 		return fillExplicitThinking(spec, facts, compat, explicitThinking, rule);

package/src/compat/rules/README.md

@@ -221,19 +221,29 @@ One object axis carries a computed form: `long-context-cost` accepts either the
 
 `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).
 
+`long-context-window-uncapped #true` keeps a model's `long-context-cost` tier from capping its runtime context window while extended context is off: the coding agent normally lowers the window to the tier's input threshold so compaction fires before a request crosses into premium pricing. Use it where the tier is an API-equivalent estimate on a subscription host (`xai-oauth`) or where the model is served at its full window regardless (GPT-5.4, except on GitHub Copilot). `buildModel` materializes it as `Model.longContextWindowUncapped`; explicit user context overrides still apply.
+
+`max-tokens-fallback` seeds `maxTokens` only when the row reports none, and `max-tokens-ceiling` lowers a larger reported `maxTokens` to the host's output cap (an unknown budget stays unknown unless a fallback seeded it). Both apply in `buildModel` after `limits-patch`, so discovery mappers pass upstream output budgets through verbatim. See the Kimi rules in [`providers/fireworks.kdl`](providers/fireworks.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, and snapcompact gives its archive frames half of it (`frameDataBytesBudget`). The budget applies only while the request reaches the official endpoint (the Anthropic API, first-party OpenAI, or the Codex backend at its default URL), which callers decide with pi-ai's `reachesOfficialEndpoint`: `compat.officialEndpoint` for the configured `baseUrl`, and for first-party Anthropic models also the `ANTHROPIC_BASE_URL` or Foundry `FOUNDRY_BASE_URL` reroute applied at request time. A custom or rerouted endpoint imposes its own body limit.
 
 `image-count-budget` is the most images one request may carry, archive frames, screenshots and imaged tool results combined. The coding agent reads it through `resolveImageCountBudget`, drops the oldest images past it, and caps snapcompact frames at it; unassigned hosts get a floor of 5. `official-image-count-budget` replaces it while the request reaches the official endpoint (same gate as `inline-image-byte-budget`), for limits established on the host's own endpoint (Anthropic: 600, 100 on 200k-window models; Codex: 2,000); a custom or rerouted endpoint keeps `image-count-budget` (Anthropic 90, Codex 200).
 
+`endpoint-hosts` lists the HTTPS hostnames a provider serves besides its bundled base URL's host, such as Copilot's per-plan `api.<plan>.githubcopilot.com` hosts. That host plus these define the provider's own endpoint (`isCatalogEndpointUrl`), which separates first-party traffic from a custom model or provider override that keeps a catalog provider id but points `baseUrl` at a gateway, proxy, or local server. Connection prewarming and request compression act only on the provider's own endpoint.
+
+`request-encodings` lists the `Content-Encoding`s (`zstd`, `gzip`) a provider's own endpoint decodes on request bodies, most preferred first; pi-ai's `wrapFetchForRequestCompression` reads them through `resolveRequestCompression` and compresses bodies of 1 KiB or more. A proxy, relay, or `ANTHROPIC_BASE_URL` reroute never receives bytes it cannot read. `request-encoding-rejection` is a regular expression for the 400/415 error body the host returns when it cannot decode the body; unassigned, every 400/415 is re-checked with an uncompressed resend. A rejected encoding is dropped for that host only after the uncompressed resend succeeds. Assign them only from a live probe of every endpoint host: a compressed body, the same plain JSON mislabeled as compressed (a decoding host must reject it), and a real request.
+
 `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.
 
+`judgment-image-input` assigns model-specific native judgment image bounds, read through `resolveJudgmentImageInput`. Its object accepts `mime-types` as a comma-separated lowercase MIME list and positive integer `max-count`, `max-bytes`, `max-total-bytes`, `min-pixels`, `max-pixels`, `min-side`, and `max-side`; byte limits count decoded data. `NativeJudge` enforces these alongside its wire's encoding constraints without resizing, and candidate filtering skips models whose bounds reject the images. Unassigned adds no model-specific bounds. The Jev selectors in [`providers/typesafe.kdl`](providers/typesafe.kdl) and [`providers/openrouter.kdl`](providers/openrouter.kdl) own Jev's limits rather than imposing them on every model using those APIs.
+
 `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.
 
 `task-sibling-prompt-cache #true` lets Task children use an automatically derived sibling cache key on the matching request model. Missing or `#false` keeps the provider's per-child default; explicit cache keys still win. The session resolves this catalog policy against the actual model for primary turns, handoff, and ephemeral requests that reuse the live context, including model changes, without sharing conversation IDs or response state. The automatic candidate is persisted separately from explicit keys and survives full forks, `/tan`, and session reopening; new and partial sessions discard it. A fork carrying an automatic candidate uses its own conversation ID on unsupported models, and re-enables the candidate when returning to an eligible model. Ordinary forks without an automatic candidate keep their existing inherited cache routing. Conventional compaction keeps its existing cache routing because its serialized summary prompt differs from the primary context. The opt-in covers Muse Code's `muse-spark-1.3`, `muse-spark-1.3-contributor`, `muse-wonder-1.0`, `muse-wonder-1.0-contributor`, `muse-wonder-full-1.0`, and `muse-wonder-full-1.0-contributor` over `openai-responses`. Meta documents shared-prefix `prompt_cache_key` routing for Responses. Warmed sibling cache reuse was measured on Spark 1.3 Contributor; the standard Spark variant shares this scope following maintainer guidance. A bounded synthetic probe observed cache reuse on all four Wonder variants; it does not establish production or latency benefits. Auxiliary-request latency has not been measured. Provider selectors also match custom providers that declare the same `providerType`; no benefit is established for custom endpoints.
 
 `image-max-edge` is the longest image edge, in pixels, a host passes to the model; it downscales larger images to fit first (Cursor: 1024 for Claude and GPT). Snapcompact reads it through `resolveImageMaxEdge` and renders frames no wider, so their glyphs reach the model at the size they were drawn; unassigned means the host keeps the image's size.
 
-`snapcompact-image-reads #true` opts a reader in to getting a fresh `read` result as snapcompact frames when `snapcompact.toolResults` is on. Frames lose exact indentation, which a weaker reader then miscopies into its edits (Haiku 5.5: 22 of 54 first edits exact, against 53 of 54 from text); Opus 5.5 edited exactly from frames, so Opus 5.5+ opts in ([`classes/anthropic.kdl`](classes/anthropic.kdl)). Unassigned: `read` results stay text; other tools' results are imaged either way.
+`snapcompact-image-reads #true` opts a reader in to getting a fresh `read` result as snapcompact frames when `snapcompact.toolResults` is on. Frames collapse whitespace, so snapcompact draws each row's leading indentation as a count bracket (`[»2]`, `[·4]`) and keeps the `[path#TAG]` header as text beside them. On 3–4 frame reads Opus 5.5 then made exact first edits from frames within one of text (38 vs 39 of 40), so Opus 5.5+ opts in ([`classes/anthropic.kdl`](classes/anthropic.kdl)); Sonnet 5.5 (37 vs 40) and Haiku 5.5 (35 vs 40) still miscounted deep tab indents. Unassigned: `read` results stay text; other tools' results are imaged either way.
 
 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`.
 
@@ -325,11 +335,17 @@ behavior {
     pricing-peer provider="google-antigravity" peers="google" "google-vertex" {
         alias "gemini-3-pro" peer-id="gemini-3-pro-preview"
     }
+    role-defaults "smol" {
+        model "claude-haiku-5-5"
+        model "openai-codex/gpt-5.3-codex-spark"
+    }
 }
 ```
 
 `exclude-discovery-modes` takes one or more exact, case-sensitive upstream mode strings plus `provider=`; discovery mappers preserve missing, malformed, and unknown modes unless the provider policy explicitly lists them. Matcher properties on `route` / `exclude-models` / `tier` nodes are `exact=` / `prefix=` / `substring=` / `glob=`, repeatable. `strip-prefix=#true` on a prefix route strips the matched prefix off the wire id. Values are copied verbatim from the TS constants they replaced; runtime accessors live in `src/compat/behavior.ts`.
 
+`role-defaults "<role>"` declares one agent role's built-in default model selector chain, one `model "<selector>"` child per entry, most preferred first. Selectors are copied verbatim (`provider/id`, bare ids, fuzzy fragments such as `-mini`, and `@role` references); duplicates within a role and repeated roles are compile errors. `roleDefaultModels()` returns every chain keyed by role in declaration order.
+
 ## Auth grammar
 
 Every provider has exactly one `auth "<id>" { … }` node under `auth/`; `auth/_order.kdl` holds a single `login-order "id" …` node pinning the `/login` roster order (every provider with a `login` and `show-in-login-list` unset/true must appear; providers without a login sort alphabetically after it). Runtime accessors live in `src/compat/auth.ts`; the id unions in the generated `src/compat/auth-ids.ts`. Every provider in `provider-models/descriptors.ts` needs an auth node (`@oh-my-pi/pi-ai` type-checks this).

package/src/compat/rules/auth/google-antigravity.kdl

@@ -1,5 +1,5 @@
 auth "google-antigravity" {
-	name "Antigravity (Gemini 3, Claude, GPT-OSS)"
+	name "Google Antigravity (Gemini, Claude, GPT-OSS)"
 	login "oauth-code" {
 		// Antigravity uses different Google OAuth credentials for its additional models.
 		client-id "MTA3MTAwNjA2MDU5MS10bWhzc2luMmgyMWxjcmUyMzV2dG9sb2poNGc0MDNlcC5hcHBzLmdvb2dsZXVzZXJjb250ZW50LmNvbQ==" encoding="base64"

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

@@ -120,9 +120,8 @@ class "anthropic" {
 			supports-sampling-params #false
 		}
 	}
-	// Opus 5.5 made every first edit exactly right from `read` results it saw
-	// only as snapcompact frames (24/24); Haiku 5.5 lost leading whitespace
-	// (22/54), so other lines keep `read` as text until measured.
+	// Opus 5.5 edits from imaged `read` results within one miss of text; Sonnet
+	// and Haiku 5.5 miscount deep tab indents (measurements: rules/README.md).
 	family "opus" {
 		revision ">=5.5 <10" {
 			snapcompact-image-reads #true

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

@@ -59,6 +59,10 @@ class "deepseek" {
 	on "alibaba-token-plan" "deepseek" {
 		supports-developer-role #false
 	}
+	// Replaces the provider-keyed leaked chat-template special-token strip.
+	on "nvidia" "deepseek" {
+		strip-deepseek-special-tokens #true
+	}
 	on "deepseek" "opencode-go" {
 		family "pro" {
 			max-tokens-field "max_tokens"

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

@@ -7,6 +7,16 @@ class "minimax" {
 	}
 	// Replaces the MiniMax lineage branch in both OpenAI baselines.
 	reasoning-deltas-may-be-cumulative #true
+	// Replaces the identity default: M2/M3 thinking rides Anthropic adaptive
+	// thinking on every Messages route, custom provider ids included.
+	on-api "anthropic-messages" {
+		family "m2" {
+			thinking-mode "anthropic-adaptive"
+		}
+		family "m3" {
+			thinking-mode "anthropic-adaptive"
+		}
+	}
 	on "aimlapi" "coreweave" "fireworks" "huggingface" "kilo" "nanogpt" "novita" "nvidia" \
 		"opencode-go" "opencode-zen" "together" "venice" "wafer-serverless" "zenmux" {
 		family "m3" {

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

@@ -11,6 +11,14 @@ class "openai" {
 	revision ">=5" {
 		supports-sampling-params #false
 	}
+	// GPT-5.4 serves its 1M window, and its long-context price tier does not
+	// cap that window. GitHub Copilot keeps its own cap (github-copilot.kdl).
+	models "gpt-5.4" {
+		limits-patch {
+			context-window 1000000
+		}
+		long-context-window-uncapped #true
+	}
 	// GPT wire ladders are model generations, not host contracts: <5.2 keeps
 	// the classic four-tier scale, 5.2+ drops minimal for xhigh, and 5.6+
 	// exposes the wire-exact five-tier low..max scale.

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

@@ -92,6 +92,10 @@ provider "anthropic" {
 	// https://platform.claude.com/docs/en/build-with-claude/vision
 	image-count-budget 90
 	official-image-count-budget 600
+	// The Messages API decodes gzip request bodies and rejects zstd and br
+	// with a 400 (`request_body_encoding_invalid`).
+	request-encodings "gzip"
+	request-encoding-rejection "request_body_encoding_invalid|Unsupported Content-Encoding"
 	class "anthropic" {
 		revision "<4.6" {
 			official-image-count-budget 100

package/src/compat/rules/providers/azure.kdl

@@ -3,6 +3,8 @@
 provider "azure" {
 	default-model "gpt-5.5"
 	env "AZURE_OPENAI_API_KEY"
+	// Replaces the provider-keyed strict Responses tool-call/result pairing.
+	strict-responses-pairing #true
 
 	class "openai" {
 		thinking-mode "effort"

package/src/compat/rules/providers/cerebras.kdl

@@ -10,6 +10,9 @@ provider "cerebras" {
 	// Replaces the Cerebras provider branches in the completions baseline.
 	supports-usage-in-streaming #false
 	tool-strict-mode "all_strict"
+	// Replaces the provider check in agent-loop history normalization: replayed
+	// assistant history drops its thinking blocks.
+	strip-thinking-history #true
 	// Prompt caching carries no discount: cached input tokens bill at the
 	// standard input rate (https://inference-docs.cerebras.ai/capabilities/prompt-caching).
 	cache-read-at-input-rate #true

package/src/compat/rules/providers/cline-pass.kdl

@@ -10,4 +10,20 @@ provider "cline-pass" {
 	wire-model-id-mode "cline-pass"
 	// Replaces the Cline Pass thinking-format branch.
 	thinking-format "openai"
+	// Replaces the Cline Pass completions baseline branches: the reasoning
+	// field, the disable shape, and reasoning kept on under tool choice.
+	reasoning-content-field "reasoning"
+	reasoning-disable-mode "cline-enabled-false"
+	disable-reasoning-on-forced-tool-choice #false
+	disable-reasoning-on-tool-choice #false
+	// Discovery reports each row's thinking ladder; a row without one
+	// (`supportsReasoningEffort: false`) has no reasoning control at all.
+	trust-explicit-thinking-only #true
+	class "qwen" {
+		supports-forced-tool-choice #false
+		cache-control-format "anthropic"
+	}
+	class "anthropic" {
+		cache-control-format "anthropic"
+	}
 }

package/src/compat/rules/providers/commandcode.kdl

@@ -337,6 +337,16 @@ provider "commandcode" {
 			cache-write 0.0
 		}
 	}
+	// Restate the 64K provider output cap beside the openai class's GPT-5.4
+	// window patch, or the class rule wins the whole limits axis.
+	class "openai" {
+		models "gpt-5.4" {
+			limits-patch {
+				context-window 1000000
+				max-tokens 65536
+			}
+		}
+	}
 	models "gpt-5.3-codex" {
 		cost-patch {
 			input 2.0

package/src/compat/rules/providers/deepinfra.kdl

@@ -1,4 +1,4 @@
-// Catalog entry for "deepinfra"; no deployment-contract compat rules are needed.
+// Catalog entry for "deepinfra".
 
 provider "deepinfra" {
 	default-model "deepseek-ai/DeepSeek-V4-Flash-0731"
@@ -9,6 +9,8 @@ provider "deepinfra" {
 		image "openai-images"
 		tts "openai-speech"
 	}
+	// Same-provider image-generation swap target for chat models.
+	image-model "black-forest-labs/FLUX-2-pro"
 
 	seed base-url="https://api.deepinfra.com/v1/openai" bundle="always" {
 		model "black-forest-labs/FLUX-2-pro" name="FLUX.2 Pro" api="openai-images" {

package/src/compat/rules/providers/devin.kdl

@@ -1,4 +1,4 @@
-// Catalog entry for "devin"; no deployment-contract compat rules are needed.
+// Catalog entry and deployment contract for "devin".
 
 provider "devin" {
 	default-model "swe-1-6"
@@ -191,3 +191,9 @@ provider "devin" {
 		}
 	}
 }
+
+// Devin's Cascade catalog reports each model's thinking surface; a row
+// without one carries no reasoning ladder.
+on-api "devin-agent" {
+	trust-explicit-thinking-only #true
+}

package/src/compat/rules/providers/factory-droid.kdl

@@ -691,6 +691,12 @@ provider "factory-droid" {
 		thinking-requires-effort #true
 		thinking-default-level "medium"
 	}
+	// The native 922K window is authoritative; the class-wide gpt-5.4 1M patch does not apply.
+	class "openai" {
+		models "gpt-5.4" {
+			limits-patch {}
+		}
+	}
 	models "gpt-5.4-fast" {
 		routing-family "openai"
 		upstream-rotation "openai" "azure_openai"

package/src/compat/rules/providers/firepass.kdl

@@ -38,4 +38,19 @@ provider "firepass" {
 		thinking-mode "effort"
 		thinking-efforts "low" "high" "max"
 	}
+	// The Fire Pass router shares Fireworks' 32,768 Kimi K2 output cap (#1849).
+	class "kimi" {
+		family "k2" {
+			max-tokens-ceiling 32768
+		}
+		family "k2.5" {
+			max-tokens-ceiling 32768
+		}
+		family "k2.6" {
+			max-tokens-ceiling 32768
+		}
+		family "k2-thinking" {
+			max-tokens-ceiling 32768
+		}
+	}
 }

package/src/compat/rules/providers/fireworks.kdl

@@ -24,6 +24,32 @@ provider "fireworks" priority=-1 {
 	class "unknown" {
 		thinking-efforts "minimal" "low" "medium" "high" "xhigh"
 	}
+	// Replaces the Fireworks Kimi output caps in provider-models/openai-compat.ts
+	// (#1849). The K2 family ships long reasoning traces Fireworks bounds at
+	// 32,768 output tokens; the control plane reports no output budget, so the
+	// cap is also the fallback. K2.7-Code serves its full 65,536 (verified with
+	// a 58,971-token completion), which seeds rows that report none.
+	class "kimi" {
+		family "k2" {
+			max-tokens-fallback 32768
+			max-tokens-ceiling 32768
+		}
+		family "k2.5" {
+			max-tokens-fallback 32768
+			max-tokens-ceiling 32768
+		}
+		family "k2.6" {
+			max-tokens-fallback 32768
+			max-tokens-ceiling 32768
+		}
+		family "k2-thinking" {
+			max-tokens-fallback 32768
+			max-tokens-ceiling 32768
+		}
+		family "k2.7-code" {
+			max-tokens-fallback 65536
+		}
+	}
 	// residue: taxonomy ranks and exact globs do not isolate these models.
 	models "deepseek-v4-flash" {
 		requires-reasoning-content-for-all-assistant-turns #true

package/src/compat/rules/providers/github-copilot.kdl

@@ -14,6 +14,30 @@ provider "github-copilot" {
 	// not belong to this connection`: a resumed session rebuilds prior turns
 	// until its first response.
 	connection-bound-native-history #true
+	// Per-plan API hosts the Copilot token resolves to; the bundled base URL
+	// is `api.githubcopilot.com`.
+	endpoint-hosts "api.individual.githubcopilot.com" "api.business.githubcopilot.com" \
+		"api.enterprise.githubcopilot.com"
+	// `/chat/completions`, `/responses` and `/v1/messages` decode zstd, br and
+	// gzip request bodies (deflate is rejected), probed live 2026-10. GHE.com
+	// tenants (`copilot-api.<tenant>.ghe.com`) are unverified and stay plain.
+	request-encodings "zstd" "gzip"
+	request-encoding-rejection "invalid_request_body|[Ff]ailed to (?:parse|read) request"
+	// Replaces the provider-keyed strict Responses tool-call/result pairing.
+	strict-responses-pairing #true
+	// Replaces the provider check that disabled reasoning params on chat completions.
+	on-api "openai-completions" {
+		supports-reasoning-params #false
+	}
+	// Copilot caps GPT-5.4 below the lineage's 1M window (model-limits in
+	// runtime/behavior.kdl), so the class-wide window patch and uncapped
+	// window do not apply here.
+	class "openai" {
+		models "gpt-5.4" {
+			limits-patch {}
+			long-context-window-uncapped #false
+		}
+	}
 	class "anthropic" {
 		revision ">=4 <4.6" {
 			thinking-efforts "minimal" "low" "medium" "high" "xhigh"

package/src/compat/rules/providers/google-antigravity.kdl

@@ -41,6 +41,17 @@ provider "google-antigravity" {
 		// any image edge over 3,000 px. The clamp above caps each image; with no
 		// byte budget on this wire, the count bounds the body.
 		image-count-budget 20
+		// Cache-warmer lifetime. Claude here is Vertex Anthropic, whose prompt
+		// cache has a five-minute default TTL refreshed on every hit; this wire
+		// sends no `cache_control`, so the 1h tier is never requested.
+		// https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude/prompt-caching
+		// Gemini declares none: its implicit cache keeps entries for a
+		// load-dependent time ("caches always deleted within 24 hours"), so no
+		// fixed lifetime exists to warm against.
+		// https://cloud.google.com/blog/products/ai-machine-learning/vertex-ai-context-caching
+		prompt-cache {
+			short 300
+		}
 		family "opus" {
 			thinking-mode "budget"
 		}

package/src/compat/rules/providers/moonshot.kdl

@@ -6,6 +6,8 @@ provider "moonshot" {
 	// as a fallback so China users need not learn MOONSHOT_API_KEY. (#2883)
 	env "MOONSHOT_API_KEY" "KIMI_API_KEY"
 	discovery label="Moonshot"
+	// Moonshot's China platform, selected with MOONSHOT_BASE_URL (#2883).
+	endpoint-hosts "api.moonshot.cn"
 
 	class "kimi" {
 		// Replaces the Moonshot Kimi thinking-format branch.

package/src/compat/rules/providers/ollama-cloud.kdl

@@ -10,6 +10,9 @@ provider "ollama-cloud" {
 	thinking-mode "effort"
 	// Same runtime as local Ollama: a trailing assistant turn is continued verbatim.
 	supports-assistant-prefill #true
+	// Replaces the provider checks in model-registry.ts and the generator:
+	// never send a caller output limit.
+	omit-max-output-tokens #true
 	class "unknown" {
 		thinking-efforts "minimal" "low" "medium" "high"
 	}

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

@@ -21,6 +21,9 @@ provider "openai-codex" {
 	inline-image-byte-budget 24000000
 	image-count-budget 200
 	official-image-count-budget 2000
+	// The backend decodes zstd request bodies, as the official client sends.
+	// Its rejection body is undocumented, so any 400/415 re-checks uncompressed.
+	request-encodings "zstd"
 
 	seed api="openai-codex-responses" base-url="https://chatgpt.com/backend-api" bundle="always" {
 		// Label only: the Codex backend ignores `tool.model` and runs gpt-image-2-codex.
@@ -224,3 +227,9 @@ provider "openai-codex" {
 		context-window-floor 1000000
 	}
 }
+
+// The Codex backend rejects every sampling control (`temperature`, `top_p`,
+// penalties, stop sequences), whichever model it serves (#3117).
+on-api "openai-codex-responses" {
+	supports-sampling-params #false
+}

package/src/compat/rules/providers/opencode-go.kdl

@@ -4,6 +4,10 @@ provider "opencode-go" {
 	default-model "kimi-k2.7-code"
 	env "OPENCODE_API_KEY"
 	dynamic-models-authoritative #true
+	// Replaces the provider check that disabled forced tool choice on Responses.
+	on-api "openai-responses" {
+		supports-forced-tool-choice #false
+	}
 
 	// The Flash lanes accept images despite their IDs lacking a vision suffix;
 	// verified against the gateway (unguessable pixel-rendered text read back

package/src/compat/rules/providers/opencode-zen.kdl

@@ -4,6 +4,10 @@ provider "opencode-zen" {
 	default-model "claude-opus-5"
 	env "OPENCODE_API_KEY"
 	dynamic-models-authoritative #true
+	// Replaces the provider check that disabled forced tool choice on Responses.
+	on-api "openai-responses" {
+		supports-forced-tool-choice #false
+	}
 
 	// Replaces the OpenCode reasoning-model whenThinking fallback object.
 	// Applies to every completions-routed reasoning model, discovered ids