@bitkyc08/opencodex 2.76.0 → 2.77.0

package/src/providers/antigravity-models.ts

@@ -1,5 +1,7 @@
 import { isValidModelDiscoveryModelId, MODEL_DISCOVERY_MAX_MODELS } from "./model-discovery-limits";
-import { isModelCacheGenerationCurrent } from "../codex/model-cache";
+import { captureModelCacheGeneration, isModelCacheGenerationCurrent } from "../codex/model-cache";
+import { getConfigDir } from "../config/paths";
+import { readAntigravityWireSnapshot, writeAntigravityWireSnapshot, type AntigravitySuffixMap } from "./antigravity-wire-snapshot";
 
 // Google Antigravity (Cloud Code Assist) bundled model list.
 //
@@ -7,8 +9,8 @@ import { isModelCacheGenerationCurrent } from "../codex/model-cache";
 // CLI resolves labels against. The ids below separate CCA wire ids, collapsed picker entries,
 // and hidden compatibility aliases for saved selections. The CCA envelope's `model` field must
 // receive the wire id (for example "Gemini 3.1 Pro (High)" => gemini-pro-agent), while the
-// picker exposes collapsed known base models only when CCA returns every known tier; unknown
-// returned wire ids remain visible so they stay directly routable.
+// picker collapses complete low/medium/high families discovered by CCA, including new versions.
+// Partial families remain wire-addressable rather than advertising an invented effort ladder.
 
 // ── Wire IDs (what CCA :fetchAvailableModels returns) ──
 
