@yansigit/opencodex 2.33.1 → 2.35.0

package/src/server/sse-frame-buffer.ts

@@ -1,3 +1,5 @@
+import { isCyberPolicyCode, isCyberPolicyMessage } from "../lib/errors";
+
 export const MAX_CLIENT_SSE_FRAME_BYTES = 4 * 1024 * 1024;
 
 const LF_LF = Uint8Array.of(10, 10);
@@ -106,10 +108,35 @@ function isResponsesTerminalFrame(block: Uint8Array): boolean {
   const payload = data.join("\n");
   if (payload === "[DONE]") return false;
   try {
-    const parsed = JSON.parse(payload) as { type?: unknown };
-    return parsed.type === "response.completed"
+    const parsed = JSON.parse(payload) as {
+      type?: unknown;
+      code?: unknown;
+      message?: unknown;
+      error?: unknown;
+      last_error?: unknown;
+      response?: { error?: unknown; incomplete_details?: unknown };
+    };
+    if (parsed.type === "response.completed"
       || parsed.type === "response.failed"
-      || parsed.type === "response.incomplete";
+      || parsed.type === "response.incomplete") return true;
+    if (parsed.type !== "error") return false;
+    // A top-level error is terminal for this boundary only when it carries the
+    // same high-confidence cyber-policy evidence used by relay.ts. Ordinary
+    // upstream errors remain transport failures and still become a bounded 502.
+    const candidates = [
+      parsed,
+      parsed.error,
+      parsed.last_error,
+      parsed.response?.error,
+      parsed.response?.incomplete_details,
+    ];
+    for (const candidate of candidates) {
+      if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) continue;
+      const record = candidate as { code?: unknown; message?: unknown };
+      if (isCyberPolicyCode(typeof record.code === "string" ? record.code : undefined)) return true;
+      if (typeof record.message === "string" && isCyberPolicyMessage(record.message)) return true;
+    }
+    return false;
   } catch {
     return false;
   }
@@ -289,4 +316,4 @@ export function joinSseFrameBytes(parts: readonly Uint8Array[]): Uint8Array {
     offset += part.byteLength;
   }
   return joined;
-}
+}

package/src/server/ws-bridge.ts

