@bitkyc08/opencodex 2.7.33 → 2.7.34

package/src/providers/registry.ts

@@ -53,6 +53,8 @@ export interface ProviderRegistryEntry {
   contextWindow?: number;
   modelContextWindows?: Record<string, number>;
   modelInputModalities?: Record<string, string[]>;
+  defaultMaxOutputTokens?: number;
+  modelMaxOutputTokens?: Record<string, number>;
   reasoningEfforts?: string[];
   modelReasoningEfforts?: Record<string, string[]>;
   modelDefaultReasoningEfforts?: Record<string, string>;
@@ -87,7 +89,7 @@ export type ProviderConfigSeed = Pick<
   OcxProviderConfig,
   "adapter" | "baseUrl" | "authMode" | "keyOptional" | "freeTier" | "modelSuffixBracketStrip" | "defaultModel" | "models"
   | "liveModels" | "contextWindow" | "modelContextWindows" | "modelInputModalities"
-  | "modelMaxInputTokens"
+  | "modelMaxInputTokens" | "defaultMaxOutputTokens" | "modelMaxOutputTokens"
   | "reasoningEfforts" | "modelReasoningEfforts" | "modelDefaultReasoningEfforts" | "reasoningEffortMap" | "modelReasoningEffortMap"
   | "noVisionModels" | "noReasoningModels" | "noTemperatureModels" | "noTopPModels" | "noPenaltyModels"
   | "autoToolChoiceOnlyModels" | "preserveReasoningContentModels" | "thinkingToggleModels" | "thinkingBudgetModels" | "escapeBuiltinToolNames"
@@ -219,6 +221,13 @@ const ALIBABA_INTL_TOKEN_PLAN_MODELS = [
 const ALIBABA_INTL_TOKEN_PLAN_QWEN_MODELS = [
   "qwen3.8-max-preview", "qwen3.7-max", "qwen3.7-plus", "qwen3.6-plus", "qwen3.6-flash",
 ];
+
+// 260722 Tencent Cloud Coding Plan. The plan's model set is explicitly dynamic; these are the
+// current documented ids and live discovery remains enabled so successful /models responses win.
+// Tencent marks every Coding Plan model as text-only input and restricts plan keys to interactive
+// coding tools (not custom application backends or non-interactive batch automation).
+// Evidence: https://cloud.tencent.cn/document/product/1823/130092
+const TENCENT_CODING_PLAN_MODELS = ["tc-code-latest", "glm-5", "kimi-k2.5", "minimax-m2.5"];
 const ALIBABA_INTL_TOKEN_PLAN_INPUT_MODALITIES: Record<string, string[]> = {
   "qwen3.8-max-preview": ["text", "image"],
   "qwen3.7-max": ["text", "image"],
@@ -343,7 +352,7 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     authKind: "oauth",
     featured: false,
     dashboardPreset: true,
-    note: "Experimental Cursor bridge. Live transport and live model discovery are enabled after a standalone PKCE browser login via 'ocx login cursor'; native read/write/delete/shell/fetch execution defaults to codex-sandbox mode (auto-enabled when the request declares Codex danger-full-access sandbox); override with \"nativeLocalExec\": \"on\" (always), \"off\" (never), or \"codex-sandbox\" (only for requests declaring the Codex danger-full-access sandbox; the declaration is caller-controlled prose the proxy cannot verify, and the auth-free loopback bind admits any process on this host, including other local users — enable only where every data-plane client is trusted) — legacy \"unsafeAllowNativeLocalExec\": true still means \"on\" — on providers.cursor in ~/.opencodex/config.json (dashboard: Providers → Cursor → Edit JSON) for a trusted local experiment.",
+    note: "Experimental Cursor bridge. Live transport and live model discovery are enabled after a standalone PKCE browser login via 'ocx login cursor'; native read/write/delete/shell/fetch execution is disabled by default and request text such as Codex sandbox markers never authorizes it. Set \"nativeLocalExec\": \"on\" on providers.cursor in ~/.opencodex/config.json (dashboard: Providers → Cursor → Edit JSON) only for a trusted local experiment where every data-plane caller is trusted. \"off\" denies all, \"codex-sandbox\" is accepted for backwards compatibility but fails closed, and legacy \"unsafeAllowNativeLocalExec\": true still means explicit operator opt-in.",
     models: cursorModelIds(CURSOR_STATIC_MODELS),
     liveModels: true,
     defaultModel: "auto",
@@ -743,6 +752,20 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
   },
   { id: "nanogpt", label: "NanoGPT", baseUrl: "https://nano-gpt.com/api/v1", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://nano-gpt.com/api" },
   { id: "synthetic", label: "Synthetic", baseUrl: "https://api.synthetic.new/openai/v1", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://synthetic.new" },
+  // SiliconFlow publishes an OpenAI-compatible chat endpoint and a dynamic model catalog. Do not
+  // freeze reasoning controls here: enable_thinking/thinking_budget support and limits vary by
+  // model, so live metadata or an explicit user override must own those capabilities.
+  // Evidence: https://docs.siliconflow.cn/en/api-reference/chat-completions/chat-completions
+  {
+    id: "siliconflow",
+    label: "SiliconFlow",
+    baseUrl: "https://api.siliconflow.cn/v1",
+    adapter: "openai-chat",
+    authKind: "key",
+    dashboardUrl: "https://cloud.siliconflow.cn/account/ak",
+    liveModels: true,
+    note: "OpenAI-compatible live model catalog; reasoning controls vary by model.",
+  },
   // Qwen Cloud: token plan is the preset default; GUI offers pay-as-you-go + custom via baseUrlChoices.
   // Formerly `qwen-portal` / portal.qwen.ai — that host is outdated.
   {
@@ -756,6 +779,20 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     dashboardUrl: "https://docs.qwencloud.com",
     note: "Pick token plan, pay as you go, or a custom compatible-mode base URL",
   },
+  {
+    id: "tencent-coding-plan",
+    label: "Tencent Cloud Coding Plan",
+    baseUrl: "https://api.lkeap.cloud.tencent.com/coding/v3",
+    adapter: "openai-chat",
+    authKind: "key",
+    dashboardUrl: "https://console.cloud.tencent.com/tokenhub/codingplan",
+    defaultModel: "tc-code-latest",
+    models: TENCENT_CODING_PLAN_MODELS,
+    liveModels: true,
+    modelInputModalities: Object.fromEntries(TENCENT_CODING_PLAN_MODELS.map(id => [id, ["text"]])),
+    noVisionModels: TENCENT_CODING_PLAN_MODELS,
+    note: "Coding tools only. Tencent forbids general API automation, custom backends, and non-interactive batch use.",
+  },
   // 2026-07-10: docs unverified; model data frozen. Evidence: devlog/_plan/260710_provider_hardening/002_research_cn.md.
   { id: "qianfan", label: "Qianfan (Baidu)", baseUrl: "https://qianfan.baidubce.com/v2", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://console.bce.baidu.com/iam/#/iam/apikey/list" },
   // 2026-07-10: docs unverified; model data frozen. Evidence: devlog/_plan/260710_provider_hardening/002_research_cn.md.

package/src/responses/parser.ts

@@ -13,6 +13,7 @@ import type {
 import { namespacedToolName } from "../types";
 import { responsesRequestSchema } from "./schema";
 import { compactionItemToText } from "./compaction";
+import { previousResponseReplayPrefixLength } from "./state";
 import { decodeReasoningEnvelope } from "./reasoning-envelope";
 import { extractHostedWebSearch, WEB_SEARCH_TOOL_NAME } from "../web-search/synthetic-tool";
 
@@ -198,6 +199,10 @@ function outputToToolResultContent(output: string | unknown[] | undefined): stri
   return parts;
 }
 
+function toolOutputContainsEncryptedContent(output: string | unknown[] | undefined): boolean {
+  return Array.isArray(output) && output.some(raw => isObj(raw) && raw.type === "encrypted_content");
+}
+
 /**
  * codex-rs ImageDetail allows "original", but chat-completions providers only accept
  * auto|low|high on image_url.detail — degrade "original" to "high" (the codex default).
@@ -220,6 +225,7 @@ function findToolById(messages: OcxMessage[], callId: string): { name: string; n
 const REASONING_EFFORTS = new Set(["none", "minimal", "low", "medium", "high", "xhigh", "max"]);
 
 export function parseRequest(body: unknown): OcxParsedRequest {
+  const replayedInputPrefixLength = previousResponseReplayPrefixLength(body);
   const parsed = responsesRequestSchema.safeParse(body);
   if (!parsed.success) {
     throw new Error(`responses parse error: ${parsed.error.message}`);
@@ -248,6 +254,7 @@ export function parseRequest(body: unknown): OcxParsedRequest {
   // Remote compaction v2: the input tail carries `{type:"compaction_trigger"}` and Codex expects a
   // synthetic `{type:"compaction"}` output item (src/responses/compaction.ts). Flagged for the server.
   let compactionRequest = false;
+  let contextCompactionBoundary = false;
 
   if (typeof data.instructions === "string" && data.instructions.length > 0) {
     systemPrompt.push(data.instructions);
@@ -256,7 +263,8 @@ export function parseRequest(body: unknown): OcxParsedRequest {
   if (typeof data.input === "string") {
     messages.push({ role: "user", content: data.input, timestamp: now });
   } else if (data.input) {
-    for (const item of data.input) {
+    for (let inputIndex = 0; inputIndex < data.input.length; inputIndex++) {
+      const item = data.input[inputIndex];
       const effectiveType = (item as { type?: string }).type ?? ("role" in item ? "message" : undefined);
 
       if (effectiveType === "compaction_trigger") {
@@ -281,7 +289,10 @@ export function parseRequest(body: unknown): OcxParsedRequest {
         // the routed model keeps the compacted context; real OpenAI-encrypted blobs degrade to a note.
         // `context_compaction` (encrypted_content optional) is codex-rs's local-compaction marker;
         // with no payload it is a pure marker (the summary follows as its own user message), so it
-        // is dropped silently. It must NOT flag _compactionRequest.
+        // is dropped silently. It must NOT flag _compactionRequest. Only a marker newly appended in
+        // this request starts a provider-private context epoch; markers inside the prefix restored by
+        // previous_response_id were already acknowledged on the turn that introduced them.
+        if (inputIndex >= replayedInputPrefixLength) contextCompactionBoundary = true;
         const encrypted = (item as { encrypted_content?: unknown }).encrypted_content;
         if (effectiveType === "context_compaction" && typeof encrypted !== "string") continue;
         pendingReasoning.length = 0;
@@ -323,7 +334,7 @@ export function parseRequest(body: unknown): OcxParsedRequest {
       }
 
       if (effectiveType === "message") {
-        const msg = item as { role?: string; content?: unknown };
+        const msg = item as { role?: string; content?: unknown; phase?: "commentary" | "final_answer" };
         switch (msg.role) {
           case "system": {
             pendingReasoning.length = 0;
@@ -346,6 +357,7 @@ export function parseRequest(body: unknown): OcxParsedRequest {
               content: pendingReasoning.length > 0
                 ? [...pendingReasoning.map(entry => entry.part), ...parts]
                 : parts,
+              ...(msg.phase ? { phase: msg.phase } : {}),
               model: data.model,
               timestamp: now,
             });
@@ -443,13 +455,10 @@ export function parseRequest(body: unknown): OcxParsedRequest {
       }
 
       if (effectiveType === "web_search_call") {
-        // Replayed hosted web-search evidence. Textify it into assistant history so the model
-        // knows the search already ran (prevents re-search loops); there is no output to pair.
-        const call = item as { action?: { type?: string; query?: string } };
-        const query = typeof call.action?.query === "string" ? call.action.query : "";
-        assistantHolderWithReasoning().content.push({
-          type: "text", text: query ? `[web search performed: ${query}]` : "[web search performed]",
-        });
+        // Replayed hosted web-search evidence has no paired result payload that routed providers can
+        // consume. Keep it out of assistant-visible text: the old marker was useful as an internal
+        // loop hint, but when no sidecar is available the model can echo it as a fake answer.
+        pendingReasoning.length = 0;
         continue;
       }
 
@@ -504,6 +513,7 @@ export function parseRequest(body: unknown): OcxParsedRequest {
           role: "toolResult", toolCallId: output.call_id,
           toolName: toolInfo.name, toolNamespace: toolInfo.namespace,
           content: outputToToolResultContent(output.output), isError: false, timestamp: now,
+          ...(toolOutputContainsEncryptedContent(output.output) ? { containsEncryptedContent: true } : {}),
         });
         continue;
       }
@@ -518,6 +528,7 @@ export function parseRequest(body: unknown): OcxParsedRequest {
           // Same payload shape as function_call_output (codex-rs FunctionCallOutputPayload):
           // string or content items — normalize arrays instead of leaking raw wire blocks.
           content: outputToToolResultContent(output.output), isError: false, timestamp: now,
+          ...(toolOutputContainsEncryptedContent(output.output) ? { containsEncryptedContent: true } : {}),
         });
       }
     }
@@ -586,6 +597,7 @@ export function parseRequest(body: unknown): OcxParsedRequest {
     ...(webSearch ? { _webSearch: webSearch } : {}),
     ...(structuredOutput ? { _structuredOutput: true } : {}),
     ...(compactionRequest ? { _compactionRequest: true } : {}),
+    ...(contextCompactionBoundary ? { _contextCompactionBoundary: true } : {}),
   };
 }
 

package/src/responses/schema.ts

@@ -47,6 +47,7 @@ const assistantMessageItemSchema = z.object({
   type: z.literal("message").optional(),
   role: z.literal("assistant"),
   content: z.union([z.string(), z.array(outputContentBlockSchema)]).optional(),
+  phase: z.enum(["commentary", "final_answer"]).optional(),
 });
 const reasoningItemSchema = z.object({
   type: z.literal("reasoning"),

package/src/responses/state.ts

@@ -1,6 +1,7 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { atomicWriteFile, getConfigDir } from "../config";
+import type { OcxProviderContinuationState } from "../types";
 
 const MAX_STORED_RESPONSES = 1_000;
 const RESPONSE_TTL_MS = 60 * 60 * 1_000;
@@ -13,11 +14,18 @@ const SNAPSHOT_TOTAL_MAX_BYTES = 24 * 1024 * 1024;
 interface StoredResponseState {
   createdAt: number;
   items: unknown[];
+  /** v2 provider-keyed continuation metadata. */
+  providers?: OcxProviderContinuationState;
+  /** v1 Cursor-only metadata, accepted only while loading old snapshots. */
   conversationId?: string;
   cursorCheckpointUsable?: boolean;
 }
 
 const states = new Map<string, StoredResponseState>();
+// Expansion provenance must stay proxy-private: a WeakMap distinguishes replayed history from the
+// newly appended input suffix without adding an unknown field that native passthrough could send
+// upstream. The parser uses this boundary to acknowledge historical compaction markers exactly once.
+const replayedInputPrefixLengths = new WeakMap<object, number>();
 let loaded = false;
 let persistTimer: ReturnType<typeof setTimeout> | null = null;
 let pendingPersistPath: string | null = null;
@@ -44,14 +52,28 @@ function ensureLoaded(): void {
     const path = snapshotPath();
     if (!existsSync(path)) return;
     const raw = JSON.parse(readFileSync(path, "utf-8")) as { version?: unknown; states?: unknown };
-    if (raw.version !== 1 || !Array.isArray(raw.states)) return;
+    if ((raw.version !== 1 && raw.version !== 2) || !Array.isArray(raw.states)) return;
     for (const entry of raw.states) {
       if (!Array.isArray(entry) || entry.length !== 2) continue;
       const [id, state] = entry as [unknown, unknown];
       if (typeof id !== "string" || !state || typeof state !== "object") continue;
       const rec = state as StoredResponseState;
       if (typeof rec.createdAt !== "number" || !Array.isArray(rec.items)) continue;
-      states.set(id, rec);
+      const providers = rec.providers ?? (rec.conversationId
+        ? {
+            cursor: {
+              conversationId: rec.conversationId,
+              ...(rec.cursorCheckpointUsable !== undefined
+                ? { checkpointUsable: rec.cursorCheckpointUsable }
+                : {}),
+            },
+          }
+        : undefined);
+      states.set(id, {
+        createdAt: rec.createdAt,
+        items: rec.items,
+        ...(providers ? { providers } : {}),
+      });
     }
     pruneResponses();
   } catch {
@@ -81,7 +103,7 @@ function persistNow(path: string): void {
     // mkdirSync's mode only applies on creation — re-harden an existing config dir so the
     // conversation-content snapshot never lands in a group/world-readable directory.
     try { chmodSync(dirname(path), 0o700); } catch { /* best-effort (e.g. Windows) */ }
-    atomicWriteFile(path, JSON.stringify({ version: 1, states: entries }));
+    atomicWriteFile(path, JSON.stringify({ version: 2, states: entries }));
   } catch {
     /* best-effort: disk trouble must never affect request handling */
   }
@@ -131,23 +153,36 @@ export function expandPreviousResponseInput(body: unknown): unknown {
   pruneResponses();
   const previous = states.get(previousId);
   if (!previous) return body;
-  return {
+  const expanded = {
     ...request,
     input: [...previous.items, ...inputItems(request.input)],
   };
+  replayedInputPrefixLengths.set(expanded, previous.items.length);
+  return expanded;
+}
+
+/** Number of leading input items restored from previous_response_id state for this exact body. */
+export function previousResponseReplayPrefixLength(body: unknown): number {
+  if (!body || typeof body !== "object" || Array.isArray(body)) return 0;
+  return replayedInputPrefixLengths.get(body) ?? 0;
 }
 
 export function previousResponseConversationId(responseId: string | undefined): string | undefined {
+  return previousResponseProviderState(responseId)?.cursor?.conversationId;
+}
+
+export function previousResponseProviderState(responseId: string | undefined): OcxProviderContinuationState | undefined {
   if (!responseId) return undefined;
   ensureLoaded();
   pruneResponses();
-  return states.get(responseId)?.conversationId;
+  const providers = states.get(responseId)?.providers;
+  return providers ? structuredClone(providers) : undefined;
 }
 
 export function rememberResponseState(
   requestBody: unknown,
   response: { id?: unknown; output?: unknown; status?: unknown },
-  conversationId?: string,
+  providerState?: OcxProviderContinuationState | string,
   opts?: { force?: boolean },
 ): void {
   if (!requestBody || typeof requestBody !== "object" || Array.isArray(requestBody)) return;
@@ -161,6 +196,14 @@ export function rememberResponseState(
   if (typeof response.id !== "string" || !Array.isArray(response.output)) return;
   if (response.status !== undefined && response.status !== "completed") return;
   ensureLoaded();
+  const normalizedProviderState: OcxProviderContinuationState = typeof providerState === "string"
+    ? { cursor: { conversationId: providerState } }
+    : structuredClone(providerState ?? {});
+  if (normalizedProviderState.cursor?.conversationId) {
+    normalizedProviderState.cursor.checkpointUsable = !response.output.some(item => {
+      return !!item && typeof item === "object" && (item as { type?: unknown }).type === "function_call";
+    });
+  }
   states.set(response.id, {
     createdAt: now(),
     items: [...inputItems(request.input), ...response.output],
@@ -169,10 +212,7 @@ export function rememberResponseState(
     // checkpoint/cache is safe to reuse: a turn that ended with a pending client tool call produced an
     // incomplete agent turn on the Cursor side (we suspended without a real mcpResult), so its
     // checkpoint must not be reused — but the conversation id string itself is still valid.
-    ...(conversationId ? { conversationId } : {}),
-    cursorCheckpointUsable: !response.output.some(item => {
-      return !!item && typeof item === "object" && (item as { type?: unknown }).type === "function_call";
-    }),
+    ...(Object.keys(normalizedProviderState).length > 0 ? { providers: normalizedProviderState } : {}),
   });
   pruneResponses();
   schedulePersist();

package/src/router.ts

@@ -49,6 +49,7 @@ export function knownModelIdsForProvider(provName: string, prov: OcxProviderConf
     registry?.modelReasoningEfforts,
     registry?.modelDefaultReasoningEfforts,
     registry?.modelReasoningEffortMap,
+    registry?.modelMaxOutputTokens,
   ]) {
     for (const id of Object.keys(map ?? {})) ids.add(id);
   }
@@ -141,6 +142,7 @@ function routedProviderConfig(providerName: string, provider: OcxProviderConfig)
   const modelMaxInputTokens = providerName === OPENAI_API_PROVIDER_ID
     ? mergePositiveNumberCaps(registryEntry.modelMaxInputTokens, provider.modelMaxInputTokens)
     : mergeRecordFill(registryEntry.modelMaxInputTokens, provider.modelMaxInputTokens);
+  const modelMaxOutputTokens = mergeRecordFill(registryEntry.modelMaxOutputTokens, provider.modelMaxOutputTokens);
   const noVisionModels = mergeStringArray(registryEntry.noVisionModels, provider.noVisionModels);
   const noReasoningModels = mergeStringArray(registryEntry.noReasoningModels, provider.noReasoningModels);
   const noTemperatureModels = mergeStringArray(registryEntry.noTemperatureModels, provider.noTemperatureModels);
@@ -183,9 +185,13 @@ function routedProviderConfig(providerName: string, provider: OcxProviderConfig)
     // opt-in, while an explicit user `false` keeps overriding registry `true`.
     ...(provider.parallelToolCalls === undefined && registryEntry.parallelToolCalls !== undefined ? { parallelToolCalls: registryEntry.parallelToolCalls } : {}),
     ...(provider.promptCacheKey === undefined && registryEntry.promptCacheKey !== undefined ? { promptCacheKey: registryEntry.promptCacheKey } : {}),
+    ...(provider.defaultMaxOutputTokens === undefined && registryEntry.defaultMaxOutputTokens !== undefined
+      ? { defaultMaxOutputTokens: registryEntry.defaultMaxOutputTokens }
+      : {}),
     ...(modelContextWindows ? { modelContextWindows } : {}),
     ...(modelInputModalities ? { modelInputModalities } : {}),
     ...(modelMaxInputTokens ? { modelMaxInputTokens } : {}),
+    ...(modelMaxOutputTokens ? { modelMaxOutputTokens } : {}),
     ...(modelReasoningEfforts ? { modelReasoningEfforts } : {}),
     ...(modelDefaultReasoningEfforts ? { modelDefaultReasoningEfforts } : {}),
     ...(reasoningEffortMap ? { reasoningEffortMap } : {}),
@@ -228,15 +234,17 @@ function routeResult(providerName: string, provider: OcxProviderConfig, modelId:
   };
 }
 
-export function routeModel(config: OcxConfig, modelId: string): RouteResult {
+function routeModelInternal(config: OcxConfig, modelId: string, bypassCombos: boolean): RouteResult {
   const preservePhysicalComboProvider =
     hasOwnProvider(config.providers, COMBO_NAMESPACE)
     && Object.keys(config.combos ?? {}).length === 0;
-  if (!preservePhysicalComboProvider) {
+  if (!bypassCombos && !preservePhysicalComboProvider) {
     const combo = tryPickComboModel(config, modelId);
     if (combo) {
       const concrete = `${combo.target.provider}/${combo.target.model}`;
-      const routed = routeModel(config, concrete);
+      // The selected target is already a concrete provider/model reference. Resolve it without
+      // consulting combo aliases again, otherwise an alias that shadows the target can recurse.
+      const routed = routeModelInternal(config, concrete, true);
       return { ...routed, combo };
     }
   }
@@ -300,6 +308,10 @@ export function routeModel(config: OcxConfig, modelId: string): RouteResult {
   throw new Error(`No provider configured for model: ${modelId}`);
 }
 
+export function routeModel(config: OcxConfig, modelId: string): RouteResult {
+  return routeModelInternal(config, modelId, false);
+}
+
 function routeByKnownModelPattern(config: OcxConfig, modelId: string): RouteResult | undefined {
   for (const { providerNames, prefixes } of MODEL_PROVIDER_PATTERNS) {
     if (prefixes.some(prefix => modelId.startsWith(prefix))) {

package/src/server/auth-cors.ts

@@ -2,6 +2,7 @@ import { timingSafeEqual } from "node:crypto";
 import { formatErrorResponse } from "../bridge";
 import {
   codexAutoStartEnabled,
+  positiveIntegerConfigError,
   positiveIntegerRecordConfigError,
   providerBaseUrlConfigError,
   providerHeadersConfigError,
@@ -227,6 +228,10 @@ export function providerManagementConfigError(name: unknown, provider: unknown):
   if (headersError) return `provider ${name} ${headersError}`;
   const maxInputError = positiveIntegerRecordConfigError(raw.modelMaxInputTokens, "modelMaxInputTokens");
   if (maxInputError) return `provider ${name} ${maxInputError}`;
+  const defaultMaxOutputError = positiveIntegerConfigError(raw.defaultMaxOutputTokens, "defaultMaxOutputTokens");
+  if (defaultMaxOutputError) return `provider ${name} ${defaultMaxOutputError}`;
+  const maxOutputError = positiveIntegerRecordConfigError(raw.modelMaxOutputTokens, "modelMaxOutputTokens");
+  if (maxOutputError) return `provider ${name} ${maxOutputError}`;
   const openRouterError = openRouterRoutingConfigError(typed);
   if (openRouterError) return `provider ${name} ${openRouterError}`;
   if (typed.authMode === "local") {
@@ -293,6 +298,8 @@ export function safeConfigDTO(config: OcxConfig): unknown {
       "models",
       "contextWindow",
       "modelContextWindows",
+      "defaultMaxOutputTokens",
+      "modelMaxOutputTokens",
       "openRouterRouting",
       "modelOpenRouterRouting",
       "reasoningEfforts",

package/src/server/claude-messages.ts

@@ -729,6 +729,12 @@ export async function handleClaudeMessages(
     return anthropicErrorResponse(502, error?.message ?? "upstream request failed", "api_error");
   }
   const message = responsesJsonToAnthropicMessage(json, requestedModel);
+  if ((message as Rec).type === "error") {
+    return new Response(JSON.stringify(message), {
+      status: 529,
+      headers: { "Content-Type": "application/json", "Retry-After": "2" },
+    });
+  }
   if (!stream) {
     return new Response(JSON.stringify(message), { status: 200, headers: { "Content-Type": "application/json" } });
   }

package/src/server/index.ts

@@ -134,9 +134,12 @@ const WEBSOCKET_IDLE_TIMEOUT_SECONDS = 0;
 // Source invariant for tests/passthrough-abort.test.ts after the pure module split:
 // if (isEventStream && upstreamResponse.body) {
 // upstreamResponse.body.tee()
+// const repairConfig = route.provider.responsesItemIdRepair;
+// const repairedBody = hasResponsesItemIdRepair(repairConfig)
 // process.platform === "win32"
+// && !hasResponsesItemIdRepair(repairConfig)
 // ? nativeBody
-// relaySseWithFailedTail(nativeBody, upstream)
+// relaySseWithFailedTail(repairedBody, upstream)
 // new Response(clientBody
 // markNativePassthroughSseResponse
 // const body = relayWithAbort(upstreamResponse.body, upstream);
@@ -251,7 +254,7 @@ export function startServer(port?: number) {
           return withCors(formatErrorResponse(403, "origin_rejected", "cross-origin data-plane request blocked"), req, config);
         }
         const goModels = await fetchAllModels(config);
-        const { applyNativeVisibility, buildCatalogEntries, disabledNativeSlugs, exactComboCatalogSlugs, loadCatalogTemplate, nativeOpenAiSlugs, orderForSubagents, filterCatalogVisibleModels, visibleNativeSlugs } = await import("../codex/catalog");
+        const { applyNativeVisibility, buildCatalogEntries, disabledNativeSlugs, exactComboCatalogSlugs, loadCatalogTemplate, nativeOpenAiSlugs, orderForSubagents, filterCatalogVisibleModels, uniqueCatalogModelsForRawPublicList, visibleNativeSlugs } = await import("../codex/catalog");
         const nativeSlugs = nativeOpenAiSlugs();
         const goEnabled = filterCatalogVisibleModels(goModels, config);
         const goOrdered = orderForSubagents(goEnabled, config.subagentModels);
@@ -301,7 +304,7 @@ export function startServer(port?: number) {
         // (pure availability list — disabled natives are omitted entirely).
         const data = [
           ...visibleNativeSlugs(config).map(id => ({ id, object: "model", created: 0, owned_by: "openai" })),
-          ...goOrdered.map(m => ({ id: `${m.provider}/${m.id}`, object: "model", created: 0, owned_by: m.owned_by ?? m.provider })),
+          ...uniqueCatalogModelsForRawPublicList(goOrdered).map(m => ({ id: m.alias ?? `${m.provider}/${m.id}`, object: "model", created: 0, owned_by: m.owned_by ?? m.provider })),
         ];
         return jsonResponse({ object: "list", data }, 200, req, config);
       }