codex-copilot-dx 0.6.1 → 0.6.3

package/src/responses-image-pressure.mjs

@@ -0,0 +1,163 @@
+import {
+  responsesHistoricalImageStats,
+  trimResponsesHistoricalImages,
+} from "./responses-byte-budget.mjs";
+
+const MIB = 1024 * 1024;
+
+export const DEFAULT_RESPONSES_IMAGE_PRESSURE_POLICY = Object.freeze({
+  triggerHistoricalImages: 24,
+  triggerBodyBytes: 18 * MIB,
+  pressureHistoricalImages: 16,
+  pressureBodyBytes: 16 * MIB,
+  recoveryHistoricalImages: 8,
+  recoveryBodyBytes: 10 * MIB,
+});
+
+function normalizedPolicy(policy = {}) {
+  return { ...DEFAULT_RESPONSES_IMAGE_PRESSURE_POLICY, ...policy };
+}
+
+function bodyPayload(body) {
+  const bodyText = JSON.stringify(body);
+  return { bodyText, bodyBytes: Buffer.byteLength(bodyText) };
+}
+
+export function applyResponsesImagePressure(reqContext, {
+  mode = "normal",
+  policy: policyOverrides,
+} = {}) {
+  const policy = normalizedPolicy(policyOverrides);
+  const body = reqContext?.body;
+  const currentInputStart = Number.isFinite(reqContext?.currentInputStart)
+    ? reqContext.currentInputStart
+    : 0;
+  const initial = bodyPayload(body);
+  const initialImages = responsesHistoricalImageStats(body?.input, currentInputStart);
+  const pressureEligible = initialImages.historicalImages > 0 && (
+    initialImages.historicalImages > policy.triggerHistoricalImages
+      || initial.bodyBytes > policy.triggerBodyBytes
+  );
+  const recovery = mode === "recovery";
+  const maxHistoricalImages = recovery
+    ? policy.recoveryHistoricalImages
+    : policy.pressureHistoricalImages;
+  const targetBytes = recovery ? policy.recoveryBodyBytes : policy.pressureBodyBytes;
+  const shouldAdapt = initialImages.historicalImages > 0 && (recovery
+    ? initialImages.historicalImages > maxHistoricalImages || initial.bodyBytes > targetBytes
+    : pressureEligible);
+
+  if (!shouldAdapt) {
+    return {
+      mode: "normal",
+      pressureEligible,
+      adapted: false,
+      imagesOmitted: 0,
+      initialBodyBytes: initial.bodyBytes,
+      bodyBytes: initial.bodyBytes,
+      initialHistoricalImages: initialImages.historicalImages,
+      historicalImages: initialImages.historicalImages,
+      currentImages: initialImages.currentImages,
+      overBudget: false,
+      overImageBudget: false,
+    };
+  }
+
+  const trimmed = trimResponsesHistoricalImages(body, {
+    currentInputStart,
+    maxHistoricalImages,
+    targetBytes,
+    initialBodyText: initial.bodyText,
+    initialBodyBytes: initial.bodyBytes,
+  });
+  return {
+    mode: recovery ? "recovery" : "pressure",
+    pressureEligible: pressureEligible || recovery,
+    initialBodyBytes: initial.bodyBytes,
+    initialHistoricalImages: initialImages.historicalImages,
+    ...trimmed,
+  };
+}
+
+export function createResponsesImagePressureController({
+  now = Date.now,
+  maxEntries = 256,
+  recoveryTtlMs = 10 * 60 * 1000,
+  successesToClear = 2,
+  policy: policyOverrides,
+} = {}) {
+  const policy = normalizedPolicy(policyOverrides);
+  const recovery = new Map();
+  const counters = {
+    adaptedRequests: 0,
+    imagesOmitted: 0,
+    recoveryActivations: 0,
+    timeoutsRecorded: 0,
+  };
+
+  const prune = () => {
+    const timestamp = now();
+    for (const [rootId, state] of recovery) {
+      if (state.expiresAt <= timestamp) recovery.delete(rootId);
+    }
+    while (recovery.size > maxEntries) recovery.delete(recovery.keys().next().value);
+  };
+
+  const modeFor = (rootId) => {
+    prune();
+    return rootId && recovery.has(rootId) ? "recovery" : "normal";
+  };
+
+  return Object.freeze({
+    apply(reqContext) {
+      const result = applyResponsesImagePressure(reqContext, {
+        mode: modeFor(reqContext?.historyRootId),
+        policy,
+      });
+      if (result.adapted) {
+        counters.adaptedRequests += 1;
+        counters.imagesOmitted += result.imagesOmitted;
+      }
+      return result;
+    },
+    markTimeout(rootId, { eligible = false } = {}) {
+      if (!rootId || !eligible) return false;
+      prune();
+      const existing = recovery.get(rootId);
+      recovery.delete(rootId);
+      recovery.set(rootId, { expiresAt: now() + recoveryTtlMs, successes: 0 });
+      counters.timeoutsRecorded += 1;
+      if (!existing) counters.recoveryActivations += 1;
+      prune();
+      return true;
+    },
+    markSuccess(rootId) {
+      if (!rootId) return false;
+      prune();
+      const state = recovery.get(rootId);
+      if (!state) return false;
+      state.successes += 1;
+      if (state.successes >= successesToClear) {
+        recovery.delete(rootId);
+        return true;
+      }
+      return false;
+    },
+    clear(rootId) {
+      return rootId ? recovery.delete(rootId) : false;
+    },
+    snapshot() {
+      prune();
+      return {
+        active_recovery_trees: recovery.size,
+        adapted_requests: counters.adaptedRequests,
+        historical_images_omitted: counters.imagesOmitted,
+        recovery_activations: counters.recoveryActivations,
+        timeouts_recorded: counters.timeoutsRecorded,
+        recovery_ttl_ms: recoveryTtlMs,
+        pressure_image_limit: policy.pressureHistoricalImages,
+        recovery_image_limit: policy.recoveryHistoricalImages,
+      };
+    },
+  });
+}

