@oh-my-pi/pi-catalog 16.0.4 → 16.0.6

package/CHANGELOG.md

@@ -2,6 +2,50 @@
 
 ## [Unreleased]
 
+## [16.0.6] - 2026-06-18
+
+### Added
+
+- Added a dedicated `openrouter` API type and `ResolvedOpenRouterCompat` configuration to support unified chat-completions and Responses-API compatibility for OpenRouter models
+
+### Changed
+
+- Migrated bundled OpenRouter models in the catalog from `openai-completions` to the new `openrouter` API type
+- Consolidated the resolved OpenAI compat shape: extracted a shared `ResolvedOpenAISharedCompat` core that both `ResolvedOpenAICompat` and `ResolvedOpenAIResponsesCompat` extend (each builder still computes its own per-surface value, preserving chat↔Responses divergence), added internal resolved wire-quirk fields (`wireModelIdMode`, `stripDeepseekSpecialTokens`, `reasoningDeltasMayBeCumulative`, `emptyLengthFinishIsContextError`, `usesOpenAIToolCallIdLimit`, `dropThinkingWhenReasoningEffort`, `supportsObfuscationOptOut`), and replaced `buildOpenRouterCompat`'s cast-and-copy with an exhaustive `pickResponsesOnly` composition that fails to compile if a new Responses-only field is added without handling. The public `OpenAICompat` config vocabulary is unchanged.
+- Expanded `OpenAICompat`/`ResolvedOpenAISharedCompat` with shared reasoning/history/stream/request flags (`reasoningDisableMode`, `omitReasoningEffort`, `includeEncryptedReasoning`, `filterReasoningHistory`, `requiresReasoningContentForAllAssistantTurns`, `streamMarkupHealingPattern`, `promptCacheSessionHeader`, etc.) so model/provider/gateway constraints are declared once in catalog compat and then consumed uniformly by Chat Completions and Responses endpoints.
+
+### Fixed
+
+- Changed the default compatibility builder for `openai-completions` to set `requiresAssistantAfterToolResult` to `isMistral`, enabling the synthetic assistant bridge for built-in Mistral and Devstral models.
+- Fixed local Ollama (`provider: "ollama"`) reasoning turns still failing with HTTP 400 `invalid reasoning value: "minimal"` when the model was selected from a stale `~/.omp/models.db` cache row or a hand-written config: the `minimal → low` / `xhigh → max` remap was only stamped during fresh discovery, so cached and custom specs reached the wire unmapped. The remap now lives in the OpenAI chat-completions and Responses compat builders, so every `buildModel` (including cache loads, custom specs, and the `whenThinking` variant) backfills it — no `omp models refresh` required. Custom OpenAI-compatible providers registered under a non-`ollama` provider id still need their own `compat.reasoningEffortMap`.
+- Advertised Ollama Cloud GLM-5.2 reasoning efforts as high/xhigh-only and mapped `xhigh` to native max effort ([#2911](https://github.com/can1357/oh-my-pi/pull/2911) by [@serverinspector](https://github.com/serverinspector))
+- Fixed OpenRouter pseudo-API model construction so bundled OpenRouter models resolve shared OpenAI compatibility metadata instead of an undefined compat record.
+- Fixed custom/direct `xai-oauth` Responses model specs (e.g. `grok-build`) emitting `reasoning.effort` and hitting xAI's HTTP 400: `buildOpenAIResponsesCompat` now defaults `supportsReasoningEffort` to `false` for `xai-oauth` Grok models that are off the effort-capable allowlist (`grok-3-mini`/`grok-4.20-multi-agent`/`grok-4.3`), matching the curated discovery path; explicit `compat.supportsReasoningEffort` still overrides. The allowlist moved to a shared `isGrokReasoningEffortCapable` identity helper consumed by both the compat builder and provider-model curation so the two cannot drift.
+
+## [16.0.5] - 2026-06-17
+
+### Added
+
+- Added `enableGeminiThinkingLoopGuard` to OpenAI compatibility options to allow explicit opt-in or opt-out of the Gemini thinking-loop guard for OpenAI-compatible model aliases
+- Added `LITELLM_BASE_URL` as the LiteLLM provider discovery base URL fallback, with discovery caches scoped by the resolved proxy URL and explicit provider `baseUrl` config kept at higher precedence. ([#2726](https://github.com/can1357/oh-my-pi/issues/2726))
+- Added `ThinkingConfig.effortBudgets` (per-effort thinking-budget contract baked into collapsed variants) and `ANTIGRAVITY_MODEL_WIRE_PROFILES` (`maxOutputTokens` + `model_enum` per Antigravity wire id) to mirror the captured Antigravity Cloud Code Assist client request shape.
+
+### Changed
+
+- Defaulted `enableGeminiThinkingLoopGuard` from Gemini family detection for both OpenAI completions and responses compatibility specs so Gemini models now enable the thinking-loop guard automatically
+- Updated the default Gemini CLI user-agent version fallback to 0.46.0.
+- Changed the Antigravity (`google-antigravity`, daily-cloudcode-pa) gemini-3.x collapse families to the `budget` thinking transport with the client's per-tier `thinkingBudget` (3.5 Flash low/medium/high = 1000/4000/10000, 3.1 Pro low/high = 1001/10001) and corrected 3.5 Flash effort→wire routing (medium → `gemini-3.5-flash-low`, high → `gemini-3-flash-agent`). Split the shared CCA collapse table so `google-gemini-cli` (cloudcode-pa) keeps the `google-level` `thinkingLevel` transport for official Gemini CLI parity. Stale collapsed snapshots (bundled catalog, recycled `gemini-3-flash` alias) self-heal from the hand table at collapse time, and the model cache schema is bumped to v7 to invalidate pre-budget Antigravity rows.
+- Changed the Antigravity user-agent to the `antigravity/hub/<version>` format (default `2.1.4`) to match the captured client.
+
+### Fixed
+
+- Fixed `off` effort routing for `claude-opus-4-5` and `claude-opus-4-6` to use their base model IDs when thinking is disabled
+- Fixed `gemini-2.5-flash` effort routing so all non-off effort levels resolve to `gemini-2.5-flash-thinking`
+- Fixed shared variant alias provider resolution so `resolveBareVariantAlias` reports all matching providers when model aliases are present in both CCA collapse tables
+- Routed google-antigravity default baseUrl to the stable primary daily endpoint in the catalog generator and all fallback snapshots, resolving connection drops on heavy queries.
+- Fixed MiniMax M3 dialect selection so MiniMax-family OpenAI-compatible models use the MiniMax tool-call dialect instead of generic XML. ([#2759](https://github.com/can1357/oh-my-pi/issues/2759))
+- Fixed GitHub Copilot dynamic discovery to honor plan-specific API endpoints stored in structured OAuth credentials. ([#2876](https://github.com/can1357/oh-my-pi/issues/2876))
+
 ## [16.0.4] - 2026-06-17
 
 ### Fixed

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

@@ -1,13 +1,15 @@
-import type { ModelSpec, OpenAICompat, ResolvedOpenAICompat, ResolvedOpenAIResponsesCompat } from "../types";
+import type { ModelSpec, OpenAICompat, ResolvedOpenAICompat, ResolvedOpenAIResponsesCompat, ResolvedOpenRouterCompat } from "../types";
 /**
  * Build the resolved chat-completions compat record for a model spec.
  * Provider takes precedence over URL-based detection since it's explicitly configured.
  */
 export declare function buildOpenAICompat(spec: ModelSpec<"openai-completions">): ResolvedOpenAICompat;
 interface OpenAIResponsesSpecLike {
+    id?: string;
     provider: string;
     name: string;
     baseUrl: string;
+    reasoning?: boolean;
     compat?: OpenAICompat;
 }
 /**
@@ -22,4 +24,5 @@ interface OpenAIResponsesSpecLike {
  * request-time check.
  */
 export declare function buildOpenAIResponsesCompat(spec: OpenAIResponsesSpecLike): ResolvedOpenAIResponsesCompat;
+export declare function buildOpenRouterCompat(spec: ModelSpec<"openrouter">): ResolvedOpenRouterCompat;
 export {};

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

@@ -1,4 +1,7 @@
 import type { ModelSpec } from "../types";
+import { type VariantCollapseTable } from "../variant-collapse";
+export declare const ANTIGRAVITY_PRIMARY_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
+export declare const ANTIGRAVITY_SANDBOX_ENDPOINT = "https://daily-cloudcode-pa.sandbox.googleapis.com";
 /**
  * Raw model metadata returned by Antigravity's `fetchAvailableModels` endpoint.
  */
@@ -51,6 +54,12 @@ export interface FetchAntigravityDiscoveryModelsOptions {
     signal?: AbortSignal;
     /** Optional fetch implementation override for tests. */
     fetcher?: typeof fetch;
+    /**
+     * Hand collapse table to apply to the discovered list. Defaults to the
+     * Antigravity (budget-transport) table; `googleGeminiCli` passes the
+     * level-transport table so cloudcode-pa keeps `thinkingLevel`.
+     */
+    collapseTable?: VariantCollapseTable;
 }
 /**
  * Fetches discoverable Antigravity models and normalizes them into canonical model entries.

package/dist/types/identity/dialect.d.ts

@@ -1,3 +1,3 @@
-export type Dialect = "glm" | "hermes" | "kimi" | "xml" | "anthropic" | "deepseek" | "harmony" | "pi" | "qwen3" | "gemini" | "gemma";
+export type Dialect = "glm" | "hermes" | "kimi" | "xml" | "anthropic" | "deepseek" | "harmony" | "pi" | "qwen3" | "gemini" | "gemma" | "minimax";
 export declare const FALLBACK_DIALECT: Dialect;
 export declare function preferredDialect(modelId: string): Dialect;

package/dist/types/identity/family.d.ts

@@ -22,6 +22,12 @@ export declare function isGemmaModelId(modelId: string): boolean;
 export declare function isDeepseekModelIdOrName(value: string): boolean;
 /** Xiaomi MiMo family by id or display name. */
 export declare function isMimoModelIdOrName(value: string): boolean;
+/**
+ * Grok SKUs that expose the wire `reasoning.effort` dial. Other Grok reasoners
+ * (e.g. `grok-build`, `grok-4.20-0309-reasoning`) think natively but reject the
+ * param, so callers must omit reasoning effort for them.
+ */
+export declare function isGrokReasoningEffortCapable(modelId: string): boolean;
 /**
  * MiniMax M2-generation family (M2, M2.1, M2.5, M2.7, including `-highspeed`/
  * `-lightning`/`-her`/`-turbo` variants, dotless aliases like `minimax-m21`,
@@ -32,6 +38,8 @@ export declare function isMimoModelIdOrName(value: string): boolean;
  * clamp instead. Excludes M1, M3, MiniMax-Text-01, music, hailuo, voice ids.
  */
 export declare function isMinimaxM2FamilyModelId(modelId: string): boolean;
+/** MiniMax M3 family ids in bundled/default and aggregator namespace forms. */
+export declare function isMinimaxM3FamilyModelId(modelId: string): boolean;
 /**
  * OpenAI gpt-oss family (`gpt-oss-20b`, `gpt-oss-120b`, `gpt-oss:120b`,
  * `vendor/gpt-oss-…`). The Harmony reasoning format only accepts

package/dist/types/provider-models/descriptors.d.ts

@@ -233,7 +233,7 @@ export declare const CATALOG_PROVIDERS: readonly [{
     readonly id: "openrouter";
     readonly defaultModel: "openai/gpt-5.5";
     readonly envVars: readonly ["OPENROUTER_API_KEY"];
-    readonly createModelManagerOptions: (config: ModelManagerConfig) => import("..").ModelManagerOptions<"openai-completions", unknown>;
+    readonly createModelManagerOptions: (config: ModelManagerConfig) => import("..").ModelManagerOptions<"openrouter", unknown>;
     readonly catalogDiscovery: {
         readonly label: "OpenRouter";
         readonly allowUnauthenticated: true;

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

@@ -95,11 +95,10 @@ interface XAICuratedModel {
     reasoning?: boolean;
     /**
      * Whether xAI accepts the `reasoning.effort` wire param for this model.
-     * Default true. When false: picker hides the effort dial (via
-     * getSupportedEfforts in model-thinking.ts) AND wire-side already omits
-     * the param via GROK_EFFORT_CAPABLE_PREFIXES in providers/xai-responses.ts.
-     * Must agree with that allowlist; two truths kept in sync by curated-catalog
-     * author convention until a follow-up Op: compress unifies them.
+     * Default true. When false: the picker hides the effort dial (via
+     * getSupportedEfforts in model-thinking.ts) AND the wire omits the param —
+     * both derive from `isGrokReasoningEffortCapable` (identity/family.ts), the
+     * single allowlist shared by this curated layer and the compat builder.
      */
     supportsReasoningEffort?: boolean;
     /**
@@ -235,7 +234,7 @@ export interface OpenRouterModelManagerConfig {
     baseUrl?: string;
     fetch?: FetchImpl;
 }
-export declare function openrouterModelManagerOptions(config?: OpenRouterModelManagerConfig): ModelManagerOptions<"openai-completions">;
+export declare function openrouterModelManagerOptions(config?: OpenRouterModelManagerConfig): ModelManagerOptions<"openrouter">;
 export interface ZenMuxModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;

package/dist/types/types.d.ts

@@ -1,6 +1,6 @@
 import type { Effort } from "./effort";
 export type { KnownProvider } from "./provider-models/descriptors";
-export type KnownApi = "openai-completions" | "openai-responses" | "openai-codex-responses" | "azure-openai-responses" | "anthropic-messages" | "bedrock-converse-stream" | "google-generative-ai" | "google-gemini-cli" | "google-vertex" | "ollama-chat" | "cursor-agent";
+export type KnownApi = "openai-completions" | "openai-responses" | "openrouter" | "openai-codex-responses" | "azure-openai-responses" | "anthropic-messages" | "bedrock-converse-stream" | "google-generative-ai" | "google-gemini-cli" | "google-vertex" | "ollama-chat" | "cursor-agent";
 export type Api = KnownApi | (string & {});
 /** Canonical thinking transport used by a model. */
 export type ThinkingControlMode = "effort" | "budget" | "google-level" | "anthropic-adaptive" | "anthropic-budget-effort";
@@ -33,6 +33,14 @@ export interface ThinkingConfig {
      * thinking is disabled. Missing keys fall back to `requestModelId ?? id`.
      */
     effortRouting?: Readonly<Partial<Record<Effort | "off", string>>>;
+    /**
+     * Per-effort thinking budget in tokens, baked at build time for collapsed
+     * variants whose upstream expects an explicit `thinkingBudget` instead of a
+     * value derived from the generic ladder (Antigravity Cloud Code Assist
+     * gemini-3.x). Request mapping prefers caller `thinkingBudgets`, then this
+     * map, then the provider default ladder. Only meaningful for `mode: "budget"`.
+     */
+    effortBudgets?: Readonly<Partial<Record<Effort, number>>>;
     /**
      * When true, a thinking-off request MUST explicitly suppress thinking on
      * the wire (google-level: `thinkingLevel: "MINIMAL"` + `includeThoughts:
@@ -109,6 +117,9 @@ export interface Usage {
         total: number;
     };
 }
+export type OpenAIReasoningFormat = "openai" | "openrouter" | "zai" | "qwen" | "qwen-chat-template";
+export type OpenAIReasoningDisableMode = "omit" | "lowest-effort" | "openrouter-enabled-false" | "zai-thinking-disabled" | "qwen-enable-thinking-false" | "qwen-template-false" | "juice-zero-developer-message";
+export type OpenAIStreamMarkupHealingPattern = "kimi" | "dsml" | "thinking";
 /**
  * Compatibility settings for openai-completions API.
  * Use this to override URL-based auto-detection for custom providers.
@@ -137,6 +148,13 @@ export interface OpenAICompat {
     reasoningEffortMap?: Partial<Record<Effort, string>>;
     /** Whether the provider supports `stream_options: { include_usage: true }` for token usage in streaming responses. Default: true. */
     supportsUsageInStreaming?: boolean;
+    /**
+     * Enable the Gemini thinking-loop guard (pi-ai stream layer) for this model.
+     * Defaults to true when the model id classifies as the gemini family. Set
+     * explicitly to cover an opaque OpenAI-compat proxy alias (e.g. `my-model`)
+     * that routes to Gemini, or to false to opt a gemini-family id out.
+     */
+    enableGeminiThinkingLoopGuard?: boolean;
     /** Which field to use for max tokens. Default: auto-detected from URL. */
     maxTokensField?: "max_completion_tokens" | "max_tokens";
     /** Whether tool results require the `name` field. Default: auto-detected from URL. */
@@ -148,13 +166,23 @@ export interface OpenAICompat {
     /** Whether tool call IDs must be normalized to Mistral format (exactly 9 alphanumeric chars). Default: auto-detected from URL. */
     requiresMistralToolIds?: boolean;
     /** Format for reasoning/thinking parameter. "openai" uses reasoning_effort, "openrouter" uses reasoning: { effort }, "zai" uses thinking: { type: "enabled" | "disabled" } (also used by Moonshot Kimi), "qwen" uses top-level enable_thinking, and "qwen-chat-template" uses chat_template_kwargs.enable_thinking. Default: "openai". */
-    thinkingFormat?: "openai" | "openrouter" | "zai" | "qwen" | "qwen-chat-template";
+    thinkingFormat?: OpenAIReasoningFormat;
+    /** Request-time disable encoding for the selected reasoning/thinking format. Default: derived from `thinkingFormat`. */
+    reasoningDisableMode?: OpenAIReasoningDisableMode;
+    /** Whether the provider rejects `reasoning.effort`/`reasoning_effort` even when the model reasons natively. Default: false unless reasoning effort is unsupported. */
+    omitReasoningEffort?: boolean;
+    /** Whether Responses requests should ask for encrypted reasoning replay items. Default: true. */
+    includeEncryptedReasoning?: boolean;
+    /** Whether replayed Responses history should strip native `type: "reasoning"` items before request encoding. Default: false. */
+    filterReasoningHistory?: boolean;
     /** Optional `thinking.keep` value for Z.ai/Moonshot-style thinking params. Set false to suppress auto-detected keep. Default: auto-detected. */
     thinkingKeep?: "all" | false;
     /** Which reasoning content field to emit on assistant messages. Default: auto-detected. */
     reasoningContentField?: "reasoning_content" | "reasoning" | "reasoning_text";
     /** Whether assistant tool-call messages must include reasoning content. Default: false. */
     requiresReasoningContentForToolCalls?: boolean;
+    /** Whether all assistant messages must include reasoning content. Default: false. */
+    requiresReasoningContentForAllAssistantTurns?: boolean;
     /** Whether the provider accepts a synthetic placeholder (e.g. ".") for missing reasoning_content on tool-call turns. Default: true. Set to false for providers like DeepSeek that validate the exact reasoning_content value. */
     allowsSyntheticReasoningContentForToolCalls?: boolean;
     /** Whether assistant tool-call messages must include non-empty content. Default: false. */
@@ -188,10 +216,22 @@ export interface OpenAICompat {
     vercelGatewayRouting?: VercelGatewayRouting;
     /** Extra fields to include in request body (e.g. gateway routing hints for OpenClaw-style proxies). */
     extraBody?: Record<string, unknown>;
+    /** Request-session header that should mirror the normalized prompt-cache key. Default: unset. */
+    promptCacheSessionHeader?: "x-grok-conv-id";
     /** Whether chat-completions payloads should include provider-specific prompt-cache markers. */
     cacheControlFormat?: "anthropic" | undefined;
     /** Whether the provider supports the `strict` field in tool definitions. Default: auto-detected per provider/baseUrl (conservative for unknown providers). */
     supportsStrictMode?: boolean;
+    /**
+     * Tool-schema dialect the endpoint validates `tools.function.parameters`
+     * against. `"moonshot-mfjs"` triggers Moonshot Flavored JSON Schema
+     * normalization (collapse `const`→`enum`, infer `type` on bare enums, strip
+     * unsupported validators/`prefixItems`) because Moonshot/Kimi native hosts
+     * reject standard JSON Schema constructs with HTTP 400. Default:
+     * auto-detected (`"moonshot-mfjs"` on api.moonshot.ai / api.kimi.com). Set
+     * `"none"` to opt a custom Moonshot-compatible host out.
+     */
+    toolSchemaFlavor?: "moonshot-mfjs" | "none";
     /**
      * Stream-watchdog idle-timeout floor in ms for slow reasoning hosts.
      * Default: auto-detected (GLM coding-plan hosts, direct DeepSeek reasoning).
@@ -215,6 +255,16 @@ export interface OpenAICompat {
      * Default: auto-detected (GPT-5-family model names).
      */
     requiresJuiceZeroHack?: 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;
+    /** 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. */
+    usesOpenAIToolCallIdLimit?: boolean;
     /**
      * Compat deltas applied when a request actually engages thinking mode
      * (reasoning requested and not disabled, model reasoning-capable, and not
@@ -316,37 +366,83 @@ export interface VercelGatewayRouting {
     order?: string[];
 }
 type ResolvedToolStrictMode = NonNullable<OpenAICompat["toolStrictMode"]> | "mixed";
+/**
+ * Fields whose meaning is identical across chat-completions and Responses surfaces.
+ * Each builder still computes its own per-surface value when defaults diverge.
+ */
+export interface ResolvedOpenAISharedCompat {
+    supportsDeveloperRole: boolean;
+    supportsStrictMode: boolean;
+    supportsReasoningEffort: boolean;
+    reasoningEffortMap: Partial<Record<Effort, string>>;
+    supportsReasoningParams: boolean;
+    thinkingFormat: OpenAIReasoningFormat;
+    reasoningDisableMode: OpenAIReasoningDisableMode;
+    omitReasoningEffort: boolean;
+    includeEncryptedReasoning: boolean;
+    filterReasoningHistory: boolean;
+    disableReasoningOnForcedToolChoice: boolean;
+    disableReasoningOnToolChoice: boolean;
+    supportsToolChoice: boolean;
+    supportsForcedToolChoice: boolean;
+    reasoningContentField?: OpenAICompat["reasoningContentField"];
+    requiresReasoningContentForToolCalls: boolean;
+    requiresReasoningContentForAllAssistantTurns: boolean;
+    allowsSyntheticReasoningContentForToolCalls: boolean;
+    requiresThinkingAsText: boolean;
+    requiresMistralToolIds: boolean;
+    requiresToolResultName: boolean;
+    requiresAssistantAfterToolResult: boolean;
+    requiresAssistantContentForToolCalls: boolean;
+    stripDeepseekSpecialTokens: boolean;
+    streamMarkupHealingPattern?: OpenAIStreamMarkupHealingPattern;
+    reasoningDeltasMayBeCumulative: boolean;
+    emptyLengthFinishIsContextError: boolean;
+    usesOpenAIToolCallIdLimit: boolean;
+    promptCacheSessionHeader?: OpenAICompat["promptCacheSessionHeader"];
+    /** The model sits behind OpenRouter (routing prefs and max-token omission apply). */
+    isOpenRouterHost: boolean;
+    /** Whether this endpoint needs a max-token field even when caller did not set one. */
+    alwaysSendMaxTokens: boolean;
+    /** See {@link OpenAICompat.enableGeminiThinkingLoopGuard}. Set by the builder from the family classifier. */
+    enableGeminiThinkingLoopGuard?: boolean;
+    openRouterRouting?: OpenAICompat["openRouterRouting"];
+    /** Provider-specific wire model-id transform applied to the base id. */
+    wireModelIdMode: "raw" | "firepass" | "fireworks" | "openrouter";
+}
 /**
  * Fully-resolved chat-completions compat view: every detected default
  * materialized and user overrides applied. Built once per model by
  * `buildModel`; request handlers read fields and never detect, resolve, or
  * allocate.
  */
-export type ResolvedOpenAICompat = Required<Omit<OpenAICompat, "openRouterRouting" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "streamIdleTimeoutMs" | "supportsLongPromptCacheRetention" | "cacheControlFormat" | "thinkingKeep" | "strictResponsesPairing" | "requiresJuiceZeroHack" | "whenThinking">> & {
-    openRouterRouting?: OpenAICompat["openRouterRouting"];
+export type ResolvedOpenAICompat = ResolvedOpenAISharedCompat & Required<Omit<OpenAICompat, "supportsDeveloperRole" | "supportsReasoningEffort" | "reasoningEffortMap" | "supportsReasoningParams" | "thinkingFormat" | "reasoningDisableMode" | "omitReasoningEffort" | "includeEncryptedReasoning" | "filterReasoningHistory" | "disableReasoningOnForcedToolChoice" | "disableReasoningOnToolChoice" | "supportsToolChoice" | "supportsForcedToolChoice" | "reasoningContentField" | "requiresReasoningContentForToolCalls" | "requiresReasoningContentForAllAssistantTurns" | "allowsSyntheticReasoningContentForToolCalls" | "requiresThinkingAsText" | "requiresMistralToolIds" | "requiresToolResultName" | "requiresAssistantAfterToolResult" | "requiresAssistantContentForToolCalls" | "stripDeepseekSpecialTokens" | "streamMarkupHealingPattern" | "reasoningDeltasMayBeCumulative" | "emptyLengthFinishIsContextError" | "usesOpenAIToolCallIdLimit" | "promptCacheSessionHeader" | "openRouterRouting" | "isOpenRouterHost" | "supportsStrictMode" | "supportsLongPromptCacheRetention" | "alwaysSendMaxTokens" | "wireModelIdMode" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "toolSchemaFlavor" | "streamIdleTimeoutMs" | "cacheControlFormat" | "thinkingKeep" | "strictResponsesPairing" | "requiresJuiceZeroHack" | "enableGeminiThinkingLoopGuard" | "whenThinking">> & {
     vercelGatewayRouting?: OpenAICompat["vercelGatewayRouting"];
     extraBody?: OpenAICompat["extraBody"];
     cacheControlFormat?: OpenAICompat["cacheControlFormat"];
     thinkingKeep?: OpenAICompat["thinkingKeep"];
     streamIdleTimeoutMs?: number;
     toolStrictMode: ResolvedToolStrictMode;
-    /** The model sits behind OpenRouter (routing prefs and max-token omission apply). */
-    isOpenRouterHost: boolean;
+    toolSchemaFlavor?: OpenAICompat["toolSchemaFlavor"];
     /** The model sits behind Vercel AI Gateway. */
     isVercelGatewayHost: boolean;
+    dropThinkingWhenReasoningEffort: boolean;
     /** Complete alternate view for thinking-engaged requests; swap pointers, never spread. */
     whenThinking?: ResolvedOpenAICompat;
 };
 /** Fully-resolved Responses-API compat view (same contract as `ResolvedOpenAICompat`). */
-export interface ResolvedOpenAIResponsesCompat {
-    supportsDeveloperRole: boolean;
-    supportsStrictMode: boolean;
-    supportsReasoningEffort: boolean;
+export interface ResolvedOpenAIResponsesCompat extends ResolvedOpenAISharedCompat {
     supportsLongPromptCacheRetention: boolean;
     strictResponsesPairing: boolean;
     requiresJuiceZeroHack: boolean;
-    reasoningEffortMap: Partial<Record<Effort, string>>;
+    supportsObfuscationOptOut: boolean;
 }
+/**
+ * OpenRouter is a pseudo API: runtime dispatch can use either Responses
+ * (default) or Chat Completions (`PI_OPENROUTER_RESPONSES=0`) with the same
+ * model object, so its resolved compat must satisfy both handlers.
+ */
+export type ResolvedOpenRouterCompat = ResolvedOpenAICompat & ResolvedOpenAIResponsesCompat;
 /** Fully-resolved anthropic-messages compat view (same contract as `ResolvedOpenAICompat`). */
 export type ResolvedAnthropicCompat = Required<AnthropicCompat> & {
     /**
@@ -358,9 +454,9 @@ export type ResolvedAnthropicCompat = Required<AnthropicCompat> & {
     officialEndpoint: boolean;
 };
 /** Sparse, user-authored compat overrides for a given API (models.json / config vocabulary). */
-export type CompatConfigOf<TApi extends Api> = TApi extends "openai-completions" | "openai-responses" | "azure-openai-responses" | "openai-codex-responses" ? OpenAICompat : TApi extends "anthropic-messages" ? AnthropicCompat : undefined;
+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 : undefined;
 /** Resolved compat for a given API: complete record, materialized once by `buildModel`. */
-export type CompatOf<TApi extends Api> = TApi extends "openai-completions" ? ResolvedOpenAICompat : TApi extends "openai-responses" | "azure-openai-responses" | "openai-codex-responses" ? ResolvedOpenAIResponsesCompat : TApi extends "anthropic-messages" ? ResolvedAnthropicCompat : undefined;
+export type CompatOf<TApi extends Api> = TApi extends "openrouter" ? ResolvedOpenRouterCompat : TApi extends "openai-completions" ? ResolvedOpenAICompat : TApi extends "openai-responses" | "azure-openai-responses" | "openai-codex-responses" ? ResolvedOpenAIResponsesCompat : TApi extends "anthropic-messages" ? ResolvedAnthropicCompat : undefined;
 export interface Model<TApi extends Api = Api> {
     id: string;
     /**

package/dist/types/variant-collapse.d.ts

@@ -46,12 +46,11 @@ export interface EffortVariantFamily {
 export interface VariantCollapseTable {
     families: readonly EffortVariantFamily[];
 }
-/**
- * Shared by `google-antigravity` and `google-gemini-cli` — both serve the
- * Antigravity discovery list (`fetchAntigravityDiscoveryModels`).
- */
+/** `google-antigravity` (daily-cloudcode-pa): Gemini 3.x on the budget transport. */
 export declare const ANTIGRAVITY_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
-/** Provider id → hand collapse table. Both CCA providers share one table. */
+/** `google-gemini-cli` (cloudcode-pa): Gemini 3.x on the level transport (official CLI parity). */
+export declare const GEMINI_CLI_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
+/** Provider id → hand collapse table. The CCA providers diverge on thinking transport. */
 export declare const VARIANT_COLLAPSE_TABLES: Readonly<Record<string, VariantCollapseTable>>;
 /**
  * The global automatic rule: derive an `X` + `X-thinking` family for every

package/dist/types/wire/gemini-headers.d.ts

@@ -9,7 +9,6 @@ export declare const getGeminiCliHeaders: (modelId?: string) => {
     "Client-Metadata": string;
 };
 export declare const ANTIGRAVITY_SYSTEM_INSTRUCTION: string;
-export declare const ANTIGRAVITY_NO_PREAMBLE_INSTRUCTION = "CRITICAL: NEVER output rule checks, formatting guidelines, constraint checklists (e.g. \"No emdashes\"), or your thinking/personality preambles in the final response. Output only the final response.";
 /**
  * Antigravity / Cloud Code Assist user agent. Lives in its own file so discovery
  * and usage code can read it without pulling the heavy google-gemini-cli provider
@@ -17,3 +16,19 @@ export declare const ANTIGRAVITY_NO_PREAMBLE_INSTRUCTION = "CRITICAL: NEVER outp
  * parse graph.
  */
 export declare let getAntigravityUserAgent: () => string;
+/**
+ * Per-wire-id Antigravity Cloud Code Assist request constants, captured from the
+ * real `antigravity/hub` client against `daily-cloudcode-pa`. `modelEnum` is the
+ * opaque `labels.model_enum` token the client tags each request with;
+ * `maxOutputTokens` is the fixed `generationConfig.maxOutputTokens` it sends
+ * regardless of the thinking budget. Keyed by the routed upstream wire id
+ * (post effort-routing), not the collapsed logical id. Checkpoint-only ids
+ * (e.g. `gemini-3.1-flash-lite`) are intentionally absent — this provider only
+ * emits agent requests.
+ */
+export interface AntigravityModelWireProfile {
+    modelEnum: string;
+    maxOutputTokens: number;
+}
+export declare const ANTIGRAVITY_MODEL_WIRE_PROFILES: Readonly<Record<string, AntigravityModelWireProfile>>;
+export declare function getAntigravityModelWireProfile(wireModelId: string): AntigravityModelWireProfile | undefined;

package/dist/types/wire/github-copilot.d.ts

@@ -25,9 +25,11 @@ export declare const COPILOT_API_HEADERS: {
 export type ParsedGitHubCopilotApiKey = {
     accessToken: string;
     enterpriseUrl?: string;
+    apiEndpoint?: string;
 };
 export declare function isPublicGitHubHost(host: string): boolean;
 export declare function normalizeGitHubCopilotEnterpriseDomain(input: string | undefined): string | undefined;
+export declare function normalizeGitHubCopilotApiEndpoint(input: string | undefined): string | undefined;
 export declare function parseGitHubCopilotApiKey(apiKeyRaw: string): ParsedGitHubCopilotApiKey;
 export declare function normalizeDomain(input: string): string | null;
 export declare function getGitHubCopilotBaseUrl(enterpriseDomain?: string): string;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-catalog",
-	"version": "16.0.4",
+	"version": "16.0.6",
 	"description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -34,11 +34,12 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-utils": "16.0.4",
+		"@oh-my-pi/pi-utils": "16.0.6",
+		"arktype": "^2.2.0",
 		"zod": "^4"
 	},
 	"devDependencies": {
-		"@oh-my-pi/pi-ai": "16.0.4",
+		"@oh-my-pi/pi-ai": "16.0.6",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {

package/src/build.ts

@@ -10,7 +10,7 @@
  * compat per request.
  */
 import { buildAnthropicCompat } from "./compat/anthropic";
-import { buildOpenAICompat, buildOpenAIResponsesCompat } from "./compat/openai";
+import { buildOpenAICompat, buildOpenAIResponsesCompat, buildOpenRouterCompat } from "./compat/openai";
 import { resolveModelThinking } from "./model-thinking";
 import type { Api, CompatOf, Model, ModelSpec } from "./types";
 import { cleanModelName } from "./utils";
@@ -28,6 +28,8 @@ export function buildModel<TApi extends Api>(spec: ModelSpec<TApi>): Model<TApi>
 
 export function buildCompat(spec: ModelSpec<Api>): CompatOf<Api> {
 	switch (spec.api) {
+		case "openrouter":
+			return buildOpenRouterCompat(spec as ModelSpec<"openrouter">);
 		case "openai-completions":
 			return buildOpenAICompat(spec as ModelSpec<"openai-completions">);
 		case "openai-responses":