@bitkyc08/opencodex 2.49.0 → 2.51.0

package/src/remote/hub-state.ts

@@ -0,0 +1,182 @@
+/**
+ * The hub-state contract shared by `GET|HEAD /v1/hub-state` and every connected client.
+ *
+ * Why it exists (#4236): an agent working on a connected client machine read that machine's
+ * own `~/.opencodex/config.json` and `ocx status`, saw `xai ✗ not logged in`, no grok provider
+ * and five delegable models, and concluded the hub could not serve grok — while the hub had
+ * xAI logged in and was serving grok all along. A client's local credential store is empty BY
+ * DESIGN, so reporting it as the truth is not a cosmetic defect: it makes the client lie about
+ * the only machine that has the facts.
+ *
+ * What may cross this boundary is deliberately narrow. The client holds a per-client DATA key
+ * and no management credential, so this is a least-privilege data-plane read in the `/v1/catalog`
+ * (#809) tradition rather than a widened `/api/*` boundary. The payload is BOOLEANS and model
+ * ids: `hasCredential` is the same `!!p.apiKey` projection `GET /api/providers` already ships,
+ * and `loggedIn` is `oauthLoginSummary`'s boolean with the email and account id dropped
+ * entirely. No keys, no tokens, no quotas, no usage, no account identity — and nothing of that
+ * shape may be added later, because this surface is reachable with a data key.
+ *
+ * The delta over `/v1/catalog`, stated exactly, because "only two booleans" was wrong and a
+ * wrong boundary claim is worse than none. Provider names already leak through `/v1/catalog`
+ * slugs and `/v1/models` ids, but only for providers those routes list. What this route adds is:
+ * `hasCredential`, `loggedIn`, `authMode`, the featured roster — and the NAME and adapter of an
+ * ENABLED provider that the catalog omits for want of a usable credential. That last one is the
+ * point of the route (a client has to be able to say "the hub has xai configured and has no key
+ * for it" rather than "the hub cannot serve grok"), and it is the whole widening.
+ *
+ * A provider the operator marked `disabled` is NOT exported — see `src/server/hub-state.ts`.
+ * Naming it would tell a data-key holder about a provider no other data-plane route mentions,
+ * and a client has no use for it: it is not routable, so "absent" is the truthful report.
+ */
+
+export const HUB_STATE_SCHEMA_VERSION = 1;
+
+/** Hard caps, so the serialized body is bounded by construction rather than by hope. */
+export const MAX_HUB_STATE_PROVIDERS = 200;
+export const MAX_HUB_STATE_SUBAGENT_MODELS = 32;
+export const MAX_HUB_STATE_OAUTH_PROVIDERS = 200;
+export const MAX_HUB_STATE_STRING_CHARS = 200;
+/** Response/transfer ceiling. The caps above keep a realistic body two orders below this. */
+export const MAX_HUB_STATE_BYTES = 64 * 1024;
+
+/**
+ * Mirrors `OcxProviderConfig.authMode` (src/types/provider.ts); default `"key"`.
+ *
+ * It is shape, not secret: it says HOW a provider authenticates, which is what lets a client
+ * explain `hasCredential: false` on an `oauth` provider without claiming nothing is configured.
+ */
+export const HUB_STATE_AUTH_MODES = ["key", "forward", "oauth", "local"] as const;
+export type HubStateAuthMode = (typeof HUB_STATE_AUTH_MODES)[number] | null;
+
+export interface HubStateProvider {
+  name: string;
+  adapter: string;
+  authMode: HubStateAuthMode;
+  /** Presence only — the same `!!p.apiKey` projection `GET /api/providers` ships. */
+  hasCredential: boolean;
+  /**
+   * Always `false` from a hub of this version, which does not export a disabled provider at all.
+   * The field stays in the contract because an OLDER hub does send `true`, and a client reading
+   * one must still be able to label the row rather than present it as routable.
+   */
+  disabled: boolean;
+}
+
+export interface HubStateOAuthEntry {
+  provider: string;
+  /** `oauthLoginSummary().loggedIn`. The email and account id are dropped, not masked. */
+  loggedIn: boolean;
+}
+
+export interface HubStateDTO {
+  schemaVersion: typeof HUB_STATE_SCHEMA_VERSION;
+  /** Always "hub": the route 404s on any other role, so a client can trust what it reads. */
+  runtimeRole: "hub";
+  hubVersion: string;
+  /** `hub.dataPublicOrigin` when the operator set one; null rather than a guess. */
+  origin: string | null;
+  providers: HubStateProvider[];
+  oauth: HubStateOAuthEntry[];
+  /** The hub's effective featured subagent roster — what a client should delegate to. */
+  subagentModels: string[];
+  /**
+   * At least one row was dropped to fit a cap above, so the arrays are a prefix rather than the
+   * whole truth. Silent truncation is what this flag exists to prevent: a client that lists 200
+   * of 240 providers and says nothing has told the reader the other 40 do not exist, which is
+   * the same class of confident-and-wrong report #4236 is about.
+   */
+  truncated: boolean;
+  claudeCode: { enabled: boolean };
+}
+
+function boundedString(value: unknown, max = MAX_HUB_STATE_STRING_CHARS): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.length > max || /[\x00-\x1f\x7f]/.test(trimmed)) return null;
+  return trimmed;
+}
+
+/**
+ * Validate a hub-state body received over the wire.
+ *
+ * Returns null instead of throwing so both the live fetch and the on-disk cache can reject a
+ * malformed document the same way, and so a client NEVER degrades to its own local login state
+ * on a shape it does not recognize — degrading quietly is the defect being fixed.
+ *
+ * Unknown keys are dropped rather than refused: a newer hub must be readable by an older
+ * client, and the fields this projection reads are all required.
+ */
+export function parseHubStateBody(value: unknown): HubStateDTO | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const raw = value as Record<string, unknown>;
+  if (raw.schemaVersion !== HUB_STATE_SCHEMA_VERSION) return null;
+  if (raw.runtimeRole !== "hub") return null;
+  const hubVersion = boundedString(raw.hubVersion, 64);
+  if (!hubVersion) return null;
+  const origin = raw.origin === null || raw.origin === undefined ? null : boundedString(raw.origin, 512);
+  if (raw.origin !== null && raw.origin !== undefined && origin === null) return null;
+  if (!Array.isArray(raw.providers) || raw.providers.length > MAX_HUB_STATE_PROVIDERS) return null;
+  if (!Array.isArray(raw.oauth) || raw.oauth.length > MAX_HUB_STATE_OAUTH_PROVIDERS) return null;
+  if (!Array.isArray(raw.subagentModels) || raw.subagentModels.length > MAX_HUB_STATE_SUBAGENT_MODELS) return null;
+  const claudeCode = raw.claudeCode;
+  if (!claudeCode || typeof claudeCode !== "object" || Array.isArray(claudeCode)) return null;
+  const enabled = (claudeCode as Record<string, unknown>).enabled;
+  if (typeof enabled !== "boolean") return null;
+  // Absent means false: a hub that predates the flag truncated nothing this client can detect,
+  // and refusing its document would turn a new honesty field into a compatibility break. A
+  // present non-boolean is still refused, like every other field here.
+  if (raw.truncated !== undefined && typeof raw.truncated !== "boolean") return null;
+  const truncated = raw.truncated === true;
+
+  const providers: HubStateProvider[] = [];
+  for (const row of raw.providers) {
+    if (!row || typeof row !== "object" || Array.isArray(row)) return null;
+    const entry = row as Record<string, unknown>;
+    const name = boundedString(entry.name);
+    const adapter = boundedString(entry.adapter);
+    if (!name || !adapter) return null;
+    if (typeof entry.hasCredential !== "boolean" || typeof entry.disabled !== "boolean") return null;
+    const authMode = entry.authMode;
+    const normalizedAuthMode = typeof authMode === "string" && (HUB_STATE_AUTH_MODES as readonly string[]).includes(authMode)
+      ? authMode as NonNullable<HubStateAuthMode>
+      : null;
+    // An unrecognized authMode is refused rather than nulled: nulling it would let a newer hub's
+    // new mode read as "unset", which is a different claim about the provider.
+    if (authMode !== null && authMode !== undefined && normalizedAuthMode === null) return null;
+    providers.push({
+      name,
+      adapter,
+      authMode: normalizedAuthMode,
+      hasCredential: entry.hasCredential,
+      disabled: entry.disabled,
+    });
+  }
+
+  const oauth: HubStateOAuthEntry[] = [];
+  for (const row of raw.oauth) {
+    if (!row || typeof row !== "object" || Array.isArray(row)) return null;
+    const entry = row as Record<string, unknown>;
+    const provider = boundedString(entry.provider);
+    if (!provider || typeof entry.loggedIn !== "boolean") return null;
+    oauth.push({ provider, loggedIn: entry.loggedIn });
+  }
+
+  const subagentModels: string[] = [];
+  for (const row of raw.subagentModels) {
+    const model = boundedString(row);
+    if (!model) return null;
+    subagentModels.push(model);
+  }
+
+  return {
+    schemaVersion: HUB_STATE_SCHEMA_VERSION,
+    runtimeRole: "hub",
+    hubVersion,
+    origin,
+    providers,
+    oauth,
+    subagentModels,
+    truncated,
+    claudeCode: { enabled },
+  };
+}

