@iislee/opencodex 2.11.0 → 2.35.0

package/src/combos/types.ts

@@ -1,4 +1,5 @@
 import { isCodexReasoningEffort } from "../reasoning-effort";
+import { SUPPORTED_NATIVE_OPENAI_SLUGS } from "../codex/catalog/native-models";
 import type {
   OcxComboConfig,
   OcxComboDefaultEffort,
@@ -24,11 +25,7 @@ const COMBO_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
  * `combo/` prefix. Codex-facing slugs tolerate at most one "/", so deeper paths reject.
  */
 const COMBO_ALIAS_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}(?:\/[A-Za-z0-9][A-Za-z0-9._-]{0,63})?$/;
-/**
- * Bare aliases in the OpenAI native family (gpt-*, o1-*, o3-*, o4-*, codex-*) are
- * rejected: they collide with native catalog rows and the canonical-OpenAI routing
- * branch, which cannot be shadowed honestly.
- */
+/** Bare aliases in this family require the explicit `nativeAlias` opt-in below. */
 const NATIVE_OPENAI_FAMILY_PATTERN = /^(?:gpt-|o1-|o3-|o4-|codex-)/;
 
 export interface ComboValidationIssue {
@@ -40,11 +37,26 @@ export interface NormalizedComboConfig {
   strategy: OcxComboStrategy;
   stickyLimit: number;
   defaultEffort: OcxComboDefaultEffort | null;
+  /** Disable image input; `auto` preserves the intersection derived from all targets. */
+  imageInput: "auto" | "disabled";
   /** Trimmed public alias, or null when the combo keeps the default `combo/<id>` slug. */
   alias: string | null;
+  /** Explicit native-family alias opt-in. */
+  nativeAlias: boolean;
+  /** Display-only label for the catalog row, or null when unset. */
+  displayName: string | null;
   targets: Array<Required<OcxComboTarget>>;
 }
 
+/** True only for an explicitly opted-in bare native-family alias. */
+export function isNativeAliasCombo(
+  combo: { alias?: string | null; nativeAlias?: boolean },
+): boolean {
+  const alias = typeof combo.alias === "string" ? combo.alias.trim() : "";
+  return combo.nativeAlias === true
+    && SUPPORTED_NATIVE_OPENAI_SLUGS.has(alias);
+}
+
 export function targetKey(target: Pick<OcxComboTarget, "provider" | "model">): string {
   return `${target.provider}/${target.model}`;
 }
@@ -66,6 +78,27 @@ export function comboPublicModelId(id: string, combo: { alias?: string | null })
   return alias || comboModelId(id);
 }
 
