@bitkyc08/opencodex 2.57.0 → 2.58.0

package/src/lib/bounded-subprocess.ts

@@ -9,28 +9,80 @@ export interface BoundedSubprocessExit {
   timedOut: boolean;
 }
 
-/** Kill at the deadline and abandon immediately; late exit/rejection remains observed. */
+export type SubprocessDeadlineScheduler = (
+  callback: () => void,
+  milliseconds: number,
+) => () => void;
+
+const scheduleDeadline: SubprocessDeadlineScheduler = (callback, milliseconds) => {
+  const timer = setTimeout(callback, milliseconds);
+  return () => clearTimeout(timer);
+};
+
+/**
+ * Compatibility allowance used by the ACL runner's outer watchdog.
+ *
+ * `kill()` only REQUESTS termination. It returns before the kernel has torn the process down, and
+ * every handle that process holds stays held until it does. On Windows that is not a detail: file
+ * locking is mandatory, so a directory an abandoned `icacls.exe` still has open cannot be removed
+ * by anyone, and the removal fails with EPERM rather than waiting.
+ */
+export const SUBPROCESS_KILL_GRACE_MS = 2_000;
+
+/**
+ * Wait for a child until the deadline. At the deadline, kill it AND wait for it to actually die.
+ *
+ * This used to kill, `unref`, and resolve in the same tick, which made every caller's "I waited
+ * for my child" guarantee false precisely when it mattered. The ACL runner now waits here until
+ * actual exit; if its separate caller-facing belt fires first, that layer registers the target so
+ * removal can wait for the reap without making ordinary startup or shutdown unbounded.
+ *
+ * That cost three failed fixes. #4789 blamed the removal retry budget and asked for more than
+ * 2.5s; #4796 gave it a 15s exponential schedule; a later change awaited the hardening flight from
+ * the test hook. Windows shard 1/6 failed identically through all three, because none of them
+ * addressed a live process holding the handle -- run 35108652486 burned the full 15s budget and
+ * still threw `EPERM ... rm ocx-management-auth-fDchUb`, with two
+ * `ACL hardening timed out (ETIMEDOUT) - transient icacls stall` lines logged beside it.
+ *
+ * The old grace still abandoned a live child after two seconds. That recreated the same false
+ * ownership contract on a slower clock: the ACL flight settled, cleanup removed the directory,
+ * and Windows returned EPERM because the child still held it. A handle-bearing caller therefore
+ * has no second deadline after kill. The child's actual exit is the only release signal.
+ *
+ * Pass `0` to opt out for a child that holds no path anyone will remove. The numeric form is kept
+ * for compatibility with the existing callers; any positive value means that reaping is required.
+ * The injected scheduler is a test seam so deadline and exit ordering can be proved without sleep.
+ */
 export function waitForSubprocessExit(
   proc: KillableSubprocess,
   timeoutMs: number,
+  reapAfterKill: number = SUBPROCESS_KILL_GRACE_MS,
+  schedule: SubprocessDeadlineScheduler = scheduleDeadline,
 ): Promise<BoundedSubprocessExit> {
   return new Promise(resolve => {
     let settled = false;
-    let timer: ReturnType<typeof setTimeout> | undefined;
+    let deadlineFired = false;
+    let cancelDeadline: (() => void) | undefined;
     const finish = (result: BoundedSubprocessExit): void => {
       if (settled) return;
       settled = true;
-      if (timer !== undefined) clearTimeout(timer);
+      cancelDeadline?.();
       resolve(result);
     };
-    timer = setTimeout(() => {
+    const reaped = proc.exited.then(
+      exitCode => finish(deadlineFired
+        ? { exitCode: null, timedOut: true }
+        : { exitCode, timedOut: false }),
+      () => finish({ exitCode: null, timedOut: deadlineFired }),
+    );
+    cancelDeadline = schedule(() => {
+      deadlineFired = true;
       try { proc.kill(); } catch { /* already exited */ }
-      try { proc.unref?.(); } catch { /* abandonment is still authoritative */ }
-      finish({ exitCode: null, timedOut: true });
+      if (reapAfterKill <= 0) {
+        try { proc.unref?.(); } catch { /* abandonment is still authoritative */ }
+        finish({ exitCode: null, timedOut: true });
+        return;
+      }
     }, Math.max(1, timeoutMs));
-    void proc.exited.then(
-      exitCode => finish({ exitCode, timedOut: false }),
-      () => finish({ exitCode: null, timedOut: false }),
-    );
   });
 }

package/src/lib/windows-secret-acl.ts

@@ -30,8 +30,13 @@
  */
 
 import { existsSync, statSync } from "node:fs";
+import { isAbsolute, relative, resolve } from "node:path";
 import { env, platform } from "node:process";
-import { waitForSubprocessExit } from "./bounded-subprocess";
+import {
+  SUBPROCESS_KILL_GRACE_MS,
+  waitForSubprocessExit,
+  type SubprocessDeadlineScheduler,
+} from "./bounded-subprocess";
 import { resolveTrustedWindowsIcaclsExe } from "./windows-elevation";
 import {
   cachedCurrentWindowsIdentity,
@@ -48,17 +53,32 @@ const hardenedPaths = new Map<string, HardenedIdentity>();
  * that attempt was consumed. Ordinary callers never consume it.
  */
 const timedOutPaths = new Map<string, boolean>();
+/** Compatibility slack before the outer belt releases a caller whose killed child has not reaped. */
+const ASYNC_ICACLS_BELT_MARGIN_MS = 250;
+const pendingAsyncIcaclsReaps = new Map<string, Set<Promise<void>>>();
+
+const scheduleAsyncIcaclsBelt: SubprocessDeadlineScheduler = (callback, milliseconds) => {
+  const timer = setTimeout(callback, milliseconds);
+  return () => clearTimeout(timer);
+};
+let asyncIcaclsBeltScheduler: SubprocessDeadlineScheduler = scheduleAsyncIcaclsBelt;
 
 /**
- * The memo value: `object:freshness` for a file a harden was actually attributed
- * to.
+ * The memo value: the `object` plus `freshness` of a file a harden was actually
+ * attributed to.
  *
  * There is deliberately no null member. An observation that cannot be read is
  * not stored at all — the entry is deleted — because a "recorded as unverifiable"
  * value was dead code the moment attribution became a before/after comparison,
  * and a branch nothing can reach is a branch no test can defend.
+ *
+ * It is the observation itself rather than a joined string so that the two
+ * questions stay separately askable after storage. `reattributeHardenedSecretPath`
+ * has to compare the object while deliberately ignoring the freshness, and
+ * recovering one half out of `dev:ino:ctimeNs` by counting colons would make that
+ * comparison depend on a format nothing declares.
  */
-type HardenedIdentity = string;
+type HardenedIdentity = PathObservation;
 
 /**
  * What a stat can tell us about WHICH OBJECT is at a path.
@@ -128,8 +148,8 @@ function observe(targetPath: string): PathObservation | null {
   }
 }
 
-function memoValue(seen: PathObservation): HardenedIdentity {
-  return `${seen.object}:${seen.freshness}`;
+function sameObservation(a: PathObservation, b: PathObservation): boolean {
+  return a.object === b.object && a.freshness === b.freshness;
 }
 
 /**
@@ -155,7 +175,7 @@ function memoSatisfied(cache: Map<string, HardenedIdentity>, targetPath: string)
   // without any ACL work. That needs exact-identity ABA to bite — outside the
   // proof bound this unit claims — but "the consequence is out of scope" is not a
   // reason to keep an entry we have just proven does not describe what is there.
-  if (current === null || memoValue(current) !== remembered) {
+  if (current === null || !sameObservation(current, remembered)) {
     cache.delete(targetPath);
     return false;
   }
@@ -203,7 +223,7 @@ function recordHarden(
     cache.delete(targetPath);
     return false;
   }
-  cache.set(targetPath, memoValue(after));
+  cache.set(targetPath, after);
   return true;
 }
 
@@ -339,7 +359,7 @@ function defaultIcaclsRunner(args: string[], timeoutMs: number): IcaclsResult {
 /**
  * Async icacls runner (#612): yields the event loop while waiting for the child.
  * Async Subprocess has no exitedDueToTimeout, so the shared settlement helper
- * classifies the deadline and abandons a child that does not settle after kill.
+ * classifies the deadline and keeps waiting for a killed child to actually exit.
  */
 async function defaultAsyncIcaclsRunner(args: string[], timeoutMs: number): Promise<IcaclsResult> {
   const proc = trySpawnIcacls(args);
@@ -359,21 +379,78 @@ async function defaultAsyncIcaclsRunner(args: string[], timeoutMs: number): Prom
 function awaitAsyncIcaclsRunner(args: string[], timeoutMs: number): Promise<IcaclsResult> {
   return new Promise(resolve => {
     let settled = false;
-    let timer: ReturnType<typeof setTimeout> | undefined;
+    let cancelBelt: (() => void) | undefined;
     const finish = (result: IcaclsResult): void => {
       if (settled) return;
       settled = true;
-      if (timer !== undefined) clearTimeout(timer);
+      cancelBelt?.();
       resolve(result);
     };
-    timer = setTimeout(
-      () => finish({ success: false, exitCode: null, timedOut: true, stdout: "" }),
-      Math.max(1, timeoutMs),
+    const runner = asyncIcaclsRunner(args, timeoutMs).then(
+      result => { finish(result); },
+      () => { finish(spawnFailedResult()); },
+    );
+    // The belt has to outlast the runner it is guarding, or it is not a belt -- it is the
+    // deadline. The runner may now legitimately outlive it while a killed child is reaped. The
+    // caller is still released, but the target is registered so removal can wait for the distinct
+    // handle-release question instead of treating flight settlement as proof that the child died.
+    cancelBelt = asyncIcaclsBeltScheduler(
+      () => {
+        const targetPath = args[0];
+        if (targetPath) registerPendingAsyncIcaclsReap(targetPath, runner);
+        finish({ success: false, exitCode: null, timedOut: true, stdout: "" });
+      },
+      Math.max(1, timeoutMs) + SUBPROCESS_KILL_GRACE_MS + ASYNC_ICACLS_BELT_MARGIN_MS,
     );
-    void asyncIcaclsRunner(args, timeoutMs).then(finish, () => finish(spawnFailedResult()));
   });
 }
 
+function registerPendingAsyncIcaclsReap(targetPath: string, reap: Promise<void>): void {
+  let pending = pendingAsyncIcaclsReaps.get(targetPath);
+  if (!pending) {
+    pending = new Set();
+    pendingAsyncIcaclsReaps.set(targetPath, pending);
+  }
+  pending.add(reap);
+  void reap.finally(() => {
+    pending!.delete(reap);
+    if (pending!.size === 0) pendingAsyncIcaclsReaps.delete(targetPath);
+  });
+}
+
+function pathIsAtOrBelow(targetPath: string, rootPath: string): boolean {
+  const relativePath = relative(resolve(rootPath), resolve(targetPath));
+  return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
+}
+
+/** True while an async icacls runner still owns this exact path after its caller's belt fired. */
+export function windowsSecretAclReapPendingForPath(targetPath: string): boolean {
+  return (pendingAsyncIcaclsReaps.get(targetPath)?.size ?? 0) > 0;
+}
+
+/** Non-blocking removal guard for callers that must refuse rather than wait for a stuck child. */
+export function windowsSecretAclReapPendingAtOrBelow(rootPath: string): boolean {
+  return [...pendingAsyncIcaclsReaps.keys()]
+    .some(targetPath => pathIsAtOrBelow(targetPath, rootPath));
+}
+
+/**
+ * Removal barrier for a file or tree that may still be held by a timed-out icacls child.
+ *
+ * This wait is deliberately separate from ordinary startup and shutdown: a genuinely stuck child
+ * must not defeat the caller-facing belt. Code that chooses to remove the target has the stricter
+ * contract and must not proceed until every registered runner at or below it has actually reaped.
+ */
+export async function flushWindowsSecretAclReapsBeforeRemoval(rootPath: string): Promise<void> {
+  while (true) {
+    const pending = [...pendingAsyncIcaclsReaps]
+      .filter(([targetPath]) => pathIsAtOrBelow(targetPath, rootPath))
+      .flatMap(([, reaps]) => [...reaps]);
+    if (pending.length === 0) return;
+    await Promise.all(pending);
+  }
+}
+
 let icaclsRunner: IcaclsRunner = defaultIcaclsRunner;
 let asyncIcaclsRunner: AsyncIcaclsRunner = defaultAsyncIcaclsRunner;
 let platformOverride: string | null = null;
@@ -389,6 +466,13 @@ export function setAsyncIcaclsRunnerForTests(runner: AsyncIcaclsRunner | null):
   asyncIcaclsRunner = runner ?? defaultAsyncIcaclsRunner;
 }
 
+/** Test seam: fire the outer caller-facing belt without sleeping. */
+export function setAsyncIcaclsBeltSchedulerForTests(
+  scheduler: SubprocessDeadlineScheduler | null,
+): void {
+  asyncIcaclsBeltScheduler = scheduler ?? scheduleAsyncIcaclsBelt;
+}
+
 /**
  * Test seam: force the platform gate (e.g. "win32") so CI on POSIX reaches the runner.
  *
@@ -423,6 +507,58 @@ export function forgetHardenedSecretPath(targetPath: string): void {
   hardenedPaths.delete(targetPath);
 }
 
+/**
+ * Re-attribute an existing file memo to the SAME object after the caller wrote
+ * content to it through a descriptor whose identity it verified.
+ *
+ * This exists because `freshness` is `ctimeNs`, and on Windows libuv reports
+ * `st_ctim` from the NTFS ChangeTime, which moves when file DATA is written. An
+ * atomic writer therefore invalidated its own memo between the harden that
+ * protects the empty temp and the harden before the rename, and paid a second
+ * full `/grant:r` + `/inheritance:r` + `/remove:g` sequence to reapply the ACL
+ * that was already on the file. Every secret write on Windows paid it twice.
+ *
+ * Only the freshness moves, and only for an unchanged object: a different object
+ * retires the entry instead. A caller must have proven, immediately beforehand,
+ * that `targetPath` resolves to the object its own descriptor refers to.
+ *
+ * The cost of this is worth stating exactly, because `PathObservation` documents
+ * that freshness also moves when PERMISSIONS change, and this call cannot tell
+ * the two apart. So a DACL change landing between the harden and this call is
+ * absorbed instead of forcing a re-harden. That window is the caller's own
+ * content write; every permission change after this call still moves ctime
+ * again and still misses the memo, so the detection this memo provides is
+ * relocated, not removed.
+ *
+ * What makes the absorbed window acceptable is who can be in it. Once the harden
+ * has run, the DACL is an explicit owner-only ACE with inheritance removed, so
+ * no other principal can open the file for `WRITE_DAC` at all. The one principal
+ * who can still rewrite that DACL is one holding a handle opened BEFORE the
+ * harden, and Windows keeps the access granted to an open handle: that principal
+ * can equally rewrite the DACL after any later harden, and after the rename, on
+ * the same object. A second mutation pass never bounded that capability — it
+ * stripped an ACE the holder could immediately re-add — so declining to repeat
+ * it removes no guarantee anyone had.
+ *
+ * Refusal is cheap and safe in either direction: an unmoved memo simply means the
+ * caller's next harden runs in full.
+ *
+ * Returns whether the memo now describes what is at the path.
+ */
+export function reattributeHardenedSecretPath(targetPath: string): boolean {
+  const remembered = hardenedPaths.get(targetPath);
+  if (remembered === undefined) return false;
+  const current = observe(targetPath);
+  // Unreadable, or a different object: this is exactly the case the memo must
+  // not cover. Retire it so the next harden is a real one.
+  if (current === null || current.object !== remembered.object) {
+    hardenedPaths.delete(targetPath);
+    return false;
+  }
+  hardenedPaths.set(targetPath, current);
+  return true;
+}
+
 /**
  * Ephemeral-path lifecycle release: clears the success memo AND any timeout
  * memo keyed by THIS TEMP path in both namespaces. Call only after the temp is

package/src/lib/windows-user-principal.ts

@@ -160,7 +160,11 @@ async function defaultAsyncWindowsPrincipalRunner(
     stderr: "ignore",
     windowsHide: true,
   });
-  const { exitCode, timedOut } = await waitForSubprocessExit(proc, timeoutMs);
+  // No kill grace. The grace exists so a dying child releases a path someone is about to
+  // remove; this lookup holds no such path, and it runs during `ocx start`, where the composed
+  // acceptance cases already measure real startups at up to 38.8s against a bounded watchdog.
+  // Paying two extra seconds per timed-out resolution there buys nothing and costs margin.
+  const { exitCode, timedOut } = await waitForSubprocessExit(proc, timeoutMs, 0);
   // `.bytes()` rather than `.text()`, for the same reason as the sync runner above.
   const stdout: string | Uint8Array = !timedOut && proc.stdout
     ? await new Response(proc.stdout).bytes().catch(() => new Uint8Array())

package/src/providers/derive.ts

@@ -266,6 +266,9 @@ export function providerConfigSeed(entry: ProviderRegistryEntry): OcxProviderCon
     ...(entry.requiresAdjacentResponsesToolResults !== undefined
       ? { requiresAdjacentResponsesToolResults: entry.requiresAdjacentResponsesToolResults }
       : {}),
+    ...(entry.requiresPairedResponsesToolResults !== undefined
+      ? { requiresPairedResponsesToolResults: entry.requiresPairedResponsesToolResults }
+      : {}),
     ...(entry.annotateEmptyToolOutputs !== undefined
       ? { annotateEmptyToolOutputs: entry.annotateEmptyToolOutputs }
       : {}),
@@ -541,6 +544,9 @@ export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig
   if (prov.requiresAdjacentResponsesToolResults === undefined && seed.requiresAdjacentResponsesToolResults !== undefined) {
     prov.requiresAdjacentResponsesToolResults = seed.requiresAdjacentResponsesToolResults;
   }
+  if (prov.requiresPairedResponsesToolResults === undefined && seed.requiresPairedResponsesToolResults !== undefined) {
+    prov.requiresPairedResponsesToolResults = seed.requiresPairedResponsesToolResults;
+  }
   if (prov.annotateEmptyToolOutputs === undefined && seed.annotateEmptyToolOutputs !== undefined) {
     prov.annotateEmptyToolOutputs = seed.annotateEmptyToolOutputs;
   }

package/src/providers/model-discovery.ts

@@ -129,6 +129,14 @@ export function providerModelDiscoverySpecError(spec: ProviderModelDiscoverySpec
   if (queryEntries.some(([key, value]) => !key.trim() || key.length > 128 || typeof value !== "string" || value.length > 512)) {
     return "discovery query keys/values exceed their bounds";
   }
+  for (const [field, value] of [
+    ["envelopeKey", spec.envelopeKey],
+    ["idField", spec.idField],
+  ] as const) {
+    if (value !== undefined && (
+      typeof value !== "string" || !value || value !== value.trim() || value.length > 128
+    )) return `${field} must be a nonblank field name up to 128 characters`;
+  }
   for (const [field, value, hardLimit] of [
     ["maxResponseBytes", spec.maxResponseBytes, MODEL_DISCOVERY_MAX_RESPONSE_BYTES],
     ["maxModels", spec.maxModels, MODEL_DISCOVERY_MAX_MODELS],
@@ -422,7 +430,7 @@ export function extractModelEnvelopeRows(
   return { ok: true, rows };
 }
 
-/** Validate, bound, deduplicate, and declaratively filter OpenAI `{data:[...]}` or top-level arrays (Together `#617`). */
+/** Validate, bound, deduplicate, and filter the declared envelope or a top-level array (Together `#617`). */
 /**
  * Metadata a sibling `models[]` array may contribute to an ALREADY-ADMITTED
  * `data[]` row (#1797).
@@ -501,24 +509,26 @@ export function extractProviderModelItems(
   let data: unknown[];
   let siblings: SiblingIndex | null = null;
   if (Array.isArray(value)) {
-    // Together-style top-level /models arrays. Catalog discovery must not treat a stray
-    // `models` key on openai-chat responses as valid — only `data` envelopes or top-level arrays.
+    // Together-style top-level /models arrays. The default contract must not treat a stray
+    // `models` key on openai-chat responses as valid; only a provider spec may opt into it.
     if (value.length > limit) return { ok: false, reason: "too_many_models" };
     data = value;
   } else {
-    const envelope = extractModelEnvelopeRows(value, discovery.maxModels, ["data"]);
+    const envelopeKey = discovery.spec?.envelopeKey ?? "data";
+    const envelope = extractModelEnvelopeRows(value, discovery.maxModels, [envelopeKey]);
     if (!envelope.ok) return envelope;
     data = envelope.rows;
-    siblings = buildSiblingIndex(value, limit);
+    siblings = envelopeKey === "data" ? buildSiblingIndex(value, limit) : null;
   }
 
   const items: ProviderModelsApiItem[] = [];
   const seen = new Set<string>();
+  const idField = discovery.spec?.idField ?? "id";
   for (const raw of data) {
     if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
       return { ok: false, reason: "invalid_shape" };
     }
-    const id = (raw as { id?: unknown }).id;
+    const id = (raw as Record<string, unknown>)[idField];
     if (!isValidModelDiscoveryModelId(id)) return { ok: false, reason: "invalid_shape" };
     const prefix = discovery.spec?.stripIdPrefix;
     let finalId = id;
@@ -526,7 +536,9 @@ export function extractProviderModelItems(
       finalId = finalId.slice(prefix.length);
       if (!isValidModelDiscoveryModelId(finalId)) continue;
     }
-    const item = finalId === id ? raw as ProviderModelsApiItem : { ...(raw as ProviderModelsApiItem), id: finalId };
+    const item = finalId === id && idField === "id"
+      ? raw as ProviderModelsApiItem
+      : { ...(raw as Record<string, unknown>), id: finalId };
     // Admission is decided on the ORIGINAL `data[]` row, before any sibling
     // enrichment. Merging first let a `models[]` entry supply the very field a
     // provider filter requires — reproduced against the real Chutes policy,

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

@@ -282,6 +282,17 @@ export const PROVIDER_REGISTRY_CORE: readonly ProviderRegistryEntry[] = [
         forwardCallerServiceTier: false,
       },
     },
+    // Grok 4.6/4.5 OAuth Responses replays Codex tool history. After a mid-stream 502/reset,
+    // the client can resend a function_call without a matching output, or with hook-injected
+    // developer context between the pair. Google already synthesizes a missing tool_result
+    // (#2199). xAI's Responses parser does not, so the next turns 400 and the thread snowballs.
+    // Reuse the existing adjacency capability (Kimi #4726, DeepSeek #1292). Do not set
+    // statelessResponses: xAI stores responses for 30 days and documents previous_response_id.
+    // https://docs.x.ai/developers/model-capabilities/text/comparison
+    requiresAdjacentResponsesToolResults: true,
+    // The dangling half of the same failure: a call whose output never arrived. Kimi accepts that
+    // shape, so this is a second capability rather than a widening of the one above.
+    requiresPairedResponsesToolResults: true,
     // Vision lineup per docs.x.ai model-capabilities/images/understanding: the grok-4.x chat
     // models accept image input (JPEG/PNG, URL or base64). Without this the catalog leaves
     // inputModalities undefined, and deriveComboCatalogModel defaults an undefined member to

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

@@ -56,6 +56,11 @@ import {
   ALIBABA_TOKEN_PLAN_MODELS,
   ALIBABA_TOKEN_PLAN_QWEN_MODELS,
   ALIBABA_TOKEN_PLAN_INPUT_MODALITIES,
+  ALIBABA_TOKEN_PLAN_CONTEXT_WINDOWS,
+  ALIBABA_TOKEN_PLAN_MAX_OUTPUT_TOKENS,
+  ALIBABA_TOKEN_PLAN_NO_VISION,
+  ALIBABA_TOKEN_PLAN_PRESERVE_REASONING,
+  QWEN38_FAMILY,
   ALIBABA_INTL_TOKEN_PLAN_MODELS,
   ALIBABA_INTL_TOKEN_PLAN_QWEN_MODELS,
   TENCENT_CODING_PLAN_MODELS,
@@ -427,6 +432,7 @@ export const PROVIDER_REGISTRY_EXTENDED: readonly ProviderRegistryEntry[] = [
     // model_access_denied, which is why the Chat path cannot simply hang off the new base.
     responsesPath: "/api/v1/responses",
     chatCompletionsPath: "/api/coding/paas/v4/chat/completions",
+    modelDiscovery: { path: "/api/v1/models", envelopeKey: "models", idField: "slug" },
     // The address this row occupied before the move. A saved custom provider still pointing
     // at the Chat endpoint keeps receiving this row's metadata (#1100).
     destinationAliases: [{ baseUrl: "https://api.z.ai/api/coding/paas/v4", adapter: "openai-chat" }],
@@ -724,22 +730,35 @@ export const PROVIDER_REGISTRY_EXTENDED: readonly ProviderRegistryEntry[] = [
     liveModels: false,
     note: "Token Plan Personal Edition · China (Beijing)",
     modelInputModalities: ALIBABA_TOKEN_PLAN_INPUT_MODALITIES,
-    modelContextWindows: {
-      "qwen3.8-max": 983_616, "qwen3.7-max": 1_000_000, "qwen3.7-plus": 1_000_000,
-      "qwen3.6-flash": 1_000_000, "glm-5.3": 1_000_000, "glm-5.3-flash": 1_000_000, "glm-5.2": 1_000_000, 
-    },
+    modelContextWindows: ALIBABA_TOKEN_PLAN_CONTEXT_WINDOWS,
+    modelMaxOutputTokens: ALIBABA_TOKEN_PLAN_MAX_OUTPUT_TOKENS,
     modelReasoningEfforts: {
       ...Object.fromEntries(ALIBABA_TOKEN_PLAN_QWEN_MODELS.map(id => [id, THINKING_BUDGET_EFFORTS])),
-      "qwen3.8-max": QWEN38_REASONING_EFFORTS,
-      "glm-5.3": ZAI_GLM_53_REASONING_EFFORTS,
-      "glm-5.3-flash": ZAI_GLM_53_REASONING_EFFORTS,
+      ...Object.fromEntries(QWEN38_FAMILY.map(id => [id, QWEN38_REASONING_EFFORTS])),
       "glm-5.2": ZAI_GLM_52_REASONING_EFFORTS,
+      "deepseek-v4-pro": deepseekThinkingEffortsFor("deepseek-v4-pro"),
+      "deepseek-v4-pro-0813": deepseekThinkingEffortsFor("deepseek-v4-pro-0813"),
+      "deepseek-v4-flash-0731": deepseekThinkingEffortsFor("deepseek-v4-flash-0731"),
+      "deepseek-v4.1-flash": deepseekThinkingEffortsFor("deepseek-v4.1-flash"),
+    },
+    modelReasoningEffortMap: {
+      "deepseek-v4-pro": deepseekReasoningMapFor("deepseek-v4-pro"),
+      "deepseek-v4-pro-0813": deepseekReasoningMapFor("deepseek-v4-pro-0813"),
+      "deepseek-v4-flash-0731": deepseekReasoningMapFor("deepseek-v4-flash-0731"),
+      "deepseek-v4.1-flash": deepseekReasoningMapFor("deepseek-v4.1-flash"),
     },
-    modelDefaultReasoningEfforts: { "qwen3.8-max": "xhigh" },
-    directReasoningEffortModels: ["qwen3.8-max"],
-    thinkingBudgetModels: ALIBABA_TOKEN_PLAN_QWEN_MODELS.filter(id => id !== "qwen3.8-max"),
-    preserveReasoningContentModels: ["glm-5.3", "glm-5.3-flash", "glm-5.2", "qwen3.8-max", "qwen3.7-max", "qwen3.7-plus", "qwen3.6-flash"],
-    noVisionModels: ["glm-5.3", "glm-5.2"],
+    // Probed 260915 on the plan gateway: json_object returns valid JSON, strict
+    // json_schema is rejected 400 ("This response_format type is unavailable now")
+    // in both thinking modes, so requests downgrade to json_object rather than
+    // sending a schema the gateway refuses.
+    noJsonSchemaModels: ["deepseek-v4.1-flash"],
+    modelDefaultReasoningEfforts: Object.fromEntries(QWEN38_FAMILY.map(id => [id, "xhigh"])),
+    directReasoningEffortModels: QWEN38_FAMILY,
+    thinkingBudgetModels: ALIBABA_TOKEN_PLAN_QWEN_MODELS.filter(id => !QWEN38_FAMILY.includes(id)),
+    preserveReasoningContentModels: ALIBABA_TOKEN_PLAN_PRESERVE_REASONING,
+    noVisionModels: ALIBABA_TOKEN_PLAN_NO_VISION,
+    // The gateway accepts prompt_cache_key on every Token Plan chat model (probed 260902).
+    promptCacheKey: true,
   },
   {
     id: "alibaba-token-plan-intl",
@@ -756,31 +775,34 @@ export const PROVIDER_REGISTRY_EXTENDED: readonly ProviderRegistryEntry[] = [
    note: "Token Plan Team Edition · Singapore (ap-southeast-1)",
     metadataModelIdNormalize: "case-insensitive",
    modelInputModalities: ALIBABA_INTL_TOKEN_PLAN_INPUT_MODALITIES,
-    modelContextWindows: {
-      "qwen3.8-max": 983_616,
-      "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-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.3": 1_000_000, "glm-5.3-flash": 1_000_000, "glm-5.2": 1_000_000, "glm-5.1": 1_000_000, "glm-5": 1_000_000,
-      "MiniMax-M2.5": 204_800,
-    },
+    modelContextWindows: ALIBABA_TOKEN_PLAN_CONTEXT_WINDOWS,
+    modelMaxOutputTokens: ALIBABA_TOKEN_PLAN_MAX_OUTPUT_TOKENS,
     modelReasoningEfforts: {
       ...Object.fromEntries(ALIBABA_INTL_TOKEN_PLAN_QWEN_MODELS.map(id => [id, THINKING_BUDGET_EFFORTS])),
-      "qwen3.8-max": QWEN38_REASONING_EFFORTS,
-      "glm-5.3": ZAI_GLM_53_REASONING_EFFORTS,
-      "glm-5.3-flash": ZAI_GLM_53_REASONING_EFFORTS,
+      ...Object.fromEntries(QWEN38_FAMILY.map(id => [id, QWEN38_REASONING_EFFORTS])),
       "glm-5.2": ZAI_GLM_52_REASONING_EFFORTS,
+      "deepseek-v4-pro": deepseekThinkingEffortsFor("deepseek-v4-pro"),
+      "deepseek-v4-pro-0813": deepseekThinkingEffortsFor("deepseek-v4-pro-0813"),
       "deepseek-v4-flash": deepseekThinkingEffortsFor("deepseek-v4-flash"),
+      "deepseek-v4-flash-0731": deepseekThinkingEffortsFor("deepseek-v4-flash-0731"),
+      "deepseek-v4.1-flash": deepseekThinkingEffortsFor("deepseek-v4.1-flash"),
     },
     modelReasoningEffortMap: {
+      "deepseek-v4-pro": deepseekReasoningMapFor("deepseek-v4-pro"),
+      "deepseek-v4-pro-0813": deepseekReasoningMapFor("deepseek-v4-pro-0813"),
       "deepseek-v4-flash": deepseekReasoningMapFor("deepseek-v4-flash"),
+      "deepseek-v4-flash-0731": deepseekReasoningMapFor("deepseek-v4-flash-0731"),
+      "deepseek-v4.1-flash": deepseekReasoningMapFor("deepseek-v4.1-flash"),
     },
-    directReasoningEffortModels: ["qwen3.8-max"],
-    thinkingBudgetModels: ALIBABA_INTL_TOKEN_PLAN_QWEN_MODELS.filter(id => id !== "qwen3.8-max"),
-    preserveReasoningContentModels: ["glm-5.3", "glm-5.3-flash", "glm-5.2", "deepseek-v4-flash", "qwen3.8-max", "qwen3.7-max", "qwen3.7-plus", "qwen3.6-plus", "qwen3.6-flash"],
-    noVisionModels: ["deepseek-v4-flash", "deepseek-v3.2", "glm-5.3", "glm-5.2", "glm-5.1", "glm-5", "MiniMax-M2.5"],
+    // Same 260915 json_schema rejection probe as the Beijing entry.
+    noJsonSchemaModels: ["deepseek-v4.1-flash"],
+    directReasoningEffortModels: QWEN38_FAMILY,
+    thinkingBudgetModels: ALIBABA_INTL_TOKEN_PLAN_QWEN_MODELS.filter(id => !QWEN38_FAMILY.includes(id)),
+    preserveReasoningContentModels: ALIBABA_TOKEN_PLAN_PRESERVE_REASONING,
+    noVisionModels: ALIBABA_TOKEN_PLAN_NO_VISION,
     noReasoningModels: ["kimi-k2.7-code", "kimi-k2.6", "kimi-k2.5", "deepseek-v3.2", "glm-5.1", "glm-5", "MiniMax-M2.5"],
-    modelDefaultReasoningEfforts: { "qwen3.8-max": "xhigh" },
+    modelDefaultReasoningEfforts: Object.fromEntries(QWEN38_FAMILY.map(id => [id, "xhigh"])),
+    promptCacheKey: true,
   },
   // NEEDS_HUMAN 2026-07-10: kept for config compatibility, but this is a dashboard URL,
   // no /models endpoint is documented, and tools are silently ignored upstream per docs.parallel.ai.