@bitkyc08/opencodex 2.87.0 → 2.88.0

package/src/cli/loopback-family.ts

@@ -0,0 +1,31 @@
+/** A failed connect cannot distinguish an absent loopback address from a slow owner. */
+export type LoopbackFamilyAvailability = "available" | "unavailable" | "unknown";
+
+function bindLoopback(hostname: string): { stop(): void } {
+  return Bun.listen({ hostname, port: 0, socket: { data(socket) { socket.end(); } } });
+}
+
+/**
+ * Ask the kernel whether the concrete local address can be bound, independently of
+ * routing/connect timeouts. Only address/family absence permits skipping discovery;
+ * permissions, resource exhaustion and other failures leave owner evidence unknown.
+ * The ephemeral listener is closed synchronously and never accepts client traffic.
+ */
+export function loopbackFamilyAvailability(
+  hostname: string,
+  bindFn: (hostname: string) => { stop(): void } = bindLoopback,
+): LoopbackFamilyAvailability {
+  const address = hostname === "[::1]" ? "::1" : hostname;
+  if (address !== "::1" && address !== "127.0.0.1") return "unknown";
+  let listener: { stop(): void };
+  try {
+    listener = bindFn(address);
+  } catch (error) {
+    const code = (error as { code?: unknown } | null)?.code;
+    return code === "EADDRNOTAVAIL" || code === "EAFNOSUPPORT"
+      || code === "EPROTONOSUPPORT"
+      ? "unavailable" : "unknown";
+  }
+  listener.stop();
+  return "available";
+}

package/src/codex/catalog/routed-gather.ts

@@ -102,7 +102,7 @@ import type {
   CatalogTrustedOpenAiApiPolicySnapshot,
 } from "../convergence-types";
 import type { CatalogGatherProviderAuthOutcome, CatalogGatherProviderModelOutcome, GatherFlightCapture, ModelsAuthResolverFactory } from "./gather-capture";
-import { applyProviderConfigHints, configuredAutoCompactTokenLimit, configuredMaxInputTokens, configuredReasoningSummarySupport, modelInputModalities, routedMaxOutputTokens, withVisionSidecarInput } from "./model-hints";
+import { applyProviderConfigHints, configuredAutoCompactTokenLimit, configuredMaxInputTokens, configuredModelDisplayName, configuredReasoningSummarySupport, modelInputModalities, routedMaxOutputTokens, withVisionSidecarInput } from "./model-hints";
 import { resolveComboCatalogMember } from "./combo-member";
 import { captureGatherFlight, captureTrustedOpenAiApiPolicy, gatherFlightKey, keyedGatherBytesIdentity, withCanonicalOpenAiForwardAuthDefault } from "./gather-capture";
 import { fetchProviderModelsWithAuth, observedModelsAuthResolver, refreshingModelsAuthResolver } from "./provider-models";
@@ -886,10 +886,12 @@ function augmentRoutedModelsWithCapturedOpenAiApiRows(
       undefined,
       metadataConfigDir,
     );
