@yansigit/opencodex 2.32.0 → 2.33.1

package/src/server/responses/empty-completion-guard.ts

@@ -153,9 +153,10 @@ export interface EmptyCompletionGuardOptions {
  * Watch an adapter event stream for the empty-completion failure mode. Events
  * are held until the turn produces content or ends: reasoning and other
  * pre-content events stay buffered (released in order on first content), the
- * terminal is withheld, and an empty terminal triggers one identical-turn
- * retry through `continuation`. Usage is merged across attempts so the bridge
- * and request log meter the whole turn, not just the attempt that succeeded.
+ * terminal is withheld, and an empty terminal or pre-output EOF triggers one
+ * identical-turn retry through `continuation`. Usage is merged across attempts
+ * so the bridge and request log meter the whole turn, not just the attempt that
+ * succeeded.
  *
  * Heartbeats always pass through untouched: they feed the bridge's stall
  * watchdog, so holding them behind the content gate would trip false
@@ -194,7 +195,11 @@ export async function* guardEmptyCompletionEventStream(
       if (sawContent || passthrough) {
         // Buffered content is already flowing; everything downstream passes
         // through. Every terminal carries usage merged across every attempt.
-        yield isTerminalEvent(event) ? withUsage(event) : event;
+        if (isTerminalEvent(event)) {
+          yield withUsage(event);
+          return;
+        }
+        yield event;
         continue;
       }
       if (isContentEvent(event)) {
@@ -231,6 +236,13 @@ export async function* guardEmptyCompletionEventStream(
         return;
       }
       if (event.type === "error") {
+        // A local route/request validation failure from a continuation is already a complete,
+        // typed client error. Do not collapse it into the generic empty-completion retry failure.
+        if (event.status === 400 && event.errorType === "invalid_request_error") {
+          yield* releaseHeld();
+          yield withUsage(event);
+          return;
+        }
         if (retries > 0 && event.status !== 499) {
           // The retry failed upstream. Its body cannot reach the client (the
           // 200 head went out with the first attempt), so state the failure in
@@ -267,8 +279,25 @@ export async function* guardEmptyCompletionEventStream(
       if (isReasoningEvent(event)) yield { type: "heartbeat" };
     }
     if (!terminalSeen) {
-      // The source ended without a terminal event (truncated stream). Release
-      // what was held so the bridge can mark the stream incomplete.
+      // A terminal-less EOF before text or a tool call is replay-safe: nothing
+      // actionable reached the client. Retry once, then surface a stated error
+      // instead of letting the bridge reduce the turn to adapter_eof.
+      if (!sawContent && !passthrough && retries < maxRetries) {
+        retries += 1;
+        try {
+          source = await options.continuation();
+        } catch {
+          yield emptyCompletionRetryFailedEvent(usage, true);
+          return;
+        }
+        continue;
+      }
+      if (!sawContent && retries > 0) {
+        yield emptyCompletionRetryFailedEvent(usage, true);
+        return;
+      }
+      // Post-output EOF remains incomplete; replaying could duplicate text or
+      // executable tool calls.
       yield* releaseHeld();
       return;
     }

package/src/server/responses/fetch-helpers.ts

@@ -9,6 +9,7 @@ import type { OcxProviderConfig } from "../../types";
 import type { WsData } from "../ws-bridge";
 import { waitForProviderRequestSlot } from "../../providers/request-pacing";
 import { withUpstreamHttpVersion } from "../../lib/upstream-http-version";
+import { providerTlsFetch } from "../../lib/provider-tls-profile";
 
 export { withUpstreamHttpVersion };
 
@@ -64,14 +65,29 @@ export function providerFetch(
   options: ProviderFetchOptions = {},
 ): ProviderFetch {
   const base = (provider as OcxProviderConfig & { fetch?: typeof globalThis.fetch }).fetch ?? globalThis.fetch;
+  const preconnect = (...args: Parameters<typeof globalThis.fetch.preconnect>): void => {
+    base.preconnect?.(...args);
+  };
+  const transport = options.providerName
+    ? providerTlsFetch(options.providerName, provider, base)
+    : base;
+  const httpFetch = Object.assign(
+    (input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit) =>
+      transport(input, withUpstreamHttpVersion(input, init, provider)),
+    { preconnect },
+  ) as typeof globalThis.fetch;
   // ChatGPT Codex backend: streaming turns ride the responses_websockets
   // transport (measured ~3s faster TTFT than the SSE POST queue); everything
   // else keeps the provider's HTTP fetch. See ws-upstream.ts for the details.
   const unpaced = async (input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit) => {
     if (typeof input === "string" && init && shouldUseCodexWsUpstream(input, init, runtime)) {
-      return codexWsUpstreamFetch(input, init, base, runtime);
+      // The fallback has to be the same HTTP fetch the non-WS branch would have
+      // used, protocol pin included: a WS turn that falls back is serving the
+      // request over HTTP, and dropping the provider's `upstreamHttpVersion`
+      // there would silently negotiate a transport the operator ruled out.
+      return codexWsUpstreamFetch(input, init, httpFetch, runtime);
     }
-    return base(input, withUpstreamHttpVersion(input, init, provider));
+    return httpFetch(input, init);
   };
   let pacingSlotAcquired = options.pacingSlotAcquired === true;
   const waitForPacing = (signal?: AbortSignal) => {
@@ -87,9 +103,6 @@ export function providerFetch(
     await waitForPacing(init?.signal ?? undefined);
     return unpaced(input, init);
   };
-  const preconnect = (...args: Parameters<typeof globalThis.fetch.preconnect>): void => {
-    base.preconnect?.(...args);
-  };
   return Object.assign(wrapped, {
     preconnect,
     waitForPacing,

package/src/server/responses/policy-fallback.ts

@@ -89,7 +89,7 @@ function finishFailedPolicyAttempt(logCtx: RequestLogContext, status: number): v
   const attempt = logCtx.activeAttempt;
   if (attempt) {
     const startedAt = logCtx.activeAttemptStartedAt ?? Date.now();
-    finishRequestAttempt(attempt, status, Math.max(0, Date.now() - startedAt), attempt.usage ?? logCtx.usage);
+    finishRequestAttempt(attempt, status, Math.max(0, Date.now() - startedAt), attempt.usage ?? logCtx.usage, logCtx.upstreamError);
   }
   delete logCtx.activeAttempt;
   delete logCtx.activeAttemptStartedAt;

package/src/server/responses/v2-native-parent-override.ts

@@ -0,0 +1,59 @@
+import type { OcxConfig, OcxParsedRequest } from "../../types";
+import { routeModel, type RouteResult } from "../../router";
+import type { PolicyRequestEvidence } from "../../routing/evaluator";
+import { isMultiAgentV2Enabled } from "../../codex/features";
+import { collabSurface } from "./collaboration";
+import { isThreadSpawnRequest } from "../effort-policy";
+import { isCanonicalOpenAiForwardProvider } from "../../providers/openai-tiers";
+
+export type V2NativeParentOverrideDecision =
+  | { kind: "skip" }
+  | { kind: "reject"; message: string; trace?: unknown }
+  | { kind: "override"; route: RouteResult };
+
+export function decideV2NativeParentOverride(args: {
+  kind: "responses" | "compact";
+  config: OcxConfig;
+  headers: Headers;
+  sourceRoute: RouteResult;
+  parsed?: OcxParsedRequest;
+  comboAttempt?: boolean;
+  targetEvidence?: PolicyRequestEvidence;
+}): V2NativeParentOverrideDecision {
+  const { config, headers, sourceRoute } = args;
+  if (
+    args.comboAttempt
+    || config.v2NativeParentOverride?.enabled !== true
+    || config.multiAgentMode !== "v2"
+    || config.keepNativeChatGptOnV1 === true
+    || !isMultiAgentV2Enabled()
+  ) return { kind: "skip" };
+  if (args.kind === "responses" && (
+    !args.parsed
+    || (collabSurface(args.parsed) !== "v2"
+      && !(args.parsed._compactionRequest === true && config.multiAgentMode === "v2"))
+  )) {
+    return { kind: "skip" };
+  }
+  if (isThreadSpawnRequest(headers) || headers.has("x-openai-subagent")) return { kind: "skip" };
+  if (!isCanonicalOpenAiForwardProvider(sourceRoute.provider)) return { kind: "skip" };
+
+  const targetModel = config.v2NativeParentOverride.model?.trim();
+  if (!targetModel) {
+    return { kind: "reject", message: "v2NativeParentOverride requires a configured model" };
+  }
+  let route: RouteResult;
+  try {
+    route = routeModel(config, targetModel, args.targetEvidence);
+  } catch (error) {
+    return {
+      kind: "reject",
+      message: error instanceof Error ? error.message : String(error),
+      trace: (error as { trace?: unknown }).trace,
+    };
+  }
+  if (isCanonicalOpenAiForwardProvider(route.provider)) {
+    return { kind: "reject", message: "v2NativeParentOverride target must resolve to a noncanonical provider" };
+  }
+  return { kind: "override", route };
+}

package/src/server/responses/ws-upstream.ts

@@ -28,6 +28,25 @@ const UPGRADE_DEADLINE_MS = 10_000;
 export const MAX_CODEX_WS_FRAME_BYTES = MAX_CLIENT_SSE_FRAME_BYTES;
 export const MAX_CODEX_WS_QUEUE_BYTES = 8 * 1024 * 1024;
 export const MIN_BOUNDED_CODEX_WS_BUN_VERSION = "1.4.0";
+// The backend drops any inbound message of 16 MiB or more: it closes the socket
+// (1009) without a Responses terminal event, which reaches clients as a bare
+// 502 upstream_server_error. Measured against the live endpoint 2026-08-23:
+// 16,777,000 B completed, 16,777,300 B closed in ~1s, every time. The same
+// request body succeeds over HTTP SSE, so the ceiling belongs to this transport
+// alone (see #2426). A full-replay thread reaches it with ~11 pasted
+// screenshots, and then never recovers, because each retry resends the frame.
+export const MAX_CODEX_WS_CREATE_FRAME_BYTES = 16 * 1024 * 1024;
+// Bun frames the payload it is handed, so the send-side budget is the JSON text
+// itself, and nothing is appended between the check and the send. The margin is
+// a conservative cushion, not a computed requirement: it covers RFC 6455 frame
+// overhead in case the backend counts it (14 bytes at this payload size — an
+// 8-byte extended length plus a 4-byte client mask, leaving ~65.5 KiB spare),
+// and it leaves room for a future caller that appends to the frame.
+const CODEX_WS_CREATE_FRAME_MARGIN_BYTES = 64 * 1024;
+export const CODEX_WS_CREATE_FRAME_LIMIT_BYTES =
+  MAX_CODEX_WS_CREATE_FRAME_BYTES - CODEX_WS_CREATE_FRAME_MARGIN_BYTES;
+/** Close code the backend uses for an oversized message (RFC 6455 "message too big"). */
+const WS_CLOSE_MESSAGE_TOO_BIG = 1009;
 
 export type BunRuntimeIdentity = {
   version: string;
@@ -102,6 +121,52 @@ export function shouldUseCodexWsUpstream(
   }
 }
 
+const CLOSED_BEFORE_TERMINAL = "codex websocket closed before a Responses terminal event";
+
+/**
+ * The close code is the only thing that separates "the backend refused this
+ * payload" from "the network dropped", and both used to reach the caller as the
+ * same bare 502. Naming the oversized case here puts that distinction in the
+ * message the client receives.
+ *
+ * It does NOT reach the request log as a typed code. The eager relay turns any
+ * stream error into a generic `upstream_reset` synthetic terminal
+ * (`relay.ts`, `relay-eager.ts`) without feeding that frame back through the
+ * inspector, so `/api/logs` keeps neither this message nor a specific code —
+ * only `streamAborted`. Machine-readable typing would mean changing the error
+ * taxonomy, which is deliberately out of scope for this transport fix.
+ */
+function closedBeforeTerminalMessage(event: unknown): string {
+  const detail = event as { code?: unknown; reason?: unknown } | null | undefined;
+  const code = typeof detail?.code === "number" ? detail.code : null;
+  const reason = typeof detail?.reason === "string" ? detail.reason.trim() : "";
+  if (code === null) return CLOSED_BEFORE_TERMINAL;
+  const suffix = reason ? ` ${code} ${reason}` : ` ${code}`;
+  if (code === WS_CLOSE_MESSAGE_TOO_BIG) {
+    return `codex websocket rejected the request frame as too large (close${suffix});`
+      + ` requests at or above ${MAX_CODEX_WS_CREATE_FRAME_BYTES} bytes must use the HTTP SSE transport`;
+  }
+  return `${CLOSED_BEFORE_TERMINAL} (close${suffix})`;
+}
+
+/**
+ * True when the `response.create` frame is at or above the backend's inbound
+ * message ceiling, so this turn must take the HTTP SSE path instead.
+ *
+ * Sizing a 16 MiB string should not cost a 16 MiB copy. UTF-8 never encodes
+ * below one byte per UTF-16 code unit and never above three, so both tails are
+ * settled from the string length alone; only the narrow band between them pays
+ * for a real byte count, and `Buffer.byteLength` measures without allocating.
+ */
+export function codexWsCreateFrameExceedsLimit(
+  frameText: string,
+  limitBytes: number = CODEX_WS_CREATE_FRAME_LIMIT_BYTES,
+): boolean {
+  if (frameText.length >= limitBytes) return true;
+  if (frameText.length * 3 < limitBytes) return false;
+  return Buffer.byteLength(frameText, "utf8") >= limitBytes;
+}
+
 export function codexWsUpstreamFetch(
   url: string,
   init: RequestInit,
@@ -127,6 +192,14 @@ export function codexWsUpstreamFetch(
     return sseFallback(url, init);
   }
 
+  // Decide before dialing. Once the socket is open the caller already holds a
+  // streaming Response, so the oversized close can only be surfaced as a stream
+  // error — and a resend at that point could double-generate. Measuring the
+  // frame we are about to send keeps the whole failure mode unreachable.
+  if (codexWsCreateFrameExceedsLimit(frameText)) {
+    return sseFallback(url, init);
+  }
+
   const headers: Record<string, string> = {};
   new Headers(init.headers ?? {}).forEach((value, key) => {
     // HTTP-body framing headers do not apply to a WS handshake.
@@ -279,7 +352,7 @@ export function codexWsUpstreamFetch(
       }
     });
 
-    ws.addEventListener("close", () => {
+    ws.addEventListener("close", (event: unknown) => {
       signal?.removeEventListener("abort", onAbort);
       if (!opened) {
         if (settledPreOpen) return;
@@ -297,7 +370,7 @@ export function codexWsUpstreamFetch(
         // here would reach clients with no response.completed/failed at all —
         // relaySseWithFailedTail() only synthesizes a failed terminal when the
         // body read THROWS. Error the stream like a reset TCP socket.
-        try { controller.error(new Error("codex websocket closed before a Responses terminal event")); } catch { /* stream already done */ }
+        try { controller.error(new Error(closedBeforeTerminalMessage(event))); } catch { /* stream already done */ }
       }
     });
 

package/src/server/responses-undeclared-tool-guard.ts

@@ -1,9 +1,31 @@
-import { namespacedToolName } from "../types";
+import { namespacedToolName, normalizeDeclaredToolName } from "../types";
 import { sseDataPayload, type SseBlockRewrite } from "./sse-payload-rewrite";
 
 /** Item types the client executes through a request-declared wire name. */
 const CLIENT_EXECUTED_CALL_TYPES = new Set(["function_call", "custom_tool_call"]);
 
+/**
+ * Hosted declarations whose response items the PROVIDER executes, keyed by the request
+ * declaration type. These need no client answer, so their names are deliberately absent from
+ * the request catalog and must not be read as an undeclared client tool.
+ *
+ * xAI surfaces hosted `x_search` as `custom_tool_call`. Probed 2026-08-23 against the OAuth CLI
+ * destination: its hosted calls use an `xs_call-` call-id prefix. Observed call names were
+ * `x_keyword_search`, `x_semantic_search`, and `x_user_search` — three literals for one tool,
+ * which is why authorization keys on the declaration, item type, and call-id prefix, never on
+ * the name.
+ */
+export type ProviderExecutedCallType = Readonly<{
+  itemType: string;
+  callIdPrefix: string;
+}>;
+
+type ProviderExecutedCallTypes = ReadonlySet<ProviderExecutedCallType>;
+
+export const PROVIDER_EXECUTED_DECLARATION_CALL_TYPES = new Map<string, ProviderExecutedCallType>([
+  ["x_search", { itemType: "custom_tool_call", callIdPrefix: "xs_call-" }],
+]);
+
 /** Nameless declaration kinds whose response items still require client execution. */
 const NAMELESS_CLIENT_DECLARATION_CALL_TYPES = new Map([
   ["local_shell", "local_shell_call"],
@@ -19,6 +41,7 @@ const NAMELESS_CLIENT_CALL_DISPLAY_NAMES = new Map([
 ]);
 
 const EMPTY_DECLARED_NAMELESS_CLIENT_CALL_TYPES: ReadonlySet<string> = new Set();
+const EMPTY_PROVIDER_EXECUTED_CALL_TYPES: ReadonlySet<ProviderExecutedCallType> = new Set();
 
 /** Supported hosted/private declarations that carry no client-executable wire name. */
 const NAMELESS_TOOL_SPEC_TYPES = new Set([
@@ -127,6 +150,53 @@ function addNamelessClientCallTypes(callTypes: Set<string>, specs: unknown): voi
   }
 }
 
+function addProviderExecutedCallTypes(
+  callTypes: Set<ProviderExecutedCallType>,
+  specs: unknown,
+): void {
+  if (!Array.isArray(specs)) return;
+  for (const spec of specs) {
+    if (!isPlainObject(spec) || typeof spec.type !== "string") continue;
+    const callType = PROVIDER_EXECUTED_DECLARATION_CALL_TYPES.get(spec.type);
+    if (callType) callTypes.add(callType);
+  }
+}
+
+/**
+ * Item types this turn's hosted declarations authorize the PROVIDER to emit unnamed.
+ *
+ * Caller must gate this on the destination actually being that provider; a declaration alone
+ * is not authority, or any upstream could claim a hosted shape it never serves.
+ */
+export function collectProviderExecutedCallTypes(body: unknown): Set<ProviderExecutedCallType> {
+  const callTypes = new Set<ProviderExecutedCallType>();
+  if (!isPlainObject(body)) return callTypes;
+  addProviderExecutedCallTypes(callTypes, body.tools);
+  if (Array.isArray(body.input)) {
+    for (const item of body.input) {
+      if (
+        isPlainObject(item)
+        && (item.type === "additional_tools" || item.type === "tool_search_output")
+      ) addProviderExecutedCallTypes(callTypes, item.tools);
+    }
+  }
+  return callTypes;
+}
+
+function isAuthorizedProviderExecutedCall(
+  item: Record<string, unknown>,
+  callTypes: ProviderExecutedCallTypes,
+): boolean {
+  if (typeof item.call_id !== "string") return false;
+  for (const callType of callTypes) {
+    if (
+      item.type === callType.itemType
+      && item.call_id.startsWith(callType.callIdPrefix)
+    ) return true;
+  }
+  return false;
+}
+
 /** Nameless client-call item types authorized by supported request tool declarations. */
 export function collectDeclaredNamelessClientCallTypes(body: unknown): Set<string> {
   const callTypes = new Set<string>();
@@ -190,9 +260,14 @@ function undeclaredNameInItem(
   item: unknown,
   declared: ReadonlySet<string>,
   declaredNamelessClientCallTypes: ReadonlySet<string>,
+  providerExecutedCallTypes: ProviderExecutedCallTypes = EMPTY_PROVIDER_EXECUTED_CALL_TYPES,
 ): string | undefined {
   if (!isPlainObject(item)) return undefined;
   if (typeof item.type !== "string") return undefined;
+  // The provider executes this exact measured shape itself, so there is no client name to
+  // authorize. The caller supplies these signatures only for the matching destination and
+  // declarations; the item must additionally carry the hosted call-id prefix.
+  if (isAuthorizedProviderExecutedCall(item, providerExecutedCallTypes)) return undefined;
   const namelessDisplayName = NAMELESS_CLIENT_CALL_DISPLAY_NAMES.get(item.type);
   if (namelessDisplayName !== undefined) {
     // Only Codex's explicit `execution: "client"` form delegates tool search to the client.
@@ -202,10 +277,14 @@ function undeclaredNameInItem(
   if (!CLIENT_EXECUTED_CALL_TYPES.has(item.type)) return undefined;
   const name = item.name;
   if (typeof name !== "string" || name.length === 0) return undefined;
-  if (declared.has(name)) return undefined;
-  if (typeof item.namespace === "string" && declared.has(namespacedToolName(item.namespace, name))) {
-    return undefined;
+  if (typeof item.namespace === "string") {
+    // Namespaced calls are matched by their full wire name only — never legacy-normalize
+    // them, or an undeclared namespaced `exec_command` could slip through as bare `exec`.
+    if (declared.has(namespacedToolName(item.namespace, name))) return undefined;
+    return name;
   }
+  const effectiveName = normalizeDeclaredToolName(name, declared);
+  if (declared.has(effectiveName)) return undefined;
   return name;
 }
 
@@ -214,14 +293,15 @@ export function undeclaredToolCallName(
   payload: unknown,
   declared: ReadonlySet<string>,
   declaredNamelessClientCallTypes: ReadonlySet<string> = EMPTY_DECLARED_NAMELESS_CLIENT_CALL_TYPES,
+  providerExecutedCallTypes: ProviderExecutedCallTypes = EMPTY_PROVIDER_EXECUTED_CALL_TYPES,
 ): string | undefined {
   if (!isPlainObject(payload)) return undefined;
   if (payload.type === "response.output_item.added" || payload.type === "response.output_item.done") {
-    return undeclaredNameInItem(payload.item, declared, declaredNamelessClientCallTypes);
+    return undeclaredNameInItem(payload.item, declared, declaredNamelessClientCallTypes, providerExecutedCallTypes);
   }
   // Sparse gateways skip incremental items and only ever ship the terminal snapshot.
   if (payload.type === "response.completed" || payload.type === "response.incomplete") {
-    return undeclaredToolCallNameInResponse(payload.response, declared, declaredNamelessClientCallTypes);
+    return undeclaredToolCallNameInResponse(payload.response, declared, declaredNamelessClientCallTypes, providerExecutedCallTypes);
   }
   return undefined;
 }
@@ -231,10 +311,11 @@ export function undeclaredToolCallNameInResponse(
   response: unknown,
   declared: ReadonlySet<string>,
   declaredNamelessClientCallTypes: ReadonlySet<string> = EMPTY_DECLARED_NAMELESS_CLIENT_CALL_TYPES,
+  providerExecutedCallTypes: ProviderExecutedCallTypes = EMPTY_PROVIDER_EXECUTED_CALL_TYPES,
 ): string | undefined {
   if (!isPlainObject(response) || !Array.isArray(response.output)) return undefined;
   for (const item of response.output) {
-    const name = undeclaredNameInItem(item, declared, declaredNamelessClientCallTypes);
+    const name = undeclaredNameInItem(item, declared, declaredNamelessClientCallTypes, providerExecutedCallTypes);
     if (name !== undefined) return name;
   }
   return undefined;
@@ -274,6 +355,7 @@ function failedBlocks(name: string, newline: string): readonly string[] {
 export function createUndeclaredToolCallGuardBlockRewrite(
   declared: ReadonlySet<string>,
   declaredNamelessClientCallTypes: ReadonlySet<string> = EMPTY_DECLARED_NAMELESS_CLIENT_CALL_TYPES,
+  providerExecutedCallTypes: ProviderExecutedCallTypes = EMPTY_PROVIDER_EXECUTED_CALL_TYPES,
 ): SseBlockRewrite {
   let tripped = false;
   return (block: string) => {
@@ -286,7 +368,7 @@ export function createUndeclaredToolCallGuardBlockRewrite(
     } catch {
       return [block];
     }
-    const name = undeclaredToolCallName(parsed, declared, declaredNamelessClientCallTypes);
+    const name = undeclaredToolCallName(parsed, declared, declaredNamelessClientCallTypes, providerExecutedCallTypes);
     if (name === undefined) return [block];
     tripped = true;
     return failedBlocks(name, block.includes("\r\n") ? "\r\n" : "\n");

package/src/server/ws-bridge.ts

@@ -35,7 +35,8 @@ export interface WsData {
   cancel?: () => void; // cancels the in-flight stream reader/fetch
   turnId?: number; // monotonically increasing per socket; prevents stale frames after replacement turns
   /** Discriminator: Responses reframing vs transparent live/realtime sideband relay. */
-  kind?: "responses" | "live-sideband";
+  kind?: "responses" | "live-sideband" | "aistudio-relay";
+  aistudioSessionId?: string;
   liveUpstream?: WebSocket;
   liveUpstreamUrl?: string;
   liveUpstreamHeaders?: Record<string, string>;

package/src/service.ts

@@ -555,7 +555,7 @@ export function installedServiceListenPort(): number {
     ?? resolveServiceListenPort();
 }
 
-export const SERVICE_INSTALL_HEALTH_MS = 20_000;
+export const SERVICE_INSTALL_HEALTH_MS = Number(process.env.OCX_SERVICE_HEALTH_TIMEOUT_MS) || 30_000;
 
 /**
  * Whether a proxy actually answers on the port this install/start just produced.

package/src/smoke/fingerprint-cache.ts

@@ -0,0 +1,133 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { homedir } from "node:os";
+
+export interface SmokeCacheEntry {
+  fingerprint: string;
+  timestamp: number;
+  status: "passed" | "skipped" | "failed";
+  reason?: string;
+  modelsTested?: string[];
+}
+
+export interface SmokeCacheData {
+  version: number;
+  providers: Record<string, SmokeCacheEntry>;
+}
+
+const CACHE_VERSION = 1;
+
+export function defaultSmokeCachePath(): string {
+  return join(homedir(), ".opencodex", "live-inference-cache.json");
+}
+
+function defaultCachePath(customPath?: string): string {
+  return customPath ?? defaultSmokeCachePath();
+}
+
+function emptyCache(): SmokeCacheData {
+  return { version: CACHE_VERSION, providers: {} };
+}
+
+function walkTs(root: string, relDir: string): string[] {
+  const paths: string[] = [];
+  const fullDir = join(root, relDir);
+  if (!existsSync(fullDir)) return paths;
+  for (const entry of readdirSync(fullDir, { withFileTypes: true })) {
+    const relPath = join(relDir, entry.name);
+    if (entry.isDirectory()) {
+      paths.push(...walkTs(root, relPath));
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(".ts")) {
+      paths.push(relPath);
+    }
+  }
+  return paths;
+}
+
+function collectProviderSourcePaths(provider: string, root: string): string[] {
+  const smokePaths = ["src/smoke/runner.ts", "src/smoke/live-scenarios.ts"];
+  let paths: string[];
+  switch (provider) {
+    case "google":
+    case "google-antigravity":
+    case "google-aistudio":
+      paths = [...smokePaths, "src/adapters/google.ts", "src/adapters/google-wire-compiler.ts", "src/adapters/google-tool-schema.ts", "src/adapters/google-antigravity-wire.ts", "src/types/tools.ts", "src/server/responses-undeclared-tool-guard.ts"];
+      break;
+    case "cursor":
+      paths = [...smokePaths, "src/adapters/cursor.ts", ...walkTs(root, "src/adapters/cursor")];
+      break;
+    case "command-code":
+      paths = [...smokePaths, "src/adapters/command-code.ts", "src/adapters/command-code-project-context.ts", "src/providers/command-code-efforts.ts"];
+      break;
+    case "openai":
+    case "openai-responses":
+      paths = [...smokePaths, "src/adapters/openai-responses.ts", "src/adapters/responses-tool-schema.ts"];
+      break;
+    default:
+      paths = [...smokePaths, `src/adapters/${provider}.ts`];
+      break;
+  }
+  return [...new Set(paths)].filter(path => existsSync(join(root, path))).sort();
+}
+
+export async function computeProviderSourceFingerprint(
+  provider: string,
+  projectRoot?: string,
+): Promise<string> {
+  const root = resolve(projectRoot ?? process.cwd());
+  const hash = createHash("sha256");
+  const paths = collectProviderSourcePaths(provider, root);
+  if (paths.length === 0) return hash.update(`empty:${provider}`, "utf8").digest("hex");
+  for (const relPath of paths) {
+    hash.update(`${relPath}\0`, "utf8");
+    hash.update(readFileSync(join(root, relPath)));
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+
+export async function loadSmokeCache(customPath?: string): Promise<SmokeCacheData> {
+  const cachePath = defaultCachePath(customPath);
+  if (!existsSync(cachePath)) return emptyCache();
+  try {
+    const parsed = JSON.parse(readFileSync(cachePath, "utf8")) as SmokeCacheData;
+    if (typeof parsed !== "object" || parsed === null) return emptyCache();
+    return {
+      version: typeof parsed.version === "number" ? parsed.version : CACHE_VERSION,
+      providers: typeof parsed.providers === "object" && parsed.providers !== null ? parsed.providers : {},
+    };
+  } catch {
+    return emptyCache();
+  }
+}
+
+export async function saveSmokeCache(data: SmokeCacheData, customPath?: string): Promise<void> {
+  const cachePath = defaultCachePath(customPath);
+  mkdirSync(dirname(cachePath), { recursive: true });
+  writeFileSync(cachePath, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+}
+
+export function shouldRunSmokeForProvider(
+  provider: string,
+  currentFingerprint: string,
+  options?: { force?: boolean; cache?: SmokeCacheData },
+): boolean {
+  if (options?.force) return true;
+  const entry = options?.cache?.providers[provider];
+  if (!entry) return true;
+  if (entry.fingerprint !== currentFingerprint) return true;
+  return entry.status !== "passed";
+}
+
+export async function recordSmokeResult(
+  provider: string,
+  entry: SmokeCacheEntry,
+  customPath?: string,
+): Promise<void> {
+  const cache = await loadSmokeCache(customPath);
+  cache.providers[provider] = entry;
+  await saveSmokeCache(cache, customPath);
+}

package/src/smoke/live-scenarios.ts

@@ -0,0 +1,33 @@
+export type SmokeLevel = 1 | 2 | 3;
+
+export interface SmokeScenario {
+  level: SmokeLevel;
+  name: string;
+  buildRequest: (modelId: string, options?: { previousResponseId?: string; toolResult?: string }) => Record<string, unknown>;
+}
+
+export function buildSmokeScenarioRequest(
+  level: SmokeLevel,
+  modelId: string,
+  options: { previousResponseId?: string; toolCallId?: string; toolResult?: string } = {},
+): Record<string, unknown> {
+  const common = { model: modelId, stream: true };
+  if (level === 1) return {
+    ...common,
+    input: [{ role: "user", content: [{ type: "input_text", text: "Reply with exactly five words and include a brief reasoning process." }] }],
+  };
+  if (level === 2) return {
+    ...common,
+    input: [{ role: "user", content: [{ type: "input_text", text: "Use the provided exec_command tool to run echo \"smoke_test_123\"." }] }],
+    tools: [{ type: "function", name: "exec_command", description: "Execute a shell command.", parameters: { type: "object", properties: { cmd: { type: "string" } }, required: ["cmd"] } }],
+  };
+  return {
+    ...common,
+    ...(options.previousResponseId ? { previous_response_id: options.previousResponseId } : {}),
+    input: [{ type: "function_call_output", call_id: options.toolCallId ?? "smoke_call", output: options.toolResult ?? "smoke_test_123" }],
+  };
+}
+
+export const BasicStreamingTurn: SmokeScenario = { level: 1, name: "BasicStreamingTurn", buildRequest: (model, options) => buildSmokeScenarioRequest(1, model, options) };
+export const ToolCallingTurn: SmokeScenario = { level: 2, name: "ToolCallingTurn", buildRequest: (model, options) => buildSmokeScenarioRequest(2, model, options) };
+export const MultiTurnContinuity: SmokeScenario = { level: 3, name: "MultiTurnContinuity", buildRequest: (model, options) => buildSmokeScenarioRequest(3, model, options) };