@bitkyc08/opencodex 2.7.4 → 2.7.7

package/src/lib/bounded-body.ts

@@ -0,0 +1,202 @@
+/** Maximum number of response-body bytes that may be retained for an error. */
+export const BOUNDED_BODY_MAX_BYTES = 65_536;
+
+/** Default wall-clock and continuous-silence deadlines. */
+export const BOUNDED_BODY_TIMEOUT_MS = 5_000;
+
+export interface BoundedBodyOptions {
+	/** Abort the read with this signal. Its reason is rethrown by identity. */
+	signal?: AbortSignal;
+	/** Total wall-clock deadline. Exposed for focused tests. */
+	totalTimeoutMs?: number;
+	/** Deadline between non-empty raw chunks. Exposed for focused tests. */
+	inactivityTimeoutMs?: number;
+}
+
+export interface BoundedBodyResult {
+	/** UTF-8 text retained from the response. Empty when the size limit was exceeded. */
+	text: string;
+	/** True when EOF was not observed. */
+	truncated: boolean;
+	/** True for either total-deadline or inactivity-deadline expiry. */
+	timedOut: boolean;
+	/** Distinguishes the wall-clock deadline from an inactivity deadline. */
+	totalTimedOut: boolean;
+	/** True only when continuous inactivity caused the timeout. */
+	inactivityTimedOut: boolean;
+	/** True when the body was observed to exceed the byte cap. */
+	oversized: boolean;
+	/** False means callers should use a status-only fallback, not `text`. */
+	displaySafe: boolean;
+}
+
+const TOTAL_TIMEOUT = Symbol("bounded body total timeout");
+const INACTIVITY_TIMEOUT = Symbol("bounded body inactivity timeout");
+
+function timeoutPromise(ms: number, value: symbol): { promise: Promise<symbol>; clear: () => void } {
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	const promise = new Promise<symbol>((resolve) => {
+		timer = setTimeout(() => resolve(value), Math.max(0, ms));
+	});
+	return {
+		promise,
+		clear: () => {
+			if (timer !== undefined) clearTimeout(timer);
+		},
+	};
+}
+
+function cancelWithoutWaiting(reader: ReadableStreamDefaultReader<Uint8Array>, reason?: unknown): void {
+	// A hostile/broken stream may reject or never settle cancel(). Neither should
+	// escape as an unhandled rejection or extend this primitive's own deadline.
+	try {
+		void reader.cancel(reason).catch(() => undefined);
+	} catch {
+		// Some stream implementations throw synchronously from cancel().
+	}
+}
+
+function decodeUtf8(chunks: readonly Uint8Array[]): string {
+	const decoder = new TextDecoder();
+	let text = "";
+	for (const chunk of chunks) text += decoder.decode(chunk, { stream: true });
+	// Flush an incomplete trailing UTF-8 sequence deterministically.
+	text += decoder.decode();
+	return text;
+}
+
+/**
+ * Consume the original response body under strict memory and time bounds.
+ *
+ * This deliberately calls `getReader()` on `response.body`: it never clones or
+ * tees the response. Once an over-limit byte is observed, all retained raw data
+ * is discarded so an untrusted prefix can never become a client-facing error.
+ */
+export async function readBoundedResponseBody(
+	response: Response,
+	options: BoundedBodyOptions = {},
+): Promise<BoundedBodyResult> {
+	const signal = options.signal;
+	if (signal?.aborted) throw signal.reason;
+
+	const body = response.body;
+	if (!body) {
+		return {
+			text: "",
+			truncated: false,
+			timedOut: false,
+			totalTimedOut: false,
+			inactivityTimedOut: false,
+			oversized: false,
+			displaySafe: true,
+		};
+	}
+
+	const reader = body.getReader();
+	const chunks: Uint8Array[] = [];
+	let retainedBytes = 0;
+	let mustCancel = false;
+	let cancelReason: unknown;
+	const total = timeoutPromise(options.totalTimeoutMs ?? BOUNDED_BODY_TIMEOUT_MS, TOTAL_TIMEOUT);
+	let inactivity = timeoutPromise(
+		options.inactivityTimeoutMs ?? BOUNDED_BODY_TIMEOUT_MS,
+		INACTIVITY_TIMEOUT,
+	);
+
+	let rejectForAbort: ((reason: unknown) => void) | undefined;
+	const aborted = new Promise<never>((_resolve, reject) => {
+		rejectForAbort = reject;
+	});
+	const onAbort = () => rejectForAbort?.(signal?.reason);
+	signal?.addEventListener("abort", onAbort, { once: true });
+	// Close the narrow race between the preflight check and listener install.
+	if (signal?.aborted) onAbort();
+
+	try {
+		while (true) {
+			// Attach a rejection handler before racing. If a deadline wins and
+			// cancellation later rejects this read, it remains observed.
+			const read = reader.read();
+			void read.catch(() => undefined);
+			const outcome = await Promise.race([read, total.promise, inactivity.promise, aborted]);
+			// Cancellation owns the body lifetime even when EOF/readability settles in
+			// the same turn. Promise.race otherwise lets array order hide the abort.
+			if (signal?.aborted) {
+				mustCancel = true;
+				cancelReason = signal.reason;
+				throw signal.reason;
+			}
+
+			if (outcome === TOTAL_TIMEOUT || outcome === INACTIVITY_TIMEOUT) {
+				mustCancel = true;
+				cancelReason = new DOMException(
+					outcome === TOTAL_TIMEOUT ? "Error body total timeout" : "Error body inactivity timeout",
+					"TimeoutError",
+				);
+				return {
+					text: decodeUtf8(chunks),
+					truncated: true,
+					timedOut: true,
+					totalTimedOut: outcome === TOTAL_TIMEOUT,
+					inactivityTimedOut: outcome === INACTIVITY_TIMEOUT,
+					oversized: false,
+					displaySafe: false,
+				};
+			}
+
+			const { value, done } = outcome as ReadableStreamReadResult<Uint8Array>;
+			if (done) {
+				return {
+					text: decodeUtf8(chunks),
+					truncated: false,
+					timedOut: false,
+					totalTimedOut: false,
+					inactivityTimedOut: false,
+					oversized: false,
+					displaySafe: true,
+				};
+			}
+
+			if (!value || value.byteLength === 0) continue;
+
+			inactivity.clear();
+			inactivity = timeoutPromise(
+				options.inactivityTimeoutMs ?? BOUNDED_BODY_TIMEOUT_MS,
+				INACTIVITY_TIMEOUT,
+			);
+
+			if (value.byteLength > BOUNDED_BODY_MAX_BYTES - retainedBytes) {
+				mustCancel = true;
+				cancelReason = new DOMException("Error body size limit reached", "QuotaExceededError");
+				chunks.length = 0;
+				retainedBytes = 0;
+				return {
+					text: "",
+					truncated: true,
+					timedOut: false,
+					totalTimedOut: false,
+					inactivityTimedOut: false,
+					oversized: true,
+					displaySafe: false,
+				};
+			}
+
+			chunks.push(value);
+			retainedBytes += value.byteLength;
+		}
+	} catch (error) {
+		mustCancel = true;
+		cancelReason = error;
+		throw error;
+	} finally {
+		total.clear();
+		inactivity.clear();
+		signal?.removeEventListener("abort", onAbort);
+		if (mustCancel) cancelWithoutWaiting(reader, cancelReason);
+		try {
+			reader.releaseLock();
+		} catch {
+			// A pending read can keep the lock briefly while cancel settles.
+		}
+	}
+}