@@ -121,10 +123,12 @@ function pickerModelIdForDiscoveredWireId(
   const effortMatch = /^(.*)-(low|medium|high)$/.exec(wireId);
   if (effortMatch) {
     const baseId = effortMatch[1]!;
-    if (isKnownAntigravityPickerModelId(baseId)
+    if (isValidModelDiscoveryModelId(baseId)
       && ANTIGRAVITY_DISCOVERY_EFFORTS.every(effort => available.has(`${baseId}-${effort}`))) {
       return baseId;
     }
+    // A shared display label must not collapse an incomplete family or rename its wire tier.
+    return wireId;
   }
 
   // Display labels are a LAST resort, never a first one. CCA labels a tier row
@@ -200,12 +204,13 @@ function completeDiscoveredEffortWireModelIds(
   pickerId: string,
   available: ReadonlyMap<string, Record<string, unknown>>,
 ): AntigravityEffortWireModelIds | undefined {
-  const explicitEffortMap = ANTIGRAVITY_EFFORT_WIRE_MAP[pickerId];
+  const explicitEffortMap = Object.hasOwn(ANTIGRAVITY_EFFORT_WIRE_MAP, pickerId)
+    ? ANTIGRAVITY_EFFORT_WIRE_MAP[pickerId] : undefined;
   if (explicitEffortMap && Object.values(explicitEffortMap).every(wireId => available.has(wireId))) {
     return { ...explicitEffortMap };
   }
 
-  if (!isKnownAntigravityPickerModelId(pickerId)) return undefined;
+  if (!isValidModelDiscoveryModelId(pickerId)) return undefined;
   const suffixEffortMap: AntigravityEffortWireModelIds = {};
   for (const effort of ANTIGRAVITY_DISCOVERY_EFFORTS) {
     const wireId = `${pickerId}-${effort}`;
@@ -364,7 +369,7 @@ interface DiscoveredWireModelMapping {
   readonly generation?: { provider: string; cacheGeneration: string };
 }
 
-const discoveredWireModelsByBaseUrl = new Map<string, DiscoveredWireModelMapping>();
+const discoveredWireModelsByBaseUrl = new Map<string, DiscoveredWireModelMapping | null>();
 
 /**
  * Strip trailing slashes without a backtracking regex.
@@ -387,9 +392,9 @@ function antigravityBaseUrlKey(baseUrl: string | undefined): string | undefined
     const url = new URL(trimmed);
     url.hash = "";
     url.search = "";
-    return stripTrailingSlashes(url.toString()).toLowerCase();
+    return stripTrailingSlashes(url.toString());
   } catch {
-    return trimmed.toLowerCase();
+    return trimmed;
   }
 }
 
@@ -401,13 +406,23 @@ export function registerAntigravityDiscoveredWireModels(
 ): void {
   const key = antigravityBaseUrlKey(baseUrl);
   if (!key) return;
+  if (generation) {
+    if (!isModelCacheGenerationCurrent(generation.provider, generation.cacheGeneration)) return;
+    const families: Record<string, AntigravitySuffixMap> = Object.create(null);
+    for (const model of models) {
+      if (ANTIGRAVITY_DISCOVERY_EFFORTS.every(effort => model.effortWireModelIds?.[effort] === `${model.id}-${effort}`)) {
+        families[model.id] = { low: `${model.id}-low`, medium: `${model.id}-medium`, high: `${model.id}-high` };
+      }
+    }
+    writeAntigravityWireSnapshot(key, { version: 1, provider: generation.provider, families });
+  }
   const wireModels = new Map<string, string>();
   const effortModels = new Map<string, AntigravityEffortWireModelIds>();
   for (const model of models) {
     wireModels.set(model.id, model.wireModelId);
     if (model.effortWireModelIds) effortModels.set(model.id, { ...model.effortWireModelIds });
   }
-  discoveredWireModelsByBaseUrl.set(key, {
+  discoveredWireModelsByBaseUrl.set(`${getConfigDir()}\0${key}`, {
     models: wireModels,
     effortModels,
     ...(generation ? { generation } : {}),
@@ -419,11 +434,21 @@ function discoveredAntigravityMapping(
 ): DiscoveredWireModelMapping | undefined {
   const key = antigravityBaseUrlKey(baseUrl);
   if (!key) return undefined;
-  const mapping = discoveredWireModelsByBaseUrl.get(key);
+  const scopedKey = `${getConfigDir()}\0${key}`;
+  if (!discoveredWireModelsByBaseUrl.has(scopedKey)) {
+    const saved = readAntigravityWireSnapshot(key);
+    discoveredWireModelsByBaseUrl.set(scopedKey, saved ? {
+      models: new Map(Object.entries(saved.families).map(([id, map]) => [id, map.medium])),
+      effortModels: new Map(Object.entries(saved.families)),
+      generation: { provider: saved.provider, cacheGeneration: captureModelCacheGeneration(saved.provider) },
+    } : null);
+  }
+  const mapping = discoveredWireModelsByBaseUrl.get(scopedKey);
   if (!mapping) return undefined;
   if (mapping.generation
     && !isModelCacheGenerationCurrent(mapping.generation.provider, mapping.generation.cacheGeneration)) {
-    discoveredWireModelsByBaseUrl.delete(key);
+    // Keep a tombstone: clearing account/cache authority must not reload old disk evidence.
+    discoveredWireModelsByBaseUrl.set(scopedKey, null);
     return undefined;
   }
   return mapping;
@@ -450,7 +475,8 @@ function discoveredAntigravityEffortWireModelId(
   }
 
   const defaultEffort = ANTIGRAVITY_DEFAULT_EFFORT[modelId]
-    ?? ANTIGRAVITY_THINKING_LEVEL_MODELS[modelId];
+    ?? ANTIGRAVITY_THINKING_LEVEL_MODELS[modelId]
+    ?? "medium";
   if (defaultEffort && isAntigravityDiscoveryEffort(defaultEffort) && effortMap[defaultEffort]) {
     return effortMap[defaultEffort];
   }
@@ -573,20 +599,27 @@ export function parseAntigravityAvailableModels(
     if (seen.has(id)) continue;
     seen.add(id);
     const effortWireModelIds = completeDiscoveredEffortWireModelIds(id, available);
+    const tierInfo = effortWireModelIds
+      ? Object.values(effortWireModelIds).map(wire => available.get(wire)!) : [info];
+    const windows = tierInfo.map(tier => antigravityPositiveInteger(tier.maxTokens));
+    const contextWindow = windows.every((window): window is number => window !== undefined)
+      ? Math.min(...windows) : undefined;
+    const supportsImages = tierInfo.every(tier => tier.supportsImages === true) ? true
+      : tierInfo.some(tier => tier.supportsImages === false) ? false : undefined;
     out.push({
       id,
       wireModelId: wireId,
       ...(effortWireModelIds ? { effortWireModelIds } : {}),
-      ...(antigravityPositiveInteger(info.maxTokens) ? { contextWindow: antigravityPositiveInteger(info.maxTokens) } : {}),
+      ...(contextWindow ? { contextWindow } : {}),
       // Tri-state, deliberately not a ternary: `true` asserts image support,
       // `false` asserts against it, and ABSENT is unknown. Collapsing absent into
       // `["text"]` let routing read it as a confident `image: false` (#1796). The
       // strict catalog still receives its `["text"]` compatibility default
       // downstream via ensureStrictCatalogFields; only the routing-evidence
       // channel stays honest about what was never asserted.
-      ...(info.supportsImages === true
+      ...(supportsImages === true
         ? { inputModalities: ["text", "image"] as string[] }
-        : info.supportsImages === false
+        : supportsImages === false
           ? { inputModalities: ["text"] as string[] }
           : {}),
     });
@@ -737,6 +770,11 @@ const ANTIGRAVITY_USAGE_BASE_BY_ID: Record<string, string> = (() => {
   // onto a model that did not exist then, and away from the 3.6 price row that still
   // prices it correctly. Retirement changes what we CALL, not what we RECORD.
   for (const retired of Object.keys(RETIRED_FLASH_TIERS)) rev[retired] = retired;
+  // Usage identity is stable even before discovery; routing keeps its own live evidence.
+  for (const base of ["claude-sonnet-5-5", "claude-opus-5-5"]) {
+    rev[base] = base;
+    for (const effort of ANTIGRAVITY_DISCOVERY_EFFORTS) rev[`${base}-${effort}`] = base;
+  }
   // Visible aliases that only appear in ANTIGRAVITY_VISIBLE_MODEL_ALIASES are already
   // included via ANTIGRAVITY_MODEL_ALIASES. Identity bases without effort maps remain.
   return rev;

package/src/providers/antigravity-wire-snapshot.ts

@@ -0,0 +1,66 @@
+import { createHash } from "node:crypto";
+import { closeSync, fstatSync, openSync, readSync } from "node:fs";
+import { join } from "node:path";
+import { atomicWriteFileNoFollow } from "../config/atomic-write";
+import { getConfigDir } from "../config/paths";
+import { isValidProviderName } from "../config/provider-name";
+import { isValidModelDiscoveryModelId, MODEL_DISCOVERY_MAX_MODELS, MODEL_DISCOVERY_MAX_RESPONSE_BYTES } from "./model-discovery-limits";
+
+export type AntigravitySuffixMap = Record<"low" | "medium" | "high", string>;
+export interface AntigravityWireSnapshot {
+  version: 1;
+  provider: string;
+  families: Record<string, AntigravitySuffixMap>;
+}
+const EFFORTS = ["low", "medium", "high"] as const;
+
+function snapshotPath(destination: string): string {
+  const key = createHash("sha256").update(destination).digest("hex");
+  return join(getConfigDir(), `antigravity-wire-${key}.json`);
+}
+
+function validatedSnapshot(value: unknown): AntigravityWireSnapshot | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const row = value as Record<string, unknown>;
+  if (row.version !== 1 || typeof row.provider !== "string" || !isValidProviderName(row.provider)
+    || !row.families || typeof row.families !== "object" || Array.isArray(row.families)) return undefined;
+  const entries = Object.entries(row.families);
+  if (entries.length > MODEL_DISCOVERY_MAX_MODELS) return undefined;
+  const families: Record<string, AntigravitySuffixMap> = Object.create(null);
+  for (const [base, candidate] of entries) {
+    if (!isValidModelDiscoveryModelId(base) || !candidate || typeof candidate !== "object" || Array.isArray(candidate)) return undefined;
+    const map = candidate as Record<string, unknown>;
+    if (!EFFORTS.every(effort => map[effort] === `${base}-${effort}` && isValidModelDiscoveryModelId(map[effort]))) return undefined;
+    families[base] = { low: `${base}-low`, medium: `${base}-medium`, high: `${base}-high` };
+  }
+  return { version: 1, provider: row.provider, families };
+}
+
+/** Routing evidence only, never an account's current availability or entitlement. */
+export function readAntigravityWireSnapshot(destination: string): AntigravityWireSnapshot | undefined {
+  let fd: number | undefined;
+  try {
+    fd = openSync(snapshotPath(destination), "r");
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.size > MODEL_DISCOVERY_MAX_RESPONSE_BYTES) return undefined;
+    const bytes = Buffer.alloc(Math.min(stat.size + 1, MODEL_DISCOVERY_MAX_RESPONSE_BYTES + 1));
+    let length = 0;
+    while (length < bytes.byteLength) {
+      const read = readSync(fd, bytes, length, bytes.byteLength - length, null);
+      if (read === 0) break;
+      length += read;
+    }
+    if (length > stat.size || length > MODEL_DISCOVERY_MAX_RESPONSE_BYTES) return undefined;
+    return validatedSnapshot(JSON.parse(bytes.subarray(0, length).toString("utf8")));
+  } catch { return undefined; }
+  finally { if (fd !== undefined) closeSync(fd); }
+}
+
+/** Throw before publishing new synthetic catalog IDs if their routing evidence cannot be saved. */
+export function writeAntigravityWireSnapshot(destination: string, snapshot: AntigravityWireSnapshot): void {
+  const validated = validatedSnapshot(snapshot);
+  if (!validated) throw new Error("invalid Antigravity wire snapshot");
+  const text = JSON.stringify(validated);
+  if (Buffer.byteLength(text) > MODEL_DISCOVERY_MAX_RESPONSE_BYTES) throw new Error("Antigravity wire snapshot exceeds size limit");
+  atomicWriteFileNoFollow(snapshotPath(destination), text);
+}

package/src/providers/derive.ts

@@ -590,6 +590,8 @@ export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig
     prov.supportsResponsesCustomTools = entry.supportsResponsesCustomTools;
   }
   if (prov.preserveResponsesReasoningContent === undefined && entry.preserveResponsesReasoningContent !== undefined) prov.preserveResponsesReasoningContent = entry.preserveResponsesReasoningContent;
+  if (prov.preserveResponsesInputItemIds === undefined && entry.preserveResponsesInputItemIds !== undefined) prov.preserveResponsesInputItemIds = entry.preserveResponsesInputItemIds;
+  if (prov.preserveResponsesMessageMetadata === undefined && entry.preserveResponsesMessageMetadata !== undefined) prov.preserveResponsesMessageMetadata = entry.preserveResponsesMessageMetadata;
   if (prov.dropResponsesReasoningItems === undefined && entry.dropResponsesReasoningItems !== undefined) prov.dropResponsesReasoningItems = entry.dropResponsesReasoningItems;
   applyReasoningSummaryDefaults(prov, entry.modelSupportsReasoningSummaries);
   applyServiceTierModelDefaults(prov, serviceTierModelDefaultsFor(entry, prov));

package/src/providers/model-rename-fields.ts

@@ -30,6 +30,8 @@ export const PROVIDER_MODEL_RENAME_ROLES = {
   fastEnabled: "none",
   modelSupportsServiceTier: "record",
   preserveResponsesReasoningContent: "none",
+  preserveResponsesInputItemIds: "none",
+  preserveResponsesMessageMetadata: "none",
   modelReasoningEffortsAuthoritative: "none",
   dropResponsesReasoningItems: "none",
   decodesNativeCompactionBlobs: "none",
@@ -69,6 +71,7 @@ export const PROVIDER_MODEL_RENAME_ROLES = {
   autoReviewModel: "none",
   autoReviewModelOverrides: "record",
   headers: "none",
+  forwardClientHeaders: "none",
   openRouterRouting: "none",
   modelOpenRouterRouting: "record",
   vercelGatewayRouting: "none",

package/src/providers/new-model-policy.ts

@@ -1,5 +1,9 @@
 import type { OcxConfig } from "../types";
-import { routedSlug } from "./slug-codec";
+import { routedSlug, slugEquals } from "./slug-codec";
+import {
+  antigravityEffortFamilyIds, antigravityFamilyDisabled,
+  type AntigravityEffortFamilyRow,
+} from "./antigravity-effort-families";
 
 export const MODEL_REMOVAL_GRACE_FETCHES = 3;
 export const MAX_KNOWN_MODELS_PER_PROVIDER = 2_000;
@@ -115,30 +119,63 @@ export function effectiveNewModelPolicy(config: OcxConfig, provider: string): Ne
   return config.modelDiscovery?.newModelPolicy ?? "on";
 }
 
+/** Normalize policy identities only; the original rows and saved wire selections stay intact. */
+function normalizeEffortFamilies(config: OcxConfig, provider: string, rows: AntigravityEffortFamilyRow[]) {
+  const aliases = new Map<string, string>();
+  const inheritedDisables: string[] = [];
+  const bases = new Set(rows.filter(row => antigravityEffortFamilyIds(row)).map(row => row.id));
+  for (const row of rows) {
+    const ids = antigravityEffortFamilyIds(row);
+    if (!ids) continue;
+    for (const id of ids) if (!bases.has(id)) aliases.set(id, row.id);
+    if (antigravityFamilyDisabled(config, row, rows)
+      && !config.disabledModels?.some(slug => slugEquals(slug, provider, row.id))) {
+      inheritedDisables.push(routedSlug(provider, row.id));
+    }
+  }
+  const normalize = (id: string) => aliases.get(id) ?? id;
+  const normalizeIds = (ids: string[]) => [...new Set(ids.map(normalize))].sort();
+  const prior = config.modelDiscovery?.knownModels?.[provider];
+  let baseline = prior;
+  if (prior && aliases.size) {
+    const missing: Record<string, number> = {};
+    for (const [id, count] of Object.entries(prior.missing ?? {})) {
+      const key = normalize(id);
+      // A family cannot disappear sooner than its least-missing known tier.
+      missing[key] = Math.min(missing[key] ?? count, count);
+    }
+    baseline = { ...prior, ids: normalizeIds(prior.ids), removed: normalizeIds(prior.removed),
+      ...(Object.keys(missing).length ? { missing } : {}) };
+  }
+  return { discoveredIds: normalizeIds(rows.map(row => row.id)), baseline, inheritedDisables };
+}
+
 /** Apply authoritative provider rows to a mutable convergence copy; degraded providers are omitted. */
 export function reconcileSuccessfulModelDiscoveries(options: {
   config: OcxConfig;
-  models: Iterable<{ provider: string; id: string; custom?: boolean }>;
+  models: Iterable<AntigravityEffortFamilyRow>;
   authoritativeProviders: Iterable<string>;
   now: string;
   /** See {@link NewModelPolicyMode}; defaults to `converge`. */
   mode?: NewModelPolicyMode;
 }): boolean {
-  const byProvider = new Map<string, string[]>();
+  const byProvider = new Map<string, AntigravityEffortFamilyRow[]>();
   for (const model of options.models) {
-    if (model.custom) continue;
-    const ids = byProvider.get(model.provider) ?? [];
-    ids.push(model.id); byProvider.set(model.provider, ids);
+    if (model.custom || model.catalogKind === "custom-model-v1") continue;
+    const rows = byProvider.get(model.provider) ?? [];
+    rows.push(model); byProvider.set(model.provider, rows);
   }
   let changed = false;
   for (const provider of options.authoritativeProviders) {
     const configured = options.config.providers[provider];
     if (!configured || configured.liveModels === false) continue;
-    const discoveredIds = byProvider.get(provider) ?? [];
+    const { discoveredIds, baseline, inheritedDisables } = normalizeEffortFamilies(
+      options.config, provider, byProvider.get(provider) ?? [],
+    );
     const discovery = options.config.modelDiscovery ??= {};
     const known = discovery.knownModels ??= {};
     const result = applyNewModelPolicy({
-      provider, discoveredIds, baseline: known[provider],
+      provider, discoveredIds, baseline,
       policy: effectiveNewModelPolicy(options.config, provider),
       hasSelectedModels: (configured.selectedModels?.length ?? 0) > 0,
       now: options.now,
@@ -151,9 +188,10 @@ export function reconcileSuccessfulModelDiscoveries(options: {
     // Keep the previous timestamp when nothing else moved, so a steady-state roster does not
     // make the baseline look dirty on the next comparison either.
     if (!baselineChanged && priorBaseline) known[provider] = priorBaseline;
-    if (result.slugsToDisable.length) {
+    const slugsToDisable = [...result.slugsToDisable, ...inheritedDisables];
+    if (slugsToDisable.length) {
       const disabled = options.config.disabledModels ??= [];
-      for (const slug of result.slugsToDisable) {
+      for (const slug of slugsToDisable) {
         if (disabled.includes(slug)) continue;
         disabled.push(slug);
         changed = true;

package/src/providers/registry/entries-extended.ts

@@ -35,6 +35,7 @@ import {
   ZAI_GLM_5X_REASONING_EFFORTS,
   MINIMAX_MODELS,
   MINIMAX_MODEL_CONTEXT_WINDOWS,
+  MINIMAX_MODEL_INPUT_MODALITIES,
   MINIMAX_M3_REASONING_EFFORTS,
   MINIMAX_M3_REASONING_EFFORT_MAP,
   MINIMAX_M31_FLASH_PREVIEW,
@@ -1024,6 +1025,7 @@ export const PROVIDER_REGISTRY_EXTENDED: readonly ProviderRegistryEntry[] = [
     id: "minimax", label: "MiniMax — Coding Plan", baseUrl: "https://api.minimax.io/v1", adapter: "openai-chat", authKind: "key",
     dashboardUrl: "https://platform.minimax.io", defaultModel: "MiniMax-M3", models: MINIMAX_MODELS,
     modelContextWindows: MINIMAX_MODEL_CONTEXT_WINDOWS,
+    modelInputModalities: MINIMAX_MODEL_INPUT_MODALITIES,
     modelReasoningEfforts: { "MiniMax-M3": MINIMAX_M3_REASONING_EFFORTS, [MINIMAX_M31_FLASH_PREVIEW]: MINIMAX_M31_REASONING_EFFORTS },
     modelDefaultReasoningEfforts: { "MiniMax-M3": "medium", [MINIMAX_M31_FLASH_PREVIEW]: MINIMAX_M31_DEFAULT_REASONING_EFFORT },
     modelReasoningEffortMap: { "MiniMax-M3": MINIMAX_M3_REASONING_EFFORT_MAP },
@@ -1049,6 +1051,7 @@ export const PROVIDER_REGISTRY_EXTENDED: readonly ProviderRegistryEntry[] = [
     id: "minimax-cn", label: "MiniMax — Coding Plan (CN)", baseUrl: "https://api.minimaxi.com/v1", adapter: "openai-chat", authKind: "key",
     dashboardUrl: "https://platform.minimaxi.com", defaultModel: "MiniMax-M3", models: MINIMAX_MODELS,
     modelContextWindows: MINIMAX_MODEL_CONTEXT_WINDOWS,
+    modelInputModalities: MINIMAX_MODEL_INPUT_MODALITIES,
     modelReasoningEfforts: { "MiniMax-M3": MINIMAX_M3_REASONING_EFFORTS, [MINIMAX_M31_FLASH_PREVIEW]: MINIMAX_M31_REASONING_EFFORTS },
     modelDefaultReasoningEfforts: { "MiniMax-M3": "medium", [MINIMAX_M31_FLASH_PREVIEW]: MINIMAX_M31_DEFAULT_REASONING_EFFORT },
     modelReasoningEffortMap: { "MiniMax-M3": MINIMAX_M3_REASONING_EFFORT_MAP },

package/src/providers/registry/model-ids.ts

@@ -87,6 +87,8 @@ export const REGISTRY_FIELD_MODEL_ID_ROLES = {
   fastOptIn: NONE,
   modelServiceTierCapabilityBaseUrlGuard: NONE,
   preserveResponsesReasoningContent: NONE,
+  preserveResponsesInputItemIds: NONE,
+  preserveResponsesMessageMetadata: NONE,
   dropResponsesReasoningItems: NONE,
   modelSupportsReasoningSummaries: RECORD_KEYS,
   modelSupportsVerbosity: RECORD_KEYS,

package/src/providers/registry/model-seeds.ts

@@ -172,6 +172,11 @@ export const MINIMAX_REASONING_SPLIT_MODELS = MINIMAX_MODELS_BEFORE_M31;
 export const MINIMAX_MODEL_CONTEXT_WINDOWS: Record<string, number> = Object.fromEntries(
   MINIMAX_MODELS.map(id => [id, id === "MiniMax-M3" || id === MINIMAX_M31_FLASH_PREVIEW ? 1_000_000 : 204_800]),
 );
+/** MiniMax's OpenAI-compatible M3 endpoints accept image_url; keep video off Codex's input enum. */
+export const MINIMAX_MODEL_INPUT_MODALITIES: Record<string, string[]> = {
+  "MiniMax-M3": ["text", "image"],
+  [MINIMAX_M31_FLASH_PREVIEW]: ["text", "image"],
+};
 export const MINIMAX_M3_REASONING_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
 /** Identity efforts on the wire; no map, so none omits the field instead of disabling thinking. */
 export const MINIMAX_M31_REASONING_EFFORTS = ["low", "medium", "high", "xhigh", "max"];

package/src/providers/registry/types.ts

@@ -278,6 +278,10 @@ export interface ProviderRegistryEntry {
   modelServiceTierCapabilityBaseUrlGuard?: (baseUrl: string) => boolean;
   /** Registry default for plaintext reasoning replay; see `OcxProviderConfig.preserveResponsesReasoningContent`. Registry-only like `supportsServiceTier`. */
   preserveResponsesReasoningContent?: boolean;
+  /** Registry default for preserving input item IDs; see `OcxProviderConfig.preserveResponsesInputItemIds`. */
+  preserveResponsesInputItemIds?: boolean;
+  /** Registry default for preserving per-item chat metadata; see `OcxProviderConfig.preserveResponsesMessageMetadata`. */
+  preserveResponsesMessageMetadata?: boolean;
   /** Registry default for dropping replayed reasoning items for Responses upstreams that reject them. */
   dropResponsesReasoningItems?: boolean;
   /** Registry defaults for per-model Codex reasoning propagation; explicit user keys win during enrichment. */

package/src/responses/compaction.ts

@@ -15,6 +15,25 @@
  * routed models get a short "history was compacted" note instead.
  */
 
+import type { TranslatorBudget } from "../lib/translator-budget";
+
+const ciphertextLeases = new WeakMap<object, { budget: TranslatorBudget; bytes: number }>();
+
+/** Attach an already-charged parser ciphertext lease to its exact terminal event. */
+export function transferCompactionCiphertextLease(event: object, budget: TranslatorBudget, bytes: number): void {
+  if (bytes === 0) return;
+  if (ciphertextLeases.has(event)) throw new Error("compaction ciphertext lease is already transferred");
+  ciphertextLeases.set(event, { budget, bytes });
+}
+
+/** Release only this event's transferred ciphertext lease, once and for its owning budget. */
+export function releaseCompactionCiphertextLease(event: object, budget: TranslatorBudget): void {
+  const lease = ciphertextLeases.get(event);
+  if (!lease || lease.budget !== budget) return;
+  ciphertextLeases.delete(event);
+  budget.releaseRetained(lease.bytes, { kind: "retained_collectors" });
+}
+
 export const OCX_COMPACTION_PREFIX = "ocx1:";
 
 export const OCX_NATIVE_REPLAY_RECOVERY_NOTE =

package/src/router.ts

@@ -426,6 +426,12 @@ export function routedProviderConfig(providerName: string, provider: OcxProvider
     ...(provider.preserveResponsesReasoningContent === undefined && registryEntry.preserveResponsesReasoningContent !== undefined
       ? { preserveResponsesReasoningContent: registryEntry.preserveResponsesReasoningContent }
       : {}),
+    ...(provider.preserveResponsesInputItemIds === undefined && registryEntry.preserveResponsesInputItemIds !== undefined
+      ? { preserveResponsesInputItemIds: registryEntry.preserveResponsesInputItemIds }
+      : {}),
+    ...(provider.preserveResponsesMessageMetadata === undefined && registryEntry.preserveResponsesMessageMetadata !== undefined
+      ? { preserveResponsesMessageMetadata: registryEntry.preserveResponsesMessageMetadata }
+      : {}),
     ...(provider.dropResponsesReasoningItems === undefined && registryEntry.dropResponsesReasoningItems !== undefined
       ? { dropResponsesReasoningItems: registryEntry.dropResponsesReasoningItems }
       : {}),

package/src/server/auth-cors.ts

@@ -27,6 +27,7 @@ import {
   positiveIntegerRecordConfigError,
   providerBaseUrlConfigError,
   providerHeadersConfigError,
+  providerForwardClientHeadersConfigError,
   reasoningSummaryDeliveryRecordConfigError,
   upstreamHttpVersionConfigError,
 } from "../config/provider-validation";
@@ -765,6 +766,9 @@ export function providerManagementConfigError(
     // validation and then rejected by the seed comparison, so canonical OpenAI could never
     // set OR clear it — the value was admitted and then refused in the same request.
     delete canonicalCandidate.annotateEmptyToolOutputs;
+    // forwardClientHeaders is an editor-managed request-metadata overlay. It is validated
+    // separately below and must not make an otherwise canonical OpenAI provider fail the seed check.
+    delete canonicalCandidate.forwardClientHeaders;
     // Canonical ChatGPT keeps WebSocket as the default, but an operator may
     // select the existing HTTP/SSE path without changing its auth or endpoint.
     if (raw.upstreamWebsocket !== undefined) {
@@ -800,6 +804,8 @@ export function providerManagementConfigError(
   }
   const headersError = providerHeadersConfigError(typed.headers);
   if (headersError) return `provider ${name} ${headersError}`;
+  const forwardClientHeadersError = providerForwardClientHeadersConfigError(raw.forwardClientHeaders);
+  if (forwardClientHeadersError) return `provider ${name} ${forwardClientHeadersError}`;
   const retryOn429Error = retryOn429PolicyConfigError(raw.retryOn429);
   if (retryOn429Error) {
     // The provider name is caller-controlled and can be token-shaped; redact and JSON-escape
@@ -998,6 +1004,8 @@ const PROVIDER_CONFIG_FIELD_POLICY = {
   supportsServiceTier: "editor",
   modelSupportsServiceTier: "editor",
   preserveResponsesReasoningContent: "editor",
+  preserveResponsesInputItemIds: "editor",
+  preserveResponsesMessageMetadata: "editor",
   dropResponsesReasoningItems: "editor",
   modelReasoningEffortsAuthoritative: "editor",
   decodesNativeCompactionBlobs: "editor",
@@ -1042,6 +1050,7 @@ const PROVIDER_CONFIG_FIELD_POLICY = {
   modelMaxOutputTokens: "editor",
   modelCosts: "editor",
   headers: "redacted",
+  forwardClientHeaders: "editor",
   openRouterRouting: "editor",
   modelOpenRouterRouting: "editor",
   vercelGatewayRouting: "editor",

package/src/server/chat-completions.ts

@@ -86,6 +86,7 @@ import { parseRequestEffortRowId } from "./effort-row";
 import { parseSyntheticRowId } from "./fast-row";
 import { isCanonicalOpenAiForwardProvider } from "../providers/openai-tiers";
 import { CODEX_RESERVE_HELPER_UNSUPPORTED_MESSAGE, isCodexReserveHelperUnsupported } from "../codex/loopback-target";
+import { applyDroidReasoningDefault, droidReasoningDefault, DROID_DEFAULT_EFFORT_HEADER } from "./droid-reasoning-default";
 
 type Rec = Record<string, unknown>;
 
@@ -157,6 +158,9 @@ async function handleChatCompletionsWithBudget(
 
   const requestedModel = chatBody.model as string;
   const { fastRow, effortRow } = parseSyntheticRowId(requestedModel, config);
+  const droidDefaultEffort = effortRow
+    ? undefined
+    : droidReasoningDefault(req.headers.get(DROID_DEFAULT_EFFORT_HEADER), chatBody);
   if (effortRow) chatBody.model = effortRow.baseId;
   if (fastRow) {
     chatBody.model = fastRow.baseId;
@@ -198,6 +202,9 @@ async function handleChatCompletionsWithBudget(
       getOrAllocateRequestSessionLane(req),
       routedProvider,
     );
+    if (!route.combo && route.routeKind !== "policy") {
+      applyDroidReasoningDefault(chatBody, droidDefaultEffort, { provider: route.provider, modelId: route.modelId });
+    }
     logCtx.model = route.modelId;
     logCtx.providerAdapter = route.provider.adapter;
     logCtx.requestedModel = requestedModel;
@@ -442,6 +449,9 @@ async function handleChatCompletionsWithBudget(
     abortSignal: req.signal,
     // Body is Responses-shaped by now, but the client spoke Chat Completions.
     inboundWire: "chat",
+    ...((settledRoute?.combo || settledRoute?.routeKind === "policy") && droidDefaultEffort
+      ? { droidDefaultEffort }
+      : {}),
     // PF-07: the combo sends eligible candidates natively from this envelope.
     ...(envelope && nativeChatCombos ? {
       protocolSource: createNativeChatComboSource({