codex-copilot-dx 0.7.9 → 0.8.0

package/src/responses-proxy.mjs

@@ -8,7 +8,11 @@ import {
   sendUpstreamError,
   writeOrDrain,
 } from "./http-transport.mjs";
-import { openCopilotResponse, selectCopilotResponseRetry } from "./copilot-responses-compat.mjs";
+import {
+  hasCopilotResponseRetryPolicy,
+  openCopilotResponse,
+  selectCopilotResponseRetry,
+} from "./copilot-responses-compat.mjs";
 import {
   dropMaterializedResponseHistory,
   hasEncryptedResponseState,
@@ -314,21 +318,29 @@ function streamHeaders(resp) {
   };
 }
 
-function selectStreamFailureRetry(reqContext, failure, usedRetryPolicies) {
+async function selectStreamFailureRetry(reqContext, failure, usedRetryPolicies, options) {
   if (!failure) return null;
+  const errorText = responseFailureText(failure.event, failure.eventType);
+  if (!hasCopilotResponseRetryPolicy(400, errorText, usedRetryPolicies)) return null;
+  const preparation = await options.acquireRetryPreparation?.(reqContext);
+  let keepReservation = false;
   try {
-    const restored = restoreMaterializedResponseHistoryForRetry(reqContext);
+    const restored = restoreMaterializedResponseHistoryForRetry(reqContext, {
+      assertActive: options.assertPrepareActive,
+      historySnapshot: preparation?.historySnapshot,
+    });
+    const retry = selectCopilotResponseRetry(restored, 400, errorText, usedRetryPolicies);
+    options.assertPrepareActive?.();
+    keepReservation = Boolean(retry);
     return {
-      retry: selectCopilotResponseRetry(
-        restored,
-        400,
-        responseFailureText(failure.event, failure.eventType),
-        usedRetryPolicies,
-      ),
+      retry: retry ? { ...retry, releasePreparation: preparation?.release } : null,
       retrySkipped: null,
     };
   } catch {
+    options.assertPrepareActive?.();
     return { retry: null, retrySkipped: "history_unavailable" };
+  } finally {
+    if (!keepReservation) preparation?.release();
   }
 }
 
@@ -362,6 +374,7 @@ async function proxyStreamingResponses(opened, res, upstream, options) {
       return { successful: false, compacted: false, upstreamStatus: resp.status };
     }
     await requireUpstreamEventStream(resp);
+    options.onStreamStart?.();
     options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
     const headers = streamHeaders(resp);
     let headersSent = false;
@@ -424,7 +437,13 @@ async function proxyStreamingResponses(opened, res, upstream, options) {
 
       let retry = null;
       if (streamState.failure && holdPrelude && !streamState.sawOutput) {
-        const selected = selectStreamFailureRetry(reqContext, streamState.failure, usedRetryPolicies);
+        let selected;
+        try {
+          selected = await selectStreamFailureRetry(reqContext, streamState.failure, usedRetryPolicies, options);
+        } catch (error) {
+          recordResponseFailure(options, reqContext, resp, streamState.failure, { retrySkipped: "retry_preparation_failed" });
+          throw error;
+        }
         retry = selected?.retry || null;
         if (!retry) retryDisabledReason = selected?.retrySkipped || "not_applicable";
       }
@@ -436,12 +455,16 @@ async function proxyStreamingResponses(opened, res, upstream, options) {
       }
       if (retry) {
         console.warn(status("warn", retry.warning));
-        opened = await openCopilotResponse(retry.reqContext, upstream, {
-          ...options,
-          usedRetryPolicies: retry.usedPolicies,
-        });
-        opened.streamRetryEligible = hasEncryptedResponseState(opened.reqContext.body?.input);
-        dropMaterializedResponseHistory(opened.reqContext);
+        try {
+          opened = await openCopilotResponse(retry.reqContext, upstream, {
+            ...options,
+            usedRetryPolicies: retry.usedPolicies,
+          });
+          opened.streamRetryEligible = hasEncryptedResponseState(opened.reqContext.body?.input);
+          dropMaterializedResponseHistory(opened.reqContext);
+        } finally {
+          retry.releasePreparation?.();
+        }
         continue;
       }
       if (streamState.failure) markStreamFailure();
@@ -515,7 +538,13 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
       const response = parseSuccessfulResponsesResult(data);
       if (response.status === "failed") {
         const failure = { event: { type: "response.failed", response }, eventType: "response.failed" };
-        const selected = selectStreamFailureRetry(reqContext, failure, usedRetryPolicies);
+        let selected;
+        try {
+          selected = await selectStreamFailureRetry(reqContext, failure, usedRetryPolicies, options);
+        } catch (error) {
+          recordResponseFailure(options, reqContext, resp, failure, { retrySkipped: "retry_preparation_failed" });
+          throw error;
+        }
         const retry = selected?.retry || null;
         recordResponseFailure(options, reqContext, resp, failure, {
           retry,
@@ -523,11 +552,15 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
         });
         if (retry) {
           console.warn(status("warn", retry.warning));
-          opened = await openCopilotResponse(retry.reqContext, upstream, {
-            ...options,
-            usedRetryPolicies: retry.usedPolicies,
-          });
-          dropMaterializedResponseHistory(opened.reqContext);
+          try {
+            opened = await openCopilotResponse(retry.reqContext, upstream, {
+              ...options,
+              usedRetryPolicies: retry.usedPolicies,
+            });
+            dropMaterializedResponseHistory(opened.reqContext);
+          } finally {
+            retry.releasePreparation?.();
+          }
           continue;
         }
       }

package/src/responses-request.mjs

@@ -389,7 +389,8 @@ export function dropMaterializedResponseHistory(reqContext) {
   return true;
 }
 
-export function restoreMaterializedResponseHistoryForRetry(reqContext, { assertActive } = {}) {
+export function restoreMaterializedResponseHistoryForRetry(reqContext, { assertActive, historySnapshot } = {}) {
+  assertActive?.();
   if (!reqContext?.[RELEASED_MATERIALIZED_HISTORY] || !reqContext.historyParentId) return reqContext;
   const body = cloneJson(reqContext.body);
   body.previous_response_id = reqContext.historyParentId;
@@ -397,6 +398,7 @@ export function restoreMaterializedResponseHistoryForRetry(reqContext, { assertA
   let restored = prepareResponsesRequest(body, {
     assertActive,
     copilotBoundary: false,
+    historySnapshot,
     mutate: true,
   });
   restored.surface = reqContext.surface;

package/src/terminal-animation-gallery.mjs

@@ -0,0 +1,85 @@
+import {
+  TERMINAL_ANIMATION_THEMES,
+  TERMINAL_ANIMATION_TRACK_WIDTH,
+  getTerminalAnimationFrameDelay,
+  renderTerminalAnimationFrame,
+} from "./terminal-animation.mjs";
+
+const ESC = "\u001b";
+const TICK_MS = 32;
+
+export function startTerminalAnimationGallery({
+  output,
+  env = process.env,
+  prefixWidth,
+  rowsBelow = 0,
+  getInputRows = () => 0,
+  timers = { setTimeout, clearTimeout },
+  now = () => performance.now(),
+} = {}) {
+  const columns = Number(output?.columns);
+  const rows = Number(output?.rows);
+  const disabled = /^(0|false|no|off)$/i.test(String(env.CCDX_TERMINAL_ANIMATION || "").trim());
+  const ci = String(env.CI || "").trim();
+  if (output?.isTTY !== true || disabled || (ci && !/^(0|false|no|off)$/i.test(ci))
+    || String(env.TERM || "").toLowerCase() === "dumb" || !Number.isFinite(columns) || !Number.isFinite(rows)
+    || columns <= prefixWidth + TERMINAL_ANIMATION_TRACK_WIDTH + 2
+    || rows < TERMINAL_ANIMATION_THEMES.length + rowsBelow + 2) {
+    return { enabled: false, stop() {} };
+  }
+
+  const timelines = TERMINAL_ANIMATION_THEMES.map((theme) => {
+    let duration = 0;
+    const frames = Array.from({ length: theme.frameCount }, (_, offset) => {
+      const frame = theme.startFrame + offset;
+      duration += getTerminalAnimationFrameDelay(theme.id, frame);
+      return { frame, until: duration };
+    });
+    return { theme, frames, duration: duration + theme.loopPauseMs, lastFrame: theme.startFrame };
+  });
+  const startedAt = now();
+  let timer;
+  let stopped = false;
+  const stop = () => {
+    if (stopped) return;
+    stopped = true;
+    if (timer !== undefined) timers.clearTimeout(timer);
+    output.off?.("resize", stop);
+    output.off?.("error", stop);
+    output.off?.("close", stop);
+  };
+  const draw = () => {
+    timer = undefined;
+    if (stopped) return;
+    try {
+      const inputRows = getInputRows();
+      // Once input scrolls the menu out of view its old row anchors are no longer safe.
+      if (!Number.isSafeInteger(inputRows) || inputRows < 0
+        || Number(output.rows) < timelines.length + rowsBelow + inputRows + 2) {
+        stop();
+        return;
+      }
+      const elapsed = now() - startedAt;
+      let update = "";
+      timelines.forEach((timeline, index) => {
+        const position = elapsed % timeline.duration;
+        const frame = timeline.frames.find(({ until }) => position < until)?.frame ?? null;
+        if (frame === timeline.lastFrame) return;
+        timeline.lastFrame = frame;
+        const track = frame === null ? `[${" ".repeat(TERMINAL_ANIMATION_TRACK_WIDTH)}]`
+          : renderTerminalAnimationFrame(timeline.theme.id, frame);
+        const up = timelines.length - index + rowsBelow + inputRows;
+        update += `${ESC}7${ESC}[${up}A${ESC}[${prefixWidth + 1}G${track}${ESC}8`;
+      });
+      if (update && output.write(update) === false) { stop(); return; }
+      timer = timers.setTimeout(draw, TICK_MS);
+      timer?.unref?.();
+    } catch { stop(); }
+  };
+  output.on?.("resize", stop);
+  output.on?.("error", stop);
+  output.on?.("close", stop);
+  timer = timers.setTimeout(draw, TICK_MS);
+  timer?.unref?.();
+  return { enabled: true, stop };
+}