package/src/providers/registry.ts

@@ -348,11 +348,13 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
       "kimi-k2.7-code-highspeed": [],
       ...Object.fromEntries(OPENCODE_GO_THINKING_TOGGLE_MODELS.map(id => [id, THINKING_TOGGLE_EFFORTS])),
       ...Object.fromEntries(OPENCODE_GO_THINKING_BUDGET_MODELS.map(id => [id, THINKING_BUDGET_EFFORTS])),
+      ...Object.fromEntries(DEEPSEEK_THINKING_MODELS.map(id => [id, DEEPSEEK_THINKING_EFFORTS])),
     },
     // glm-5.2 uses identity labels now that `max` is a native Codex level (no alias map);
     // the thinking-toggle map is a REAL wire alias (effort -> enabled/disabled) and stays.
     modelReasoningEffortMap: {
       ...Object.fromEntries(OPENCODE_GO_THINKING_TOGGLE_MODELS.map(id => [id, THINKING_TOGGLE_MAP])),
+      ...Object.fromEntries(DEEPSEEK_THINKING_MODELS.map(id => [id, DEEPSEEK_THINKING_REASONING_MAP])),
     },
     thinkingToggleModels: OPENCODE_GO_THINKING_TOGGLE_MODELS,
     thinkingBudgetModels: THINKING_BUDGET_MODELS,
