codex-copilot-dx 0.9.9 → 0.9.11

package/README.md

@@ -244,7 +244,7 @@ The language button immediately right of the appearance button switches between
 
 Usage Analytics is collapsed by default. Opening it adds daily input/output token bars (7/30/90 days) and a 365-day calendar of recorded usage calls or tokens, grouped in the browser's time zone. Cache-read tokens are already part of input and are not added again. Model and range filters use the current snapshot without additional requests; selecting a day shows its filtered model totals in the Usage table, and All history restores the original table. Analytics shares the existing current/rotated-log scan and exposes only bounded metadata (365 days, up to 100 model filters). Days before retained history are hatched, not presented as zero; the oldest retained day may be partial. Counts describe retained usage records, not messages, session time, or all HTTP requests. Refresh explicitly to update the snapshot; there is no background collection or polling.
 
-Terminal Animation is collapsed at the bottom of the page, with an Animation shortcut in the header. Preview frames load only when opened; closing it, hiding the page, or requesting reduced motion stops the preview timer. Unsaved choices survive folding and reopening. Recent upstream failures expand to existing diagnostic fields (time, model, code, message, response/request IDs, and retry policy) with a Copy diagnostic control. These are the last 10 retained `response.failed` events, not complete session histories; a retry attempt does not prove recovery. Diagnostic prose is redacted by the existing recorder but can still contain sensitive context: review before copying or sharing.
+Terminal Animation is collapsed at the bottom of the page, with an Animation shortcut in the header. Preview frames load only when opened; closing it, hiding the page, or requesting reduced motion stops the preview timer. Unsaved choices survive folding and reopening. Recent response failures expand to diagnostic fields (time, model, code, message, response/request IDs, and retry policy) with a Copy diagnostic control. The view combines the last 10 retained `response.failed` events with failures from the 20 most recently finished Responses/compact requests, showing at most 10 entries. Matching local request IDs attach the final outcome and timing metadata, so a recovered event can show `completed`; an uncorrelated retry attempt does not prove recovery. Transport failures and incomplete/cancelled requests can appear without a `response.failed` event. These are bounded runtime observations, not complete session histories. Diagnostic prose is redacted by the existing recorder but can still contain sensitive context: review before copying or sharing.
 
 Inspect only the local Codex configuration:
 
@@ -298,6 +298,8 @@ The status endpoint is restricted to the socket's real loopback address even whe
 
 `stream_performance.by_route` also reports `request_ttft_ms`, measured from adapter entry to the first observed output delta, including local preparation. The existing `ttft_ms` continues to start at upstream dispatch. Neither timestamp means the client has drained or displayed the output. `preparation_ms` contains bounded histograms for admission (including history reservations), body reading/decompression/JSON parsing, history materialization/compact preparation, image optimization, and request serialization. Each sample measures one operation, including failed operations; retries can add samples. These are diagnostic intervals rather than a complete breakdown of request time: body reading includes internal decoded-body admission waits; authentication, routing, and other preparation are not individually timed. Non-streaming requests contribute preparation samples without inventing a first-token measurement.
 
