@linxiraos/pi-catalog 1.0.9 → 1.1.0

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

@@ -26,6 +26,8 @@ export declare const OPENAI_HEADERS: {
     readonly RESPONSES_LITE: "x-openai-internal-codex-responses-lite";
     /** DeviceCheck attestation envelope (codex-rs `X_OAI_ATTESTATION_HEADER`); sent on ChatGPT-OAuth requests. */
     readonly ATTESTATION: "x-oai-attestation";
+    /** Client-declared data residency for region-pinned enterprise workspaces. */
+    readonly RESIDENCY: "x-openai-internal-codex-residency";
 };
 export declare const OPENAI_HEADER_VALUES: {
     readonly BETA_RESPONSES: "responses=experimental";
@@ -43,3 +45,22 @@ export declare const JWT_CLAIM_PATH: "https://api.openai.com/auth";
  * Returns undefined if the token is not a valid Codex JWT.
  */
 export declare function getCodexAccountId(accessToken: string): string | undefined;
+/**
+ * Extract the account's data residency from a Codex JWT access token.
+ *
+ * Enterprise ChatGPT workspaces can be pinned to a region. Such a workspace
+ * rejects a Codex request whose egress does not match it — HTTP 401
+ * `Workspace is not authorized in this region.` — unless the client declares
+ * the residency itself. The token already carries it, so no configuration is
+ * needed: `chatgpt_data_residency` is the authoritative claim, with
+ * `chatgpt_compute_residency` as the fallback for tokens that only carry that.
+ *
+ * Returns undefined for a non-JWT token, or for the (common) accounts whose
+ * claims omit residency entirely — those workspaces are not region-pinned.
+ */
+export declare function getCodexResidency(accessToken: string): string | undefined;
+/**
+ * Adds the token's workspace residency to Codex request headers without
+ * replacing a caller-supplied value.
+ */
+export declare function applyCodexResidencyHeader(headers: Headers | Record<string, string>, accessToken: string): void;

package/dist/types/wire/image-fetchers.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Identification of provider-side image fetchers.
+ *
+ * A request may carry an image either inline (base64) or as a URL. With a URL,
+ * the provider's backend performs its own server-side GET against that URL, so
+ * a local blob server sees an inbound request from vendor infrastructure rather
+ * than from the client. This module names those fetchers, letting a blob server
+ * attribute an inbound GET to the vendor that issued it — which is how a caller
+ * learns where a request actually landed when a router sits between them and
+ * the model.
+ *
+ * NOT an authentication mechanism. Every value here is a request header chosen
+ * by the caller and is trivially forged. Authorize blob reads with an
+ * unguessable URL (single-use capability token, short TTL) and treat a fetcher
+ * match as attribution/telemetry only.
+ *
+ * Each entry was captured from a live fetch triggered by handing that vendor's
+ * API a URL-sourced image.
+ */
+/** Vendor whose infrastructure performed an inbound fetch. */
+export type ImageFetcherVendor = "openai" | "anthropic" | "xai" | "google";
+/** Registry key for a known fetcher. */
+export type ImageFetcherId = "openai-file-downloader" | "anthropic-claude-user" | "anthropic-claude-user-preview" | "xai-image-api-fetch" | "google";
+/** Request signature of one provider-side fetcher. */
+export interface ImageFetcherIdentity {
+    vendor: ImageFetcherVendor;
+    /** Human-readable name for logs and UI. */
+    label: string;
+    /**
+     * `User-Agent` contract: an exact string for fetchers that send a fixed
+     * value, or a pattern for those embedding a client version.
+     */
+    userAgent: string | RegExp;
+    /**
+     * Vendor-proprietary headers observed alongside the agent, used to
+     * corroborate a `User-Agent` claim. Generic infrastructure headers
+     * (`traceparent`, `x-cloud-trace-context`) are deliberately excluded: they
+     * are emitted by unrelated infrastructure and corroborate nothing. Empty
+     * means the agent string is the only available signal, so
+     * {@link ImageFetcherMatch.corroborated} can never be true for that entry.
+     */
+    markerHeaders: readonly string[];
+    /** API surface the capture came from. */
+    observedVia: string;
+    /** Operational caveats a blob server should account for. */
+    note?: string;
+}
+/**
+ * Known provider-side fetchers.
+ *
+ * Agent contracts do not overlap — exact strings never collide with the
+ * versioned patterns — so lookup order carries no meaning.
+ */
+export declare const IMAGE_FETCHERS: Readonly<Record<ImageFetcherId, ImageFetcherIdentity>>;
+/** Attribution outcome for one inbound request. */
+export interface ImageFetcherMatch {
+    id: ImageFetcherId;
+    identity: ImageFetcherIdentity;
+    /**
+     * Whether every proprietary marker header for the matched identity is
+     * present. Always false for identities declaring no markers — absence of
+     * corroboration is not evidence against the match.
+     */
+    corroborated: boolean;
+}
+/** Inbound header bag, as exposed by either `fetch` or a Node-style server. */
+export type InboundHeaders = Headers | Readonly<Record<string, string | readonly string[] | undefined>>;
+/**
+ * Attribute an inbound blob request to a known provider-side fetcher, or
+ * `null` when the agent matches none.
+ *
+ * Matches on `User-Agent` alone and reports marker-header corroboration
+ * separately; callers MUST NOT treat either as proof of origin. Gate access on
+ * the unguessable URL.
+ */
+export declare function identifyImageFetcher(headers: InboundHeaders): ImageFetcherMatch | null;

package/package.json

@@ -1,9 +1,9 @@
 {
 	"type": "module",
 	"name": "@linxiraos/pi-catalog",
-	"version": "1.0.9",
+	"version": "1.1.0",
 	"description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
-	"homepage": "https://linxira-os.github.io",
+	"homepage": "https://linxira-os.github.io/zeta/",
 	"author": "Can Boluk",
 	"license": "MIT",
 	"repository": {
@@ -12,7 +12,7 @@
 		"directory": "packages/catalog"
 	},
 	"bugs": {
-		"url": "https://github.com/can1357/oh-my-pi/issues"
+		"url": "https://github.com/Linxira-OS/linxira-zeta/issues"
 	},
 	"keywords": [
 		"ai",
@@ -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",
-		"@linxiraos/pi-omptype": "1.0.9",
-		"@linxiraos/pi-utils": "1.0.9"
+		"@linxiraos/pi-omptype": "1.1.0",
+		"@linxiraos/pi-utils": "1.1.0"
 	},
 	"devDependencies": {
-		"@linxiraos/pi-ai": "1.0.9",
+		"@linxiraos/pi-ai": "1.1.0",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {
@@ -49,6 +48,8 @@
 		"src",
 		"README.md",
 		"CHANGELOG.md",
+		"LICENSE",
+		"THIRD-PARTY-NOTICES.txt",
 		"dist/types"
 	],
 	"exports": {

package/src/build.ts

@@ -15,7 +15,9 @@ import { buildBedrockCompat } from "./compat/bedrock";
 import { buildDevinCompat } from "./compat/devin";
 import { buildOpenAICompat, buildOpenAIResponsesCompat, buildOpenRouterCompat } from "./compat/openai";
 import { bareModelId, parseOpenAIModel, semverGte } from "./identity/classify";
+import { isClaudeModelId } from "./identity/family";
 import { resolveModelThinking } from "./model-thinking";
+import { resolveModelTokenizer } from "./model-tokenizer";
 import type { Api, CompatOf, Model, ModelSpec } from "./types";
 import { cleanModelName } from "./utils";
 
@@ -58,12 +60,19 @@ 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),
+		requiresGlyphTokenization: isClaudeModelId(spec.id),
+		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 {
@@ -311,6 +312,7 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 		modelMatchesHost(hostModel, "anthropic") || isClaudeModelId(spec.id) || isAnthropicNamespacedModelId(spec.id);
 	const isAlibaba = modelMatchesHost(hostModel, "alibabaDashscope");
 	const isNvidiaNim = modelMatchesHost(hostModel, "nvidia");
+	const isVenice = modelMatchesHost(hostModel, "venice");
 	const isQwen = isQwenModelId(spec.id);
 	// DeepSeek V4 (and other reasoning-capable DeepSeek models) reject follow-up requests in
 	// thinking mode unless prior assistant tool-call turns include `reasoning_content`. The
@@ -464,9 +466,9 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 			? "zai"
 			: isOpenRouter
 				? "openrouter"
-				: isQwen && isNvidiaNim
+				: isQwen && (isNvidiaNim || provider === "vllm")
 					? "qwen-chat-template"
-					: isQwen && isFireworks
+					: isQwen && (isFireworks || isVenice)
 						? "openai"
 						: isAlibaba || isQwen
 							? "qwen"
@@ -527,7 +529,7 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 		// (issue #2299).
 		thinkingFormat,
 		kimiApiFormat: undefined,
-		reasoningDisableMode: resolveReasoningDisableMode(thinkingFormat),
+		reasoningDisableMode: isVenice ? "venice-disable-thinking" : resolveReasoningDisableMode(thinkingFormat),
 		omitReasoningEffort: false,
 		includeEncryptedReasoning: true,
 		filterReasoningHistory: isOpenRouter && isAnthropicModel,
@@ -587,6 +589,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,
@@ -635,7 +649,9 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 			? "omit"
 			: isDirectDeepseekReasoning
 				? "zai-thinking-disabled"
-				: resolveReasoningDisableMode(compat.thinkingFormat);
+				: isVenice
+					? "venice-disable-thinking"
+					: resolveReasoningDisableMode(compat.thinkingFormat);
 	}
 	if (spec.compat?.omitReasoningEffort === undefined && !compat.supportsReasoningEffort) {
 		compat.omitReasoningEffort = true;
@@ -653,7 +669,9 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 		const variant: ResolvedOpenAICompat = { ...compat };
 		applyCompatOverrides(variant, whenThinkingPolicy);
 		if (whenThinkingPolicy.reasoningDisableMode === undefined) {
-			variant.reasoningDisableMode = resolveReasoningDisableMode(variant.thinkingFormat);
+			variant.reasoningDisableMode = isVenice
+				? "venice-disable-thinking"
+				: resolveReasoningDisableMode(variant.thinkingFormat);
 		}
 		if (whenThinkingPolicy.omitReasoningEffort === undefined && !variant.supportsReasoningEffort) {
 			variant.omitReasoningEffort = true;
@@ -746,7 +764,7 @@ export function buildOpenAIResponsesCompat(spec: OpenAIResponsesSpecLike): Resol
 		disableReasoningOnForcedToolChoice: isKimiModel,
 		disableReasoningOnToolChoice: isDeepseekFamily && reasoningCapable && !isOpenRouter,
 		supportsToolChoice: true,
-		supportsForcedToolChoice: true,
+		supportsForcedToolChoice: spec.provider !== "opencode-go" && spec.provider !== "opencode-zen",
 		supportsNamedToolChoice: STRING_ONLY_NAMED_TOOL_CHOICE_PROVIDERS[spec.provider] !== true,
 		reasoningContentField: "reasoning_content",
 		requiresReasoningContentForToolCalls:
@@ -761,6 +779,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 +826,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 "@linxiraos/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";
@@ -9,13 +10,42 @@ const DEFAULT_MODEL_LIST_PATHS = ["/codex/models", "/models"] as const;
 const DEFAULT_CONTEXT_WINDOW = 272_000;
 const DEFAULT_MAX_TOKENS = 128_000;
 /**
- * GPT-5.6 luna/sol/terra hard context capacity. Codex discovery omits
- * `context_window` for these SKUs, so the generic {@link DEFAULT_CONTEXT_WINDOW}
- * (272000) would understate the real window — OpenAI's Codex model registry
- * declares context_window = max_context_window = 372000 (#5705). Used as the
- * fallback only when upstream reports no value.
+ * Fallback for GPT-5.6-family SKUs when upstream omits `context_window`: the
+ * generic {@link DEFAULT_CONTEXT_WINDOW} (272000) understates the registry's
+ * former 372000 hard capacity (#5705).
  */
 const GPT_5_6_CONTEXT_WINDOW = 372_000;
+/**
+ * OpenAI enabled a 1M-token window for subscription Codex on GPT-5.6
+ * luna/sol/terra (2026-08-16), but the Codex model registry still reports the
+ * stale 272000 — so the reported value must be floored, not just defaulted
+ * (openai/codex#38917; Codex CLI override `model_context_window = 1000000`).
+ */
+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",
@@ -38,6 +68,7 @@ const codexModelEntrySchema = type({
 	"priority?": "unknown",
 	"prefer_websockets?": "unknown",
 	"use_responses_lite?": "unknown",
+	"tool_mode?": "unknown",
 });
 
 const codexModelsResponseSchema = type({
@@ -188,11 +219,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));
 		}
 	}
 
@@ -206,7 +256,38 @@ 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;
+	toolMode: boolean;
+	priority: number;
+}
+
+function parseCodexModelEntry(entry: unknown): ParsedCodexModelEntry | null {
 	const parsedEntry = codexModelEntrySchema(entry);
 	if (parsedEntry instanceof type.errors) {
 		return null;
@@ -223,40 +304,67 @@ function normalizeCodexModelEntry(entry: unknown, baseUrl: string): NormalizedCo
 		return null;
 	}
 
-	const name = toNonEmptyString(payload.display_name) ?? slug;
-	// Codex discovery omits `context_window` for GPT-5.6 luna/sol/terra; the
-	// generic 272000 fallback understates their real 372000 window (#5705).
-	const parsed = parseKnownModel(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,
+		toolMode: payload.tool_mode === "code_mode_only",
+		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. 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 contextWindow = toPositiveInt(payload.context_window) ?? fallbackContextWindow;
+	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.toolMode ? { toolMode: "code_mode_only" as const } : {}),
+			...(parsed.priority !== Number.MAX_SAFE_INTEGER ? { priority: parsed.priority } : {}),
 		},
 	};
 }