@@ -34,9 +34,10 @@ export interface WsData {
   authContext?: CodexAuthContext; // last resolved account decision for observability/registry cleanup
   cancel?: () => void; // cancels the in-flight stream reader/fetch
   turnId?: number; // monotonically increasing per socket; prevents stale frames after replacement turns
+  /** Fixed-size logical session lane derived at the HTTP upgrade boundary. */
+  sessionLaneId?: string;
   /** Discriminator: Responses reframing vs transparent live/realtime sideband relay. */
-  kind?: "responses" | "live-sideband" | "aistudio-relay";
-  aistudioSessionId?: string;
+  kind?: "responses" | "live-sideband";
   liveUpstream?: WebSocket;
   liveUpstreamUrl?: string;
   liveUpstreamHeaders?: Record<string, string>;
@@ -61,10 +62,20 @@ export interface WsData {
  * A test that only asserts "the socket opened" would still pass if the admission
  * were dropped from the payload, so the payload itself is what gets asserted.
  */
-export function buildResponsesWsData(headers: Headers, admission: DataPlaneAdmission, admissionLease?: AdmissionReservation<ServerWebSocket<WsData>>): WsData {
+export function buildResponsesWsData(
+  headers: Headers,
+  admission: DataPlaneAdmission,
+  admissionLease?: AdmissionReservation<ServerWebSocket<WsData>>,
+  sessionLaneId?: string,
+): WsData {
   // Auth is handshake-time only on this path: the per-frame contexts have no
   // request headers left to re-resolve from, so the decision rides along here.
-  return { headers, admission, ...(admissionLease ? { admissionLease } : {}) };
+  return {
+    headers,
+    admission,
+    ...(admissionLease ? { admissionLease } : {}),
+    ...(sessionLaneId ? { sessionLaneId } : {}),
+  };
 }
 
 export class WsSendDroppedError extends Error {

package/src/telemetry/dispatcher.ts

@@ -0,0 +1,44 @@
+import type { LedgerRecord } from "./types";
+
+export type GhCommandRunner = (args: string[]) => Promise<string>;
+
+export interface AutonomousRemediationConfig {
+  autonomousRemediation?: { enabled?: boolean; instanceId?: string };
+}
+
+export type DispatchResult =
+  | { status: "skipped"; reason: "unauthorized" | "invalid-record" }
+  | { status: "dispatched"; issueNumber?: number; issueUrl?: string; existing: boolean };
+
+const defaultRunner: GhCommandRunner = async args => {
+  const proc = Bun.spawn(["gh", ...args], { stdout: "pipe", stderr: "pipe" });
+  return await new Response(proc.stdout).text();
+};
+
+export async function dispatchAutonomousFix(
+  record: LedgerRecord,
+  config: AutonomousRemediationConfig,
+  run: GhCommandRunner = defaultRunner,
+): Promise<DispatchResult> {
+  const authorization = config.autonomousRemediation;
+  const eventInstance = typeof record.details?.instanceId === "string" ? record.details.instanceId : undefined;
+  if (authorization?.enabled !== true || !authorization.instanceId || (eventInstance !== undefined && eventInstance !== authorization.instanceId)) {
+    return { status: "skipped", reason: "unauthorized" };
+  }
+  if (!record.fingerprint) return { status: "skipped", reason: "invalid-record" };
+
+  const search = await run(["issue", "list", "--repo", "yansigit/opencodex", "--state", "open", "--search", `fingerprint:${record.fingerprint}`]);
+  const existing = search.match(/(?:^|\D)(\d+)(?:\D|$)/);
+  if (existing) {
+    const issueNumber = Number(existing[1]);
+    return { status: "dispatched", issueNumber, existing: true };
+  }
+
+  const metadata = { fingerprint: record.fingerprint, instanceId: authorization.instanceId, firstSeen: record.firstSeen, lastSeen: record.lastSeen, count: record.count, ...(record.details ?? {}) };
+  const body = `<!-- opencodex-failure-telemetry ${JSON.stringify(metadata)} -->\n\nFailure fingerprint: ${record.fingerprint}\n\nThis issue was dispatched by the verified local telemetry instance.`;
+  const title = `Autonomous fix: ${String(record.details?.failureKind ?? "failure")} (${record.fingerprint})`;
+  const created = await run(["issue", "create", "--repo", "yansigit/opencodex", "--title", title, "--body", body, "--label", "agent:jules,autonomous-fix,instance:verified"]);
+  const url = created.match(/https?:\/\/\S+/)?.[0];
+  const issueNumber = url?.match(/\/issues\/(\d+)/)?.[1];
+  return { status: "dispatched", existing: false, ...(url ? { issueUrl: url } : {}), ...(issueNumber ? { issueNumber: Number(issueNumber) } : {}) };
+}

package/src/telemetry/fingerprint.ts

@@ -0,0 +1,24 @@
+import { createHash } from "node:crypto";
+import type { FailureEvent, FailureFingerprint } from "./types";
+
+const EPHEMERAL_KEYS = /^(timestamp|.*(?:request|session)[_-]?id|line|column|col)$/i;
+const EPHEMERAL_TEXT = [
+  /\b(?:request|session)[_-]?id\s*[:=]\s*[^\s,;]+/gi,
+  /\b(?:timestamp|time)\s*[:=]\s*[^\s,;]+/gi,
+  /:\d+\s*:\s*\d+(?=\b|\D)/g,
+  /\b(?:line|col(?:umn)?)\s*[:=]?\s*\d+/gi,
+  /\b\d{10,13}\b/g,
+];
+
+function canonical(value: unknown): unknown {
+  if (typeof value === "string") return EPHEMERAL_TEXT.reduce((text, pattern) => text.replace(pattern, ""), value).replace(/\s+/g, " ").trim();
+  if (Array.isArray(value)) return value.map(canonical);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).filter(([key]) => !EPHEMERAL_KEYS.test(key)).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, canonical(item)]));
+  }
+  return value;
+}
+
+export function computeFailureFingerprint(event: FailureEvent): FailureFingerprint {
+  return createHash("sha256").update(JSON.stringify(canonical(event))).digest("hex");
+}