+    const displayName = configuredModelDisplayName(configured, id);
     return {
       provider: OPENAI_API_PROVIDER_ID,
       id,
       owned_by: OPENAI_API_PROVIDER_ID,
+      ...(displayName ? { displayName } : {}),
       ...(contextWindow ? { contextWindow } : {}),
       ...(maxInputTokens ? { maxInputTokens } : {}),
       ...(maxOutputTokens !== undefined ? { maxOutputTokens } : {}),

package/src/codex/websocket-activity.ts

@@ -0,0 +1,161 @@
+import { createHash } from "node:crypto";
+import { isAuthorizedProviderExecutedCall, type ProviderExecutedCallType } from "../server/responses-undeclared-tool-guard";
+
+// Logical recency avoids clock adjustments and ties between messages in one millisecond.
+let activityOrder = 0;
+const MAX_PENDING_RESULTS = 1024;
+const MAX_RESULT_ID_LENGTH = 1024;
+const resultTypes: Readonly<Record<string, string>> = {
+  function_call: "function_call_output",
+  custom_tool_call: "custom_tool_call_output",
+  local_shell_call: "function_call_output",
+  shell_call: "shell_call_output",
+  computer_call: "computer_call_output",
+  apply_patch_call: "apply_patch_call_output",
+  tool_search_call: "tool_search_output",
+  mcp_approval_request: "mcp_approval_response",
+};
+
+function record(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function resultKey(type: string, id: string): string {
+  return createHash("sha256").update(JSON.stringify([type, id])).digest("hex");
+}
+
+/** Content-free activity owned by one admitted incoming Responses socket. */
+export class CodexWebSocketActivity {
+  lastUsed = ++activityOrder;
+  closing = false;
+  private turns = 0;
+  private pendingResults = new Set<string>();
+  private returnedResults = new Set<string>();
+  // Hashed identities only; null marks a route-authorized provider-owned call.
+  private argumentCalls = new Map<string, { type: string; result: string | null }>();
+  // Unknown/oversized identities cannot safely prove that client work finished.
+  private untrackedResults = false;
+
+  get idle(): boolean {
+    return !this.closing && this.turns === 0 && this.pendingResults.size === 0 && !this.untrackedResults;
+  }
+
+  touch(): void {
+    this.lastUsed = ++activityOrder;
+  }
+
+  /** Each turn retains its own busy reference, including superseded async cleanup. */
+  beginTurn(input: unknown): () => void {
+    this.turns += 1;
+    this.touch();
+    this.acceptResults(input);
+    // Ordinary creates start a new response even when its upstream omits response.created.
+    // Prior results settle old waits, but cannot suppress new calls reusing their IDs.
+    this.returnedResults.clear();
+    this.argumentCalls.clear();
+    let finished = false;
+    return () => {
+      if (finished) return;
+      finished = true;
+      this.turns -= 1;
+      if (this.turns === 0) this.touch();
+    };
+  }
+
+  /** Called only after admission or native control accepts the client's results. */
+  acceptResults(input: unknown): void {
+    if (this.untrackedResults) return;
+    if (Array.isArray(input)) {
+      for (const item of input) {
+        if (!record(item) || typeof item.type !== "string") continue;
+        const id = item.type === "mcp_approval_response" ? item.approval_request_id : item.call_id;
+        if (typeof id === "string" && id.length <= MAX_RESULT_ID_LENGTH) {
+          // Ordinary Codex shell results use function_call_output; native steering
+          // also accepts its explicit local_shell_call_output continuation stub.
+          const type = item.type === "local_shell_call_output" ? "function_call_output" : item.type;
+          const key = resultKey(type, id);
+          if (this.pendingResults.delete(key)) {
+            if (this.returnedResults.size >= MAX_PENDING_RESULTS) { this.protectUntracked(); return; }
+            else this.returnedResults.add(key);
+          }
+        }
+      }
+    }
+  }
+
+  /** Preserve tool waits even when the response terminal omits its output array. */
+  observePayload(payload: string, providerExecuted?: ReadonlySet<ProviderExecutedCallType>): void {
+    if (this.untrackedResults) return;
+    let frame: unknown;
+    try { frame = JSON.parse(payload); } catch { return; }
+    if (!record(frame)) return;
+    // Native injection can return a result before the same terminal repeats its call.
+    if (frame.type === "response.created") {
+      this.returnedResults.clear();
+      this.argumentCalls.clear();
+    }
+    if (frame.type === "response.output_item.added") this.rememberArgumentCall(frame.item, providerExecuted);
+    if (frame.type === "response.function_call_arguments.done" || frame.type === "response.custom_tool_call_input.done") {
+      const type = frame.type === "response.function_call_arguments.done" ? "function_call" : "custom_tool_call";
+      const call = typeof frame.item_id === "string" && frame.item_id.length <= MAX_RESULT_ID_LENGTH
+        ? this.argumentCalls.get(resultKey("item", frame.item_id)) : undefined;
+      if (!call || call.type !== type) this.protectUntracked();
+      else if (call.result !== null) this.observeResultKey(call.result);
+    }
+    if (frame.type === "response.output_item.done") this.observeOutput(frame.item, providerExecuted);
+    if (["response.completed", "response.incomplete", "response.failed"].includes(String(frame.type))
+      && record(frame.response) && Array.isArray(frame.response.output)) {
+      for (const item of frame.response.output) this.observeOutput(item, providerExecuted);
+    }
+  }
+
+  private rememberArgumentCall(item: unknown, providerExecuted?: ReadonlySet<ProviderExecutedCallType>): void {
+    if (!record(item) || (item.type !== "function_call" && item.type !== "custom_tool_call")) return;
+    if (typeof item.id !== "string" || !item.id.length || item.id.length > MAX_RESULT_ID_LENGTH) return;
+    const key = resultKey("item", item.id);
+    const hosted = providerExecuted && isAuthorizedProviderExecutedCall(item, providerExecuted);
+    if (!hosted && (typeof item.call_id !== "string" || !item.call_id.length || item.call_id.length > MAX_RESULT_ID_LENGTH)) {
+      if (this.argumentCalls.has(key)) this.protectUntracked();
+      return;
+    }
+    const result = hosted ? null : resultKey(resultTypes[item.type]!, item.call_id as string);
+    const previous = this.argumentCalls.get(key);
+    if (previous) {
+      if (previous.type !== item.type || previous.result !== result) this.protectUntracked();
+      return;
+    }
+    if (this.argumentCalls.size >= MAX_PENDING_RESULTS) { this.protectUntracked(); return; }
+    // An unfinished argument stream alone does not prove the client started work.
+    this.argumentCalls.set(key, { type: item.type, result });
+  }
+
+  private observeOutput(item: unknown, providerExecuted?: ReadonlySet<ProviderExecutedCallType>): void {
+    if (this.untrackedResults) return;
+    if (!record(item) || typeof item.type !== "string") return;
+    // Hosted execution may publish both the call and its result in the output stream.
+    this.acceptResults([item]);
+    if (!Object.hasOwn(resultTypes, item.type)) return;
+    if (providerExecuted && isAuthorizedProviderExecutedCall(item, providerExecuted)) return;
+    if (item.type === "tool_search_call" && item.execution !== "client") return;
+    const id = item.type === "mcp_approval_request" ? item.id
+      : item.type === "local_shell_call" || item.type === "tool_search_call" ? item.call_id ?? item.id : item.call_id;
+    if (typeof id !== "string" || !id.length || id.length > MAX_RESULT_ID_LENGTH) {
+      this.protectUntracked();
+      return;
+    }
+    this.observeResultKey(resultKey(resultTypes[item.type]!, id));
+  }
+
+  private observeResultKey(key: string): void {
+    if (this.pendingResults.has(key) || this.returnedResults.has(key)) return;
+    if (this.pendingResults.size >= MAX_PENDING_RESULTS) this.protectUntracked();
+    else this.pendingResults.add(key);
+  }
+
+  private protectUntracked(): void {
+    this.untrackedResults = true;
+    this.pendingResults.clear();
+    this.returnedResults.clear();
+    this.argumentCalls.clear();
+  }
+}

package/src/codex/websocket-registry.ts

@@ -1,23 +1,47 @@
 import type { ServerWebSocket } from "bun";
 import type { WsData } from "../server/ws-bridge";
 import { createAdmissionGate, type AdmissionMetrics, type AdmissionReservation } from "../lib/admission";
+import { CodexWebSocketActivity } from "./websocket-activity";
 
 export const MAX_TRACKED_CODEX_WEBSOCKETS = 128;
 const websocketGate = createAdmissionGate("codex_websockets", MAX_TRACKED_CODEX_WEBSOCKETS);
+const admittedSockets = new Set<ServerWebSocket<WsData>>();
+
+function reclaimOldestIdleSocket(): void {
+  let oldest: ServerWebSocket<WsData> | undefined;
+  for (const ws of admittedSockets) {
+    const activity = ws.data.responsesActivity;
+    if (!activity?.idle || ws.data.nativeControl || ws.readyState !== 1 || ws.getBufferedAmount() !== 0) continue;
+    if (!oldest || activity.lastUsed < oldest.data.responsesActivity!.lastUsed) oldest = ws;
+  }
+  if (!oldest) return;
+  // Fence late frames before closing. Only the actual close callback releases admission.
+  oldest.data.responsesActivity!.closing = true;
+  try {
+    oldest.close(1001, "Idle Responses connection reclaimed");
+  } catch {
+    // A failed/delayed close never manufactures a free slot or retries another victim.
+    if (oldest.readyState === 1) oldest.data.responsesActivity!.closing = false;
+  }
+}
 
 export function tryReserveCodexWebSocket(): AdmissionReservation<ServerWebSocket<WsData>> | null {
+  if (websocketGate.metrics().active >= MAX_TRACKED_CODEX_WEBSOCKETS) reclaimOldestIdleSocket();
   const gateLease = websocketGate.tryAcquire();
   if (!gateLease) return null;
   let socket: ServerWebSocket<WsData> | undefined;
   let active = true;
   return {
     bind(value) {
-      if (!active) return;
+      if (!active || socket) return;
       socket = value;
+      socket.data.responsesActivity = new CodexWebSocketActivity();
+      admittedSockets.add(socket);
     },
     release() {
       if (!active) return;
       active = false;
+      if (socket) admittedSockets.delete(socket);
       socket = undefined;
       gateLease.release();
     },

package/src/config/opencode-zen-upgrade.ts

@@ -1,4 +1,4 @@
-import { openCodeZenBaseUrl } from "../types/opencode-zen";
+import { openCodeZenBaseUrl, openCodeZenKeyBaseUrl, type OpenCodeZenDestination } from "../types/opencode-zen";
 import { declaredUnsupportedHostedTools, isHostedToolUnsupportedForModel } from "../responses/hosted-tool-policy";
 
 function record(value: unknown): Record<string, unknown> | undefined {
@@ -6,8 +6,9 @@ function record(value: unknown): Record<string, unknown> | undefined {
     ? value as Record<string, unknown> : undefined;
 }
 
-function isGeminiModel(model: string): boolean {
-  return model.trim().toLowerCase().startsWith("gemini-");
+function isNativeZenModel(model: string, provider: OpenCodeZenDestination): boolean {
+  const folded = model.trim().toLowerCase();
+  return folded.startsWith("claude-") || (folded.startsWith("gemini-") && openCodeZenBaseUrl(provider) !== undefined);
 }
 
 /** Repair legacy Zen wire overrides and dependent preferences in file-backed reads only. */
@@ -15,7 +16,7 @@ export function sanitizeOpenCodeZenOverridesForLoad(parsed: unknown): void {
   const providers = record(record(parsed)?.providers);
   const provider = providers && Object.hasOwn(providers, "opencode-zen")
     ? record(providers["opencode-zen"]) : undefined;
-  if (!provider || !openCodeZenBaseUrl(provider)) return;
+  if (!provider || !openCodeZenKeyBaseUrl(provider)) return;
   const overrides = record(provider.modelAdapters) ?? {};
   const preferences = record(provider.modelPreferHostedTools);
   let preferencesChanged = false;
@@ -25,7 +26,7 @@ export function sanitizeOpenCodeZenOverridesForLoad(parsed: unknown): void {
       // Capture the old wire before deleting overrides. An explicit non-Responses entry
       // must not inherit a provider-wide Responses default for this migration.
       const oldAdapter = Object.hasOwn(overrides, model) ? overrides[model] : provider.adapter;
-      if (!isGeminiModel(model) || oldAdapter !== "openai-responses"
+      if (!isNativeZenModel(model, provider) || oldAdapter !== "openai-responses"
         || !Array.isArray(tools) || tools.length === 0 || tools.some(tool => tool !== "image_generation")
         || isHostedToolUnsupportedForModel(model, "image_generation", undefined, unsupported)) continue;
       delete preferences[model];
@@ -37,16 +38,16 @@ export function sanitizeOpenCodeZenOverridesForLoad(parsed: unknown): void {
   for (const [model, adapter] of Object.entries(overrides)) {
     // Retain invalid preference/wire pairs so repeated normalization cannot admit them.
     if (preferences && Object.hasOwn(preferences, model)) continue;
-    if (isGeminiModel(model) && (adapter === "openai-chat" || adapter === "openai-responses")) {
+    if (isNativeZenModel(model, provider) && (adapter === "openai-chat" || adapter === "openai-responses")) {
       delete overrides[model];
       overridesChanged = true;
     }
   }
   if (overridesChanged) {
     if (Object.keys(overrides).length === 0) delete provider.modelAdapters;
-    console.warn("OpenCode Zen Gemini models now use the native Google API; obsolete Chat/Responses overrides were ignored while loading config.json.");
+    console.warn("OpenCode Zen Gemini and Claude models now use their native APIs; obsolete Chat/Responses overrides were ignored while loading config.json.");
   }
   if (preferencesChanged) {
-    console.warn("OpenCode Zen Gemini models now use the native Google API; legacy Responses-only hosted-tool preferences were ignored while loading config.json.");
+    console.warn("OpenCode Zen Gemini and Claude models now use their native APIs; legacy Responses-only hosted-tool preferences were ignored while loading config.json.");
   }
 }