@oh-my-pi/pi-catalog 18.2.0 → 18.2.2

package/CHANGELOG.md

@@ -2,6 +2,45 @@
 
 ## [Unreleased]
 
+## [18.2.2] - 2026-09-16
+
+### Added
+
+- OpenAI-compatible model discovery now fills in reasoning-effort tiers for unrecognized models using the shared catalog’s published reasoning options, while preserving explicit discovery metadata and reviewed model rules.
+
+### Fixed
+
+- Fixed recovery of corrupted model caches so private backups are preserved and concurrent recovery cannot overwrite a cache that has already been restored.
+- Fixed pricing for Devin (SWE-2, SWE-1.7, and GLM-5.2 High) and Kimi Code models when upstream discovery omits cost information. SWE-2 now reflects its promotional pricing through December 31, 2026, then switches to list pricing on January 1, 2027.
+- Fixed pricing and chat routing for Devin Fusion models so composite models use their own headline rates and supported Fusion lanes connect directly instead of failing through an incompatible routing path.
+
+## [18.2.1] - 2026-09-15
+
+### Added
+
+- DeepSeek V4.1 Flash (`deepseek-flash`) now accepts image inputs and resolves its reasoning metadata, name, and effort ladder from upstream instead of shipping as a text-only row without them.
+
+### Fixed
+
+- Fixed Cerebras Qwen 3.8 reasoning control by enabling correct effort tiers and disable behavior
+- Fixed Cerebras Qwen models using incorrect reasoning format, enabling proper support for thinking modes
+- Fixed Command Code's `deepseek/deepseek-v4.1-flash` row exposing its documented low/high/max thinking levels and image input, and made live discovery resolve the reasoning contract its rules declare ([#1666](https://github.com/can1357/oh-my-pi/issues/1666), [#11703](https://github.com/can1357/oh-my-pi/pull/11703) by [@aliefe04](https://github.com/aliefe04)).
+- Fixed Meta Model API and Muse Code requests failing with 400 whenever omp forced a tool choice: `api.meta.ai/v1` accepts only `tool_choice: "auto"`, so `none`, `required`, and named choices (subagent final-retry `yield`, forced tools, structured output, compaction handoff) are now omitted instead of sent ([#11635](https://github.com/can1357/oh-my-pi/pull/11635) by [@quantmind-br](https://github.com/quantmind-br)).
+- Bedrock's Qwen rows no longer ask for more output tokens than the model accepts, which Bedrock rejected with a 400. ([#12117](https://github.com/can1357/oh-my-pi/pull/12117) by [@Huang-404-Q](https://github.com/Huang-404-Q))
+- Gemini 2.5 Flash Lite on Vertex AI no longer requests `maxOutputTokens=65536`, which the endpoint rejects with a 400; the output cap is clamped to 65535 ([#10595](https://github.com/can1357/oh-my-pi/pull/10595) by [@WeMingT](https://github.com/WeMingT)).
+- Fixed Meta muse-spark models on OpenRouter wedging every turn with `400 Referenced reasoning item ... was not found or has expired`: replayed Responses reasoning history is now filtered for the muse-spark family, matching the existing Anthropic-on-OpenRouter treatment ([#10675](https://github.com/can1357/oh-my-pi/pull/10675) by [@Giardi77](https://github.com/Giardi77)).
+- Fixed Ollama Cloud model discovery synthesizing a generic `minimal`/`low`/`medium`/`high` effort ladder for every thinking-capable model, which shadowed the per-model compat rules and made `max` unreachable on the DeepSeek V4 line (including the served `deepseek-v4.1-flash`, `deepseek-v4-flash:0731`, and `deepseek-v4-pro:0813` ids): discovery now leaves the ladder to the rule tree, so those models advertise the wire-exact `low`/`high`/`max` and GLM-5.3 exposes `low`/`high`/`max` ([#8334](https://github.com/can1357/oh-my-pi/issues/8334)).
+- Fixed Meta Model API and Muse Code requests failing with 400 whenever omp forced a tool choice: `api.meta.ai/v1` accepts only `tool_choice: "auto"`, so `none`, `required`, and named choices (subagent final-retry `yield`, forced tools, structured output, compaction handoff) are now omitted instead of sent.
+- Fixed Azure GPT-6 Astra Chat Completions policy to disable reasoning with function tools and encode thinking-off as `reasoning_effort: "none"` ([#11052](https://github.com/can1357/oh-my-pi/issues/11052)).
+- Fixed Z.AI and Zhipu timezone-naive quota reset timestamps resolving eight hours late by declaring their UTC+8 reset timezone ([#11014](https://github.com/can1357/oh-my-pi/issues/11014)).
+- Fixed Amazon Bedrock Claude Fable 5.1 effort metadata to expose `xhigh` and `max` instead of the unsupported `minimal` level. ([#10788](https://github.com/can1357/oh-my-pi/pull/10788) by [@voonfoo](https://github.com/voonfoo))
+- LiteLLM discovery no longer exposes known task-specific models, including embedding, media, moderation, reranking, and search models, as coding models.
+- Fixed custom `anthropic-messages` providers whose adaptive effort ladder exposes `minimal` sending `output_config.effort: "minimal"`, which the Anthropic Messages API rejects with `400 level "minimal" not supported`; the adaptive effort mapper now clamps `minimal` to `low` ([#10994](https://github.com/can1357/oh-my-pi/issues/10994)).
+- Qwen 3.8 models on Alibaba Token Plan now send the selected reasoning effort and replay reasoning history across turns.
+- Fixed DeepInfra model cost reporting so promotional pricing is reflected: the `metadata.discount` fraction is now applied to input, output, and cache-read rates ([#10935](https://github.com/can1357/oh-my-pi/issues/10935)).
+- Fixed LiteLLM model discovery leaking ClinePass display names and pricing into models with colliding ids ([#10932](https://github.com/can1357/oh-my-pi/issues/10932)).
+- Raised Cursor context windows to Cursor's documented sizes (Grok 4.5/4.6 256k, default/Auto 256k, Kimi K2.7 Code 262k, GPT-5.6 272k, Claude Opus 5 and Fable 300k by default) so compaction no longer fires too early, without lowering existing 1M Max-mode windows.
+
 ## [18.2.0] - 2026-09-15
 
 ### Breaking Changes

package/dist/types/compat/behavior.d.ts

@@ -29,6 +29,8 @@ export declare function cursorModelParameters(model: string): readonly {
  * preserve quota semantics for newly discovered ids.
  */
 export declare function quotaTierFor(provider: string, model: string): string | undefined;
+/** UTC offset for a provider's timezone-naive absolute retry-reset timestamps. */
+export declare function retryResetTimezoneOffsetFor(provider: string): string | undefined;
 /** Whether a provider has catalog-authored model quota scopes. */
 export declare function hasQuotaTierPolicy(provider: string): boolean;
 /** The provider-default wire model for a model-less hosted operation. */
@@ -55,11 +57,20 @@ export declare function modelLimitsFor(provider: string, model: string): {
 } | undefined;
 /** Whether a provider roster entry is a declared non-chat/unsupported SKU. */
 export declare function isExcludedModel(provider: string, model: string): boolean;
+/** Whether an exact upstream discovery mode is excluded from a provider's coding-model roster. */
+export declare function isExcludedDiscoveryMode(provider: string, mode: string): boolean;
 /**
  * Whether a provider is retired: its entire roster is excluded from the
  * generated bundle and must never be resurrected from the previous snapshot.
  */
 export declare function isRetiredProvider(provider: string): boolean;
+/**
+ * Whether a provider's bundled rows may seed cross-provider bare-id enrichment
+ * references. Gateway-namespaced providers (ClinePass) are isolated so their
+ * limits, pricing, and reasoning controls never contaminate an unrelated proxy
+ * model that happens to advertise the same bare id.
+ */
+export declare function isBareIdReferenceProvider(provider: string): boolean;
 /** The declared subscription tier required to use a provider model id, if any. */
 export declare function planRequirementFor(provider: string, model: string): string | undefined;
 /** Cross-provider pricing-peer resolution for one provider model id. */

package/dist/types/compat/cascade.d.ts

@@ -30,3 +30,13 @@ export declare function resolveCascade(target: ResolveTarget): ResolvedAxes;
  * mutable rule data. Bundled target lookups use {@link resolveCascade}.
  */
 export declare function resolveCascadeRules(cascade: CompiledCascade, target: ResolveTarget): ResolvedAxes;
+/**
+ * Whether the effort ladder this target resolves to comes from a rule scoped
+ * to the model's identity (a recognized class, family, revision, or an explicit
+ * model selector), rather than a provider/api-wide or fallback unknown-class
+ * rule that any unrecognized id at that provider inherits.
+ *
+ * Discovery reads this to tell reviewed tiers apart from a blanket default, so
+ * catalog-published tiers can correct the latter and never the former.
+ */
+export declare function hasModelScopedEffortsRule(target: ResolveTarget): boolean;

package/dist/types/compat/collapse.d.ts

@@ -124,6 +124,14 @@ export declare function deriveThinkingPairFamilies<TSpec extends VariantSpecLike
  * unrelated carriers (GitHub Copilot `-1m` context variants) never match.
  */
 export declare function isCollapsedVariantSpec(spec: VariantSpecLike): boolean;
+/**
+ * Whether a Cursor wire id names an extended tier that upstream serves only in
+ * max mode. The compiled taxonomy identifies `xhigh`/`extra-high`/`max`
+ * efforts and their optional service lanes. This is an inference, not an
+ * upstream marker: it is the only per-tier signal available for bundled rows
+ * and for routes live discovery never advertised.
+ */
+export declare function isCursorMaxModeWireId(wireModelId: string): boolean;
 /**
  * Collapse a full mixed-provider list: per provider, the compiled reviewed table, Cursor's
  * conservative live effort-sibling rule, and the automatic `X`/`X-thinking`

package/dist/types/compat/resolve.d.ts

@@ -13,3 +13,13 @@ export interface ResolvedModelPolicy<TApi extends Api = Api> {
  * complete compat record, thinking metadata, and catalog-data corrections.
  */
 export declare function resolveModelPolicy<TApi extends Api>(spec: ModelSpec<TApi>): ResolvedModelPolicy<TApi>;
+/**
+ * Whether reviewed rules know THIS model's effort ladder, as opposed to it
+ * inheriting a provider-wide default or {@link resolveThinkingPolicy} falling
+ * through to the neutral wire ladder.
+ *
+ * Discovery uses this to tell "omp knows this model's tiers" apart from "omp
+ * is guessing them", so catalog-published tiers can correct the guess without
+ * ever overriding reviewed knowledge.
+ */
+export declare function hasModelScopedEffortLadder<TApi extends Api>(spec: ModelSpec<TApi>): boolean;

package/dist/types/compat/types.d.ts

@@ -272,6 +272,11 @@ export interface CompiledExcludeModels {
     provider: string;
     match: CompiledMatchList;
 }
+/** Exact upstream discovery modes excluded from one provider's coding-model roster. */
+export interface CompiledExcludeDiscoveryModes {
+    provider: string;
+    modes: string[];
+}
 /** Provider plan-requirement tiers keyed by matcher token lists. */
 export interface CompiledPlanRequirement {
     provider: string;
@@ -289,6 +294,11 @@ export interface CompiledPricingPeer {
         peerId: string;
     }[];
 }
+/** Provider timezone assumption for offset-less absolute retry-reset timestamps. */
+export interface CompiledRetryResetTimezone {
+    provider: string;
+    offset: string;
+}
 /** Compiled runtime behavior vocabulary (`runtime/behavior.kdl`). */
 export interface CompiledBehavior {
     openaiResponsesHeuristic?: CompiledResponsesHeuristic;
@@ -299,10 +309,13 @@ export interface CompiledBehavior {
     hostedDefaults: CompiledHostedDefault[];
     apiRoutes: CompiledApiRoutes[];
     modelLimits: CompiledModelLimits[];
+    excludeDiscoveryModes: CompiledExcludeDiscoveryModes[];
     excludeModels: CompiledExcludeModels[];
     planRequirements: CompiledPlanRequirement[];
     pricingPeers: CompiledPricingPeer[];
+    retryResetTimezones: CompiledRetryResetTimezone[];
     retiredProviders: string[];
+    referenceIsolatedProviders: string[];
 }
 /**
  * A string setting from `auth/*.kdl` that may be overridden by environment
@@ -647,4 +660,12 @@ export interface ResolvedAxes {
     wire: Record<string, unknown>;
     thinking: Record<string, unknown>;
     catalog: Record<string, unknown>;
+    /**
+     * Reasoning capability after the exact-model effort upgrade: `true` when the
+     * target reported reasoning or an exact rule declares a ladder for it (the
+     * reviewed correction to metadata-less discovery rows). Compat resolvers
+     * read this instead of the raw spec flag, or one id resolves two different
+     * wire contracts depending on whether it came from discovery or the bake.
+     */
+    reasoning: boolean;
 }

package/dist/types/discovery/antigravity.d.ts

@@ -1,3 +1,4 @@
+import type { FetchImpl } from "@oh-my-pi/pi-utils";
 import { type VariantCollapseTable } from "../compat/collapse.js";
 import type { ModelSpec } from "../types.js";
 export declare const ANTIGRAVITY_PRIMARY_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
@@ -37,6 +38,7 @@ export interface AntigravityDiscoveryAgentModelSort {
 export interface AntigravityDiscoveryApiResponse {
     models?: Record<string, AntigravityDiscoveryApiModel>;
     agentModelSorts?: AntigravityDiscoveryAgentModelSort[];
+    imageGenerationModelIds?: string[];
 }
 /**
  * Options for fetching Antigravity discovery models.
@@ -53,7 +55,7 @@ export interface FetchAntigravityDiscoveryModelsOptions {
     /** Optional abort signal for request cancellation. */
     signal?: AbortSignal;
     /** Optional fetch implementation override for tests. */
-    fetcher?: typeof fetch;
+    fetcher?: FetchImpl;
     /**
      * Hand collapse table to apply to the discovered list. Defaults to the
      * Antigravity (budget-transport) table; `googleGeminiCli` passes the
@@ -68,3 +70,10 @@ export interface FetchAntigravityDiscoveryModelsOptions {
  * Returns `[]` only when the endpoint responds successfully with no usable models.
  */
 export declare function fetchAntigravityDiscoveryModels(options: FetchAntigravityDiscoveryModelsOptions): Promise<ModelSpec<"google-gemini-cli">[] | null>;
+/** Advertised image model and serving endpoint for one Antigravity account. */
+export interface AntigravityImageModel {
+    id: string;
+    endpoint: string;
+}
+/** Resolves the first image-generation model advertised by an Antigravity account. */
+export declare function fetchAntigravityImageModel(options: FetchAntigravityDiscoveryModelsOptions): Promise<AntigravityImageModel | null>;

package/dist/types/model-thinking.d.ts

@@ -35,6 +35,13 @@ export declare function mapEffortToGoogleThinkingLevel<TApi extends Api>(effort:
 /**
  * Maps a normalized thinking effort to Anthropic adaptive effort values via
  * the model's baked `thinking.effortMap` (identity for unmapped efforts).
+ *
+ * The Anthropic adaptive wire vocabulary has no `minimal` tier (valid values:
+ * `low`, `medium`, `high`, `xhigh`, `max`); a model ladder that exposes
+ * `minimal` — custom `anthropic-messages` providers do, unlike the built-in
+ * Claude ladders — would otherwise serialize `output_config.effort: "minimal"`
+ * and 400 (`level "minimal" not supported`). Clamp it to the lowest real tier,
+ * mirroring {@link mapEffortToGoogleThinkingLevel}'s `minimal` handling.
  */
 export declare function mapEffortToAnthropicAdaptiveEffort<TApi extends Api>(model: ApiModel<TApi>, effort: Effort): "low" | "medium" | "high" | "xhigh" | "max" | "adaptive";
 /**

package/dist/types/provider-models/openai-compat.d.ts

@@ -523,6 +523,8 @@ export interface FetchLiteLLMRichModelsOptions<TApi extends Api> {
 }
 export declare const OPENAI_COMPAT_DISCOVERY_DEFAULT_CONTEXT_WINDOW = 128000;
 export declare const OPENAI_COMPAT_DISCOVERY_DEFAULT_MAX_TOKENS = 32768;
+/** Exclude only known non-conversational modes; unknown and non-string modes remain selectable for aliases. */
+export declare function isSelectableLiteLLMModelMode(mode: unknown): boolean;
 export declare function normalizeLiteLLMManagementBaseUrl(baseUrl: string): string;
 export declare function resolveLiteLLMApi(entry: Record<string, unknown> | undefined, id: string, fallbackApi?: Api): Api;
 export declare function fetchLiteLLMRichModels<TApi extends Api>(options: FetchLiteLLMRichModelsOptions<TApi>): Promise<ModelSpec<TApi>[] | null>;

package/dist/types/types.d.ts

@@ -278,6 +278,12 @@ export interface OpenAICompat {
      * Default: auto-detected (DeepSeek reasoning models).
      */
     disableReasoningOnToolChoice?: boolean;
+    /**
+     * Disable reasoning whenever the request advertises function tools.
+     * Use for model surfaces that reject every tools-plus-reasoning combination.
+     * Default: false.
+     */
+    disableReasoningWithTools?: boolean;
     /** OpenRouter-specific routing preferences. Only used when baseUrl points to OpenRouter. */
     openRouterRouting?: OpenRouterRouting;
     /** Vercel AI Gateway routing preferences. Only used when baseUrl points to Vercel AI Gateway. */
@@ -372,12 +378,24 @@ export interface OpenAICompat {
     strictResponsesPairing?: boolean;
     /** Whether the Responses API accepts the `detail: "original"` image hint. Default: auto-detected (false for GitHub Copilot, which rejects it with a 400). */
     supportsImageDetailOriginal?: boolean;
+    /**
+     * Whether the Responses endpoint accepts `configuration_update` input items
+     * that change `reasoning.effort` mid-conversation while the request-level
+     * effort stays pinned for prompt caching (GPT-6 Astra). Default:
+     * rule-detected (`true` for `gpt-6-astra` on any host, `false` otherwise).
+     * Set `false` for custom `openai-responses` / `openai-codex-responses`
+     * endpoints that reject the item type with HTTP 400; effort changes are then
+     * sent as the top-level `reasoning.effort`.
+     */
+    supportsConfigurationUpdate?: boolean;
     /** Whether streamed reasoning deltas for the same field may repeat the full cumulative text snapshot. Default: false. */
     reasoningDeltasMayBeCumulative?: boolean;
     /** Strip leaked DeepSeek chat-template special tokens from visible content deltas. Default: auto-detected. */
     stripDeepseekSpecialTokens?: boolean;
     /** Heal leaked chat-template/tool-call/thinking markup from visible content deltas. Default: auto-detected. */
     streamMarkupHealingPattern?: OpenAIStreamMarkupHealingPattern;
+    /** Whether this wire may revise already-streamed text (`stream-revision` axis). Unassigned: append-only. */
+    streamRevision?: "none" | "possible";
     /** Treat an empty length-finished stream as a context-window error. Default: auto-detected. */
     emptyLengthFinishIsContextError?: boolean;
     /** Normalize tool call ids to OpenAI's 40-character limit. Default: auto-detected. */
@@ -548,6 +566,8 @@ export interface AnthropicCompat {
 export interface BedrockCompat {
     /** Whether this endpoint accepts no checkpoints, automatic caching, or explicit cachePoint blocks. */
     promptCacheMode?: "none" | "automatic" | "explicit";
+    /** Whether this wire may revise already-streamed text (`stream-revision` axis). Unassigned: append-only. */
+    streamRevision?: "none" | "possible";
     /** Whether explicit cachePoint blocks accept `ttl: "1h"`; omitted TTL means Bedrock's 5-minute default. */
     supportsLongPromptCacheRetention?: boolean;
     /**
@@ -571,6 +591,8 @@ export interface BedrockCompat {
 /** Fully-resolved Bedrock Converse prompt-cache capabilities, materialized once by `buildModel`. */
 export interface ResolvedBedrockCompat {
     promptCacheMode: NonNullable<BedrockCompat["promptCacheMode"]>;
+    /** See {@link BedrockCompat.streamRevision}. */
+    streamRevision?: BedrockCompat["streamRevision"];
     supportsLongPromptCacheRetention: boolean;
     promptCacheMinimumTokens: number;
     promptCacheMaximumCheckpoints: number;
@@ -632,6 +654,7 @@ export interface ResolvedOpenAISharedCompat {
     filterReasoningHistory: boolean;
     disableReasoningOnForcedToolChoice: boolean;
     disableReasoningOnToolChoice: boolean;
+    disableReasoningWithTools?: boolean;
     supportsToolChoice: boolean;
     supportsForcedToolChoice: boolean;
     supportsNamedToolChoice: boolean;
@@ -649,6 +672,8 @@ export interface ResolvedOpenAISharedCompat {
     requiresAssistantContentForToolCalls: boolean;
     stripDeepseekSpecialTokens: boolean;
     streamMarkupHealingPattern?: OpenAIStreamMarkupHealingPattern;
+    /** See {@link OpenAICompat.streamRevision}. */
+    streamRevision?: OpenAICompat["streamRevision"];
     /** See {@link OpenAICompat.streamFirstEventTimeoutMs}. */
     streamFirstEventTimeoutMs?: number;
     reasoningDeltasMayBeCumulative: boolean;
@@ -689,7 +714,7 @@ export interface ResolvedOpenAISharedCompat {
  * `buildModel`; request handlers read fields and never detect, resolve, or
  * allocate.
  */
-export type ResolvedOpenAICompat = ResolvedOpenAISharedCompat & Required<Omit<OpenAICompat, "supportsDeveloperRole" | "supportsReasoningEffort" | "reasoningEffortMap" | "supportsReasoningParams" | "supportsReasoningSummary" | "supportsSamplingParams" | "supportsPenaltyAndStopParams" | "thinkingFormat" | "kimiApiFormat" | "reasoningDisableMode" | "omitReasoningEffort" | "includeEncryptedReasoning" | "filterReasoningHistory" | "disableReasoningOnForcedToolChoice" | "disableReasoningOnToolChoice" | "supportsToolChoice" | "supportsForcedToolChoice" | "supportsNamedToolChoice" | "reasoningContentField" | "requiresReasoningContentForToolCalls" | "requiresReasoningContentForAllAssistantTurns" | "allowsSyntheticReasoningContentForToolCalls" | "replayReasoningContent" | "qwenPreserveThinking" | "qwenTemplateReasoningEffort" | "requiresThinkingAsText" | "requiresMistralToolIds" | "requiresToolResultName" | "requiresAssistantAfterToolResult" | "requiresAssistantContentForToolCalls" | "stripDeepseekSpecialTokens" | "streamMarkupHealingPattern" | "reasoningDeltasMayBeCumulative" | "emptyLengthFinishIsContextError" | "usesOpenAIToolCallIdLimit" | "promptCacheSessionHeader" | "supportsPromptCacheBreakpoints" | "promptCacheBreakpointTtl" | "openRouterRouting" | "isOpenRouterHost" | "supportsStrictMode" | "supportsLongPromptCacheRetention" | "alwaysSendMaxTokens" | "clampOutputToModelMax" | "wireModelIdMode" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "toolSchemaFlavor" | "streamFirstEventTimeoutMs" | "streamIdleTimeoutMs" | "cacheControlFormat" | "thinkingKeep" | "strictResponsesPairing" | "supportsImageDetailOriginal" | "stripImageInput" | "thinkingLoopGuard" | "whenThinking">> & {
+export type ResolvedOpenAICompat = ResolvedOpenAISharedCompat & Required<Omit<OpenAICompat, "supportsDeveloperRole" | "supportsReasoningEffort" | "reasoningEffortMap" | "supportsReasoningParams" | "supportsReasoningSummary" | "supportsSamplingParams" | "supportsPenaltyAndStopParams" | "thinkingFormat" | "kimiApiFormat" | "reasoningDisableMode" | "omitReasoningEffort" | "includeEncryptedReasoning" | "filterReasoningHistory" | "disableReasoningOnForcedToolChoice" | "disableReasoningOnToolChoice" | "disableReasoningWithTools" | "supportsToolChoice" | "supportsForcedToolChoice" | "supportsNamedToolChoice" | "reasoningContentField" | "requiresReasoningContentForToolCalls" | "requiresReasoningContentForAllAssistantTurns" | "allowsSyntheticReasoningContentForToolCalls" | "replayReasoningContent" | "qwenPreserveThinking" | "qwenTemplateReasoningEffort" | "requiresThinkingAsText" | "requiresMistralToolIds" | "requiresToolResultName" | "requiresAssistantAfterToolResult" | "requiresAssistantContentForToolCalls" | "stripDeepseekSpecialTokens" | "streamMarkupHealingPattern" | "reasoningDeltasMayBeCumulative" | "emptyLengthFinishIsContextError" | "usesOpenAIToolCallIdLimit" | "promptCacheSessionHeader" | "supportsPromptCacheBreakpoints" | "promptCacheBreakpointTtl" | "openRouterRouting" | "isOpenRouterHost" | "supportsStrictMode" | "supportsLongPromptCacheRetention" | "alwaysSendMaxTokens" | "clampOutputToModelMax" | "wireModelIdMode" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "toolSchemaFlavor" | "streamFirstEventTimeoutMs" | "streamIdleTimeoutMs" | "streamRevision" | "cacheControlFormat" | "thinkingKeep" | "strictResponsesPairing" | "supportsImageDetailOriginal" | "supportsConfigurationUpdate" | "stripImageInput" | "thinkingLoopGuard" | "whenThinking">> & {
     vercelGatewayRouting?: OpenAICompat["vercelGatewayRouting"];
     extraBody?: OpenAICompat["extraBody"];
     cacheControlFormat?: OpenAICompat["cacheControlFormat"];
@@ -988,6 +1013,16 @@ export interface Model<TApi extends Api = Api> {
     gitlabDuoWorkflowRootNamespaceId?: string;
     /** Cursor `max_mode` request flag returned by `GetUsableModels` for premium models that require max mode. */
     cursorMaxMode?: boolean;
+    /**
+     * Per-wire-id `max_mode` markers for the members a collapsed Cursor row
+     * routes to, recorded by `collapseVariants` from live `GetUsableModels`
+     * rows. {@link cursorMaxMode} on a collapsed row is an OR across members,
+     * so it cannot tell a `-low` route that needs no max mode from an Opus
+     * `-fast` route that does; transports look the routed wire id up here
+     * first. Absent on raw rows (their own `cursorMaxMode` already describes
+     * their single wire id) and on bundled snapshots that predate discovery.
+     */
+    cursorMaxModeRoutes?: Readonly<Record<string, boolean>>;
     cost: ModelCost;
     /** Premium Copilot requests charged per user-initiated request (defaults to 1). */
     premiumMultiplier?: number;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-catalog",
-	"version": "18.2.0",
+	"version": "18.2.2",
 	"description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -35,12 +35,12 @@
 		"gen:proto": "bun scripts/generate-protocols.ts"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.2.0",
-		"@oh-my-pi/pi-utils": "18.2.0"
+		"@oh-my-pi/omptype": "18.2.2",
+		"@oh-my-pi/pi-utils": "18.2.2"
 	},
 	"devDependencies": {
 		"@bgotink/kdl": "0.4.0",
-		"@oh-my-pi/pi-ai": "18.2.0",
+		"@oh-my-pi/pi-ai": "18.2.2",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {

package/src/build.ts

@@ -24,6 +24,41 @@ function objectPayload(value: unknown): object | undefined {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
 }
 
+/**
+ * Overwrite seeded fallback rates with the latest dated card whose
+ * `effectiveFrom` is already due. Leaves the seed unchanged when no card
+ * has started, and never attaches a `timeBased` tariff.
+ */
+function applyEffectiveFallbackRates(
+	cost: { input: number; output: number; cacheRead: number; cacheWrite: number },
+	effectiveRates: unknown,
+	now = Date.now(),
+): void {
+	const rates = objectPayload(effectiveRates);
+	if (rates === undefined) return;
+	let latestFrom = Number.NEGATIVE_INFINITY;
+	let latest: object | undefined;
+	for (const entry of Object.values(rates)) {
+		const payload = objectPayload(entry);
+		if (payload === undefined) continue;
+		const date = Reflect.get(payload, "effectiveFrom");
+		if (typeof date !== "string") continue;
+		const from = Date.parse(date);
+		if (!Number.isFinite(from) || from > now || from < latestFrom) continue;
+		latestFrom = from;
+		latest = payload;
+	}
+	if (latest === undefined) return;
+	const input = numberField(latest, "input");
+	if (input !== undefined) cost.input = input;
+	const output = numberField(latest, "output");
+	if (output !== undefined) cost.output = output;
+	const cacheRead = numberField(latest, "cacheRead");
+	if (cacheRead !== undefined) cost.cacheRead = cacheRead;
+	const cacheWrite = numberField(latest, "cacheWrite");
+	if (cacheWrite !== undefined) cost.cacheWrite = cacheWrite;
+}
+
 /** Narrow a compiled `input-modalities` axis value to the model input union. */
 function isInputModalities(value: unknown): value is ("text" | "image")[] {
 	return Array.isArray(value) && value.every(entry => entry === "text" || entry === "image");
@@ -139,6 +174,30 @@ export function applyCatalogCorrections(
 		const cacheWrite = numberField(patch, "cacheWrite");
 		if (cacheWrite !== undefined) model.cost.cacheWrite = cacheWrite;
 	}
+	const fallback = objectPayload(catalog.costFallback);
+	if (fallback !== undefined) {
+		const base = model.cost;
+		const hasTokenPrice = base.input !== 0 || base.output !== 0 || base.cacheRead !== 0 || base.cacheWrite !== 0;
+		if (!hasTokenPrice) {
+			// Upstream reported no token price (plan-included or promo-free
+			// rows): seed the reviewed list price instead of overwriting real
+			// discovery data the way `cost-patch` would.
+			model.cost = { ...model.cost };
+			const input = numberField(fallback, "input");
+			if (input !== undefined) model.cost.input = input;
+			const output = numberField(fallback, "output");
+			if (output !== undefined) model.cost.output = output;
+			const cacheRead = numberField(fallback, "cacheRead");
+			if (cacheRead !== undefined) model.cost.cacheRead = cacheRead;
+			const cacheWrite = numberField(fallback, "cacheWrite");
+			if (cacheWrite !== undefined) model.cost.cacheWrite = cacheWrite;
+			// Dated fallback rates overwrite the seeded numbers when they have
+			// already taken effect. They are not a recurring tariff: wrapping
+			// them in `timeBased` with empty peak windows would report
+			// permanent off-peak and never wake at the dated boundary.
+			applyEffectiveFallbackRates(model.cost, Reflect.get(fallback, "effectiveRates"));
+		}
+	}
 	if (catalog.timeBased !== undefined) {
 		model.cost = { ...model.cost, timeBased: materializeTimeBasedCost(catalog.timeBased) };
 	}

package/src/compat/axes.ts

@@ -93,6 +93,7 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	"clamp-output-to-model-max": wire("clampOutputToModelMax", OAI),
 	"disable-reasoning-on-forced-tool-choice": wire("disableReasoningOnForcedToolChoice", OAI),
 	"disable-reasoning-on-tool-choice": wire("disableReasoningOnToolChoice", OAI),
+	"disable-reasoning-with-tools": wire("disableReasoningWithTools", ["openai"]),
 	"drop-thinking-when-reasoning-effort": wire("dropThinkingWhenReasoningEffort", ["openai"]),
 	"empty-length-finish-is-context-error": wire("emptyLengthFinishIsContextError", OAI),
 	"extra-body": { ...wire("extraBody", ["openai"], "object"), verbatimKeys: true },
@@ -235,6 +236,19 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	"supports-function-part-id": wire("supportsFunctionPartId", ["google"]),
 
 	// ── wire: shared across surfaces ──
+	/**
+	 * Whether this wire may revise text it has already streamed: bytes
+	 * reclassified out of the visible channel (a leaned-on thinking opener),
+	 * carved into a tool call, reordered by content-block index, or replaced
+	 * wholesale by an authoritative final payload. Unassigned means the wire
+	 * only appends, so the transcript may retire finished lines into native
+	 * scrollback while the turn is still streaming (see
+	 * `AssistantMessageComponent`). Declare `possible` only with a citable
+	 * mechanism: the renderer also verifies published rows every frame and stops
+	 * retiring the block on the first mismatch, so this axis decides where
+	 * mid-stream retirement is attempted, not whether it is safe.
+	 */
+	"stream-revision": wire("streamRevision", [...OAI, "bedrock"], "scalar", ["none", "possible"]),
 	"stream-first-event-timeout-ms": wire("streamFirstEventTimeoutMs", [...OAI, "google"]),
 	"stream-idle-timeout-ms": wire("streamIdleTimeoutMs", [...OAI, "anthropic", "bedrock", "google"]),
 	"strip-image-input": wire("stripImageInput", [...OAI, "anthropic", "google"]),
@@ -274,6 +288,7 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	"context-promotion-target": { key: "contextPromotionTarget", set: "catalog", shape: "scalar" },
 	"context-window-floor": { key: "contextWindowFloor", set: "catalog", shape: "scalar" },
 	"cost-patch": { key: "costPatch", set: "catalog", shape: "object" },
+	"cost-fallback": { key: "costFallback", set: "catalog", shape: "object" },
 	"delegation-bias": { key: "delegationBias", set: "catalog", shape: "scalar", values: DELEGATION_BIASES },
 	"edit-prompt-variant": { key: "editPromptVariant", set: "catalog", shape: "scalar", values: ["full", "compact"] },
 	"edit-revision": { key: "editRevision", set: "catalog", shape: "scalar" },

package/src/compat/behavior.ts

@@ -2,8 +2,8 @@
  * Typed accessors over the compiled runtime-behavior vocabulary
  * (`rules/runtime/behavior.kdl`): provider/model heuristics that run before
  * or outside exact bundled-model lookup — responses routing, API routing,
- * quota tiers, plan requirements, model limits, roster exclusions, hosted
- * defaults, and pricing peers.
+ * quota tiers, plan requirements, model limits, roster and discovery-mode
+ * exclusions, hosted defaults, and pricing peers.
  */
 import { globMatch } from "./cascade";
 import rules from "./rules.json";
@@ -103,6 +103,11 @@ export function quotaTierFor(provider: string, model: string): string | undefine
 	return undefined;
 }
 
+/** UTC offset for a provider's timezone-naive absolute retry-reset timestamps. */
+export function retryResetTimezoneOffsetFor(provider: string): string | undefined {
+	return behavior.retryResetTimezones.find(rule => rule.provider === provider)?.offset;
+}
+
 /** Whether a provider has catalog-authored model quota scopes. */
 export function hasQuotaTierPolicy(provider: string): boolean {
 	return behavior.quotaTiers.some(rule => rule.provider === provider);
@@ -176,6 +181,11 @@ export function isExcludedModel(provider: string, model: string): boolean {
 	return behavior.excludeModels.some(rule => rule.provider === provider && matchesList(rule.match, lower, lower));
 }
 
+/** Whether an exact upstream discovery mode is excluded from a provider's coding-model roster. */
+export function isExcludedDiscoveryMode(provider: string, mode: string): boolean {
+	return behavior.excludeDiscoveryModes.some(rule => rule.provider === provider && rule.modes.includes(mode));
+}
+
 /**
  * Whether a provider is retired: its entire roster is excluded from the
  * generated bundle and must never be resurrected from the previous snapshot.
@@ -184,6 +194,16 @@ export function isRetiredProvider(provider: string): boolean {
 	return behavior.retiredProviders.includes(provider);
 }
 
+/**
+ * Whether a provider's bundled rows may seed cross-provider bare-id enrichment
+ * references. Gateway-namespaced providers (ClinePass) are isolated so their
+ * limits, pricing, and reasoning controls never contaminate an unrelated proxy
+ * model that happens to advertise the same bare id.
+ */
+export function isBareIdReferenceProvider(provider: string): boolean {
+	return !behavior.referenceIsolatedProviders.includes(provider);
+}
+
 /** The declared subscription tier required to use a provider model id, if any. */
 export function planRequirementFor(provider: string, model: string): string | undefined {
 	const rule = behavior.planRequirements.find(candidate => candidate.provider === provider);

package/src/compat/cascade.ts

@@ -293,6 +293,7 @@ function cloneAxes(axes: ResolvedAxes): ResolvedAxes {
 		wire: cloneAxisRecord(axes.wire),
 		thinking: cloneAxisRecord(axes.thinking),
 		catalog: cloneAxisRecord(axes.catalog),
+		reasoning: axes.reasoning,
 	};
 }
 
@@ -324,9 +325,33 @@ export function resolveCascadeRules(cascade: CompiledCascade, target: ResolveTar
 	return cloneAxes(resolveOverIndex(buildRuleIndex(cascade), target));
 }
 
+/**
+ * Whether the effort ladder this target resolves to comes from a rule scoped
+ * to the model's identity (a recognized class, family, revision, or an explicit
+ * model selector), rather than a provider/api-wide or fallback unknown-class
+ * rule that any unrecognized id at that provider inherits.
+ *
+ * Discovery reads this to tell reviewed tiers apart from a blanket default, so
+ * catalog-published tiers can correct the latter and never the former.
+ */
+export function hasModelScopedEffortsRule(target: ResolveTarget): boolean {
+	const winners: WinnerTable = {};
+	for (const { rule, rank } of rankRelevantRules(getRuleIndex(), prepareTarget(target))) {
+		contest(winners, rule.compiled.thinking, rank, rule, target);
+	}
+	const winner = winners.efforts?.rule.compiled;
+	if (winner === undefined) return false;
+	return (
+		(winner.class !== undefined && winner.class !== "unknown") ||
+		winner.family !== undefined ||
+		winner.revision !== undefined ||
+		winner.models !== undefined
+	);
+}
+
 function resolveOverIndex(index: RuleIndex, target: ResolveTarget): ResolvedAxes {
 	const ranked = rankRelevantRules(index, prepareTarget(target));
-	let reasoning = target.reasoning;
+	let reasoning = target.reasoning === true;
 	if (!reasoning) {
 		for (const { rule, rank } of ranked) {
 			if (rule.hasExactEffortsRule && rank[0] === 2) {
@@ -347,5 +372,6 @@ function resolveOverIndex(index: RuleIndex, target: ResolveTarget): ResolvedAxes
 		wire: collect(wire, rule => rule.wire),
 		thinking: collect(thinking, rule => rule.thinking),
 		catalog: collect(catalog, rule => rule.catalog),
+		reasoning,
 	};
 }