@iislee/opencodex 2.11.0 → 2.31.0

package/src/chat/inbound.ts

@@ -8,12 +8,25 @@
 export class ChatCompletionsRequestError extends Error {}
 
 type Rec = Record<string, unknown>;
+type ChatCompletionsRoutingBody = Rec & { model: string; messages: unknown[] };
 
 function isRec(v: unknown): v is Rec {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
 
+/** Validate only the fields needed before Chat routing, without projecting the body. */
+export function assertChatCompletionsRoutingBody(raw: unknown): asserts raw is ChatCompletionsRoutingBody {
+  if (!isRec(raw)) throw new ChatCompletionsRequestError("request body must be a JSON object");
+  if (typeof raw.model !== "string" || raw.model.length === 0) {
+    throw new ChatCompletionsRequestError("model is required");
+  }
+  if (!Array.isArray(raw.messages) || raw.messages.length === 0) {
+    throw new ChatCompletionsRequestError("messages must be a non-empty array");
+  }
+}
+
 const OUTPUT_CONFIG_EFFORTS = new Set(["minimal", "low", "medium", "high", "xhigh", "max", "ultra"]);
+const OUTPUT_CONFIG_SUMMARIES = new Set(["auto", "concise", "detailed", "none"]);
 
 function contentToText(content: unknown): string {
   if (typeof content === "string") return content;
@@ -86,17 +99,8 @@ function pushSystemText(parts: string[], content: unknown): void {
   if (text) parts.push(text);
 }
 
-function toolCallsToItems(toolCalls: unknown, input: Rec[]): void {
+function toolCallsToItems(toolCalls: unknown, input: Rec[], knownNameByCallId: Map<string, string>): void {
   if (!Array.isArray(toolCalls)) return;
-  // Recover names from earlier function_call items in the same transcript when a client
-  // re-sends tool_calls with only id/arguments (replace-style merge lost function.name).
-  const knownNameByCallId = new Map<string, string>();
-  for (const item of input) {
-    if (!isRec(item) || item.type !== "function_call") continue;
-    if (typeof item.call_id === "string" && typeof item.name === "string" && item.name.length > 0) {
-      knownNameByCallId.set(item.call_id, item.name);
-    }
-  }
   for (const raw of toolCalls) {
     if (!isRec(raw)) continue;
     const fn = isRec(raw.function) ? raw.function : null;
@@ -205,21 +209,34 @@ function resolveReasoningEffort(raw: Rec): string | undefined {
   return undefined;
 }
 
+/**
+ * Chat Completions clients (Grok Build, Copilot, OpenAI-compatible SDKs) expect
+ * `delta.reasoning_content` whenever the model thinks. The internal Responses
+ * parser hides thinking unless `reasoning.summary` is set and is not `"none"`.
+ * Map the common Chat Completions knobs onto that field. When the client only
+ * sent an effort, default the summary to `"auto"` so traces are not swallowed.
+ */
+function resolveReasoningSummary(raw: Rec): string | undefined {
+  if (isRec(raw.reasoning) && typeof raw.reasoning.summary === "string" && OUTPUT_CONFIG_SUMMARIES.has(raw.reasoning.summary)) {
+    return raw.reasoning.summary;
+  }
+  if (raw.include_reasoning === false) return "none";
+  if (raw.include_reasoning === true) return "auto";
+  return undefined;
+}
+
 /**
  * Translate an OpenAI Chat Completions request body into a /v1/responses request body.
  * Throws ChatCompletionsRequestError (-> 400) on malformed input.
  */
 export function chatCompletionsToResponsesBody(raw: unknown): Rec {
-  if (!isRec(raw)) throw new ChatCompletionsRequestError("request body must be a JSON object");
-  if (typeof raw.model !== "string" || raw.model.length === 0) {
-    throw new ChatCompletionsRequestError("model is required");
-  }
-  if (!Array.isArray(raw.messages) || raw.messages.length === 0) {
-    throw new ChatCompletionsRequestError("messages must be a non-empty array");
-  }
+  assertChatCompletionsRoutingBody(raw);
 
   const systemParts: string[] = [];
   const input: Rec[] = [];
+  // Recover replace-style tool calls incrementally instead of rebuilding the
+  // call-id index from the entire translated transcript for every message.
+  const knownNameByCallId = new Map<string, string>();
 
   for (const msg of raw.messages) {
     if (!isRec(msg)) continue;
@@ -237,7 +254,7 @@ export function chatCompletionsToResponsesBody(raw: unknown): Rec {
       case "assistant": {
         const blocks = assistantContentToBlocks(msg.content);
         if (blocks.length > 0) input.push({ type: "message", role: "assistant", content: blocks });
-        if (msg.tool_calls !== undefined) toolCallsToItems(msg.tool_calls, input);
+        if (msg.tool_calls !== undefined) toolCallsToItems(msg.tool_calls, input, knownNameByCallId);
         break;
       }
       case "tool": {
@@ -282,11 +299,18 @@ export function chatCompletionsToResponsesBody(raw: unknown): Rec {
   if (raw.stop !== undefined) body.stop = raw.stop;
   if (typeof raw.user === "string") body.user = raw.user;
   if (typeof raw.parallel_tool_calls === "boolean") body.parallel_tool_calls = raw.parallel_tool_calls;
+  if (typeof raw.service_tier === "string") body.service_tier = raw.service_tier;
   if (typeof raw.prompt_cache_key === "string") body.prompt_cache_key = raw.prompt_cache_key;
   if (raw.metadata !== undefined) body.metadata = raw.metadata;
 
   const effort = resolveReasoningEffort(raw);
-  if (effort) body.reasoning = { effort };
+  const summary = resolveReasoningSummary(raw);
+  if (effort || summary !== undefined) {
+    body.reasoning = {
+      ...(effort ? { effort } : {}),
+      summary: summary ?? "auto",
+    };
+  }
 
   const text = responseFormatToText(raw.response_format);
   if (text) body.text = text;

package/src/chat/outbound.ts

@@ -7,7 +7,7 @@
  */
 type Rec = Record<string, unknown>;
 
-import { decodeServerSentEvents } from "../lib/sse-decoder";
+import { decodeServerSentEvents, sseFieldValue } from "../lib/sse-decoder";
 import { isTranslatorBudgetExceededError, type TranslatorBudget } from "../lib/translator-budget";
 import { classifyError, CYBER_POLICY_ERROR_CODE, isCyberPolicyCode, isCyberPolicyMessage } from "../lib/errors";
 
@@ -319,7 +319,9 @@ export function responsesSseToChatCompletionsSse(
           closeToolCalls();
           try { void sseIterator?.return(undefined).catch(() => {}); } catch { /* already closed */ }
           classified.code = "translation_buffer_limit";
-          classified.type = "invalid_request_error";
+          // Provider-controlled overflow is an upstream failure on every path:
+          // streaming frame, collector, and defensive JSON agree on 502.
+          classified.type = "upstream_error";
         } else if (isCyberPolicyCode(details?.code) || classified.code === CYBER_POLICY_ERROR_CODE) {
           classified.code = CYBER_POLICY_ERROR_CODE;
           classified.type = "invalid_request_error";
@@ -468,7 +470,7 @@ export function responsesSseToChatCompletionsSse(
             fail(message, {
               code,
               ...(code === "translation_buffer_limit"
-                ? { status: 413, type: "invalid_request_error" }
+                ? { status: 502, type: "upstream_error" }
                 : { type, ...(code === CYBER_POLICY_ERROR_CODE ? { status: 400 } : {}) }),
             });
             break;
@@ -514,7 +516,7 @@ export function responsesSseToChatCompletionsSse(
           if (isTranslatorBudgetExceededError(err)) {
             upstreamAbort.abort(err);
             closeToolCalls();
-            fail(err.message, { status: 413, type: "invalid_request_error", code: err.code });
+            fail(err.message, { status: 502, type: "upstream_error", code: err.code });
           } else {
             fail(err instanceof Error ? err.message : String(err));
           }
@@ -629,6 +631,9 @@ export async function collectChatCompletion(
   let content = "";
   let reasoning = "";
   const toolCalls = new Map<number, { id: string; name: string; arguments: string; argumentBytes: number }>();
+  // Per-call budget scopes (2 MiB/call enforced by the budget): the map key is the
+  // wire index, which is stable across deltas and present before the call id.
+  const callScope = (index: number) => `chat_collect_${index}`;
   let finishReason = "stop";
   let usage: unknown;
   let streamError: ChatCompletionsStreamError | null = null;
@@ -648,9 +653,11 @@ export async function collectChatCompletion(
       } catch (err) {
         if (isChatCompletionsStreamError(err)) throw err;
         if (isTranslatorBudgetExceededError(err)) {
+          // Provider-controlled overflow is an upstream failure, not a client
+          // request error: match the adapter/bridge contract (502 upstream_error).
           throw new ChatCompletionsStreamError(err.message, {
-            status: 413,
-            type: "invalid_request_error",
+            status: 502,
+            type: "upstream_error",
             code: err.code,
           });
         }
@@ -664,8 +671,9 @@ export async function collectChatCompletion(
         const rawFrame = buffer.slice(0, sep);
         buffer = replaceRetained(buffer, buffer.slice(sep + 2), "live_transient");
         for (const line of rawFrame.split("\n")) {
-          if (!line.startsWith("data: ")) continue;
-          const data = line.slice(6).trim();
+          const rawData = sseFieldValue(line, "data");
+          if (rawData === null) continue;
+          const data = rawData.trim();
           if (!data || data === "[DONE]") continue;
           let parsed: unknown;
           try { parsed = JSON.parse(data); } catch { continue; }
@@ -677,11 +685,15 @@ export async function collectChatCompletion(
             const type = typeof parsed.error.type === "string" ? parsed.error.type : "server_error";
             const code = typeof parsed.error.code === "string" ? parsed.error.code : null;
             const status = code === "translation_buffer_limit"
-              ? 413
+              ? 502
               : code === CYBER_POLICY_ERROR_CODE || isCyberPolicyMessage(message)
                 ? 400
                 : streamErrorStatus(message);
-            streamError = new ChatCompletionsStreamError(message, { status, type, code });
+            streamError = new ChatCompletionsStreamError(message, {
+              status,
+              type: code === "translation_buffer_limit" ? "upstream_error" : type,
+              code,
+            });
             continue;
           }
           if (parsed.usage) usage = parsed.usage;
@@ -697,7 +709,12 @@ export async function collectChatCompletion(
             for (const tc of delta.tool_calls) {
               if (!isRec(tc)) continue;
               const index = typeof tc.index === "number" ? tc.index : 0;
-              const current = toolCalls.get(index) ?? { id: "", name: "", arguments: "", argumentBytes: 0 };
+              let current = toolCalls.get(index);
+              if (!current) {
+                current = { id: "", name: "", arguments: "", argumentBytes: 0 };
+                toolCalls.set(index, current);
+                translatorBudget.openCall(callScope(index));
+              }
               if (typeof tc.id === "string") current.id = tc.id;
               const fn = isRec(tc.function) ? tc.function : {};
               // Done-frame final arguments are authoritative last-write-wins snapshots.
@@ -707,27 +724,43 @@ export async function collectChatCompletion(
                 const nextBytes = replace
                   ? Buffer.byteLength(fn.arguments)
                   : appendedUtf8Bytes(current.arguments, current.argumentBytes, fn.arguments);
-                const reservation = translatorBudget.reserveTransient(nextBytes, { kind: "retained_collectors" });
+                const reservation = translatorBudget.reserveTransient(nextBytes, { kind: "tool_args", callId: callScope(index) });
                 try {
                   current.arguments = replace ? fn.arguments : current.arguments + fn.arguments;
                   reservation.commitRetained();
-                  translatorBudget.releaseRetained(current.argumentBytes, { kind: "retained_collectors" });
+                  translatorBudget.releaseRetained(current.argumentBytes, { kind: "tool_args", callId: callScope(index) });
                   current.argumentBytes = nextBytes;
                 } catch (error) {
                   reservation.release();
                   throw error;
                 }
               }
-              toolCalls.set(index, current);
             }
           }
         }
       }
     }
+  } catch (error) {
+    // Never leak an open call scope on the error path; the turn budget's
+    // dispose is a backstop, not the owner of this transfer.
+    for (const index of toolCalls.keys()) translatorBudget.closeCall(callScope(index));
+    // Processing-time overflow (per-call or turn cap) gets the same typed
+    // contract as read-time overflow: 502 upstream_error.
+    if (isTranslatorBudgetExceededError(error)) {
+      throw new ChatCompletionsStreamError(error.message, {
+        status: 502,
+        type: "upstream_error",
+        code: error.code,
+      });
+    }
+    throw error;
   } finally {
     reader.releaseLock();
   }
-  if (streamError) throw streamError;
+  if (streamError) {
+    for (const index of toolCalls.keys()) translatorBudget.closeCall(callScope(index));
+    throw streamError;
+  }
 
   const message: Rec = {
     role: "assistant",
@@ -735,17 +768,40 @@ export async function collectChatCompletion(
   };
   if (reasoning) message.reasoning_content = reasoning;
   if (toolCalls.size > 0) {
-    message.tool_calls = [...toolCalls.entries()]
-      .sort((a, b) => a[0] - b[0])
-      .map(([, tc]) => {
-        const copy = {
-        id: tc.id || `call_${uuid().slice(0, 16)}`,
-        type: "function",
-        function: { name: tc.name, arguments: tc.arguments },
-        };
-        translatorBudget.chargeRetained(Buffer.byteLength(JSON.stringify(copy)), { kind: "retained_collectors" });
-        return copy;
-      });
+    // Final owner transfer is itself a charging operation: if it overflows,
+    // release every copy already charged in this loop and close every scope
+    // still open — the error must not escape as a raw budget exception.
+    const chargedCopies: number[] = [];
+    try {
+      message.tool_calls = [...toolCalls.entries()]
+        .sort((a, b) => a[0] - b[0])
+        .map(([index, tc]) => {
+          const copy = {
+          id: tc.id || `call_${uuid().slice(0, 16)}`,
+          type: "function",
+          function: { name: tc.name, arguments: tc.arguments },
+          };
+          const copyBytes = Buffer.byteLength(JSON.stringify(copy));
+          translatorBudget.chargeRetained(copyBytes, { kind: "retained_collectors" });
+          chargedCopies.push(copyBytes);
+          // The serialized owner is charged; release the per-call accumulation.
+          translatorBudget.closeCall(callScope(index));
+          return copy;
+        });
+    } catch (error) {
+      for (const copyBytes of chargedCopies) {
+        translatorBudget.releaseRetained(copyBytes, { kind: "retained_collectors" });
+      }
+      for (const index of toolCalls.keys()) translatorBudget.closeCall(callScope(index));
+      if (isTranslatorBudgetExceededError(error)) {
+        throw new ChatCompletionsStreamError(error.message, {
+          status: 502,
+          type: "upstream_error",
+          code: error.code,
+        });
+      }
+      throw error;
+    }
     if (finishReason === "stop") finishReason = "tool_calls";
   }
 

package/src/claude/agents-inject.ts

@@ -11,16 +11,17 @@
  * Ownership contract: this module only creates/overwrites/deletes files matching
  * `ocx-*.md` inside the agents dir. User-authored agents are never touched.
  */
-import { lstatSync, mkdirSync, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { lstatSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { OcxConfig } from "../types";
+import { renameAtomicFile } from "../lib/windows-atomic-replace";
 import { claudeCodeAlias, claudeCodeNativeAlias } from "./alias";
-import { resolveAutoContext, stripOneMillionMarker, withOneMillionMarker } from "./context-windows";
+import { AUTO_CONTEXT_OFF, shouldMarkOneMillion, stripOneMillionMarker, withOneMillionMarker } from "./context-windows";
 import { claudeConfigDir } from "./gateway-cache";
 import { DEFAULT_SUBAGENT_MODELS, hasOwnProvider } from "../config";
 import { effectiveBlockedSkillNames, resolveInboundModel } from "./inbound";
 import { knownModelIdsForProvider } from "../router";
-import { decodeRoutedModelId } from "../providers/slug-codec";
+import { decodeRoutedModelIdOrThrow } from "../providers/slug-codec";
 
 export interface ClaudeAgentDef {
   file: string;
@@ -58,13 +59,34 @@ function pickerDefaultModel(configDir: string): string | null {
 /** Roster entry -> alias + display parts. Entries are bare native slugs or "provider/id".
  * Codex-facing encoded ids (`provider/vendor-model`) decode to the native slash id first
  * so the alias joins the raw-native context-window map (context-windows.ts). */
+
+/**
+ * Generated subagent defs cannot rely on the parent's auto-context compaction
+ * pairing, so their [1m] marker follows the AUTHORITATIVE window only: mark when
+ * the effective window (exact selector, then the canonical [1m] form, then bare)
+ * is genuinely >= 1M; strip an inherited unsafe marker back to the bare selector;
+ * with no window information, keep the selector as it was. Genuine routed [1m]
+ * ids are preserved through the canonical-exact lookup. (#854)
+ */
+function withSubagentContextMarker(selector: string, windows: Record<string, number>): string {
+  const bare = stripOneMillionMarker(selector);
+  const wasMarked = selector !== bare;
+  const canonicalExact = wasMarked ? `${bare}[1m]` : selector;
+  const authoritativeWindow = windows[selector] ?? windows[canonicalExact] ?? windows[bare];
+  if (typeof authoritativeWindow === "number" && authoritativeWindow > 0) {
+    return shouldMarkOneMillion(authoritativeWindow, AUTO_CONTEXT_OFF)
+      ? (withOneMillionMarker(selector, windows) ?? selector)
+      : bare;
+  }
+  return wasMarked ? selector : bare;
+}
 function entryParts(entry: string, config: OcxConfig): { alias: string; id: string; provider: string } {
   const slash = entry.indexOf("/");
   if (slash > 0) {
     const provider = entry.slice(0, slash);
     const prov = hasOwnProvider(config.providers, provider) ? config.providers[provider] : undefined;
     const id = prov
-      ? decodeRoutedModelId(entry.slice(slash + 1), knownModelIdsForProvider(provider, prov))
+      ? decodeRoutedModelIdOrThrow(entry.slice(slash + 1), knownModelIdsForProvider(provider, prov, config))
       : entry.slice(slash + 1);
     return { alias: claudeCodeAlias(provider, id), id, provider };
   }
@@ -72,7 +94,6 @@ function entryParts(entry: string, config: OcxConfig): { alias: string; id: stri
 }
 
 export function buildClaudeAgentDefs(config: OcxConfig, windows: Record<string, number>, configDir = claudeConfigDir()): ClaudeAgentDef[] {
-  const auto = resolveAutoContext(config.claudeCode);
   const blockedSkills = effectiveBlockedSkillNames(config.claudeCode);
   const blockedSkillsFor = (model: string): readonly string[] => {
     const unmarked = stripOneMillionMarker(model);
@@ -87,8 +108,10 @@ export function buildClaudeAgentDefs(config: OcxConfig, windows: Record<string,
   const coveredModels = new Set<string>();
 
   const push = (name: string, alias: string, description: string) => {
-    // Effective model value: [1m] marking follows the same predicate as env slots.
-    const model = withOneMillionMarker(alias, windows, auto) ?? alias;
+    // Generated defs mark [1m] on the authoritative window only — never the
+    // main-session auto-context predicate (a 372K route marked [1m] would be
+    // accounted at 1M with no compaction safety net in the subagent).
+    const model = withSubagentContextMarker(alias, windows);
     const bare = alias.toLowerCase();
     if (coveredModels.has(bare)) return;
     coveredModels.add(bare);
@@ -120,7 +143,7 @@ export function buildClaudeAgentDefs(config: OcxConfig, windows: Record<string,
   // the next launch sync — documented limit. No resolvable default -> no self def.
   const selfModel = pickerDefaultModel(configDir) ?? (config.claudeCode?.model?.trim() || null);
   if (selfModel) {
-    const marked = withOneMillionMarker(selfModel, windows, auto) ?? selfModel;
+    const marked = withSubagentContextMarker(selfModel, windows);
     defs.push({
       file: `${OWNED_PREFIX}self.md`,
       name: `${OWNED_PREFIX}self`,
@@ -213,7 +236,7 @@ export function syncClaudeAgentDefs(defs: readonly ClaudeAgentDef[], configDir =
       } catch { /* does not exist: ours to create */ }
       const tmp = `${target}.tmp-${process.pid}`;
       writeFileSync(tmp, renderAgentDef(def), { encoding: "utf8", mode: 0o644 });
-      renameSync(tmp, target);
+      renameAtomicFile(tmp, target, undefined, "claude-agents");
       written.push(def.file);
     }
     return written;

package/src/claude/context-windows.ts

@@ -10,12 +10,24 @@
  */
 import { aliasForNative, aliasForRoute } from "./alias";
 import { desktop3pAlias } from "./desktop-3p";
-import { nativeOpenAiContextWindow, type CatalogModel } from "../codex/catalog";
+import { nativeOpenAiContextWindow, type CatalogModel, type NativeContextLimitsInput } from "../codex/catalog";
 
 const ONE_MILLION = 1_000_000;
 
-/** Auto-context defaults (devlog 260712 020, user-approved). */
-export const AUTO_COMPACT_WINDOW_DEFAULT = 350_000;
+/**
+ * Auto-context defaults (devlog 260712 020, user-approved).
+ *
+ * The compact window is the token count at which Claude Code starts compacting, and it is
+ * also the floor `shouldMarkOneMillion` uses — a model may only carry the marker if it can
+ * host this window. 350,000 was chosen when the widest native row advertised 372,000.
+ *
+ * It now matches the auto-compaction limit the Codex catalog ships for the same models
+ * (`nativeAutoCompactLimit`: 829,800 against the 922,000 native window). Leaving the two
+ * apart meant one model compacting at 350k under Claude Code and at 829,800 under Codex.
+ * The value stays clear of the measured 922,000 ceiling by ~92k, so compaction still has
+ * room to run before the upstream refuses.
+ */
+export const AUTO_COMPACT_WINDOW_DEFAULT = 829_800;
 export const AUTO_CONTEXT_FLOOR = 200_000;
 /** Binary-verified accepted range for CLAUDE_CODE_AUTO_COMPACT_WINDOW (2.1.207: pSo=1e5, yDs=1e6). */
 export const AUTO_COMPACT_WINDOW_MIN = 100_000;
@@ -59,7 +71,7 @@ function inAutoCompactRange(value: number): boolean {
  * predicate so marker and threshold never separate (audit 021 #2); an invalid
  * value disables auto marking entirely (the CLI would ignore it, leaving marked
  * sub-1M models without their safety net). Out-of-range CONFIG values fall back
- * to the 350k default (the management API rejects them; this guards hand-edits).
+ * to AUTO_COMPACT_WINDOW_DEFAULT (the management API rejects them; this guards hand-edits).
  */
 export function resolveAutoContext(claudeCode: AutoContextConfigSlice | undefined, envOverride?: string): AutoContextMode {
   if (claudeCode?.autoContext === false) return AUTO_CONTEXT_OFF;
@@ -89,6 +101,10 @@ export function shouldMarkOneMillion(window: number | undefined, auto: AutoConte
 export function buildClaudeContextWindows(
   nativeSlugs: readonly string[],
   routedModels: readonly CatalogModel[],
+  // A configured providerContextCaps.openai has to reach the native rows here too. Without
+  // it the Claude surface keeps advertising the uncapped authoritative window while the
+  // Codex catalog advertises the capped one, and the two disagree about the same model.
+  nativeContextCap?: NativeContextLimitsInput,
 ): Record<string, number> {
   const out: Record<string, number> = {};
   const put = (key: string | null, value: number) => {
@@ -96,7 +112,7 @@ export function buildClaudeContextWindows(
     if (out[key] === undefined) out[key] = value; // first-wins (registry policy)
   };
   for (const slug of nativeSlugs) {
-    const window = nativeOpenAiContextWindow(slug);
+    const window = nativeOpenAiContextWindow(slug, nativeContextCap);
     if (typeof window !== "number" || window <= 0) continue;
     put(slug, window);
     put(desktop3pAlias("native", slug), window);