package/src/telemetry/hook.ts

@@ -0,0 +1,43 @@
+import { resolveAutonomousRemediationConfig, type AutonomousRemediationConfig } from "../config/autonomous-remediation";
+import { TelemetryLedger } from "./ledger";
+import type { LedgerRecord } from "./types";
+
+export type RuntimeFailureCategory = "websocket_1006" | "tool_repetition_loop" | "upstream_wire_error";
+
+export interface RuntimeFailureContext {
+  category?: RuntimeFailureCategory;
+  provider?: string;
+  model?: string;
+  requestId?: string;
+  sessionId?: string;
+  timestamp?: number;
+  config?: AutonomousRemediationConfig | unknown;
+  ledger?: TelemetryLedger;
+}
+
+let defaultLedger: TelemetryLedger | undefined;
+
+function categoryFor(error: unknown, requested?: RuntimeFailureCategory): RuntimeFailureCategory {
+  if (requested) return requested;
+  const message = error instanceof Error ? error.message : String(error);
+  if (/1006|abnormal closure|websocket/i.test(message)) return "websocket_1006";
+  if (/tool.{0,32}(repeat|loop)|(?:repeat|loop).{0,32}tool/i.test(message)) return "tool_repetition_loop";
+  return "upstream_wire_error";
+}
+
+export function interceptRuntimeFailure(error: unknown, context: RuntimeFailureContext = {}): LedgerRecord | null {
+  const config = resolveAutonomousRemediationConfig(context.config);
+  if (!config.enabled) return null;
+  const ledger = context.ledger ?? (defaultLedger ??= new TelemetryLedger());
+  const category = categoryFor(error, context.category);
+  const signature = error instanceof Error ? error.message : String(error);
+  return ledger.recordFailure({
+    failureKind: category,
+    signature,
+    ...(context.provider ? { provider: context.provider } : {}),
+    ...(context.model ? { model: context.model } : {}),
+    ...(context.requestId ? { requestId: context.requestId } : {}),
+    ...(context.sessionId ? { sessionId: context.sessionId } : {}),
+    ...(context.timestamp !== undefined ? { timestamp: context.timestamp } : {}),
+  }, config.rollingWindowMs);
+}

package/src/telemetry/ledger.ts