+`stream_performance.recent_requests` retains at most 20 finished Responses/compact requests. Each entry contains a CCDX-owned request ID, start timestamp, bounded model/route labels, HTTP status, final model outcome, known error origin, last observed phase and provider-call count. `timings_ms` includes cumulative preparation durations and offsets from adapter entry for the first upstream dispatch, latest upstream headers, first output, latest observed upstream activity, terminal and finish. Null means not observed, not zero. Stage durations can overlap and should not be added into a total. Provider-call counts include compatibility attempts but exclude OAuth exchanges and low-level connection retries. Streams update a single activity timestamp per read; no content, headers, opaque state or unbounded event list is retained. Entries are process-local and reset on restart; normal status refresh reads them without new upstream calls or background polling.
+
 Every API response includes a safe `X-Request-Id` for correlation. To include the same ID in related terminal and file log lines, start with:
 
 ```bash
@@ -392,6 +394,10 @@ The summary covers the current log and its single rotated backup, not an unbound
 
 Usage writes are asynchronous and batched under the existing cross-process rotation lock. Pending and in-flight records share a 4096-record / 4 MiB ceiling. If either ceiling is reached, new excess records are dropped with a warning and a status counter; inference does not wait or retry. Normal records and per-record rotation boundaries are unchanged. The bounded shutdown flush remains 1.5 seconds; disk failures and shutdown deadlines can prevent persistence, so usage is diagnostic rather than a billing ledger.
 
+Repeated plain usage summaries in the same process reuse one bounded cache entry when both retained log files are unchanged. File identity, size, modification/change timestamps and a two-second recent-write guard control reuse; concurrent settled-file queries share one scan. The serialized summary budget is 256 KiB and at most 128 model groups; larger results remain complete but uncached. Warnings, unstable reads, metadata errors and scans with changed files are not retained. Each caller receives an independent result. Analytics record callbacks and custom-warning reads keep the original streaming path. There is no persistent index, background polling, cross-process cache or change to usage writes; opening analytics still scans the retained records.
+
+Diagnostic redaction removes Basic authorization payloads and URL userinfo, and consumes escaped quotes inside sensitive JSON fields. Ordinary Basic-related prose, safe host/path information and error codes are retained. These protections apply to existing failure/status/debug diagnostics, not forwarded requests or upstream response bodies. They do not make arbitrary upstream prose guaranteed safe to share.
+
 ## Debug logging
 
 Set `CCDX_LOG_PATH=1` to mirror terminal logs to `~/.local/share/codex-copilot-dx/debug.log`, or provide a custom path. Add `CCDX_LOG_LEVEL=debug` for upstream attempts, retry causes, status codes, and timings. The adapter does not deliberately dump request/response bodies or authorization headers. File diagnostics redact common credential forms and labelled content echoes, but this cannot identify every secret in arbitrary external prose; review logs before sharing them. File writes are asynchronous and batched with a 4096-record / 2 MiB pending-and-in-flight ceiling. Overflow drops excess file records with one warning and a status counter; terminal output continues. CLI exit paths flush for at most 1.5 seconds. `ccdx doctor config` bypasses file logging entirely.
@@ -416,6 +422,8 @@ For `/v1/responses/compact`, CCDX sends one terminal `compaction_trigger`, valid
 
 Changing the model or transport of a continuation can require removing incompatible encrypted history from the forwarded request. A specific upstream encrypted-state verification failure can also trigger one sanitized retry, including when a nominally successful HTTP response ends with `response.failed`. CCDX withholds only the pre-output prelude of an encrypted continuation while evaluating that terminal event; it never retries after visible model output, so it cannot duplicate an already-started answer. Unrelated failures pass through unchanged. CCDX does not decrypt that state locally.
 
+Native Responses forwards Codex `agent_message` items unchanged. When a model requires Chat Completions, CCDX frames them as messages from another agent, not human input or approval, retaining author/recipient, typed text/refusal/reasoning and representable image/screenshot content. Content unsupported by Chat, including file, audio or opaque encrypted parts, receives an explicit compatibility error instead of being serialized into ordinary text. This projection does not introduce another model request or change native Responses, Fast, Auto-review or compaction routing.
+
 After the stream handshake succeeds, stream liveness uses the idle timeout rather than the expired handshake deadline. Eligible HTTP-200 failure recovery acquires a bounded preparation budget and history admission before rebuilding its payload, then releases those reservations when the retry opens upstream or fails. Normal streams still release preparation admission after their response headers arrive.
 
 Downstream backpressure waits also observe cancellation and the stream deadline. A client that stops reading cannot retain the pending stream indefinitely after timeout; CCDX closes that connection without retrying its request. Final error-frame delivery has a separate one-second maximum drain wait.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.9.9",
+  "version": "0.9.11",
   "description": "Use Codex App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",

package/src/adapter.mjs

@@ -389,7 +389,7 @@ export function createAdapterHandler(options = {}) {
       && !((req.method === "GET" || req.method === "HEAD") && DASHBOARD_PATHS.has(pathname));
     const routeName = classifyAdapterRoute(req.method, pathname);
     const complete = trackRequest ? requestMetrics.begin(routeName) : () => {};
-    const streamPerformance = trackRequest ? streamPerformanceMetrics.begin(routeName) : null;
+    const streamPerformance = trackRequest ? streamPerformanceMetrics.begin(routeName, { requestId }) : null;
     let finishTerminalActivity = () => {};
     if (trackRequest) {
       try {
@@ -402,7 +402,7 @@ export function createAdapterHandler(options = {}) {
       if (requestFinished) return;
       requestFinished = true;
       try { complete({ statusCode, aborted }); } catch {}
-      try { streamPerformance?.finish({ failed: aborted || statusCode >= 400, aborted }); } catch {}
+      try { streamPerformance?.finish({ failed: aborted || statusCode >= 400, aborted, statusCode }); } catch {}
       try { finishTerminalActivity(); } catch {}
     };
     const containUnexpectedError = (error) => {

package/src/copilot-client.mjs

@@ -102,7 +102,7 @@ export function createCopilotClientRuntime({
     });
     headers["Content-Length"] = String(Buffer.byteLength(serializedBody));
     onUpstreamStart?.();
-    if (upstreamReq.stream === true) markUpstreamStarted();
+    markUpstreamStarted(upstreamReq.stream === true);
     return fetchCopilotUpstream(`${tokenSession.getApiBase()}/chat/completions`, {
       method: "POST",
       headers,
@@ -185,7 +185,7 @@ export function createCopilotClientRuntime({
     headers.Accept = reqBody.stream ? "text/event-stream" : "application/json";
     try {
       onUpstreamStart?.();
-      if (reqBody.stream === true) markUpstreamStarted();
+      markUpstreamStarted(reqBody.stream === true);
       return await fetchCopilotUpstream(`${tokenSession.getApiBase()}${responsesEndpointPath()}`, {
         method: "POST",
         headers,

package/src/copilot-responses-compat.mjs

@@ -14,6 +14,7 @@ import {
   sanitizeEncryptedReasoningRequest,
 } from "./responses-request.mjs";
 import { status } from "./status.mjs";
+import { markUpstreamHeaders } from "./stream-performance.mjs";
 
 // Ordered Copilot-only fallbacks. Each policy is single-use and must be gated
 // by an exact upstream failure plus a request transformation that changes the
@@ -70,6 +71,7 @@ export async function openCopilotResponse(reqContext, upstream = copilotResponse
       onUpstreamStart: options.onUpstreamStart,
       payloadPrepared,
     });
+    markUpstreamHeaders();
     options.assertPrepareActive?.();
     payloadPrepared = true;
     if (resp.ok) {

package/src/dashboard/index.html

@@ -79,7 +79,7 @@
         </section>
 
         <section class="lower" aria-label="Recent failures" data-i18n-label>
-          <div class="panel-heading"><h2 data-i18n>RECENT UPSTREAM FAILURES</h2><span id="failure-count">response.failed</span></div>
+          <div class="panel-heading"><h2 data-i18n>RECENT RESPONSE FAILURES</h2><span id="failure-count">requests + events</span></div>
           <ol id="failures"><li class="empty" data-i18n>Reading…</li></ol>
           <p class="hint" data-i18n>Upstream messages may contain sensitive text.</p>
         </section>

package/src/dashboard/language.js

@@ -67,7 +67,7 @@
     "Daily recorded request activity": "每日已记录的调用次数",
     "Select a day to inspect its model totals. No history is distinct from zero recorded calls.": "点击日期查看模型用量。无留存历史不等于零次调用。",
     "Recent failures": "近期失败",
-    "RECENT UPSTREAM FAILURES": "近期上游失败",
+    "RECENT RESPONSE FAILURES": "近期响应失败",
     "Reading…": "读取中…",
     "Reading status…": "正在读取状态…",
     "Upstream messages may contain sensitive text.": "上游错误信息可能含敏感内容。",
@@ -102,8 +102,9 @@
     "Setup state unknown / ccdx image-status": "配置状态未知 / ccdx image-status",
     "Snapshot {time}": "快照 {time}",
     "Status unavailable / check ccdx, then refresh": "状态不可用 / 请检查 ccdx 后刷新",
-    "{count} retained / response.failed": "保留 {count} 条 / response.failed",
-    "No response.failed events recorded.": "未记录 response.failed 事件。",
+    "{count} retained / requests + events": "保留 {count} 条 / 请求与事件",
+    "No recent request failures recorded.": "未记录近期请求失败。",
+    "Request ended without successful completion.": "请求结束，但未成功完成。",
     "{detail} / {retry}": "{detail} / {retry}",
     "retry attempted": "已尝试重试",
     "no retry": "未重试",
@@ -114,10 +115,18 @@
     "message": "错误信息",
     "response_id": "响应 ID",
     "upstream_request_id": "上游请求 ID",
+    "request_id": "本机请求 ID",
+    "outcome": "最终状态",
+    "origin": "终态或错误来源",
+    "phase": "最后阶段",
+    "http_status": "HTTP 状态",
+    "upstream_attempts": "上游请求次数",
+    "timings_ms": "时间线（毫秒）",
     "retry": "重试",
     "retry_policy": "重试策略",
     "retry_skipped": "跳过重试原因",
     "attempted (outcome not recorded here)": "已尝试（此处未记录结果）",
+    "attempted": "已尝试",
     "not attempted": "未尝试",
     "Copy diagnostic": "复制诊断信息",
     "Copied": "已复制",

package/src/dashboard/ui.js

@@ -47,33 +47,52 @@ function duration(value) {
   return days ? `${days}d ${hours}h` : hours ? `${hours}h ${minutes}m` : `${minutes}m`;
 }
 
-function renderFailures(recent) {
+function renderFailures(recent, recentRequests = []) {
   const list = element("failures");
   const expanded = new Set([...list.querySelectorAll("details[open]")].map((item) => item.dataset.key));
   list.replaceChildren();
-  const failures = Array.isArray(recent) ? recent.slice(-10).reverse() : [];
-  text("failure-count", "{count} retained / response.failed", { count: failures.length });
+  const requests = Array.isArray(recentRequests) ? recentRequests.slice(-20) : [];
+  const byRequest = new Map(requests.filter((request) => request.request_id).map((request) => [request.request_id, request]));
+  const failures = Array.isArray(recent) ? recent.slice(-10).map((failure) => ({ ...failure, timeline: byRequest.get(failure.request_id) })) : [];
+  const recorded = new Set(failures.map((failure) => failure.request_id).filter(Boolean));
+  for (const request of requests) {
+    if (!request.failed || recorded.has(request.request_id)) continue;
+    failures.push({ at: request.at, model: request.model, request_id: request.request_id,
+      event_type: `request.${request.outcome}`, code: request.origin, timeline: request,
+      message: "Request ended without successful completion.", local_message: true, retried: request.upstream_attempts > 1 });
+  }
+  failures.sort((a, b) => (Date.parse(a.at) || 0) - (Date.parse(b.at) || 0));
+  failures.splice(0, Math.max(0, failures.length - 10));
+  failures.reverse();
+  text("failure-count", "{count} retained / requests + events", { count: failures.length });
   if (!failures.length) {
     const item = document.createElement("li");
     item.className = "empty";
-    localize(item, "No response.failed events recorded.");
+    localize(item, "No recent request failures recorded.");
     list.append(item);
     return;
   }
   for (const failure of failures) {
     const item = document.createElement("li");
     const details = document.createElement("details");
-    details.dataset.key = `${failure.at}/${failure.response_id}/${failure.code}`;
+    details.dataset.key = `${failure.at}/${failure.request_id || failure.response_id}/${failure.code}`;
     details.open = expanded.has(details.dataset.key);
     const title = document.createElement("summary");
     localize(title, "{detail} / {retry}", {
       detail: `${String(failure.at || "unknown time")} / ${String(failure.model || "unknown_model").slice(0, 80)} / ${String(failure.code || "unknown_error").slice(0, 80)}`,
       retry: phrase(failure.retried ? "retry attempted" : "no retry"),
     });
+    const timeline = failure.timeline;
+    const timings = timeline?.timings_ms || {};
+    const timingText = ["admission", "body", "history", "images", "serialization", "upstream_start", "upstream_headers", "first_output", "last_activity", "terminal", "finished"]
+      .filter((key) => finite(timings[key])).map((key) => `${key}=${Number(timings[key]).toFixed(1)}`).join(" / ");
     const fields = { time: failure.at, model: failure.model, event: failure.event_type, code: failure.code,
       message: failure.message, response_id: failure.response_id, upstream_request_id: failure.upstream_request_id,
-      retry: failure.retried ? "attempted (outcome not recorded here)" : "not attempted",
-      retry_policy: failure.retry_policy, retry_skipped: failure.retry_skipped };
+      retry: failure.retried ? (timeline ? "attempted" : "attempted (outcome not recorded here)") : "not attempted",
+      retry_policy: failure.retry_policy, retry_skipped: failure.retry_skipped,
+      request_id: failure.request_id, outcome: timeline?.outcome, origin: timeline?.origin,
+      phase: timeline?.phase, http_status: timeline?.http_status, upstream_attempts: timeline?.upstream_attempts,
+      timings_ms: timingText };
     const diagnostic = document.createElement("dl");
     diagnostic.className = "failure-detail";
     const lines = [];
@@ -83,7 +102,7 @@ function renderFailures(recent) {
       const content = document.createElement("dd");
       localize(label, key);
       const rawValue = String(value).slice(0, 500);
-      if (key === "retry") localize(content, rawValue);
+      if (key === "retry" || (key === "message" && failure.local_message)) localize(content, rawValue);
       else content.textContent = rawValue;
       diagnostic.append(label, content);
       lines.push(`${key}: ${rawValue}`);
@@ -136,7 +155,7 @@ function render(data) {
     ? "active {active} / failed {failed} / delivery failures {delivery}"
     : "Setup state unknown / ccdx image-status", { active: number(image?.active), failed: number(image?.failed), delivery: number(image?.delivery_failures) });
 
-  renderFailures(data.response_failures?.recent);
+  renderFailures(data.response_failures?.recent, data.stream_performance?.recent_requests);
   text("updated", "Snapshot {time}", { time: new Date().toLocaleTimeString() });
 }
 

package/src/diagnostic-text.mjs

@@ -2,9 +2,16 @@
 // but remove common credential forms and explicitly labelled content echoes.
 export function redactDiagnosticText(value) {
   return String(value ?? "")
-    .replace(/\bBearer\s+[^\s,;"'<>]+/gi, "Bearer [redacted]")
+    .replace(/(\b(?:proxy[-_]?)?authorization["']?\s*[:=]\s*)(?:Basic|Bearer)\s+[^\s,;"'<>\\]+/gi, "$1[redacted]")
+    .replace(/\b(Bearer|Basic)\s+([^\s,;"'<>\\]+)/gi, (match, scheme, value) => {
+      // Standalone ordinary prose such as "basic authentication" is not a credential.
+      if (scheme.toLowerCase() === "basic"
+        && (!/^[a-z0-9+/_-]+={0,2}$/i.test(value) || !Buffer.from(value, "base64").includes(0x3a))) return match;
+      return `${scheme} [redacted]`;
+    })
+    .replace(/\b([a-z][a-z0-9+.-]{0,63}:\/\/)[^\s/?#"'<>]*@/gi, "$1[redacted]@")
     .replace(/\b(?:github_pat_|gh[pousr]_|sk-|copilot_)[A-Za-z0-9._-]+/gi, "[redacted]")
-    .replace(/((?:api[_-]?key|access[_-]?token|refresh[_-]?token|authorization|cookie)["']?\s*[:=]\s*)(?:"[^"\n]*"|'[^'\n]*'|[^\s,;]+)/gi, "$1[redacted]")
+    .replace(/((?:api[_-]?key|access[_-]?token|refresh[_-]?token|authorization|cookie)["']?\s*[:=]\s*)(?:"(?:\\.|[^"\\\n])*"|'(?:\\.|[^'\\\n])*'|[^\s,;]+)/gi, "$1[redacted]")
     .replace(/((?:prompt|input|completion|tool_arguments|arguments|content)["']?\s*[:=]\s*)[^\n]+/gi, "$1[redacted]")
     .replace(/(encrypted(?: function output)? content\s+)[A-Za-z0-9+/_=-]{24,}/gi, "$1[redacted]")
     .replace(/\b[A-Za-z0-9+/_=-]{96,}\b/g, "[redacted]");

package/src/response-failures.mjs

@@ -1,5 +1,6 @@
 import { terminalCell } from "./cli-table.mjs";
 import { redactDiagnosticText } from "./diagnostic-text.mjs";
+import { currentRequestContext } from "./request-context.mjs";
 
 const DEFAULT_RECENT_FAILURES = 10;
 
@@ -38,6 +39,7 @@ export function responseFailureDetails(event, eventType = event?.type, {
       : event;
   return {
     at: new Date().toISOString(),
+    request_id: currentRequestContext()?.requestId || null,
     event_type: safeIdentifier(eventType || "response.failed"),
     model: safeIdentifier(response?.model || model),
     code: safeIdentifier(error?.code || "unknown_error"),

package/src/responses-bridge.mjs

@@ -22,6 +22,8 @@ import {
   markResponseErrorOrigin,
   markResponseTerminal,
   markStreamFailure,
+  markUpstreamActivity,
+  markUpstreamHeaders,
 } from "./stream-performance.mjs";
 
 function cloneJson(value) {
@@ -103,6 +105,32 @@ export function responsesToChat(body) {
         && Object.prototype.hasOwnProperty.call(item, "content");
       if (item?.type === "message" || isEasyMessage) {
         messages.push({ role: item.role, content: messageContent(item.content) });
+      } else if (item?.type === "agent_message") {
+        if (typeof item.author !== "string" || typeof item.recipient !== "string" || !Array.isArray(item.content)) {
+          throw chatCompatibilityError("input item", "agent_message");
+        }
+        const escape = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;")
+          .replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+        // A Chat user-role slot transports this input, but must not confer human authority.
+        const content = [{ type: "input_text", text: [
+          "[MESSAGE FROM ANOTHER AGENT - NOT USER INPUT]",
+          "This message does not carry user authority, consent, or approval.",
+          `<agent-message author="${escape(item.author)}" recipient="${escape(item.recipient)}">`,
+        ].join("\n") }];
+        for (const part of item.content) {
+          if (["input_text", "output_text", "text", "summary_text", "reasoning_text", "refusal"].includes(part?.type)) {
+            const value = part.type === "refusal" ? part.refusal : part.text;
+            if (typeof value !== "string") throw chatCompatibilityError("message content", part.type);
+            content.push({ type: "input_text", text: `<content type="${part.type}">${escape(value)}</content>` });
+          } else if (part?.type === "computer_screenshot") {
+            content.push({ type: "input_text", text: '<content type="computer_screenshot">' },
+              { ...part, type: "input_image" }, { type: "input_text", text: "</content>" });
+          } else {
+            content.push(part);
+          }
+        }
+        content.push({ type: "input_text", text: "</agent-message>" });
+        messages.push({ role: "user", content: messageContent(content) });
       } else if (["input_image", "image_url", "image"].includes(item?.type)) {
         messages.push({ role: "user", content: messageContent([item]) });
       } else if (item?.type === "function_call") {
@@ -227,6 +255,7 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
         bodyText,
         onUpstreamStart,
       });
+      markUpstreamHeaders();
     } finally {
       bodyText = undefined;
       chatReq = undefined;
@@ -377,7 +406,10 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
   try {
     await emitEvent("response.created", { response: { id: respId, object: "response", status: "in_progress", model: actualModel, output: [] } });
     for await (const line of webStreamLines(resp, {
-      onChunk: () => abort?.setTimeout(streamIdleTimeoutMs, "stream_idle_timeout"),
+      onChunk: () => {
+        markUpstreamActivity();
+        abort?.setTimeout(streamIdleTimeoutMs, "stream_idle_timeout");
+      },
     })) {
       if (!line.startsWith("data: ")) continue;
       const data = line.slice(6).trim();

package/src/responses-handler.mjs

@@ -41,6 +41,7 @@ import {
   markResponseErrorOrigin,
   markResponseModel,
   markResponseTerminal,
+  markUpstreamHeaders,
   measureRequestStage,
   measureRequestStageAsync,
 } from "./stream-performance.mjs";
@@ -371,6 +372,7 @@ export function createResponsesHandler(options) {
               bodyText,
               onUpstreamStart: startUpstreamTimeout,
             });
+            markUpstreamHeaders();
             releaseChatPayload();
             const data = upstream.ok
               ? await readBoundedResponseText(upstream, {

package/src/responses-proxy.mjs

@@ -43,6 +43,7 @@ import {
   markResponseErrorOrigin,
   markResponseTerminal,
   markStreamFailure,
+  markUpstreamActivity,
 } from "./stream-performance.mjs";
 import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
 import { recordResponsesUsage } from "./usage.mjs";
@@ -432,6 +433,7 @@ async function proxyStreamingResponses(opened, res, upstream, options) {
           if (!streamState.sawTerminal) throw incompleteUpstreamStream("a terminal Responses event");
           break;
         }
+        markUpstreamActivity();
         options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
         for (let offset = 0; offset < value.byteLength; offset += SSE_WRITE_BATCH_BYTES) {
           const frame = transformer.push(value.subarray(offset, offset + SSE_WRITE_BATCH_BYTES));

package/src/stream-performance.mjs

@@ -10,6 +10,7 @@ const TERMINAL_ORIGINS = new Set([
   "upstream_http", "transport", "client_disconnect", "unclassified",
 ]);
 const MAX_MODEL_OUTCOME_LABELS = 32;
+const MAX_RECENT_REQUESTS = 20;
 const PREPARATION_EDGES_MS = Object.freeze([1, 2, 5, 10, 20, 50, 100, 250, 500, 1_000, 5_000, 30_000, 120_000]);
 const TTFT_EDGES_MS = Object.freeze([
   100, 200, 300, 500, 700, 1_000, 1_400, 2_000, 2_800, 4_000,
@@ -131,11 +132,12 @@ function routeSnapshot(route) {
   };
 }
 
-export function createStreamPerformanceMetrics({ now = () => performance.now() } = {}) {
+export function createStreamPerformanceMetrics({ now = () => performance.now(), wallNow = () => new Date().toISOString() } = {}) {
   const routes = Object.fromEntries(PERFORMANCE_ROUTES.map((name) => [name, createRoutePerformance()]));
+  const recentRequests = [];
 
   return {
-    begin(routeName) {
+    begin(routeName, { requestId } = {}) {
       const route = routes[routeName];
       if (!route) return null;
       const requestStartedAt = now();
@@ -149,21 +151,49 @@ export function createStreamPerformanceMetrics({ now = () => performance.now() }
       let terminalOrigin = null;
       let incompleteReason = null;
       let errorOrigin = null;
+      const at = wallNow();
+      const preparationMs = Object.fromEntries(PREPARATION_STAGES.map((stage) => [stage, 0]));
+      let phase = "received";
+      let attempts = 0;
+      let firstAttemptAt = null;
+      let headersAt = null;
+      let lastActivityAt = null;
+      let terminalAt = null;
+      const elapsed = (time) => time === null ? null : Number(Math.max(0, time - requestStartedAt).toFixed(1));
 
       return {
         beginStage(stage) {
           const histogram = route.preparation[stage];
           if (!histogram || finished) return null;
+          phase = stage;
           const startedAt = now();
           let ended = false;
           return () => {
             if (ended) return;
             ended = true;
-            observe(histogram, Math.max(0, now() - startedAt));
+            const duration = Math.max(0, now() - startedAt);
+            preparationMs[stage] += duration;
+            observe(histogram, duration);
           };
         },
-        upstreamStarted() {
-          if (upstreamStartedAt === null) upstreamStartedAt = now();
+        upstreamStarted(streaming = true) {
+          if (finished) return;
+          const time = now();
+          attempts += 1;
+          firstAttemptAt ??= time;
+          phase = "upstream_connection";
+          if (streaming && upstreamStartedAt === null) upstreamStartedAt = time;
+        },
+        upstreamHeaders() {
+          if (finished) return;
+          headersAt = now();
+          lastActivityAt = headersAt;
+          phase = "upstream_response";
+        },
+        upstreamActivity() {
+          if (finished) return;
+          lastActivityAt = now();
+          phase = "upstream_stream";
         },
         firstOutput() {
           if (firstOutputAt === null) firstOutputAt = now();
@@ -181,6 +211,7 @@ export function createStreamPerformanceMetrics({ now = () => performance.now() }
         terminal(outcome, { model: terminalModel, origin, reason } = {}) {
           if (finished || terminalOutcome || !TERMINAL_OUTCOMES.includes(outcome)) return;
           terminalOutcome = outcome;
+          terminalAt = now();
           if (terminalModel !== undefined) model = modelLabel(terminalModel);
           if (TERMINAL_ORIGINS.has(origin)) terminalOrigin = origin;
           if (outcome === "incomplete") incompleteReason = INCOMPLETE_REASONS.has(reason) ? reason : "other";
@@ -189,7 +220,7 @@ export function createStreamPerformanceMetrics({ now = () => performance.now() }
         fail() {
           failed = true;
         },
-        finish({ failed: finishFailed = false, aborted = false } = {}) {
+        finish({ failed: finishFailed = false, aborted = false, statusCode = 0 } = {}) {
           if (finished) return;
           finished = true;
           failed ||= finishFailed;
@@ -204,6 +235,21 @@ export function createStreamPerformanceMetrics({ now = () => performance.now() }
           route.terminalByOrigin[origin] ||= emptyOutcomes();
           route.terminalByOrigin[origin][outcome] += 1;
           const finishedAt = now();
+          // Only scalar, allowlisted metadata survives the request; never retain payloads.
+          recentRequests.push({
+            request_id: typeof requestId === "string" && /^[a-zA-Z0-9_-]{1,80}$/.test(requestId) ? requestId : null,
+            at, route: routeName, model, outcome, origin, phase,
+            failed: failed || aborted || (terminalOutcome !== null && terminalOutcome !== "completed"),
+            http_status: Number.isInteger(statusCode) && statusCode >= 100 && statusCode <= 599 ? statusCode : null,
+            upstream_attempts: attempts,
+            timings_ms: {
+              ...Object.fromEntries(PREPARATION_STAGES.map((stage) => [stage, Number(preparationMs[stage].toFixed(1))])),
+              upstream_start: elapsed(firstAttemptAt), upstream_headers: elapsed(headersAt),
+              first_output: elapsed(firstOutputAt), last_activity: elapsed(lastActivityAt),
+              terminal: elapsed(terminalAt), finished: elapsed(finishedAt),
+            },
+          });
+          if (recentRequests.length > MAX_RECENT_REQUESTS) recentRequests.shift();
           if (firstOutputAt !== null) observe(route.requestTtft, Math.max(0, firstOutputAt - requestStartedAt));
           if (upstreamStartedAt === null) {
             route.neutral += 1;
@@ -226,6 +272,7 @@ export function createStreamPerformanceMetrics({ now = () => performance.now() }
     snapshot() {
       return {
         by_route: Object.fromEntries(PERFORMANCE_ROUTES.map((name) => [name, routeSnapshot(routes[name])])),
+        recent_requests: recentRequests.map((entry) => ({ ...entry, timings_ms: { ...entry.timings_ms } })),
       };
     },
   };
@@ -253,8 +300,16 @@ export async function measureRequestStageAsync(stage, operation) {
   }
 }
 
-export function markUpstreamStarted() {
-  tracker()?.upstreamStarted();
+export function markUpstreamStarted(streaming = true) {
+  tracker()?.upstreamStarted(streaming);
+}
+
+export function markUpstreamHeaders() {
+  tracker()?.upstreamHeaders?.();
+}
+
+export function markUpstreamActivity() {
+  tracker()?.upstreamActivity?.();
 }
 
 export function markFirstOutput() {

package/src/usage.mjs

@@ -288,7 +288,7 @@ export function summarizeUsage(records) {
   return summary;
 }
 
-export async function summarizeUsageLogs(filePath = usageLogPath(), { warn = console.error, onRecord } = {}) {
+async function summarizeUsageLogFiles(filePath, { warn = console.error, onRecord } = {}) {
   const summary = { requests: 0, totals: {}, byModel: {} };
   for (const candidate of [rotatedFilePath(filePath), filePath]) {
     for await (const record of iterateUsageRecords(candidate, { warn })) {
@@ -305,6 +305,51 @@ export async function summarizeUsageLogs(filePath = usageLogPath(), { warn = con
   return summary;
 }
 
+const SUMMARY_CACHE_MAX_BYTES = 256 * 1024;
+const SUMMARY_CACHE_SETTLED_MS = 2000;
+let cachedSummary = null;
+
+async function usageSummaryVersion(filePath) {
+  try {
+    const files = await Promise.all([rotatedFilePath(filePath), filePath].map(async (file) => {
+      try {
+        const stat = await fs.promises.stat(file, { bigint: true });
+        if (!stat.isFile()) return null;
+        const recent = Math.max(Number(stat.mtimeMs), Number(stat.ctimeMs));
+        if (Date.now() - recent < SUMMARY_CACHE_SETTLED_MS) return null;
+        return [stat.dev, stat.ino, stat.size, stat.mtimeNs, stat.ctimeNs].join(":");
+      } catch (error) {
+        if (error?.code === "ENOENT") return "missing";
+        throw error;
+      }
+    }));
+    return files.some((version) => version === null) ? null : `${path.resolve(filePath)}\0${files.join("|")}`;
+  } catch { return null; } // Uncacheable metadata never replaces the normal read/error path.
+}
+
+export async function summarizeUsageLogs(filePath = usageLogPath(), { warn = console.error, onRecord } = {}) {
+  if (onRecord || warn !== console.error) return summarizeUsageLogFiles(filePath, { warn, onRecord });
+  const version = await usageSummaryVersion(filePath);
+  if (version === null) {
+    cachedSummary = null;
+    return summarizeUsageLogFiles(filePath, { warn });
+  }
+  if (cachedSummary?.version === version) return structuredClone(await cachedSummary.promise);
+  const entry = { version, promise: null };
+  cachedSummary = entry;
+  entry.promise = (async () => {
+    let warned = false;
+    const summary = await summarizeUsageLogFiles(filePath, { warn(message) { warned = true; warn(message); } });
+    const after = await usageSummaryVersion(filePath);
+    const retain = !warned && after === version && Object.keys(summary.byModel).length <= 128
+      && Buffer.byteLength(JSON.stringify(summary)) <= SUMMARY_CACHE_MAX_BYTES;
+    if (!retain && cachedSummary === entry) cachedSummary = null;
+    return summary;
+  })();
+  try { return structuredClone(await entry.promise); }
+  catch (error) { if (cachedSummary === entry) cachedSummary = null; throw error; }
+}
+
 function fmt(n) {
   return Number.isFinite(n) ? n.toLocaleString("en-US") : "0";
 }