npm - @bitkyc08/opencodex - Versions diffs - 2.6.26-preview.20260705 → 2.6.28-preview.20260707 - Mend

@bitkyc08/opencodex 2.6.26-preview.20260705 → 2.6.28-preview.20260707

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (118) hide show

package/README.md +1 -0
package/bin/ocx.mjs +4 -4
package/gui/dist/assets/index-ByGC8-Bm.css +1 -0
package/gui/dist/assets/index-CkV5xFA8.js +15 -0
package/gui/dist/index.html +2 -2
package/package.json +4 -4
package/src/adapters/anthropic-image-guard.ts +195 -0
package/src/adapters/anthropic.ts +85 -14
package/src/adapters/cursor/cursor-errors.ts +2 -2
package/src/adapters/cursor/live-transport.ts +1 -1
package/src/adapters/cursor/transport-retry.ts +2 -2
package/src/adapters/google-errors.ts +1 -1
package/src/adapters/google-http.ts +1 -1
package/src/adapters/google-truncation.ts +1 -1
package/src/adapters/google.ts +1 -1
package/src/adapters/kiro-errors.ts +1 -1
package/src/adapters/kiro-retry.ts +1 -1
package/src/adapters/kiro-truncation.ts +1 -1
package/src/adapters/kiro.ts +1 -1
package/src/adapters/openai-chat.ts +12 -2
package/src/adapters/openai-responses.ts +126 -3
package/src/bridge.ts +164 -7
package/src/{doctor.ts → cli/doctor.ts} +21 -4
package/src/{cli-help.ts → cli/help.ts} +1 -1
package/src/cli/index.ts +584 -0
package/src/{init.ts → cli/init.ts} +6 -6
package/src/{cli-models.ts → cli/models.ts} +2 -2
package/src/{cli-provider.ts → cli/provider.ts} +12 -8
package/src/{star-prompt.ts → cli/star-prompt.ts} +1 -1
package/src/{cli-status.ts → cli/status.ts} +7 -7
package/src/cli.ts +9 -575
package/src/{codex-account-label.ts → codex/account-label.ts} +1 -1
package/src/{codex-account-lifecycle.ts → codex/account-lifecycle.ts} +6 -6
package/src/{codex-account-store.ts → codex/account-store.ts} +2 -2
package/src/{codex-account-usability.ts → codex/account-usability.ts} +4 -4
package/src/{codex-auth-api.ts → codex/auth-api.ts} +18 -18
package/src/{codex-auth-collision.ts → codex/auth-collision.ts} +4 -4
package/src/{codex-auth-context.ts → codex/auth-context.ts} +9 -9
package/src/{codex-catalog.ts → codex/catalog.ts} +49 -20
package/src/codex/history-migration-guardian.ts +102 -0
package/src/{codex-history-provider.ts → codex/history-provider.ts} +111 -7
package/src/{codex-home.ts → codex/home.ts} +1 -1
package/src/{codex-inject.ts → codex/inject.ts} +204 -26
package/src/{codex-journal.ts → codex/journal.ts} +2 -2
package/src/{codex-main-account.ts → codex/main-account.ts} +2 -2
package/src/{model-cache.ts → codex/model-cache.ts} +1 -1
package/src/{codex-paths.ts → codex/paths.ts} +2 -2
package/src/{codex-plugins-doctor.ts → codex/plugins-doctor.ts} +2 -2
package/src/{codex-refresh.ts → codex/refresh.ts} +4 -4
package/src/{codex-routing.ts → codex/routing.ts} +8 -8
package/src/{codex-shim.ts → codex/shim.ts} +6 -5
package/src/{codex-sync.ts → codex/sync.ts} +4 -4
package/src/{codex-websocket-registry.ts → codex/websocket-registry.ts} +1 -1
package/src/config.ts +2 -0
package/src/generated/jawcode-model-metadata.ts +2 -0
package/src/{bun-runtime.ts → lib/bun-runtime.ts} +1 -1
package/src/{crash-guard.ts → lib/crash-guard.ts} +1 -1
package/src/{process-control.ts → lib/process-control.ts} +1 -1
package/src/{service-secrets.ts → lib/service-secrets.ts} +1 -1
package/src/oauth/callback-server.ts +1 -1
package/src/oauth/google-antigravity.ts +7 -4
package/src/oauth/index.ts +67 -16
package/src/oauth/login-cli.ts +2 -2
package/src/oauth/store.ts +236 -20
package/src/oauth/token-guardian.ts +24 -20
package/src/oauth/types.ts +16 -0
package/src/providers/api-keys.ts +121 -0
package/src/{provider-context-cap.ts → providers/context-cap.ts} +1 -1
package/src/providers/derive.ts +2 -0
package/src/providers/key-failover.ts +145 -0
package/src/{provider-label.ts → providers/label.ts} +1 -1
package/src/{provider-quota.ts → providers/quota.ts} +12 -7
package/src/providers/registry.ts +66 -4
package/src/responses/compaction.ts +117 -0
package/src/responses/parser.ts +89 -13
package/src/responses/reasoning-envelope.ts +52 -0
package/src/responses/schema.ts +15 -3
package/src/responses/state.ts +117 -2
package/src/router.ts +2 -0
package/src/server/auth-cors.ts +231 -0
package/src/server/index.ts +523 -0
package/src/server/lifecycle.ts +73 -0
package/src/server/management-api.ts +628 -0
package/src/{proxy-liveness.ts → server/proxy-liveness.ts} +1 -1
package/src/server/relay.ts +534 -0
package/src/server/request-decompress.ts +46 -0
package/src/server/request-log.ts +310 -0
package/src/server/responses.ts +775 -0
package/src/{ws-bridge.ts → server/ws-bridge.ts} +44 -13
package/src/service.ts +19 -11
package/src/types.ts +27 -0
package/src/{update.ts → update/index.ts} +5 -5
package/src/{update-job.ts → update/job.ts} +7 -6
package/src/{update-notify.ts → update/notify.ts} +3 -3
package/src/{usage-debug.ts → usage/debug.ts} +3 -3
package/src/{usage-log.ts → usage/log.ts} +3 -3
package/src/{usage-summary.ts → usage/summary.ts} +3 -3
package/src/{usage-totals.ts → usage/totals.ts} +1 -1
package/src/vision/describe.ts +3 -3
package/src/vision/index.ts +21 -1
package/src/web-search/executor.ts +4 -4
package/src/web-search/index.ts +1 -1
package/src/web-search/loop.ts +84 -24
package/gui/dist/assets/index-BcHhxo1I.css +0 -1
package/gui/dist/assets/index-DCC1q_Jx.js +0 -15
package/src/server.ts +0 -2501
/package/src/{codex-account-runtime-state.ts → codex/account-runtime-state.ts} +0 -0
/package/src/{codex-quota.ts → codex/quota.ts} +0 -0
/package/src/{abort.ts → lib/abort.ts} +0 -0
/package/src/{debug.ts → lib/debug.ts} +0 -0
/package/src/{errors.ts → lib/errors.ts} +0 -0
/package/src/{open-url.ts → lib/open-url.ts} +0 -0
/package/src/{privacy.ts → lib/privacy.ts} +0 -0
/package/src/{redact.ts → lib/redact.ts} +0 -0
/package/src/{sidecar-tracker.ts → lib/sidecar-tracker.ts} +0 -0
/package/src/{upstream-retry.ts → lib/upstream-retry.ts} +0 -0
/package/src/{win-paths.ts → lib/win-paths.ts} +0 -0
/package/src/{ports.ts → server/ports.ts} +0 -0