@@ -0,0 +1,54 @@
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { computeFailureFingerprint } from "./fingerprint";
+import type { FailureEvent, FailureFingerprint, LedgerRecord, RemediationStatus } from "./types";
+
+type Stored = LedgerRecord & { occurrences: number[] };
+
+export class TelemetryLedger {
+  private readonly db: Database;
+
+  constructor(path = join(homedir(), ".opencodex", "telemetry-issues.sqlite")) {
+    if (path !== ":memory:") mkdirSync(dirname(path), { recursive: true });
+    this.db = new Database(path, { create: true });
+    this.db.run("CREATE TABLE IF NOT EXISTS failure_events (fingerprint TEXT PRIMARY KEY, first_seen INTEGER NOT NULL, last_seen INTEGER NOT NULL, count INTEGER NOT NULL, status TEXT NOT NULL, details TEXT, occurrences TEXT NOT NULL)");
+  }
+
+  recordFailure(event: FailureEvent, windowMs: number): LedgerRecord {
+    const fingerprint = computeFailureFingerprint(event);
+    const timestamp = event.timestamp ?? Date.now();
+    const old = this.db.query("SELECT * FROM failure_events WHERE fingerprint = ?").get(fingerprint) as Stored | null;
+    const occurrences = [...(old ? JSON.parse((old as unknown as { occurrences: string }).occurrences) : []), timestamp].filter((seen) => seen >= timestamp - windowMs).sort((a, b) => a - b);
+    const record: LedgerRecord = { fingerprint, firstSeen: old?.firstSeen ?? timestamp, lastSeen: timestamp, count: occurrences.length, status: old?.status ?? "monitoring", ...(old?.details ? { details: JSON.parse(old.details as unknown as string) } : {}) };
+    this.db.query("INSERT INTO failure_events (fingerprint, first_seen, last_seen, count, status, details, occurrences) VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(fingerprint) DO UPDATE SET first_seen=excluded.first_seen, last_seen=excluded.last_seen, count=excluded.count, status=excluded.status, details=excluded.details, occurrences=excluded.occurrences").run(fingerprint, record.firstSeen, timestamp, record.count, record.status, record.details ? JSON.stringify(record.details) : null, JSON.stringify(occurrences));
+    return record;
+  }
+
+  getRecord(fingerprint: FailureFingerprint): LedgerRecord | null {
+    const row = this.db.query("SELECT fingerprint, first_seen, last_seen, count, status, details FROM failure_events WHERE fingerprint = ?").get(fingerprint) as Record<string, unknown> | null;
+    if (!row) return null;
+    return { fingerprint: row.fingerprint as string, firstSeen: row.first_seen as number, lastSeen: row.last_seen as number, count: row.count as number, status: row.status as RemediationStatus, ...(row.details ? { details: JSON.parse(row.details as string) } : {}) };
+  }
+
+  listRecords(): LedgerRecord[] {
+    return this.db.query("SELECT fingerprint, first_seen, last_seen, count, status, details FROM failure_events ORDER BY last_seen DESC").all().map(row => {
+      const value = row as Record<string, unknown>;
+      return { fingerprint: value.fingerprint as string, firstSeen: value.first_seen as number, lastSeen: value.last_seen as number, count: value.count as number, status: value.status as RemediationStatus, ...(value.details ? { details: JSON.parse(value.details as string) } : {}) };
+    });
+  }
+
+  updateStatus(fingerprint: FailureFingerprint, status: RemediationStatus, details?: Record<string, unknown>): void {
+    this.db.query("UPDATE failure_events SET status = ?, details = ? WHERE fingerprint = ?").run(status, details ? JSON.stringify(details) : null, fingerprint);
+  }
+
+  shouldDispatch(fingerprint: FailureFingerprint, threshold: number, windowMs: number): boolean {
+    const row = this.db.query("SELECT status, last_seen, occurrences FROM failure_events WHERE fingerprint = ?").get(fingerprint) as { status: RemediationStatus; last_seen: number; occurrences: string } | null;
+    if (!row || row.status !== "monitoring") return false;
+    const count = (JSON.parse(row.occurrences) as number[]).filter((seen) => seen >= row.last_seen - windowMs).length;
+    return count >= threshold;
+  }
+
+  close(): void { this.db.close(); }
+}

package/src/telemetry/types.ts

@@ -0,0 +1,23 @@
+export type RemediationStatus = "monitoring" | "dispatched" | "fixed" | "ignored";
+
+export interface FailureEvent {
+  failureKind: string;
+  provider?: string;
+  model?: string;
+  signature: string;
+  timestamp?: number;
+  requestId?: string;
+  sessionId?: string;
+  [key: string]: unknown;
+}
+
+export type FailureFingerprint = string;
+
+export interface LedgerRecord {
+  fingerprint: FailureFingerprint;
+  firstSeen: number;
+  lastSeen: number;
+  count: number;
+  status: RemediationStatus;
+  details?: Record<string, unknown>;
+}

package/src/types/config.ts

@@ -255,8 +255,19 @@ export interface OcxSubagentRole {
   enabled?: boolean;
 }
 
