@bitkyc08/opencodex 2.6.1 → 2.6.2

package/src/sidecar-tracker.ts

@@ -0,0 +1,49 @@
+/**
+ * Lightweight in-flight breadcrumb for sidecar work (web-search / vision), read by crash-guard.
+ *
+ * The proxy's unhandled rejections arrive with a native-only stack, so the throw site is invisible.
+ * To confirm or rule out the strong correlation with sidecar activity (the gpt-mini web-search /
+ * vision passes that run an EXTRA upstream fetch alongside the main turn), each sidecar call brackets
+ * itself with enter()/exit(). crash-guard then records whether any sidecar was in flight when a
+ * rejection fired — turning a guess into evidence without a debugger.
+ */
+let inFlight = 0;
+let lastLabel = "";
+let lastEnterAt = 0;
+
+export function sidecarEnter(label: string): () => void {
+  inFlight++;
+  lastLabel = label;
+  lastEnterAt = Date.now();
+  let exited = false;
+  return () => {
+    if (exited) return;
+    exited = true;
+    if (inFlight > 0) inFlight--;
+  };
+}
+
+export function sidecarBreadcrumb(): { inFlight: number; lastLabel: string; sinceMs: number } {
+  return {
+    inFlight,
+    lastLabel,
+    sinceMs: lastEnterAt ? Date.now() - lastEnterAt : 0,
+  };
+}
+
+/**
+ * Generic last-activity breadcrumb (any code path, not just sidecars). The proxy's native-only
+ * rejections carry no source location, so we record the most recent meaningful activity —
+ * request path + a short note — to correlate the next fault with what the daemon was doing.
+ */
+let lastActivity = "";
+let lastActivityAt = 0;
+
+export function markActivity(note: string): void {
+  lastActivity = note;
+  lastActivityAt = Date.now();
+}
+
+export function activityBreadcrumb(): { note: string; sinceMs: number } {
+  return { note: lastActivity, sinceMs: lastActivityAt ? Date.now() - lastActivityAt : 0 };
+}

package/src/types.ts

@@ -175,6 +175,7 @@ export interface OcxRequestOptions {
 }
 
 export type AdapterEvent =
+  | { type: "heartbeat" }
   | { type: "text_delta"; text: string }
   | { type: "thinking_delta"; thinking: string }
   | { type: "reasoning_raw_delta"; text: string }