@@ -371,7 +373,8 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     noTopPModels: ["kimi-k2.7-code", "kimi-k2.7-code-highspeed"],
     noPenaltyModels: ["kimi-k2.7-code", "kimi-k2.7-code-highspeed"],
     autoToolChoiceOnlyModels: ["kimi-k2.7-code", "kimi-k2.7-code-highspeed"],
-    preserveReasoningContentModels: ["glm-5.2", "kimi-k2.7-code", "kimi-k2.7-code-highspeed"],
+    // Issue #78: DeepSeek V4 thinking mode requires reasoning_content replay on tool-call turns.
+    preserveReasoningContentModels: ["glm-5.2", "kimi-k2.7-code", "kimi-k2.7-code-highspeed", ...DEEPSEEK_THINKING_MODELS],
   },
   {
     id: "neuralwatt",
@@ -456,6 +459,10 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     modelReasoningEfforts: Object.fromEntries(DEEPSEEK_THINKING_MODELS.map(id => [id, DEEPSEEK_THINKING_EFFORTS])),
     modelReasoningEffortMap: Object.fromEntries(DEEPSEEK_THINKING_MODELS.map(id => [id, DEEPSEEK_THINKING_REASONING_MAP])),
     preserveReasoningContentModels: DEEPSEEK_THINKING_MODELS,
+    // Issue #88: every DeepSeek API model is text-only input (no image support upstream) — the
+    // vision sidecar describes attached images for them, and the catalog advertises image input
+    // on their behalf (same treatment as opencode-go's DeepSeek V4 entries above).
+    noVisionModels: ["deepseek-chat", "deepseek-reasoner", ...DEEPSEEK_THINKING_MODELS],
   },
   // llama-3.3-70b was deprecated by Cerebras on 2026-02-16. Evidence: devlog/_plan/260710_provider_hardening/003_research_aggregators.md.
   { id: "cerebras", label: "Cerebras", baseUrl: "https://api.cerebras.ai/v1", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://cloud.cerebras.ai/platform/apikeys", defaultModel: "gpt-oss-120b" },

package/src/reasoning-effort.ts

@@ -19,6 +19,11 @@ export function isCodexReasoningEffort(effort: string): boolean {
   return CODEX_REASONING_SET.has(effort);
 }
 
+/** Position of `effort` in the Codex ladder (low=0 .. ultra=5), or -1 when not a ladder member. */
+export function codexEffortRank(effort: string): number {
+  return CODEX_REASONING_ORDER.indexOf(effort);
+}
+
 export function modelRecordValue<T>(record: Record<string, T> | undefined, modelId: string): T | undefined {
   if (!record) return undefined;
   if (Object.prototype.hasOwnProperty.call(record, modelId)) return record[modelId];

package/src/server/auth-cors.ts

@@ -117,31 +117,34 @@ export function assertServerAuthConfig(config: OcxConfig): void {
   }
 }
 
-export function hasValidApiAuth(req: Request, config: OcxConfig): boolean {
-  if (!isApiAuthRequired(config)) return true;
-  const actual = req.headers.get("x-opencodex-api-key")?.trim()
-    || req.headers.get("authorization")?.replace(/^Bearer\s+/i, "").trim();
+/** Whether `token` is one of the proxy's own admission secrets (env token or config API keys). */
+export function isProxyAdmissionSecret(token: string, config: OcxConfig): boolean {
+  const actual = token.trim();
   if (!actual) return false;
+  const enc = new TextEncoder();
+  const actualBytes = enc.encode(actual);
   // Check env-based token
   const expected = configuredApiAuthToken(config);
   if (expected) {
-    const enc = new TextEncoder();
     const expectedBytes = enc.encode(expected);
-    const actualBytes = enc.encode(actual);
     if (expectedBytes.length === actualBytes.length && timingSafeEqual(actualBytes, expectedBytes)) return true;
   }
   // Check config-based API keys
-  if (config.apiKeys?.length) {
-    const enc = new TextEncoder();
-    const actualBytes = enc.encode(actual);
-    for (const k of config.apiKeys) {
-      const keyBytes = enc.encode(k.key);
-      if (keyBytes.length === actualBytes.length && timingSafeEqual(actualBytes, keyBytes)) return true;
-    }
+  for (const k of config.apiKeys ?? []) {
+    const keyBytes = enc.encode(k.key);
+    if (keyBytes.length === actualBytes.length && timingSafeEqual(actualBytes, keyBytes)) return true;
   }
   return false;
 }
 
+export function hasValidApiAuth(req: Request, config: OcxConfig): boolean {
+  if (!isApiAuthRequired(config)) return true;
+  const actual = req.headers.get("x-opencodex-api-key")?.trim()
+    || req.headers.get("authorization")?.replace(/^Bearer\s+/i, "").trim();
+  if (!actual) return false;
+  return isProxyAdmissionSecret(actual, config);
+}
+
 export function requireApiAuth(req: Request, config: OcxConfig, kind: "management" | "data-plane"): Response | null {
   if (hasValidApiAuth(req, config)) return null;
   if (kind === "management") return jsonResponse({ error: "opencodex API key required" }, 401);

package/src/server/effort-policy.ts

@@ -0,0 +1,172 @@
+/**
+ * Hard reasoning-effort caps (devlog/260710_subagent_effort_intercept).
+ *
+ * Prompt-side effort designation (injectionEffort) is advisory only: codex-rs inherits the
+ * parent's effective effort when spawn_agent carries no model/effort args
+ * (multi_agents_common.rs resolve defaults), rejects overrides on full-history forks, and a
+ * non-empty agent-role file rebuilds the child Config and silently drops spawn-time
+ * model/effort. So a session whose config default is ultra leaks max-tier children whenever
+ * the parent model spawns bare. This module is the enforcement path: it rewrites the effort
+ * of proxied turns at the single choke point every HTTP/WS turn passes through
+ * (handleResponses), using the same dual-shape rewrite contract as nativeEffortClamp —
+ * parsed.options.reasoning feeds routed adapters, _rawBody.reasoning.effort feeds the
+ * ChatGPT passthrough serializer.
+ */
+import type { OcxConfig, OcxParsedRequest, OcxProviderConfig } from "../types";
+import { modelInList } from "../types";
+import { codexEffortRank, configuredReasoningEfforts, isCodexReasoningEffort, modelRecordValue } from "../reasoning-effort";
+import { catalogModelEfforts } from "../codex/catalog";
+
+/**
+ * True when the request carries codex-rs's spawned-child markers, matched EXACTLY.
+ * Source of truth (openai/codex @ 6138909d): every collab-spawned child turn sends
+ * `x-openai-subagent: collab_spawn` (core/src/responses_metadata.rs) and embeds
+ * `"subagent_kind":"thread_spawn"` in the JSON `x-codex-turn-metadata` compatibility
+ * header. Both are checked: the WS bridge rebuilds internal requests from the
+ * FORWARD_HEADERS allowlist, so either header alone is sufficient evidence.
+ *
+ * Exact matching matters: upstream emits `x-openai-subagent` for OTHER internal
+ * turn categories too (review, compact, memory_consolidation, arbitrary "other"
+ * sources — responses_metadata.rs subagent_source). Those are maintenance turns,
+ * not spawned children, and must never trip subagentEffortCap.
+ */
+export function isThreadSpawnRequest(headers: Headers): boolean {
+  if (headers.get("x-openai-subagent") === "collab_spawn") return true;
+  const turnMeta = headers.get("x-codex-turn-metadata");
+  if (!turnMeta) return false;
+  try {
+    const parsed = JSON.parse(turnMeta) as { subagent_kind?: unknown };
+    return parsed.subagent_kind === "thread_spawn";
+  } catch {
+    return false;
+  }
+}
+
+/** The effective ceiling for this turn, or undefined when no configured cap applies. */
+export function effortCapFor(config: OcxConfig, subagent: boolean): string | undefined {
+  const caps: string[] = [];
+  if (config.effortCap && isCodexReasoningEffort(config.effortCap)) caps.push(config.effortCap);
+  if (subagent && config.subagentEffortCap && isCodexReasoningEffort(config.subagentEffortCap)) {
+    caps.push(config.subagentEffortCap);
+  }
+  if (caps.length === 0) return undefined;
+  return caps.reduce((low, cap) => (codexEffortRank(cap) < codexEffortRank(low) ? cap : low));
+}
+
+/**
+ * Whether the effort caps apply to this turn at all. Caps are a V2-surface feature
+ * (v1 sub-agents are pinned via explicit spawn args + injectionEffort prompting, so
+ * the ultra-default leak this module intercepts is v2-specific):
+ *  - compaction turns are maintenance, not agent turns: they bypass caps entirely so
+ *    native /v1/responses/compact (forwarded, never enters handleResponses) and routed
+ *    compaction (synthesized internal request) get identical cap semantics.
+ *  - multiAgentMode "v1" disables caps entirely (mirrors the GUI hiding the panel).
+ *  - a main turn qualifies when its own tool list carries the v2 collab surface.
+ *  - a CHILD turn is admitted by its spawned-child markers (isThreadSpawnRequest)
+ *    REGARDLESS of tool surface: depth-limited leaves carry no collab tools (surface
+ *    null) while children below the spawn-depth limit retain collab tools (spec_plan.rs
+ *    leaf guard), so tool sniffing alone would cap siblings inconsistently.
+ *  - a v1-surface MAIN turn (no child markers) never qualifies.
+ */
+export function effortCapAppliesTo(
+  surface: "v1" | "v2" | null,
+  headers: Headers,
+  config: OcxConfig,
+  compaction = false,
+): boolean {
+  if (compaction) return false;
+  if (config.multiAgentMode === "v1") return false;
+  return surface === "v2" || isThreadSpawnRequest(headers);
+}
+
+/**
+ * The routed model's supported effort ladder for cap resolution, from the ROUTE's
+ * registry-merged provider (router.ts routedProviderConfig) — the persisted
+ * config.providers entry misses registry seeds, and bare ids can route via
+ * defaultModel/model-list/default-provider, so no "/" heuristic anywhere.
+ *
+ * - `[]`   -> the model intentionally exposes no effort control (noReasoningModels or
+ *             an explicitly empty configured ladder): cap resolution strips.
+ * - list   -> sanitized + healed ladder (configuredReasoningEfforts).
+ * - undefined -> unknown. Includes the raw-nonempty-but-non-rankable case (e.g. a
+ *             thinking-toggle ladder of ["enabled"]): sanitizing would flatten it to []
+ *             and mis-classify it as "no effort control", so it stays unknown.
+ *
+ * Catalog fallback fires only for the ChatGPT-backend native passthrough IDENTITY
+ * (adapter "openai-responses" + authMode "forward", the fresh-install `openai`
+ * provider shape): the injected catalog is authoritative exactly for models Codex
+ * validates against that backend. A custom responses provider (key mode) serving a
+ * native-looking bare id must NOT inherit the unrelated native ladder.
+ */
+export function supportedLadderFor(route: { provider: OcxProviderConfig; modelId: string }): string[] | undefined {
+  const { provider, modelId } = route;
+  if (modelInList(provider.noReasoningModels, modelId)) return [];
+  const raw = modelRecordValue(provider.modelReasoningEfforts, modelId) ?? provider.reasoningEfforts;
+  if (raw !== undefined) {
+    const sanitized = configuredReasoningEfforts(provider, modelId) ?? [];
+    if (sanitized.length === 0 && raw.length > 0) return undefined;
+    return sanitized;
+  }
+  if (provider.adapter === "openai-responses" && provider.authMode === "forward") {
+    const efforts = catalogModelEfforts([modelId]).get(modelId);
+    if (efforts && efforts.length > 0) return efforts;
+  }
+  return undefined;
+}
+
+/**
+ * Resolve the configured cap against the model's supported ladder. Returns the effective
+ * ceiling rung, or null when the turn must be STRIPPED of its effort entirely. The cap
+ * NEVER raises: when rankable rungs exist but none sits at or below the cap, the model
+ * cannot run within the ceiling, so the effort is stripped and the provider default
+ * applies (never a rung above the cap).
+ */
+export function resolveCappedEffort(cap: string, supported: readonly string[] | undefined): string | null {
+  if (supported === undefined) return cap;
+  const rankable = supported.filter(isCodexReasoningEffort);
+  if (rankable.length === 0) {
+    // Nonempty but non-rankable (e.g. ["enabled"]) -> unknown ladder, cap as-is.
+    // Genuinely empty -> no effort control at all -> strip.
+    return supported.length > 0 ? cap : null;
+  }
+  const capRank = codexEffortRank(cap);
+  let best: string | null = null;
+  for (const rung of rankable) {
+    const rank = codexEffortRank(rung);
+    if (rank <= capRank && (best === null || rank > codexEffortRank(best))) best = rung;
+  }
+  return best;
+}
+
+/**
+ * Cap the turn's reasoning effort in BOTH request shapes. Non-strip resolution only
+ * lowers: efforts at or below the resolved ceiling (and non-ladder/absent efforts) pass
+ * untouched. Strip resolution (model exposes no effort control, or no supported rung
+ * fits under the cap) removes whatever effort is present — regardless of its rank —
+ * from both shapes while preserving `reasoning.summary`. Returns the applied rewrite
+ * for request-log annotation (`to: "none"` on strip), or null when nothing changed.
+ */
+export function applyEffortCap(
+  parsed: OcxParsedRequest,
+  headers: Headers,
+  config: OcxConfig,
+  supported?: readonly string[] | undefined,
+): { from: string; to: string; subagent: boolean } | null {
+  const subagent = isThreadSpawnRequest(headers);
+  const cap = effortCapFor(config, subagent);
+  if (!cap) return null;
+  const resolved = resolveCappedEffort(cap, supported);
+  const requested = parsed.options.reasoning;
+  const raw = parsed._rawBody as { reasoning?: { effort?: string } } | undefined;
+  if (resolved === null) {
+    if (!requested) return null;
+    parsed.options.reasoning = undefined;
+    if (raw?.reasoning && typeof raw.reasoning === "object") delete raw.reasoning.effort;
+    return { from: requested, to: "none", subagent };
+  }
+  if (!requested || !isCodexReasoningEffort(requested)) return null;
+  if (codexEffortRank(requested) <= codexEffortRank(resolved)) return null;
+  parsed.options.reasoning = resolved;
+  if (raw?.reasoning && typeof raw.reasoning === "object") raw.reasoning.effort = resolved;
+  return { from: requested, to: resolved, subagent };
+}