@oh-my-pi/pi-catalog 17.3.7 → 17.4.0

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

@@ -3,3 +3,4 @@ export * from "./codex.js";
 export * from "./gemini.js";
 export * from "./gitlab-duo-workflow.js";
 export * from "./openai-compatible.js";
+export * from "./protobuf.js";

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

@@ -0,0 +1,102 @@
+/**
+ * High-performance, zero-builder protobuf wire codecs for @oh-my-pi/pi-catalog.
+ *
+ * Schemas are declared as static IR descriptors with near-zero module load overhead
+ * and lazy compilation on first encode/decode/create invocation.
+ */
+/** JSON values carried by `google.protobuf.Value` fields. */
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/** An unrecognised wire field retained for forward-compatible round-trips. */
+export interface ProtoUnknownField {
+    no: number;
+    wireType: number;
+    data: Uint8Array;
+}
+/** Shared internal metadata present on every decoded protocol message. */
+export interface ProtoMessage {
+    $typeName?: string;
+    $unknown?: ProtoUnknownField[];
+}
+/** A bidirectional codec for one protobuf message type. */
+export interface MessageCodec<T extends ProtoMessage = ProtoMessage> {
+    (value: T): Uint8Array;
+    (value: Uint8Array): T;
+    /** Creates a message with protobuf defaults for omitted fields. */
+    create(value?: Partial<T>): T;
+    /** Encodes one message into protobuf wire bytes. */
+    encode(value: T): Uint8Array;
+    /** Decodes one protobuf message from wire bytes. */
+    decode(value: Uint8Array): T;
+    /** Converts a message to its protobuf JSON representation. */
+    toJson(value: T): JsonValue;
+}
+/** Infers a message shape from a codec result. */
+export type InferMessage<TCodec> = TCodec extends MessageCodec<infer TMessage> ? TMessage : never;
+/** Erases a referenced message's concrete shape for static field descriptors. */
+export interface MessageReference {
+    encode(value: unknown): Uint8Array;
+    decode(value: Uint8Array): ProtoMessage;
+    toJson(value: unknown): JsonValue;
+}
+export type ScalarKind = "bool" | "bytes" | "double" | "enum" | "float" | "int32" | "int64" | "string" | "uint32" | "uint64";
+export type WireType = 0 | 1 | 2 | 5;
+export interface ScalarFieldDesc {
+    readonly no: number;
+    readonly name: string;
+    readonly kind: ScalarKind;
+    readonly optional?: boolean;
+    readonly repeat?: boolean;
+}
+export interface MessageFieldDesc {
+    readonly no: number;
+    readonly name: string;
+    readonly kind: "message";
+    readonly T: () => MessageReference;
+    readonly repeat?: boolean;
+}
+export interface EnumFieldDesc {
+    readonly no: number;
+    readonly name: string;
+    readonly kind: "enum";
+    readonly optional?: boolean;
+    readonly repeat?: boolean;
+}
+export interface MapFieldDesc {
+    readonly no: number;
+    readonly name: string;
+    readonly kind: "map";
+    readonly K: "string";
+    readonly V: ScalarKind | (() => MessageReference);
+}
+export type VariantDesc = {
+    readonly no: number;
+    readonly name: string;
+    readonly kind: ScalarKind;
+} | {
+    readonly no: number;
+    readonly name: string;
+    readonly kind: "message";
+    readonly T: () => MessageReference;
+};
+export interface OneofFieldDesc {
+    readonly kind: "oneof";
+    readonly name: string;
+    readonly variants: readonly VariantDesc[];
+}
+export type FieldDesc = ScalarFieldDesc | MessageFieldDesc | EnumFieldDesc | MapFieldDesc | OneofFieldDesc;
+/** Creates a high-performance, lazy protobuf message codec from an IR field descriptor list. */
+export declare function pb<T extends ProtoMessage = ProtoMessage>(typeName: string, fields?: readonly FieldDesc[]): MessageCodec<T>;
+/** Creates a message using its codec's protobuf defaults. */
+export declare function create<TMessage extends ProtoMessage>(codec: MessageCodec<TMessage>, value?: Partial<TMessage>): TMessage;
+/** Encodes a message using its codec. */
+export declare function toBinary<TMessage extends ProtoMessage>(codec: MessageCodec<TMessage>, value: TMessage): Uint8Array;
+/** Decodes wire bytes using a message codec. */
+export declare function fromBinary<TMessage extends ProtoMessage>(codec: MessageCodec<TMessage>, value: Uint8Array): TMessage;
+/** Converts a message to protobuf JSON using its codec. */
+export declare function toJson<TMessage extends ProtoMessage>(codec: MessageCodec<TMessage>, value: TMessage): JsonValue;
+/** Encodes a JSON value as `google.protobuf.Value`. */
+export declare function encodeJsonValue(value: JsonValue): Uint8Array;
+/** Decodes `google.protobuf.Value` wire bytes into a JSON value. */
+export declare function decodeJsonValue(value: Uint8Array): JsonValue;

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

