codex-copilot-dx 0.8.6 → 0.8.8

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);
+}