@bitkyc08/opencodex 2.29.0 → 2.30.0-preview.20260821

package/src/adapters/cursor/live-transport.ts

@@ -13,6 +13,8 @@ import {
   type TranslatorBudget,
 } from "../../lib/translator-budget";
 import { activePromptText, prepareCursorRunRequest } from "./protobuf-request";
+import { prepareCursorRawMessages, resolveActiveCursorImages } from "./images";
+import { cursorRequestMessagesFromRaw } from "./request-builder";
 import {
   createCursorContextUsageTracker,
   createCursorProtobufEventState,
@@ -569,10 +571,29 @@ class LiveCursorTransport implements CursorTransport {
 
     // Advertise MCP tools before the stream opens — the server only calls tools it was told about.
     await this.prepareMcp();
-    const activeText = activePromptText(request);
-    this.activeClientToolFinalizeGraceMs = clientToolFinalizeGraceMsForRequest(request, this.clientToolFinalizeGraceMs);
-    const cursorVisibleTools = cursorToolsForActivePrompt(request.tools, activeText, request.toolChoice);
-    const clientToolDefs = buildCursorToolDefinitions(cursorVisibleTools, request.toolChoice);
+    // JPEG soft-cap rewrite for active-turn data: images before encode. Rebuild text
+    // messages from the prepared raw channel so omission markers replace stale
+    // pre-rewrite content that activePromptText and the tool filter would otherwise see.
+    const preparedRaw = await prepareCursorRawMessages(request.rawMessages, signal);
+    const preparedRawMessages = preparedRaw.messages;
+    const selectedImages = await resolveActiveCursorImages(
+      preparedRawMessages,
+      signal,
+      preparedRaw.images,
+    );
+    const preparedMessages = preparedRawMessages === request.rawMessages
+      ? request.messages
+      : cursorRequestMessagesFromRaw(preparedRawMessages);
+    const activeRequest: CursorRunRequest = {
+      ...request,
+      messages: preparedMessages,
+      rawMessages: preparedRawMessages,
+      selectedImages,
+    };
+    const activeText = activePromptText(activeRequest);
+    this.activeClientToolFinalizeGraceMs = clientToolFinalizeGraceMsForRequest(activeRequest, this.clientToolFinalizeGraceMs);
+    const cursorVisibleTools = cursorToolsForActivePrompt(activeRequest.tools, activeText, activeRequest.toolChoice);
+    const clientToolDefs = buildCursorToolDefinitions(cursorVisibleTools, activeRequest.toolChoice);
     // `request.tools` is the catalog already filtered and budgeted by request-builder. Derive
     // conversion provenance only from tagged synthetic tools that also survive this final prompt
     // filter; a client tool with the same wire name can never opt into conversion by collision.
@@ -608,7 +629,7 @@ class LiveCursorTransport implements CursorTransport {
     });
     // Build the payload once. The estimate is only worth deriving when there is no
     // carry-forward to fall back on — with a carry present it would never be used (#373).
-    const prepared = prepareCursorRunRequest(request, {
+    const prepared = prepareCursorRunRequest(activeRequest, {
       estimateInputTokens: contextUsage.carryForwardTokens === undefined,
     });
     this.blobRequestScope = prepared.blobRequestScope;

package/src/adapters/cursor/protobuf-request.ts

@@ -15,6 +15,7 @@ import {
   storeCursorBlob,
   type CursorBlobRequestScopeToken,
 } from "./native-exec";
+import { buildSelectedContext, CURSOR_VISION_IMAGE_HISTORY_MARKER } from "./images";
 import { estimateTokens } from "../../lib/token-estimate";
 import { parseDataUrl } from "../image";
 import {
@@ -219,7 +220,7 @@ function rootPromptMessages(request: CursorRunRequest, requestScope: CursorBlobR
     const message = messages[i];
     if (!message) continue;
     if (message.role === "user" || message.role === "developer") {
-      const text = contentText(message).trim();
+      const text = historyContentText(message).trim();
       // Cursor root replay expects OpenAI-style content parts for historical user messages.
       // A bare string survives blob hydration but external workers reject the completed replay
       // before tokenization (`usedTokens: 0`, then invalid_argument).
@@ -336,7 +337,7 @@ function contentText(message: OcxMessage): string {
     .map(part => {
       if (part.type === "text") return part.text;
       if (part.type === "thinking") return part.thinking;
-      if (part.type === "image") return `[image produced by this tool, omitted from Cursor text replay: ${part.detail ?? "auto"}]`;
+      if (part.type === "image") return undefined;
       return undefined;
     })
     .filter((value): value is string => typeof value === "string" && value.length > 0)
@@ -346,7 +347,26 @@ function contentText(message: OcxMessage): string {
 function contentToText(content: OcxToolResultMessage["content"]): string {
   if (typeof content === "string") return content;
   return content
-    .map(part => part.type === "text" ? part.text : `[image produced by this tool, omitted from Cursor text replay: ${part.detail ?? "auto"}]`)
+    .map(part => {
+      if (part.type === "text") return part.text;
+      if (part.type === "image") return CURSOR_VISION_IMAGE_HISTORY_MARKER;
+      return undefined;
+    })
+    .filter((value): value is string => typeof value === "string" && value.length > 0)
+    .join("\n");
+}
+
+/** History serializer. Replayed turns are text-only; never embed image bytes. */
+function historyContentText(message: OcxMessage): string {
+  if (message.role === "toolResult" || typeof message.content === "string") return contentText(message);
+  return message.content
+    .map(part => {
+      if (part.type === "text") return part.text;
+      if (part.type === "thinking") return part.thinking;
+      if (part.type === "image") return CURSOR_VISION_IMAGE_HISTORY_MARKER;
+      return undefined;
+    })
+    .filter((value): value is string => typeof value === "string" && value.length > 0)
     .join("\n");
 }
 
@@ -721,8 +741,10 @@ function conversationTurns(
     flush();
     current = {
       userMessage: storeCursorBlob(toBinary(UserMessageSchema, create(UserMessageSchema, {
-        text: contentText(message),
+        text: historyContentText(message),
         messageId: crypto.randomUUID(),
+        selectedContext: buildSelectedContext([], requestScope),
+        mode: 1,
       })), requestScope),
       steps: [],
     };
@@ -792,6 +814,7 @@ function buildPreparedCursorRunRequest(
     ? appendCursorGenericToolUseHint(request.tools, rawText)
     : rawText;
   const lastRawIsToolResult = request.rawMessages?.at(-1)?.role === "toolResult";
+  const selectedImages = request.selectedImages ?? [];
   // Native models resume the remembered Cursor conversation. External wire
   // models continue as userMessageAction so history-blob tool results stay
   // visible without a ResumeAction. Some native composer ids are also routed
@@ -799,7 +822,11 @@ function buildPreparedCursorRunRequest(
   // because a bare resumeAction makes them continue exploring with native tools
   // instead of answering (observed on composer-2.5; see discovery.ts).
   const externalToolContinuation = lastRawIsToolResult && cursorNeedsExternalToolContinuation(request.modelId);
-  const actionCase = (externalToolContinuation || (!lastRawIsToolResult && text.trim().length > 0))
+  // Image-only active turns (including soft-omitted images) stay userMessageAction.
+  const actionCase = (
+    externalToolContinuation
+    || (!lastRawIsToolResult && (text.trim().length > 0 || selectedImages.length > 0))
+  )
     ? "userMessageAction"
     : "resumeAction";
   const actionText = externalToolContinuation
@@ -813,6 +840,9 @@ function buildPreparedCursorRunRequest(
             userMessage: create(UserMessageSchema, {
               text: actionText,
               messageId: crypto.randomUUID(),
+              selectedContext: buildSelectedContext(selectedImages, requestScope),
+              // OmniRoute / cursor-agent always send mode=1 on UserMessage.
+              mode: 1,
             }),
             requestContext: buildRequestContext(),
           }),

package/src/adapters/cursor/request-builder.ts

@@ -31,6 +31,7 @@ import {
   type CursorCheckpointInvalidationReason,
   type CursorCheckpointSnapshot,
 } from "./checkpoint-store";
+import { extractCursorImageUrls } from "./images";
 
 /** Probe-verified Cursor Connect boundaries, with byte headroom for the enclosing field. */
 export const CURSOR_TOOL_COUNT_LIMIT = 330;
@@ -211,15 +212,8 @@ function contentPartToText(part: OcxContentPart | OcxAssistantContentPart): stri
     case "thinking":
       return part.thinking;
     case "image":
-      // User-message images are still flattened here: this path builds the plain-text prompt, and
-      // the schema slot that could carry them (UserMessage.selectedContext.selectedImages) is not
-      // populated by this adapter. The tool-result ENCODER does build real McpImageContent
-      // (see protobuf-request.ts), so the old "unsupported by Cursor adapter" wording is no
-      // longer true of the encoder — but note that nothing reaches Cursor today either way:
-      // every Cursor model is in noVisionModels (providers/registry.ts), so the vision sidecar
-      // describes or strips images before this adapter runs. Kept the same length to avoid
-      // shifting any byte-budgeted prompt path.
-      return `[image omitted from this Cursor text prompt: ${part.detail ?? "auto"}]`;
+      // Images ride UserMessage.selected_context (SelectedImage) instead of text.
+      return undefined;
     case "toolCall":
       // Cursor does not accept OpenAI Responses assistant tool-call parts as native history here.
       // Rendering them as visible "[tool_call]" text leaks synthetic protocol markers back into
@@ -252,9 +246,19 @@ function requestMessage(message: OcxMessage): CursorRequestMessage | undefined {
   switch (message.role) {
     case "user":
     case "developer":
-      return { role: message.role, content: contentToText(message.content) };
+      {
+        const content = contentToText(message.content);
+        // Image-only turns survive as empty content; the encoder keeps them userMessageAction.
+        if (content.length === 0 && extractCursorImageUrls(message.content).length === 0) {
+          return undefined;
+        }
+        return { role: message.role, content };
+      }
     case "assistant":
-      return { role: "assistant", content: contentToText(message.content) };
+      {
+        const content = contentToText(message.content);
+        return content.length > 0 ? { role: "assistant", content } : undefined;
+      }
     case "toolResult":
       return {
         role: "tool",
@@ -263,6 +267,19 @@ function requestMessage(message: OcxMessage): CursorRequestMessage | undefined {
   }
 }
 
+/**
+ * Rebuild the text `messages` channel from prepared `rawMessages` so omission markers
+ * and JPEG-rewritten parts stay visible to activePromptText after image preparation.
+ */
+export function cursorRequestMessagesFromRaw(
+  messages: readonly OcxMessage[] | undefined,
+): CursorRequestMessage[] {
+  if (!messages?.length) return [];
+  return messages
+    .map(requestMessage)
+    .filter((message): message is CursorRequestMessage => !!message);
+}
+
 export function generatedCursorConversationId(): string {
   return `cursor_${crypto.randomUUID().replace(/-/g, "")}`;
 }
@@ -409,9 +426,7 @@ export function createCursorRequest(
   parsed: OcxParsedRequest,
   options: CreateCursorRequestOptions = {},
 ): CursorRunRequest {
-  const messages = parsed.context.messages
-    .map(requestMessage)
-    .filter((message): message is CursorRequestMessage => !!message && message.content.length > 0);
+  const messages = cursorRequestMessagesFromRaw(parsed.context.messages);
   const activeText = [...messages].reverse().find(message => message.role === "user" || message.role === "developer")?.content ?? "";
   const visibleTools = cursorToolsForActivePrompt(parsed.context.tools, activeText, parsed.options.toolChoice);
   const budget = applyCursorToolBudget(visibleTools, parsed.options.toolChoice);

package/src/adapters/cursor/types.ts

@@ -2,6 +2,7 @@ import type { OcxUsage } from "../../types";
 import type { OcxMessage, OcxRequestOptions, OcxTool } from "../../types";
 import type { CursorRoutingLevel } from "./discovery";
 import type { CursorCheckpointInvalidationReason } from "./checkpoint-store";
+import type { ResolvedCursorImage } from "./images";
 
 export interface CursorRequestedModelParameter {
   id: string;
@@ -17,7 +18,13 @@ export interface CursorRunRequest {
   conversationId: string;
   system: string[];
   messages: CursorRequestMessage[];
-  rawMessages?: OcxMessage[];
+  rawMessages?: readonly OcxMessage[];
+  /**
+   * Images for the active user/developer turn. Encoded as SelectedImage blobIdWithData refs under
+   * UserMessage.selected_context (bytes live in the request-scoped KV store for getBlobArgs
+   * hydration). History stays text-only. data: URLs only in this slice.
+   */
+  selectedImages?: readonly ResolvedCursorImage[];
   tools?: OcxTool[];
   toolChoice?: OcxRequestOptions["toolChoice"];
   parallelToolCalls?: boolean;

package/src/codex/features.ts

@@ -155,6 +155,29 @@ export function multiAgentV2EnabledFromConfigText(content: string | null): boole
     return false;
   }
 
+  // Bun 1.4 enforces TOML's "value must begin on the assignment line" rule that
+  // 1.3.14 did not, so `hint =` followed by `[` on the next line now fails the
+  // real parse and reaches the line-based fallback below — which reads that `[`
+  // as a table header and truncates the table before `enabled`. Codex's own
+  // parser accepts the document, so answering "disabled" would report a parser
+  // disagreement as a feature state (#1295, #1691).
+  //
+  // Joining a dangling `=` to the line that follows is the smallest repair that
+  // keeps the scanner untouched: widening `tomlTableBody` to be string-aware is
+  // what previously broke `getAgentsEnabled`, `getAgentsMaxDepth`, and
+  // `getMaxConcurrentThreads` (see its comment). If the joined document parses,
+  // that answer is authoritative; if it does not, nothing is lost.
+  const joined = joinDanglingTomlAssignments(content);
+  if (joined !== content) {
+    const reparsed = parsedTomlTable(joined, "features");
+    if (reparsed !== null) {
+      const table = plainTomlRecord(reparsed.multi_agent_v2);
+      if (table !== null) return table.enabled === true;
+      if (typeof reparsed.multi_agent_v2 === "boolean") return reparsed.multi_agent_v2;
+      return false;
+    }
+  }
+
   const table = tomlTableBody(content, "features.multi_agent_v2");
   if (table !== null) {
     const enabled = tomlBoolInBody(table, "enabled");
@@ -184,6 +207,41 @@ function plainTomlRecord(value: unknown): Record<string, unknown> | null {
     : null;
 }
 
+/**
+ * Join `key =` to the following line when the value was written on the next
+ * line, so a parser enforcing TOML's same-line rule can read the document.
+ *
+ * Bun 1.3.14 accepted this shape; Bun 1.4 rejects it, correctly — TOML requires
+ * the value to begin on the assignment line. Codex's parser still accepts it, so
+ * this exists to keep the two readers agreeing rather than to endorse the shape.
+ *
+ * Deliberately narrow: it only acts on a line whose LAST non-comment character
+ * is `=`, which cannot occur in a valid assignment. Lines inside multi-line
+ * strings are left alone — a `"""` body line ending in `=` would be rewritten,
+ * but the result is only used when it PARSES, and the unmodified document is
+ * always tried first, so a wrong join cannot displace a correct read.
+ */
+function joinDanglingTomlAssignments(content: string): string {
+  const lines = content.split("\n");
+  const out: string[] = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!;
+    // A dangling assignment: trailing `=` with nothing after it on this line.
+    if (/^[^#]*[^=!<>]=\s*$/.test(line) && i + 1 < lines.length) {
+      let j = i + 1;
+      // Skip blank and comment-only lines between the `=` and its value.
+      while (j < lines.length && /^\s*(?:#.*)?$/.test(lines[j]!)) j++;
+      if (j < lines.length) {
+        out.push(`${line.replace(/\s*$/, "")} ${lines[j]!.replace(/^\s*/, "")}`);
+        i = j;
+        continue;
+      }
+    }
+    out.push(line);
+  }
+  return out.join("\n");
+}
+
 /**
  * A top-level table from a full TOML parse, or null when the document does not
  * parse. A parsed document with no such table yields `{}` rather than null: that

package/src/generated/compatibility-version.json

@@ -2,15 +2,15 @@
   "schemaVersion": 1,
   "assertionDslVersion": "1.0.0",
   "evidenceSchemaVersion": "1.0.0",
-  "bunRuntimeVersion": "1.3.14",
+  "bunRuntimeVersion": "1.4.0",
   "files": [
     {
       "path": "bun.lock",
-      "sha256": "dbbd8ffc7f0fc893dbf15cb96552b9ba044a4ffaf0447ac5f6c1817b9ec48ca2"
+      "sha256": "29a6cf6ad4c475b5ec0fbcc104b032fbdb293fed12eb17d803ce626481e7e2f5"
     },
     {
       "path": "package.json",
-      "sha256": "fd4c288d8c09df6271ed0e94759eba0c897c31a3a66431ba5c658225046c3745"
+      "sha256": "e93619c60e2ad2e56d45c02fa28e0f3df982f60821532d3211d764c7f4e199b3"
     },
     {
       "path": "scripts/model-metadata.source.json",
@@ -78,7 +78,7 @@
     },
     {
       "path": "src/adapters/cursor/discovery.ts",
-      "sha256": "07916522a2df0c9bb15c4676cfb7c24d3bb39e7cfa857f6e0ac97421ef695264"
+      "sha256": "cdebbff19a9d7e3a51ec0444c21a2d09aaf30e49858c4a791b28176096aa2607"
     },
     {
       "path": "src/adapters/cursor/effort-map.ts",
@@ -100,6 +100,10 @@
       "path": "src/adapters/cursor/http1-bidi.ts",
       "sha256": "351a05fa5bab54709c5fcb1bbbaaae2974f041ea6033283b854812d97df53c7d"
     },
+    {
+      "path": "src/adapters/cursor/images.ts",
+      "sha256": "3fe4ef5a79540055ec57b896fe5df73c3b0a532cc9d9031e29e1921d52969c89"
+    },
     {
       "path": "src/adapters/cursor/kv-store.ts",
       "sha256": "9699c3b4bf5c61f42f2a6653755dc46d662513b728e0e284ca2b46a1006c57ed"
@@ -114,7 +118,7 @@
     },
     {
       "path": "src/adapters/cursor/live-transport.ts",
-      "sha256": "f44b3fad927a7559f4ddf231f02216c0f732570c4a7765338ee7ab0a2431283b"
+      "sha256": "f7ec1630801fb7fd240052807e0cbd1b32207e0b13e4c95874757f0686cf57c8"
     },
     {
       "path": "src/adapters/cursor/mcp-config.ts",
@@ -166,11 +170,11 @@
     },
     {
       "path": "src/adapters/cursor/protobuf-request.ts",
-      "sha256": "43a9745dec2007f819e30b6ee8cc1221040bf7138228f5a3dce5cb2f97fc382c"
+      "sha256": "d712426a8ee1b3c4de4d0705b1277e1edd1d5d96ad1c264fb852c2ff426dd50e"
     },
     {
       "path": "src/adapters/cursor/request-builder.ts",
-      "sha256": "d05a75fc2f051bbd6ca53ab085196ecc545d366d967dc31dc45be34c202307ba"
+      "sha256": "0d73c142a173ee52aefb90038f99667915c8def79e009bcf5044571d4f44cb0b"
     },
     {
       "path": "src/adapters/cursor/thread-continuity.ts",
@@ -194,7 +198,7 @@
     },
     {
       "path": "src/adapters/cursor/types.ts",
-      "sha256": "18b53a305b3006ead774026dd91b7b15667e106c56b2e9e3f69b3e81ab33447e"
+      "sha256": "afbcb4770747dd3287c3f9069805c4f9a2cb675f3e124bad8295b672a678b3ad"
     },
     {
       "path": "src/adapters/google-antigravity-replay.ts",
@@ -766,7 +770,7 @@
     },
     {
       "path": "src/codex/features.ts",
-      "sha256": "f6e64aa07c4ac8330df679a2b613fac84029d2fe1b8f0d5e8ace27ea664dda16"
+      "sha256": "a42c3891a7978d27b974d68a3b5abecc7c3650e7d4d6f17c9e96ff52536f0a1e"
     },
     {
       "path": "src/codex/generation.ts",
@@ -1702,7 +1706,7 @@
     },
     {
       "path": "src/lib/bun-stream-caps.ts",
-      "sha256": "e1523443bb2aefcb59cf2759e9f41b5e5e3ca54b8e5cef0d421a22e8e35ac35c"
+      "sha256": "d2255a860bc9ea451abc7913cca76779c41656d35965d80ce10c63ad94e032aa"
     },
     {
       "path": "src/lib/codex-restart-contract.ts",
@@ -2078,7 +2082,7 @@
     },
     {
       "path": "src/providers/command-code-efforts.ts",
-      "sha256": "3aaec189b3d2661bb27f9aa1487c9efa9d8ba180d05de86e90c8e87a865d8d2f"
+      "sha256": "1f1e616bc6179d729f582142d854406be626d3900a978383c7fdc33a291476d8"
     },
     {
       "path": "src/providers/context-cap.ts",
@@ -2162,11 +2166,11 @@
     },
     {
       "path": "src/providers/quota.ts",
-      "sha256": "d74e47b5106a03d447532f283bdbfe96f632dee1ef662014bbfb049ddb857c8d"
+      "sha256": "940224c87ba91f249b04e7088e71a151914d186f43cb48abcb636bc306e00d7e"
     },
     {
       "path": "src/providers/registry.ts",
-      "sha256": "ec1ad142e7ad3e2d49cf60fa59281f0d5fd995d94d61d3a9611acc6c8d2b327b"
+      "sha256": "68af5ea5f483ace1f33d64d23b03ac778668c180e6b896b2e0f7043028217e05"
     },
     {
       "path": "src/providers/request-pacing.ts",

package/src/lib/bun-stream-caps.ts

@@ -3,9 +3,9 @@
  *
  * The eager bounded relay (src/server/relay-eager.ts) uses a JS async producer
  * loop — the exact shape of the Bun#32111 use-after-free (fixed upstream by Bun
- * PR #32120, merged 2026-06-21). No RELEASED Bun version is proven to carry
- * that fix yet, so `MIN_FIXED_BUN_VERSION` is null: every runtime is
- * "known-bad" until a bundle-bump commit sets it. Windows no-rewrite traffic
+ * PR #32120, merged 2026-06-21). Bun 1.4.0 is the first RELEASED version proven
+ * to carry that fix, so `MIN_FIXED_BUN_VERSION` is "1.4.0": older runtimes stay
+ * "known-bad". Windows no-rewrite traffic
  * follows this runtime/config decision, preserving the explicit legacy-tee
  * safety pin. Darwin no-rewrite traffic stays on tee
  * for `auto` regardless of runtime capability and reaches eager relay only via
@@ -21,8 +21,11 @@
 /**
  * Bump in the SAME commit that bumps package.json's bundled Bun to a version
  * verified to include Bun PR #32120. null = no released version is known-fixed.
+ * Bun 1.4.0 (npm stable, bundled by this package.json) carries the fix: PR
+ * #32120 merged 2026-06-21, well before the 1.4.0 cut, and the full suite ran
+ * green under the 1.4 line on every supported OS (devlog/260814_bun14-preview-dev).
  */
-export const MIN_FIXED_BUN_VERSION: string | null = null;
+export const MIN_FIXED_BUN_VERSION: string | null = "1.4.0";
 
 export type StreamMode = "auto" | "legacy-tee" | "eager-relay";
 

package/src/providers/command-code-efforts.ts

@@ -9,6 +9,13 @@ const COMMAND_CODE_MODEL_EFFORTS = {
     efforts: ["high", "max"],
     profileUrl: "https://commandcode.ai/models/deepseek-v4-flash",
   },
+  // Ox Alpha (stealth preview, added in Command Code v1.31.0): free 1M-context
+  // reasoning model on every plan. The profile does not publish an effort ladder,
+  // so mirror the OpenRouter contract (reasoning mandatory; max/high/low).
+  "stealth/ox-alpha": {
+    efforts: ["low", "high", "max"],
+    profileUrl: "https://commandcode.ai/models/ox-alpha",
+  },
   // Keys must match the EXACT upstream /provider/v1/models ids (GLM ships as
   // `zai-org/GLM-5.3`, not `zai-org/glm-5.3`). The table doubles as the router's
   // known-ids decode source (via `knownModelIdsForProvider`), so a case mismatch

package/src/providers/quota.ts

@@ -50,6 +50,7 @@ const OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
 const DEEPSEEK_BASE_URL = "https://api.deepseek.com";
 const CLINE_BASE_URL = "https://api.cline.bot";
 const ZAI_BASE_URL = "https://api.z.ai";
+const ZAI_CN_BASE_URL = "https://open.bigmodel.cn";
 const MINIMAX_REMAINS_URL = "https://www.minimax.io/v1/token_plan/remains";
 const MOONSHOT_BASE_URL = "https://api.moonshot.ai/v1";
 const VENICE_BASE_URL = "https://api.venice.ai/api/v1";
@@ -343,7 +344,12 @@ function isCanonicalClineBaseUrl(baseUrl: string): boolean {
 
 function isCanonicalZaiBaseUrl(baseUrl: string): boolean {
   const normalized = normalizedBaseUrl(baseUrl);
-  return normalized === ZAI_BASE_URL || normalized === `${ZAI_BASE_URL}/api/coding/paas/v4`;
+  return normalized === ZAI_BASE_URL
+    || normalized === `${ZAI_BASE_URL}/api/coding/paas/v4`
+    || normalized === ZAI_CN_BASE_URL
+    || normalized === `${ZAI_CN_BASE_URL}/api/coding/paas/v4`
+    // BigModel serves the same GLM Coding Plan on the OpenAI Responses wire at /api/v1.
+    || normalized === `${ZAI_CN_BASE_URL}/api/v1`;
 }
 
 function isCanonicalMinimaxBaseUrl(baseUrl: string): boolean {
@@ -669,34 +675,67 @@ async function fetchClineQuota(provider: string, config: OcxProviderConfig): Pro
 
 /**
  * Z.AI GLM Coding Plan `GET /api/monitor/usage/quota/limit` — the coding-plan
- * subscription's 5-hour token cycle, weekly quota, and monthly MCP usage.
- * Authenticates with the API key as a Bearer token per Z.AI's API reference.
+ * limits arrive as a `limits` array of `TOKENS_LIMIT` (newer plans call the
+ * same rows `CREDIT_LIMIT`) and `TIME_LIMIT` rows. `TOKENS_LIMIT`/`CREDIT_LIMIT`
+ * rows carry the window length as `unit`/`number`: unit 3 is hours (number 5 →
+ * the rolling five-hour window), unit 6 is weeks (number 1 → the weekly
+ * window). `TIME_LIMIT` rows are the monthly MCP tool budget (Web Search / Web
+ * Reader / Zread). Every row's `percentage` is the consumed share (falling
+ * back to `currentValue`/`usage` when absent) and `nextResetTime` (unix ms)
+ * the window reset.
  */
-async function fetchZaiQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
-  if (!isCanonicalZaiBaseUrl(config.baseUrl)) return null;
-  const apiKey = resolveEnvValue(config.apiKey)?.trim();
-  if (!apiKey) return null;
-  const response = await fetch(`${ZAI_BASE_URL}/api/monitor/usage/quota/limit`, {
-    headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
-    redirect: "error",
-    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
-  });
-  if (!response.ok) {
-    return response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 429
-      ? TERMINAL_QUOTA_FAILURE
-      : null;
+export function parseZaiQuotaLimits(data: Record<string, unknown> | null): ProviderQuota | null {
+  const limits = Array.isArray(data?.limits) ? data.limits as unknown[] : null;
+  if (!limits) return null;
+  const quota: ProviderQuota = { updatedAt: Date.now() };
+  let windows = 0;
+  for (const raw of limits) {
+    const row = asRecord(raw);
+    if (!row) continue;
+    const resetAt = normalizeResetAt(row.nextResetTime);
+    let percent = normalizePercent(row.percentage);
+    if (percent === undefined) {
+      const used = toFiniteNumber(row.currentValue);
+      const total = toFiniteNumber(row.usage);
+      if (used !== undefined && total !== undefined && total > 0) {
+        percent = normalizePercent((used / total) * 100);
+      }
+    }
+    if (percent === undefined) continue;
+    if (row.type === "TOKENS_LIMIT" || row.type === "CREDIT_LIMIT") {
+      const unit = toFiniteNumber(row.unit);
+      const number = toFiniteNumber(row.number);
+      if (unit === 3 && number === 5) {
+        quota.fiveHourPercent = percent;
+        if (resetAt !== undefined) quota.fiveHourResetAt = resetAt;
+        windows += 1;
+      } else if (unit === 6 && number === 1) {
+        quota.weeklyPercent = percent;
+        if (resetAt !== undefined) quota.weeklyResetAt = resetAt;
+        windows += 1;
+      }
+    } else if (row.type === "TIME_LIMIT") {
+      quota.monthlyPercent = percent;
+      if (resetAt !== undefined) quota.monthlyResetAt = resetAt;
+      windows += 1;
+    }
   }
-  const body = asRecord(await readQuotaJson(response));
-  if (!body || body.success === false) return null;
-  const data = asRecord(body.data) ?? body;
-  // The plugin renders a 5h token window, a weekly window, and a monthly MCP
-  // window. Look for percent fields with window identifiers.
+  return windows > 0 ? quota : null;
+}
+
+/**
+ * Legacy Z.AI payload shape: percent fields with window identifiers directly on
+ * the data object (optionally nested under `quota`). Kept as a fallback so
+ * older responses keep rendering when the `limits` array is absent.
+ */
+function parseZaiQuotaLegacyFields(data: Record<string, unknown> | null): ProviderQuota | null {
+  if (!data) return null;
   const quota: ProviderQuota = { updatedAt: Date.now() };
   let windows = 0;
   const percentAt = (key: string): number | undefined => {
-    const value = normalizePercent(data?.[key]);
+    const value = normalizePercent(data[key]);
     if (value !== undefined) return value;
-    const nested = asRecord(data?.quota);
+    const nested = asRecord(data.quota);
     return nested ? normalizePercent(nested[key]) : undefined;
   };
   const fiveHour = percentAt("fiveHourPercent") ?? percentAt("fiveHourUsage") ?? percentAt("fiveHourUsed");
@@ -714,7 +753,40 @@ async function fetchZaiQuota(provider: string, config: OcxProviderConfig): Promi
     quota.monthlyPercent = monthly;
     windows += 1;
   }
-  return windows > 0 ? report(provider, "zai:quota-limit", quota) : null;
+  return windows > 0 ? quota : null;
+}
+
+/**
+ * Fetches the Z.AI GLM Coding Plan quota — on whichever region the provider
+ * points at (api.z.ai or open.bigmodel.cn). Authenticates with the API key as
+ * a Bearer token per Z.AI's API reference. The `limits` array shape is
+ * preferred; older field-name payloads fall back to the legacy parser.
+ */
+async function fetchZaiQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
+  if (!isCanonicalZaiBaseUrl(config.baseUrl)) return null;
+  const apiKey = resolveEnvValue(config.apiKey)?.trim();
+  if (!apiKey) return null;
+  const normalized = normalizedBaseUrl(config.baseUrl);
+  const monitorHost = normalized === ZAI_BASE_URL || normalized === `${ZAI_BASE_URL}/api/coding/paas/v4`
+    ? ZAI_BASE_URL
+    : ZAI_CN_BASE_URL;
+  const response = await fetch(`${monitorHost}/api/monitor/usage/quota/limit`, {
+    headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
+    redirect: "error",
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+  });
+  if (!response.ok) {
+    return response.status >= 400 && response.status < 500 && response.status !== 408 && response.status !== 429
+      ? TERMINAL_QUOTA_FAILURE
+      : null;
+  }
+  const body = asRecord(await readQuotaJson(response));
+  if (!body || body.success === false) return null;
+  const data = asRecord(body.data) ?? body;
+  const quota = Array.isArray(data?.limits)
+    ? parseZaiQuotaLimits(data)
+    : parseZaiQuotaLegacyFields(data);
+  return quota ? report(provider, "zai:quota-limit", quota) : null;
 }
 
 /**
@@ -2106,7 +2178,8 @@ async function maybeFetchProviderQuota(
     if ((provider.authMode ?? "key") === "key" && name === "cline-pass") {
       return fetchClineQuota(name, provider);
     }
-    if ((provider.authMode ?? "key") === "key" && name === "zai") {
+    if ((provider.authMode ?? "key") === "key"
+      && (name === "zai" || name === "glm" || name === "glm-cn" || name === "zhipu-bigmodel-coding")) {
       return fetchZaiQuota(name, provider);
     }
     if ((provider.authMode ?? "key") === "key" && (name === "minimax" || name === "minimax-cn")) {