@@ -30,6 +30,17 @@ export declare const isClaudeModelId: (modelId: string) => boolean;
 export declare const isAnthropicNamespacedModelId: (modelId: string) => boolean;
 /** Qwen family ids (substring match — Qwen SKUs have no stable prefix shape). */
 export declare const isQwenModelId: (modelId: string) => boolean;
+/**
+ * Open-weight Qwen 3.8+ releases (`qwen3.8-27b`, `qwen3.8-2.4t-a95b`, GGUF
+ * names like `Qwen3.8-27B-UD-Q6_K_XL`) whose chat template steers thinking
+ * depth through a `reasoning_effort` template kwarg (`low`/`medium`/`xhigh`,
+ * template default `xhigh`; thinking itself cannot be disabled). Compared
+ * component-wise so `qwen3.10` sorts after `qwen3.8`. API-only `-max` SKUs are
+ * excluded — Dashscope drives them through OpenAI-style `reasoning_effort`
+ * with curated compat. The trailing guard rejects parameter-count lookalikes
+ * (`qwen-3.8b`) without breaking `qwen3.8-27b`.
+ */
+export declare const isQwen38PlusTemplateEffortModelId: (modelId: string) => boolean;
 /** Gemma open-weights family (`gemma-3-27b-it`, `google/gemma-4-E2B-it`, `gemma2-9b`). */
 export declare const isGemmaModelId: (modelId: string) => boolean;
 /** DeepSeek family by id or display name (proxies often rename the id but keep the name). */
@@ -45,6 +56,8 @@ export declare const isDeepseekModelIdOrName: (modelId: string) => boolean;
 export declare const isDeepseekV4FlashModelId: (modelId: string) => boolean;
 /** Xiaomi MiMo family by id or display name. */
 export declare const isMimoModelIdOrName: (modelId: string) => boolean;
+/** StepFun Step 3.7 Flash SKU in any namespace form (`kilo/stepfun/step-3.7-flash:free`). */
+export declare const isStep37FlashModelId: (modelId: string) => boolean;
 /** Gemini family ids in any namespace form (`gemini-*`, `google/gemini-*`, `openrouter/google/gemini-…`). */
 export declare const isGeminiModelId: (modelId: string) => boolean;
 /** Grok family ids across namespace and delimiter forms (`grok-*`, `cursor-grok-*`, `xai/grok-*`). */
