@bitkyc08/opencodex 2.57.0 → 2.58.0

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

@@ -437,20 +437,42 @@ export const deepseekReasoningMapFor = (modelId: string): Record<string, string>
 // Coding Plan: the products use different exact allowlists and different base URLs.
 // Evidence: https://help.aliyun.com/en/model-studio/token-plan-personal-overview
 //           https://help.aliyun.com/en/model-studio/token-plan-quickstart
+// 260909 refresh, re-probed against the live gateway (both regions, both tiers):
+// https://github.com/oliver-mee/alibaba-token-plan-wiki (machine-readable catalog).
+// glm-5.3 / glm-5.3-flash removed from both Token Plan catalogs: they exist on Z.AI
+// endpoints but the Token Plan gateway has never served either id (the 260826 seed
+// propagated them across every GLM-carrying catalog; a selected row 404s).
+// The Beijing preset keeps the Personal Edition subset; non-chat ids (audio/image/
+// video families) stay out: they answer only on async endpoints openai-chat cannot
+// reach. deepseek-v4-pro-0813 is callable but NOT listed by /models, which is the
+// reason liveModels must stay false for this provider. deepseek-v4.1-flash is the
+// 260910 DeepSeek rename row: listed on /models on both tiers and regions from 260915,
+// hybrid thinking, vision via user message and tool result, json_object but not
+// json_schema (see noJsonSchemaModels on the entries).
+// Beijing serves the Personal Edition, so this is the Personal-tier roster probed
+// 260909 (a strict subset of Team). deepseek-v4-pro-0813 stays out of the Beijing
+// entry: its callability is only proven on Team keys, and no Personal key has been
+// shown to reach it. The Beijing entry also shares the intl maps, so it carries a
+// few orphan keys (kimi/glm-5/MiniMax rows); harmless, and one map beats two
+// drifting ones.
 export const ALIBABA_TOKEN_PLAN_MODELS = [
-  "qwen3.8-max", "qwen3.7-max", "qwen3.7-plus", "qwen3.6-flash",
-  "glm-5.3", "glm-5.3-flash", "glm-5.2", 
+  "qwen3.8-max", "qwen3.8-flash", "qwen3.7-max", "qwen3.7-plus", "qwen3.6-flash",
+  "deepseek-v4-pro", "deepseek-v4-flash-0731", "deepseek-v4.1-flash", "glm-5.2",
 ];
 export const ALIBABA_TOKEN_PLAN_QWEN_MODELS = [
-  "qwen3.8-max", "qwen3.7-max", "qwen3.7-plus", "qwen3.6-flash",
+  "qwen3.8-max", "qwen3.8-flash", "qwen3.7-max", "qwen3.7-plus", "qwen3.6-flash",
 ];
 export const ALIBABA_TOKEN_PLAN_INPUT_MODALITIES: Record<string, string[]> = {
   "qwen3.8-max": ["text", "image"],
-  "qwen3.7-max": ["text", "image"],
+  "qwen3.8-flash": ["text", "image"],
+  "qwen3.7-max": ["text"],
   "qwen3.7-plus": ["text", "image"],
   "qwen3.6-flash": ["text", "image"],
-  "glm-5.3": ["text"],
-  "glm-5.3-flash": ["text", "image"],
+  "deepseek-v4-pro": ["text"],
+  "deepseek-v4-pro-0813": ["text"],
+  "deepseek-v4-flash-0731": ["text"],
+  // Vision probed on the plan gateway 260915 (user message and tool result, both 200).
+  "deepseek-v4.1-flash": ["text", "image"],
   "glm-5.2": ["text"],
 };
 