package/src/server/auth-cors.ts

@@ -6,6 +6,7 @@ import {
   codexAutoStartEnabled,
   modelPreferHostedToolsConfigError,
   providerModelCostsConfigError,
+  providerWebSearchBridgeConfigError,
   requestPacingConfigError,
   retryOn429PolicyConfigError,
   sanitizeModelCostsForDisplay,
@@ -438,6 +439,11 @@ export const AUTH_MATRIX: readonly ApiAuthMatrixRow[] = [
   // /v1/models and for the same reason — it forwards no caller credential upstream — so a
   // remote client no longer needs an admin token just to read the model catalog.
   { endpoint: "/v1/catalog", bearer: "accepted", dedicated: "accepted", xApiKey: "accepted" },
+  // #4236: the hub-state read a connected client uses instead of reporting its own empty
+  // credential store. Same admission set and the same justification as the two rows above —
+  // it forwards no caller credential upstream and its body is booleans plus model ids — and it
+  // 404s on any host whose runtimeRole is not "hub", so no standalone install gains a surface.
+  { endpoint: "/v1/hub-state", bearer: "accepted", dedicated: "accepted", xApiKey: "accepted" },
 ];
 
 /** Whether `token` is the environment-provided management secret. */
@@ -650,6 +656,10 @@ export function providerManagementConfigError(name: unknown, provider: unknown):
   if (requestPacingError) {
     return `provider ${JSON.stringify(redactSecretString(name))} ${requestPacingError}`;
   }
+  const webSearchBridgeError = providerWebSearchBridgeConfigError(raw.webSearchBridge);
+  if (webSearchBridgeError) {
+    return `provider ${JSON.stringify(redactSecretString(name))} ${webSearchBridgeError}`;
+  }
   const upstreamHttpVersionError = upstreamHttpVersionConfigError(raw.upstreamHttpVersion);
   if (upstreamHttpVersionError) {
     return `provider ${JSON.stringify(redactSecretString(name))} ${upstreamHttpVersionError}`;
@@ -847,6 +857,7 @@ const PROVIDER_CONFIG_FIELD_POLICY = {
   xaiResponsesDefaultVersion: "runtime",
   supportsResponsesCustomTools: "editor",
   responsesSnapshotRepair: "editor",
+  webSearchBridge: "editor",
   reasoningEffortMap: "editor",
   modelReasoningEffortMap: "editor",
   reasoningWireFormat: "editor",

package/src/server/chat-completions.ts

@@ -26,9 +26,12 @@ import { NoEligiblePolicyCandidateError, UnknownRoutingPolicyError, routeModel }
 import { evidenceFromBody } from "../routing/request-evidence";
 import { resolveWireProtocolOverride } from "./adapter-resolve";
 import { resolveOpenCodeGoTransport } from "../providers/opencode-go-transport";
-import { normalizeLogConversationId, sessionLaneIdFromRequest } from "./request-log-conversation";
+import {
+  getOrAllocateRequestSessionLane,
+  linkRequestSessionLane,
+} from "./request-log-conversation";
 import type { OcxConfig } from "../types";
-import { readJsonRequestBody } from "./request-decompress";
+import { readJsonRequestBody, resolveInboundBodyLimitBytes } from "./request-decompress";
 import {
   addFinalRequestLog,
   httpStatusForRequestLogTerminal,
@@ -62,9 +65,9 @@ type Rec = Record<string, unknown>;
 function isRec(v: unknown): v is Rec {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
-async function readChatBody(req: Request, budget: TranslatorBudget): Promise<unknown> {
+async function readChatBody(req: Request, budget: TranslatorBudget, maxBytes: number): Promise<unknown> {
   try {
-    return await readJsonRequestBody(req, budget);
+    return await readJsonRequestBody(req, budget, maxBytes);
   } catch (err) {
     if (isTranslatorBudgetExceededError(err)) throw err;
     throw new ChatCompletionsRequestError(err instanceof Error && err.message ? err.message : "Invalid JSON body");
@@ -106,7 +109,7 @@ async function handleChatCompletionsWithBudget(
 ): Promise<Response> {
   let chatBody: Rec;
   try {
-    const rawBody = await readChatBody(req, translatorBudget);
+    const rawBody = await readChatBody(req, translatorBudget, resolveInboundBodyLimitBytes(config.maxInboundBodyBytes));
     assertChatCompletionsRoutingBody(rawBody);
     chatBody = rawBody;
   } catch (err) {
@@ -142,8 +145,7 @@ async function handleChatCompletionsWithBudget(
   let chatNativeRoute: ReturnType<typeof routeModel> | null = null;
   try {
     const route = routeModel(config, chatBody.model as string, evidenceFromBody(chatBody));
-    route.provider = resolveOpenCodeGoTransport(route.provider,
-      sessionLaneIdFromRequest(req.headers) ?? normalizeLogConversationId(req.headers.get("x-opencode-session")));
+    route.provider = resolveOpenCodeGoTransport(route.provider, getOrAllocateRequestSessionLane(req));
     // Settle the wire once so every branch below reads the adapter this model will
     // actually use, not the provider-wide default (#404).
     route.provider = resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, "chat");
@@ -305,6 +307,7 @@ async function handleChatCompletionsWithBudget(
     headers,
     body: internalBodyJson,
   });
+  linkRequestSessionLane(req, internalReq);
 
   let nativeLogged = false;
   const finalizeNativeLog = (status: number, meta: { terminalStatus?: RequestLogEntry["terminalStatus"]; closeReason: "terminal" | "client_cancel" | "non_stream" }) => {

package/src/server/chat-native.ts

@@ -40,6 +40,7 @@ import {
 } from "../providers/key-failover";
 import { fastPolicyForModel } from "../providers/service-tier";
 import { providerApiKeySelectionIsCurrent, resolveCurrentProviderApiKeyTransport } from "../providers/api-key-selection";
+import { enrichOpenCodeZenFreeTierMessage } from "../providers/opencode-zen-rate-limit";
 import type { OcxProviderTransport } from "../providers/xai-transport";
 import type { RouteResult } from "../router";
 import type { OcxConfig, OcxProviderConfig } from "../types";
@@ -438,12 +439,20 @@ export async function handleNativeChatCompletions(options: HandleNativeChatOptio
       && (isCyberPolicyCode(upstreamCode) || isCyberPolicyMessage(upstreamMessage))
       ? upstreamMessage
       : detail ? `Provider error ${response.status}: ${detail}` : `Provider error ${response.status}`;
+    // Zen's keyless free tier refuses the request outright rather than rate-limiting it, and
+    // the raw `MissingSessionID` tells a user nothing about why or what to do (#4121).
+    const clientMessage = enrichOpenCodeZenFreeTierMessage(message, {
+      providerName: route.providerName,
+      baseUrl: route.provider.baseUrl,
+      adapter: route.provider.adapter,
+      upstreamErrorType: upstreamType,
+    });
     const classified = classifyError(
       response.status,
       upstreamType ?? (response.status === 401 ? "authentication_error"
         : response.status === 429 ? "rate_limit_error"
           : response.status >= 500 ? "server_error" : "invalid_request_error"),
-      message,
+      clientMessage,
     );
     if (isCyberPolicyCode(upstreamCode) || classified.code === CYBER_POLICY_ERROR_CODE) {
       classified.code = CYBER_POLICY_ERROR_CODE;

package/src/server/claude-messages.ts

@@ -34,9 +34,14 @@ import { registryEntryForProviderDestination } from "../providers/registry";
 import { evidenceFromBody } from "../routing/request-evidence";
 import { resolveWireProtocolOverride } from "./adapter-resolve";
 import type { OcxConfig } from "../types";
-import { readJsonRequestBody } from "./request-decompress";
+import { readJsonRequestBody, resolveInboundBodyLimitBytes } from "./request-decompress";
 import { addFinalRequestLog, httpStatusForRequestLogTerminal, recordFirstOutput, type RequestLogContext, type RequestLogEntry } from "./request-log";
-import { conversationIdFromClaudeMetadata, normalizeLogConversationId, sessionLaneIdFromRequest } from "./request-log-conversation";
+import {
+  conversationIdFromClaudeMetadata,
+  linkRequestSessionLane,
+  normalizeLogConversationId,
+  sessionLaneIdFromRequest,
+} from "./request-log-conversation";
 import { responseWithDeferredRequestLog } from "./relay";
 import { handleResponses } from "./responses";
 import {
@@ -129,9 +134,9 @@ function claudeInboundDisabled(config: OcxConfig): Response | null {
   return null;
 }
 
-async function readAnthropicBody(req: Request, budget: TranslatorBudget): Promise<unknown> {
+async function readAnthropicBody(req: Request, budget: TranslatorBudget, maxBytes: number): Promise<unknown> {
   try {
-    return await readJsonRequestBody(req, budget);
+    return await readJsonRequestBody(req, budget, maxBytes);
   } catch (err) {
     if (isTranslatorBudgetExceededError(err)) throw err;
     throw new AnthropicRequestError(err instanceof Error && err.message ? err.message : "Invalid JSON body");
@@ -655,7 +660,7 @@ async function handleClaudeMessagesWithBudget(
   let fastRow: ParsedFastRowId | null = null;
   let requestedModel = "";
   try {
-    anthropicBody = await readAnthropicBody(req, translatorBudget);
+    anthropicBody = await readAnthropicBody(req, translatorBudget, resolveInboundBodyLimitBytes(config.maxInboundBodyBytes));
     // Defensive [1m] strip (devlog 138): clients normally remove the context-variant
     // marker themselves; the 1M signal we act on is the anthropic-beta header.
     // Case-insensitive — the CLI matches /\[1m\]/i (audit 021 #7).
@@ -897,6 +902,7 @@ async function handleClaudeMessagesWithBudget(
         headers,
         body: JSON.stringify(internalBody),
       });
+      linkRequestSessionLane(req, internalReq);
     } finally {
       reservation.release();
     }
@@ -1154,7 +1160,7 @@ export async function handleClaudeCountTokens(
   let body: unknown;
   const translatorBudget = createTranslatorBudget();
   try {
-    body = await readAnthropicBody(req, translatorBudget);
+    body = await readAnthropicBody(req, translatorBudget, resolveInboundBodyLimitBytes(config.maxInboundBodyBytes));
   } catch (err) {
     if (err instanceof DesktopModelMappingUnavailableError) return desktopMappingUnavailableResponse(err);
     if (err instanceof AnthropicRequestError) return anthropicErrorResponse(400, err.message);

package/src/server/hub-state.ts

@@ -0,0 +1,98 @@
+/**
+ * The hub's own projection for `GET|HEAD /v1/hub-state` (#4236).
+ *
+ * Pure: it takes the config and an already-computed login summary and returns the DTO. The
+ * route owns admission, the role gate and the size ceiling; this module owns what a client is
+ * allowed to learn. Keeping the projection here — and building each row field by field rather
+ * than spreading a provider or a login summary — is what makes "no keys, no emails, no account
+ * ids" checkable by reading one function. A spread would silently start exporting whatever the
+ * next field added to those records happens to be.
+ *
+ * Contract and caps live in `src/remote/hub-state.ts` so the client validates the same shape.
+ */
+import {
+  HUB_STATE_SCHEMA_VERSION,
+  MAX_HUB_STATE_OAUTH_PROVIDERS,
+  MAX_HUB_STATE_PROVIDERS,
+  MAX_HUB_STATE_SUBAGENT_MODELS,
+  HUB_STATE_AUTH_MODES,
+  type HubStateDTO,
+  type HubStateOAuthEntry,
+  type HubStateProvider,
+} from "../remote/hub-state";
+import { DEFAULT_SUBAGENT_MODELS } from "../config/subagent-models";
+import type { OcxConfig } from "../types";
+
+export type HubStateConfigView = Pick<OcxConfig, "providers" | "subagentModels" | "claudeCode" | "hub">;
+
+/** A login summary row as `oauthLoginSummary()` returns it; extra fields are never read. */
+export interface HubStateLoginRow {
+  provider: string;
+  loggedIn: boolean;
+}
+
+/**
+ * The hub's effective featured roster: the same "unset means the defaults, an explicit `[]`
+ * means none" rule `buildClaudeAgentDefs` applies, so a client that delegates from this list
+ * sees exactly what the hub itself would offer.
+ */
+export function hubSubagentRoster(config: Pick<OcxConfig, "subagentModels">): string[] {
+  return uncappedSubagentRoster(config).slice(0, MAX_HUB_STATE_SUBAGENT_MODELS);
+}
+
+/** The same roster before the cap, so `truncated` can be computed instead of guessed. */
+function uncappedSubagentRoster(config: Pick<OcxConfig, "subagentModels">): string[] {
+  const roster = config.subagentModels === undefined ? DEFAULT_SUBAGENT_MODELS : config.subagentModels;
+  return roster
+    .filter((entry): entry is string => typeof entry === "string" && entry.trim() !== "")
+    .map(entry => entry.trim());
+}
+
+export function buildHubState(
+  config: HubStateConfigView,
+  logins: readonly HubStateLoginRow[],
+  hubVersion: string,
+): HubStateDTO {
+  // A disabled provider is dropped, not exported with a flag. `/v1/catalog` and `/v1/models`
+  // both filter it out (`src/router.ts`, `src/codex/catalog/*`), so exporting it here was the
+  // one thing this route told a data-key holder that no other data-plane route does — and a
+  // client has no use for it either: it cannot be routed to, so absence IS the truthful report,
+  // and `authMode` already explains a present-but-credential-less row without it.
+  const enabledProviders = Object.entries(config.providers ?? {}).filter(([, provider]) => provider.disabled !== true);
+  const providers: HubStateProvider[] = enabledProviders
+    .slice(0, MAX_HUB_STATE_PROVIDERS)
+    .map(([name, provider]) => ({
+      name,
+      adapter: provider.adapter,
+      authMode: provider.authMode !== undefined && HUB_STATE_AUTH_MODES.includes(provider.authMode)
+        ? provider.authMode
+        : null,
+      // Presence only. Identical to the projection GET /api/providers already ships.
+      hasCredential: Boolean(provider.apiKey),
+      // Always false here. The field stays in the contract for an older hub's documents; see
+      // `HubStateProvider` in src/remote/hub-state.ts.
+      disabled: false,
+    }));
+  // Field-by-field, never a spread: oauthLoginSummary also carries the operator's email.
+  const oauth: HubStateOAuthEntry[] = logins
+    .slice(0, MAX_HUB_STATE_OAUTH_PROVIDERS)
+    .map(entry => ({ provider: entry.provider, loggedIn: entry.loggedIn === true }));
+  const rosterBeforeCap = uncappedSubagentRoster(config).length;
+  // Said out loud rather than silently: the caps are a prefix, and a client presenting a prefix
+  // as the whole list is the same confident-and-wrong report this route exists to prevent.
+  const truncated = enabledProviders.length > MAX_HUB_STATE_PROVIDERS
+    || logins.length > MAX_HUB_STATE_OAUTH_PROVIDERS
+    || rosterBeforeCap > MAX_HUB_STATE_SUBAGENT_MODELS;
+  return {
+    schemaVersion: HUB_STATE_SCHEMA_VERSION,
+    runtimeRole: "hub",
+    hubVersion,
+    origin: config.hub?.dataPublicOrigin ?? null,
+    providers,
+    oauth,
+    subagentModels: hubSubagentRoster(config),
+    truncated,
+    // Same predicate the launch path uses: absence means enabled.
+    claudeCode: { enabled: config.claudeCode?.enabled !== false },
+  };
+}

package/src/server/images.ts

@@ -29,7 +29,7 @@ import { sidecarEnter } from "../lib/sidecar-tracker";
 import type { OcxConfig } from "../types";
 import { resolveFirstUsableOpenAiSidecar, selectImagesProvider } from "../providers/openai-sidecar";
 import { getProviderRegistryEntry } from "../providers/registry";
-import { readJsonRequestBody } from "./request-decompress";
+import { readJsonRequestBody, resolveInboundBodyLimitBytes } from "./request-decompress";
 import { ForwardAdmissionCredentialError, validateForwardAdmissionCredential } from "./auth-cors";
 import type { RequestLogContext } from "./request-log";
 import { codexLogAccountId, decodeRequestErrorResponse } from "./responses";
@@ -602,7 +602,7 @@ export async function handleImages(
 ): Promise<Response> {
   let body: unknown;
   try {
-    body = await readJsonRequestBody(req);
+    body = await readJsonRequestBody(req, undefined, resolveInboundBodyLimitBytes(config.maxInboundBodyBytes));
   } catch (err) {
     return decodeRequestErrorResponse(err, "images");
   }