package/src/responses-proxy.mjs

@@ -126,7 +126,7 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
   reqContext = opened.reqContext;
   if (errorText !== undefined) {
     sendUpstreamError(res, resp, errorText);
-    return;
+    return { successful: false, compacted: false };
   }
 
   if (reqContext.body.stream) {
@@ -158,7 +158,7 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
           if (!streamState.sawTerminal) throw incompleteUpstreamStream("a terminal Responses event");
           storeCompletedResponse(reqContext, streamState.completed);
           res.end();
-          return;
+          return { successful: Boolean(streamState.completed), compacted: false };
         }
         options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
         buffer += decoder.decode(value, { stream: true });
@@ -170,12 +170,13 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
         if (streamState.sawTerminal) {
           storeCompletedResponse(reqContext, streamState.completed);
           res.end();
-          return;
+          return { successful: Boolean(streamState.completed), compacted: false };
         }
       }
     } catch (e) {
       logRequestFailure("Responses", e, options.abort);
       await endStreamWithError(res, "responses", e, options.abort);
+      return { successful: false, compacted: false };
     } finally {
       await reader.cancel().catch(() => {});
       reader.releaseLock();
@@ -199,7 +200,7 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
         contentType: "application/json",
       }));
       res.end(JSON.stringify(response));
-      return;
+      return { successful: true, compacted: true };
     }
     res.writeHead(resp.status, safeUpstreamResponseHeaders(resp.headers, {
       contentType: "application/json",
@@ -216,7 +217,9 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
           response,
           event: response,
         });
+        return { successful: true, compacted: false };
       } catch {}
     }
+    return { successful: false, compacted: false };
   }
 }

package/src/responses-request.mjs

@@ -1,7 +1,11 @@
 import { responses as copilotResponses } from "./copilot.mjs";
 import { httpError } from "./http-transport.mjs";
 import { debugLog } from "./log.mjs";
-import { materializeResponseHistory, rememberResponseHistoryNode } from "./response-history.mjs";
+import {
+  materializeResponseHistory,
+  rememberResponseHistoryNode,
+  responseHistoryRootId,
+} from "./response-history.mjs";
 import { enforceResponsesImageLimit } from "./responses-image-limit.mjs";
 import { status } from "./status.mjs";
 
@@ -157,6 +161,7 @@ export async function openCopilotResponse(reqContext, upstream = copilotResponse
     const resp = await upstream(reqContext.body, {
       signal: options.signal,
       currentInputStart: reqContext.currentInputStart,
+      onUpstreamStart: options.onUpstreamStart,
       payloadPrepared,
     });
     payloadPrepared = true;
@@ -198,9 +203,11 @@ export function prepareResponsesRequest(reqBody, { mutate = false } = {}) {
   );
   const previousId = body.previous_response_id;
   let historyItems = [];
+  let historyRootId = null;
 
   if (previousId !== undefined && previousId !== null) {
     historyItems = materializeResponseHistory(previousId);
+    historyRootId = responseHistoryRootId(previousId);
     body.input = [...historyItems, ...currentInputItems];
   } else {
     body.input = currentInputItems;
@@ -232,6 +239,7 @@ export function prepareResponsesRequest(reqBody, { mutate = false } = {}) {
     inputItems: body.input,
     currentInputStart: retainedCurrentInputStart < 0 ? body.input.length : retainedCurrentInputStart,
     historyParentId: previousId ?? null,
+    historyRootId,
     historyInputItems,
     takeHistoryOwnership: mutate,
   };