@bitkyc08/opencodex 0.2.2 → 1.9.0

package/src/server.ts

@@ -6,7 +6,17 @@ import { createGoogleAdapter } from "./adapters/google";
 import { createOpenAIChatAdapter } from "./adapters/openai-chat";
 import { createResponsesPassthroughAdapter } from "./adapters/openai-responses";
 import { bridgeToResponsesSSE, buildResponseJSON, formatErrorResponse } from "./bridge";
-import { DEFAULT_SUBAGENT_MODELS, loadConfig, saveConfig } from "./config";
+import {
+  buildWarmupCompletionFrames,
+  buildWsErrorFrame,
+  selectForwardHeaders,
+  sendJsonFrame,
+  sendResponseToWebSocket,
+  sendTextFrame,
+  type WsData,
+} from "./ws-bridge";
+import type { ServerWebSocket } from "bun";
+import { DEFAULT_SUBAGENT_MODELS, loadConfig, saveConfig, websocketsEnabled } from "./config";
 import { parseRequest } from "./responses/parser";
 import { routeModel } from "./router";
 import { namespacedToolName } from "./types";
@@ -19,6 +29,7 @@ import { buildWebSearchTool, planWebSearch, runWithWebSearch } from "./web-searc
 import { describeImagesInPlace, planVisionSidecar } from "./vision";
 import { removeCredential } from "./oauth/store";
 import { enrichProviderFromCatalog, listKeyLoginProviders } from "./oauth/key-providers";
+import { deriveProviderPresets } from "./providers/derive";
 import type { OcxConfig, OcxProviderConfig } from "./types";
 
 const VERSION = "0.0.1";
@@ -67,7 +78,7 @@ function serveGuiFile(pathname: string): Response | null {
   });
 }
 