+/**
+ * Persisted selector that hides a combo from discovery. Native aliases keep the canonical
+ * `combo/<id>` selector because their bare public id remains the native OpenAI disable key.
+ */
+export function comboDisabledModelId(
+  id: string,
+  combo: { alias?: string | null; nativeAlias?: boolean },
+): string {
+  return isNativeAliasCombo(combo) ? comboModelId(id) : comboPublicModelId(id, combo);
+}
+
+/** Every persisted selector that can refer to this combo in `disabledModels`. */
+export function comboDisabledModelSelectors(
+  id: string,
+  combo: { alias?: string | null; nativeAlias?: boolean },
+): string[] {
+  const canonical = comboModelId(id);
+  const preferred = comboDisabledModelId(id, combo);
+  return preferred === canonical ? [canonical] : [canonical, preferred];
+}
+
 /**
  * Resolve a client-requested model id to a combo config key. The canonical `combo/<id>`
  * form wins first (back-compat); otherwise an exact alias match across configured combos.
@@ -94,7 +127,7 @@ export function comboAliasIssues(
   id: string,
   alias: string,
   combos: Record<string, OcxComboConfig> | undefined,
-  options: { excludeComboId?: string } = {},
+  options: { excludeComboId?: string; allowNativeAlias?: boolean } = {},
 ): ComboValidationIssue[] {
   const issues: ComboValidationIssue[] = [];
   if (!COMBO_ALIAS_PATTERN.test(alias)) {
@@ -110,10 +143,12 @@ export function comboAliasIssues(
       message: `alias must not use the reserved "${COMBO_NAMESPACE}/" namespace`,
     });
   }
-  if (!alias.includes("/") && NATIVE_OPENAI_FAMILY_PATTERN.test(alias)) {
+  if (!alias.includes("/")
+    && NATIVE_OPENAI_FAMILY_PATTERN.test(alias)
+    && options.allowNativeAlias !== true) {
     issues.push({
       path: ["alias"],
-      message: "bare aliases in the OpenAI native family (gpt-*, o1-*, o3-*, o4-*, codex-*) are not allowed",
+      message: "bare aliases in the OpenAI native family require nativeAlias=true",
     });
   }
   for (const [otherId, other] of Object.entries(combos ?? {})) {
@@ -168,6 +203,16 @@ export function comboConfigIssues(
   }
 
   const body = raw as Record<string, unknown>;
+  if (typeof body.alias === "string") {
+    const alias = body.alias.toLowerCase();
+    for (const [providerName, provider] of Object.entries(providers)) {
+      if (provider.alias?.toLowerCase() === alias) {
+        issues.push({ path: ["alias"], message: `alias "${body.alias}" is already used by provider "${providerName}"` });
+      }
+      const model = Object.entries(provider.modelAliases ?? {}).find(([, value]) => value.toLowerCase() === alias);
+      if (model) issues.push({ path: ["alias"], message: `alias "${body.alias}" is already used by model "${providerName}/${model[0]}"` });
+    }
+  }
   if (body.strategy !== undefined
     && body.strategy !== "failover"
     && body.strategy !== "round-robin") {
@@ -187,15 +232,48 @@ export function comboConfigIssues(
       message: "defaultEffort must be one of: low, medium, high, xhigh, max, ultra",
     });
   }
+  if (body.imageInput !== undefined && body.imageInput !== "auto" && body.imageInput !== "disabled") {
+    issues.push({ path: ["imageInput"], message: 'imageInput must be "auto" or "disabled"' });
+  }
 
   if (body.alias !== undefined) {
     if (typeof body.alias !== "string") {
       issues.push({ path: ["alias"], message: "alias must be a string" });
     } else {
       const alias = body.alias.trim();
-      if (alias) issues.push(...comboAliasIssues(id, alias, options.combos, options));
+      if (alias) {
+        issues.push(...comboAliasIssues(id, alias, options.combos, {
+          ...options,
+          allowNativeAlias: body.nativeAlias === true,
+        }));
+      }
+    }
+  }
+
+  if (body.nativeAlias !== undefined && typeof body.nativeAlias !== "boolean") {
+    issues.push({ path: ["nativeAlias"], message: "nativeAlias must be a boolean" });
+  }
+  if (body.displayName !== undefined) {
+    if (typeof body.displayName !== "string") {
+      issues.push({ path: ["displayName"], message: "displayName must be a string" });
+    } else if (body.displayName.trim().length > 128 || /[\u0000-\u001f\u007f]/.test(body.displayName)) {
+      issues.push({
+        path: ["displayName"],
+        message: "displayName must be at most 128 characters and contain no control characters",
+      });
     }
   }
+  const alias = typeof body.alias === "string" ? body.alias.trim() : "";
+  const nativeAlias = body.nativeAlias === true;
+  if (nativeAlias && !SUPPORTED_NATIVE_OPENAI_SLUGS.has(alias)) {
+    issues.push({
+      path: ["nativeAlias"],
+      message: "nativeAlias requires a currently supported bare OpenAI-native model alias",
+    });
+  }
+  if (nativeAlias && (typeof body.displayName !== "string" || body.displayName.trim().length === 0)) {
+    issues.push({ path: ["displayName"], message: "displayName is required for native aliases" });
+  }
 
   if (!Array.isArray(body.targets) || body.targets.length === 0) {
     issues.push({ path: ["targets"], message: "targets must be a non-empty array" });
@@ -271,11 +349,15 @@ export function comboConfigError(
 
 export function normalizeComboConfig(raw: OcxComboConfig): NormalizedComboConfig {
   const alias = typeof raw.alias === "string" ? raw.alias.trim() : "";
+  const displayName = typeof raw.displayName === "string" ? raw.displayName.trim() : "";
   return {
     strategy: raw.strategy ?? "failover",
     stickyLimit: raw.stickyLimit ?? 1,
     defaultEffort: raw.defaultEffort ?? null,
+    imageInput: raw.imageInput === "disabled" ? "disabled" : "auto",
     alias: alias || null,
+    nativeAlias: raw.nativeAlias === true,
+    displayName: displayName || null,
     targets: raw.targets.map(target => ({
       provider: target.provider.trim(),
       model: target.model.trim(),

package/src/compatibility/index.ts

@@ -0,0 +1,26 @@
+import { OPENAI_CODEX_FORWARD_GPT56_SOL_MANIFEST } from "./openai-responses";
+import type { CompatibilityManifestV1 } from "./manifest";
+
+export {
+  COMPATIBILITY_DISPOSITIONS,
+  COMPATIBILITY_MANIFEST_SCHEMA_VERSION,
+  compatibilityManifestIssues,
+  defineCompatibilityManifest,
+} from "./manifest";
+export type {
+  CompatibilityClaimV1,
+  CompatibilityDisposition,
+  CompatibilityEvidenceKind,
+  CompatibilityEvidenceRefV1,
+  CompatibilityManifestV1,
+  CompatibilitySubjectV1,
+} from "./manifest";
+export { OPENAI_CODEX_FORWARD_GPT56_SOL_MANIFEST } from "./openai-responses";
+
+export const COMPATIBILITY_MANIFESTS: readonly CompatibilityManifestV1[] = Object.freeze([
+  OPENAI_CODEX_FORWARD_GPT56_SOL_MANIFEST,
+]);
+
+export function getCompatibilityManifest(id: string): CompatibilityManifestV1 | undefined {
+  return COMPATIBILITY_MANIFESTS.find(manifest => manifest.id === id);
+}

package/src/compatibility/manifest.ts

@@ -0,0 +1,253 @@
+export const COMPATIBILITY_MANIFEST_SCHEMA_VERSION = 1 as const;
+
+export const COMPATIBILITY_DISPOSITIONS = [
+  "passthrough",
+  "translated",
+  "degraded",
+  "unsupported",
+] as const;
+
+export type CompatibilityDisposition = typeof COMPATIBILITY_DISPOSITIONS[number];
+export type CompatibilityEvidenceKind = "fixture" | "lab-scenario";
+
+export interface CompatibilityEvidenceRefV1 {
+  kind: CompatibilityEvidenceKind;
+  id: string;
+  /** Exact fixture assertions that prove this claim. Required for fixture evidence. */
+  assertionIds?: readonly string[];
+}
+
+export interface CompatibilityClaimV1 {
+  /** Stable manifest-local claim id. */
+  id: string;
+  /** Stable public feature key, such as `request.previous_response_id`. */
+  feature: string;
+  disposition: CompatibilityDisposition;
+  summary: string;
+  /** Required when behavior is not byte/semantic passthrough. */
+  limitation?: string;
+  evidence: readonly CompatibilityEvidenceRefV1[];
+}
+
+export interface CompatibilitySubjectV1 {
+  providerId: string;
+  /** Exact normalized provider base URL; destination changes require a new subject/version. */
+  baseUrl: string;
+  adapterId: string;
+  authMode: "forward" | "key" | "oauth" | "local";
+  inboundProtocol: "responses" | "chat" | "messages";
+  upstreamProtocol: string;
+  /** Claims apply only to these exact wire model ids. */
+  modelIds: readonly string[];
+}
+
+export interface CompatibilityManifestV1 {
+  schemaVersion: typeof COMPATIBILITY_MANIFEST_SCHEMA_VERSION;
+  id: string;
+  version: string;
+  subject: CompatibilitySubjectV1;
+  claims: readonly CompatibilityClaimV1[];
+}
+
+const ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,127}$/;
+const FEATURE_PATTERN = /^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)+$/;
+const DISPOSITIONS = new Set<string>(COMPATIBILITY_DISPOSITIONS);
+const EVIDENCE_KINDS = new Set<string>(["fixture", "lab-scenario"]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function checkKnownKeys(
+  value: Record<string, unknown>,
+  allowed: readonly string[],
+  path: string,
+  issues: string[],
+): void {
+  const allowedSet = new Set(allowed);
+  for (const key of Object.keys(value)) {
+    if (!allowedSet.has(key)) issues.push(`${path}${path ? "." : ""}${key} is not allowed by schema v1`);
+  }
+}
+
+function checkId(value: unknown, path: string, issues: string[]): value is string {
+  if (typeof value !== "string" || !ID_PATTERN.test(value)) {
+    issues.push(`${path} must match ${ID_PATTERN}`);
+    return false;
+  }
+  return true;
+}
+
+function checkNonBlank(value: unknown, path: string, issues: string[]): value is string {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    issues.push(`${path} must be a non-blank string`);
+    return false;
+  }
+  return true;
+}
+
+function checkNormalizedBaseUrl(value: unknown, path: string, issues: string[]): value is string {
+  if (typeof value !== "string") {
+    issues.push(`${path} must be a normalized absolute HTTP(S) base URL`);
+    return false;
+  }
+  try {
+    const parsed = new URL(value);
+    if (
+      (parsed.protocol !== "https:" && parsed.protocol !== "http:")
+      || parsed.username
+      || parsed.password
+      || parsed.search
+      || parsed.hash
+    ) {
+      issues.push(`${path} must be a normalized absolute HTTP(S) base URL without credentials, query, or fragment`);
+      return false;
+    }
+    const normalizedPath = parsed.pathname.replace(/\/+$/, "");
+    const normalized = `${parsed.origin}${normalizedPath}`;
+    if (value !== normalized) {
+      issues.push(`${path} must be normalized as ${normalized}`);
+      return false;
+    }
+    return true;
+  } catch {
+    issues.push(`${path} must be a normalized absolute HTTP(S) base URL`);
+    return false;
+  }
+}
+
+function checkSortedUniqueStrings(
+  value: unknown,
+  path: string,
+  issues: string[],
+  options: { nonEmpty?: boolean } = {},
+): value is string[] {
+  if (!Array.isArray(value) || (options.nonEmpty === true && value.length === 0)) {
+    issues.push(`${path} must be${options.nonEmpty === true ? " a non-empty" : " an"} array`);
+    return false;
+  }
+  if (value.some(item => typeof item !== "string" || item.trim().length === 0)) {
+    issues.push(`${path} must contain only non-blank strings`);
+    return false;
+  }
+  const strings = value as string[];
+  if (new Set(strings).size !== strings.length) issues.push(`${path} must not contain duplicates`);
+  const sorted = [...strings].sort();
+  if (strings.some((item, index) => item !== sorted[index])) issues.push(`${path} must be sorted`);
+  return true;
+}
+
+function checkEvidence(value: unknown, path: string, issues: string[]): void {
+  if (!Array.isArray(value) || value.length === 0) {
+    issues.push(`${path} must be a non-empty array`);
+    return;
+  }
+  const seen = new Set<string>();
+  value.forEach((raw, index) => {
+    const evidencePath = `${path}[${index}]`;
+    if (!isRecord(raw)) {
+      issues.push(`${evidencePath} must be an object`);
+      return;
+    }
+    checkKnownKeys(raw, ["kind", "id", "assertionIds"], evidencePath, issues);
+    if (!EVIDENCE_KINDS.has(String(raw.kind))) {
+      issues.push(`${evidencePath}.kind must be fixture or lab-scenario`);
+    }
+    const id = checkId(raw.id, `${evidencePath}.id`, issues) ? raw.id : "";
+    const assertionIds = raw.assertionIds;
+    if (raw.kind === "fixture") {
+      checkSortedUniqueStrings(assertionIds, `${evidencePath}.assertionIds`, issues, { nonEmpty: true });
+    } else if (assertionIds !== undefined) {
+      checkSortedUniqueStrings(assertionIds, `${evidencePath}.assertionIds`, issues, { nonEmpty: true });
+    }
+    const key = `${String(raw.kind)}:${id}:${JSON.stringify(assertionIds ?? [])}`;
+    if (seen.has(key)) issues.push(`${evidencePath} duplicates an earlier evidence reference`);
+    seen.add(key);
+  });
+}
+
+/**
+ * Validate one versioned compatibility manifest without importing provider or Lab state.
+ * Keeping this as a leaf lets future CLI/GUI readers load contracts without activating Lab.
+ */
+export function compatibilityManifestIssues(value: unknown): string[] {
+  const issues: string[] = [];
+  if (!isRecord(value)) return ["manifest must be an object"];
+  checkKnownKeys(value, ["schemaVersion", "id", "version", "subject", "claims"], "", issues);
+  if (value.schemaVersion !== COMPATIBILITY_MANIFEST_SCHEMA_VERSION) {
+    issues.push(`schemaVersion must be ${COMPATIBILITY_MANIFEST_SCHEMA_VERSION}`);
+  }
+  checkId(value.id, "id", issues);
+  checkNonBlank(value.version, "version", issues);
+
+  if (!isRecord(value.subject)) {
+    issues.push("subject must be an object");
+  } else {
+    checkKnownKeys(
+      value.subject,
+      ["providerId", "baseUrl", "adapterId", "authMode", "inboundProtocol", "upstreamProtocol", "modelIds"],
+      "subject",
+      issues,
+    );
+    checkId(value.subject.providerId, "subject.providerId", issues);
+    checkNormalizedBaseUrl(value.subject.baseUrl, "subject.baseUrl", issues);
+    checkId(value.subject.adapterId, "subject.adapterId", issues);
+    if (!["forward", "key", "oauth", "local"].includes(String(value.subject.authMode))) {
+      issues.push("subject.authMode must be forward, key, oauth, or local");
+    }
+    if (!["responses", "chat", "messages"].includes(String(value.subject.inboundProtocol))) {
+      issues.push("subject.inboundProtocol must be responses, chat, or messages");
+    }
+    checkNonBlank(value.subject.upstreamProtocol, "subject.upstreamProtocol", issues);
+    checkSortedUniqueStrings(value.subject.modelIds, "subject.modelIds", issues, { nonEmpty: true });
+  }
+
+  if (!Array.isArray(value.claims) || value.claims.length === 0) {
+    issues.push("claims must be a non-empty array");
+    return issues;
+  }
+  const claimIds = new Set<string>();
+  const claimFeatures = new Set<string>();
+  value.claims.forEach((raw, index) => {
+    const path = `claims[${index}]`;
+    if (!isRecord(raw)) {
+      issues.push(`${path} must be an object`);
+      return;
+    }
+    checkKnownKeys(raw, ["id", "feature", "disposition", "summary", "limitation", "evidence"], path, issues);
+    const id = checkId(raw.id, `${path}.id`, issues) ? raw.id : "";
+    if (id && claimIds.has(id)) issues.push(`${path}.id duplicates ${id}`);
+    if (id) claimIds.add(id);
+    if (typeof raw.feature !== "string" || !FEATURE_PATTERN.test(raw.feature)) {
+      issues.push(`${path}.feature must be a dotted stable feature key`);
+    } else if (claimFeatures.has(raw.feature)) {
+      issues.push(`${path}.feature duplicates ${raw.feature}`);
+    } else {
+      claimFeatures.add(raw.feature);
+    }
+    if (!DISPOSITIONS.has(String(raw.disposition))) {
+      issues.push(`${path}.disposition is invalid`);
+    }
+    checkNonBlank(raw.summary, `${path}.summary`, issues);
+    if (raw.disposition !== "passthrough") {
+      checkNonBlank(raw.limitation, `${path}.limitation`, issues);
+    } else if (raw.limitation !== undefined) {
+      issues.push(`${path}.limitation must be omitted for passthrough claims`);
+    }
+    checkEvidence(raw.evidence, `${path}.evidence`, issues);
+  });
+  return issues;
+}
+
+function deepFreeze<T>(value: T, seen = new WeakSet<object>()): Readonly<T> {
+  if (!value || typeof value !== "object" || seen.has(value)) return value;
+  seen.add(value);
+  for (const nested of Object.values(value as Record<string, unknown>)) deepFreeze(nested, seen);
+  return Object.freeze(value);
+}
+
+export function defineCompatibilityManifest<T extends CompatibilityManifestV1>(manifest: T): Readonly<T> {
+  const issues = compatibilityManifestIssues(manifest);
+  if (issues.length > 0) throw new TypeError(`Invalid compatibility manifest ${manifest.id}: ${issues.join("; ")}`);
+  return deepFreeze(manifest);
+}

