@bitkyc08/opencodex 2.48.0 → 2.50.0

package/src/providers/opencode-zen-rate-limit.ts

@@ -7,6 +7,11 @@
  * bodies and may omit `Retry-After` / `X-RateLimit-*`; when those headers are
  * present they still take precedence. Distinct from the keyless desktop
  * ~200 requests / 5h quota documented on `opencode-free`.
+ *
+ * The same module also owns the keyless free-tier admission explanation (#4121):
+ * Zen rejects a request that carries no `x-opencode-session` header with
+ * `MissingSessionID` / "OpenCode's free tier can only be used in OpenCode".
+ * opencodex does not synthesize that header — see {@link enrichOpenCodeZenFreeTierMessage}.
  */
 import { validateClientRetryAfterHeader } from "../lib/retry-after";
 import { registryEntryForProviderDestination } from "./registry";
@@ -100,3 +105,73 @@ export function enrichOpenCodeZenRateLimitMessage(
     + paceHint
   );
 }
+
+/**
+ * Zen's keyless free tier admits only OpenCode's own client. A request without an
+ * `x-opencode-session` header is refused with error type `MissingSessionID` and the
+ * message "OpenCode's free tier can only be used in OpenCode" (#4121).
+ *
+ * Presence of the header is the whole gate — any value clears it — so opencodex could
+ * pass by minting one. It does not. Fabricating a session identifier and a versioned
+ * `opencode/<version>` User-Agent is a claim to *be* the OpenCode client, and no upstream
+ * contract authorizes a third-party agent to make it; an HTTP 200 obtained that way is a
+ * bypassed admission check, not permission. Until OpenCode publishes a third-party
+ * integration path for this exact keyless tier, the supported route is the keyed
+ * `opencode-zen` provider.
+ *
+ * Two markers are matched because the two request surfaces expose different parts of the
+ * upstream envelope: the Responses path forwards the bounded raw body (which carries the
+ * `MissingSessionID` type), while the native Chat path forwards only the parsed message.
+ */
+const OPENCODE_ZEN_FREE_TIER_LOCK_IN = /MissingSessionID|free tier can only be used in OpenCode/i;
+
+/** Idempotence marker — the appended guidance must not stack across enrichment layers. */
+const FREE_TIER_ENRICHMENT_MARKER = "does not send a fabricated OpenCode session header";
+
+/** True when an upstream error body is Zen's keyless free-tier admission refusal. */
+export function isOpenCodeZenFreeTierLockIn(message: string, upstreamErrorType?: string | null): boolean {
+  if (upstreamErrorType && OPENCODE_ZEN_FREE_TIER_LOCK_IN.test(upstreamErrorType)) return true;
+  return OPENCODE_ZEN_FREE_TIER_LOCK_IN.test(message);
+}
+
+/**
+ * Replace a raw `MissingSessionID` passthrough with an explanation of the upstream
+ * restriction and the supported alternative. No-op for every other provider and every
+ * other error, and idempotent so layered enrichment cannot append it twice.
+ */
+export function enrichOpenCodeZenFreeTierMessage(
+  message: string,
+  opts: {
+    providerName?: string;
+    baseUrl?: string;
+    adapter?: string;
+    /** Upstream `error.type`, when the caller parsed one out of the envelope. */
+    upstreamErrorType?: string | null;
+  },
+): string {
+  if (message.includes(FREE_TIER_ENRICHMENT_MARKER)) return message;
+  if (!isOpenCodeZenFreeTierLockIn(message, opts.upstreamErrorType)) return message;
+  if (!isOpenCodeZenRateLimitProvider(opts)) return message;
+  return (
+    `${message}`
+    + " OpenCode Zen's keyless free tier admits only OpenCode's own client: it refuses any"
+    + " request that arrives without an x-opencode-session header."
+    + ` opencodex ${FREE_TIER_ENRICHMENT_MARKER}, because presenting itself as the OpenCode`
+    + " client is a claim no upstream contract supports."
+    + " Use the keyed opencode-zen provider with an OpenCode Zen API key"
+    + " (https://opencode.ai/auth), or route this model through another provider."
+    + " Upstream terms: https://opencode.ai/docs/zen/."
+  );
+}
+
+/**
+ * Single entry point for Zen upstream-error guidance on the Responses wire: short-window
+ * rate limits first, then the keyless free-tier admission refusal. Each layer is a no-op
+ * outside its own case, so the composition is safe for every other upstream failure.
+ */
+export function enrichOpenCodeZenUpstreamMessage(
+  message: string,
+  opts: Parameters<typeof enrichOpenCodeZenRateLimitMessage>[1] & { upstreamErrorType?: string | null },
+): string {
+  return enrichOpenCodeZenFreeTierMessage(enrichOpenCodeZenRateLimitMessage(message, opts), opts);
+}