-function resolveAdapter(providerConfig: OcxProviderConfig) {
+export function resolveAdapter(providerConfig: OcxProviderConfig) {
   switch (providerConfig.adapter) {
     case "openai-chat":
       return createOpenAIChatAdapter(providerConfig);
@@ -77,6 +88,7 @@ function resolveAdapter(providerConfig: OcxProviderConfig) {
       return createResponsesPassthroughAdapter(providerConfig);
     case "google":
       return createGoogleAdapter(providerConfig);
+    case "azure":
     case "azure-openai":
       return createAzureAdapter(providerConfig);
     default:
@@ -84,7 +96,12 @@ function resolveAdapter(providerConfig: OcxProviderConfig) {
   }
 }
 
-async function handleResponses(req: Request, config: OcxConfig, logCtx: { model: string; provider: string }): Promise<Response> {
+async function handleResponses(
+  req: Request,
+  config: OcxConfig,
+  logCtx: { model: string; provider: string },
+  options: { forceEmptyResponseId?: boolean; abortSignal?: AbortSignal } = {},
+): Promise<Response> {
   let body: unknown;
   try {
     body = await req.json();
@@ -133,24 +150,30 @@ async function handleResponses(req: Request, config: OcxConfig, logCtx: { model:
   // with text BEFORE the main call, so the text-only model can reason about it.
   const visionPlan = planVisionSidecar(config, route.provider, route.modelId, parsed, req.headers);
   if (visionPlan) {
-    await describeImagesInPlace(parsed, visionPlan.forwardProvider, req.headers, visionPlan.settings);
+    await describeImagesInPlace(parsed, visionPlan.forwardProvider, req.headers, visionPlan.settings, options.abortSignal);
   }
 
   const adapter = resolveAdapter(route.provider);
 
   if ("passthrough" in adapter && adapter.passthrough) {
     const request = adapter.buildRequest(parsed, { headers: req.headers });
+    // Abort the upstream if the client disconnects. A directly-relayed body does not propagate the
+    // consumer's cancel to a signalled fetch, so we pass the signal and relay through relayWithAbort,
+    // whose cancel() aborts the upstream — preventing leaked connections (RC2, passthrough path).
+    const upstream = new AbortController();
+    linkAbortSignal(upstream, options.abortSignal);
     let upstreamResponse: Response;
     try {
       upstreamResponse = await fetch(request.url, {
         method: request.method,
         headers: request.headers,
         body: request.body,
+        signal: upstream.signal,
       });
     } catch (err) {
       return formatErrorResponse(502, "upstream_error", `Provider unreachable: ${err instanceof Error ? err.message : String(err)}`);
     }
-    return new Response(upstreamResponse.body, {
+    return new Response(relayWithAbort(upstreamResponse.body, upstream), {
       status: upstreamResponse.status,
       headers: sanitizePassthroughHeaders(upstreamResponse.headers),
     });
@@ -169,17 +192,23 @@ async function handleResponses(req: Request, config: OcxConfig, logCtx: { model:
       incomingHeaders: req.headers,
       settings: wsPlan.settings,
       maxSearches: wsPlan.maxSearches,
+      abortSignal: options.abortSignal,
     });
   }
 
   const request = adapter.buildRequest(parsed, { headers: req.headers });
 
+  // Abort the upstream fetch if the client (Codex) disconnects mid-stream, so a cancelled turn does
+  // not leak the upstream connection or keep draining tokens. The bridge's cancel() fires upstream.abort() (RC2).
+  const upstream = new AbortController();
+  linkAbortSignal(upstream, options.abortSignal);
   let upstreamResponse: Response;
   try {
     upstreamResponse = await fetch(request.url, {
       method: request.method,
       headers: request.headers,
       body: request.body,
+      signal: upstream.signal,
     });
   } catch (err) {
     return formatErrorResponse(502, "upstream_error", `Provider unreachable: ${err instanceof Error ? err.message : String(err)}`);
@@ -202,7 +231,16 @@ async function handleResponses(req: Request, config: OcxConfig, logCtx: { model:
       if (t.freeform) freeformToolNames.add(t.name);
       if (t.toolSearch) toolSearchToolNames.add(t.name);
     }
-    const sseStream = bridgeToResponsesSSE(eventStream, parsed.modelId, toolNsMap, freeformToolNames, toolSearchToolNames);
+    const sseStream = bridgeToResponsesSSE(
+      eventStream,
+      parsed.modelId,
+      toolNsMap,
+      freeformToolNames,
+      toolSearchToolNames,
+      () => upstream.abort(),
+      2_000,
+      options.forceEmptyResponseId ? { responseId: "" } : undefined,
+    );
     return new Response(sseStream, {
       headers: {
         "Content-Type": "text/event-stream",
@@ -224,6 +262,15 @@ async function handleResponses(req: Request, config: OcxConfig, logCtx: { model:
   return formatErrorResponse(500, "internal_error", "Non-streaming not supported by this adapter");
 }
 
+export function linkAbortSignal(upstream: AbortController, signal?: AbortSignal): void {
+  if (!signal) return;
+  if (signal.aborted) {
+    upstream.abort(signal.reason);
+    return;
+  }
+  signal.addEventListener("abort", () => upstream.abort(signal.reason), { once: true });
+}
+
 const requestLog: { timestamp: number; model: string; provider: string; status: number; durationMs: number }[] = [];
 const MAX_LOG_SIZE = 200;
 
@@ -232,6 +279,39 @@ function addRequestLog(entry: typeof requestLog[number]) {
   if (requestLog.length > MAX_LOG_SIZE) requestLog.shift();
 }
 
+/**
+ * Relay an upstream body verbatim while wiring client-cancel -> upstream.abort(). A body returned
+ * directly from fetch does NOT propagate the consumer's cancel to a signalled fetch, so a client
+ * disconnect would leak the upstream connection. Pumping through this stream (whose cancel() aborts
+ * the upstream) fixes the leak with zero byte changes — passthrough fidelity is preserved (RC2).
+ */
+export function relayWithAbort(
+  body: ReadableStream<Uint8Array> | null,
+  upstream: AbortController,
+): ReadableStream<Uint8Array> | null {
+  if (!body) return null;
+  const reader = body.getReader();
+  return new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(value);
+      } catch (err) {
+        try { controller.error(err); } catch { /* already torn down */ }
+      }
+    },
+    cancel(reason) {
+      // Client disconnected: abort the upstream fetch and release the reader so we do not leak it.
+      upstream.abort(reason);
+      reader.cancel(reason).catch(() => {});
+    },
+  });
+}
+
 /**
  * Bun's fetch auto-decompresses the response body but leaves the upstream `content-encoding`
  * (and a now-stale `content-length`) on `response.headers`. Relaying those with the already-decoded
@@ -239,7 +319,18 @@ function addRequestLog(entry: typeof requestLog[number]) {
  * Drop encoding + hop-by-hop headers; relay everything else (content-type, etc.) verbatim.
  */
 export function sanitizePassthroughHeaders(upstream: Headers): Headers {
-  const DROP = new Set(["content-encoding", "content-length", "transfer-encoding", "connection", "keep-alive"]);
+  const DROP = new Set([
+    "content-encoding",
+    "content-length",
+    "transfer-encoding",
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "upgrade",
+  ]);
   const out = new Headers();
   upstream.forEach((value, key) => {
     if (!DROP.has(key.toLowerCase())) out.set(key, value);
@@ -361,6 +452,12 @@ async function handleManagementAPI(req: Request, url: URL, config: OcxConfig): P
     return jsonResponse({ providers: listKeyLoginProviders() });
   }
 
+  // Complete GUI picker presets, derived from the canonical provider registry. The GUI is a
+  // standalone Vite package, so it consumes this runtime view instead of importing repo-root src.
+  if (url.pathname === "/api/provider-presets" && req.method === "GET") {
+    return jsonResponse({ providers: deriveProviderPresets() });
+  }
+
   // Subagent model picker: which ≤5 routed models Codex's spawn_agent advertises (it shows the
   // first 5 routed catalog entries). PUT reorders the injected catalog so the chosen ones lead.
   if (url.pathname === "/api/subagent-models" && req.method === "GET") {
@@ -452,7 +549,7 @@ export function startServer(port?: number) {
   }
   const listenPort = port ?? config.port ?? 10100;
 
-  const server = Bun.serve({
+  const server = Bun.serve<WsData>({
     port: listenPort,
     async fetch(req) {
       const url = new URL(req.url);
@@ -461,6 +558,13 @@ export function startServer(port?: number) {
         return new Response(null, { status: 204, headers: corsHeaders() });
       }
 
+      // Responses WebSocket (phase 120.2). Codex upgrades the same /v1/responses path; auth is
+      // handshake-time only, so capture inbound headers and thread them into the pipeline.
+      if (url.pathname === "/v1/responses" && req.headers.get("upgrade")?.toLowerCase() === "websocket") {
+        if (server.upgrade(req, { data: { headers: selectForwardHeaders(req.headers) } })) return undefined as unknown as Response;
+        return formatErrorResponse(426, "upgrade_required", "WebSocket upgrade failed");
+      }
+
       if (url.pathname === "/healthz" && req.method === "GET") {
         return jsonResponse({ status: "ok", version: VERSION, uptime: process.uptime() });
       }
@@ -481,7 +585,7 @@ export function startServer(port?: number) {
           // Codex client → Codex catalog shape: native gpt + namespaced routed models,
           // cloned from a native template so required fields (base_instructions, etc.) are present.
           // Pass the subagent picks so featured models lead by priority (matches the on-disk file).
-          return jsonResponse({ models: buildCatalogEntries(loadCatalogTemplate(), nativeSlugs, goOrdered, config.subagentModels) });
+          return jsonResponse({ models: buildCatalogEntries(loadCatalogTemplate(), nativeSlugs, goOrdered, config.subagentModels, websocketsEnabled(config)) });
         }
         // OpenAI list shape: native gpt bare + routed models namespaced "<provider>/<id>"
         const data = [
@@ -510,6 +614,75 @@ export function startServer(port?: number) {
 
       return formatErrorResponse(404, "not_found", `Unknown endpoint: ${req.method} ${url.pathname}`);
     },
+    websocket: {
+      // 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).
+      message(ws: ServerWebSocket<WsData>, raw: string | Buffer) {
+        let frame: Record<string, unknown>;
+        try {
+          frame = JSON.parse(typeof raw === "string" ? raw : raw.toString()) as Record<string, unknown>;
+        } catch {
+          return; // text-only contract; ignore unparseable frames
+        }
+        if (frame.type === "response.processed") return; // ack — no-op
+        if (frame.type !== "response.create") return;
+
+        ws.data.cancel?.();
+        const turnId = (ws.data.turnId ?? 0) + 1;
+        ws.data.turnId = turnId;
+        const isCurrent = () => ws.data.turnId === turnId;
+        const turnAbort = new AbortController();
+        const cancelTurn = () => {
+          turnAbort.abort("websocket turn superseded or closed");
+        };
+        ws.data.cancel = cancelTurn;
+
+        if (frame.generate === false) {
+          for (const payload of buildWarmupCompletionFrames(frame)) {
+            if (!isCurrent()) return;
+            sendTextFrame(ws, payload);
+          }
+          if (ws.data.cancel === cancelTurn) ws.data.cancel = undefined;
+          return;
+        }
+
+        const payload: Record<string, unknown> = { ...frame };
+        delete payload.type;
+        void (async () => {
+          const logCtx = { model: "unknown", provider: "unknown" };
+          const fwd = new Headers({ "content-type": "application/json" });
+          ws.data.headers?.forEach((value, key) => fwd.set(key, value));
+          const req = new Request("http://localhost/v1/responses", {
+            method: "POST",
+            headers: fwd,
+            body: JSON.stringify({ ...payload, stream: true }),
+          });
+          try {
+            const response = await handleResponses(req, config, logCtx, {
+              forceEmptyResponseId: true,
+              abortSignal: turnAbort.signal,
+            });
+            await sendResponseToWebSocket(ws, response, isCurrent);
+          } catch (err) {
+            if (!isCurrent()) return;
+            try {
+              sendJsonFrame(ws, buildWsErrorFrame(502, {
+                type: "proxy_error",
+                message: err instanceof Error ? err.message : String(err),
+              }));
+            } catch {
+              /* socket already gone or send dropped */
+            }
+          } finally {
+            if (ws.data.cancel === cancelTurn) ws.data.cancel = undefined;
+          }
+        })();
+      },
+      close(ws: ServerWebSocket<WsData>) {
+        ws.data.cancel?.(); // RC2: abort the upstream when the client disconnects
+      },
+    },
   });
 
   console.log(`🚀 opencodex proxy running on http://localhost:${listenPort}`);

package/src/types.ts

@@ -1,5 +1,6 @@
 export interface OcxParsedRequest {
   modelId: string;
+  previousResponseId?: string;
   context: OcxContext;
   stream: boolean;
   options: OcxRequestOptions;
@@ -149,6 +150,7 @@ export interface OcxRequestOptions {
 export type AdapterEvent =
   | { type: "text_delta"; text: string }
   | { type: "thinking_delta"; thinking: string }
+  | { type: "reasoning_raw_delta"; text: string }
   | { type: "tool_call_start"; id: string; name: string }
   | { type: "tool_call_delta"; arguments: string }
   | { type: "tool_call_end" }
@@ -158,6 +160,8 @@ export type AdapterEvent =
 export interface OcxUsage {
   inputTokens: number;
   outputTokens: number;
+  cachedInputTokens?: number;
+  reasoningOutputTokens?: number;
 }
 
 export interface OcxConfig {
@@ -171,6 +175,8 @@ export interface OcxConfig {
   subagentModels?: string[];
   /** Routed model ids ("<provider>/<model>") hidden from Codex (excluded from the catalog + /v1/models). */
   disabledModels?: string[];
+  /** Advertise supports_websockets so Codex opens the WS endpoint. Default false; set true to opt into WS. */
+  websockets?: boolean;
   /** Freshness window (ms) for the per-provider live `/models` cache. Defaults to 5 min. */
   modelCacheTtlMs?: number;
   /** Web-search sidecar: route web_search for non-OpenAI models through a gpt-mini via ChatGPT passthrough. */

package/src/vision/describe.ts

@@ -1,5 +1,6 @@
 import type { OcxProviderConfig } from "../types";
 import { FORWARD_HEADERS } from "../adapters/openai-responses";
+import { signalWithTimeout } from "../abort";
 import { parseSidecarSSE } from "../web-search/parse";
 
 export interface VisionSettings {
@@ -48,6 +49,7 @@ export async function describeImage(
   forwardProvider: OcxProviderConfig,
   incomingHeaders: Headers,
   settings: VisionSettings,
+  abortSignal?: AbortSignal,
 ): Promise<DescribeOutcome> {
   const invalid = validateImageUrl(imageUrl);
   if (invalid) return { text: "", error: invalid };
@@ -76,12 +78,13 @@ export async function describeImage(
     store: false,
     stream: true,
   };
+  const linkedSignal = signalWithTimeout(settings.timeoutMs, abortSignal);
   try {
     const res = await fetch(`${forwardProvider.baseUrl}/responses`, {
       method: "POST",
       headers,
       body: JSON.stringify(body),
-      signal: AbortSignal.timeout(settings.timeoutMs),
+      signal: linkedSignal.signal,
     });
     if (!res.ok) {
       const t = await res.text().catch(() => "");
@@ -94,5 +97,7 @@ export async function describeImage(
     return { text: parsed.text };
   } catch (e) {
     return { text: "", error: e instanceof Error ? e.message : String(e) };
+  } finally {
+    linkedSignal.cleanup();
   }
 }

package/src/vision/index.ts

@@ -107,6 +107,7 @@ export async function describeImagesInPlace(
   forwardProvider: OcxProviderConfig,
   incomingHeaders: Headers,
   settings: VisionSettings,
+  abortSignal?: AbortSignal,
 ): Promise<void> {
   // 1. Gather every image part across messages, each with its own message's text as context.
   const jobs: ImageJob[] = [];
@@ -129,7 +130,7 @@ export async function describeImagesInPlace(
 
   // 2. Describe all images with bounded concurrency (order preserved).
   const outcomes = await runBounded(jobs, VISION_CONCURRENCY, j =>
-    describeImage(j.imageUrl, j.detail, j.contextText, forwardProvider, incomingHeaders, settings));
+    describeImage(j.imageUrl, j.detail, j.contextText, forwardProvider, incomingHeaders, settings, abortSignal));
 
   // 3. Rebuild each message, replacing image parts with their descriptions in order.
   let oi = 0;

package/src/web-search/executor.ts

@@ -1,5 +1,6 @@
 import type { OcxProviderConfig } from "../types";
 import { FORWARD_HEADERS } from "../adapters/openai-responses";
+import { signalWithTimeout } from "../abort";
 import { parseSidecarSSE, type WebSearchResult } from "./parse";
 
 export interface SidecarSettings {
@@ -36,6 +37,7 @@ export async function runWebSearch(
   forwardProvider: OcxProviderConfig,
   incomingHeaders: Headers,
   settings: SidecarSettings,
+  abortSignal?: AbortSignal,
 ): Promise<SidecarOutcome> {
   const headers: Record<string, string> = { "Content-Type": "application/json" };
   if (forwardProvider.headers) Object.assign(headers, forwardProvider.headers);
@@ -57,12 +59,13 @@ export async function runWebSearch(
     stream: true,
   };
   const url = `${forwardProvider.baseUrl}/responses`;
+  const linkedSignal = signalWithTimeout(settings.timeoutMs, abortSignal);
   try {
     const res = await fetch(url, {
       method: "POST",
       headers,
       body: JSON.stringify(body),
-      signal: AbortSignal.timeout(settings.timeoutMs),
+      signal: linkedSignal.signal,
     });
     if (!res.ok) {
       const t = await res.text().catch(() => "");
@@ -71,5 +74,7 @@ export async function runWebSearch(
     return await parseSidecarSSE(res);
   } catch (e) {
     return { text: "", sources: [], error: e instanceof Error ? e.message : String(e) };
+  } finally {
+    linkedSignal.cleanup();
   }
 }

package/src/web-search/loop.ts

@@ -95,6 +95,7 @@ export interface WebSearchLoopDeps {
   incomingHeaders: Headers;
   settings: SidecarSettings;
   maxSearches: number;
+  abortSignal?: AbortSignal;
 }
 
 /**
@@ -104,7 +105,7 @@ export interface WebSearchLoopDeps {
  * streamed Responses SSE. web_search calls are executed internally and never relayed to Codex.
  */
 export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Response> {
-  const { parsed, adapter, incomingHeaders, forwardProvider, hostedTool, settings, maxSearches } = deps;
+  const { parsed, adapter, incomingHeaders, forwardProvider, hostedTool, settings, maxSearches, abortSignal } = deps;
   if (!adapter.parseResponse) return jsonError(500, "web-search sidecar requires a non-streaming adapter");
 
   const messages: OcxMessage[] = [...parsed.context.messages];
@@ -129,7 +130,12 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
     const request = adapter.buildRequest(iterParsed, { headers: incomingHeaders });
     let resp: Response;
     try {
-      resp = await fetch(request.url, { method: request.method, headers: request.headers, body: request.body });
+      resp = await fetch(request.url, {
+        method: request.method,
+        headers: request.headers,
+        body: request.body,
+        signal: abortSignal,
+      });
     } catch (e) {
       return jsonError(502, `Provider unreachable: ${e instanceof Error ? e.message : String(e)}`);
     }
@@ -159,7 +165,7 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
         outcome = { text: "", sources: [], error: "the model called web_search with an empty query" };
         searchesExecuted++;
       } else {
-        outcome = await runWebSearch(call.query, hostedTool, forwardProvider, incomingHeaders, settings);
+        outcome = await runWebSearch(call.query, hostedTool, forwardProvider, incomingHeaders, settings, abortSignal);
         searchesExecuted++;
         if (outcome.error) failedQueries.add(normalizeQuery(call.query));
       }