codex-copilot-dx 0.6.15 → 0.6.18

package/src/responses-bridge.mjs

@@ -1,7 +1,12 @@
 import { randomUUID } from "node:crypto";
 import { chatCompletions } from "./copilot.mjs";
 import { webStreamLines } from "./stream.mjs";
-import { abortErrorStatusCode, isAbortLikeError } from "./http-transport.mjs";
+import {
+  abortErrorStatusCode,
+  isAbortLikeError,
+  MAX_UPSTREAM_ERROR_BODY_BYTES,
+  readBoundedResponseText,
+} from "./http-transport.mjs";
 import {
   incompleteUpstreamStream,
   invalidUpstreamStream,
@@ -216,7 +221,10 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
     return false;
   }
   if (!resp.ok) {
-    await onError(resp.status, await resp.text(), undefined, resp);
+    await onError(resp.status, await readBoundedResponseText(resp, {
+      maxBytes: MAX_UPSTREAM_ERROR_BODY_BYTES,
+      label: "Copilot Chat error body",
+    }), undefined, resp);
     return false;
   }
   try {
@@ -235,6 +243,13 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
   let usage = { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
   const toolCalls = new Map();
   const toolArgumentGuard = new ToolArgumentDeltaGuard();
+  const downstreamClosed = Symbol("downstream-closed");
+  const configuredEmitEvent = emitEvent;
+  emitEvent = async (...args) => {
+    const written = await configuredEmitEvent(...args);
+    if (written === false) throw downstreamClosed;
+    return written;
+  };
   let performanceOutputSeen = false;
   const markPerformanceOutput = () => {
     if (performanceOutputSeen) return;
@@ -242,8 +257,6 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
     markFirstOutput();
   };
 
-  await emitEvent("response.created", { response: { id: respId, object: "response", status: "in_progress", model: actualModel, output: [] } });
-
   const ensureMessageItem = async () => {
     if (messageItem) return messageItem;
     messageItem = { id: `msg_${uid()}`, outputIndex: nextOutputIndex++ };
@@ -331,6 +344,7 @@ 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"),
     })) {
@@ -386,6 +400,10 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
       }
     }
   } catch (e) {
+    if (e === downstreamClosed) {
+      await resp.body?.cancel?.().catch?.(() => {});
+      return false;
+    }
     const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(abort?.reason) : (e?.statusCode || 502);
     await onError(statusCode, e?.message || "upstream stream error", e);
     return false;

package/src/responses-handler.mjs

@@ -3,7 +3,9 @@ import { applyCopilotResponsesRequestPolicies } from "./copilot-responses-policy
 import {
   createRequestAbort,
   logRequestFailure,
+  MAX_UPSTREAM_ERROR_BODY_BYTES,
   readJsonBody,
+  readBoundedResponseText,
   sendJsonError,
   sendUpstreamError,
   writeOrDrain,
@@ -12,6 +14,7 @@ import {
   CODEX_AUTO_REVIEW_MODEL,
   modelIsResponsesOnly,
   modelSupportsChatCompletions,
+  resolveCopilotPriorityTierModel,
   resolveOpenAIModel,
 } from "./models.mjs";
 import { chatToResponses, forwardToChat, responsesBodyUsesCustomTools } from "./responses-bridge.mjs";
@@ -19,7 +22,7 @@ import { prepareResponsesChatPayload } from "./responses-chat-payload.mjs";
 import { prepareResponsesCompactionRequest } from "./responses-compaction.mjs";
 import { clearResponsesToolOutputPartsCache } from "./responses-content.mjs";
 import { proxyCopilotResponses } from "./responses-proxy.mjs";
-import { responseHistoryMaterializedBytes } from "./response-history.mjs";
+import { acquireResponseHistorySnapshot } from "./response-history.mjs";
 import {
   applyResponseHistoryRoutePlan,
   dropMaterializedResponseHistory,
@@ -90,6 +93,7 @@ export function createResponsesHandler(options) {
     chatCompletionsFn,
     getCachedModelEndpointsFn = getCachedModelEndpoints,
     imagePressure,
+    modelRegistry,
     openAIModelEnv,
     requestBodyTimeoutMs,
     responsesPayloadOptions,
@@ -105,10 +109,15 @@ export function createResponsesHandler(options) {
     let releaseRequest = () => {};
     let prepared = null;
     let imagePressureResult = null;
+    let historySnapshot = null;
     let parsed = null;
     let upstreamPayloadReleased = false;
     let activeDeadline = Number.POSITIVE_INFINITY;
     let activeTimeoutReason = "responses_prepare_timeout";
+    const releaseHistorySnapshot = () => {
+      historySnapshot?.release();
+      historySnapshot = null;
+    };
     const assertPrepareActive = () => {
       if (abort.signal.aborted) throw abort.signal.reason;
       if (now() < activeDeadline) return;
@@ -152,6 +161,7 @@ export function createResponsesHandler(options) {
     const releaseUpstreamPayload = (finalContext) => {
       if (upstreamPayloadReleased) return;
       upstreamPayloadReleased = true;
+      if (finalContext?.historyParentId === null) releaseHistorySnapshot();
       clearResponsesToolOutputPartsCache(prepared?.body?.input);
       clearResponsesToolOutputPartsCache(prepared?.historyInputItems);
       if (finalContext && finalContext !== prepared) {
@@ -170,15 +180,19 @@ export function createResponsesHandler(options) {
       activeTimeoutReason = "responses_prepare_timeout";
       abort.setTimeout(upstreamTimeoutMs, "responses_prepare_timeout");
       if (parsed.previous_response_id !== undefined && parsed.previous_response_id !== null) {
-        const historyBytes = responseHistoryMaterializedBytes(parsed.previous_response_id);
-        if (historyBytes > 0) {
-          await releaseRequest.reserveResponseHistory?.(historyBytes, { signal: abort.signal });
+        historySnapshot = acquireResponseHistorySnapshot(parsed.previous_response_id, {
+          assertActive: assertPrepareActive,
+          signal: abort.signal,
+        });
+        if (historySnapshot.bytes > 0) {
+          await releaseRequest.reserveResponseHistory?.(historySnapshot.bytes, { signal: abort.signal });
         }
         assertPrepareActive();
       }
       prepared = prepareResponsesRequest(parsed, {
         assertActive: assertPrepareActive,
         copilotBoundary: false,
+        historySnapshot,
         mutate: true,
       });
       parsed = null;
@@ -191,12 +205,22 @@ export function createResponsesHandler(options) {
       prepared.surface = "responses";
       const model = prepared.body.model || "unknown";
       const streaming = prepared.body.stream === true;
-      const { requestedModel, upstreamModel } = resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver);
+      const resolvedModel = resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver);
+      const { requestedModel } = resolvedModel;
+      let { upstreamModel } = resolvedModel;
+      const priorityTierModel = requestedModel === upstreamModel
+        ? resolveCopilotPriorityTierModel(upstreamModel, prepared.body.service_tier, modelRegistry?.models)
+        : null;
+      if (priorityTierModel) {
+        upstreamModel = priorityTierModel;
+        delete prepared.body.service_tier;
+      }
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
       console.log(status("info", `responses model=${requestedModel}${upstreamLog} stream=${streaming}`));
       const usesCustomTools = responsesBodyUsesCustomTools(prepared.body);
-      const useNativeResponses = requestedModel === CODEX_AUTO_REVIEW_MODEL
+      const useNativeResponses = Boolean(priorityTierModel)
+        || requestedModel === CODEX_AUTO_REVIEW_MODEL
         || isResponsesOnlyModel(upstreamModel, getCachedModelEndpointsFn)
         || (usesCustomTools && cachedModelSupportsResponses(upstreamModel, getCachedModelEndpointsFn));
       if (usesCustomTools && !useNativeResponses) throw unsupportedCustomToolsError(upstreamModel);
@@ -209,6 +233,7 @@ export function createResponsesHandler(options) {
         surface: "responses",
       });
       prepared = applyResponseHistoryRoutePlan(prepared, routePlan);
+      if (prepared.historyParentId === null) releaseHistorySnapshot();
       applyCopilotResponsesRequestPolicies(prepared.body);
       if (routePlan.protocol === "openai-responses") {
         const result = await proxyCopilotResponses(prepared, req, res, responsesFn, {
@@ -241,11 +266,13 @@ export function createResponsesHandler(options) {
               "Cache-Control": "no-cache",
               Connection: "keep-alive",
             });
-            await writeOrDrain(res, `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+            const written = await writeOrDrain(res, `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+            if (!written) return false;
             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) {
@@ -282,7 +309,12 @@ export function createResponsesHandler(options) {
               onUpstreamStart: startUpstreamTimeout,
             });
             releaseChatPayload();
-            const data = await upstream.text();
+            const data = upstream.ok
+              ? await upstream.text()
+              : await readBoundedResponseText(upstream, {
+                maxBytes: MAX_UPSTREAM_ERROR_BODY_BYTES,
+                label: "Copilot Chat error body",
+              });
             if (!upstream.ok) {
               markAdaptiveHttpTimeout(upstream.status);
               sendUpstreamError(res, upstream, data);
@@ -311,6 +343,7 @@ export function createResponsesHandler(options) {
       sendJsonError(res, responseError, 502);
     } finally {
       releaseUpstreamPayload();
+      releaseHistorySnapshot();
       abort.cleanup();
     }
   };
@@ -321,6 +354,7 @@ export function createResponsesCompactHandler(options) {
     acquireRequest,
     autoReviewModelResolver,
     imagePressure,
+    modelRegistry,
     openAIModelEnv,
     requestBodyTimeoutMs,
     responsesCompactFn,
@@ -332,7 +366,47 @@ export function createResponsesCompactHandler(options) {
     const abort = createRequestAbort(req, res);
     let releaseRequest = () => {};
     let prepared = null;
+    let imagePressureResult = null;
+    let historySnapshot = null;
     let upstreamPayloadReleased = false;
+    let activeDeadline = Number.POSITIVE_INFINITY;
+    let activeTimeoutReason = "responses_prepare_timeout";
+    const releaseHistorySnapshot = () => {
+      historySnapshot?.release();
+      historySnapshot = null;
+    };
+    const assertPrepareActive = () => {
+      if (abort.signal.aborted) throw abort.signal.reason;
+      if (now() < activeDeadline) return;
+      abort.abort(activeTimeoutReason);
+      throw abort.signal.reason;
+    };
+    const startUpstreamTimeout = () => {
+      assertPrepareActive();
+      activeDeadline = now() + upstreamTimeoutMs;
+      activeTimeoutReason = "upstream_timeout";
+      abort.setTimeout(upstreamTimeoutMs, "upstream_timeout");
+    };
+    const pressureRootId = () => responseHistoryPressureRootId(prepared);
+    const markCompactTimeout = () => {
+      const eligible = imagePressure?.isEligible?.(prepared) === true;
+      return imagePressure?.markTimeout?.(pressureRootId(), { eligible }) || false;
+    };
+    const applyAdaptiveTimeout = (error) => {
+      if (!["responses_prepare_timeout", "upstream_timeout"].includes(abort.reason)) return error;
+      if (!markCompactTimeout()) return error;
+      const message = "Responses compact timed out while processing a large visual history. Retry the request; ccdx will keep fewer earlier images automatically. Restart is not required.";
+      error.statusCode = 504;
+      error.jsonBody = {
+        error: {
+          message,
+          type: "timeout_error",
+          code: "ccdx_visual_history_timeout",
+          retryable: true,
+        },
+      };
+      return error;
+    };
     const releaseUpstreamPayload = (finalContext) => {
       if (upstreamPayloadReleased) return;
       upstreamPayloadReleased = true;
@@ -348,39 +422,43 @@ export function createResponsesCompactHandler(options) {
       releaseRequest = await acquireRequest(req, { signal: abort.signal });
       abort.setTimeout(requestBodyTimeoutMs, "request_body_timeout");
       const parsed = await readJsonBody(req, { admission: releaseRequest, signal: abort.signal });
-      let activeDeadline = now() + upstreamTimeoutMs;
-      let activeTimeoutReason = "responses_prepare_timeout";
-      const assertPrepareActive = () => {
-        if (abort.signal.aborted) throw abort.signal.reason;
-        if (now() < activeDeadline) return;
-        abort.abort(activeTimeoutReason);
-        throw abort.signal.reason;
-      };
-      const startUpstreamTimeout = () => {
-        assertPrepareActive();
-        activeDeadline = now() + upstreamTimeoutMs;
-        activeTimeoutReason = "upstream_timeout";
-        abort.setTimeout(upstreamTimeoutMs, "upstream_timeout");
-      };
+      activeDeadline = now() + upstreamTimeoutMs;
+      activeTimeoutReason = "responses_prepare_timeout";
       abort.setTimeout(upstreamTimeoutMs, "responses_prepare_timeout");
       if (parsed.previous_response_id !== undefined && parsed.previous_response_id !== null) {
-        const historyBytes = responseHistoryMaterializedBytes(parsed.previous_response_id);
-        if (historyBytes > 0) {
-          await releaseRequest.reserveResponseHistory?.(historyBytes, { signal: abort.signal });
+        historySnapshot = acquireResponseHistorySnapshot(parsed.previous_response_id, {
+          assertActive: assertPrepareActive,
+          signal: abort.signal,
+        });
+        if (historySnapshot.bytes > 0) {
+          await releaseRequest.reserveResponseHistory?.(historySnapshot.bytes, { signal: abort.signal });
         }
         assertPrepareActive();
       }
-      prepared = prepareResponsesCompactionRequest(
-        prepareResponsesRequest(parsed, {
-          assertActive: assertPrepareActive,
-          copilotBoundary: false,
-          mutate: true,
-        }),
-      );
+      prepared = prepareResponsesRequest(parsed, {
+        assertActive: assertPrepareActive,
+        copilotBoundary: false,
+        historySnapshot,
+        mutate: true,
+      });
+      imagePressureResult = imagePressure?.applyRecovery?.(prepared, { assertActive: assertPrepareActive }) || null;
+      if (imagePressureResult?.adapted) {
+        console.warn(status("warn", `responses compact visual history mode=recovery historical_images=${imagePressureResult.initialHistoricalImages}->${imagePressureResult.historicalImages} omitted=${imagePressureResult.imagesOmitted} bytes=${imagePressureResult.initialBodyBytes}->${imagePressureResult.bodyBytes}`));
+      }
+      prepared = prepareResponsesCompactionRequest(prepared);
       assertPrepareActive();
       prepared.surface = "responses_compact";
       const model = parsed.model || "unknown";
-      const { requestedModel, upstreamModel } = resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver);
+      const resolvedModel = resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver);
+      const { requestedModel } = resolvedModel;
+      let { upstreamModel } = resolvedModel;
+      const priorityTierModel = requestedModel === upstreamModel
+        ? resolveCopilotPriorityTierModel(upstreamModel, prepared.body.service_tier, modelRegistry?.models)
+        : null;
+      if (priorityTierModel) {
+        upstreamModel = priorityTierModel;
+        delete prepared.body.service_tier;
+      }
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
       console.log(status("info", `responses compact model=${requestedModel}${upstreamLog} stream=false`));
@@ -392,6 +470,7 @@ export function createResponsesCompactHandler(options) {
         model: upstreamModel,
         surface: "responses-compact",
       }));
+      releaseHistorySnapshot();
       applyCopilotResponsesRequestPolicies(prepared.body);
       const result = await proxyCopilotResponses(prepared, req, res, responsesCompactFn, {
         assertPrepareActive,
@@ -401,11 +480,14 @@ export function createResponsesCompactHandler(options) {
         releaseRequest: releaseUpstreamPayload,
       });
       if (result?.compacted) imagePressure?.clear?.(responseHistoryPressureRootId(prepared));
+      else if (result?.upstreamStatus === 408) markCompactTimeout();
     } catch (error) {
-      logRequestFailure("Responses compact", error, abort);
-      sendJsonError(res, error, 502);
+      const responseError = applyAdaptiveTimeout(error);
+      logRequestFailure("Responses compact", responseError, abort);
+      sendJsonError(res, responseError, 502);
     } finally {
       releaseUpstreamPayload();
+      releaseHistorySnapshot();
       abort.cleanup();
     }
   };

package/src/responses-image-pressure.mjs

@@ -25,6 +25,20 @@ function bodyPayload(body, assertActive) {
   return { bodyText, bodyBytes: Buffer.byteLength(bodyText) };
 }
 
+export function responsesImagePressureEligible(reqContext, {
+  assertActive,
+  policy: policyOverrides,
+} = {}) {
+  const policy = normalizedPolicy(policyOverrides);
+  const currentInputStart = Number.isFinite(reqContext?.currentInputStart)
+    ? reqContext.currentInputStart
+    : 0;
+  const images = responsesHistoricalImageStats(reqContext?.body?.input, currentInputStart, { assertActive });
+  if (images.historicalImages === 0) return false;
+  if (images.historicalImages > policy.triggerHistoricalImages) return true;
+  return bodyPayload(reqContext?.body, assertActive).bodyBytes > policy.triggerBodyBytes;
+}
+
 export function applyResponsesImagePressure(reqContext, {
   assertActive,
   mode = "normal",
@@ -143,6 +157,22 @@ export function createResponsesImagePressureController({
       }
       return result;
     },
+    isEligible(reqContext, { assertActive } = {}) {
+      return responsesImagePressureEligible(reqContext, { assertActive, policy });
+    },
+    applyRecovery(reqContext, { assertActive } = {}) {
+      if (modeFor(reqContext?.historyRootId) !== "recovery") return null;
+      const result = applyResponsesImagePressure(reqContext, {
+        assertActive,
+        mode: "recovery",
+        policy,
+      });
+      if (result.adapted) {
+        counters.adaptedRequests += 1;
+        counters.imagesOmitted += result.imagesOmitted;
+      }
+      return result;
+    },
     markTimeout(rootId, { eligible = false } = {}) {
       if (!rootId || !eligible) return false;
       prune();

package/src/responses-proxy.mjs

@@ -2,6 +2,8 @@ import { responses as copilotResponses } from "./copilot.mjs";
 import {
   httpError,
   logRequestFailure,
+  MAX_UPSTREAM_ERROR_BODY_BYTES,
+  readBoundedResponseText,
   sendUpstreamError,
   writeOrDrain,
 } from "./http-transport.mjs";
@@ -262,7 +264,12 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
       reader.releaseLock();
     }
   } else {
-    const data = await resp.text();
+    const data = resp.ok
+      ? await resp.text()
+      : await readBoundedResponseText(resp, {
+        maxBytes: MAX_UPSTREAM_ERROR_BODY_BYTES,
+        label: "Copilot Responses error body",
+      });
     if (resp.ok && reqContext.surface === "responses_compact") {
       const response = parseResponsesCompactionResult(
         compactionInputWithoutTrigger(reqContext.body.input),

package/src/responses-request.mjs

@@ -298,6 +298,7 @@ export function responseHistoryPressureRootId(reqContext) {
 export function prepareResponsesRequest(reqBody, {
   assertActive,
   copilotBoundary = true,
+  historySnapshot,
   mutate = false,
 } = {}) {
   assertActive?.();
@@ -313,11 +314,22 @@ export function prepareResponsesRequest(reqBody, {
   const historyRouteMetadata = [];
 
   if (previousId !== undefined && previousId !== null) {
-    historyItems = materializeResponseHistory(previousId, {
-      assertActive,
-      routeMetadata: historyRouteMetadata,
-    });
-    historyRootId = responseHistoryRootId(previousId);
+    if (historySnapshot) {
+      if (historySnapshot.responseId !== previousId) {
+        throw new TypeError("Response history snapshot does not match previous_response_id");
+      }
+      historyItems = historySnapshot.materialize({
+        assertActive,
+        routeMetadata: historyRouteMetadata,
+      });
+      historyRootId = historySnapshot.rootId;
+    } else {
+      historyItems = materializeResponseHistory(previousId, {
+        assertActive,
+        routeMetadata: historyRouteMetadata,
+      });
+      historyRootId = responseHistoryRootId(previousId);
+    }
     body.input = [...historyItems, ...currentInputItems];
   } else {
     body.input = currentInputItems;

package/src/usage.mjs

@@ -150,7 +150,7 @@ export async function flushUsageWrites() {
   await writeQueue;
 }
 
-async function* iterateUsageRecords(filePath) {
+async function* iterateUsageRecords(filePath, { warn = console.error } = {}) {
   let input;
   try {
     input = fs.createReadStream(filePath, { encoding: "utf8" });
@@ -165,14 +165,31 @@ async function* iterateUsageRecords(filePath) {
   }
 
   const lines = readline.createInterface({ input, crlfDelay: Infinity });
+  let invalidRecords = 0;
   for await (const line of lines) {
-    if (line) yield JSON.parse(line);
+    if (!line) continue;
+    try {
+      const record = JSON.parse(line);
+      if (!record || typeof record !== "object" || Array.isArray(record)) {
+        invalidRecords += 1;
+        continue;
+      }
+      yield record;
+    } catch {
+      invalidRecords += 1;
+    }
+  }
+  if (invalidRecords > 0) {
+    try {
+      const safePath = terminalCell(JSON.stringify(filePath));
+      warn(`codex-copilot-dx usage log ignored ${invalidRecords} invalid record${invalidRecords === 1 ? "" : "s"} in ${safePath}`);
+    } catch {}
   }
 }
 
-export async function readUsageRecords(filePath = usageLogPath()) {
+export async function readUsageRecords(filePath = usageLogPath(), { warn = console.error } = {}) {
   const records = [];
-  for await (const record of iterateUsageRecords(filePath)) records.push(record);
+  for await (const record of iterateUsageRecords(filePath, { warn })) records.push(record);
   return records;
 }
 
@@ -200,10 +217,10 @@ export function summarizeUsage(records) {
   return summary;
 }
 
-export async function summarizeUsageLogs(filePath = usageLogPath()) {
+export async function summarizeUsageLogs(filePath = usageLogPath(), { warn = console.error } = {}) {
   const summary = { requests: 0, totals: {}, byModel: {} };
   for (const candidate of [rotatedFilePath(filePath), filePath]) {
-    for await (const record of iterateUsageRecords(candidate)) {
+    for await (const record of iterateUsageRecords(candidate, { warn })) {
       const one = summarizeUsage([record]);
       summary.requests += one.requests;
       addUsageTotals(summary.totals, one.totals);
@@ -324,7 +341,8 @@ export async function printUsageSummary({
   format = "auto",
   output = process.stdout,
   log = console.log,
+  warn = console.error,
 } = {}) {
-  const summary = await summarizeUsageLogs(filePath);
+  const summary = await summarizeUsageLogs(filePath, { warn });
   log(formatUsageSummary(summary, { filePath, format, output }));
 }