@@ -52,7 +65,8 @@ export declare const isGrokModelId: (modelId: 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.
+ * param, so callers must omit reasoning effort for them. `grok-4.6` accepts
+ * `low`/`medium`/`high`/`xhigh` and 400s on `max`.
  */
 export declare const isGrokReasoningEffortCapable: (modelId: string) => boolean;
 /**
@@ -187,6 +201,14 @@ export declare const hasOpus47ApiRestrictions: (modelId: string) => boolean;
  * @see https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages
  */
 export declare const supportsMidConversationSystemMessages: (modelId: string) => boolean;
+/**
+ * Models that reliably follow the hashline line-anchored edit dialect
+ * (`[path#TAG]` headers plus 1-indexed anchors). Kimi, MiMo, DeepSeek V4
+ * Flash, and Step 3.7 Flash miscount anchors or drop the tag header often
+ * enough that hosts fall back to a literal search-replace edit format for
+ * them.
+ */
+export declare const supportsHashlineEdits: (modelId: string) => boolean;
 export declare const isAnthropicFableOrMythosModel: (modelId: string) => boolean;
 /** Thinking-variant token location inside a model id. */
 export interface ThinkingVariantToken {

package/dist/types/index.d.ts

@@ -6,6 +6,7 @@ export * from "./identity/index.js";
 export * from "./model-cache.js";
 export * from "./model-manager.js";
 export * from "./model-thinking.js";
+export * from "./model-tokenizer.js";
 export * from "./models.js";
 export * from "./provider-models/index.js";
 export * from "./types.js";

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

@@ -44,8 +44,12 @@ export declare function getSupportedEfforts<TApi extends Api>(model: ApiModel<TA
  */
 export declare function clampThinkingLevelForModel<TApi extends Api>(model: ApiModel<TApi> | undefined, requested: Effort | undefined): Effort | undefined;
 export declare function requireSupportedEffort<TApi extends Api>(model: ApiModel<TApi>, effort: Effort): Effort;
-/** Maps a normalized thinking effort to Google's `thinkingLevel` enum values. */
-export declare function mapEffortToGoogleThinkingLevel(effort: Effort): "MINIMAL" | "LOW" | "MEDIUM" | "HIGH";
+/** Maps a normalized thinking effort to Google's `thinkingLevel` enum values.
+ * When a collapsed family routes `minimal` onto the same wire id as `low`
+ * (Antigravity Gemini 3.6/3.7 Flash), emit `LOW` — Cloud Code Assist rejects
+ * `MINIMAL` on those `-low` SKUs.
+ */
+export declare function mapEffortToGoogleThinkingLevel<TApi extends Api>(effort: Effort, model?: ApiModel<TApi>): "MINIMAL" | "LOW" | "MEDIUM" | "HIGH";
 /**
  * Maps a normalized thinking effort to Anthropic adaptive effort values via
  * the model's baked `thinking.effortMap` (identity for unmapped efforts).

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

@@ -0,0 +1,8 @@
+import type { ModelTokenizer } from "./types.js";
+/**
+ * Resolve the exact locally embedded tokenizer for a canonical model id.
+ *
+ * This is catalog policy, not a runtime caller heuristic: [`buildModel`](./build.ts)
+ * materializes the result as `Model.tokenizer`; consumers read that property.
+ */
+export declare function resolveModelTokenizer(modelId: string): ModelTokenizer | undefined;

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

@@ -428,6 +428,7 @@ export declare const CATALOG_PROVIDERS: readonly [{
     readonly defaultModel: "openai/gpt-oss-120b";
     readonly envVars: readonly ["COREWEAVE_API_KEY", "WANDB_API_KEY"];
     readonly createModelManagerOptions: (config: ModelManagerConfig) => import("../index.js").ModelManagerOptions<"openai-completions", unknown>;
+    readonly dynamicModelsAuthoritative: true;
     readonly catalogDiscovery: {
         readonly label: "CoreWeave Serverless Inference";
     };

package/dist/types/types.d.ts

@@ -220,6 +220,16 @@ export interface OpenAICompat {
      * Non-Qwen templates ignore the flag, so the auto-detection is safe.
      */
     qwenPreserveThinking?: boolean;
+    /**
+     * Route the requested thinking effort onto the Qwen 3.8+ chat template's
+     * `reasoning_effort` kwarg (`low`/`medium`/`xhigh`; template default
+     * `xhigh`). Emitted inside `chat_template_kwargs` for both Qwen dialects
+     * (plus the top-level field on the `qwen` dialect, which newer llama.cpp
+     * builds map natively). Without it the qwen dialects only toggle
+     * `enable_thinking` and the template always thinks at its `xhigh` default.
+     * Default: auto-detected (Qwen 3.8+ id on a local llama.cpp-style backend).
+     */
+    qwenTemplateReasoningEffort?: boolean;
     /** Whether assistant tool-call messages must include non-empty content. Default: false. */
     requiresAssistantContentForToolCalls?: boolean;
     /** Whether the provider supports the `tool_choice` parameter. Default: true. */
@@ -558,6 +568,7 @@ export interface ResolvedOpenAISharedCompat {
     allowsSyntheticReasoningContentForToolCalls: boolean;
     replayReasoningContent: boolean;
     qwenPreserveThinking: boolean;
+    qwenTemplateReasoningEffort: boolean;
     requiresThinkingAsText: boolean;
     requiresMistralToolIds: boolean;
     requiresToolResultName: boolean;
@@ -595,7 +606,7 @@ export interface ResolvedOpenAISharedCompat {
  * `buildModel`; request handlers read fields and never detect, resolve, or
  * allocate.
  */
-export type ResolvedOpenAICompat = ResolvedOpenAISharedCompat & Required<Omit<OpenAICompat, "supportsDeveloperRole" | "supportsReasoningEffort" | "reasoningEffortMap" | "supportsReasoningParams" | "supportsSamplingParams" | "supportsPenaltyAndStopParams" | "thinkingFormat" | "kimiApiFormat" | "reasoningDisableMode" | "omitReasoningEffort" | "includeEncryptedReasoning" | "filterReasoningHistory" | "disableReasoningOnForcedToolChoice" | "disableReasoningOnToolChoice" | "supportsToolChoice" | "supportsForcedToolChoice" | "supportsNamedToolChoice" | "reasoningContentField" | "requiresReasoningContentForToolCalls" | "requiresReasoningContentForAllAssistantTurns" | "allowsSyntheticReasoningContentForToolCalls" | "replayReasoningContent" | "qwenPreserveThinking" | "requiresThinkingAsText" | "requiresMistralToolIds" | "requiresToolResultName" | "requiresAssistantAfterToolResult" | "requiresAssistantContentForToolCalls" | "stripDeepseekSpecialTokens" | "streamMarkupHealingPattern" | "reasoningDeltasMayBeCumulative" | "emptyLengthFinishIsContextError" | "usesOpenAIToolCallIdLimit" | "promptCacheSessionHeader" | "supportsPromptCacheBreakpoints" | "promptCacheBreakpointTtl" | "openRouterRouting" | "isOpenRouterHost" | "supportsStrictMode" | "supportsLongPromptCacheRetention" | "alwaysSendMaxTokens" | "wireModelIdMode" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "toolSchemaFlavor" | "streamFirstEventTimeoutMs" | "streamIdleTimeoutMs" | "cacheControlFormat" | "thinkingKeep" | "strictResponsesPairing" | "supportsImageDetailOriginal" | "whenThinking">> & {
+export type ResolvedOpenAICompat = ResolvedOpenAISharedCompat & Required<Omit<OpenAICompat, "supportsDeveloperRole" | "supportsReasoningEffort" | "reasoningEffortMap" | "supportsReasoningParams" | "supportsSamplingParams" | "supportsPenaltyAndStopParams" | "thinkingFormat" | "kimiApiFormat" | "reasoningDisableMode" | "omitReasoningEffort" | "includeEncryptedReasoning" | "filterReasoningHistory" | "disableReasoningOnForcedToolChoice" | "disableReasoningOnToolChoice" | "supportsToolChoice" | "supportsForcedToolChoice" | "supportsNamedToolChoice" | "reasoningContentField" | "requiresReasoningContentForToolCalls" | "requiresReasoningContentForAllAssistantTurns" | "allowsSyntheticReasoningContentForToolCalls" | "replayReasoningContent" | "qwenPreserveThinking" | "qwenTemplateReasoningEffort" | "requiresThinkingAsText" | "requiresMistralToolIds" | "requiresToolResultName" | "requiresAssistantAfterToolResult" | "requiresAssistantContentForToolCalls" | "stripDeepseekSpecialTokens" | "streamMarkupHealingPattern" | "reasoningDeltasMayBeCumulative" | "emptyLengthFinishIsContextError" | "usesOpenAIToolCallIdLimit" | "promptCacheSessionHeader" | "supportsPromptCacheBreakpoints" | "promptCacheBreakpointTtl" | "openRouterRouting" | "isOpenRouterHost" | "supportsStrictMode" | "supportsLongPromptCacheRetention" | "alwaysSendMaxTokens" | "wireModelIdMode" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "toolSchemaFlavor" | "streamFirstEventTimeoutMs" | "streamIdleTimeoutMs" | "cacheControlFormat" | "thinkingKeep" | "strictResponsesPairing" | "supportsImageDetailOriginal" | "whenThinking">> & {
     vercelGatewayRouting?: OpenAICompat["vercelGatewayRouting"];
     extraBody?: OpenAICompat["extraBody"];
     cacheControlFormat?: OpenAICompat["cacheControlFormat"];
@@ -705,6 +716,15 @@ export interface LongContextTokenCost extends TokenCost {
 export interface ModelCost extends TokenCost {
     longContext?: LongContextTokenCost;
 }
+/**
+ * Exact local content tokenizer family for a model.
+ *
+ * Absent means no first-party local tokenizer is known and consumers retain
+ * their estimate/default-tokenizer policy. The values name tokenizer
+ * generations rather than providers: DeepSeek V3 through V4 share
+ * `"deepseek-v3"`; Kimi K2 through K3 share `"kimi-k2"`.
+ */
+export type ModelTokenizer = "claude-v3" | "claude-v47" | "claude-v5" | "claude-v5-sonnet" | "qwen3" | "deepseek-v3" | "kimi-k2" | "glm5";
 export interface Model<TApi extends Api = Api> {
     id: string;
     /**
@@ -728,6 +748,12 @@ export interface Model<TApi extends Api = Api> {
     provider: Provider;
     baseUrl: string;
     reasoning: boolean;
+    /**
+     * Exact local tokenizer family resolved from the model identity or supplied
+     * explicitly by a catalog/discovery source. Absent leaves local counting to
+     * the consumer's fallback policy.
+     */
+    tokenizer?: ModelTokenizer;
     input: ("text" | "image")[];
     /**
      * Decoder family used for image inputs when it has narrower format support

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

@@ -58,6 +58,8 @@ export declare const ANTIGRAVITY_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
 /** `google-gemini-cli` Gemini families on the official CLI's level transport. */
 export declare const GEMINI_CLI_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
 export declare const DEVIN_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
+/** `cursor` Grok families: per-effort siblings collapsed per service-tier lane. */
+export declare const CURSOR_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>>;
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-catalog",
-	"version": "17.3.7",
+	"version": "17.4.0",
 	"description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -31,15 +31,14 @@
 		"fix": "biome check --write --unsafe .",
 		"fmt": "biome format --write .",
 		"gen:models": "bun scripts/generate-models.ts",
-		"gen:cursor-proto": "protoc --plugin=protoc-gen-es=../../node_modules/.bin/protoc-gen-es --es_out=src/discovery/cursor-gen --es_opt=target=ts -I ../ai/src/providers/cursor/proto ../ai/src/providers/cursor/proto/agent.proto"
+		"gen:proto": "bun scripts/generate-protocols.ts"
 	},
 	"dependencies": {
-		"@bufbuild/protobuf": "^2.12.1",
-		"@oh-my-pi/omptype": "17.3.7",
-		"@oh-my-pi/pi-utils": "17.3.7"
+		"@oh-my-pi/omptype": "17.4.0",
+		"@oh-my-pi/pi-utils": "17.4.0"
 	},
 	"devDependencies": {
-		"@oh-my-pi/pi-ai": "17.3.7",
+		"@oh-my-pi/pi-ai": "17.4.0",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {

package/src/build.ts

@@ -16,6 +16,7 @@ import { buildDevinCompat } from "./compat/devin";
 import { buildOpenAICompat, buildOpenAIResponsesCompat, buildOpenRouterCompat } from "./compat/openai";
 import { bareModelId, parseOpenAIModel, semverGte } from "./identity/classify";
 import { resolveModelThinking } from "./model-thinking";
+import { resolveModelTokenizer } from "./model-tokenizer";
 import type { Api, CompatOf, Model, ModelSpec } from "./types";
 import { cleanModelName } from "./utils";
 
@@ -58,12 +59,18 @@ function supportsOpenAIGAComputerUse(spec: ModelSpec<Api>, explicitSupport: bool
 	return parsed !== null && semverGte(parsed.version, "5.4");
 }
 
+/**
+ * Build one model from an authored spec. Bundled models.json rows are fully
+ * materialized by the generator and consumed directly (see `models.ts`), so
+ * this only runs for discovered/custom/override specs.
+ */
 export function buildModel<TApi extends Api>(spec: ModelSpec<TApi>): Model<TApi> {
 	const compat = buildCompat(spec) as CompatOf<TApi>;
 	const supportsComputerUseConfig = explicitComputerUseConfig(spec);
 	return {
 		...spec,
 		name: cleanModelName(spec.name),
+		tokenizer: spec.tokenizer ?? resolveModelTokenizer(spec.requestModelId ?? spec.id),
 		thinking: resolveModelThinking(spec, compat),
 		supportsComputerUse: supportsOpenAIGAComputerUse(spec, supportsComputerUseConfig),
 		supportsComputerUseConfig,

package/src/compat/openai.ts

@@ -22,6 +22,7 @@ import {
 	isKimiModelId,
 	isMimoModelIdOrName,
 	isOpenAISamplingRestrictedModelId,
+	isQwen38PlusTemplateEffortModelId,
 	isQwenModelId,
 } from "../identity/family";
 import type {
@@ -464,7 +465,7 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 			? "zai"
 			: isOpenRouter
 				? "openrouter"
-				: isQwen && isNvidiaNim
+				: isQwen && (isNvidiaNim || provider === "vllm")
 					? "qwen-chat-template"
 					: isQwen && isFireworks
 						? "openai"
@@ -587,6 +588,18 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 		// parameter, so the flag stays a no-op outside the Qwen path.
 		qwenPreserveThinking:
 			(thinkingFormat === "qwen" || thinkingFormat === "qwen-chat-template") && isLocalOpenAICompatBackend,
+		// Qwen 3.8+ templates steer thinking depth via the `reasoning_effort`
+		// template kwarg (low/medium/xhigh, default xhigh); without routing the
+		// requested effort there, the enable_thinking toggle alone leaves the
+		// model at xhigh no matter what the user selects.
+		// Local-only like `qwenPreserveThinking`: first-party Qwen APIs
+		// (Dashscope, Qwen Portal) drive effort through their own OpenAI-style
+		// dialect, and local Ollama keeps its native effort vocabulary.
+		qwenTemplateReasoningEffort:
+			(thinkingFormat === "qwen" || thinkingFormat === "qwen-chat-template") &&
+			isLocalOpenAICompatBackend &&
+			provider !== "ollama" &&
+			isQwen38PlusTemplateEffortModelId(spec.id),
 		requiresAssistantContentForToolCalls: isKimiModel || isDirectDeepseekReasoning,
 		cacheControlFormat: isOpenRouter && spec.id.startsWith("anthropic/") ? "anthropic" : undefined,
 		supportsPromptCacheBreakpoints,
@@ -761,6 +774,7 @@ export function buildOpenAIResponsesCompat(spec: OpenAIResponsesSpecLike): Resol
 		// Responses-only; the Qwen `preserve_thinking` template knob lives on
 		// the chat-completions wire shape, never on Responses.
 		qwenPreserveThinking: false,
+		qwenTemplateReasoningEffort: false,
 		requiresThinkingAsText: false,
 		requiresMistralToolIds: false,
 		requiresToolResultName: false,
@@ -807,6 +821,18 @@ export function buildOpenAIResponsesCompat(spec: OpenAIResponsesSpecLike): Resol
 	if (spec.compat?.omitReasoningEffort === undefined && !compat.supportsReasoningEffort) {
 		compat.omitReasoningEffort = true;
 	}
+	// xai-oauth cache/discovery rows written before a SKU joined the
+	// effort-capable allowlist still carry omitReasoningEffort: true. The
+	// allowlist is the live wire contract; do not let that stale flag hide
+	// the picker or strip reasoning.effort.
+	if (
+		spec.provider === "xai-oauth" &&
+		isGrokReasoningEffortCapable(id) &&
+		spec.compat?.supportsReasoningEffort !== false
+	) {
+		compat.supportsReasoningEffort = true;
+		compat.omitReasoningEffort = false;
+	}
 	return compat;
 }
 

package/src/discovery/codex.ts

@@ -1,5 +1,6 @@
 import { type } from "@oh-my-pi/omptype";
 import { parseKnownModel, semverEqual } from "../identity/classify";
+import { getBundledModels } from "../models";
 import { resolveOpenAIDaybreakStandardCost } from "../openai-pricing";
 import type { FetchImpl, ModelSpec } from "../types";
 import { discoveryFetch } from "../utils";
@@ -22,6 +23,29 @@ const GPT_5_6_CONTEXT_WINDOW = 372_000;
  */
 const GPT_5_6_1M_CONTEXT_WINDOW = 1_000_000;
 const CODEX_GPT_5_6_1M_SLUGS: ReadonlySet<string> = new Set(["gpt-5.6-luna", "gpt-5.6-sol", "gpt-5.6-terra"]);
+/**
+ * Codex advertises worker-mode SKUs under a `-wm` suffix (`gpt-5.6-luna-wm`).
+ *
+ * Those rows route through the same Codex backend as their plain SKU, but an
+ * authoritative discovery list that only advertises the `-wm` slug prunes the
+ * bundled plain model, leaving a configured `openai-codex/gpt-5.6-luna`
+ * unresolvable except via fuzzy fallback onto the `-wm` row — which this user's
+ * ChatGPT account rejects. The compatibility rule, scoped to Codex discovery:
+ * a `-wm` slug whose plain counterpart exists in the bundled Codex catalog is
+ * ALSO registered under its plain id. Both listings derive their base-model
+ * metadata (1M-window floor, daybreak pricing, context fallback) from the
+ * canonical plain slug — the suffix is a routing variant, not a different
+ * model, so the `-wm` row no longer keeps stale backend-parsed capability
+ * values while its plain listing is enriched.
+ *
+ * Deliberate boundary: the "safe" gate is the bundled Codex catalog. A `-wm`
+ * slug whose plain counterpart is only a user-local models.yml entry (not
+ * bundled) stays verbatim — authoritative discovery for genuinely distinct
+ * `-wm` SKUs is preserved, and a hidden plain backend entry can be re-surfaced
+ * through its advertised `-wm` row because the configured plain slug must
+ * resolve.
+ */
+const CODEX_WORKER_SUFFIX = "-wm";
 const CODEX_REMOTE_COMPACTION = {
 	enabled: true,
 	api: "openai-codex-responses",
@@ -194,11 +218,30 @@ function normalizeCodexModels(payload: unknown, baseUrl: string): ModelSpec<"ope
 	}
 
 	const entries = parsedResponse.models ?? parsedResponse.data ?? [];
-	const normalized: NormalizedCodexModel[] = [];
+	const parsedEntries: ParsedCodexModelEntry[] = [];
 	for (const entry of entries) {
-		const model = normalizeCodexModelEntry(entry, baseUrl);
-		if (model) {
-			normalized.push(model);
+		const parsed = parseCodexModelEntry(entry);
+		if (parsed) {
+			parsedEntries.push(parsed);
+		}
+	}
+
+	// A worker `-wm` slug gets an extra plain-id route only when the bundled
+	// catalog ships the plain SKU (the "safe" precondition); the backend's own
+	// plain slug wins over any synthesized clone, and unknown `-wm` SKUs stay
+	// verbatim. Both listings of a safe `-wm` model carry the same base-model
+	// metadata (context-window floor, daybreak pricing) derived from the
+	// canonical plain slug — the suffix is a routing variant, not a different
+	// model.
+	const advertisedSlugs = new Set(parsedEntries.map(parsed => parsed.slug));
+	const bundledCodexModelIds = getBundledCodexModelIds();
+	const normalized: NormalizedCodexModel[] = [];
+	for (const parsed of parsedEntries) {
+		const canonicalSlug = plainCounterpartForWorkerSlug(parsed.slug, bundledCodexModelIds) ?? parsed.slug;
+		normalized.push(buildNormalizedCodexModel(parsed, parsed.slug, canonicalSlug, baseUrl));
+		const plainSlug = canonicalSlug !== parsed.slug ? canonicalSlug : null;
+		if (plainSlug && !advertisedSlugs.has(plainSlug)) {
+			normalized.push(buildNormalizedCodexModel(parsed, plainSlug, canonicalSlug, baseUrl));
 		}
 	}
 
@@ -212,7 +255,37 @@ function normalizeCodexModels(payload: unknown, baseUrl: string): ModelSpec<"ope
 	return normalized.map(item => item.model);
 }
 
-function normalizeCodexModelEntry(entry: unknown, baseUrl: string): NormalizedCodexModel | null {
+/** Ids of the bundled Codex catalog, consulted once per discovery run. */
+function getBundledCodexModelIds(): ReadonlySet<string> {
+	const ids = new Set(getBundledModels("openai-codex").map(model => model.id));
+	return ids;
+}
+
+/**
+ * Map a Codex worker `-wm` slug to its plain counterpart when the bundled
+ * catalog registers that plain SKU. Returns `null` for non-worker slugs and
+ * for `-wm` slugs without a safe plain counterpart.
+ */
+function plainCounterpartForWorkerSlug(slug: string, bundledCodexModelIds: ReadonlySet<string>): string | null {
+	if (!slug.endsWith(CODEX_WORKER_SUFFIX)) {
+		return null;
+	}
+	const plain = slug.slice(0, -CODEX_WORKER_SUFFIX.length);
+	return plain.length > 0 && bundledCodexModelIds.has(plain) ? plain : null;
+}
+
+interface ParsedCodexModelEntry {
+	slug: string;
+	name: string;
+	contextWindow: number | null;
+	reasoning: boolean;
+	input: ("text" | "image")[];
+	preferWebsockets: boolean;
+	useResponsesLite: boolean;
+	priority: number;
+}
+
+function parseCodexModelEntry(entry: unknown): ParsedCodexModelEntry | null {
 	const parsedEntry = codexModelEntrySchema(entry);
 	if (parsedEntry instanceof type.errors) {
 		return null;
@@ -229,44 +302,65 @@ function normalizeCodexModelEntry(entry: unknown, baseUrl: string): NormalizedCo
 		return null;
 	}
 
-	const name = toNonEmptyString(payload.display_name) ?? slug;
+	return {
+		slug,
+		name: toNonEmptyString(payload.display_name) ?? slug,
+		contextWindow: toPositiveInt(payload.context_window),
+		reasoning: supportsReasoning(payload.default_reasoning_level, payload.supported_reasoning_levels),
+		input: normalizeInputModalities(payload.input_modalities),
+		preferWebsockets: toBoolean(payload.prefer_websockets) === true,
+		useResponsesLite: toBoolean(payload.use_responses_lite) === true,
+		priority: toFiniteNumber(payload.priority) ?? Number.MAX_SAFE_INTEGER,
+	};
+}
+
+/**
+ * Build a normalized Codex model spec. `slug` is the registered id (either the
+ * advertised slug or a synthesized plain counterpart); `canonicalSlug` names
+ * the model's bundled SKU (`slug` itself for plain/unknown rows, the plain
+ * counterpart for a safe `-wm` row) and owns the base-model metadata derivation
+ * so both listings of a model report the same context window and pricing.
+ */
+function buildNormalizedCodexModel(
+	parsed: ParsedCodexModelEntry,
+	slug: string,
+	canonicalSlug: string,
+	baseUrl: string,
+): NormalizedCodexModel {
 	// Codex discovery historically omitted `context_window` for GPT-5.6-family
 	// SKUs (#5705); luna/sol/terra additionally floor the reported value because
-	// the registry still declares the pre-1M 272000 window.
-	const parsed = parseKnownModel(slug);
+	// the registry still declares the pre-1M 272000 window. Keyed on the
+	// canonical slug so a safe `gpt-5.6-luna-wm` row gets the same floor as its
+	// plain listing.
+	const parsedKnown = parseKnownModel(canonicalSlug);
 	const fallbackContextWindow =
-		parsed.family === "openai" && semverEqual(parsed.version, "5.6")
+		parsedKnown.family === "openai" && semverEqual(parsedKnown.version, "5.6")
 			? GPT_5_6_CONTEXT_WINDOW
 			: DEFAULT_CONTEXT_WINDOW;
-	const reportedContextWindow = toPositiveInt(payload.context_window) ?? fallbackContextWindow;
-	const contextWindow = CODEX_GPT_5_6_1M_SLUGS.has(slug)
+	const reportedContextWindow = parsed.contextWindow ?? fallbackContextWindow;
+	const contextWindow = CODEX_GPT_5_6_1M_SLUGS.has(canonicalSlug)
 		? Math.max(reportedContextWindow, GPT_5_6_1M_CONTEXT_WINDOW)
 		: reportedContextWindow;
 	const maxTokens = Math.min(DEFAULT_MAX_TOKENS, contextWindow);
-	const reasoning = supportsReasoning(payload.default_reasoning_level, payload.supported_reasoning_levels);
-	const input = normalizeInputModalities(payload.input_modalities);
-	const preferWebsockets = toBoolean(payload.prefer_websockets) === true;
-	const useResponsesLite = toBoolean(payload.use_responses_lite) === true;
-	const priority = toFiniteNumber(payload.priority) ?? Number.MAX_SAFE_INTEGER;
-	const daybreakCost = resolveOpenAIDaybreakStandardCost(slug);
+	const daybreakCost = resolveOpenAIDaybreakStandardCost(canonicalSlug);
 
 	return {
-		priority,
+		priority: parsed.priority,
 		model: {
 			id: slug,
-			name,
+			name: parsed.name,
 			api: "openai-codex-responses",
 			provider: "openai-codex",
 			baseUrl,
-			reasoning,
-			input,
+			reasoning: parsed.reasoning,
+			input: parsed.input,
 			cost: daybreakCost ? { ...daybreakCost } : { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 			remoteCompaction: CODEX_REMOTE_COMPACTION,
 			contextWindow,
 			maxTokens,
-			...(preferWebsockets ? { preferWebsockets: true } : {}),
-			...(useResponsesLite ? { useResponsesLite: true } : {}),
-			...(priority !== Number.MAX_SAFE_INTEGER ? { priority } : {}),
+			...(parsed.preferWebsockets ? { preferWebsockets: true } : {}),
+			...(parsed.useResponsesLite ? { useResponsesLite: true } : {}),
+			...(parsed.priority !== Number.MAX_SAFE_INTEGER ? { priority: parsed.priority } : {}),
 		},
 	};
 }