package/src/providers/qoder-models.ts

@@ -0,0 +1,25 @@
+/**
+ * Cold-start fallback from the official Qoder Global model documentation, verified 2026-09-03.
+ * The account-specific `qoder --list-models` result is authoritative whenever discovery succeeds.
+ */
+export const QODER_GLOBAL_MODELS = [
+  "Qwen3.8-Max",
+  "Qwen3.7-Max",
+  "Qwen3.7-Plus",
+  "Kimi-K3",
+  "Kimi-K2.7-Code",
+  "GLM-5.3",
+  "GLM-5.2",
+  "DeepSeek-V4-Pro",
+] as const;
+
+/** Live Qoder CN roster captured from the official CLI on 2026-09-03. */
+export const QODER_CN_MODELS = [
+  "Qwen3.8-Max",
+  "Qwen3.8-Flash",
+  "Qwen3.7-Max",
+  "Qwen3.7-Plus",
+  "Qwen3.7-Flash",
+] as const;
+
+export const QODER_REASONING_EFFORTS = ["low", "medium", "high", "xhigh", "max"] as const;

package/src/providers/quota.ts

@@ -1398,6 +1398,21 @@ function parseClaudeLimit(value: unknown): { label: string; percent: number; res
 /** Claude's OAuth usage endpoint, probed with ONE account's own bearer token. */
 const anthropicUsageInflight = new Map<string, Promise<ProviderQuota | null>>();
 
+/**
+ * Anthropic per-credential usage.
+ *
+ * This endpoint reports quota only. Its body carries `five_hour`, `seven_day`, the
+ * model-scoped weekly buckets (`seven_day_fable`/`_opus`/`_sonnet`) and a `limits` array,
+ * and **no subscription or tier field** — nor does the OAuth token response, which yields only
+ * `account.uuid` and `account.email_address` (`src/oauth/anthropic.ts`). That is why
+ * `OAuthAccountSummary.plan` is `null` for Anthropic rather than populated here (#3777); it is
+ * a missing upstream field, not an unfinished mapping.
+ *
+ * A tier must not be inferred from what is here. Percentages are normalized per account, so a
+ * Max x5 seat at 50% is byte-identical to a Max x20 seat at 50%, and the presence of a
+ * model-scoped window tracks entitlement rather than seat size. Populate `plan` only when
+ * upstream returns the tier itself.
+ */
 async function fetchAnthropicUsageQuota(accessToken: string): Promise<ProviderQuota | null> {
   const joinable = anthropicUsageInflight.get(accessToken);
   if (joinable) return joinable;

package/src/providers/registry.ts

@@ -21,6 +21,21 @@ import {
 import { cursorFastCapableBases } from "../adapters/cursor/catalog";
 import { COMMAND_CODE_MODEL_REASONING_EFFORTS } from "./command-code-efforts";
 import { isCanonicalOpenRouterTarget } from "./openrouter-routing";
+import {
+  CODEBUDDY_CN_MODELS,
+  CODEBUDDY_CN_MODEL_CONTEXT_WINDOWS,
+  CODEBUDDY_CN_MODEL_DEFAULT_REASONING_EFFORTS,
+  CODEBUDDY_CN_MODEL_MAX_OUTPUT_TOKENS,
+  CODEBUDDY_CN_MODEL_REASONING_EFFORTS,
+  CODEBUDDY_CN_NO_VISION_MODELS,
+  CODEBUDDY_GLOBAL_MODELS,
+  CODEBUDDY_GLOBAL_MODEL_CONTEXT_WINDOWS,
+  CODEBUDDY_GLOBAL_MODEL_DEFAULT_REASONING_EFFORTS,
+  CODEBUDDY_GLOBAL_MODEL_MAX_OUTPUT_TOKENS,
+  CODEBUDDY_GLOBAL_MODEL_REASONING_EFFORTS,
+  CODEBUDDY_REASONING_EFFORTS,
+} from "./codebuddy-models";
+import { QODER_CN_MODELS, QODER_GLOBAL_MODELS, QODER_REASONING_EFFORTS } from "./qoder-models";
 
 export type ProviderAuthKind = "forward" | "oauth" | "key" | "local";
 export type MetadataModelIdNormalize = "case-insensitive";
@@ -160,6 +175,13 @@ export interface ProviderRegistryEntry {
   staticHeaders?: Record<string, string>;
   modelSuffixBracketStrip?: boolean;
   featured?: boolean;
+  /**
+   * Paid provider sponsorship under SPONSORS.md. `main` is reserved for model developers,
+   * `standard` for relays and gateways. The picker pins sponsor rows first (alphabetical among
+   * themselves) and labels them; nothing else reads this field. Routing, failover, quota, and
+   * defaults never consult it — that boundary is what SPONSORS.md promises users.
+   */
+  sponsor?: { tier: "main" | "standard"; url: string };
   dashboardPreset?: boolean;
   note?: string;
   dashboardUrl?: string;
@@ -1903,6 +1925,9 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     authKind: "key", dashboardUrl: "https://www.orcarouter.ai/console",
     // The catalog is public, so a successful /models probe cannot validate a submitted key.
     apiKeyValidation: "unknown",
+    // Standard sponsor under SPONSORS.md (agreement signed 2026-09-07). Pins the row in the
+    // picker and adds the chip; nothing about routing or defaults changes.
+    sponsor: { tier: "standard", url: "https://www.orcarouter.ai/?utm_source=opencodex&utm_medium=readme" },
     defaultModel: "openai/gpt-5.5",
     models: ORCAROUTER_MODELS,
     liveModels: true,
@@ -1915,6 +1940,25 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     preserveReasoningContentModels: ORCAROUTER_TEXT_ONLY_MODELS,
     note: "OpenAI-compatible adaptive router. Models and multimodal capabilities are discovered live from the public chat catalog. Use the OrcaRouter account entry for PKCE login.",
   },
+  {
+    // PackyCode: API relay (packyapi.com) for Claude Code, Codex, Gemini and more. Codex traffic
+    // uses the OpenAI-compatible host from their Codex/Kimi Code guides (docs.packyapi.com):
+    // https://cf.api.fan/v1 — GET /v1/models answers 401 without a key, so the host is live and
+    // discovery narrows to what the key's token group allows. Model ids are bare OpenAI-style
+    // ids (the Codex token group lists gpt-5.5 / gpt-5.1-codex).
+    // Standard sponsor under SPONSORS.md; the dashboardUrl carries their affiliate code.
+    id: "packycode", label: "PackyCode", adapter: "openai-chat", baseUrl: "https://cf.api.fan/v1",
+    authKind: "key", dashboardUrl: "https://www.packyapi.com/register?aff=k5KT",
+    sponsor: { tier: "standard", url: "https://www.packyapi.com/register?aff=k5KT" },
+    defaultModel: "gpt-5.5",
+    models: ["gpt-5.5", "gpt-5.1-codex"],
+    liveModels: true,
+    // New key preset: opt into collision preservation so a row named `packycode` that a user
+    // points at a different PackyCode host keeps its own destination instead of being pulled
+    // back onto the Codex endpoint below.
+    preserveCustomDestination: true,
+    note: "API relay for Claude Code, Codex, Gemini and more. Create a Codex-group token at packyapi.com; live discovery lists what the token group allows.",
+  },
   {
     // BizRouter: Korean enterprise LLM gateway (api.bizrouter.ai). Model ids are
     // vendor-namespaced (`<vendor>/<model>`) and pass through to the upstream as-is.
@@ -2974,7 +3018,7 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     keyOptional: true,
     featured: true,
     liveModels: true,
-    note: "No key needed — public desktop tier. OpenCode currently advertises about 200 Big Pickle/free-model requests per 5 hours. The same Zen gateway can also short-window rate-limit free models at roughly 15-20 requests/minute, and may return generic 429s without Retry-After (opencodex synthesizes backoff only when that header is omitted). Free models are discovered live from Zen. Data use: per OpenCode's Zen docs (https://opencode.ai/docs/zen/), prompts sent to free models may be retained and used for training/improvement — do not send confidential material through this provider.",
+    note: "No key needed, but OpenCode now gates this tier to its own client: Zen refuses any request that arrives without an x-opencode-session header (error type MissingSessionID, \"OpenCode's free tier can only be used in OpenCode\"). opencodex does not mint that header or claim an OpenCode client identity, because no upstream contract authorizes a third-party agent to present itself as OpenCode. Until OpenCode publishes a third-party integration path for the keyless tier, use the keyed opencode-zen provider instead (https://opencode.ai/auth). Quota figures for when the tier admitted a request: OpenCode advertises about 200 Big Pickle/free-model requests per 5 hours, and the same Zen gateway can short-window rate-limit free models at roughly 15-20 requests/minute, and may return generic 429s without Retry-After (opencodex synthesizes backoff only when that header is omitted). Free models are discovered live from Zen. Data use: per OpenCode's Zen docs (https://opencode.ai/docs/zen/), prompts sent to free models may be retained and used for training/improvement — do not send confidential material through this provider.",
     dashboardUrl: "https://opencode.ai",
     staticHeaders: {
       // Zen answers a bare runtime User-Agent (Bun/x.y.z) more aggressively than a client
@@ -3140,6 +3184,101 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
   },
   // FREEZE 2026-07-10: no public OpenAI-compatible endpoint is documented. Evidence: devlog/_plan/260710_provider_hardening/003_research_aggregators.md.
   { id: "gitlab-duo", label: "GitLab Duo", baseUrl: "https://cloud.gitlab.com/ai/v1/proxy/openai/v1", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://gitlab.com/-/user_settings/personal_access_tokens" },
+  {
+    // Official Qoder Global CLI automation surface. The canonical URL is an identity boundary;
+    // inference and model discovery are performed only by the installed vendor CLI. Authentication
+    // uses the documented PAT environment variable and never imports desktop/session credentials.
+    id: "qoder",
+    label: "Qoder (Global)",
+    adapter: "qoder",
+    baseUrl: "https://qoder.com",
+    authKind: "key",
+    apiKeyValidation: "unknown",
+    preserveCustomDestination: true,
+    dashboardUrl: "https://qoder.com/account/integrations",
+    defaultModel: "Qwen3.8-Max",
+    models: [...QODER_GLOBAL_MODELS],
+    liveModels: true,
+    reasoningEfforts: [...QODER_REASONING_EFFORTS],
+    noVisionModels: [...QODER_GLOBAL_MODELS],
+    note: "Official Qoder Global CLI using QODER_PERSONAL_ACCESS_TOKEN. Models are discovered per account with `qoder --list-models`; the documented roster is a degraded fallback. The CLI runs single-turn with tools, MCP, settings hooks, and session persistence disabled. Requires `npm install -g @qoder-ai/qodercli`.",
+  },
+  {
+    // Qoder CN is a separate credential, executable, destination, entitlement cache, and health
+    // domain. It deliberately does not reuse the OAuth/private-protocol design from #3010.
+    id: "qoder-cn",
+    label: "Qoder CN",
+    adapter: "qoder",
+    baseUrl: "https://qoder.cn",
+    authKind: "key",
+    apiKeyValidation: "unknown",
+    preserveCustomDestination: true,
+    dashboardUrl: "https://qoder.cn/account/integrations",
+    defaultModel: "Qwen3.8-Max",
+    models: [...QODER_CN_MODELS],
+    liveModels: true,
+    reasoningEfforts: [...QODER_REASONING_EFFORTS],
+    noVisionModels: [...QODER_CN_MODELS],
+    note: "Official Qoder CN CLI using QODERCN_PERSONAL_ACCESS_TOKEN. Models are discovered per account with `qodercn --list-models`; the verified roster is a degraded fallback. The CLI runs single-turn with tools, MCP, settings hooks, and session persistence disabled. Requires `npm install -g @qodercn-ai/qoderclicn`.",
+  },
+  {
+    // Official CodeBuddy Code CLI provider (Tencent Cloud), GLOBAL / `public` environment.
+    // Transport is the vendor-documented headless CLI automation surface
+    // (`codebuddy -p --output-format stream-json --tools ""`) authenticated with the official
+    // `CODEBUDDY_API_KEY` (https://www.codebuddy.ai/profile/keys). It does NOT read desktop
+    // session files, import desktop bearer tokens, impersonate the desktop client, or call the
+    // private console endpoint — the approach closed in #687 and left in draft in #2244.
+    // baseUrl is the canonical region identity: the adapter fails closed if it is overridden, so a
+    // global key is never sent to the CN environment (that is the separate `codebuddy-cn` entry).
+    // v1 runs tools-disabled so Codex keeps tool ownership; this provider is text/reasoning only
+    // until the control-protocol tool bridge lands (see docs). Free/trial/promotional/subscription
+    // credits draw from the same official API-key pool. Requires the CLI: `npm i -g @tencent-ai/codebuddy-code`.
+    // GOVERNANCE: whether routing this vendor automation surface behind a proxy for a third-party
+    // agent satisfies CodeBuddy's AUP is an open question flagged for maintainer security review.
+    id: "codebuddy",
+    label: "CodeBuddy (Global)",
+    adapter: "codebuddy",
+    baseUrl: "https://www.codebuddy.ai",
+    authKind: "key",
+    apiKeyValidation: "unknown",
+    preserveCustomDestination: true,
+    dashboardUrl: "https://www.codebuddy.ai/profile/keys",
+    defaultModel: "default-model",
+    models: CODEBUDDY_GLOBAL_MODELS,
+    liveModels: false,
+    modelContextWindows: CODEBUDDY_GLOBAL_MODEL_CONTEXT_WINDOWS,
+    modelMaxOutputTokens: CODEBUDDY_GLOBAL_MODEL_MAX_OUTPUT_TOKENS,
+    defaultMaxOutputTokens: 32_000,
+    reasoningEfforts: CODEBUDDY_REASONING_EFFORTS,
+    modelReasoningEfforts: CODEBUDDY_GLOBAL_MODEL_REASONING_EFFORTS,
+    modelDefaultReasoningEfforts: CODEBUDDY_GLOBAL_MODEL_DEFAULT_REASONING_EFFORTS,
+    note: "Official CodeBuddy Code CLI (Tencent Cloud), global/public environment. Uses the documented CODEBUDDY_API_KEY + headless CLI surface; never reads desktop sessions or private console endpoints. Region-isolated from codebuddy-cn. v1 disables CLI tools (--tools \"\") so Codex retains tool ownership: text/reasoning only for now. Requires `npm i -g @tencent-ai/codebuddy-code`. AUP/routing authorization flagged for maintainer security review.",
+  },
+  {
+    // Official CodeBuddy Code CLI provider, CHINA / `internal` environment. Identical adapter and
+    // binary as `codebuddy`; the region is fixed by the profile's CODEBUDDY_INTERNET_ENVIRONMENT
+    // and this canonical baseUrl. CN key: https://copilot.tencent.com/profile/keys. The CN model
+    // roster differs from Global (see codebuddy-models.ts) and is seeded separately (§八).
+    id: "codebuddy-cn",
+    label: "CodeBuddy (CN)",
+    adapter: "codebuddy",
+    baseUrl: "https://www.codebuddy.cn",
+    authKind: "key",
+    apiKeyValidation: "unknown",
+    preserveCustomDestination: true,
+    dashboardUrl: "https://copilot.tencent.com/profile/keys",
+    defaultModel: "default",
+    models: CODEBUDDY_CN_MODELS,
+    liveModels: false,
+    modelContextWindows: CODEBUDDY_CN_MODEL_CONTEXT_WINDOWS,
+    modelMaxOutputTokens: CODEBUDDY_CN_MODEL_MAX_OUTPUT_TOKENS,
+    defaultMaxOutputTokens: 32_000,
+    reasoningEfforts: CODEBUDDY_REASONING_EFFORTS,
+    modelReasoningEfforts: CODEBUDDY_CN_MODEL_REASONING_EFFORTS,
+    modelDefaultReasoningEfforts: CODEBUDDY_CN_MODEL_DEFAULT_REASONING_EFFORTS,
+    noVisionModels: CODEBUDDY_CN_NO_VISION_MODELS,
+    note: "Official CodeBuddy Code CLI (Tencent Cloud), China/internal environment. Uses the documented CODEBUDDY_API_KEY + headless CLI surface; never reads desktop sessions or private console endpoints. Region-isolated from codebuddy (Global); credentials are never exchanged across regions. v1 disables CLI tools (--tools \"\"): text/reasoning only for now. Requires `npm i -g @tencent-ai/codebuddy-code`. AUP/routing authorization flagged for maintainer security review.",
+  },
 ];
 
 export function providerRegistryFastWireError(

package/src/responses/compaction.ts

@@ -17,6 +17,10 @@
 
 export const OCX_COMPACTION_PREFIX = "ocx1:";
 
+export const OCX_NATIVE_REPLAY_RECOVERY_NOTE =
+  "Threads compacted through a routed provider can contain OpenCodeX-owned ocx1 state. "
+  + "Before resuming one through native Codex, run `ocx recover-history --ocx-compaction <thread-id> --yes`.";
+
 /** Mirrors codex-rs core/templates/compact/prompt.md (the local-compaction instruction). */
 export const COMPACT_PROMPT = `You are performing a CONTEXT CHECKPOINT COMPACTION. Create a handoff summary for another LLM that will resume the task.
 

package/src/responses/task-input.ts

@@ -20,9 +20,29 @@ function supportedBlock(value: unknown): value is TaskInputBlock {
   return value.detail === undefined || (typeof value.detail === "string" && imageDetails.has(value.detail));
 }
 
+/**
+ * Does this item carry a pairing key? A tool result is paired by `call_id`; a seed is not.
+ *
+ * Presence of the FIELD is not presence of a KEY (#3807). Codex desktop seeds a sub-agent
+ * thread with a lone `function_call_output` that some client builds emit with an explicit
+ * `call_id: null` or `""` rather than omitting it. Those values can never pair with a
+ * `function_call`, so treating them as a paired result sent the item to the guard in
+ * core.ts and answered 400 for a turn that is really external task input.
+ *
+ * A wrong-typed key (number, object) is NOT relaxed: that is malformed input rather than
+ * the absent-pairing seed shape, and it keeps the #3259 rejection.
+ */
+function hasPairingKey(item: Record<string, unknown>): boolean {
+  if (!("call_id" in item)) return false;
+  const callId = item.call_id;
+  if (callId === null) return false;
+  if (typeof callId === "string") return callId.trim().length > 0;
+  return true;
+}
+
 /** Recognize Codex external task input without repairing ordinary orphaned tool results. */
 export function externalTaskInputContent(item: unknown): string | OcxContentPart[] | undefined {
-  if (!isObj(item) || item.type !== "function_call_output" || "call_id" in item) return undefined;
+  if (!isObj(item) || item.type !== "function_call_output" || hasPairingKey(item)) return undefined;
   if (!nonBlank(item.id) || !nonBlank(item.name) || !nonBlank(item.namespace)) return undefined;
   const output = item.output;
   if (typeof output === "string") return nonBlank(output) ? output : undefined;

package/src/router.ts

@@ -10,7 +10,7 @@ import {
 import type { NormalizedComboConfig } from "./combos/types";
 import { hasOwnProvider } from "./config/provider-name";
 import { providerUsesKeyAuthOverride, resolveProviderApiKey } from "./providers/key-store";
-import { captureProviderApiKeySelection } from "./providers/api-key-selection";
+import { captureProviderApiKeySelection } from "./providers/api-key-selection-capture";
 import { assertProviderDestinationAllowed } from "./lib/destination-policy";
 import { redactSecretString, redactUrlForLog } from "./lib/redact";
 import {

package/src/server/auth-cors.ts

@@ -6,6 +6,7 @@ import {
   codexAutoStartEnabled,
   modelPreferHostedToolsConfigError,
   providerModelCostsConfigError,
+  providerWebSearchBridgeConfigError,
   requestPacingConfigError,
   retryOn429PolicyConfigError,
   sanitizeModelCostsForDisplay,
@@ -650,6 +651,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 +852,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

@@ -28,7 +28,7 @@ import { resolveWireProtocolOverride } from "./adapter-resolve";
 import { resolveOpenCodeGoTransport } from "../providers/opencode-go-transport";
 import { normalizeLogConversationId, sessionLaneIdFromRequest } from "./request-log-conversation";
 import type { OcxConfig } from "../types";
-import { readJsonRequestBody } from "./request-decompress";
+import { readJsonRequestBody, resolveInboundBodyLimitBytes } from "./request-decompress";
 import {
   addFinalRequestLog,
   httpStatusForRequestLogTerminal,
@@ -38,6 +38,9 @@ import {
 } from "./request-log";
 import { responseWithDeferredRequestLog } from "./relay";
 import { handleResponses } from "./responses";
+import { providerConsumesCallerAuthorization } from "../providers/caller-authorization";
+import { captureExplicitOpenAiCallerAuth } from "../providers/openai-sidecar";
+import { captureCallerDirectAuth } from "../providers/caller-authorization";
 import type { AdmissionLease } from "../lib/admission";
 import type { DataPlaneAdmission } from "./auth-cors";
 import { tryClaimNativeMainProfileForTurn } from "../codex/native-main-admission";
@@ -59,9 +62,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");
@@ -103,7 +106,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) {
@@ -133,7 +136,8 @@ async function handleChatCompletionsWithBudget(
   // it registers (extra_headers, sent verbatim by upstream Grok). Dashboard usage
   // bucketing only — never an auth or billing signal.
   if (req.headers.get("x-opencodex-grok") === "1") logCtx.surface = "grok";
-  let directRoute = false;
+  let callerAuthorizationRoute = false;
+  let routeMayChangeCredentialDomain = false;
   let settledRoute: ReturnType<typeof routeModel> | null = null;
   let chatNativeRoute: ReturnType<typeof routeModel> | null = null;
   try {
@@ -150,9 +154,9 @@ async function handleChatCompletionsWithBudget(
     logCtx.provider = route.providerName;
     logCtx.routeDecision = route.routeDecision;
     settledRoute = route;
-    if (route.provider.adapter === "openai-responses") {
-      directRoute = route.codexAccountMode === "direct";
-    }
+    routeMayChangeCredentialDomain = route.combo !== undefined || route.routeKind === "policy";
+    callerAuthorizationRoute = !routeMayChangeCredentialDomain
+      && providerConsumesCallerAuthorization(route.provider);
     if (route.provider.adapter === "cursor" || route.provider.adapter === "kiro") {
       const parts: string[] = [];
       if (chatBody.messages !== undefined) parts.push(JSON.stringify(chatBody.messages));
@@ -240,17 +244,23 @@ async function handleChatCompletionsWithBudget(
     && isCodexReserveHelperUnsupported(config, settledRoute.modelId, logIds?.admission, visionDescribeTerminal)) {
     return chatCompletionsErrorResponse(400, CODEX_RESERVE_HELPER_UNSUPPORTED_MESSAGE, "invalid_request_error");
   }
+  const nativeCallerAuth = captureExplicitOpenAiCallerAuth(req.headers, config);
+  // Caller-owned only: stored-main enrichment below is sidecar authority, never Direct authority.
+  const callerDirectAuth = captureCallerDirectAuth(req.headers, config);
+  let openAiSidecarAuth = nativeCallerAuth;
   const headers = new Headers({ "content-type": "application/json" });
   // Internal bridge metadata; the Go resolver scopes and hashes it before upstream use.
   const openCodeSession = req.headers.get("x-opencode-session");
   if (openCodeSession) headers.set("x-opencode-session", openCodeSession);
   for (const name of FORWARD_HEADERS) {
-    if (name === "authorization" && !directRoute) continue;
+    if (routeMayChangeCredentialDomain && (name === "authorization" || name === "chatgpt-account-id")) continue;
+    if (name === "authorization" && !callerAuthorizationRoute) continue;
     const value = req.headers.get(name);
     if (value) headers.set(name, value);
   }
-  // Prefer main ChatGPT auth so OpenAI-backed sidecars remain reachable on routed turns.
-  if (!directRoute) {
+  // A noncanonical caller-auth route can use stored main auth only through a sidecar snapshot.
+  // Later shadow/thread rewrites strip primary credentials at the actual Responses boundary.
+  if (!callerAuthorizationRoute || (settledRoute && !isCanonicalOpenAiForwardProvider(settledRoute.provider))) {
     // This enrichment is optional for routed/non-main providers. If native main
     // is fenced, omit it and let auth-context reject only a final physical-main
     // selection while healthy pool/provider routes continue.
@@ -259,8 +269,12 @@ async function handleChatCompletionsWithBudget(
         const { getMainAccountToken } = await import("../codex/main-account");
         const token = getMainAccountToken();
         if (token) {
-          headers.set("authorization", `Bearer ${token.accessToken}`);
-          headers.set("chatgpt-account-id", token.chatgptAccountId);
+          const mainHeaders = new Headers({ authorization: `Bearer ${token.accessToken}`, "chatgpt-account-id": token.chatgptAccountId });
+          openAiSidecarAuth ??= captureExplicitOpenAiCallerAuth(mainHeaders, config);
+          if (!callerAuthorizationRoute && !routeMayChangeCredentialDomain) {
+            headers.set("authorization", `Bearer ${token.accessToken}`);
+            headers.set("chatgpt-account-id", token.chatgptAccountId);
+          }
         }
       } catch {
         /* optional */
@@ -299,6 +313,9 @@ async function handleChatCompletionsWithBudget(
     addFinalRequestLog(logIds.requestId, logIds.start, logCtx, status, meta);
   };
   const upstream = await handleResponses(internalReq, config, logCtx, {
+    openAiSidecarAuth,
+    nativeCallerAuth,
+    callerDirectAuth,
     ...(logIds?.turnAdmissionLease ? { turnAdmissionLease: logIds.turnAdmissionLease } : {}),
     // #1686: the Chat surface translates its body and replays here, so the admission fact has
     // to ride along or a bearer-admitted Chat caller would still be refused by Direct.

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,7 +34,7 @@ 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 { responseWithDeferredRequestLog } from "./relay";
@@ -129,9 +129,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");
@@ -603,7 +603,7 @@ export async function fetchWithHeaderDeadline(
 ): Promise<HeaderDeadlineFetchResult> {
   const deadline = makeDeadline(timeoutMs, parent);
   try {
-    const upstream = await fetchImpl(input, { ...init, signal: deadline.signal, timeout: 0 });
+    const upstream = await fetchImpl(input, { ...init, redirect: "manual", signal: deadline.signal, timeout: 0 });
     return { kind: "response", upstream };
   } catch (error) {
     if (deadline.didExpire()) return { kind: "timeout" };
@@ -655,7 +655,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).
@@ -837,6 +837,7 @@ async function handleClaudeMessagesWithBudget(
   }
 
   const headers = new Headers({ "content-type": "application/json" });
+  let trustedClaudeMainAuth: { authorization: string; chatgptAccountId?: string } | undefined;
   for (const name of FORWARD_HEADERS) {
     // The caller's bearer is the proxy admission token (ocx claude placeholder), never a
     // ChatGPT credential — forwarding it upstream turns into {"detail":"Unauthorized"}.
@@ -852,8 +853,13 @@ async function handleClaudeMessagesWithBudget(
     const { getMainAccountToken } = await import("../codex/main-account");
     const token = getMainAccountToken();
     if (token) {
-      headers.set("authorization", `Bearer ${token.accessToken}`);
+      const authorization = `Bearer ${token.accessToken}`;
+      headers.set("authorization", authorization);
       headers.set("chatgpt-account-id", token.chatgptAccountId);
+      trustedClaudeMainAuth = {
+        authorization,
+        ...(token.chatgptAccountId ? { chatgptAccountId: token.chatgptAccountId } : {}),
+      };
     }
   }
   if (opencodeGoRoute) {
@@ -923,6 +929,10 @@ async function handleClaudeMessagesWithBudget(
     // would fire, disagreeing with the pre-flight decision above.
     inboundWire: "anthropic",
     stripClaudeMainAuthForNoncanonicalForward: true,
+    ...(trustedClaudeMainAuth ? { trustedClaudeMainAuth } : {}),
+    // Claude's internal stored-main enrichment is not an original caller credential.
+    nativeCallerAuth: null,
+    callerDirectAuth: null,
     translatorBudget,
     ...(logIds ? { onFirstOutput: () => recordFirstOutput(logCtx, logIds.start) } : {}),
     onNativePassthroughTerminal: status => finalizeNativeLog(httpStatusForRequestLogTerminal(status, logCtx), { terminalStatus: status, closeReason: "terminal" }),
@@ -1144,7 +1154,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);