codex-copilot-dx 0.8.6 → 0.8.7

package/README.md

@@ -12,7 +12,7 @@ One in-process adapter listens on `127.0.0.1:2026` by default and exposes:
 - `POST /v1/responses/compact`
 - `GET /v1/models`
 
-Responses-only models and compaction use Copilot's Responses transport directly. For GPT models that advertise only Chat Completions, CCDX converts the supported text, image, and function-tool subset and rejects incompatible request shapes explicitly. Both streaming SSE and non-streaming responses are supported.
+Responses-only models and compaction use Copilot's Responses transport directly. For requests routed through Chat Completions, CCDX converts the supported text, image, and function-tool subset and rejects incompatible message content rather than turning it into JSON text. Chat `length` and `content_filter` finish reasons become incomplete Responses in both streaming and non-streaming modes. Both streaming SSE and non-streaming responses are supported.
 
 The adapter handles response history, encrypted reasoning state, function/custom tools, images, compaction, cancellation, retries, and usage metadata within the compatibility boundaries below. Routing prefers endpoint metadata from Copilot's live or cached catalog; when metadata is unavailable, a small built-in set identifies known Responses-only GPT models.
 
@@ -259,7 +259,7 @@ For the complete machine-readable status payload:
 curl -s http://127.0.0.1:2026/_ccdx/status | jq
 ```
 
-The status endpoint is restricted to the socket's real loopback address even when LAN binding is explicitly enabled. It reports fixed-size request counters, bounded TTFT/TPOT histograms, admission pressure, memory use, response-history size, image queue/cache and adaptive-history state, model-cache counts, token expiry state, and the ten most recent upstream `response.failed` diagnostics retained by the running process. Failure diagnostics include the event type, model, error code/message, response/request IDs when supplied upstream, and retry outcome. Common credential forms, long opaque encrypted values, and explicitly labelled input/prompt/tool-content echoes are redacted. They are cleared when the adapter restarts. No request/response bodies, credential fields, or account profiles are copied into status. Arbitrary upstream prose cannot be guaranteed free of sensitive content; review diagnostics before sharing them.
+The status endpoint is restricted to the socket's real loopback address even when LAN binding is explicitly enabled. It reports fixed-size HTTP request counters separately from bounded `completed` / `incomplete` / `failed` / `cancelled` response outcomes by model and origin, plus bounded incomplete-reason counts, TTFT/TPOT histograms, admission pressure, memory use, response-history size/tree concentration/lookup misses, image queue/cache and adaptive-history state, model-cache counts, token expiry state, and the ten most recent upstream `response.failed` diagnostics retained by the running process. HTTP errors without a model terminal remain "without terminal" and retain their known origin; they are not counted as model failures. History eviction markers are not failed-request counts; `ccdx status` warns near the cache limit without deleting or compressing history. Failure diagnostics include the event type, model, error code/message, response/request IDs when supplied upstream, and retry outcome. Common credential forms, long opaque encrypted values, and explicitly labelled input/prompt/tool-content echoes are redacted. They are cleared when the adapter restarts. No request/response bodies, credential fields, or account profiles are copied into status. Arbitrary upstream prose cannot be guaranteed free of sensitive content; review diagnostics before sharing them.
 
 `image_mcp` has its own HTTP route counter. After the image handler has been used, `image_generation` separately reports active, succeeded, failed, busy, cancelled, and chat-file delivery-failure counts, including tool errors returned with HTTP 200. A delivery failure can accompany a successful generation; it never causes another generation. Before handler initialization this field is `null`, meaning not observed, not necessarily disabled. Status never initializes that handler, reads its provider credential, installs guidance, or probes the provider. Input-image optimization metrics remain separate. `logging` reports pending records/bytes, queue caps, overflow drops, and write failures for usage and enabled debug-file logging.
 
@@ -367,7 +367,7 @@ Set `CCDX_LOG_PATH=1` to mirror terminal logs to `~/.local/share/codex-copilot-d
 
 Long computer-use sessions can accumulate screenshots that are sent again on later turns. This can increase local preparation time, upstream handshake latency, and the chance of a `413 Payload Too Large` response.
 