@@ -187,8 +188,10 @@ export type AdapterEvent =
 export interface OcxUsage {
   inputTokens: number;
   outputTokens: number;
+  totalTokens?: number;
   cachedInputTokens?: number;
   reasoningOutputTokens?: number;
+  estimated?: boolean;
 }
 
 export interface OcxConfig {

package/src/usage-debug.ts

@@ -1,6 +1,7 @@
 import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { getConfigDir } from "./config";
+import { redactSecretString, redactSecrets } from "./redact";
 import type { OcxUsage } from "./types";
 
 export const USAGE_DEBUG_ENV = "OPENCODEX_USAGE_DEBUG";
@@ -31,9 +32,10 @@ export function usageDebugPath(): string {
 }
 
 export function truncateForDebug(text: string, max = USAGE_DEBUG_BODY_SAMPLE_BYTES): string {
-  if (text.length <= max) return text;
-  const cut = text.slice(0, max);
-  const remaining = text.length - max;
+  const redacted = redactSecretString(text);
+  if (redacted.length <= max) return redacted;
+  const cut = redacted.slice(0, max);
+  const remaining = redacted.length - max;
   return `${cut}... [+${remaining} more]`;
 }
 
@@ -56,7 +58,8 @@ export function appendUsageDebug(record: UsageDebugRecord): void {
   try {
     ensureUsageDebugDir();
     const path = usageDebugPath();
-    appendFileSync(path, `${JSON.stringify(record)}\n`, { encoding: "utf-8", mode: 0o600 });
+    const safeRecord = redactSecrets(record) as UsageDebugRecord;
+    appendFileSync(path, `${JSON.stringify(safeRecord)}\n`, { encoding: "utf-8", mode: 0o600 });
     try { chmodSync(path, 0o600); } catch { /* best-effort */ }
     if (existsSync(path)) trimRollingFile(path);
   } catch {

package/src/usage-log.ts

@@ -24,11 +24,49 @@ export function usageLogPath(): string {
 
 export function usageTotalTokens(usage: OcxUsage | undefined): number | undefined {
   if (!usage) return undefined;
-  return usage.inputTokens + usage.outputTokens;
+  return usage.totalTokens ?? usage.inputTokens + usage.outputTokens;
+}
+
+function isKiroLogProvider(provider: string): boolean {
+  return provider === "kiro" || provider.startsWith("kiro-");
+}
+
+export function usageForFinalLog(provider: string, usage: OcxUsage | undefined): OcxUsage | undefined {
+  if (!usage) return undefined;
+  if (usage.estimated || isKiroLogProvider(provider)) return { ...usage, estimated: true };
+  return usage;
 }
 
 export function usageStatusForFinalLog(usage: OcxUsage | undefined): UsageStatus {
-  return usage ? "reported" : "unreported";
+  if (!usage) return "unreported";
+  return usage.estimated ? "estimated" : "reported";
+}
+
+function normalizeUsageValue(usage: OcxUsage | undefined): OcxUsage | undefined {
+  if (!usage) return undefined;
+  return {
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    ...(typeof usage.totalTokens === "number" ? { totalTokens: usage.totalTokens } : {}),
+    ...(typeof usage.cachedInputTokens === "number" ? { cachedInputTokens: usage.cachedInputTokens } : {}),
+    ...(typeof usage.reasoningOutputTokens === "number" ? { reasoningOutputTokens: usage.reasoningOutputTokens } : {}),
+    ...(usage.estimated ? { estimated: true } : {}),
+  };
+}
+
+function normalizeUsageEntry(entry: PersistedUsageEntry): PersistedUsageEntry {
+  return {
+    requestId: entry.requestId,
+    timestamp: entry.timestamp,
+    provider: entry.provider,
+    model: entry.model,
+    ...(entry.resolvedModel ? { resolvedModel: entry.resolvedModel } : {}),
+    status: entry.status,
+    durationMs: entry.durationMs,
+    usageStatus: entry.usageStatus,
+    ...(entry.usage ? { usage: normalizeUsageValue(entry.usage) } : {}),
+    ...(typeof entry.totalTokens === "number" ? { totalTokens: entry.totalTokens } : {}),
+  };
 }
 
 function ensureUsageLogDir(): void {
@@ -40,7 +78,7 @@ function ensureUsageLogDir(): void {
 export function appendUsageEntry(entry: PersistedUsageEntry): void {
   ensureUsageLogDir();
   const path = usageLogPath();
-  appendFileSync(path, `${JSON.stringify(entry)}\n`, { encoding: "utf-8", mode: 0o600 });
+  appendFileSync(path, `${JSON.stringify(normalizeUsageEntry(entry))}\n`, { encoding: "utf-8", mode: 0o600 });
   try { chmodSync(path, 0o600); } catch { /* best-effort on platforms that ignore chmod */ }
 }
 

package/src/vision/describe.ts

@@ -1,6 +1,7 @@
 import type { OcxProviderConfig } from "../types";
 import { FORWARD_HEADERS } from "../adapters/openai-responses";
-import { signalWithTimeout } from "../abort";
+import { signalWithTimeout, cancelBodyOnAbort } from "../abort";
+import { sidecarEnter } from "../sidecar-tracker";
 import { parseSidecarSSE } from "../web-search/parse";
 import type { SidecarOutcomeRecorder } from "../web-search/executor";
 
@@ -81,6 +82,7 @@ export async function describeImage(
     stream: true,
   };
   const linkedSignal = signalWithTimeout(settings.timeoutMs, abortSignal);
+  const sidecarExit = sidecarEnter("vision");
   try {
     const res = await fetch(`${forwardProvider.baseUrl}/responses`, {
       method: "POST",
@@ -93,7 +95,13 @@ export async function describeImage(
       const t = await res.text().catch(() => "");
       return { text: "", error: `vision sidecar HTTP ${res.status}: ${t.slice(0, 200)}` };
     }
-    const parsed = await parseSidecarSSE(res);
+    const detachBodyGuard = cancelBodyOnAbort(res.body, linkedSignal.signal);
+    let parsed;
+    try {
+      parsed = await parseSidecarSSE(res);
+    } finally {
+      detachBodyGuard();
+    }
     // The backend can return HTTP 200 then stream a `response.failed`/`error` event with no text;
     // surface that as a describe error instead of an empty (silently-blank) description.
     if (!parsed.text.trim() && parsed.error) return { text: "", error: parsed.error };
@@ -102,6 +110,7 @@ export async function describeImage(
     recordOutcome?.(e instanceof Error && e.name === "TimeoutError" ? "timeout" : "connect_error");
     return { text: "", error: e instanceof Error ? e.message : String(e) };
   } finally {
+    sidecarExit();
     linkedSignal.cleanup();
   }
 }

package/src/web-search/executor.ts

@@ -1,6 +1,7 @@
 import type { OcxProviderConfig } from "../types";
 import { FORWARD_HEADERS } from "../adapters/openai-responses";
-import { signalWithTimeout } from "../abort";
+import { signalWithTimeout, cancelBodyOnAbort } from "../abort";
+import { sidecarEnter } from "../sidecar-tracker";
 import { parseSidecarSSE, type WebSearchResult } from "./parse";
 import type { CodexUpstreamOutcome } from "../codex-routing";
 
@@ -63,6 +64,7 @@ export async function runWebSearch(
   };
   const url = `${forwardProvider.baseUrl}/responses`;
   const linkedSignal = signalWithTimeout(settings.timeoutMs, abortSignal);
+  const sidecarExit = sidecarEnter("web-search");
   try {
     const res = await fetch(url, {
       method: "POST",
@@ -75,11 +77,17 @@ export async function runWebSearch(
       const t = await res.text().catch(() => "");
       return { text: "", sources: [], error: `sidecar HTTP ${res.status}: ${t.slice(0, 200)}` };
     }
-    return await parseSidecarSSE(res);
+    const detachBodyGuard = cancelBodyOnAbort(res.body, linkedSignal.signal);
+    try {
+      return await parseSidecarSSE(res);
+    } finally {
+      detachBodyGuard();
+    }
   } catch (e) {
     recordOutcome?.(e instanceof Error && e.name === "TimeoutError" ? "timeout" : "connect_error");
     return { text: "", sources: [], error: e instanceof Error ? e.message : String(e) };
   } finally {
+    sidecarExit();
     linkedSignal.cleanup();
   }
 }

package/src/web-search/loop.ts

@@ -3,6 +3,7 @@ import type { AdapterEvent, OcxMessage, OcxParsedRequest, OcxProviderConfig } fr
 import { namespacedToolName } from "../types";
 import { bridgeToResponsesSSE } from "../bridge";
 import { runWebSearch, type SidecarOutcomeRecorder, type SidecarSettings } from "./executor";
+import { cancelBodyOnAbort } from "../abort";
 import { formatWebSearchResult } from "./format-result";
 import { WEB_SEARCH_TOOL_NAME } from "./synthetic-tool";
 
@@ -132,12 +133,14 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
     const request = adapter.buildRequest(iterParsed, { headers: selectedForwardHeaders });
     let resp: Response;
     try {
-      resp = await fetch(request.url, {
-        method: request.method,
-        headers: request.headers,
-        body: request.body,
-        signal: abortSignal,
-      });
+      resp = adapter.fetchResponse
+        ? await adapter.fetchResponse(request, { abortSignal })
+        : 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)}`);
     }
@@ -145,7 +148,24 @@ export async function runWithWebSearch(deps: WebSearchLoopDeps): Promise<Respons
       const t = await resp.text().catch(() => "");
       return jsonError(resp.status, `Provider error ${resp.status}: ${t.slice(0, 400)}`);
     }
-    const events = await adapter.parseResponse(resp);
+    // The fetch above carries `abortSignal`; when the turn is superseded/cancelled, Bun aborts the
+    // response body stream. If parseResponse hasn't attached a reader yet, the body's pending read is
+    // orphaned off the awaited path and surfaces as `unhandledRejection: TypeError: null is not an
+    // object` (native-only stack). Proactively cancel the body on abort so WE settle it, and guard
+    // the drain so a mid-decode abort/stream error ends cleanly instead of throwing.
+    const detachBodyGuard = cancelBodyOnAbort(resp.body, abortSignal);
+    let events: AdapterEvent[];
+    try {
+      events = await adapter.parseResponse(resp);
+    } catch (e) {
+      await resp.body?.cancel().catch(() => {});
+      if (abortSignal?.aborted) {
+        return jsonError(499, "client closed request during web-search");
+      }
+      return jsonError(502, `Provider stream error: ${e instanceof Error ? e.message : String(e)}`);
+    } finally {
+      detachBodyGuard();
+    }
     const { calls, passthrough, hasRealToolCall } = scanEventsForWebSearch(events);
     // Loop (search + re-ask) ONLY when the model's actionable output is purely web_search. A real
     // tool call (e.g. shell/apply_patch) means this turn is terminal for Codex — finalize so those