package/gui/dist/index.html CHANGED Viewed

@@ -16,8 +16,8 @@
         } catch (e) {}
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-DCC1q_Jx.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BcHhxo1I.css">
+    <script type="module" crossorigin src="/assets/index-CkV5xFA8.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-ByGC8-Bm.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@bitkyc08/opencodex",
-  "version": "2.6.26-preview.20260705",
+  "version": "2.6.28-preview.20260707",
   "description": "Universal provider proxy for OpenAI Codex — use any LLM with Codex CLI/App/SDK",
   "type": "module",
   "main": "./bin/package-main.mjs",
@@ -32,10 +32,10 @@
     "bun"
   ],
   "scripts": {
-    "dev": "bun run src/cli.ts start",
-    "dev:proxy": "bun run src/cli.ts start",
+    "dev": "bun run src/cli/index.ts start",
+    "dev:proxy": "bun run src/cli/index.ts start",
     "dev:gui": "cd gui && bun run dev",
-    "start": "bun run src/cli.ts start",
+    "start": "bun run src/cli/index.ts start",
     "test": "bun test ./tests/",
     "typecheck": "bun x tsc --noEmit",
     "privacy:scan": "bun scripts/privacy-scan.ts",

package/src/adapters/anthropic-image-guard.ts ADDED Viewed

@@ -0,0 +1,195 @@
+/**
+ * Anthropic per-request image limits (docs.anthropic.com Vision, verified 2026-07-06):
+ * - <= 20 images: each image may be up to 8000px on a side.
+ * - > 20 images ("many-image request"): each image is capped at 2000px per side;
+ *   one offender 400s the whole request:
+ *   "At least one of the image dimensions exceed max allowed size for many-image requests: 2000 pixels"
+ * - Hard cap: 100 images per request.
+ *
+ * Codex threads accumulate screenshots in history, so long sessions cross 20 images
+ * easily and any single retina capture (>2000px wide) kills every later turn. Bun has
+ * no native resizer and we do not want a decoder dependency, so instead of downscaling
+ * we keep the request under the 20-image threshold (restoring the 8000px allowance) by
+ * textifying the OLDEST image blocks. Newest screenshots are the ones the model needs.
+ */
+export const MANY_IMAGE_THRESHOLD = 20;
+export const MANY_IMAGE_MAX_DIMENSION = 2000;
+export const ABSOLUTE_MAX_DIMENSION = 8000;
+export const MAX_IMAGES_PER_REQUEST = 100;
+const OMITTED_TEXT = "[image omitted: Anthropic request exceeded the 20-image limit for large images; older screenshots were dropped]";
+const OVERSIZED_TEXT = "[image omitted: exceeds Anthropic's 8000px per-side limit]";
+interface ImageDimensions { width: number; height: number }
+/** Read big-endian u16/u32 helpers over a byte array. */
+function u16be(b: Uint8Array, o: number): number { return (b[o] << 8) | b[o + 1]; }
+function u32be(b: Uint8Array, o: number): number { return ((b[o] << 24) | (b[o + 1] << 16) | (b[o + 2] << 8) | b[o + 3]) >>> 0; }
+function u16le(b: Uint8Array, o: number): number { return b[o] | (b[o + 1] << 8); }
+function u24le(b: Uint8Array, o: number): number { return b[o] | (b[o + 1] << 8) | (b[o + 2] << 16); }
+function pngDimensions(b: Uint8Array): ImageDimensions | null {
+  // 8-byte signature + IHDR chunk (len+type at 8..16, data at 16).
+  if (b.length < 24) return null;
+  if (b[0] !== 0x89 || b[1] !== 0x50 || b[2] !== 0x4e || b[3] !== 0x47) return null;
+  return { width: u32be(b, 16), height: u32be(b, 20) };
+}
+function jpegDimensions(b: Uint8Array): ImageDimensions | null {
+  if (b.length < 4 || b[0] !== 0xff || b[1] !== 0xd8) return null;
+  let o = 2;
+  while (o + 9 < b.length) {
+    if (b[o] !== 0xff) { o++; continue; }
+    const marker = b[o + 1];
+    // Skip padding/fill bytes and standalone markers (RSTn, TEM) which have no length.
+    if (marker === 0xff) { o++; continue; }
+    if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) { o += 2; continue; }
+    // SOF0-SOF15 carry dimensions, excluding DHT(0xc4)/JPG(0xc8)/DAC(0xcc).
+    if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+      return { height: u16be(b, o + 5), width: u16be(b, o + 7) };
+    }
+    if (marker === 0xd9 || marker === 0xda) return null; // EOI / start of scan: no SOF found
+    const len = u16be(b, o + 2);
+    if (len < 2) return null;
+    o += 2 + len;
+  }
+  return null;
+}
+function gifDimensions(b: Uint8Array): ImageDimensions | null {
+  if (b.length < 10) return null;
+  if (b[0] !== 0x47 || b[1] !== 0x49 || b[2] !== 0x46) return null;
+  return { width: u16le(b, 6), height: u16le(b, 8) };
+}
+function webpDimensions(b: Uint8Array): ImageDimensions | null {
+  if (b.length < 30) return null;
+  if (b[0] !== 0x52 || b[1] !== 0x49 || b[2] !== 0x46 || b[3] !== 0x46) return null; // RIFF
+  if (b[8] !== 0x57 || b[9] !== 0x45 || b[10] !== 0x42 || b[11] !== 0x50) return null; // WEBP
+  const fourcc = String.fromCharCode(b[12], b[13], b[14], b[15]);
+  if (fourcc === "VP8X") {
+    return { width: u24le(b, 24) + 1, height: u24le(b, 27) + 1 };
+  }
+  if (fourcc === "VP8 ") {
+    // Lossy: frame tag at 20, sync code 9d 01 2a, then 14-bit width/height.
+    if (b[23] !== 0x9d || b[24] !== 0x01 || b[25] !== 0x2a) return null;
+    return { width: u16le(b, 26) & 0x3fff, height: u16le(b, 28) & 0x3fff };
+  }
+  if (fourcc === "VP8L") {
+    if (b[20] !== 0x2f) return null;
+    // VP8L stores 14-bit width-1 / height-1 little-endian-bit-packed.
+    const raw = b[21] | (b[22] << 8) | (b[23] << 16) | (b[24] << 24);
+    const width = (raw & 0x3fff) + 1;
+    const height = ((raw >> 14) & 0x3fff) + 1;
+    return { width, height };
+  }
+  return null;
+}
+/**
+ * Sniff pixel dimensions from the first bytes of a base64 image. Returns null when the
+ * format is unrecognized or the header is malformed — callers must treat null as
+ * "unknown, assume within limits" so we never drop an image we cannot prove oversized.
+ */
+export function sniffImageDimensions(base64: string): ImageDimensions | null {
+  // ~48KB of decoded header is enough for every sniffer above, including JPEGs whose
+  // SOF sits behind large EXIF/APPn segments (segments are skipped by length).
+  const slice = base64.slice(0, 65536);
+  let bytes: Uint8Array;
+  try {
+    bytes = Uint8Array.from(atob(slice.length % 4 === 0 ? slice : slice.slice(0, slice.length - (slice.length % 4))), c => c.charCodeAt(0));
+  } catch {
+    return null;
+  }
+  return pngDimensions(bytes) ?? jpegDimensions(bytes) ?? gifDimensions(bytes) ?? webpDimensions(bytes) ?? null;
+}
+interface ImageBlockRef {
+  /** The array holding the block (message content or tool_result content). */
+  container: unknown[];
+  index: number;
+  base64: string | null;
+}
+function isImageBlock(block: unknown): block is { type: "image"; source: Record<string, unknown> } {
+  return typeof block === "object" && block !== null && (block as { type?: unknown }).type === "image";
+}
+/** Collect refs to every image block in wire order (oldest first), descending into tool_result content. */
+function collectImageRefs(messages: unknown[]): ImageBlockRef[] {
+  const refs: ImageBlockRef[] = [];
+  const scanArray = (arr: unknown[]): void => {
+    for (let i = 0; i < arr.length; i++) {
+      const block = arr[i];
+      if (isImageBlock(block)) {
+        const source = block.source as { type?: unknown; data?: unknown };
+        refs.push({
+          container: arr,
+          index: i,
+          base64: source?.type === "base64" && typeof source.data === "string" ? source.data : null,
+        });
+      } else if (typeof block === "object" && block !== null && (block as { type?: unknown }).type === "tool_result") {
+        const content = (block as { content?: unknown }).content;
+        if (Array.isArray(content)) scanArray(content);
+      }
+    }
+  };
+  for (const msg of messages) {
+    const content = (msg as { content?: unknown })?.content;
+    if (Array.isArray(content)) scanArray(content);
+  }
+  return refs;
+}
+function textify(ref: ImageBlockRef, text: string): void {
+  ref.container[ref.index] = { type: "text", text };
+}
+/**
+ * Enforce Anthropic image limits on already-built wire messages (mutates in place).
+ * Policy: unconditionally textify >8000px images; when the request would be a
+ * many-image request (>20) with at least one image over 2000px, textify oldest
+ * images until <=20 so the 8000px allowance applies; always cap at 100 images.
+ */
+export function enforceAnthropicImageLimits(messages: unknown[]): void {
+  const refs = collectImageRefs(messages);
+  if (refs.length === 0) return;
+  const dims = refs.map(r => (r.base64 ? sniffImageDimensions(r.base64) : null));
+  const live = new Set<number>(refs.keys());
+  // Rule 1: images over the absolute 8000px cap are invalid in any request.
+  for (let i = 0; i < refs.length; i++) {
+    const d = dims[i];
+    if (d && (d.width > ABSOLUTE_MAX_DIMENSION || d.height > ABSOLUTE_MAX_DIMENSION)) {
+      textify(refs[i], OVERSIZED_TEXT);
+      live.delete(i);
+    }
+  }
+  // Rule 2: many-image requests cap each image at 2000px. Keep the request at <=20
+  // images (dropping oldest first) whenever a surviving image exceeds that cap OR has
+  // unknown dimensions (URL sources and unsniffable formats): one unverifiable offender
+  // 400s the whole request upstream, so unknown counts as risky, not as safe.
+  const hasRiskyForMany = [...live].some(i => {
+    const d = dims[i];
+    return d === null || d.width > MANY_IMAGE_MAX_DIMENSION || d.height > MANY_IMAGE_MAX_DIMENSION;
+  });
+  if (hasRiskyForMany && live.size > MANY_IMAGE_THRESHOLD) {
+    for (const i of [...live]) {
+      if (live.size <= MANY_IMAGE_THRESHOLD) break;
+      textify(refs[i], OMITTED_TEXT);
+      live.delete(i);
+    }
+  }
+  // Rule 3: hard cap of 100 images per request regardless of size.
+  if (live.size > MAX_IMAGES_PER_REQUEST) {
+    for (const i of [...live]) {
+      if (live.size <= MAX_IMAGES_PER_REQUEST) break;
+      textify(refs[i], OMITTED_TEXT);
+      live.delete(i);
+    }
+  }
+}

