@oh-my-pi/pi-catalog 18.10.2 → 18.10.4

package/CHANGELOG.md

@@ -2,6 +2,67 @@
 
 ## [Unreleased]
 
+## [18.10.4] - 2026-10-13
+
+### Added
+
+- Added Muse Code's subscription-only Muse Wonder Full and Wonder contributor tiers with the `max` effort, recording API-equivalent cost instead of $0: Wonder Full at Muse Wonder's $4 input / $0.20 cached / $20 output per 1M tokens, contributor tiers at the measured $1.60 / $0.08 / $8 ([#15522](https://github.com/can1357/oh-my-pi/pull/15522) by [@eggpeat](https://github.com/eggpeat))
+- Added the `classifier-cot-extraction` rule axis, set for Claude, marking models whose classifier refuses earlier reasoning quoted back into their input ([#15436](https://github.com/can1357/oh-my-pi/pull/15436) by [@will-bogusz](https://github.com/will-bogusz))
+- Added Gemini 4 Argon pricing on Cursor ($2 input / $0.10 cached / $10 output per 1M tokens) and Google Antigravity, which now uses Google's first-party rate instead of showing $0 ([#15620](https://github.com/can1357/oh-my-pi/pull/15620) by [@eggpeat](https://github.com/eggpeat))
+- Added scheduled list-price changes to `cost-patch`, as `cost-fallback` already allowed: a dated `effective-rates` card sets the price from its date, and each request is priced at the card in force when it was made, even on models loaded before the change, on rebuilt models, and on Cursor lanes priced from a sibling's card. A malformed dated card now fails the model build instead of silently keeping the old price. `getEffectiveTokenCost` returns that card for price displays, and `hasRecurringTariff` tells these dated-only schedules apart from peak/off-peak tariffs, which alone show a status-line arrow ([#15620](https://github.com/can1357/oh-my-pi/pull/15620) by [@eggpeat](https://github.com/eggpeat))
+
+### Changed
+
+- Devin models with a long-context price tier (GPT-5.4 through 5.6 standard lanes, GPT-6 through 6.1, Gemini Pro, and Grok 4.5 through 4.7) now default to a 272K or 200K context window, where that pricing starts; run `/extended-context on` to use the full window at long-context rates ([#14891](https://github.com/can1357/oh-my-pi/pull/14891) by [@eggpeat](https://github.com/eggpeat)).
+- Devin SWE-2, SWE-1.7, and GLM-5.2 fallback pricing no longer charges cache writes at the input rate, since Devin publishes no cache-write rate for them ([#14891](https://github.com/can1357/oh-my-pi/pull/14891) by [@eggpeat](https://github.com/eggpeat)).
+- Google Antigravity now lists Gemini 4 Argon once, with selectable low, medium, and high thinking levels, instead of a separate entry per thinking tier ([#15620](https://github.com/can1357/oh-my-pi/pull/15620) by [@eggpeat](https://github.com/eggpeat))
+- Gemini 4 Argon on Google, Vertex, Google Antigravity, and Cursor moves to Google's $4 input / $0.20 cached / $20 output list price on 2026-12-01 (midnight US Pacific), including requests on models loaded before then, without a catalog update ([#15620](https://github.com/can1357/oh-my-pi/pull/15620) by [@eggpeat](https://github.com/eggpeat))
+- Devin SWE-2's promotional fallback price now ends on 2027-01-01 for requests on models loaded before then too ([#15620](https://github.com/can1357/oh-my-pi/pull/15620) by [@eggpeat](https://github.com/eggpeat))
+
+### Fixed
+
+- Fixed Devin Claude and GPT-5.6 through GPT-6 models pricing prompt-cache writes at $0; they now use Devin's published rate of 1.25x input, and Adaptive uses its input rate ([#14891](https://github.com/can1357/oh-my-pi/pull/14891) by [@eggpeat](https://github.com/eggpeat)).
+- Fixed Devin GPT-5.4 through GPT-6.1, Gemini Pro, and Grok 4.5 through 4.7 models missing the long-context price tiers Devin publishes above 272K and 200K prompt tokens ([#14891](https://github.com/can1357/oh-my-pi/pull/14891) by [@eggpeat](https://github.com/eggpeat)).
+- Fixed Devin Fusion pairings ignoring their lead model's rules, including its cache-write rate and long-context tier ([#14891](https://github.com/can1357/oh-my-pi/pull/14891) by [@eggpeat](https://github.com/eggpeat)).
+- Fixed Kilo and NanoGPT models showing stale or missing prices (for example Gemini 4 Argon at $4/$20 instead of $2/$10, and many models at $0); prices now come from each gateway's live model list ([#15623](https://github.com/can1357/oh-my-pi/pull/15623) by [@eggpeat](https://github.com/eggpeat))
+- Fixed NanoGPT models showing their raw id as the name and no context window (disabling auto-compaction) when the bundled catalog lacked them; names, context windows and output limits now come from NanoGPT's live model list ([#15623](https://github.com/can1357/oh-my-pi/pull/15623) by [@eggpeat](https://github.com/eggpeat))
+
+### Removed
+
+- Removed the Codex `toolMode` model field (`code_mode_only`); Codex discovery no longer maps `tool_mode`
+
+## [18.10.3] - 2026-10-12
+
+### Breaking Changes
+
+- `resolveInlineImageByteBudget(model, officialEndpoint)` and `resolveImageCountBudget(model, officialEndpoint)` take whether the request reaches the official endpoint instead of reading `compat.officialEndpoint`, which misses request-time reroutes such as `ANTHROPIC_BASE_URL`; pass pi-ai's `reachesOfficialEndpoint(model)` ([#15434](https://github.com/can1357/oh-my-pi/pull/15434) by [@will-bogusz](https://github.com/will-bogusz))
+
+### Added
+
+- Added Muse Wonder (`muse-wonder-1.0`) to Meta and Muse Code with its `minimal`–`max` effort ladder and pricing
+- Added the `thinking-unverified` rule axis: on hosts whose model list carries no capability metadata (Meta, Muse Code), unrecognized models now offer an opt-in thinking ladder (`ThinkingConfig.unverified`) instead of none
+- Added `thinking-unverified` axis for offering reasoning ladders on unclassified model IDs
+- Added `Muse Wonder 1.0` model definition to Meta provider
+- Added the opt-in `snapcompact-image-reads` axis: snapcompact images a fresh `read` result only for readers whose rule sets it; Claude Opus 5.5 and later opt in ([#14249](https://github.com/can1357/oh-my-pi/pull/14249) by [@will-bogusz](https://github.com/will-bogusz))
+- Added the `image-count-budget` rule for how many images one request may carry (Anthropic 90, Codex 200, other hosts unchanged) and the `official-image-count-budget` override that applies only on the official endpoint: Anthropic 600 (100 on 200k-window Claude models), Codex 2,000 ([#15434](https://github.com/can1357/oh-my-pi/pull/15434) by [@will-bogusz](https://github.com/will-bogusz))
+- Added a 24 MB inline-image byte budget for the Codex backend, which now counts as its official endpoint at its default URL and at paths under it such as `/codex/responses` ([#15434](https://github.com/can1357/oh-my-pi/pull/15434) by [@will-bogusz](https://github.com/will-bogusz))
+- Added `isOfficialCodexApiUrl` to `wire/codex`, moved from pi-ai ([#15434](https://github.com/can1357/oh-my-pi/pull/15434) by [@will-bogusz](https://github.com/will-bogusz))
+- Added `verified` to `image-tokenization` rules, marking the Claude 4.7+ high-res tier and the GPT-5.5 to 6.1 and gpt-6-astra rules as matching measured provider billing ([#15442](https://github.com/can1357/oh-my-pi/pull/15442) by [@will-bogusz](https://github.com/will-bogusz))
+- Added the `image-max-edge` axis and `resolveImageMaxEdge()` for hosts that shrink images before the model reads them; Cursor's Claude and GPT models and its `default` (Auto) route fit 1024×1024 ([#15448](https://github.com/can1357/oh-my-pi/pull/15448) by [@will-bogusz](https://github.com/will-bogusz))
+- Added the `thinking-replay-tokens` axis; Claude lines set it to `output` on every host, since a replayed signed thinking block bills the turn's full reasoning, not the signature's bytes ([#15446](https://github.com/can1357/oh-my-pi/pull/15446) by [@will-bogusz](https://github.com/will-bogusz))
+- Added a KDL opt-in for sibling subagent prompt-cache sharing, enabled for Muse Code's Spark 1.3, Wonder 1.0, and Wonder Full 1.0 variants over the Responses API ([#15467](https://github.com/can1357/oh-my-pi/pull/15467) by [@iliaal](https://github.com/iliaal))
+
+### Changed
+
+- Updated model definitions and compatibility rules for provider metadata
+- Google Antigravity, xAI and Cursor requests keep up to 60 images, 20 for Claude on Antigravity and Cursor, up from 5; this counts snapcompact frames and live screenshots together ([#15449](https://github.com/can1357/oh-my-pi/pull/15449) by [@will-bogusz](https://github.com/will-bogusz))
+- Snapcompact sizes archives at the frame prices measured for Antigravity Gemini (a fixed 1,089 tokens), Grok 4.6 to 4.20, and Claude Sonnet 4.6's standard tier ([#15449](https://github.com/can1357/oh-my-pi/pull/15449) by [@will-bogusz](https://github.com/will-bogusz))
+
+### Fixed
+
+- Applied `max-image-dimension` and `max-image-payload-bytes` to Google API models, and declared the 5 MiB per-image limit of Claude on Google Antigravity ([#15444](https://github.com/can1357/oh-my-pi/pull/15444) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed local token counts for OpenAI GPT-5 and later models (Codex, OpenAI, Azure, OpenRouter, Copilot and other hosts) reading about 12% low: their text is now counted with o200k_base instead of a bytes/4 estimate ([#15447](https://github.com/can1357/oh-my-pi/pull/15447) by [@will-bogusz](https://github.com/will-bogusz))
+
 ## [18.10.2] - 2026-10-12
 
 ### Added

package/README.md

@@ -47,12 +47,14 @@ The `models` subpath (also exported from the root) provides timestamp-aware pric
 | `calculateCost(model, usage, timestamp?)`                         | Updates and returns `usage.cost` using `model.cost`.                                                      |
 | `calculateUsageCost(cost, usage, timestamp?)`                     | Updates and returns `usage.cost` using a `ModelCost`.                                                     |
 | `calculateUncachedInputCost(cost, promptInputTokens, timestamp?)` | Returns the cost of a fully uncached prompt.                                                              |
-| `getTimeBasedPricingPeriod(cost, timestamp?)`                     | Returns `"peak"`, `"off-peak"`, or `undefined` without a schedule.                                        |
+| `getEffectiveTokenCost(cost, timestamp?)`                         | Returns the base card in force: the latest due effective rate, else the row's own legs.                  |
+| `getTimeBasedPricingPeriod(cost, timestamp?)`                     | Returns `"peak"`, `"off-peak"`, or `undefined` without a recurring tariff.                                |
+| `hasRecurringTariff(schedule)`                                    | Whether a `TimeBasedCost` carries a peak/off-peak tariff rather than only dated rate cards.               |
 | `getNextTimeBasedPricingTransition(cost, timestamp?)`             | Returns the next actual peak/off-peak change strictly after the timestamp, or `undefined` if none exists. |
 
 Timestamps are Unix milliseconds; omitted timestamps use the current time for scheduled pricing. Flat token prices are unaffected. Pricing selects the latest applicable effective rate card, then its long-context tier, then the peak/off-peak multiplier. A transition query concerns the recurring tariff, not dated rate-card changes.
 
-`ModelCost.timeBased` is optional typed metadata (`TimeBasedCost`): `offPeakMultiplier`, `peakWindows` (UTC `weekdays`, Sunday = 0, and start-inclusive/end-exclusive `startMinute`/`endMinute`), and optional `effectiveRates`. Each effective rate is a complete `TokenCost` with an `effectiveFrom` Unix-millisecond timestamp and optional `longContext` tier, replacing the base card from that instant.
+`ModelCost.timeBased` is optional typed metadata (`TimeBasedCost`): `offPeakMultiplier`, `peakWindows` (UTC `weekdays`, Sunday = 0, and start-inclusive/end-exclusive `startMinute`/`endMinute`), and optional `effectiveRates`. Each effective rate is a complete `TokenCost` with an `effectiveFrom` Unix-millisecond timestamp and optional `longContext` tier, replacing the base card from that instant. A schedule with no peak windows at a 1x off-peak multiplier has no recurring tariff, only dated rate cards: `cost-patch`/`cost-fallback` `effective-rates` compile to one, so a row built before a scheduled price change still prices later requests at the new card.
 
 Pass the request-start timestamp when estimating request usage, then preserve the resulting monetary amounts rather than repricing history at display time. OMP does this using the assistant message timestamp; it is an estimation convention, not a claim about server billing across boundaries. Prefer monetary costs reported by a provider when available.
 

package/dist/types/build.d.ts

@@ -9,8 +9,9 @@
 import { type Api, type Model, type ModelSpec } from "./types.js";
 /**
  * Applies reviewed catalog-data value corrections (`cost-patch`,
- * `cache-read-at-input-rate`, `limits-patch`, `long-context-cost`,
- * `context-window-floor`, `input-modalities`) onto an upstream-sourced spec. Applied by
+ * `cache-read-at-input-rate`, `cache-write-rate`, `limits-patch`,
+ * `long-context-cost`, `context-window-floor`, `input-modalities`) onto an
+ * upstream-sourced spec. Applied by
  * `buildModel` to every upstream-sourced spec; user-authored overrides are
  * recomposed after building by the override applicators, so explicit user
  * limits and pricing still win.

package/dist/types/compat/image-tokenization.d.ts

@@ -23,7 +23,7 @@ export interface OpenAiPatchTokenization {
     auto: "high" | "original";
 }
 /** One model line's image billing rule: the vendor formula and its per-model numbers. */
-export type ImageTokenization = OpenAiPatchTokenization
+export type ImageTokenization = (OpenAiPatchTokenization
 /** Anthropic 28px patches, resized to fit a padded-edge limit and a visual-token budget. */
  | {
     regime: "anthropic-patch";
@@ -34,6 +34,9 @@ export type ImageTokenization = OpenAiPatchTokenization
  | {
     regime: "fixed";
     tokens: number;
+}) & {
+    /** Provider billing was measured to match this rule; unset for docs-only rules and wire fallbacks. */
+    verified?: boolean;
 };
 /** What reads the image: a built model, any `{ id }` with optional host and identity, or just a wire `{ api }`. */
 export interface ImageTokenizationTarget {
@@ -48,5 +51,10 @@ export interface ImageTokenizationTarget {
  * unregistered API).
  */
 export declare function resolveImageTokenization(target: ImageTokenizationTarget): ImageTokenization | undefined;
+/**
+ * Longest image edge the reader's host passes to the model (`image-max-edge`),
+ * or undefined when the host keeps the image's size.
+ */
+export declare function resolveImageMaxEdge(target: ImageTokenizationTarget): number | undefined;
 /** Billed input tokens for one image of `size` under `rule`; only `openai-patch` reads `detail`. */
 export declare function imageTokens(rule: ImageTokenization, size: ImageSize, detail?: ImageDetail): number;

package/dist/types/compat/request-size.d.ts

@@ -1,7 +1,15 @@
 import type { Model } from "../types.js";
 /**
  * Maximum encoded inline-image bytes retained per request for a deployment with a documented body-size limit.
- * The axis is a host contract: a rerouted `baseUrl` (proxy, gateway) imposes its own limit, so the budget
- * applies only while the model targets its official endpoint.
+ * The axis is a host contract: a rerouted endpoint (proxy, gateway) imposes its own limit, so the budget applies
+ * only when `officialEndpoint` says the request reaches the model's official endpoint. `compat.officialEndpoint`
+ * classifies only the configured `baseUrl`; pi-ai's `reachesOfficialEndpoint` also follows request-time reroutes.
  */
-export declare function resolveInlineImageByteBudget(model: Model): number | undefined;
+export declare function resolveInlineImageByteBudget(model: Model, officialEndpoint: boolean): number | undefined;
+/**
+ * Most images one request to this deployment may carry, or `undefined` when no rule names the host. The
+ * `official-image-count-budget` axis replaces `image-count-budget` only when `officialEndpoint` says the request
+ * reaches the model's official endpoint (see {@link resolveInlineImageByteBudget}); a rerouted endpoint keeps the
+ * provider's generic budget.
+ */
+export declare function resolveImageCountBudget(model: Model, officialEndpoint: boolean): number | undefined;

package/dist/types/compat/thinking-replay.d.ts

@@ -0,0 +1,9 @@
+import type { ImageTokenizationTarget } from "./image-tokenization.js";
+/**
+ * `output`: the reasoning the signature carries, at the size its turn billed
+ * as output; the signature's own bytes are free. `signature`: the signature's
+ * bytes stand in for that reasoning.
+ */
+export type ThinkingReplayTokens = "output" | "signature";
+/** How `reader` bills replayed thinking; `signature` unless its lineage declares otherwise. */
+export declare function resolveThinkingReplayTokens(reader: ImageTokenizationTarget): ThinkingReplayTokens;

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

@@ -7,7 +7,7 @@
  * id parsing, no host matching, no compat detection per request.
  */
 import { Effort } from "./effort.js";
-import type { Api, Model, ModelSpec } from "./types.js";
+import type { Api, Model, ModelSpec, ThinkingConfig } from "./types.js";
 /**
  * Runtime helpers read baked metadata only, so they accept both pre-build
  * specs and built models.
@@ -19,6 +19,16 @@ type ApiModel<TApi extends Api = Api> = ModelSpec<TApi> | Model<TApi>;
  * controllable effort surface (`thinking: undefined`).
  */
 export declare function getSupportedEfforts<TApi extends Api>(model: ApiModel<TApi>): readonly Effort[];
+/**
+ * Neutral view of a model whose thinking ladder is unverified: `reasoning: false`
+ * and no ladder. Re-entering policy resolution starts from it (the ladder is
+ * derived output, not authored input), and requests without an effort send it so
+ * no reasoning or disable fields reach an upstream that may reject them.
+ */
+export declare function withoutUnverifiedThinking<T extends {
+    reasoning: boolean;
+    thinking?: ThinkingConfig;
+}>(model: T): T;
 /**
  * Clamps a requested thinking level against explicit model metadata.
  *

package/dist/types/models.d.ts

@@ -1,5 +1,5 @@
 import MODELS from "./models.json";
-import type { Api, KnownProvider, Model, ModelCost, ModelPricingStatus, Usage } from "./types.js";
+import type { Api, KnownProvider, Model, ModelCost, ModelPricingStatus, TimeBasedCost, TokenCost, Usage } from "./types.js";
 export type GeneratedProvider = keyof typeof MODELS;
 /** Whether `provider` has bundled rows in models.json (e.g. a provider id authored in KDL). */
 export declare function isGeneratedProvider(provider: string): provider is GeneratedProvider;
@@ -8,6 +8,21 @@ export declare function getBundledProviders(): KnownProvider[];
 export declare function getBundledModels(provider: GeneratedProvider): Model<Api>[];
 /** Resolve display semantics without mistaking an absent rate card for a free model. */
 export declare function getModelPricingStatus(model: Pick<Model<Api>, "cost" | "pricingStatus">): ModelPricingStatus;
+/**
+ * The base token card in force at `timestamp` (Unix ms, default now): the
+ * latest due `timeBased` effective rate, else the row's own legs. Price
+ * displays read this rather than the scalar legs, which keep the card current
+ * when the row was built while bundles, caches, and long sessions outlive it.
+ * Applies no long-context tier or peak/off-peak multiplier.
+ */
+export declare function getEffectiveTokenCost(cost: ModelCost, timestamp?: number): TokenCost;
+/**
+ * Whether a schedule carries a recurring peak/off-peak tariff. A schedule with
+ * no peak windows at a 1x off-peak multiplier only carries dated rate cards
+ * (`cost-patch`/`cost-fallback` `effective-rates`): its price changes on a
+ * date, never by time of day.
+ */
+export declare function hasRecurringTariff(schedule: TimeBasedCost): boolean;
 /** Return the recurring UTC tariff period, independently of its monetary multiplier. */
 export declare function getTimeBasedPricingPeriod(cost: ModelCost, timestamp?: number): "peak" | "off-peak" | undefined;
 /** Return the next actual peak/off-peak change strictly after the Unix-ms timestamp. */

package/dist/types/pricing.d.ts

@@ -1,5 +1,41 @@
-import type { TimeBasedCost } from "./types.js";
+import type { EffectiveTokenCost, ModelCost, TimeBasedCost, TokenCost } from "./types.js";
 /** Validate serialized schedules before admitting cached model rows. */
 export declare function isTimeBasedCost(value: unknown): value is TimeBasedCost;
 /** KDL object children are named records; normalize them once while constructing the model. */
 export declare function materializeTimeBasedCost(value: unknown): TimeBasedCost;
+/**
+ * The latest `effectiveRates` card of a materialized schedule due at
+ * `timestamp`, or undefined before the first one (or without a schedule).
+ */
+export declare function dueEffectiveRate(schedule: TimeBasedCost | undefined, timestamp: number): EffectiveTokenCost | undefined;
+/** A `cost-patch`/`cost-fallback` dated card: the legs it overwrites from `effectiveFrom` (Unix ms). */
+export interface DatedCostCard extends Partial<TokenCost> {
+    effectiveFrom: number;
+}
+/**
+ * Parse the compiled `effective-rates` block of a `cost-patch` or
+ * `cost-fallback` payload into dated cards, ascending by date. Throws on a
+ * malformed card, so a typo in a rule fails the build instead of silently
+ * leaving the old price in force.
+ */
+export declare function parseDatedCostCards(costAxis: unknown, axis: "cost-patch" | "cost-fallback"): DatedCostCard[];
+/**
+ * Earliest instant a rate card can name (the `Date` range minimum). A leading
+ * card from here holds the price in force before the first dated change.
+ */
+export declare const EARLIEST_EFFECTIVE_FROM = -8640000000000000;
+/** A schedule of dated rate cards alone: no peak windows, no off-peak discount. */
+export declare const NO_RECURRING_TARIFF: TimeBasedCost;
+/**
+ * A flat card plus its dated overrides as a request-time `ModelCost`: the
+ * card due at `now` in the scalar legs, and every period (a leading card for
+ * the base price, then each dated card over the previous one) in a
+ * `timeBased` schedule without a recurring tariff. The plain card when no
+ * dated card exists.
+ */
+export declare function datedCost(base: TokenCost, cards: readonly DatedCostCard[], now?: number): ModelCost;
+/**
+ * Overwrite `cost` legs with the latest dated card due at `now`. Leaves
+ * `cost` unchanged before the first card.
+ */
+export declare function applyDueDatedCostCard(cost: TokenCost, cards: readonly DatedCostCard[], now?: number): void;

package/dist/types/types.d.ts

@@ -93,6 +93,14 @@ export interface ThinkingConfig {
      * provides an explicit wire off-path.
      */
     requiresEffort?: boolean;
+    /**
+     * The catalog has no evidence this model reasons (unclassified id, no
+     * capability metadata). The ladder is offered for the user to opt into:
+     * sessions leave thinking unset until the user picks an effort, and a
+     * request without an effort goes out as non-reasoning (see
+     * `withoutUnverifiedThinking`).
+     */
+    unverified?: boolean;
 }
 export type Provider = string;
 /** Token budgets for each thinking level (token-based providers only) */
@@ -936,9 +944,11 @@ export interface ResolvedOpenAIResponsesCompat extends ResolvedOpenAISharedCompa
     isVercelGatewayHost: boolean;
     /**
      * The configured endpoint is first-party OpenAI (`provider === "openai"` on
-     * an `api.openai.com` or unset baseUrl). Gates official-only Responses
-     * behavior: default-on stateful `previous_response_id` chaining and the
-     * `text.verbosity` field.
+     * an `api.openai.com` or unset baseUrl), or the Codex backend
+     * (`openai-codex-responses` on the default Codex baseUrl). Gates platform
+     * OpenAI's official-only Responses behavior (default-on stateful
+     * `previous_response_id` chaining and the `text.verbosity` field; the Codex
+     * adapter is not governed by either gate) and host request-size budgets.
      */
     officialEndpoint: boolean;
     /** Run Harmony-protocol leak detection/mitigation on streamed output. */
@@ -1063,18 +1073,32 @@ export interface GoogleCompat {
     antigravityUsageLabel?: string;
     /** Strip image inputs before encoding (text-only serving of a multimodal id). */
     stripImageInput?: boolean;
+    /**
+     * Largest width or height a single image may carry for a Claude reader on
+     * this host (see {@link AnthropicCompat.maxImageDimension}). Setting this or
+     * {@link maxImagePayloadBytes} turns on Claude's image clamp, many-image
+     * cap included; unset leaves images as sent.
+     */
+    maxImageDimension?: number;
+    /**
+     * Largest base64 payload a single image may carry, in bytes (see
+     * {@link AnthropicCompat.maxImagePayloadBytes}).
+     */
+    maxImagePayloadBytes?: number;
     /** Thinking-loop watchdog guard family applied to streamed reasoning. */
     thinkingLoopGuard?: "gemini" | "deepseek" | "xai";
     /** See {@link BedrockCompat.supportsSamplingParams}. */
     supportsSamplingParams?: boolean;
 }
 /** Fully-resolved google-API compat view, materialized once by `buildModel`. */
-export type ResolvedGoogleCompat = Required<Omit<GoogleCompat, "streamFirstEventTimeoutMs" | "streamIdleTimeoutMs" | "thinkingLoopGuard" | "antigravityUsageLabel" | "supportsSamplingParams">> & {
+export type ResolvedGoogleCompat = Required<Omit<GoogleCompat, "streamFirstEventTimeoutMs" | "streamIdleTimeoutMs" | "thinkingLoopGuard" | "antigravityUsageLabel" | "supportsSamplingParams" | "maxImageDimension" | "maxImagePayloadBytes">> & {
     streamFirstEventTimeoutMs?: number;
     streamIdleTimeoutMs?: number;
     thinkingLoopGuard?: GoogleCompat["thinkingLoopGuard"];
     antigravityUsageLabel?: string;
     supportsSamplingParams?: boolean;
+    maxImageDimension?: number;
+    maxImagePayloadBytes?: number;
 };
 /** Sparse, user-authored compat overrides for a given API (models.json / config vocabulary). */
 export type CompatConfigOf<TApi extends Api> = TApi extends "openai-completions" | "openrouter" | "openai-responses" | "azure-openai-responses" | "openai-codex-responses" ? OpenAICompat : TApi extends "anthropic-messages" ? AnthropicCompat : TApi extends "bedrock-converse-stream" ? BedrockCompat : TApi extends "devin-agent" ? DevinCompat : TApi extends "google-generative-ai" | "google-vertex" | "google-gemini-cli" ? GoogleCompat : undefined;
@@ -1153,7 +1177,7 @@ export interface ModelCost extends TokenCost {
  * generations rather than providers: DeepSeek V3 through V4 share
  * `"deepseek-v3"`; Kimi K2 through K3 share `"kimi-k2"`.
  */
-export type ModelTokenizer = "claude-v3" | "claude-v47" | "claude-v5" | "claude-v5-sonnet" | "qwen3" | "deepseek-v3" | "kimi-k2" | "glm5";
+export type ModelTokenizer = "claude-v3" | "claude-v47" | "claude-v5" | "claude-v5-sonnet" | "qwen3" | "deepseek-v3" | "kimi-k2" | "glm5" | "o200k";
 /** One account's discovered entitlements on a model; see {@link Model.accountAccess}. */
 export interface ModelAccountAccess {
     /**
@@ -1377,8 +1401,6 @@ export interface Model<TApi extends Api = Api> {
     preferWebsockets?: boolean;
     /** Codex Responses Lite transport: send the lite marker and carry instructions/tools as input items (mirrors codex-rs `use_responses_lite`). */
     useResponsesLite?: boolean;
-    /** Codex Code Mode restriction: model expects tools routed through a programmatic exec surface (mirrors codex-rs `tool_mode`). */
-    toolMode?: "code_mode_only";
     /**
      * Service-tier ids the provider advertises for this model (Codex discovery
      * `service_tiers[].id`, e.g. `priority`, `ultrafast`). Absent when the

package/dist/types/wire/codex.d.ts

@@ -2,6 +2,8 @@
  * Constants for OpenAI Codex (ChatGPT OAuth) backend
  */
 export declare const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+/** Strict official-Codex endpoint check; exact origin or a path boundary after {@link CODEX_BASE_URL}. */
+export declare function isOfficialCodexApiUrl(baseUrl: string | undefined): boolean;
 /**
  * Pinned OpenAI Codex client version (corresponds to @openai/codex package version).
  * Updated from npm by `bun run check-spoofed-versions --update`.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-catalog",
-	"version": "18.10.2",
+	"version": "18.10.4",
 	"description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
 	"keywords": [
 		"ai",
@@ -93,12 +93,12 @@
 		"gen:proto": "bun scripts/generate-protocols.ts"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.10.2",
-		"@oh-my-pi/pi-utils": "18.10.2"
+		"@oh-my-pi/omptype": "18.10.4",
+		"@oh-my-pi/pi-utils": "18.10.4"
 	},
 	"devDependencies": {
 		"@bgotink/kdl": "0.4.0",
-		"@oh-my-pi/pi-ai": "18.10.2",
+		"@oh-my-pi/pi-ai": "18.10.4",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {