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

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [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

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/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.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.5",
+		"@oh-my-pi/pi-utils": "16.0.6",
+		"arktype": "^2.2.0",
 		"zod": "^4"
 	},
 	"devDependencies": {
-		"@oh-my-pi/pi-ai": "16.0.5",
+		"@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":

package/src/compat/openai.ts

@@ -13,13 +13,22 @@ import {
 	isClaudeModelId,
 	isDeepseekModelIdOrName,
 	isGlm52ReasoningEffortModelId,
+	isGrokReasoningEffortCapable,
 	isKimiK26ModelId,
 	isKimiModelId,
 	isMimoModelIdOrName,
 	isQwenModelId,
 	modelFamilyToken,
 } from "../identity/family";
-import type { ModelSpec, OpenAICompat, ResolvedOpenAICompat, ResolvedOpenAIResponsesCompat } from "../types";
+import type {
+	ModelSpec,
+	OpenAICompat,
+	OpenAIStreamMarkupHealingPattern,
+	ResolvedOpenAICompat,
+	ResolvedOpenAIResponsesCompat,
+	ResolvedOpenAISharedCompat,
+	ResolvedOpenRouterCompat,
+} from "../types";
 import { applyCompatOverrides } from "./apply";
 
 /** GLM coding-plan SKUs idle for minutes mid-reasoning; see `streamIdleTimeoutMs`. */
@@ -29,6 +38,76 @@ const GLM_CODING_PLAN_STREAM_IDLE_TIMEOUT_MS = 600_000;
 const DEEPSEEK_REASONING_STREAM_IDLE_TIMEOUT_MS = 300_000;
 /** Kimi K2.6 can spend several minutes reasoning before the first visible token. */
 const KIMI_K26_REASONING_STREAM_IDLE_TIMEOUT_MS = 300_000;
+const MINIMAX_PROVIDER_OR_ID_PATTERN = /minimax/i;
+const DSML_HEALING_PROVIDERS = new Set([
+	"ollama",
+	"ollama-cloud",
+	"nvidia",
+	"deepseek",
+	"fireworks",
+	"nanogpt",
+	"opencode-go",
+	"openrouter",
+]);
+
+/**
+ * Ollama's OpenAI-compatible `reasoning.effort` only accepts
+ * `high|medium|low|max|none`; OMP's `minimal`/`xhigh` levels make the server
+ * reject the turn with HTTP 400 `invalid reasoning value`. Map the two
+ * unsupported levels onto the closest accepted ones. Stamped in the compat
+ * builder (not only at discovery) so stale-cached and custom `ollama`-provider
+ * specs are backfilled on every `buildModel`, not just on a fresh
+ * `omp models refresh`. Custom OpenAI-compatible providers pointed at a local
+ * Ollama port under a different provider id are not covered — they must set
+ * `compat.reasoningEffortMap` themselves.
+ */
+const OLLAMA_REASONING_EFFORT_MAP: ResolvedOpenAISharedCompat["reasoningEffortMap"] = { minimal: "low", xhigh: "max" };
+
+/**
+ * Merge the Ollama default effort map under any explicit overrides (overrides
+ * win). No-op off the local `ollama` provider or for non-reasoning models.
+ */
+function mergeOllamaReasoningEffortMap(
+	compat: ResolvedOpenAISharedCompat,
+	provider: string,
+	reasoning: boolean | undefined,
+): void {
+	if (provider !== "ollama" || !reasoning) return;
+	compat.reasoningEffortMap = { ...OLLAMA_REASONING_EFFORT_MAP, ...compat.reasoningEffortMap };
+}
+
+function resolveReasoningDisableMode(
+	thinkingFormat: ResolvedOpenAISharedCompat["thinkingFormat"],
+): ResolvedOpenAISharedCompat["reasoningDisableMode"] {
+	switch (thinkingFormat) {
+		case "openrouter":
+			return "openrouter-enabled-false";
+		case "zai":
+			return "zai-thinking-disabled";
+		case "qwen":
+			return "qwen-enable-thinking-false";
+		case "qwen-chat-template":
+			return "qwen-template-false";
+		default:
+			return "lowest-effort";
+	}
+}
+
+function detectStreamMarkupHealingPattern(
+	provider: string,
+	modelId: string,
+): OpenAIStreamMarkupHealingPattern | undefined {
+	if (MINIMAX_PROVIDER_OR_ID_PATTERN.test(provider) || MINIMAX_PROVIDER_OR_ID_PATTERN.test(modelId)) {
+		return "thinking";
+	}
+	if (provider === "kimi-code" || provider === "moonshot" || /kimi[-/_.]?k2/i.test(modelId)) {
+		return "kimi";
+	}
+	if (isDeepseekModelIdOrName(modelId) && DSML_HEALING_PROVIDERS.has(provider)) {
+		return "dsml";
+	}
+	return undefined;
+}
 
 /**
  * OpenCode's gateways (https://opencode.ai/zen|go) gate `reasoning_content`
@@ -197,6 +276,25 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 					? DEEPSEEK_REASONING_STREAM_IDLE_TIMEOUT_MS
 					: undefined;
 
+	const wireModelIdMode: ResolvedOpenAISharedCompat["wireModelIdMode"] =
+		provider === "firepass"
+			? "firepass"
+			: provider === "fireworks"
+				? "fireworks"
+				: isOpenRouter
+					? "openrouter"
+					: "raw";
+	const thinkingFormat: ResolvedOpenAISharedCompat["thinkingFormat"] =
+		isZai || isZhipu || isMoonshotKimi || isXiaomiMimo
+			? "zai"
+			: isOpenRouter
+				? "openrouter"
+				: isQwen && isNvidiaNim
+					? "qwen-chat-template"
+					: isAlibaba || isQwen
+						? "qwen"
+						: "openai";
+
 	const compat: ResolvedOpenAICompat = {
 		supportsStore: !isNonStandard,
 		// `developer` is an OpenAI-Responses-era extension to the chat-completions schema. Almost
@@ -229,7 +327,7 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 		supportsForcedToolChoice: true,
 		maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
 		requiresToolResultName: isMistral,
-		requiresAssistantAfterToolResult: false,
+		requiresAssistantAfterToolResult: isMistral,
 		requiresThinkingAsText: isMistral,
 		requiresMistralToolIds: isMistral,
 		// Only Kimi's native hosts (Moonshot / Kimi-code, matched by `isMoonshotKimi`)
@@ -241,16 +339,11 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 		// (`chat_template_kwargs.enable_thinking`); top-level `enable_thinking`
 		// is rejected by NIM's `additionalProperties: false` request schema
 		// (issue #2299).
-		thinkingFormat:
-			isZai || isZhipu || isMoonshotKimi || isXiaomiMimo
-				? "zai"
-				: isOpenRouter
-					? "openrouter"
-					: isQwen && isNvidiaNim
-						? "qwen-chat-template"
-						: isAlibaba || isQwen
-							? "qwen"
-							: "openai",
+		thinkingFormat,
+		reasoningDisableMode: resolveReasoningDisableMode(thinkingFormat),
+		omitReasoningEffort: false,
+		includeEncryptedReasoning: true,
+		filterReasoningHistory: false,
 		thinkingKeep: usesMoonshotKimiPreservedThinking ? "all" : undefined,
 		reasoningContentField: "reasoning_content",
 		// Backends that 400 follow-up requests when prior assistant tool-call turns lack `reasoning_content`:
@@ -271,6 +364,8 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 			(isDeepseekFamily && Boolean(spec.reasoning)) ||
 			isXiaomiMimo ||
 			(isOpenRouter && Boolean(spec.reasoning)),
+		requiresReasoningContentForAllAssistantTurns:
+			((isDeepseekFamily && Boolean(spec.reasoning)) || isXiaomiMimo) && !isOpenRouter,
 		// DeepSeek V4 and Xiaomi MiMo reject synthetic reasoning_content placeholders (".") on tool-call turns.
 		// Kimi and OpenRouter accept them when actual reasoning is unavailable.
 		allowsSyntheticReasoningContentForToolCalls: (!isDeepseekFamily || !spec.reasoning) && !isXiaomiMimo,
@@ -279,20 +374,45 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 		openRouterRouting: undefined,
 		vercelGatewayRouting: undefined,
 		isOpenRouterHost: isOpenRouter,
+		wireModelIdMode,
 		isVercelGatewayHost: isVercelGateway,
 		supportsStrictMode: detectStrictModeSupport(provider, baseUrl),
 		extraBody: isDirectDeepseekReasoning ? { thinking: { type: "enabled" } } : undefined,
 		toolStrictMode: isCerebras ? "all_strict" : "mixed",
+		toolSchemaFlavor: isMoonshotNative ? "moonshot-mfjs" : undefined,
 		streamIdleTimeoutMs,
+		stripDeepseekSpecialTokens:
+			isDeepseekModelIdOrName(spec.id) && (provider === "nvidia" || provider === "deepseek"),
+		streamMarkupHealingPattern: detectStreamMarkupHealingPattern(provider, spec.id),
+		reasoningDeltasMayBeCumulative:
+			MINIMAX_PROVIDER_OR_ID_PATTERN.test(provider) || MINIMAX_PROVIDER_OR_ID_PATTERN.test(spec.id),
+		emptyLengthFinishIsContextError: provider === "ollama",
+		usesOpenAIToolCallIdLimit: provider === "openai",
+		promptCacheSessionHeader: undefined,
+		dropThinkingWhenReasoningEffort: provider === "fireworks",
 	};
 
 	applyCompatOverrides(compat, spec.compat);
+	if (spec.compat?.reasoningDisableMode === undefined) {
+		compat.reasoningDisableMode = resolveReasoningDisableMode(compat.thinkingFormat);
+	}
+	if (spec.compat?.omitReasoningEffort === undefined && !compat.supportsReasoningEffort) {
+		compat.omitReasoningEffort = true;
+	}
+	mergeOllamaReasoningEffortMap(compat, provider, spec.reasoning);
 
 	const whenThinkingPolicy =
 		spec.compat?.whenThinking ?? (isOpenCodeProvider && spec.reasoning ? OPENCODE_WHEN_THINKING : undefined);
 	if (whenThinkingPolicy) {
 		const variant: ResolvedOpenAICompat = { ...compat };
 		applyCompatOverrides(variant, whenThinkingPolicy);
+		if (whenThinkingPolicy.reasoningDisableMode === undefined) {
+			variant.reasoningDisableMode = resolveReasoningDisableMode(variant.thinkingFormat);
+		}
+		if (whenThinkingPolicy.omitReasoningEffort === undefined && !variant.supportsReasoningEffort) {
+			variant.omitReasoningEffort = true;
+		}
+		mergeOllamaReasoningEffortMap(variant, provider, spec.reasoning);
 		compat.whenThinking = variant;
 	}
 
@@ -304,6 +424,7 @@ interface OpenAIResponsesSpecLike {
 	provider: string;
 	name: string;
 	baseUrl: string;
+	reasoning?: boolean;
 	compat?: OpenAICompat;
 }
 
@@ -321,22 +442,88 @@ interface OpenAIResponsesSpecLike {
 export function buildOpenAIResponsesCompat(spec: OpenAIResponsesSpecLike): ResolvedOpenAIResponsesCompat {
 	const baseUrl = spec.baseUrl ?? "";
 	const isAzure = modelMatchesHost({ provider: spec.provider, baseUrl }, "azureOpenAI");
+	const isOpenRouter = modelMatchesHost({ provider: spec.provider, baseUrl }, "openrouter");
+	const isOpenAIUrl = hostMatchesUrl(baseUrl, "openai");
+	const id = spec.id ?? "";
+	const thinkingFormat: ResolvedOpenAISharedCompat["thinkingFormat"] = isOpenRouter ? "openrouter" : "openai";
+	const isKimiModel = id ? isKimiModelId(id) : false;
+	const isDeepseekFamily = id ? isDeepseekModelIdOrName(id) || isDeepseekModelIdOrName(spec.name) : false;
+	const reasoningCapable = Boolean(spec.reasoning);
+
 	const compat: ResolvedOpenAIResponsesCompat = {
-		supportsDeveloperRole: isAzure || hostMatchesUrl(baseUrl, "openai") || hostMatchesUrl(baseUrl, "githubCopilot"),
+		supportsDeveloperRole: isAzure || isOpenAIUrl || hostMatchesUrl(baseUrl, "githubCopilot"),
 		supportsStrictMode:
-			spec.provider === "openai" ||
-			isAzure ||
-			spec.provider === "github-copilot" ||
-			hostMatchesUrl(baseUrl, "openai"),
-		supportsReasoningEffort: true,
-		supportsLongPromptCacheRetention: hostMatchesUrl(baseUrl, "openai"),
+			spec.provider === "openai" || isAzure || spec.provider === "github-copilot" || isOpenRouter || isOpenAIUrl,
+		supportsReasoningEffort: spec.provider !== "xai-oauth" || isGrokReasoningEffortCapable(id),
+		supportsLongPromptCacheRetention: isOpenAIUrl,
 		// Azure OpenAI and GitHub Copilot Responses paths require tool results
 		// to strictly match prior tool calls when building Responses inputs.
 		strictResponsesPairing: isAzure || spec.provider === "github-copilot",
 		requiresJuiceZeroHack: spec.name.toLowerCase().startsWith("gpt-5"),
 		reasoningEffortMap: {},
+		supportsReasoningParams: true,
+		thinkingFormat,
+		reasoningDisableMode: resolveReasoningDisableMode(thinkingFormat),
+		omitReasoningEffort: false,
+		includeEncryptedReasoning: spec.provider !== "xai-oauth",
+		filterReasoningHistory: spec.provider === "xai-oauth",
+		disableReasoningOnForcedToolChoice: isKimiModel,
+		disableReasoningOnToolChoice: isDeepseekFamily && reasoningCapable && !isOpenRouter,
+		supportsToolChoice: true,
+		supportsForcedToolChoice: true,
+		reasoningContentField: "reasoning_content",
+		requiresReasoningContentForToolCalls:
+			(isKimiModel || (isDeepseekFamily && reasoningCapable) || (isOpenRouter && reasoningCapable)) &&
+			reasoningCapable,
+		requiresReasoningContentForAllAssistantTurns: isDeepseekFamily && reasoningCapable && !isOpenRouter,
+		allowsSyntheticReasoningContentForToolCalls: !isDeepseekFamily || !reasoningCapable,
+		requiresThinkingAsText: false,
+		requiresMistralToolIds: false,
+		requiresToolResultName: false,
+		requiresAssistantAfterToolResult: false,
+		requiresAssistantContentForToolCalls: isKimiModel,
+		openRouterRouting: undefined,
+		isOpenRouterHost: isOpenRouter,
+		wireModelIdMode: isOpenRouter ? "openrouter" : "raw",
+		alwaysSendMaxTokens: spec.id ? isKimiModelId(spec.id) : false,
 		enableGeminiThinkingLoopGuard: modelFamilyToken(spec.id ?? "") === "gemini",
+		supportsObfuscationOptOut: isOpenAIUrl || spec.provider === "openai",
+		stripDeepseekSpecialTokens:
+			Boolean(id) && isDeepseekModelIdOrName(id) && (spec.provider === "nvidia" || spec.provider === "deepseek"),
+		streamMarkupHealingPattern: id ? detectStreamMarkupHealingPattern(spec.provider, id) : undefined,
+		reasoningDeltasMayBeCumulative:
+			MINIMAX_PROVIDER_OR_ID_PATTERN.test(spec.provider) || (id ? MINIMAX_PROVIDER_OR_ID_PATTERN.test(id) : false),
+		emptyLengthFinishIsContextError: spec.provider === "ollama",
+		usesOpenAIToolCallIdLimit: spec.provider === "openai",
+		promptCacheSessionHeader: spec.provider === "xai-oauth" ? "x-grok-conv-id" : undefined,
 	};
 	applyCompatOverrides(compat, spec.compat);
+	if (spec.compat?.reasoningDisableMode === undefined) {
+		compat.reasoningDisableMode = resolveReasoningDisableMode(compat.thinkingFormat);
+	}
+	if (spec.compat?.omitReasoningEffort === undefined && !compat.supportsReasoningEffort) {
+		compat.omitReasoningEffort = true;
+	}
+	mergeOllamaReasoningEffortMap(compat, spec.provider, spec.reasoning);
 	return compat;
 }
+
+type ResponsesOnlyCompat = Omit<ResolvedOpenAIResponsesCompat, keyof ResolvedOpenAISharedCompat>;
+
+function pickResponsesOnly(compat: ResolvedOpenAIResponsesCompat): ResponsesOnlyCompat {
+	return {
+		supportsLongPromptCacheRetention: compat.supportsLongPromptCacheRetention,
+		strictResponsesPairing: compat.strictResponsesPairing,
+		requiresJuiceZeroHack: compat.requiresJuiceZeroHack,
+		supportsObfuscationOptOut: compat.supportsObfuscationOptOut,
+	} satisfies ResponsesOnlyCompat;
+}
+
+export function buildOpenRouterCompat(spec: ModelSpec<"openrouter">): ResolvedOpenRouterCompat {
+	const chat = buildOpenAICompat({
+		...spec,
+		api: "openai-completions",
+	} as ModelSpec<"openai-completions">);
+	const responses = buildOpenAIResponsesCompat(spec);
+	return { ...chat, ...pickResponsesOnly(responses) } as ResolvedOpenRouterCompat;
+}