package/src/adapters/anthropic.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 import type { ProviderAdapter } from "./base";
-import { debugDroppedFrame } from "../debug";
+import { debugDroppedFrame } from "../lib/debug";
 import type {
   AdapterEvent,
   OcxAssistantMessage,
@@ -16,6 +16,7 @@ import type {
 import { isAllowedToolChoice, namespacedToolName, resolveToolChoiceWireName, toolAllowedByChoice } from "../types";
 import { ANTHROPIC_OAUTH_BETA, CLAUDE_CODE_SYSTEM_INSTRUCTION, applyClaudeToolPrefix, stripClaudeToolPrefix } from "../oauth/anthropic";
 import { parseDataUrl } from "./image";
+import { enforceAnthropicImageLimits } from "./anthropic-image-guard";
 import { neutralizeIdentity } from "./identity";
 import { CLAUDE_CODE_HEADERS, claudeCodeSessionId } from "./client-fingerprint";
 import { buildNonOpenAIToolCatalogNudgeForTools } from "./tool-catalog-nudge";
@@ -257,6 +258,36 @@ function reasoningBudget(effort: string): number {
   }
 }
+/**
+ * Claude families that moved to adaptive thinking: they 400 on `thinking.type: "enabled"`
+ * ("Use \"thinking.type.adaptive\" and \"output_config.effort\" to control thinking behavior."),
+ * while older families (Haiku 4.5, Sonnet 4.x, Opus <= 4.6) 400 on `adaptive` — so both wire
+ * shapes must stay. Verified against api.anthropic.com: sonnet-5, fable-5, opus-4-7 and opus-4-8
+ * require adaptive; haiku-4-5 and sonnet-4-5 reject it; opus-4-6/sonnet-4-6 accept both.
+ */
+const ADAPTIVE_THINKING_FAMILY_MINIMUMS: Record<string, readonly [major: number, minor: number]> = {
+  sonnet: [5, 0],
+  opus: [4, 7],
+  fable: [0, 0],
+};
+function usesAdaptiveThinking(modelId: string): boolean {
+  // Minor is 1-2 digits with a non-digit lookahead so date-pinned ids ("claude-opus-4-20250514")
+  // parse as minor 0 instead of minor 20250514; suffixed ids ("claude-opus-4-8[1m]") still match.
+  const match = /^claude-([a-z]+)-(\d+)(?:-(\d{1,2}))?(?!\d)/.exec(modelId);
+  if (!match) return false;
+  const minimum = ADAPTIVE_THINKING_FAMILY_MINIMUMS[match[1]];
+  if (!minimum) return false;
+  const major = Number(match[2]);
+  const minor = match[3] === undefined ? 0 : Number(match[3]);
+  return major > minimum[0] || (major === minimum[0] && minor >= minimum[1]);
+}
+/** `output_config.effort` accepts low|medium|high|xhigh|max — "minimal" is rejected with a 400. */
+function adaptiveEffort(effort: string): string {
+  return effort === "minimal" ? "low" : effort;
+}
 function usageFromAnthropic(usage: Record<string, number> | undefined): OcxUsage | undefined {
   if (!usage) return undefined;
   const hasCache = usage.cache_read_input_tokens !== undefined || usage.cache_creation_input_tokens !== undefined;
@@ -354,6 +385,11 @@ function messagesToAnthropicFormat(
             content.push({ type: "text", text: (part as OcxTextContent).text });
           } else if (part.type === "thinking") {
             const t = part as OcxThinkingContent;
+            // Redacted blocks replay verbatim FIRST (they preceded the visible thinking block
+            // in the original stream order preserved by the bridge envelope).
+            for (const data of t.redacted ?? []) {
+              content.push({ type: "redacted_thinking", data });
+            }
             if (isLikelyRealAnthropicThinkingSignature(t.signature)) {
               content.push({ type: "thinking", thinking: t.thinking, signature: t.signature });
             }
@@ -406,6 +442,16 @@ function messagesToAnthropicFormat(
     }
   }
+  // Newer Anthropic models reject assistant-tail histories as prefill:
+  // "This model does not support assistant message prefill. The conversation must end with a user message."
+  // previous_response_id expansion with empty new input, interrupted-turn replay, and web-search sidecar
+  // first iterations can all reach this; Kiro uses the same "(continue)" nudge precedent (src/adapters/kiro.ts:283).
+  if (messages.length === 0) {
+    messages.push({ role: "user", content: "(continue)" });
+  } else if ((messages[messages.length - 1] as { role?: string }).role === "assistant") {
+    messages.push({ role: "user", content: "(continue)" });
+  }
   return { system, messages };
 }
@@ -434,6 +480,9 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
     buildRequest(parsed: OcxParsedRequest) {
       const { system, messages } = messagesToAnthropicFormat(parsed, toolNames);
+      // Anthropic rejects many-image requests (>20 images) carrying any image over
+      // 2000px per side; see anthropic-image-guard.ts for the full limit policy.
+      enforceAnthropicImageLimits(messages);
       const tools = toolsToAnthropicFormat(parsed, toolNames);
       const body: Record<string, unknown> = {
@@ -460,16 +509,23 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
       // REASONING_EFFORTS). A bare truthy check would treat "none" as truthy and wrongly enable
       // extended thinking (and strip temperature/top_p), so gate on a real, non-disable effort.
       if (typeof parsed.options.reasoning === "string" && parsed.options.reasoning !== "none") {
-        // Anthropic requires max_tokens > thinking.budget_tokens (max_tokens caps thinking +
-        // visible output) and budget_tokens >= 1024. Codex sends the SAME value for both, which
-        // 400s ("max_tokens must be greater than thinking.budget_tokens"). Size them so max_tokens
-        // always exceeds the budget within a model-safe ceiling, reserving room for visible output.
-        const maxOut = parsed.options.maxOutputTokens ?? DEFAULT_MAX_TOKENS;
-        const wantBudget = reasoningBudget(parsed.options.reasoning);
-        const maxTokens = Math.min(REASONING_MAX_TOKENS_CEILING, Math.max(maxOut, wantBudget + OUTPUT_HEADROOM));
-        const budget = Math.max(MIN_THINKING_BUDGET, Math.min(wantBudget, maxTokens - OUTPUT_FLOOR));
-        body.max_tokens = maxTokens;
-        body.thinking = { type: "enabled", budget_tokens: budget };
+        if (usesAdaptiveThinking(parsed.modelId)) {
+          // Adaptive-thinking models replace the token budget with an effort knob and reject
+          // `thinking.type: "enabled"` outright — no budget/max_tokens re-sizing needed.
+          body.thinking = { type: "adaptive" };
+          body.output_config = { effort: adaptiveEffort(parsed.options.reasoning) };
+        } else {
+          // Anthropic requires max_tokens > thinking.budget_tokens (max_tokens caps thinking +
+          // visible output) and budget_tokens >= 1024. Codex sends the SAME value for both, which
+          // 400s ("max_tokens must be greater than thinking.budget_tokens"). Size them so max_tokens
+          // always exceeds the budget within a model-safe ceiling, reserving room for visible output.
+          const maxOut = parsed.options.maxOutputTokens ?? DEFAULT_MAX_TOKENS;
+          const wantBudget = reasoningBudget(parsed.options.reasoning);
+          const maxTokens = Math.min(REASONING_MAX_TOKENS_CEILING, Math.max(maxOut, wantBudget + OUTPUT_HEADROOM));
+          const budget = Math.max(MIN_THINKING_BUDGET, Math.min(wantBudget, maxTokens - OUTPUT_FLOOR));
+          body.max_tokens = maxTokens;
+          body.thinking = { type: "enabled", budget_tokens: budget };
+        }
         // Extended thinking disallows temperature != 1 and top_p — drop both or the API 400s.
         delete body.temperature;
         delete body.top_p;
@@ -577,7 +633,7 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
                 break;
               }
               case "content_block_start": {
-                const block = data.content_block as { type: string; id?: string; name?: string } | undefined;
+                const block = data.content_block as { type: string; id?: string; name?: string; data?: string } | undefined;
                 if (!block) break;
                 currentBlockType = block.type;
                 if (block.type === "tool_use") {
@@ -585,6 +641,10 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
                   currentToolCallName = toolNames.fromWire(block.name ?? "");
                   yield { type: "tool_call_start", id: currentToolCallId, name: currentToolCallName };
                 }
+                if (block.type === "redacted_thinking" && typeof block.data === "string") {
+                  // Opaque redacted block: replay verbatim later or tool-use turns 400.
+                  yield { type: "redacted_thinking", data: block.data };
+                }
                 break;
               }
               case "content_block_delta": {
@@ -594,6 +654,10 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
                   yield { type: "text_delta", text: delta.text };
                 } else if (delta.type === "thinking_delta" && typeof delta.thinking === "string") {
                   yield { type: "thinking_delta", thinking: delta.thinking };
+                } else if (delta.type === "signature_delta" && typeof delta.signature === "string" && currentBlockType === "thinking") {
+                  // Arrives once, just before the thinking block's content_block_stop; block-scoped
+                  // so a stray signature on a non-thinking block can never be captured.
+                  yield { type: "thinking_signature", signature: delta.signature };
                 } else if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
                   yield { type: "tool_call_delta", arguments: delta.partial_json };
                 }
@@ -603,8 +667,8 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
                 if (currentBlockType === "tool_use") {
                   yield { type: "tool_call_end" };
                   currentToolCallId = "";
-                  currentBlockType = "";
                 }
+                currentBlockType = "";
                 break;
               }
               case "message_delta": {
@@ -634,11 +698,18 @@ export function createAnthropicAdapter(provider: OcxProviderConfig, cacheRetenti
     async parseResponse(response: Response): Promise<AdapterEvent[]> {
       const json = await response.json() as Record<string, unknown>;
       const events: AdapterEvent[] = [];
-      const content = json.content as { type: string; text?: string; id?: string; name?: string; input?: unknown }[] | undefined;
+      const content = json.content as { type: string; text?: string; id?: string; name?: string; input?: unknown; thinking?: string; signature?: string; data?: string }[] | undefined;
       if (content) {
         for (const block of content) {
           if (block.type === "text" && block.text) {
             events.push({ type: "text_delta", text: block.text });
+          } else if (block.type === "thinking" && typeof block.thinking === "string") {
+            events.push({ type: "thinking_delta", thinking: block.thinking });
+            if (typeof block.signature === "string" && block.signature) {
+              events.push({ type: "thinking_signature", signature: block.signature });
+            }
+          } else if (block.type === "redacted_thinking" && typeof block.data === "string") {
+            events.push({ type: "redacted_thinking", data: block.data });
           } else if (block.type === "tool_use") {
             events.push({ type: "tool_call_start", id: block.id ?? "", name: toolNames.fromWire(block.name ?? "") });
             events.push({ type: "tool_call_delta", arguments: JSON.stringify(block.input ?? {}) });

package/src/adapters/cursor/cursor-errors.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { redactSecretString } from "../../redact";
+import { redactSecretString } from "../../lib/redact";
 const ABSOLUTE_PATH_PATTERN = /(?:\/Users\/[^ "';,]+|\/home\/[^ "';,]+|[A-Za-z]:\\Users\\[^ "';,]+)/g;
 // Cursor error messages can contain raw credential key=value pairs beyond what the shared
@@ -13,7 +13,7 @@ function sanitize(value: string): string {
 /**
  * Classify a Cursor transport/Connect/gRPC error message into an actionable category.
- * The returned prefix string is recognized by `src/errors.ts` `classifyError` keywords,
+ * The returned prefix string is recognized by `src/lib/errors.ts` `classifyError` keywords,
  * so bridge-level error mapping produces the right Codex error type (rate_limit, auth, etc.).
  */
 export function classifyCursorError(message: string): string {

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

@@ -30,7 +30,7 @@ import {
   type InteractionQuery,
   type InteractionResponse,
 } from "./gen/agent_pb";
-import { debugProviderDiagnostic } from "../../debug";
+import { debugProviderDiagnostic } from "../../lib/debug";
 import { mcpArgsFromToolCall } from "./protobuf-events";
 import { OCX_RESPONSES_TOOL_PROVIDER } from "./tool-definitions";
 import { cursorUnsafeNativeLocalExecEnabled, handleCursorNativeExec, handleCursorNativeKv, type CursorNativeExecContext } from "./native-exec";

package/src/adapters/cursor/transport-retry.ts CHANGED Viewed

@@ -1,9 +1,9 @@
 import type { CursorRunRequest, CursorServerMessage } from "./types";
 import type { CursorTransport, CursorTransportFactory, CursorTransportFactoryInput } from "./transport";
-import { abortError, sleepWithAbort } from "../../upstream-retry";
+import { abortError, sleepWithAbort } from "../../lib/upstream-retry";
 // Compat: historical name for the shared abortable sleep, kept for external callers.
-export { sleepWithAbort as abortAwareSleep } from "../../upstream-retry";
+export { sleepWithAbort as abortAwareSleep } from "../../lib/upstream-retry";
 export const CURSOR_RETRY_ATTEMPTS = 3;
 export const CURSOR_RETRY_BASE_MS = 250;

package/src/adapters/google-errors.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { redactSecretString } from "../redact";
+import { redactSecretString } from "../lib/redact";
 const ABSOLUTE_PATH_PATTERN = /(?:\/Users\/[^ "';,]+|\/home\/[^ "';,]+|\/root\/[^ "';,]*|[A-Za-z]:\\Users\\[^ "';,]+)/g;

package/src/adapters/google-http.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import type { AdapterFetchContext, AdapterRequest } from "./base";
 import { isQuotaExhaustedBody, retryableGoogleStatus, safeGoogleHttpErrorMessage } from "./google-errors";
-import { abortError, sleepWithAbort } from "../upstream-retry";
+import { abortError, sleepWithAbort } from "../lib/upstream-retry";
 const GOOGLE_RETRY_ATTEMPTS = 3;
 const GOOGLE_RETRY_BASE_MS = 250;

package/src/adapters/google-truncation.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { redactSecretString } from "../redact";
+import { redactSecretString } from "../lib/redact";
 /** Gemini/Vertex finishReason values that mean the turn was cut off, not cleanly stopped. */
 const TRUNCATION_REASONS = new Set(["MAX_TOKENS", "MALFORMED_FUNCTION_CALL"]);

package/src/adapters/google.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 import type { AdapterFetchContext, AdapterRequest, ProviderAdapter } from "./base";
-import { debugDroppedFrame } from "../debug";
+import { debugDroppedFrame } from "../lib/debug";
 import { createHash } from "node:crypto";
 import type {
   AdapterEvent,

package/src/adapters/kiro-errors.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { redactSecretString } from "../redact";
+import { redactSecretString } from "../lib/redact";
 const ABSOLUTE_PATH_PATTERN = /(?:\/Users\/[^ "';,]+|\/home\/[^ "';,]+|[A-Za-z]:\\Users\\[^ "';,]+)/g;
 const DETAIL_KEYS = ["__type", "code", "error", "name", "message", "Message", "errorMessage"];

package/src/adapters/kiro-retry.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import type { AdapterFetchContext, AdapterRequest } from "./base";
 import { safeKiroHttpErrorMessage } from "./kiro-errors";
-import { abortError, sleepWithAbort } from "../upstream-retry";
+import { abortError, sleepWithAbort } from "../lib/upstream-retry";
 const KIRO_RETRY_ATTEMPTS = 3;
 const KIRO_RETRY_BASE_MS = 250;

package/src/adapters/kiro-truncation.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { redactSecretString } from "../redact";
+import { redactSecretString } from "../lib/redact";
 const REASON_KEYS = ["finish_reason", "finishReason", "stop_reason", "stopReason", "completionReason", "reason"];
 const TRUNCATION_PATTERN = /length|max[_-]?tokens?|truncat|incomplete|context_length/i;

package/src/adapters/kiro.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import { decodeEventStream } from "../lib/eventstream-decoder";
 import { estimateTokens } from "../lib/token-estimate";
-import { debugProviderDiagnostic } from "../debug";
+import { debugProviderDiagnostic } from "../lib/debug";
 import { resolveKiroApiRegion, resolveKiroProfileArn } from "../oauth/kiro";
 import { KIRO_MODEL_CONTEXT_WINDOWS, normalizeKiroModelId } from "../providers/kiro-models";
 import { modelRecordValue } from "../reasoning-effort";

package/src/adapters/openai-chat.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 import type { ProviderAdapter } from "./base";
-import { debugDroppedFrame } from "../debug";
+import { debugDroppedFrame } from "../lib/debug";
 import type { AdapterEvent, OcxAssistantMessage, OcxContentPart, OcxMessage, OcxParsedRequest, OcxProviderConfig, OcxTextContent, OcxThinkingContent, OcxToolCall, OcxUsage } from "../types";
 import { isAllowedToolChoice, modelInList, namespacedToolName, resolveToolChoiceWireName, toolAllowedByChoice } from "../types";
 import { mapReasoningEffort } from "../reasoning-effort";
@@ -195,7 +195,17 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
       }
       if (parsed.options.stopSequences !== undefined) body.stop = parsed.options.stopSequences;
       const reasoningEffort = mapReasoningEffort(provider, parsed.modelId, parsed.options.reasoning);
-      if (reasoningEffort !== undefined) body.reasoning_effort = reasoningEffort;
+      if (reasoningEffort !== undefined) {
+        if (modelInList(provider.thinkingToggleModels, parsed.modelId)) {
+          // Vendor thinking-toggle wire (MiMo v2.x, GLM 5/5.1): the mapped value is the toggle
+          // state, sent as `thinking: {type}` — these models ignore/reject reasoning_effort.
+          if (reasoningEffort === "enabled" || reasoningEffort === "disabled") {
+            body.thinking = { type: reasoningEffort };
+          }
+        } else {
+          body.reasoning_effort = reasoningEffort;
+        }
+      }
       if (parsed.options.presencePenalty !== undefined && !modelInList(provider.noPenaltyModels, parsed.modelId)) {
         body.presence_penalty = parsed.options.presencePenalty;
       }