@@ -458,15 +480,18 @@ export const ALIBABA_TOKEN_PLAN_INPUT_MODALITIES: Record<string, string[]> = {
 // Multi-vendor lineup distinct from Beijing — includes DeepSeek V4 flash, Kimi K2.7, MiniMax.
 // Evidence: https://www.alibabacloud.com/help/en/model-studio/token-plan-overview
 //           https://qwencloud.com/pricing/token-plan (qwen3.8 metadata)
+// The Team Edition roster (Singapore), verified identical to the CN Team set on 260909.
+// deepseek-v4-pro is restored: it remains callable on the plan gateway (probed 260909,
+// listed on /models on both regions) after being dropped as "retired" upstream.
 export const ALIBABA_INTL_TOKEN_PLAN_MODELS = [
-  "qwen3.8-max", "qwen3.7-max", "qwen3.7-plus", "qwen3.6-plus", "qwen3.6-flash",
-  "deepseek-v4-flash", "deepseek-v3.2",
+  "qwen3.8-max", "qwen3.8-flash", "qwen3.7-max", "qwen3.7-plus", "qwen3.6-plus", "qwen3.6-flash",
+  "deepseek-v4-pro", "deepseek-v4-pro-0813", "deepseek-v4-flash", "deepseek-v4-flash-0731", "deepseek-v4.1-flash", "deepseek-v3.2",
   "kimi-k2.7-code", "kimi-k2.6", "kimi-k2.5",
-  "glm-5.3", "glm-5.3-flash", "glm-5.2", "glm-5.1", "glm-5",
+  "glm-5.2", "glm-5.1", "glm-5",
   "MiniMax-M2.5",
 ];
 export const ALIBABA_INTL_TOKEN_PLAN_QWEN_MODELS = [
-  "qwen3.8-max", "qwen3.7-max", "qwen3.7-plus", "qwen3.6-plus", "qwen3.6-flash",
+  "qwen3.8-max", "qwen3.8-flash", "qwen3.7-max", "qwen3.7-plus", "qwen3.6-plus", "qwen3.6-flash",
 ];
 
 // 260722 Tencent Cloud Coding Plan. The plan's model set is explicitly dynamic; these are the
@@ -543,24 +568,49 @@ export const VOLCENGINE_PLAN_TEXT_ONLY_MODELS = [
   "doubao-seed-2.0-pro",
 ];
 export const ALIBABA_INTL_TOKEN_PLAN_INPUT_MODALITIES: Record<string, string[]> = {
-  "qwen3.8-max": ["text", "image"],
-  "qwen3.7-max": ["text", "image"],
-  "qwen3.7-plus": ["text", "image"],
+  ...ALIBABA_TOKEN_PLAN_INPUT_MODALITIES,
   "qwen3.6-plus": ["text", "image"],
-  "qwen3.6-flash": ["text", "image"],
   "deepseek-v4-flash": ["text"],
   "deepseek-v3.2": ["text"],
   "kimi-k2.7-code": ["text", "image"],
   "kimi-k2.6": ["text", "image"],
   "kimi-k2.5": ["text", "image"],
-  "glm-5.3": ["text"],
-  "glm-5.3-flash": ["text", "image"],
-  "glm-5.2": ["text"],
   "glm-5.1": ["text"],
   "glm-5": ["text"],
   "MiniMax-M2.5": ["text"],
 };
 
+// Shared Token Plan metadata (260909 gateway probes; output ceilings are max_tokens
+// boundary probes: accept at N, reject at N+1).
+export const QWEN38_FAMILY = ["qwen3.8-max", "qwen3.8-flash"];
+export const ALIBABA_TOKEN_PLAN_CONTEXT_WINDOWS: Record<string, number> = {
+  "qwen3.8-max": 1_000_000, "qwen3.8-flash": 1_000_000, "qwen3.7-max": 1_000_000, "qwen3.7-plus": 1_000_000,
+  "qwen3.6-plus": 1_000_000, "qwen3.6-flash": 1_000_000,
+  "deepseek-v4-pro": 1_000_000, "deepseek-v4-pro-0813": 1_000_000, "deepseek-v4-flash": 1_000_000,
+  "deepseek-v4-flash-0731": 1_000_000, "deepseek-v4.1-flash": 1_000_000, "deepseek-v3.2": 131_072,
+  "kimi-k2.7-code": 262_144, "kimi-k2.6": 262_144, "kimi-k2.5": 262_144,
+  "glm-5.2": 1_000_000, "glm-5.1": 202_752, "glm-5": 202_752,
+  "MiniMax-M2.5": 196_608,
+};
+export const ALIBABA_TOKEN_PLAN_MAX_OUTPUT_TOKENS: Record<string, number> = {
+  "qwen3.8-max": 131_072, "qwen3.8-flash": 131_072, "qwen3.7-max": 131_072, "qwen3.7-plus": 131_072,
+  "qwen3.6-plus": 65_536, "qwen3.6-flash": 65_536,
+  "deepseek-v4-pro": 393_216, "deepseek-v4-pro-0813": 393_216, "deepseek-v4-flash": 393_216,
+  "deepseek-v4-flash-0731": 393_216, "deepseek-v4.1-flash": 393_216, "deepseek-v3.2": 65_536,
+  "kimi-k2.7-code": 262_144, "kimi-k2.6": 262_144, "kimi-k2.5": 98_304,
+  "glm-5.2": 131_072, "glm-5.1": 128_000, "glm-5": 16_384,
+  "MiniMax-M2.5": 32_768,
+};
+export const ALIBABA_TOKEN_PLAN_NO_VISION = [
+  "qwen3.7-max", "deepseek-v4-pro", "deepseek-v4-pro-0813", "deepseek-v4-flash",
+  "deepseek-v4-flash-0731", "deepseek-v3.2", "glm-5.2", "glm-5.1", "glm-5", "MiniMax-M2.5",
+];
+export const ALIBABA_TOKEN_PLAN_PRESERVE_REASONING = [
+  "qwen3.8-max", "qwen3.8-flash", "qwen3.7-max", "qwen3.7-plus", "qwen3.6-plus", "qwen3.6-flash",
+  "deepseek-v4-pro", "deepseek-v4-pro-0813", "deepseek-v4-flash", "deepseek-v4-flash-0731",
+  "deepseek-v4.1-flash", "glm-5.2",
+];
+
 // 260717 Kimi K3: the subscription endpoint uses one upstream id (`k3`) for both
 // entitlement tiers. Bare `k3` advertises the Moderato 256K ceiling; the local `[1m]`
 // alias advertises Allegretto's 1M ceiling and is stripped before the upstream request.

package/src/providers/registry/types.ts

@@ -64,6 +64,10 @@ export interface ProviderModelDiscoveryFilter {
 interface ProviderModelDiscoverySharedSpec {
   /** Query parameters applied to the resolved discovery URL. */
   query?: Readonly<Record<string, string>>;
+  /** Top-level response key containing model rows; defaults to `data`. */
+  envelopeKey?: string;
+  /** Model-row field containing the provider-native identifier; defaults to `id`. */
+  idField?: string;
   /** Declarative eligibility rules evaluated against each untrusted model row. */
   filter?: ProviderModelDiscoveryFilter;
   /** Optional lower byte ceiling; the process-wide hard ceiling still wins. */
@@ -217,6 +221,11 @@ export interface ProviderRegistryEntry {
    * to stay contiguous. This is seeded/backfilled like other fixed wire capabilities.
    */
   requiresAdjacentResponsesToolResults?: boolean;
+  /**
+   * Responses upstream that also rejects a tool call with no matching output anywhere in the
+   * replayed input. Seeded/backfilled like other fixed wire capabilities.
+   */
+  requiresPairedResponsesToolResults?: boolean;
   /**
    * When enabled, tool results that are present but empty are annotated on the wire.
    * Seeded/backfilled like other fixed wire capabilities.

package/src/responses/spill-store.ts

@@ -159,6 +159,23 @@ function spillNow(): number {
   return spillNowOverride?.() ?? Date.now();
 }
 
+/**
+ * The spill deadline clock, shared with the shutdown drain in `state/spill-queue.ts`.
+ *
+ * Every deadline the shutdown path enforces has to read the same clock the work it
+ * budgets reads. When the drain measured its reserve on `Date.now()` while the ACL
+ * harden it was budgeting ran on this injected clock, a test could freeze the clock,
+ * believe it had removed wall time from the case, and still lose an 80 ms reserve to
+ * real elapsed time on a loaded runner — which is what turned
+ * `shutdown fallback prices the job-owned superseded generation before publishing`
+ * red on macOS 2/2 in run 35137850114 while the assertion it was written for never ran.
+ *
+ * Production is unchanged: with no override installed this is `Date.now()`.
+ */
+export function responseSpillNow(): number {
+  return spillNow();
+}
+
 function record(event: "write" | "fsync" | "close" | "harden" | "publish" | "dir-fsync" | "stub-swap"): void {
   spillIoForTest?.record?.(event);
 }

package/src/responses/state/body-policy.ts

@@ -0,0 +1,25 @@
+/**
+ * Request bodies that must never enter the continuation cache.
+ *
+ * The cache is persisted to `responses-state.json`, so anything recorded here reaches disk.
+ * Encrypted-agent-task recovery decrypts task text into the request body and promises
+ * in-memory, TTL-bounded retention; recording that body would put the plaintext on disk with
+ * no TTL and break the promise.
+ *
+ * A WeakSet rather than a body field on purpose: `_rawBody` is serialized verbatim by the
+ * native passthrough, so any marker written into the body itself would be sent upstream.
+ * Marking is enforced once here rather than at each call site, because every recording path
+ * (streaming, non-streaming, passthrough, forced) funnels through `rememberResponseState` —
+ * a new call site cannot reintroduce the leak by forgetting a guard.
+ */
+const nonPersistableBodies = new WeakSet<object>();
+
+/** Bar this exact request body from the continuation cache, and therefore from disk. */
+export function markBodyNonPersistable(body: unknown): void {
+  if (body && typeof body === "object") nonPersistableBodies.add(body as object);
+}
+
+/** Test the body's in-memory persistence restriction without adding a wire marker. */
+export function isBodyNonPersistable(body: unknown): boolean {
+  return !!body && typeof body === "object" && nonPersistableBodies.has(body);
+}

package/src/responses/state/spill-queue.ts

@@ -7,6 +7,7 @@ import {
   MAX_RESPONSE_SPILL_PAYLOAD_BYTES,
   prospectiveResponseSpillBytes,
   responseSpillPayloadCap,
+  responseSpillNow,
   type ResponseSpillPublicationControl,
   type ResponseSpillRef,
   writeResponseSpillDurably,
@@ -377,7 +378,7 @@ function responseSpillShutdownBudget(): { totalMs: number; fallbackReserveMs: nu
 }
 
 function awaitResponseSpillTailUntil(observed: Promise<void>, deadline: number): Promise<boolean> {
-  const remaining = deadline - Date.now();
+  const remaining = deadline - responseSpillNow();
   if (remaining <= 0) return Promise.resolve(false);
   return new Promise(resolve => {
     let finished = false;
@@ -554,12 +555,13 @@ function terminalizeExhaustedShutdownFallback(
 }
 
 function fallbackPendingResponseSpills(reserveMs: number): Error[] {
-  const deadline = Date.now() + reserveMs;
+  // Same clock as the harden work this reserve is budgeting — see `responseSpillNow`.
+  const deadline = responseSpillNow() + reserveMs;
   const failures: Error[] = [];
   for (;;) {
     const pending = pendingShutdownFallbackCandidates();
     if (pending.length === 0) return failures;
-    if (Date.now() >= deadline) {
+    if (responseSpillNow() >= deadline) {
       terminalizeExhaustedShutdownFallback(pending, failures);
       return failures;
     }
@@ -569,7 +571,7 @@ function fallbackPendingResponseSpills(reserveMs: number): Error[] {
     for (let index = 0; index < pending.length; index += 1) {
       const { job, candidate } = pending[index]!;
       if (requireStore().currentEntry(job.id) !== candidate) continue;
-      const remaining = deadline - Date.now();
+      const remaining = deadline - responseSpillNow();
       if (remaining <= 0) {
         reserveExhausted = true;
         for (const exhausted of pending.slice(index)) {
@@ -587,7 +589,7 @@ function fallbackPendingResponseSpills(reserveMs: number): Error[] {
     requireStore().recomputeOldestResident();
     requireStore().pruneResponses();
     enforceAppOwnedMemoryBudget();
-    if (reserveExhausted || Date.now() >= deadline) {
+    if (reserveExhausted || responseSpillNow() >= deadline) {
       terminalizeExhaustedShutdownFallback(pendingShutdownFallbackCandidates(), failures);
       return failures;
     }
@@ -597,7 +599,7 @@ function fallbackPendingResponseSpills(reserveMs: number): Error[] {
 export async function drainResponseSpillPublications(): Promise<void> {
   const budget = responseSpillShutdownBudget();
   const fallbackReserveMs = Math.min(budget.totalMs, Math.max(1, budget.fallbackReserveMs));
-  const drainDeadline = Date.now() + Math.max(0, budget.totalMs - fallbackReserveMs);
+  const drainDeadline = responseSpillNow() + Math.max(0, budget.totalMs - fallbackReserveMs);
 
   for (;;) {
     if (pendingResponseSpills.size === 0) return;

package/src/responses/state.ts

@@ -23,6 +23,8 @@ import type { ResponseSpillWriteFailureCode, ResponseSpillWriteStatus, ResponseS
 export { responseAdmissionCountersForTests } from "./state/spill-failure";
 import { admissionCounters, noteSpillWriteFailure, noteSpillWriteSuccess, spillCounters, spillWriteHealth } from "./state/spill-failure";
 import { loadSnapshotEntry } from "./state/snapshot-codec";
+import { isBodyNonPersistable } from "./state/body-policy";
+export { isBodyNonPersistable, markBodyNonPersistable } from "./state/body-policy";
 export { flushPendingResponseSpillsForTests, awaitResponseSpillPublicationTailForTests, pendingResponseSpillMetricsForTests, setResponseSpillShutdownBudgetForTests, setResponseSpillAsyncAclAttemptBudgetForTests, setResponseSpillShutdownTerminalizationPassLimitForTests } from "./state/spill-queue";
 import {
   bindSpillQueueStore,
@@ -1235,27 +1237,6 @@ export function responseStateMetrics(): ResponseStateMetrics {
  * Cache completed output and max_output_tokens partial output for previous_response_id replay.
  * Content-filtered incomplete and failed output are not authoritative replay history.
  */
-/**
- * Request bodies that must never enter the continuation cache.
- *
- * The cache is persisted to `responses-state.json`, so anything recorded here reaches disk.
- * Encrypted-agent-task recovery decrypts task text into the request body and promises
- * in-memory, TTL-bounded retention; recording that body would put the plaintext on disk with
- * no TTL and break the promise.
- *
- * A WeakSet rather than a body field on purpose: `_rawBody` is serialized verbatim by the
- * native passthrough, so any marker written into the body itself would be sent upstream.
- * Marking is enforced once here rather than at each call site, because every recording path
- * (streaming, non-streaming, passthrough, forced) funnels through `rememberResponseState` —
- * a new call site cannot reintroduce the leak by forgetting a guard.
- */
-const nonPersistableBodies = new WeakSet<object>();
-
-/** Bar this exact request body from the continuation cache, and therefore from disk. */
-export function markBodyNonPersistable(body: unknown): void {
-  if (body && typeof body === "object") nonPersistableBodies.add(body as object);
-}
-
 export function rememberResponseState(
   requestBody: unknown,
   response: { id?: unknown; output?: unknown; status?: unknown; incomplete_details?: unknown },
@@ -1264,7 +1245,7 @@ export function rememberResponseState(
 ): void {
   if (!requestBody || typeof requestBody !== "object" || Array.isArray(requestBody)) return;
   const request = requestBody as Record<string, unknown>;
-  if (nonPersistableBodies.has(request)) return;
+  if (isBodyNonPersistable(request)) return;
   // `force` bypasses only the store:false skip: Codex sends `store:false` on every non-Azure
   // HTTP request (and WS inherits it), yet its WS turns still chain with previous_response_id.
   // The passthrough branch records with force so those chains can be expanded locally; the

package/src/router.ts

@@ -384,6 +384,10 @@ export function routedProviderConfig(providerName: string, provider: OcxProvider
       && registryEntry.requiresAdjacentResponsesToolResults !== undefined
       ? { requiresAdjacentResponsesToolResults: registryEntry.requiresAdjacentResponsesToolResults }
       : {}),
+    ...(provider.requiresPairedResponsesToolResults === undefined
+      && registryEntry.requiresPairedResponsesToolResults !== undefined
+      ? { requiresPairedResponsesToolResults: registryEntry.requiresPairedResponsesToolResults }
+      : {}),
     ...(provider.annotateEmptyToolOutputs === undefined
       && registryEntry.annotateEmptyToolOutputs !== undefined
       ? { annotateEmptyToolOutputs: registryEntry.annotateEmptyToolOutputs }

package/src/server/auth-cors.ts

@@ -913,6 +913,7 @@ const PROVIDER_CONFIG_FIELD_POLICY = {
   commandCodeVersion: "editor",
   statelessResponses: "editor",
   requiresAdjacentResponsesToolResults: "editor",
+  requiresPairedResponsesToolResults: "editor",
   annotateEmptyToolOutputs: "editor",
   supportsServiceTier: "editor",
   modelSupportsServiceTier: "editor",

package/src/server/index/websocket-handler.ts

@@ -1,3 +1,7 @@
+import { nativeSteeringUnavailableReason, nativeResponseControlMode, type NativeResponseControl } from "../responses/native-response-control";
+import { NativeInjectionChannel } from "../responses/native-injection";
+import { NativeSteeringChannel, NativeSteeringError } from "../responses/native-steering";
+import { createNativeSteeringLogObserver } from "../responses/native-steering-log";
 import type { Server, ServerWebSocket } from "bun";
 import {
   LIVE_SIDEBAND_UPSTREAM_OPEN_TIMEOUT_MS,
@@ -188,11 +192,47 @@ export function createWebsocketHandler(ctx: ServeOptionsContext) {
         } catch {
           return; // text-only contract; ignore unparseable frames
         }
+        if (frame.type === "response.inject" || frame.type === "response.steer" || (frame.type === "response.create" && ws.data.nativeControl)) {
+          try {
+            if (frame.type === "response.inject") {
+              if (!ws.data.nativeControl?.inject) throw new NativeSteeringError("injection_not_supported", "Native injection is disabled or unavailable on this route.");
+              ws.data.nativeControl.inject(frame);
+              return;
+            }
+            if (frame.type === "response.steer") {
+              if (!ws.data.nativeControl) throw new NativeSteeringError("steering_not_supported", ws.data.nativeSteeringUnavailable ?? "Native steering transport is unavailable; the route may be unsupported or using HTTP fallback.");
+              ws.data.nativeControl.steer(frame);
+              return;
+            }
+            if (ws.data.nativeControl?.continue(frame)) return;
+          } catch (error) {
+            sendJsonFrame(ws, buildWsErrorFrame(400, {
+              type: "invalid_request_error",
+              code: error instanceof NativeSteeringError ? error.code : "native_steering_error",
+              message: error instanceof NativeSteeringError ? error.message : "Native steering transport failed; delivery may be unknown. Do not automatically replay input.",
+            }));
+            return;
+          }
+        }
         if (frame.type === "response.processed") return; // ack — no-op
         if (frame.type !== "response.create") return;
         markActivity("ws response.create");
 
+        let nativeControl: NativeResponseControl | undefined;
+        try {
+          const idleMs = typeof config.stallTimeoutSec === "number" && Number.isFinite(config.stallTimeoutSec)
+            ? Math.max(1, config.stallTimeoutSec) * 1000 : 300_000;
+          const mode = nativeResponseControlMode(frame, config);
+          nativeControl = mode === "injection" ? new NativeInjectionChannel(frame, idleMs)
+            : mode === "steering" ? new NativeSteeringChannel(frame, idleMs) : undefined;
+        } catch {
+          sendJsonFrame(ws, buildWsErrorFrame(400, { type: "invalid_request_error", message: "Invalid native steering request settings" }));
+          return;
+        }
         ws.data.cancel?.();
+        // A superseded turn must not keep ownership during warmup or refusal.
+        ws.data.nativeControl = undefined;
+        ws.data.nativeSteeringUnavailable = nativeSteeringUnavailableReason(frame, config.codexNativeSteering);
         const turnId = (ws.data.turnId ?? 0) + 1;
         ws.data.turnId = turnId;
         const isCurrent = () => ws.data.turnId === turnId;
@@ -227,6 +267,8 @@ export function createWebsocketHandler(ctx: ServeOptionsContext) {
           return;
         }
 
+        // Only a genuinely admitted turn may receive steering or continuations.
+        ws.data.nativeControl = nativeControl;
         const payload: Record<string, unknown> = { ...frame };
         delete payload.type;
         turnAdmissionLease.bindAbortController(turnAbort);
@@ -267,6 +309,7 @@ export function createWebsocketHandler(ctx: ServeOptionsContext) {
               ...(wsAdmission ? { admission: wsAdmission } : {}),
               forceEmptyResponseId: true,
               inboundTransport: "websocket",
+              nativeControl,
               abortSignal: turnAbort.signal,
               turnAdmissionLease,
               onFirstOutput: () => recordFirstOutput(logCtx, start),
@@ -277,7 +320,10 @@ export function createWebsocketHandler(ctx: ServeOptionsContext) {
               },
             });
             await sendResponseToWebSocket(ws, response, isCurrent, {
-              onSsePayload: payload => inspectResponseLogSsePayload(logCtx, payload),
+              untilEof: nativeControl?.relayActive === true,
+              onSsePayload: nativeControl?.relayActive
+                ? createNativeSteeringLogObserver(logCtx, () => recordFirstOutput(logCtx, start))
+                : payload => inspectResponseLogSsePayload(logCtx, payload),
               onTerminal: status => {
                 terminalRecorder?.(status, logCtx.terminalHttpStatus);
                 finalizeLog(httpStatusForRequestLogTerminal(status, logCtx), {
@@ -313,6 +359,7 @@ export function createWebsocketHandler(ctx: ServeOptionsContext) {
             }
           } finally {
             turnAdmissionLease.release();
+            if (ws.data.nativeControl === nativeControl) ws.data.nativeControl = undefined;
             if (!logged && turnAbort.signal.aborted) finalizeLog(499);
             if (ws.data.cancel === cancelTurn) ws.data.cancel = undefined;
           }

package/src/server/management/config-routes.ts

@@ -3,6 +3,11 @@ import { randomUUID } from "node:crypto";
 import { readFileSync } from "node:fs";
 import type { CatalogModel } from "../../codex/catalog";
 import { catalogModelSlug, invalidateCodexModelsCache, nativeContextLimits, nativeModelRows, uniqueCatalogModelsForPublicList } from "../../codex/catalog";
+import {
+  applyCodexDesktopSwitches,
+  describeCodexDesktopSwitches,
+  type CodexDesktopSwitchApply,
+} from "../../codex/desktop-switches";
 import {
   DEFAULT_SUBAGENT_MODELS,
   codexAutoStartEnabled,
@@ -328,6 +333,11 @@ export async function handleConfigRoutes(ctx: ManagementContext): Promise<Respon
       codexDesktopAuthless: config.codexDesktopAuthless === true,
       // Absent keeps Design B remote compaction; true selects the dedicated provider identity.
       codexClientCompaction: config.codexClientCompaction === true,
+      codexDesktopSwitches: describeCodexDesktopSwitches(config, {
+        applied: false,
+        reason: "not_requested",
+        retryable: false,
+      }),
       startupHealth: await readStartupHealth(config),
       codexRuntime: {
         path: displayCodexRuntimePath(resolved.runtime.command),
@@ -597,15 +607,26 @@ export async function handleConfigRoutes(ctx: ManagementContext): Promise<Respon
       configureAppOwnedMemoryBudget(resolveAppOwnedMemoryBudgetBytes(body.appOwnedMemoryBudgetMb));
       enforceAppOwnedMemoryBudget();
     }
-    // Both Desktop compatibility switches change the injected config.toml shape, so converge now
-    // rather than waiting for the next start; the injector re-reads config and rewrites the form.
     const authlessIsEnabled = config.codexDesktopAuthless === true;
     const clientCompactionIsEnabled = config.codexClientCompaction === true;
-    const catalogRefresh = pickerWasEnabled !== pickerIsEnabled
-      || authlessWasEnabled !== authlessIsEnabled
-      || clientCompactionWasEnabled !== clientCompactionIsEnabled
+    const desktopSwitchesChanged = authlessWasEnabled !== authlessIsEnabled
+      || clientCompactionWasEnabled !== clientCompactionIsEnabled;
+    // Catalog convergence is not config injection, and the comment that used to sit here said
+    // it was. `convergeCodexCatalog` rejects any scope but `catalog` and never reaches the
+    // injector, which is why flipping either switch left `config.toml` in its old shape until
+    // a separate `ocx sync` (#4809). Both halves are needed when a Desktop switch changes; a
+    // picker-only update still refreshes just the catalog.
+    const catalogRefresh = pickerWasEnabled !== pickerIsEnabled || desktopSwitchesChanged
       ? await convergeCodexCatalog()
       : undefined;
+    // Injection second, matching `syncModelsToCodex`: the injected `model_catalog_json` should
+    // point at a catalog that has already settled. And it runs here rather than inside the save
+    // because coordinated Codex writes acquire the Codex write lock N before the config mutation
+    // lock C — awaiting N while still holding C would invert that order.
+    const desktopSwitchApply: CodexDesktopSwitchApply = desktopSwitchesChanged
+      ? await applyCodexDesktopSwitches(config)
+      : { applied: false, reason: "not_requested", retryable: false };
+    const codexDesktopSwitches = describeCodexDesktopSwitches(config, desktopSwitchApply);
     const catalogRefreshPending = catalogRefresh
       ? catalogRefreshIsPending(catalogRefresh)
       : false;
@@ -622,6 +643,7 @@ export async function handleConfigRoutes(ctx: ManagementContext): Promise<Respon
       catalogRefreshPending,
       codexDesktopAuthless: authlessIsEnabled,
       codexClientCompaction: clientCompactionIsEnabled,
+      codexDesktopSwitches,
       codexMainAccountHardLock: config.codexMainAccountHardLock === true,
       mainAccountHardLock: getMainAccountHardLockStatus(config),
       startupHealth: await readStartupHealth(config),

package/src/server/models-capabilities.ts

@@ -10,6 +10,11 @@ import type { CursorEffortTable } from "../integrations/cursor-effort-table";
  * Completions, Responses and Anthropic Messages, streams, and accepts tool calls, so those are
  * constants; context length and vision come from catalog data when known and are omitted
  * otherwise, matching Cursor's optional-field schema.
+ *
+ * Top-level capacity metrics (`context_window`, `context_length`, `max_output_tokens`) are
+ * mirrored directly on each model row for external client discovery (e.g. pi-ai, DSH,
+ * LibreChat) that inspects flat properties rather than Cursor's nested `capabilities.*` shape.
+ * A row that gains a nested capacity value must gain the top-level mirror in the same change.
  */
 
 /**
@@ -132,6 +137,19 @@ export interface ModelCapabilityFields {
     supports_vision?: boolean;
     reasoning_effort?: string[];
   };
+  /**
+   * Mirrored top-level context window for external/legacy client discovery (e.g. pi-ai, DSH)
+   * that reads top-level context_window / context_length instead of nested capabilities.
+   */
+  context_window?: number;
+  /**
+   * Top-level context length alias matching capabilities.context_length for clients expecting context_length.
+   */
+  context_length?: number;
+  /**
+   * Mirrored top-level max output token limit for external/legacy client discovery.
+   */
+  max_output_tokens?: number;
   /**
    * Cursor reads the long-context threshold from `pricing.overrides[].min_prompt_tokens`. That
    * key sits outside its validated capability schema, so it is the one place a threshold can
@@ -153,6 +171,7 @@ export function modelCapabilityFields(input: ModelCapabilityInput): ModelCapabil
   const longContextLength = positiveInt(input.longContextWindow);
   const maxOutputTokens = positiveInt(input.maxOutputTokens);
   const hasLongTier = contextLength !== undefined && longContextLength !== undefined && longContextLength > contextLength;
+  const effectiveContextLength = hasLongTier ? longContextLength : contextLength;
   const modalities = Array.isArray(input.inputModalities)
     ? input.inputModalities.filter(modality => typeof modality === "string" && modality.length > 0)
     : undefined;
@@ -160,9 +179,7 @@ export function modelCapabilityFields(input: ModelCapabilityInput): ModelCapabil
   return {
     api_types: [...OPENCODEX_MODEL_API_TYPES],
     capabilities: {
-      ...(hasLongTier
-        ? { context_length: longContextLength }
-        : contextLength !== undefined ? { context_length: contextLength } : {}),
+      ...(effectiveContextLength !== undefined ? { context_length: effectiveContextLength } : {}),
       ...(maxOutputTokens !== undefined ? { max_output_tokens: maxOutputTokens } : {}),
       // Once a gateway advertises api_types, Cursor keeps only rows whose output_modalities
       // include "text"; omitting the key drops the row from the extended catalog.
@@ -174,6 +191,10 @@ export function modelCapabilityFields(input: ModelCapabilityInput): ModelCapabil
       ...(supportsVision !== undefined ? { supports_vision: supportsVision } : {}),
       ...(efforts.length > 0 ? { reasoning_effort: [...efforts] } : {}),
     },
+    ...(effectiveContextLength !== undefined
+      ? { context_window: effectiveContextLength, context_length: effectiveContextLength }
+      : {}),
+    ...(maxOutputTokens !== undefined ? { max_output_tokens: maxOutputTokens } : {}),
     ...(hasLongTier ? { pricing: { overrides: [{ min_prompt_tokens: contextLength }] } } : {}),
   };
 }