package/src/compatibility/openai-responses.ts

@@ -0,0 +1,121 @@
+import { defineCompatibilityManifest } from "./manifest";
+
+const FIXTURE_ID = "openai-codex-forward-gpt56-sol-v1";
+
+/**
+ * First deliberately narrow compatibility slice: one exact native Codex-login model.
+ * Broader model/provider claims require their own fixtures instead of inheriting this row.
+ */
+export const OPENAI_CODEX_FORWARD_GPT56_SOL_MANIFEST = defineCompatibilityManifest({
+  schemaVersion: 1,
+  id: "openai.codex-forward.gpt-5-6-sol.responses",
+  version: "1.3.0",
+  subject: {
+    providerId: "openai",
+    baseUrl: "https://chatgpt.com/backend-api/codex",
+    adapterId: "openai-responses",
+    authMode: "forward",
+    inboundProtocol: "responses",
+    upstreamProtocol: "openai-responses",
+    modelIds: ["gpt-5.6-sol"],
+  },
+  claims: [
+    {
+      id: "custom-tools",
+      feature: "request.custom_tools",
+      disposition: "passthrough",
+      summary: "Native custom-tool declarations retain their Responses representation.",
+      evidence: [{ kind: "fixture", id: FIXTURE_ID, assertionIds: ["custom-tool-preserved"] }],
+    },
+    {
+      id: "prompt-cache-key",
+      feature: "request.prompt_cache_key",
+      disposition: "passthrough",
+      summary: "The caller's prompt cache key is forwarded unchanged.",
+      evidence: [{ kind: "fixture", id: FIXTURE_ID, assertionIds: ["prompt-cache-key-preserved"] }],
+    },
+    {
+      id: "previous-response-id",
+      feature: "request.previous_response_id",
+      disposition: "translated",
+      summary: "Continuation is owned by the proxy rather than the ChatGPT backend field.",
+      limitation: "OpenCodex expands remembered input locally and removes previous_response_id before dispatch.",
+      evidence: [
+        { kind: "fixture", id: FIXTURE_ID, assertionIds: ["previous-response-id-removed"] },
+        { kind: "lab-scenario", id: "codex-core.protocol.previous-response-replay" },
+      ],
+    },
+    {
+      id: "orphan-tool-output",
+      feature: "continuation.orphan_tool_output",
+      disposition: "degraded",
+      summary: "An output whose prior call is unavailable remains visible to the model.",
+      limitation: "The orphan output is converted to user text because the forward backend cannot accept the unmatched item.",
+      evidence: [{ kind: "fixture", id: FIXTURE_ID, assertionIds: ["orphan-output-converted"] }],
+    },
+    {
+      id: "max-output-tokens",
+      feature: "request.max_output_tokens",
+      disposition: "unsupported",
+      summary: "The ChatGPT Codex forward route does not receive max_output_tokens.",
+      limitation: "The field is removed before dispatch to avoid a backend parameter rejection.",
+      evidence: [{ kind: "fixture", id: FIXTURE_ID, assertionIds: ["max-output-tokens-removed"] }],
+    },
+    {
+      id: "metadata",
+      feature: "request.metadata",
+      disposition: "unsupported",
+      summary: "Caller metadata is not forwarded to the ChatGPT Codex backend.",
+      limitation: "The field is removed before dispatch.",
+      evidence: [{ kind: "fixture", id: FIXTURE_ID, assertionIds: ["metadata-removed"] }],
+    },
+    {
+      id: "system-input-messages",
+      feature: "request.input.system_messages",
+      disposition: "translated",
+      summary: "Text-only input system messages are folded into top-level instructions.",
+      limitation: "The destination does not accept system-role input items; multimodal system messages stay unchanged rather than being dropped.",
+      evidence: [{ kind: "fixture", id: FIXTURE_ID, assertionIds: ["system-message-folded", "system-message-removed"] }],
+    },
+    {
+      id: "truncation",
+      feature: "request.truncation",
+      disposition: "unsupported",
+      summary: "The ChatGPT Codex forward route does not receive truncation.",
+      limitation: "The field is removed only for the canonical forward destination; public and custom Responses providers keep it.",
+      evidence: [{ kind: "fixture", id: FIXTURE_ID, assertionIds: ["truncation-removed"] }],
+    },
+    {
+      id: "prompt-cache-breakpoint",
+      feature: "request.prompt_cache_breakpoint",
+      disposition: "unsupported",
+      summary: "Client-only prompt cache breakpoint markers do not reach the forward backend.",
+      limitation: "Markers are removed recursively from input within bounded depth and node budgets.",
+      evidence: [{ kind: "fixture", id: FIXTURE_ID, assertionIds: ["prompt-cache-breakpoint-removed"] }],
+    },
+    {
+      id: "unstored-item-reference",
+      feature: "continuation.item_reference",
+      disposition: "degraded",
+      summary: "Unpersisted item references are omitted from store-false continuations.",
+      limitation: "The referenced item cannot exist at the backend when store is false; tool call_id pairs remain unchanged.",
+      evidence: [{ kind: "fixture", id: FIXTURE_ID, assertionIds: ["unstored-item-reference-removed"] }],
+    },
+    {
+      id: "prompt-cache-retention",
+      feature: "request.prompt_cache_retention",
+      disposition: "unsupported",
+      summary: "The retired retention field is not sent for gpt-5.6-sol.",
+      limitation: "The field is removed without inventing a replacement prompt_cache_options value.",
+      evidence: [{ kind: "fixture", id: FIXTURE_ID, assertionIds: ["prompt-cache-retention-removed"] }],
+    },
+    {
+      id: "prompt-cache-options",
+      feature: "request.prompt_cache_options",
+      disposition: "unsupported",
+      summary: "The ChatGPT Codex forward route does not receive public prompt cache options.",
+      limitation: "The field is removed only for the canonical forward destination; public and custom Responses providers keep it.",
+      evidence: [{ kind: "fixture", id: FIXTURE_ID, assertionIds: ["prompt-cache-options-removed"] }],
+    },
+  ],
+} as const);