codex-copilot-dx 0.6.14 → 0.6.18

package/src/responses-handler.mjs

@@ -1,8 +1,11 @@
 import { getCachedModelEndpoints } from "./copilot.mjs";
+import { applyCopilotResponsesRequestPolicies } from "./copilot-responses-policy.mjs";
 import {
   createRequestAbort,
   logRequestFailure,
+  MAX_UPSTREAM_ERROR_BODY_BYTES,
   readJsonBody,
+  readBoundedResponseText,
   sendJsonError,
   sendUpstreamError,
   writeOrDrain,
@@ -11,6 +14,7 @@ import {
   CODEX_AUTO_REVIEW_MODEL,
   modelIsResponsesOnly,
   modelSupportsChatCompletions,
+  resolveCopilotPriorityTierModel,
   resolveOpenAIModel,
 } from "./models.mjs";
 import { chatToResponses, forwardToChat, responsesBodyUsesCustomTools } from "./responses-bridge.mjs";
@@ -18,12 +22,15 @@ 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,
   prepareResponsesRequest,
   rememberResponseHistory,
+  responseHistoryPressureRootId,
 } from "./responses-request.mjs";
+import { createRoutePlan } from "./route-plan.mjs";
 import { status } from "./status.mjs";
 import { endStreamWithError } from "./stream-errors.mjs";
 import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
@@ -86,6 +93,7 @@ export function createResponsesHandler(options) {
     chatCompletionsFn,
     getCachedModelEndpointsFn = getCachedModelEndpoints,
     imagePressure,
+    modelRegistry,
     openAIModelEnv,
     requestBodyTimeoutMs,
     responsesPayloadOptions,
@@ -101,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;
@@ -141,13 +154,14 @@ export function createResponsesHandler(options) {
     };
     const markAdaptiveHttpTimeout = (statusCode) => {
       if (statusCode !== 408) return false;
-      return imagePressure?.markTimeout?.(prepared?.historyRootId, {
+      return imagePressure?.markTimeout?.(responseHistoryPressureRootId(prepared), {
         eligible: imagePressureResult?.pressureEligible === true,
       }) || false;
     };
     const releaseUpstreamPayload = (finalContext) => {
       if (upstreamPayloadReleased) return;
       upstreamPayloadReleased = true;
+      if (finalContext?.historyParentId === null) releaseHistorySnapshot();
       clearResponsesToolOutputPartsCache(prepared?.body?.input);
       clearResponsesToolOutputPartsCache(prepared?.historyInputItems);
       if (finalContext && finalContext !== prepared) {
@@ -166,13 +180,21 @@ 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, mutate: true });
+      prepared = prepareResponsesRequest(parsed, {
+        assertActive: assertPrepareActive,
+        copilotBoundary: false,
+        historySnapshot,
+        mutate: true,
+      });
       parsed = null;
       assertPrepareActive();
       imagePressureResult = imagePressure?.apply?.(prepared, { assertActive: assertPrepareActive }) || null;
@@ -183,16 +205,37 @@ 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);
-      if (useNativeResponses) {
+      const routePlan = createRoutePlan({
+        disposition: "relay",
+        origin: "ccdx",
+        profile: "codex",
+        protocol: useNativeResponses ? "openai-responses" : "openai-chat-completions",
+        model: upstreamModel,
+        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, {
           assertPrepareActive,
           signal: abort.signal,
@@ -201,9 +244,9 @@ export function createResponsesHandler(options) {
           releaseRequest: releaseUpstreamPayload,
           streamIdleTimeoutMs,
         });
-        if (result?.successful) imagePressure?.markSuccess?.(prepared.historyRootId);
+        if (result?.successful) imagePressure?.markSuccess?.(responseHistoryPressureRootId(prepared));
         else markAdaptiveHttpTimeout(result?.upstreamStatus);
-      } else {
+      } else if (routePlan.protocol === "openai-chat-completions") {
         let { chatReq, bodyText } = await prepareResponsesChatPayload(prepared, {
           assertActive: assertPrepareActive,
           payloadOptions: responsesPayloadOptions,
@@ -223,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) {
@@ -254,7 +299,7 @@ export function createResponsesHandler(options) {
               });
             },
           });
-          if (successful) imagePressure?.markSuccess?.(prepared.historyRootId);
+          if (successful) imagePressure?.markSuccess?.(responseHistoryPressureRootId(prepared));
         } else {
           try {
             startUpstreamTimeout();
@@ -264,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);
@@ -272,7 +322,7 @@ export function createResponsesHandler(options) {
             }
             const response = chatToResponses(JSON.parse(data), model);
             rememberResponseHistory(prepared, response);
-            imagePressure?.markSuccess?.(prepared.historyRootId);
+            imagePressure?.markSuccess?.(responseHistoryPressureRootId(prepared));
             recordResponsesUsage({ surface: prepared.surface, mode: "json", model, response, event: response });
             res.writeHead(200, safeUpstreamResponseHeaders(upstream.headers, {
               contentType: "application/json",
@@ -284,6 +334,8 @@ export function createResponsesHandler(options) {
             sendJsonError(res, responseError, 502);
           }
         }
+      } else {
+        throw new Error(`Unsupported Responses target protocol: ${routePlan.protocol}`);
       }
     } catch (error) {
       const responseError = applyAdaptiveTimeout(error);
@@ -291,6 +343,7 @@ export function createResponsesHandler(options) {
       sendJsonError(res, responseError, 502);
     } finally {
       releaseUpstreamPayload();
+      releaseHistorySnapshot();
       abort.cleanup();
     }
   };
@@ -301,6 +354,7 @@ export function createResponsesCompactHandler(options) {
     acquireRequest,
     autoReviewModelResolver,
     imagePressure,
+    modelRegistry,
     openAIModelEnv,
     requestBodyTimeoutMs,
     responsesCompactFn,
@@ -312,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;
@@ -328,38 +422,56 @@ 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, 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`));
+      prepared = applyResponseHistoryRoutePlan(prepared, createRoutePlan({
+        disposition: "relay",
+        origin: "ccdx",
+        profile: "codex",
+        protocol: "openai-responses",
+        model: upstreamModel,
+        surface: "responses-compact",
+      }));
+      releaseHistorySnapshot();
+      applyCopilotResponsesRequestPolicies(prepared.body);
       const result = await proxyCopilotResponses(prepared, req, res, responsesCompactFn, {
         assertPrepareActive,
         signal: abort.signal,
@@ -367,12 +479,15 @@ export function createResponsesCompactHandler(options) {
         onUpstreamStart: startUpstreamTimeout,
         releaseRequest: releaseUpstreamPayload,
       });
-      if (result?.compacted) imagePressure?.clear?.(prepared.historyRootId);
+      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,10 +2,13 @@ import { responses as copilotResponses } from "./copilot.mjs";
 import {
   httpError,
   logRequestFailure,
+  MAX_UPSTREAM_ERROR_BODY_BYTES,
+  readBoundedResponseText,
   sendUpstreamError,
   writeOrDrain,
 } from "./http-transport.mjs";
-import { openCopilotResponse, rememberResponseHistory } from "./responses-request.mjs";
+import { openCopilotResponse } from "./copilot-responses-compat.mjs";
+import { rememberResponseHistory } from "./responses-request.mjs";
 import {
   compactionInputWithoutTrigger,
   parseResponsesCompactionResult,
@@ -261,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),