codex-copilot-dx 0.7.6 → 0.7.8

package/src/image-provider.mjs

@@ -0,0 +1,268 @@
+import dns from "node:dns/promises";
+import https from "node:https";
+import net from "node:net";
+
+export const IMAGE_MAX_BYTES = 32 * 1024 * 1024;
+export const IMAGE_GENERATION_TIMEOUT_MS = 180_000;
+export const IMAGE_DOWNLOAD_TIMEOUT_MS = 60_000;
+export const IMAGE_SIZES = new Set(["1024x1024", "1536x1024", "1024x1536"]);
+
+function providerError(message, code = "ccdx_image_provider_error") {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+
+function checkedPrompt(value) {
+  const prompt = String(value || "").trim();
+  if (!prompt) throw providerError("Image prompt is required", "ccdx_image_prompt_required");
+  if (prompt.length > 16_000) throw providerError("Image prompt exceeds 16000 characters", "ccdx_image_prompt_too_large");
+  return prompt;
+}
+
+function checkedSize(value) {
+  const size = String(value || "1024x1024").trim().toLowerCase();
+  if (!IMAGE_SIZES.has(size)) {
+    throw providerError(`Image size must be one of: ${[...IMAGE_SIZES].join(", ")}`, "ccdx_image_size_invalid");
+  }
+  return size;
+}
+
+function generationBody(config, prompt, size) {
+  if (config.protocol === "qwen-messages") {
+    return {
+      model: config.model,
+      input: { messages: [{ role: "user", content: [{ text: prompt }] }] },
+      parameters: { n: 1, size: size.replace("x", "*"), watermark: false },
+    };
+  }
+  return { model: config.model, prompt, n: 1, size };
+}
+
+async function boundedJson(response) {
+  const maxBytes = 48 * 1024 * 1024;
+  const declared = Number(response.headers?.get?.("content-length"));
+  if (Number.isFinite(declared) && declared > maxBytes) throw providerError("Image API response was too large");
+  const reader = response.body?.getReader?.();
+  let text;
+  if (!reader) {
+    text = await response.text();
+    if (Buffer.byteLength(text) > maxBytes) throw providerError("Image API response was too large");
+  } else {
+    const chunks = [];
+    let total = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        total += value.byteLength;
+        if (total > maxBytes) {
+          await reader.cancel().catch(() => {});
+          throw providerError("Image API response was too large");
+        }
+        chunks.push(Buffer.from(value.buffer, value.byteOffset, value.byteLength));
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    text = Buffer.concat(chunks, total).toString("utf8");
+  }
+  try { return JSON.parse(text); } catch { throw providerError("Image API returned invalid JSON"); }
+}
+
+function upstreamMessage(body) {
+  return String(body?.message || body?.error?.message || body?.error || "")
+    .replace(/[\u0000-\u001f\u007f-\u009f]/g, " ")
+    .trim()
+    .slice(0, 500);
+}
+
+function imageSource(body) {
+  const standard = body?.data?.[0];
+  if (typeof standard?.b64_json === "string" && standard.b64_json) {
+    return { type: "base64", value: standard.b64_json };
+  }
+  if (typeof standard?.url === "string" && standard.url) return { type: "url", value: standard.url };
+  const contents = body?.output?.choices?.[0]?.message?.content;
+  if (Array.isArray(contents)) {
+    const image = contents.find((part) => typeof part?.image === "string" && part.image);
+    if (image) return { type: "url", value: image.image };
+  }
+  return null;
+}
+
+function imageMetadata(bytes) {
+  if (bytes.length >= 24 && bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    return { mimeType: "image/png", width: bytes.readUInt32BE(16), height: bytes.readUInt32BE(20) };
+  }
+  if (bytes.length >= 12 && bytes.toString("ascii", 0, 4) === "RIFF" && bytes.toString("ascii", 8, 12) === "WEBP") {
+    return { mimeType: "image/webp" };
+  }
+  if (bytes.length >= 4 && bytes[0] === 0xff && bytes[1] === 0xd8) {
+    let offset = 2;
+    while (offset + 9 < bytes.length) {
+      if (bytes[offset] !== 0xff) { offset += 1; continue; }
+      const marker = bytes[offset + 1];
+      if (marker === 0xd8 || marker === 0xd9) { offset += 2; continue; }
+      const length = bytes.readUInt16BE(offset + 2);
+      if (length < 2 || offset + 2 + length > bytes.length) break;
+      if ([0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf].includes(marker)) {
+        return { mimeType: "image/jpeg", height: bytes.readUInt16BE(offset + 5), width: bytes.readUInt16BE(offset + 7) };
+      }
+      offset += 2 + length;
+    }
+    return { mimeType: "image/jpeg" };
+  }
+  throw providerError("Image API returned an unsupported image format", "ccdx_image_format_unsupported");
+}
+
+function ipv4Public(address) {
+  const parts = address.split(".").map(Number);
+  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return false;
+  const [a, b, c] = parts;
+  if (a === 0 || a === 10 || a === 127 || a >= 224) return false;
+  if (a === 100 && b >= 64 && b <= 127) return false;
+  if (a === 169 && b === 254) return false;
+  if (a === 172 && b >= 16 && b <= 31) return false;
+  if (a === 192 && (b === 168 || (b === 0 && [0, 2].includes(c)))) return false;
+  if (a === 198 && (b === 18 || b === 19 || (b === 51 && c === 100))) return false;
+  if (a === 203 && b === 0 && c === 113) return false;
+  return true;
+}
+
+function publicAddress(address) {
+  const family = net.isIP(address);
+  if (family === 4) return ipv4Public(address);
+  if (family !== 6) return false;
+  const lower = address.toLowerCase();
+  if (lower === "::" || lower === "::1" || lower.startsWith("fc") || lower.startsWith("fd")
+    || /^fe[89ab]/.test(lower) || lower.startsWith("ff") || lower.startsWith("2001:db8:")) return false;
+  const mapped = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(lower);
+  return mapped ? ipv4Public(mapped[1]) : true;
+}
+
+export async function downloadPublicImage(urlValue, {
+  lookup = dns.lookup,
+  timeoutMs = IMAGE_DOWNLOAD_TIMEOUT_MS,
+  maxBytes = IMAGE_MAX_BYTES,
+  signal,
+} = {}) {
+  let url;
+  try { url = new URL(urlValue); } catch { throw providerError("Image API returned an invalid image URL"); }
+  if (url.protocol !== "https:" || url.username || url.password) {
+    throw providerError("Image API returned an unsafe image URL", "ccdx_image_url_unsafe");
+  }
+  const addresses = await lookup(url.hostname, { all: true, verbatim: true });
+  if (!Array.isArray(addresses) || !addresses.length || addresses.some(({ address }) => !publicAddress(address))) {
+    throw providerError("Image API returned a non-public image URL", "ccdx_image_url_unsafe");
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      signal?.removeEventListener("abort", onAbort);
+      if (error) reject(error);
+      else resolve(value);
+    };
+    const request = https.get(url, {
+      headers: { Accept: "image/*,application/octet-stream;q=0.5" },
+      lookup: (_hostname, options, callback) => {
+        if (options?.all) callback(null, addresses);
+        else callback(null, addresses[0].address, addresses[0].family);
+      },
+    }, (response) => {
+      if (response.statusCode < 200 || response.statusCode >= 300) {
+        response.resume();
+        finish(providerError(`Image download failed with HTTP ${response.statusCode}`));
+        return;
+      }
+      const declared = Number(response.headers["content-length"]);
+      if (Number.isFinite(declared) && declared > maxBytes) {
+        response.destroy();
+        finish(providerError("Generated image exceeds the size limit", "ccdx_image_too_large"));
+        return;
+      }
+      const chunks = [];
+      let total = 0;
+      response.on("data", (chunk) => {
+        total += chunk.length;
+        if (total > maxBytes) {
+          response.destroy();
+          finish(providerError("Generated image exceeds the size limit", "ccdx_image_too_large"));
+          return;
+        }
+        chunks.push(chunk);
+      });
+      response.on("end", () => finish(null, Buffer.concat(chunks, total)));
+      response.on("error", (error) => finish(error));
+    });
+    const timer = setTimeout(() => request.destroy(providerError("Image download timed out", "ccdx_image_timeout")), timeoutMs);
+    timer.unref?.();
+    request.on("close", () => clearTimeout(timer));
+    request.on("error", (error) => finish(error));
+    const onAbort = () => request.destroy(signal.reason instanceof Error ? signal.reason : providerError("Image request was cancelled"));
+    if (signal?.aborted) onAbort();
+    else signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+export async function generateImage(config, {
+  prompt,
+  size = "1024x1024",
+} = {}, {
+  fetchImpl = fetch,
+  downloadImage = downloadPublicImage,
+  signal,
+  timeoutMs = IMAGE_GENERATION_TIMEOUT_MS,
+} = {}) {
+  const normalizedPrompt = checkedPrompt(prompt);
+  const normalizedSize = checkedSize(size);
+  const timeout = AbortSignal.timeout(timeoutMs);
+  const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
+  let response;
+  try {
+    response = await fetchImpl(config.endpoint, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${config.api_key}`,
+        "Content-Type": "application/json",
+        Accept: "application/json",
+      },
+      body: JSON.stringify(generationBody(config, normalizedPrompt, normalizedSize)),
+      signal: requestSignal,
+    });
+  } catch (error) {
+    if (requestSignal.aborted) throw providerError("Image generation timed out or was cancelled", "ccdx_image_timeout");
+    throw providerError("Image API could not be reached");
+  }
+  const body = await boundedJson(response);
+  if (!response.ok) {
+    const detail = upstreamMessage(body);
+    throw providerError(`Image API failed with HTTP ${response.status}${detail ? `: ${detail}` : ""}`);
+  }
+  const source = imageSource(body);
+  if (!source) throw providerError("Image API response did not contain an image");
+  let bytes;
+  try {
+    bytes = source.type === "base64"
+      ? Buffer.from(source.value, "base64")
+      : await downloadImage(source.value, { signal: requestSignal, maxBytes: IMAGE_MAX_BYTES });
+  } catch (error) {
+    if (error?.code?.startsWith?.("ccdx_")) throw error;
+    const code = String(error?.cause?.code || error?.code || "").replace(/[^A-Z0-9_-]/gi, "").slice(0, 64);
+    throw providerError(`Generated image could not be downloaded${code ? ` (${code})` : ""}`);
+  }
+  if (!bytes.length || bytes.length > IMAGE_MAX_BYTES) {
+    throw providerError("Generated image is empty or exceeds the size limit", "ccdx_image_too_large");
+  }
+  const metadata = imageMetadata(bytes);
+  return {
+    data: bytes.toString("base64"),
+    mimeType: metadata.mimeType,
+    width: metadata.width,
+    height: metadata.height,
+    model: config.model,
+    size: normalizedSize,
+  };
+}

package/src/observability.mjs

@@ -154,6 +154,7 @@ export function runtimeStatusPayload({
   streamPerformance,
   admission,
   imagePressure,
+  responseFailures,
   modelRegistry,
   codexClient,
   codexModelRegistry,
@@ -177,6 +178,7 @@ export function runtimeStatusPayload({
     response_history: responseHistoryStats(),
     image_optimization: imageOptimizationStats(),
     image_history_pressure: imagePressure?.snapshot?.() || null,
+    response_failures: responseFailures?.snapshot?.() || null,
     copilot: codexRuntime,
     models: codexModels,
     profiles: {

package/src/response-failures.mjs

@@ -0,0 +1,100 @@
+import { terminalCell } from "./cli-table.mjs";
+
+const DEFAULT_RECENT_FAILURES = 10;
+
+function safeIdentifier(value, fallback = "unknown") {
+  const text = terminalCell(value, { fallback });
+  return text.slice(0, 200);
+}
+
+function safeFailureMessage(value) {
+  let text = terminalCell(value, { fallback: "Response failed without an error message" });
+  text = text
+    .replace(/(encrypted(?: function output)? content\s+)[A-Za-z0-9+/_=-]{24,}/gi, "$1[redacted]")
+    .replace(/\b[A-Za-z0-9+/_=-]{96,}\b/g, "[redacted]");
+  return text.slice(0, 500);
+}
+
+function upstreamRequestId(headers) {
+  if (!headers?.get) return null;
+  for (const name of ["x-request-id", "x-github-request-id", "x-ms-request-id", "request-id", "x-correlation-id"]) {
+    const value = headers.get(name);
+    if (value) return safeIdentifier(value, "");
+  }
+  return null;
+}
+
+export function responseFailureDetails(event, eventType = event?.type, {
+  model,
+  headers,
+  retried = false,
+  retryPolicy = null,
+  retrySkipped = null,
+} = {}) {
+  const response = event?.response && typeof event.response === "object" ? event.response : event;
+  const error = response?.error && typeof response.error === "object"
+    ? response.error
+    : event?.error && typeof event.error === "object"
+      ? event.error
+      : event;
+  return {
+    at: new Date().toISOString(),
+    event_type: safeIdentifier(eventType || "response.failed"),
+    model: safeIdentifier(response?.model || model),
+    code: safeIdentifier(error?.code || "unknown_error"),
+    message: safeFailureMessage(error?.message),
+    response_id: response?.id ? safeIdentifier(response.id, "") : null,
+    upstream_request_id: upstreamRequestId(headers),
+    retried: Boolean(retried),
+    retry_policy: retryPolicy ? safeIdentifier(retryPolicy, "") : null,
+    retry_skipped: retrySkipped ? safeIdentifier(retrySkipped, "") : null,
+  };
+}
+
+export function responseFailureText(event, eventType = event?.type) {
+  const response = event?.response && typeof event.response === "object" ? event.response : event;
+  const error = response?.error && typeof response.error === "object"
+    ? response.error
+    : event?.error && typeof event.error === "object"
+      ? event.error
+      : event;
+  return JSON.stringify({ error: { code: error?.code, message: error?.message } });
+}
+
+export function formatResponseFailureLog(details) {
+  const fields = [
+    `Responses ${details.event_type}`,
+    `model=${details.model}`,
+    `code=${details.code}`,
+    details.response_id ? `response_id=${details.response_id}` : null,
+    details.upstream_request_id ? `upstream_request_id=${details.upstream_request_id}` : null,
+    details.retried ? `retry=${details.retry_policy || "yes"}` : null,
+    details.retry_skipped ? `retry_skipped=${details.retry_skipped}` : null,
+    `message=${details.message}`,
+  ].filter(Boolean);
+  return fields.join(" ");
+}
+
+export function createResponseFailureDiagnostics({
+  maxEntries = DEFAULT_RECENT_FAILURES,
+  now = () => new Date().toISOString(),
+} = {}) {
+  const recent = [];
+  let total = 0;
+  let retried = 0;
+  return {
+    record(details) {
+      total += 1;
+      if (details.retried) retried += 1;
+      recent.push({ ...details, at: now() });
+      if (recent.length > maxEntries) recent.splice(0, recent.length - maxEntries);
+    },
+    snapshot() {
+      return {
+        total,
+        retried,
+        recent: recent.map((entry) => ({ ...entry })),
+      };
+    },
+  };
+}

package/src/responses-handler.mjs

@@ -109,6 +109,7 @@ export function createResponsesHandler(options) {
     requestBodyTimeoutMs,
     responsesPayloadOptions,
     responsesFn,
+    responseFailures,
     streamHandshakeTimeoutMs,
     streamIdleTimeoutMs,
     upstreamTimeoutMs,
@@ -255,6 +256,7 @@ export function createResponsesHandler(options) {
           abort,
           onUpstreamStart: startUpstreamTimeout,
           releaseRequest: releaseUpstreamPayload,
+          responseFailures,
           streamIdleTimeoutMs,
         });
         if (result?.successful) imagePressure?.markSuccess?.(responseHistoryPressureRootId(prepared));

package/src/responses-proxy.mjs

@@ -8,8 +8,18 @@ import {
   sendUpstreamError,
   writeOrDrain,
 } from "./http-transport.mjs";
-import { openCopilotResponse } from "./copilot-responses-compat.mjs";
-import { rememberResponseHistory } from "./responses-request.mjs";
+import { openCopilotResponse, selectCopilotResponseRetry } from "./copilot-responses-compat.mjs";
+import {
+  dropMaterializedResponseHistory,
+  hasEncryptedResponseState,
+  rememberResponseHistory,
+  restoreMaterializedResponseHistoryForRetry,
+} from "./responses-request.mjs";
+import {
+  formatResponseFailureLog,
+  responseFailureDetails,
+  responseFailureText,
+} from "./response-failures.mjs";
 import {
   compactionInputWithoutTrigger,
   parseResponsesCompactionResult,
@@ -30,9 +40,11 @@ import {
 } from "./stream-performance.mjs";
 import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
 import { recordResponsesUsage } from "./usage.mjs";
+import { status } from "./status.mjs";
 
 const MAX_SSE_BUFFER_BYTES = loadRuntimeConfig().maxSseBufferBytes;
 const SSE_WRITE_BATCH_BYTES = 64 * 1024;
+const STREAM_RETRY_PRELUDE_MAX_BYTES = 256 * 1024;
 const RESPONSES_TERMINAL_EVENT_TYPES = new Set([
   "response.completed",
   "response.incomplete",
@@ -124,7 +136,9 @@ function inspectResponseSseEvent(state, eventName, data) {
     );
   }
   state.sawTerminal = true;
-  if (eventType === "response.failed" || eventType === "error") markStreamFailure();
+  if (eventType === "response.failed" || eventType === "error") {
+    state.failure = { event, eventType };
+  }
   if (eventType === "response.completed") {
     const response = event.response;
     state.completed = { response, event };
@@ -292,68 +306,182 @@ function storeCompletedResponse(reqContext, completed) {
   });
 }
 
-export async function proxyCopilotResponses(reqContext, req, res, upstream = copilotResponses, options = {}) {
-  let opened;
+function streamHeaders(resp) {
+  return {
+    ...safeUpstreamResponseHeaders(resp.headers, { defaultContentType: "text/event-stream" }),
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+  };
+}
+
+function selectStreamFailureRetry(reqContext, failure, usedRetryPolicies) {
+  if (!failure) return null;
   try {
-    opened = await openCopilotResponse(reqContext, upstream, options);
-  } finally {
-    options.releaseRequest?.(opened?.reqContext);
-  }
-  const { resp, errorText } = opened;
-  reqContext = opened.reqContext;
-  if (errorText !== undefined) {
-    sendUpstreamError(res, resp, errorText);
-    return { successful: false, compacted: false, upstreamStatus: resp.status };
+    const restored = restoreMaterializedResponseHistoryForRetry(reqContext);
+    return {
+      retry: selectCopilotResponseRetry(
+        restored,
+        400,
+        responseFailureText(failure.event, failure.eventType),
+        usedRetryPolicies,
+      ),
+      retrySkipped: null,
+    };
+  } catch {
+    return { retry: null, retrySkipped: "history_unavailable" };
   }
+}
 
-  if (reqContext.body.stream) {
+function recordResponseFailure(options, reqContext, resp, failure, {
+  retry,
+  retrySkipped,
+} = {}) {
+  if (!failure) return;
+  const details = responseFailureDetails(failure.event, failure.eventType, {
+    model: reqContext.body?.model,
+    headers: resp.headers,
+    retried: Boolean(retry),
+    retryPolicy: retry?.policyId,
+    retrySkipped,
+  });
+  options.responseFailures?.record?.(details);
+  console.warn(status("warn", formatResponseFailureLog(details)));
+}
+
+async function proxyStreamingResponses(opened, res, upstream, options) {
+  while (true) {
+    let {
+      resp,
+      errorText,
+      reqContext,
+      streamRetryEligible = false,
+      usedRetryPolicies = new Set(),
+    } = opened;
+    if (errorText !== undefined) {
+      sendUpstreamError(res, resp, errorText);
+      return { successful: false, compacted: false, upstreamStatus: resp.status };
+    }
     await requireUpstreamEventStream(resp);
     options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
-    res.writeHead(resp.status, {
-      ...safeUpstreamResponseHeaders(resp.headers, { defaultContentType: "text/event-stream" }),
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-    });
+    const headers = streamHeaders(resp);
+    let headersSent = false;
+    const writeHeaders = () => {
+      if (headersSent || res.headersSent) return;
+      headersSent = true;
+      res.writeHead(resp.status, headers);
+    };
     const reader = resp.body.getReader();
     const streamState = {
       completed: null,
+      failure: null,
       sawTerminal: false,
       sawOutput: false,
       toolArgumentGuard: new ToolArgumentDeltaGuard(),
       messageIds: new Map(),
     };
     const transformer = createResponseSseTransformer(streamState);
+    let holdPrelude = streamRetryEligible;
+    let retryDisabledReason = holdPrelude ? null : "request_not_eligible";
+    const prelude = [];
+    let preludeBytes = 0;
+    const flushPrelude = async () => {
+      if (!preludeBytes) return true;
+      writeHeaders();
+      const body = prelude.length === 1 ? prelude[0] : Buffer.concat(prelude, preludeBytes);
+      prelude.length = 0;
+      preludeBytes = 0;
+      return writeOrDrain(res, body);
+    };
+    const forwardFrame = async (frame) => {
+      if (!frame) return true;
+      if (!holdPrelude) {
+        writeHeaders();
+        return writeOrDrain(res, frame);
+      }
+      prelude.push(frame);
+      preludeBytes += frame.byteLength;
+      if (!streamState.sawOutput && preludeBytes <= STREAM_RETRY_PRELUDE_MAX_BYTES) return true;
+      retryDisabledReason = streamState.sawOutput ? "output_started" : "prelude_limit";
+      holdPrelude = false;
+      return flushPrelude();
+    };
+
     try {
       while (true) {
         const { done, value } = await reader.read();
         if (done) {
           if (!streamState.sawTerminal) throw incompleteUpstreamStream("a terminal Responses event");
-          storeCompletedResponse(reqContext, streamState.completed);
-          res.end();
-          return { successful: Boolean(streamState.completed), compacted: false };
+          break;
         }
         options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
-        // Batch within this read, not across reads, and await drain before processing more.
         for (let offset = 0; offset < value.byteLength; offset += SSE_WRITE_BATCH_BYTES) {
           const frame = transformer.push(value.subarray(offset, offset + SSE_WRITE_BATCH_BYTES));
-          if (frame && !await writeOrDrain(res, frame)) return;
+          if (!await forwardFrame(frame)) return { successful: false, compacted: false };
           if (streamState.sawTerminal) break;
         }
-        if (streamState.sawTerminal) {
-          storeCompletedResponse(reqContext, streamState.completed);
-          res.end();
-          return { successful: Boolean(streamState.completed), compacted: false };
-        }
+        if (streamState.sawTerminal) break;
+      }
+
+      let retry = null;
+      if (streamState.failure && holdPrelude && !streamState.sawOutput) {
+        const selected = selectStreamFailureRetry(reqContext, streamState.failure, usedRetryPolicies);
+        retry = selected?.retry || null;
+        if (!retry) retryDisabledReason = selected?.retrySkipped || "not_applicable";
+      }
+      if (streamState.failure) {
+        recordResponseFailure(options, reqContext, resp, streamState.failure, {
+          retry,
+          retrySkipped: retry ? null : retryDisabledReason,
+        });
+      }
+      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);
+        continue;
       }
-    } catch (e) {
-      logRequestFailure("Responses", e, options.abort);
-      await endStreamWithError(res, e, options.abort);
+      if (streamState.failure) markStreamFailure();
+      if (holdPrelude && !await flushPrelude()) return { successful: false, compacted: false };
+      storeCompletedResponse(reqContext, streamState.completed);
+      if (!res.writableEnded) res.end();
+      return { successful: Boolean(streamState.completed), compacted: false };
+    } catch (error) {
+      logRequestFailure("Responses", error, options.abort);
+      writeHeaders();
+      await endStreamWithError(res, error, options.abort);
       return { successful: false, compacted: false };
     } finally {
       await reader.cancel().catch(() => {});
       reader.releaseLock();
     }
-  } else {
+  }
+}
+
+export async function proxyCopilotResponses(reqContext, req, res, upstream = copilotResponses, options = {}) {
+  let opened;
+  try {
+    opened = await openCopilotResponse(reqContext, upstream, options);
+    opened.streamRetryEligible = opened.reqContext.body.stream === true
+      && hasEncryptedResponseState(opened.reqContext.body?.input);
+  } finally {
+    options.releaseRequest?.(opened?.reqContext);
+  }
+  reqContext = opened.reqContext;
+  if (reqContext.body.stream) {
+    return proxyStreamingResponses(opened, res, upstream, options);
+  }
+
+  while (true) {
+    const { resp, errorText, usedRetryPolicies = new Set() } = opened;
+    reqContext = opened.reqContext;
+    if (errorText !== undefined) {
+      sendUpstreamError(res, resp, errorText);
+      return { successful: false, compacted: false, upstreamStatus: resp.status };
+    }
     const data = resp.ok
       ? await readBoundedResponseText(resp, {
         maxBytes: MAX_UPSTREAM_RESPONSES_SUCCESS_BODY_BYTES,
@@ -385,6 +513,24 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
     }
     if (resp.ok) {
       const response = parseSuccessfulResponsesResult(data);
+      if (response.status === "failed") {
+        const failure = { event: { type: "response.failed", response }, eventType: "response.failed" };
+        const selected = selectStreamFailureRetry(reqContext, failure, usedRetryPolicies);
+        const retry = selected?.retry || null;
+        recordResponseFailure(options, reqContext, resp, failure, {
+          retry,
+          retrySkipped: retry ? null : selected?.retrySkipped || "not_applicable",
+        });
+        if (retry) {
+          console.warn(status("warn", retry.warning));
+          opened = await openCopilotResponse(retry.reqContext, upstream, {
+            ...options,
+            usedRetryPolicies: retry.usedPolicies,
+          });
+          dropMaterializedResponseHistory(opened.reqContext);
+          continue;
+        }
+      }
       rememberResponseHistory(reqContext, response);
       recordResponsesUsage({
         surface: reqContext.surface,
@@ -397,7 +543,7 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
         contentType: "application/json",
       }));
       res.end(data);
-      return { successful: true, compacted: false };
+      return { successful: response.status !== "failed" && response.status !== "incomplete", compacted: false };
     }
     res.writeHead(resp.status, safeUpstreamResponseHeaders(resp.headers, {
       contentType: "application/json",