@bitkyc08/opencodex 2.7.38-preview.20260724 → 2.7.39

package/src/combos/resolve.ts

@@ -143,13 +143,18 @@ export function noteComboFailure(comboId: string, target: OcxComboTarget): void
 export function advanceComboAfterFailure(
   config: OcxConfig,
   pick: ComboPick,
-  options: { retryAfter?: string | null; now?: number } = {},
+  options: {
+    retryAfter?: string | null;
+    now?: number;
+    eligible?: (target: Required<OcxComboTarget>) => boolean;
+  } = {},
 ): ComboPick | null {
   noteComboFailure(pick.comboId, pick.target);
   coolComboTarget(pick.comboId, pick.target, options);
   return pickComboTarget(config, pick.comboId, {
     exclude: pick.attempted,
-    eligible: target => !isComboTargetInCooldown(pick.comboId, target, options.now),
+    eligible: target => !isComboTargetInCooldown(pick.comboId, target, options.now)
+      && (options.eligible?.(target) ?? true),
   });
 }
 

package/src/config.ts

@@ -442,6 +442,7 @@ const configSchema = z.object({
   providerContextCaps: z.record(z.string(), z.number().int().positive()).optional(),
   contextCapValue: z.number().int().positive().optional(),
   multiAgentGuidanceEnabled: z.boolean().optional(),
+  codexShimAutoRestore: z.boolean().optional(),
   // Invalid values degrade to undefined ("auto") instead of failing the whole
   // parse: a hand-edited typo must never trip the backup-and-defaults repair
   // path below and wipe providers/pool accounts. Warning emitted in loadConfig.
@@ -793,6 +794,15 @@ export function codexAutoStartEnabled(config: Pick<OcxConfig, "codexAutoStart">)
   return config.codexAutoStart !== false;
 }
 
+export const CODEX_SHIM_AUTO_RESTORE_ENV = "OPENCODEX_CODEX_SHIM_AUTO_RESTORE";
+
+export function codexShimAutoRestoreEnabled(
+  config: Pick<OcxConfig, "codexShimAutoRestore">,
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  return config.codexShimAutoRestore !== false && env[CODEX_SHIM_AUTO_RESTORE_ENV] !== "0";
+}
+
 export function multiAgentGuidanceEnabled(
   config: Pick<OcxConfig, "multiAgentGuidanceEnabled">,
 ): boolean {
@@ -822,6 +832,7 @@ export function getDefaultConfig(): OcxConfig {
     multiAgentGuidanceEnabled: true,
     websockets: false,
     codexAutoStart: true,
+    codexShimAutoRestore: true,
   };
 }
 

package/src/lib/sse-decoder.ts

@@ -3,6 +3,10 @@ export interface ServerSentEvent {
   data: string;
 }
 
+export type SseRecord =
+  | { kind: "event"; event?: string; data: string }
+  | { kind: "comment"; comment: string };
+
 /**
  * Decode text/event-stream records across arbitrary fetch chunk boundaries.
  *
@@ -10,10 +14,18 @@ export interface ServerSentEvent {
  * final newline. That matters for compatible APIs that place a terminal event in the last bytes of
  * the body: dropping that record turns a successful response into an adapter_eof failure.
  */
+export function decodeServerSentEvents(
+  source: ReadableStream<Uint8Array>,
+  options: { includeComments: true; signal?: AbortSignal },
+): AsyncGenerator<SseRecord>;
+export function decodeServerSentEvents(
+  source: ReadableStream<Uint8Array>,
+  options?: { includeComments?: false; signal?: AbortSignal },
+): AsyncGenerator<ServerSentEvent>;
 export async function* decodeServerSentEvents(
   source: ReadableStream<Uint8Array>,
-  options?: { signal?: AbortSignal },
-): AsyncGenerator<ServerSentEvent> {
+  options?: { includeComments?: boolean; signal?: AbortSignal },
+): AsyncGenerator<ServerSentEvent | SseRecord> {
   const reader = source.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
@@ -27,7 +39,9 @@ export async function* decodeServerSentEvents(
   if (signal?.aborted) onAbort();
   else signal?.addEventListener("abort", onAbort, { once: true });
 
-  const dispatch = (): ServerSentEvent | undefined => {
+  const includeComments = options?.includeComments === true;
+
+  const dispatch = (): ServerSentEvent | SseRecord | undefined => {
     if (dataLines.length === 0) {
       event = undefined;
       return undefined;
@@ -35,13 +49,18 @@ export async function* decodeServerSentEvents(
     const record = { ...(event ? { event } : {}), data: dataLines.join("\n") };
     event = undefined;
     dataLines = [];
-    return record;
+    return includeComments ? { kind: "event", ...record } : record;
   };
 
-  const acceptLine = (rawLine: string): ServerSentEvent | undefined => {
+  const acceptLine = (rawLine: string): ServerSentEvent | SseRecord | undefined => {
     const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
     if (line === "") return dispatch();
-    if (line.startsWith(":")) return undefined;
+    if (line.startsWith(":")) {
+      if (!includeComments) return undefined;
+      let comment = line.slice(1);
+      if (comment.startsWith(" ")) comment = comment.slice(1);
+      return { kind: "comment", comment };
+    }
 
     const colon = line.indexOf(":");
     const field = colon < 0 ? line : line.slice(0, colon);

package/src/responses/parser.ts

@@ -129,7 +129,7 @@ function buildTools(tools: unknown[] | undefined): OcxTool[] | undefined {
       out.push({
         name: t.name,
         description: (t.description as string) ?? "",
-        parameters: { type: "object", properties: { input: { type: "string", description: "Raw tool input (verbatim body, e.g. the apply_patch envelope)." } }, required: ["input"] },
+        parameters: { type: "object", properties: { input: { type: "string", description: "Raw tool input. For apply_patch, begin exactly with `*** Begin Patch` (no trailing `***`), then use its standard patch envelope." } }, required: ["input"] },
         freeform: true,
       });
     }

package/src/responses/state.ts

@@ -241,9 +241,13 @@ export function previousResponseProviderState(responseId: string | undefined): O
   return providers ? structuredClone(providers) : undefined;
 }
 
+/**
+ * Cache completed output and max_output_tokens partial output for previous_response_id replay.
+ * Content-filtered incomplete and failed output are not authoritative replay history.
+ */
 export function rememberResponseState(
   requestBody: unknown,
-  response: { id?: unknown; output?: unknown; status?: unknown },
+  response: { id?: unknown; output?: unknown; status?: unknown; incomplete_details?: unknown },
   providerState?: OcxProviderContinuationState | string,
   opts?: { force?: boolean },
 ): void {
@@ -256,7 +260,11 @@ export function rememberResponseState(
   // real server-side response storage.
   if (request.store === false && !opts?.force) return;
   if (typeof response.id !== "string" || !Array.isArray(response.output)) return;
-  if (response.status !== undefined && response.status !== "completed") return;
+  if (response.status === "incomplete") {
+    const details = response.incomplete_details;
+    if (!details || typeof details !== "object" || Array.isArray(details)
+      || (details as { reason?: unknown }).reason !== "max_output_tokens") return;
+  } else if (response.status !== undefined && response.status !== "completed") return;
   ensureLoaded();
   const normalizedProviderState: OcxProviderContinuationState = typeof providerState === "string"
     ? { cursor: { conversationId: providerState } }

package/src/server/auth-cors.ts

@@ -80,7 +80,10 @@ export function corsHeaders(req?: Request, config?: OcxConfig): Record<string, s
   return {
     "Access-Control-Allow-Origin": allowOrigin,
     "Access-Control-Allow-Methods": "GET, POST, PUT, PATCH, DELETE, OPTIONS",
-    "Access-Control-Allow-Headers": "Content-Type, Authorization, X-OpenCodex-API-Key, X-Api-Key, Anthropic-Version, Anthropic-Beta",
+    // ChatGPT-Account-Id is required for browser/Electron ChatGPT & Codex App voice preflights
+    // (direct forward auth matches the bearer to this account id). The OpenAI-Alpha .. X-OAI-Attestation
+    // block covers GPT-Live voice protocol headers relayed by the /v1/live call-create path.
+    "Access-Control-Allow-Headers": "Content-Type, Authorization, X-OpenCodex-API-Key, X-Api-Key, Anthropic-Version, Anthropic-Beta, ChatGPT-Account-Id, OpenAI-Alpha, X-Session-Id, Session-Id, Thread-Id, Originator, X-OAI-Attestation",
     "Vary": "Origin",
   };
 }

package/src/server/index.ts

@@ -122,11 +122,90 @@ import { handleChatCompletions } from "./chat-completions";
 import { anthropicErrorResponse } from "../claude/outbound";
 import { buildDesktop3pRegistry } from "../claude/desktop-3p";
 import { handleImages } from "./images";
+import { handleLive, parseLiveSidebandTarget, resolveLiveSidebandUpgrade } from "./live";
 import { handleSearch } from "./search";
 import { fetchAllModels, handleManagementAPI, VERSION } from "./management-api";
 
 const MAX_WS_FRAME_BYTES = 50 * 1024 * 1024;
 const WEBSOCKET_IDLE_TIMEOUT_SECONDS = 0;
+const LIVE_SIDEBAND_PENDING_MAX = 32;
+
+function closeLiveSideband(ws: ServerWebSocket<WsData>, code = 1000, reason = ""): void {
+  try {
+    ws.data.liveUpstream?.close(code, reason);
+  } catch {
+    /* upstream already gone */
+  }
+  ws.data.liveUpstream = undefined;
+  ws.data.livePending = undefined;
+  try {
+    if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+      ws.close(code, reason);
+    }
+  } catch {
+    /* client already gone */
+  }
+}
+
+function attachLiveSidebandUpstream(ws: ServerWebSocket<WsData>): void {
+  const url = ws.data.liveUpstreamUrl;
+  if (!url) {
+    closeLiveSideband(ws, 1011, "missing upstream");
+    return;
+  }
+  let upstream: WebSocket;
+  try {
+    // Bun accepts per-handshake headers; the DOM lib types only list protocol arrays.
+    upstream = new WebSocket(url, { headers: ws.data.liveUpstreamHeaders ?? {} } as unknown as string[]);
+  } catch {
+    closeLiveSideband(ws, 1011, "upstream connect failed");
+    return;
+  }
+  ws.data.liveUpstream = upstream;
+  ws.data.cancel = () => {
+    try {
+      upstream.close(1000, "client closed");
+    } catch {
+      /* ignore */
+    }
+  };
+
+  upstream.addEventListener("open", () => {
+    ws.data.liveOpened = true;
+    const pending = ws.data.livePending ?? [];
+    ws.data.livePending = undefined;
+    for (const frame of pending) {
+      try {
+        upstream.send(frame);
+      } catch {
+        closeLiveSideband(ws, 1011, "upstream send failed");
+        return;
+      }
+    }
+  });
+  upstream.addEventListener("message", (event) => {
+    try {
+      if (typeof event.data === "string") ws.send(event.data);
+      else if (event.data instanceof ArrayBuffer) ws.send(event.data);
+      else if (ArrayBuffer.isView(event.data)) {
+        ws.send(event.data.buffer.slice(event.data.byteOffset, event.data.byteOffset + event.data.byteLength));
+      } else ws.send(event.data as Buffer);
+    } catch {
+      closeLiveSideband(ws, 1011, "client send failed");
+    }
+  });
+  upstream.addEventListener("close", (event) => {
+    try {
+      ws.close(event.code || 1000, event.reason || "");
+    } catch {
+      /* ignore */
+    }
+    ws.data.liveUpstream = undefined;
+  });
+  upstream.addEventListener("error", () => {
+    closeLiveSideband(ws, 1011, "upstream error");
+  });
+}
 
 // GUI static serving extracted to ./server/gui-static. Re-exported below to keep the
 // "../src/server" import surface stable for tests/callers.
@@ -498,6 +577,77 @@ export function startServer(port?: number) {
         return withCors(response, req, config);
       }
 
+      // ChatGPT / Codex App voice (GPT‑Live / Frameless Bidi) + OpenAI Realtime call-create.
+      // Clients hit either /v1/live (Frameless App) or /v1/realtime/calls (codex RealtimeCallClient /
+      // public Realtime API). Sideband WS joins are handled just below.
+      if (
+        req.method === "POST"
+        && (url.pathname === "/v1/live" || url.pathname === "/v1/realtime/calls")
+      ) {
+        disableResponsesRequestTimeout(req, requestServer);
+        if (isDraining()) {
+          return new Response("Service shutting down", {
+            status: 503,
+            headers: { ...corsHeaders(req, config), "Retry-After": "5" },
+          });
+        }
+        const apiAuthError = requireApiAuth(req, config, "data-plane");
+        if (apiAuthError) return withCors(apiAuthError, req, config);
+        if (!isAllowedRequestOrigin(req, config)) {
+          return withCors(formatErrorResponse(403, "origin_rejected", "cross-origin data-plane request blocked"), req, config);
+        }
+        const start = Date.now();
+        const requestId = nextRequestLogId(start);
+        const logCtx: RequestLogContext = { model: "gpt-live", provider: "unknown" };
+        const response = await handleLive(req, config, logCtx);
+        addFinalRequestLog(
+          requestId,
+          start,
+          logCtx,
+          response.status,
+          response.status === 499 ? { closeReason: "client_cancel" } : undefined,
+        );
+        return withCors(response, req, config);
+      }
+
+      // Voice / Realtime sideband WebSocket: Frameless joins /v1/live/{callId}; Realtime v1 joins
+      // /v1/realtime?call_id= (or /v1/realtime/calls/{callId}). Transparent bidirectional relay.
+      const liveSidebandTarget = req.headers.get("upgrade")?.toLowerCase() === "websocket"
+        ? parseLiveSidebandTarget(url.pathname, url.searchParams)
+        : null;
+      if (liveSidebandTarget) {
+        if (isDraining()) {
+          return new Response("Service shutting down", {
+            status: 503,
+            headers: { ...corsHeaders(req, config), "Retry-After": "5" },
+          });
+        }
+        const apiAuthError = requireApiAuth(req, config, "data-plane");
+        if (apiAuthError) return withCors(apiAuthError, req, config);
+        if (!isAllowedRequestOrigin(req, config)) {
+          return withCors(formatErrorResponse(403, "origin_rejected", "WebSocket upgrade blocked: non-local Origin"), req, config);
+        }
+        const start = Date.now();
+        const requestId = nextRequestLogId(start);
+        const logCtx: RequestLogContext = { model: "gpt-live", provider: "unknown" };
+        const resolved = await resolveLiveSidebandUpgrade(req, config, logCtx, liveSidebandTarget);
+        if (resolved instanceof Response) {
+          addFinalRequestLog(requestId, start, logCtx, resolved.status);
+          return withCors(resolved, req, config);
+        }
+        addFinalRequestLog(requestId, start, logCtx, 101);
+        if (server.upgrade(req, {
+          data: {
+            kind: "live-sideband",
+            liveUpstreamUrl: resolved.upstreamWsUrl,
+            liveUpstreamHeaders: resolved.headers,
+            livePending: [],
+            liveOpened: false,
+          } satisfies WsData,
+        })) return undefined as unknown as Response;
+        return withCors(formatErrorResponse(426, "upgrade_required", "WebSocket upgrade failed"), req, config);
+      }
+
       // Data-plane guard: unknown /v1/* paths must fail with JSON 404, never fall through to the
       // GUI static handler (extensionless paths would get index.html with HTTP 200 and codex-rs
       // endpoint clients — memories/*, realtime/* — would surface confusing
@@ -519,10 +669,37 @@ export function startServer(port?: number) {
       // Responses WebSocket data plane (phase 120.2). Re-frames the same SSE pipeline onto the
       // socket: parse response.create → run handleResponses unchanged → pump its SSE body as WS
       // Text frames. response.processed is a no-op ack. close() aborts the upstream (RC2 parity).
+      // Live sideband sockets (kind=live-sideband) are a transparent bidirectional relay instead.
       open(ws: ServerWebSocket<WsData>) {
+        if (ws.data.kind === "live-sideband") {
+          attachLiveSidebandUpstream(ws);
+          return;
+        }
         registerCodexWebSocket(ws);
       },
       message(ws: ServerWebSocket<WsData>, raw: string | Buffer) {
+        if (ws.data.kind === "live-sideband") {
+          const upstream = ws.data.liveUpstream;
+          if (!upstream || upstream.readyState === WebSocket.CONNECTING || !ws.data.liveOpened) {
+            const pending = ws.data.livePending ?? (ws.data.livePending = []);
+            if (pending.length >= LIVE_SIDEBAND_PENDING_MAX) {
+              closeLiveSideband(ws, 1009, "too many pending frames");
+              return;
+            }
+            pending.push(raw);
+            return;
+          }
+          if (upstream.readyState !== WebSocket.OPEN) {
+            closeLiveSideband(ws, 1011, "upstream not open");
+            return;
+          }
+          try {
+            upstream.send(raw);
+          } catch {
+            closeLiveSideband(ws, 1011, "upstream send failed");
+          }
+          return;
+        }
         const rawBytes = typeof raw === "string" ? Buffer.byteLength(raw) : raw.byteLength;
         if (rawBytes > MAX_WS_FRAME_BYTES) {
           sendJsonFrame(ws, buildWsErrorFrame(413, {
@@ -639,6 +816,11 @@ export function startServer(port?: number) {
         })();
       },
       close(ws: ServerWebSocket<WsData>) {
+        if (ws.data.kind === "live-sideband") {
+          ws.data.cancel?.();
+          ws.data.liveUpstream = undefined;
+          return;
+        }
         unregisterCodexWebSocket(ws);
         ws.data.cancel?.(); // RC2: abort the upstream when the client disconnects
       },