+export interface OcxConfigRebaseProvenance {
+  version: 1;
+  deletedTopLevelKeys: string[];
+}
+
 export interface OcxConfig {
   port: number;
+  autonomousRemediation?: {
+    enabled?: boolean;
+    instanceId?: string;
+    threshold?: number;
+    rollingWindowMs?: number;
+  };
   /** Opt in to one identical-turn retry when a Responses completion has no text or tool call. */
   emptyCompletionRetry?: boolean;
   /**
@@ -276,6 +287,22 @@ export interface OcxConfig {
   managementUsageMaxReadBytes?: number;
   providers: Record<string, OcxProviderConfig>;
   defaultProvider: string;
+  /** Persisted state for newly discovered provider models (#2464). Absent keeps legacy "on" behavior. */
+  modelDiscovery?: {
+    newModelPolicy?: "on" | "off";
+    knownModels?: Record<string, {
+      ids: string[];
+      removed: string[];
+      updatedAt: string;
+      /** Consecutive successful discoveries in which an active id was absent. */
+      missing?: Record<string, number>;
+    }>;
+    recentArrivals?: Record<string, Array<{ id: string; at: string }>>;
+  };
+  /** Enable the shipped model alias patterns for providers without an override. */
+  defaultModelAliases?: boolean;
+  /** Explicit top-level deletion intent used by stale whole-config rebases. */
+  configRebaseProvenance?: OcxConfigRebaseProvenance | Record<string, unknown>;
   /** OpenAI provider-contract migration marker (v2 = single `openai` provider with account mode). */
   openaiProviderTierVersion?: 1 | 2;
   /** One-time migration marker for Antigravity's static-catalog defaults. */
@@ -294,12 +321,7 @@ export interface OcxConfig {
    * into a selector-qualified group; Codex still advertises only the first 5 visible rows.
    */
   subagentModels?: string[];
-  /**
-   * Named specialist roles the parent may spawn: id, when-to-use description,
-   * model, optional effort, and child developer instructions. Max 8 roles and
-   * 5 unique enabled models (the spawn picker window). Do not store
-   * `model_fallback` here — use `subagentModelFallbackByModel`.
-   */
+  /** Named specialist roles the parent may spawn by id. */
   subagentRoles?: OcxSubagentRole[];
   /**
    * Project enabled roles into marker-owned `$CODEX_HOME/agents/ocx-<id>.toml`.
@@ -338,6 +360,10 @@ export interface OcxConfig {
    * reject the whole role file as an unknown field (#1190).
    */
   subagentModelFallbackByModel?: Record<string, string[]>;
+  /**
+   * Ordered candidates for spawned sub-agents, globally or keyed by role/model.
+   */
+  subagentCandidates?: string[] | Record<string, string[]>;
   /**
    * TTL (ms) for cached sub-agent model availability probes. Default 60_000.
    */
@@ -402,9 +428,7 @@ export interface OcxConfig {
    * remain unchanged),
    * `{{effort}}` -> injectionEffort, `{{roster}}` -> the resolved sub-agent roster
    * block ("" when nothing resolves), `{{fallback}}` -> the configured subagent
-   * model fallback guidance block ("" when unset), `{{roles}}` -> the compact
-   * enabled role catalog ("" when none). A custom prompt replaces the built-in
-   * body; include `{{roles}}` to keep the catalog.
+   * model fallback guidance block ("" when unset).
    */
   injectionPrompt?: string;
   /**
@@ -468,12 +492,12 @@ export interface OcxConfig {
    * Routed parents get v2 tools; Sol/Terra can still spawn Grok/Claude (issue #92).
    */
   keepNativeChatGptOnV1?: boolean;
-  /** Experimental routed target for eligible native V2 root parents. */
+  /** Optional v2-native parent override for spawn_agent routing. */
   v2NativeParentOverride?: { enabled?: boolean; model?: string };
   /** Experimental, default-off ChatGPT recovery for encrypted V2 routed tasks. */
   agentTaskRecovery?: {
     enabled?: boolean;
-    /** ChatGPT model used by the recovery request. Default: gpt-5.6-luna. */
+    /** ChatGPT model used by the recovery request. Default: gpt-5.6-sol. */
     model?: string;
     /** Recovery request timeout in milliseconds. Default: 45000. */
     timeoutMs?: number;
@@ -516,6 +540,13 @@ export interface OcxConfig {
    * those are unset — Bun's fetch honors them for all outbound calls; localhost is excluded.
    */
   proxy?: string;
+  /**
+   * Hosts that bypass `proxy` for OpenCodex's own outbound provider calls, merged into
+   * NO_PROXY at startup. Accepts a comma-separated string (NO_PROXY syntax) or an array.
+   * Loopback is always excluded regardless of this setting, and an inherited NO_PROXY is
+   * preserved — this ADDS entries, it never replaces the environment.
+   */
+  noProxy?: string | string[];
   /**
    * Upstream stall timeout (seconds). After this many seconds of no upstream data, emits
    * response.incomplete. Default 300. Min 1.
@@ -587,6 +618,15 @@ export interface OcxConfig {
    * selector map remains visible for compatibility with hand-written configurations.
    */
   codexAccountPickerEnabled?: boolean;
+  /**
+   * Show the GPT-5.3-Codex-Spark weekly window on Codex quota surfaces. Default false.
+   *
+   * Spark is a single-model window that reads 0% for most operators, and on a multi-account
+   * pool it doubles the bar count for information almost nobody acts on. Hidden by default and
+   * revealed by an explicit `true`; a malformed value reads as hidden rather than rejecting the
+   * whole config.
+   */
+  showCodexSparkQuota?: boolean;
   /** Active pool account id for next session. undefined = main (passthrough as-is). */
   activeCodexAccountId?: string;
   /** Auto-switch threshold (0-100). Default 80. 0 = disabled. */
@@ -617,10 +657,22 @@ export interface OcxConfig {
     stickyLimit?: number;
   };
   /**
-   * Opt-in Cursor OAuth account pool. Default OFF.
-   * Sticky `_clientThreadId` affinity + bounded 429/auth failover when ≥2 OAuth accounts exist.
-   * Does not wire weighted-round-robin `CursorCredentialRouter`.
+   * Generic OAuth multi-account 429 failover (#2568). Presence-driven by default.
+   *
+   * Rotates to another logged-in account of the SAME provider when one is rate-limited, for
+   * OAuth providers that have no pool of their own — xAI, Cursor, Kimi, GitHub Copilot,
+   * Antigravity, Nous. The Codex pool and the Anthropic pool own their own rotation and are
+   * excluded; this setting changes neither.
+   *
+   * With the key absent, rotation activates when a provider has 2 or more eligible stored
+   * accounts — the same consent rule API-key pools already apply to a 2+ key pool (#2568d). A
+   * single account is a strict no-op. Set `false` to keep strict single-account behaviour;
+   * `providers.<name>.oauthAccountFailover` overrides this per provider.
    */
+  oauthAccountFailover?: {
+    enabled?: boolean;
+  };
+  /** Cursor OAuth account pool rotation for api2.cursor.sh. */
   cursorAccountPool?: {
     enabled?: boolean;
   };

package/src/types/provider.ts

@@ -119,6 +119,15 @@ export interface TierObservationContext {
   fastWire: FastWire | null;
   demandDecision: "force-fast" | "force-default" | "inherit";
   callerTier?: string;
+  /**
+   * Whether the destination's echoed `service_tier` is authoritative about Fast scheduling.
+   *
+   * The ChatGPT-internal Codex backend returns `service_tier: "default"` on turns that were in
+   * fact scheduled as priority, so treating its echo as a downgrade produced a false
+   * `response-declined` on every Fast request (#2558). Absent means "assume authoritative",
+   * preserving the behaviour for the public API where the echo does mean what it says.
+   */
+  responseTierAuthoritative?: boolean;
 }
 
 export type TierDecision =
@@ -131,6 +140,12 @@ export type TierDecision =
  * retries are allowed; OAuth/forward credentials and local runtimes are never replayed.
  */
 export interface OcxProviderConfig {
+  /** Optional short provider namespace used only at request/catalog presentation time. */
+  alias?: string;
+  /** Native model id -> short, slash-free request alias. */
+  modelAliases?: Record<string, string>;
+  /** Override the global built-in model-alias switch for this provider. */
+  defaultAliases?: boolean;
   adapter: string;
   /**
    * Codex tool calling mode for routed models.
@@ -227,6 +242,19 @@ export interface OcxProviderConfig {
    * link-local, or unique-local upstreams. Metadata endpoints remain blocked.
    */
   allowPrivateNetwork?: boolean;
+  /**
+   * ChatGPT Codex backend WebSocket upstream transport.
+   * Defaults to false (routes streaming turns over standard HTTP/SSE).
+   * Set `true` to opt into the faster responses_websockets transport.
+   * `OCX_CODEX_WS_UPSTREAM=true` or `1` also enables it when this is omitted;
+   * `false` and `0` disable it. Invalid or absent values default to HTTP/SSE.
+   */
+  wsUpstream?: boolean;
+  /**
+   * Maximum WebSocket request frame size in bytes before routing over standard HTTP/SSE.
+   * Defaults to CODEX_WS_CREATE_FRAME_LIMIT_BYTES (~16 MiB minus margin).
+   */
+  maxWsFrameBytes?: number;
   /**
    * Pin the HTTP version used for upstream provider requests. Bun's fetch negotiates
    * HTTP/2 via TLS ALPN by default; some Cloudflare-fronted SSE endpoints hang on
@@ -284,6 +312,33 @@ export interface OcxProviderConfig {
    * full set so the user can pick). See devlog issue_052_provider-model-allowlist.
    */
   selectedModels?: string[];
+  /** Override for newly discovered models. Absent/"inherit" uses the install policy. */
+  newModelPolicy?: "on" | "off" | "inherit";
+  /**
+   * Model-preset marker for `selectedModels` (#2465). Absent means "all", exactly today's
+   * semantics — an existing provider is never narrowed by an upgrade.
+   *
+   * The preset is a SEED, not a lock: `selectedModels` holds concrete ids materialized from
+   * the shipped rules, so every existing consumer and older binaries keep working against a
+   * plain allowlist. Divergence is detected at the WRITE path rather than by diffing — any user
+   * edit while the mode is "preset" flips it to "custom", after which the proxy never
+   * re-materializes. That collapses upgrade reconciliation to a version compare.
+   *
+   * Deliberately distinct from `deriveProviderPresets`, which curates WHICH PROVIDERS to offer.
+   * This curates which MODELS a provider exposes; the code says "model preset" throughout.
+   */
+  modelPreset?: {
+    mode: "preset" | "all" | "custom";
+    /** MODEL_PRESETS version materialized into `selectedModels`. */
+    appliedVersion?: number;
+    appliedAt?: string;
+    /**
+     * Set when materialization matched nothing and the provider fell back to "all". A preset
+     * must never write an empty allowlist, because empty means ALL and would silently
+     * un-curate; the fallback marker lets the next convergence retry.
+     */
+    fallback?: "preset-empty";
+  };
   /** Provider-wide fallback when context metadata is absent; otherwise caps the reported window. */
   contextWindow?: number;
   /** Per-model fallback when context metadata is absent; otherwise caps the reported window. */
@@ -327,6 +382,16 @@ export interface OcxProviderConfig {
    * providers whose registry entry declares authKind "local" (management API enforces).
    */
   authMode?: "key" | "forward" | "oauth" | "local";
+  /**
+   * Per-provider override for generic OAuth multi-account 429 failover (#2568).
+   *
+   * Rotation is presence-driven by default — 2+ logged-in accounts activate it — so this exists
+   * for the operator who accepts rotation on one provider and refuses it on another. An explicit
+   * boolean here beats the global `oauthAccountFailover` and beats presence.
+   */
+  oauthAccountFailover?: {
+    enabled?: boolean;
+  };
   /** Allow an explicitly key/oauth provider to run without a credential (for keyless local proxies). */
   keyOptional?: boolean;
   /**
@@ -359,6 +424,18 @@ export interface OcxProviderConfig {
    * Responses backend rejects Codex summary-delivery fields for that model.
    */
   modelSupportsReasoningSummaries?: Record<string, boolean>;
+  /**
+   * Model-specific Codex Responses verbosity capability. Set false when the upstream ignores
+   * `text.verbosity`; the catalog hides the no-op picker and the Responses adapter strips stale
+   * or caller-supplied values while preserving other `text` fields.
+   */
+  modelSupportsVerbosity?: Record<string, boolean>;
+  /**
+   * Provider-wide Codex Responses verbosity capability, applied to models the per-model map
+   * does not enumerate (a live-discovered id, for example). Materialized from the registry at
+   * seed/enrich time so the catalog hint pass never has to read PROVIDER_REGISTRY.
+   */
+  supportsVerbosity?: boolean;
   /**
    * Per-model wire value for Responses `stream_options.reasoning_summary_delivery`.
    * Presence also advertises reasoning-summary support for that routed model.

package/src/types/request.ts

@@ -72,6 +72,8 @@ export interface OcxParsedRequest {
   _promptCacheKeyIsSharedCohort?: boolean;
   /** Provider-private Command Code session affinity id, stable across in-process request mutation. */
   _commandCodeSessionId?: string;
+  /** Cursor-only thread owner; may be an opaque process-local Desktop session/thread identity. */
+  _cursorClientThreadId?: string;
   /** Conversation/provider/account/model-bound namespace for reasoning replay state. */
   _reasoningReplayScope?: OcxReasoningReplayScopeRef;
   /**
@@ -90,7 +92,7 @@ export interface OcxParsedRequest {
    */
   _cursorIsolateConversation?: boolean;
   /** Account-scoped, non-secret Kiro request metadata selected with the OAuth access token. */
-  _kiroAuthContext?: Pick<KiroOAuthMetadata, "profileArn" | "apiRegion" | "ssoRegion">;
+  _kiroAuthContext?: Pick<KiroOAuthMetadata, "profileArn" | "apiRegion" | "ssoRegion" | "authType">;
   /** Provider-private continuation metadata resolved from the Responses previous_response_id chain. */
   _providerContinuation?: OcxProviderContinuationState;
   /** Persisted continuation considered only after the final physical route is known. */
@@ -198,8 +200,14 @@ export interface OcxImageContent {
   detail?: string;
 }
 
-/** A user/developer message content part: text or an image (vision). */
-export type OcxContentPart = OcxTextContent | OcxImageContent;
+export interface OcxVideoContent {
+  type: "video";
+  /** A base64 `data:` URL from an OpenAI-compatible `video_url` part. */
+  videoUrl: string;
+}
+
+/** A user/developer message content part: text or native media. */
+export type OcxContentPart = OcxTextContent | OcxImageContent | OcxVideoContent;
 
 export interface OcxThinkingContent {
   type: "thinking";
@@ -260,13 +268,9 @@ export interface OcxRequestOptions {
   /**
    * Responses `text.format` (json_schema / json_object), preserved for adapters whose
    * upstream wire has an equivalent. The openai-chat adapter re-nests it as chat
-   * `response_format`, the exact inverse of responseFormatToText in src/chat/inbound.ts; the
-   * Google adapter lowers supported requests to Gemini JSON mode (`responseMimeType` /
-   * `responseSchema`) but skips requests with tools, Claude models, or image-capable models.
-   * The `openai-chat` adapter can omit it for models in `noStructuredOutputModels`; Kiro
-   * rejects structured output via `_structuredOutput`; and Cursor has no structured-output
-   * wire field and rejects the request before transport.
-   * Native passthrough does not consume this option and forwards `_rawBody.text` verbatim.
+   * `response_format`, the exact inverse of responseFormatToText in src/chat/inbound.ts.
+   * The native passthrough ignores it (it forwards `_rawBody.text` verbatim) and Kiro
+   * keeps rejecting structured output via `_structuredOutput`.
    */
   textFormat?: {
     type: "json_schema" | "json_object";
@@ -292,10 +296,12 @@ export type GoogleSafetyThreshold =
   | "BLOCK_ONLY_HIGH"
   | "BLOCK_NONE"
   | "OFF";
+
 export interface GoogleSafetySetting {
   category: GoogleSafetyCategory;
   threshold: GoogleSafetyThreshold;
 }
+
 export interface GoogleProviderOptions {
   thinkingBudget?: number;
   includeThoughts?: boolean;