@oh-my-pi/pi-catalog 16.0.5 → 16.0.7

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 ## [Unreleased]
 
+## [16.0.7] - 2026-06-18
+
+### Fixed
+
+- Fixed MiniMax Anthropic-compatible M2/M3 thinking metadata to expose the adaptive transport and keep M2 mandatory reasoning floored ([#2928](https://github.com/can1357/oh-my-pi/issues/2928)).
+
+## [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

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

@@ -1,4 +1,4 @@
-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.
@@ -9,6 +9,7 @@ interface OpenAIResponsesSpecLike {
     provider: string;
     name: string;
     baseUrl: string;
+    reasoning?: boolean;
     compat?: OpenAICompat;
 }
 /**
@@ -23,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/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`,

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

@@ -63,7 +63,7 @@ export declare function mapEffortToGoogleThinkingLevel(effort: Effort): "MINIMAL
  * Maps a normalized thinking effort to Anthropic adaptive effort values via
  * the model's baked `thinking.effortMap` (identity for unmapped efforts).
  */
-export declare function mapEffortToAnthropicAdaptiveEffort<TApi extends Api>(model: ApiModel<TApi>, effort: Effort): "low" | "medium" | "high" | "xhigh" | "max";
+export declare function mapEffortToAnthropicAdaptiveEffort<TApi extends Api>(model: ApiModel<TApi>, effort: Effort): "low" | "medium" | "high" | "xhigh" | "max" | "adaptive";
 /**
  * Resolves the upstream wire model id for a request at the given effort
  * (`undefined` = thinking off). Collapsed effort-tier variants route through

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";
@@ -117,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.
@@ -163,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. */
@@ -203,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).
@@ -230,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
@@ -331,41 +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" | "enableGeminiThinkingLoopGuard" | "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;
-    /** See {@link OpenAICompat.enableGeminiThinkingLoopGuard}. Set by the builder from the family classifier. */
-    enableGeminiThinkingLoopGuard?: 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>>;
-    /** See {@link OpenAICompat.enableGeminiThinkingLoopGuard}. */
-    enableGeminiThinkingLoopGuard?: boolean;
+    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> & {
     /**
@@ -377,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/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-catalog",
-	"version": "16.0.5",
+	"version": "16.0.7",
 	"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.5",
+		"@oh-my-pi/pi-utils": "16.0.7",
+		"arktype": "^2.2.0",
 		"zod": "^4"
 	},
 	"devDependencies": {
-		"@oh-my-pi/pi-ai": "16.0.5",
+		"@oh-my-pi/pi-ai": "16.0.7",
 		"@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":