-The response-history cache is process-local and byte/entry bounded. Restarting the adapter discards it; a `previous_response_id` stored only in that process becomes unavailable. CCDX does not persist conversation history to disk. Clients can still submit explicit history in the request body, subject to the same limits.
+The response-history cache is process-local and byte/entry bounded. Restarting the adapter discards it; a `previous_response_id` stored only in that process becomes unavailable. CCDX does not persist conversation history to disk. Near-limit status diagnostics report the largest tree and actual lookup misses, but do not recover an already evicted ID or change the cache budget. Clients can still submit explicit history in the request body, subject to the same limits.
 
 CCDX attempts to downsample inline base64 images to model-appropriate pixel bounds, with a 2048 px long-edge fallback, and initially encodes them as WebP quality 82. It never replaces an image with a larger encoding and uses one global concurrency limit across direct images and function/custom-tool outputs. GIFs and non-inline references are not re-encoded. An encoding/decode failure keeps the original image; the final request-byte limit still applies.
 

package/package.json

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

package/src/adapter.mjs

@@ -389,7 +389,7 @@ export function createAdapterHandler(options = {}) {
       if (requestFinished) return;
       requestFinished = true;
       try { complete({ statusCode, aborted }); } catch {}
-      try { streamPerformance?.finish({ failed: aborted || statusCode >= 400 }); } catch {}
+      try { streamPerformance?.finish({ failed: aborted || statusCode >= 400, aborted }); } catch {}
       try { finishTerminalActivity(); } catch {}
     };
     const containUnexpectedError = (error) => {

package/src/cli-status.mjs

@@ -132,6 +132,7 @@ export async function readAdapterStatus({
 export function formatAdapterStatus({ baseUrl, data }, { commandName = "ccdx", cliVersion = data.version } = {}) {
   const requests = data.requests || {};
   const performance = data.stream_performance?.by_route?.responses || {};
+  const terminalOutcomes = performance.terminal_outcomes?.totals;
   const admission = data.admission || {};
   const history = data.response_history || {};
   const images = data.image_optimization || {};
@@ -150,11 +151,18 @@ export function formatAdapterStatus({ baseUrl, data }, { commandName = "ccdx", c
     adapterLine,
     status("info", `Requests: ${count(requests.completed)}/${count(requests.total)} completed, ${count(requests.active)} active, ${count(requests.status_4xx)} 4xx, ${count(requests.status_5xx)} 5xx, ${count(requests.aborted)} aborted`),
     status("info", `Responses stream: TTFT avg ${latency(performance.ttft_ms?.avg)} (${count(performance.ttft_ms?.samples)} samples), TPOT avg ${tpot(performance.tpot_us)}`),
+    ...(terminalOutcomes ? [status("info", `Model outcomes: ${count(terminalOutcomes.completed)} completed, ${count(terminalOutcomes.incomplete)} incomplete, ${count(terminalOutcomes.failed)} failed, ${count(terminalOutcomes.cancelled)} cancelled, ${count(terminalOutcomes.unknown)} without terminal`)] : []),
     status("info", `Admission: ${count(admission.activeRequests)} active, ${count(admission.queued)} queued, ${count(admission.rejected)} rejected, ${count(admission.timedOut)} timed out, wait avg ${latency(admission.waitMsAvg)}`),
     status("info", `Memory: RSS ${mebibytes(processStats.rss_bytes)}, heap ${mebibytes(processStats.heap_used_bytes)}`),
-    status("info", `History: ${mebibytes(history.bytes)} / ${mebibytes(limits.response_history_max_bytes)}, ${count(history.entries)} entries, ${count(history.evicted)} evicted`),
+    status("info", `History: ${mebibytes(history.bytes)} / ${mebibytes(limits.response_history_max_bytes)}, ${count(history.entries)} entries, ${count(history.evicted)} evicted ID markers`),
     status("info", `Image cache: ${count(images.cache_entries)} entries, ${cacheHitRate(images)} hits, ${mebibytes(images.cache_bytes)} / ${mebibytes(images.cache_max_bytes)}`),
   ];
+  if (Number.isFinite(history.tree_count)) {
+    const limit = Number(limits.response_history_max_bytes || history.maxBytes);
+    const nearLimit = Number.isFinite(limit) && limit > 0 && history.bytes / limit >= 0.9;
+    lines.push(status(nearLimit ? "warn" : "info",
+      `${nearLimit ? "History near limit" : "History diagnostics"}: largest tree ${mebibytes(history.largest_tree_bytes)} across ${count(history.tree_count)} trees; ${count(history.lookup_misses)} lookup misses, ${count(history.evicted_lookup_misses)} for evicted IDs`));
+  }
   if (imageHistory && typeof imageHistory === "object") {
     lines.push(status("info", `Visual history: ${count(imageHistory.active_recovery_trees)} recovery trees, ${count(imageHistory.adapted_requests)} adapted requests, ${count(imageHistory.historical_images_omitted)} older images omitted, ${count(imageHistory.timeouts_recorded)} timeouts`));
   }

package/src/response-history.mjs

@@ -81,6 +81,9 @@ const treeLru = new Map();
 const pinnedTrees = new Map();
 const evictedIds = new Set();
 let totalBytes = 0;
+let evictedEntriesTotal = 0;
+let lookupMisses = 0;
+let evictedLookupMisses = 0;
 const HISTORY_RUNTIME_CONFIG = loadRuntimeConfig();
 let maxBytes = HISTORY_RUNTIME_CONFIG.responseHistoryMaxBytes;
 let maxEntries = HISTORY_RUNTIME_CONFIG.responseHistoryMaxEntries;
@@ -133,6 +136,7 @@ function removeSubtree(rootId) {
   const pending = [rootId];
   const removed = new Set();
   const affectedRoots = new Set();
+  let removedEntries = 0;
   while (pending.length) {
     const id = pending.pop();
     if (removed.has(id)) continue;
@@ -149,7 +153,9 @@ function removeSubtree(rootId) {
     totalBytes -= entry.bytes;
     histories.delete(id);
     rememberEvictedId(id);
+    removedEntries += 1;
   }
+  evictedEntriesTotal += removedEntries;
   for (const affectedRoot of affectedRoots) {
     const entry = histories.get(affectedRoot);
     if (!entry || entry.rootId !== affectedRoot) treeLru.delete(affectedRoot);
@@ -223,6 +229,9 @@ export function clearResponseHistory() {
   pinnedTrees.clear();
   evictedIds.clear();
   totalBytes = 0;
+  evictedEntriesTotal = 0;
+  lookupMisses = 0;
+  evictedLookupMisses = 0;
   return removed;
 }
 
@@ -253,7 +262,18 @@ export function configureResponseHistoryForTests({ maxBytes: nextMaxBytes, maxEn
 }
 
 export function responseHistoryStats() {
+  const trees = new Map();
+  for (const entry of histories.values()) {
+    trees.set(entry.rootId, (trees.get(entry.rootId) || 0) + entry.bytes);
+  }
+  let largestTreeBytes = 0;
+  for (const bytes of trees.values()) largestTreeBytes = Math.max(largestTreeBytes, bytes);
   return { entries: histories.size, bytes: totalBytes, evicted: evictedIds.size,
+    evicted_entries_total: evictedEntriesTotal,
+    lookup_misses: lookupMisses,
+    evicted_lookup_misses: evictedLookupMisses,
+    tree_count: trees.size,
+    largest_tree_bytes: largestTreeBytes,
     pinnedTrees: pinnedTrees.size, maxBytes, maxEntries };
 }
 
@@ -270,7 +290,10 @@ function responseHistoryChain(responseId) {
     seen.add(currentId);
     const entry = histories.get(currentId);
     if (!entry) {
-      const reason = evictedIds.has(currentId) ? " was evicted after reaching the local history limit" : " is not available";
+      lookupMisses += 1;
+      const wasEvicted = evictedIds.has(currentId);
+      if (wasEvicted) evictedLookupMisses += 1;
+      const reason = wasEvicted ? " was evicted after reaching the local history limit" : " is not available";
       throw httpError(`previous_response_id${reason}: ${currentId}`, 400);
     }
     chain.push(entry);

package/src/responses-bridge.mjs

@@ -15,7 +15,14 @@ import {
   upstreamChatStreamError,
   withChatStreamUsage,
 } from "./stream-contract.mjs";
-import { isChatOutputDelta, markFirstOutput, markOutputTokens } from "./stream-performance.mjs";
+import {
+  isChatOutputDelta,
+  markFirstOutput,
+  markOutputTokens,
+  markResponseErrorOrigin,
+  markResponseTerminal,
+  markStreamFailure,
+} from "./stream-performance.mjs";
 
 function cloneJson(value) {
   return value === undefined ? undefined : structuredClone(value);
@@ -66,18 +73,20 @@ export function responsesToChat(body) {
 
   const messageContent = (content) => {
     if (typeof content === "string") return content;
-    if (!Array.isArray(content)) return JSON.stringify(content);
+    if (content === null) return null;
+    if (!Array.isArray(content)) throw chatCompatibilityError("message content", typeof content);
     const parts = [];
     for (const part of content) {
-      if (!part || typeof part !== "object") continue;
+      if (!part || typeof part !== "object") throw chatCompatibilityError("message content", part?.type);
       if (["input_text", "output_text", "text"].includes(part.type)) {
-        parts.push({ type: "text", text: String(part.text || "") });
+        if (typeof part.text !== "string") throw chatCompatibilityError("message content", part.type);
+        parts.push({ type: "text", text: part.text });
       } else if (["input_image", "image_url", "image"].includes(part.type)) {
         const imagePart = chatImagePart(part);
         if (imagePart) parts.push(imagePart);
-        else parts.push({ type: "text", text: JSON.stringify(part) });
+        else throw chatCompatibilityError("message content", part.type);
       } else {
-        parts.push({ type: "text", text: JSON.stringify(part) });
+        throw chatCompatibilityError("message content", part.type);
       }
     }
     if (parts.length === 1 && parts[0].type === "text") return parts[0].text;
@@ -176,11 +185,20 @@ export function responsesToChat(body) {
 
 function uid() { return randomUUID().replace(/-/g, ""); }
 
+function chatTerminal(finishReason) {
+  const reason = finishReason === "length" ? "max_output_tokens"
+    : finishReason === "content_filter" ? "content_filter" : null;
+  return reason
+    ? { status: "incomplete", incomplete_details: { reason } }
+    : { status: "completed" };
+}
+
 export function chatToResponses(chatResp, model) {
   const id = `resp_${uid()}`, choice = chatResp.choices?.[0], msg = choice?.message, output = [];
-  if (msg?.content) output.push({ type: "message", id: `msg_${uid()}`, role: "assistant", status: "completed", content: [{ type: "output_text", text: msg.content }] });
-  if (msg?.tool_calls) for (const tc of msg.tool_calls) output.push({ type: "function_call", id: tc.id, call_id: tc.id, name: tc.function.name, arguments: tc.function.arguments, status: "completed" });
-  return { id, object: "response", status: "completed", model: chatResp.model || model, output, usage: chatResp.usage ? { input_tokens: chatResp.usage.prompt_tokens || 0, output_tokens: chatResp.usage.completion_tokens || 0, total_tokens: chatResp.usage.total_tokens || 0 } : undefined };
+  const terminal = chatTerminal(choice?.finish_reason);
+  if (msg?.content) output.push({ type: "message", id: `msg_${uid()}`, role: "assistant", status: terminal.status, content: [{ type: "output_text", text: msg.content }] });
+  if (msg?.tool_calls) for (const tc of msg.tool_calls) output.push({ type: "function_call", id: tc.id, call_id: tc.id, name: tc.function.name, arguments: tc.function.arguments, status: terminal.status });
+  return { id, object: "response", ...terminal, model: chatResp.model || model, output, usage: chatResp.usage ? { input_tokens: chatResp.usage.prompt_tokens || 0, output_tokens: chatResp.usage.completion_tokens || 0, total_tokens: chatResp.usage.total_tokens || 0 } : undefined };
 }
 
 export async function forwardToChat(chatReq, emitEvent, onDone, onError, options = {}) {
@@ -216,11 +234,15 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
       releaseRequest?.();
     }
   } catch (e) {
+    markResponseErrorOrigin("transport");
+    markStreamFailure();
     const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(abort?.reason) : 502;
     await onError(statusCode, e.message);
     return false;
   }
   if (!resp.ok) {
+    markResponseErrorOrigin("upstream_http");
+    markStreamFailure();
     await onError(resp.status, await readBoundedResponseText(resp, {
       maxBytes: MAX_UPSTREAM_ERROR_BODY_BYTES,
       label: "Copilot Chat error body",
@@ -230,6 +252,8 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
   try {
     await requireUpstreamEventStream(resp);
   } catch (error) {
+    markResponseErrorOrigin("transport");
+    markStreamFailure();
     await onError(error.statusCode, error.message, error);
     return false;
   }
@@ -237,6 +261,7 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
   abort?.setTimeout(streamIdleTimeoutMs, "stream_idle_timeout");
   const respId = `resp_${uid()}`;
   let actualModel = requestModel;
+  let finishReason = null;
   let fullText = "";
   let messageItem = null;
   let nextOutputIndex = 0;
@@ -298,7 +323,8 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
     return { tool, created: true };
   };
 
-  const emitCompleted = async () => {
+  const emitTerminal = async () => {
+    const terminal = chatTerminal(finishReason);
     if (!messageItem && toolCalls.size === 0) await ensureMessageItem();
     const output = [];
     if (messageItem) {
@@ -306,7 +332,7 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
         type: "message",
         id: messageItem.id,
         role: "assistant",
-        status: "completed",
+        status: terminal.status,
         content: [{ type: "output_text", text: fullText }],
       };
       await emitEvent("response.output_text.done", { output_index: messageItem.outputIndex, content_index: 0, text: fullText });
@@ -321,7 +347,7 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
         call_id: tool.callId,
         name: tool.name,
         arguments: tool.arguments,
-        status: "completed",
+        status: terminal.status,
       };
       await emitEvent("response.function_call_arguments.done", {
         output_index: tool.outputIndex,
@@ -331,16 +357,21 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
       await emitEvent("response.output_item.done", { output_index: tool.outputIndex, item });
       output[tool.outputIndex] = item;
     }
-    await emitEvent("response.completed", {
+    if (terminal.status === "incomplete") markStreamFailure();
+    await emitEvent(`response.${terminal.status}`, {
       response: {
         id: respId,
         object: "response",
-        status: "completed",
+        ...terminal,
         model: actualModel,
         output: output.filter(Boolean),
         usage,
       },
     });
+    markResponseTerminal(terminal.status, {
+      model: actualModel, origin: "chat_completion", reason: terminal.incomplete_details?.reason,
+    });
+    return terminal.status === "completed";
   };
 
   try {
@@ -350,7 +381,7 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
     })) {
       if (!line.startsWith("data: ")) continue;
       const data = line.slice(6).trim();
-      if (data === "[DONE]") { await emitCompleted(); onDone(); return true; }
+      if (data === "[DONE]") { const completed = await emitTerminal(); onDone(); return completed; }
       let parsed;
       try {
         parsed = JSON.parse(data);
@@ -373,7 +404,9 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
         if (cached) usage.input_tokens_details = { cached_tokens: cached };
         markOutputTokens(usage.output_tokens);
       }
-      const delta = parsed.choices?.[0]?.delta;
+      const choice = parsed.choices?.[0];
+      if (choice?.finish_reason) finishReason = choice.finish_reason;
+      const delta = choice?.delta;
       if (!delta) continue;
       if (isChatOutputDelta(delta)) markPerformanceOutput();
       if (delta.content) {
@@ -401,14 +434,19 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
     }
   } catch (e) {
     if (e === downstreamClosed) {
+      markResponseTerminal("cancelled", { model: actualModel, origin: "client_disconnect" });
       await resp.body?.cancel?.().catch?.(() => {});
       return false;
     }
+    markResponseErrorOrigin("transport");
+    markStreamFailure();
     const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(abort?.reason) : (e?.statusCode || 502);
     await onError(statusCode, e?.message || "upstream stream error", e);
     return false;
   }
   const error = incompleteUpstreamStream("[DONE]");
+  markResponseErrorOrigin("transport");
+  markStreamFailure();
   await onError(error.statusCode, error.message, error);
   return false;
 }

package/src/responses-handler.mjs

@@ -37,7 +37,13 @@ import { status } from "./status.mjs";
 import { endStreamWithError } from "./stream-errors.mjs";
 import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
 import { recordResponsesUsage } from "./usage.mjs";
-import { measureRequestStage, measureRequestStageAsync } from "./stream-performance.mjs";
+import {
+  markResponseErrorOrigin,
+  markResponseModel,
+  markResponseTerminal,
+  measureRequestStage,
+  measureRequestStageAsync,
+} from "./stream-performance.mjs";
 
 const RESPONSES_ONLY_FALLBACK = new Set([
   "gpt-5.6-luna",
@@ -267,6 +273,7 @@ export function createResponsesHandler(options) {
       stripUnsupportedGpt6ServiceTier(prepared.body, requestedModel, upstreamModel, priorityTierModel);
       if (requestedModel === CODEX_AUTO_REVIEW_MODEL) delete prepared.body.service_tier;
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
+      markResponseModel(upstreamModel);
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
       console.log(status("info", `responses model=${requestedModel}${upstreamLog} stream=${streaming}`));
       const usesCustomTools = responsesBodyUsesCustomTools(prepared.body);
@@ -322,19 +329,21 @@ export function createResponsesHandler(options) {
             });
             const written = await writeOrDrain(res, `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`, { signal: abort.signal });
             if (!written) return false;
-            if (event === "response.completed") {
-              rememberResponseHistory(prepared, data.response);
+            if (event === "response.completed" || event === "response.incomplete") {
+              if (event === "response.completed") rememberResponseHistory(prepared, data.response);
               recordResponsesUsage({ surface: prepared.surface, mode: "stream", model, response: data.response, event: data });
             }
             return true;
           }, () => { if (!res.writableEnded) res.end(); }, async (statusCode, errMsg, error, upstreamResponse) => {
             if (!res.headersSent) {
               if (upstreamResponse) {
+                markResponseErrorOrigin("upstream_http");
                 markAdaptiveHttpTimeout(upstreamResponse.status);
                 sendUpstreamError(res, upstreamResponse, errMsg);
                 return;
               }
               const responseError = applyAdaptiveTimeout(error || Object.assign(new Error(errMsg), { statusCode }));
+              markResponseErrorOrigin("transport");
               sendJsonError(res, responseError, statusCode || 500);
               return;
             }
@@ -374,13 +383,17 @@ export function createResponsesHandler(options) {
                 label: "Copilot Chat error body",
               });
             if (!upstream.ok) {
+              markResponseErrorOrigin("upstream_http");
               markAdaptiveHttpTimeout(upstream.status);
               sendUpstreamError(res, upstream, data);
               return;
             }
             const response = chatToResponses(JSON.parse(data), model);
+            markResponseTerminal(response.status, {
+              model: response.model || model, origin: "chat_completion", reason: response.incomplete_details?.reason,
+            });
             rememberResponseHistory(prepared, response);
-            imagePressure?.markSuccess?.(responseHistoryPressureRootId(prepared));
+            if (response.status === "completed") imagePressure?.markSuccess?.(responseHistoryPressureRootId(prepared));
             recordResponsesUsage({ surface: prepared.surface, mode: "json", model, response, event: response });
             res.writeHead(200, safeUpstreamResponseHeaders(upstream.headers, {
               contentType: "application/json",
@@ -388,6 +401,8 @@ export function createResponsesHandler(options) {
             res.end(JSON.stringify(response));
           } catch (error) {
             const responseError = applyAdaptiveTimeout(error);
+            markResponseErrorOrigin(responseError?.statusCode >= 400 && responseError.statusCode < 500
+              ? "client_validation" : "transport");
             logRequestFailure("Responses", responseError, abort);
             sendJsonError(res, responseError, 502);
           }
@@ -397,6 +412,8 @@ export function createResponsesHandler(options) {
       }
     } catch (error) {
       const responseError = applyAdaptiveTimeout(error);
+      markResponseErrorOrigin(responseError?.statusCode >= 400 && responseError.statusCode < 500
+        ? "client_validation" : "transport");
       logRequestFailure("Responses", responseError, abort);
       sendJsonError(res, responseError, 502);
     } finally {

package/src/responses-proxy.mjs

@@ -40,6 +40,8 @@ import {
   isResponsesOutputEvent,
   markFirstOutput,
   markOutputTokens,
+  markResponseErrorOrigin,
+  markResponseTerminal,
   markStreamFailure,
 } from "./stream-performance.mjs";
 import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
@@ -146,6 +148,8 @@ function inspectResponseSseEvent(state, eventName, data) {
   if (eventType === "response.completed") {
     const response = event.response;
     state.completed = { response, event };
+  } else if (eventType === "response.incomplete") {
+    state.incomplete = { response: event.response, event };
   }
   return changed ? event : null;
 }
@@ -370,6 +374,7 @@ async function proxyStreamingResponses(opened, res, upstream, options) {
       usedRetryPolicies = new Set(),
     } = opened;
     if (errorText !== undefined) {
+      markResponseErrorOrigin("upstream_http");
       sendUpstreamError(res, resp, errorText);
       return { successful: false, compacted: false, upstreamStatus: resp.status };
     }
@@ -386,6 +391,7 @@ async function proxyStreamingResponses(opened, res, upstream, options) {
     const reader = resp.body.getReader();
     const streamState = {
       completed: null,
+      incomplete: null,
       failure: null,
       sawTerminal: false,
       sawOutput: false,
@@ -467,12 +473,28 @@ async function proxyStreamingResponses(opened, res, upstream, options) {
         }
         continue;
       }
-      if (streamState.failure) markStreamFailure();
       if (holdPrelude && !await flushPrelude()) return { successful: false, compacted: false };
+      if (streamState.completed) {
+        markResponseTerminal("completed", {
+          model: streamState.completed.response.model || reqContext.body?.model,
+          origin: "upstream_response",
+        });
+      } else if (streamState.incomplete) {
+        markResponseTerminal("incomplete", {
+          model: streamState.incomplete.response.model || reqContext.body?.model,
+          origin: "upstream_response",
+          reason: streamState.incomplete.response.incomplete_details?.reason,
+        });
+      } else if (streamState.failure) {
+        markStreamFailure();
+        markResponseTerminal("failed", { model: reqContext.body?.model, origin: "upstream_event" });
+      }
       storeCompletedResponse(reqContext, streamState.completed);
       if (!res.writableEnded) res.end();
       return { successful: Boolean(streamState.completed), compacted: false };
     } catch (error) {
+      markResponseErrorOrigin("transport");
+      markStreamFailure();
       logRequestFailure("Responses", error, options.abort);
       writeHeaders();
       await endStreamWithError(res, error, options.abort);
@@ -502,6 +524,7 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
     const { resp, errorText, usedRetryPolicies = new Set() } = opened;
     reqContext = opened.reqContext;
     if (errorText !== undefined) {
+      markResponseErrorOrigin("upstream_http");
       sendUpstreamError(res, resp, errorText);
       return { successful: false, compacted: false, upstreamStatus: resp.status };
     }
@@ -528,6 +551,7 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
         response,
         event: response,
       });
+      markResponseTerminal("completed", { model: response.model || reqContext.body?.model, origin: "upstream_response" });
       res.writeHead(resp.status, safeUpstreamResponseHeaders(resp.headers, {
         contentType: "application/json",
       }));
@@ -572,6 +596,13 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
         response,
         event: response,
       });
+      if (["completed", "incomplete", "failed"].includes(response.status)) {
+        markResponseTerminal(response.status, {
+          model: response.model || reqContext.body?.model,
+          origin: "upstream_response",
+          reason: response.incomplete_details?.reason,
+        });
+      }
       res.writeHead(resp.status, safeUpstreamResponseHeaders(resp.headers, {
         contentType: "application/json",
       }));
@@ -581,6 +612,7 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
     res.writeHead(resp.status, safeUpstreamResponseHeaders(resp.headers, {
       contentType: "application/json",
     }));
+    markResponseErrorOrigin("upstream_http");
     res.end(data);
     return { successful: false, compacted: false };
   }

package/src/stream-performance.mjs

@@ -3,6 +3,13 @@ import { currentRequestContext } from "./request-context.mjs";
 
 const PERFORMANCE_ROUTES = Object.freeze(["responses", "responses_compact"]);
 const PREPARATION_STAGES = Object.freeze(["admission", "body", "history", "images", "serialization"]);
+const TERMINAL_OUTCOMES = Object.freeze(["completed", "incomplete", "failed", "cancelled", "unknown"]);
+const INCOMPLETE_REASONS = new Set(["max_output_tokens", "max_messages", "content_filter", "steered"]);
+const TERMINAL_ORIGINS = new Set([
+  "upstream_response", "upstream_event", "chat_completion", "client_validation",
+  "upstream_http", "transport", "client_disconnect", "unclassified",
+]);
+const MAX_MODEL_OUTCOME_LABELS = 32;
 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,
@@ -78,6 +85,16 @@ function histogramSnapshot(histogram, unit) {
   };
 }
 
+function emptyOutcomes() {
+  return Object.fromEntries(TERMINAL_OUTCOMES.map((outcome) => [outcome, 0]));
+}
+
+function modelLabel(value) {
+  const model = String(value || "").trim();
+  return model === "codex-auto-review" || /^gpt-[A-Za-z0-9._-]{1,72}$/.test(model)
+    ? model : "other";
+}
+
 function createRoutePerformance() {
   return {
     ttft: createHistogram(TTFT_EDGES_MS),
@@ -88,6 +105,10 @@ function createRoutePerformance() {
     errors_with_output: 0,
     zero_output_errors: 0,
     neutral: 0,
+    terminalTotals: emptyOutcomes(),
+    incompleteReasons: Object.create(null),
+    terminalByModel: new Map(),
+    terminalByOrigin: Object.create(null),
   };
 }
 
@@ -97,6 +118,12 @@ function routeSnapshot(route) {
     errors_with_output: route.errors_with_output,
     zero_output_errors: route.zero_output_errors,
     neutral: route.neutral,
+    terminal_outcomes: {
+      totals: { ...route.terminalTotals },
+      incomplete_reasons: { ...route.incompleteReasons },
+      by_model: Object.fromEntries([...route.terminalByModel].map(([model, counts]) => [model, { ...counts }])),
+      by_origin: Object.fromEntries(Object.entries(route.terminalByOrigin).map(([origin, counts]) => [origin, { ...counts }])),
+    },
     ttft_ms: histogramSnapshot(route.ttft, "ms"),
     tpot_us: histogramSnapshot(route.tpot, "us"),
     request_ttft_ms: histogramSnapshot(route.requestTtft, "ms"),
@@ -117,6 +144,11 @@ export function createStreamPerformanceMetrics({ now = () => performance.now() }
       let outputTokens = null;
       let failed = false;
       let finished = false;
+      let model = "other";
+      let terminalOutcome = null;
+      let terminalOrigin = null;
+      let incompleteReason = null;
+      let errorOrigin = null;
 
       return {
         beginStage(stage) {
@@ -140,13 +172,37 @@ export function createStreamPerformanceMetrics({ now = () => performance.now() }
           const tokens = Number(value);
           if (Number.isFinite(tokens) && tokens >= 0) outputTokens = tokens;
         },
+        setModel(value) {
+          model = modelLabel(value);
+        },
+        setErrorOrigin(value) {
+          if (TERMINAL_ORIGINS.has(value)) errorOrigin = value;
+        },
+        terminal(outcome, { model: terminalModel, origin, reason } = {}) {
+          if (finished || terminalOutcome || !TERMINAL_OUTCOMES.includes(outcome)) return;
+          terminalOutcome = outcome;
+          if (terminalModel !== undefined) model = modelLabel(terminalModel);
+          if (TERMINAL_ORIGINS.has(origin)) terminalOrigin = origin;
+          if (outcome === "incomplete") incompleteReason = INCOMPLETE_REASONS.has(reason) ? reason : "other";
+          if (outcome !== "completed") failed = true;
+        },
         fail() {
           failed = true;
         },
-        finish({ failed: finishFailed = false } = {}) {
+        finish({ failed: finishFailed = false, aborted = false } = {}) {
           if (finished) return;
           finished = true;
           failed ||= finishFailed;
+          const outcome = terminalOutcome || (aborted ? "cancelled" : "unknown");
+          const origin = terminalOrigin || errorOrigin || (aborted ? "client_disconnect" : "unclassified");
+          route.terminalTotals[outcome] += 1;
+          if (incompleteReason) route.incompleteReasons[incompleteReason] = (route.incompleteReasons[incompleteReason] || 0) + 1;
+          const label = route.terminalByModel.has(model) || route.terminalByModel.size < MAX_MODEL_OUTCOME_LABELS
+            ? model : "other";
+          if (!route.terminalByModel.has(label)) route.terminalByModel.set(label, emptyOutcomes());
+          route.terminalByModel.get(label)[outcome] += 1;
+          route.terminalByOrigin[origin] ||= emptyOutcomes();
+          route.terminalByOrigin[origin][outcome] += 1;
           const finishedAt = now();
           if (firstOutputAt !== null) observe(route.requestTtft, Math.max(0, firstOutputAt - requestStartedAt));
           if (upstreamStartedAt === null) {
@@ -212,3 +268,15 @@ export function markOutputTokens(value) {
 export function markStreamFailure() {
   tracker()?.fail();
 }
+
+export function markResponseModel(model) {
+  tracker()?.setModel?.(model);
+}
+
+export function markResponseErrorOrigin(origin) {
+  tracker()?.setErrorOrigin?.(origin);
+}
+
+export function markResponseTerminal(outcome, options) {
+  tracker()?.terminal?.(outcome, options);
+}