codex-copilot-dx 0.4.43 → 0.4.44

package/src/doctor.mjs

@@ -124,6 +124,15 @@ function parseResponseObject(text) {
   return response;
 }
 
+function parseCompactionResponse(text) {
+  const response = parseResponseObject(text);
+  if (response.object !== "response.compaction"
+    || !response.output.some((item) => item?.type === "compaction")) {
+    throw new Error("response body is missing valid compaction state");
+  }
+  return response;
+}
+
 export async function inspectAdapterCompatibility({
   host = "127.0.0.1",
   port = 2026,
@@ -184,7 +193,7 @@ export async function inspectAdapterCompatibility({
       stream: false,
       input: "Compact this short context.",
     }, timeoutMs);
-    parseResponseObject(text);
+    parseCompactionResponse(text);
   });
 
   if (!claudeModel) {
@@ -446,7 +455,7 @@ export async function collectDoctorChecks({
 export async function runDoctor(options = {}) {
   const log = options.log || console.log;
   const flags = [options.online ? "--online" : "", options.compat ? "--compat" : ""].filter(Boolean);
-  log(`codex-copilot-dx doctor${flags.length ? ` ${flags.join(" ")}` : ""}`);
+  log(`ccdx doctor${flags.length ? ` ${flags.join(" ")}` : ""}`);
   const checks = await collectDoctorChecks(options);
   for (const check of checks) log(status(check.kind, check.message));
   return checks;

package/src/http-transport.mjs

@@ -2,6 +2,7 @@ import { promisify } from "node:util";
 import * as zlib from "node:zlib";
 import { loadRuntimeConfig, parsePositiveInteger } from "./runtime-config.mjs";
 import { status } from "./status.mjs";
+import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
 
 const COMPRESSED_BODY_WEIGHT_MULTIPLIER = 4;
 const gunzipAsync = promisify(zlib.gunzip);
@@ -296,7 +297,9 @@ export function sendJsonError(res, err, fallbackStatus = 400) {
 
 export function sendUpstreamError(res, response, text) {
   if (!res.headersSent) {
-    res.writeHead(response.status || 502, { "Content-Type": response.headers?.get("content-type") || "application/json" });
+    res.writeHead(response.status || 502, safeUpstreamResponseHeaders(response.headers, {
+      defaultContentType: "application/json",
+    }));
   }
   res.end(text || JSON.stringify({ error: "Upstream request failed" }));
 }

package/src/image-optimization.mjs

@@ -4,17 +4,19 @@ import {
   readResponsesImagePart,
   readResponsesToolOutputParts,
 } from "./responses-content.mjs";
+import { createBoundedResultCache } from "./bounded-result-cache.mjs";
 import { status } from "./status.mjs";
 
 const DEFAULT_IMG_CONCURRENCY = 2;
 const IMG_MAX_CONCURRENCY = 12;
 const DEFAULT_IMG_MAX_INPUT_PIXELS = 40 * 1000 * 1000;
+const DEFAULT_IMG_CACHE_MAX_BYTES = 64 * 1024 * 1024;
 const DEFAULT_MAX_UPSTREAM_BODY_BYTES = 30 * 1024 * 1024;
-const MAX_OPTIMIZED_IMAGE_DIGESTS = 4096;
 const IMG_MAX_DIM = positiveInt(process.env.CCDX_IMG_MAX_DIM, 2048);
 const IMG_QUALITY = positiveInt(process.env.CCDX_IMG_QUALITY, 82, 100);
 const IMG_MIN_BYTES = nonNegativeInt(process.env.CCDX_IMG_MIN_BYTES, 100000);
 const IMG_MAX_INPUT_PIXELS = positiveInt(process.env.CCDX_IMG_MAX_INPUT_PIXELS, DEFAULT_IMG_MAX_INPUT_PIXELS);
+const IMG_CACHE_MAX_BYTES = nonNegativeInt(process.env.CCDX_IMG_CACHE_MAX_BYTES, DEFAULT_IMG_CACHE_MAX_BYTES);
 const MAX_UPSTREAM_BODY_BYTES = positiveInt(process.env.CCDX_MAX_UPSTREAM_BODY_BYTES, DEFAULT_MAX_UPSTREAM_BODY_BYTES);
 const IMG_OPT_DISABLED = process.env.CCDX_DISABLE_IMG_OPT === "1";
 const IMG_CONCURRENCY = parseImageConcurrency(process.env.CCDX_IMG_CONCURRENCY);
@@ -22,7 +24,8 @@ const OVERSIZE_IMAGE_PROFILES = [
   { maxDim: Math.min(IMG_MAX_DIM, 1600), quality: Math.min(IMG_QUALITY, 75) },
   { maxDim: Math.min(IMG_MAX_DIM, 1280), quality: Math.min(IMG_QUALITY, 65) },
 ];
-const optimizedImageDigests = new Set();
+const IMAGE_ENCODER_CONFIG = "webp:v1:effort=4:autorotate=1:fit=inside:without_enlargement=1";
+const imageResultCache = createBoundedResultCache({ maxBytes: IMG_CACHE_MAX_BYTES });
 let sharpImport = null;
 
 function positiveInt(value, fallback, max = Number.MAX_SAFE_INTEGER) {
@@ -140,52 +143,50 @@ export function createTaskLimiter(concurrency) {
 const runGlobalImageTask = createTaskLimiter(IMG_CONCURRENCY);
 
 export function imageOptimizationStats() {
+  const cache = imageResultCache.stats();
   return {
     ...runGlobalImageTask.stats(),
     disabled: IMG_OPT_DISABLED,
-    cache_entries: optimizedImageDigests.size,
+    cache_entries: cache.entries,
+    cache_bytes: cache.bytes,
+    cache_max_bytes: cache.max_bytes,
+    cache_hits: cache.hits,
+    cache_misses: cache.misses,
+    cache_evictions: cache.evictions,
+    cache_inflight: cache.inflight,
     sharp_loaded: sharpImport !== null,
   };
 }
 
+export function resetImageOptimizationCacheForTests() {
+  imageResultCache.clear();
+}
+
 async function sharp() {
   sharpImport ||= import("sharp");
   const mod = await sharpImport;
   return mod.default || mod;
 }
 
-function imageDigest(raw) {
-  return createHash("sha256").update(raw).digest("base64url");
+function imageDigest(value, encoding) {
+  return createHash("sha256").update(value, encoding).digest("base64url");
 }
 
-function imageOptimizationKey(digest, constraints, quality) {
+function imageOptimizationKey(digest, mime, constraints, quality) {
   return [
     digest,
+    mime,
     constraints.maxLongEdge || "",
     constraints.maxShortEdge || "",
     constraints.maxArea || "",
     quality,
+    IMAGE_ENCODER_CONFIG,
   ].join(":");
 }
 
-function touchOptimizedImage(digest) {
-  if (!optimizedImageDigests.delete(digest)) return false;
-  optimizedImageDigests.add(digest);
-  return true;
-}
-
-function rememberOptimizedImage(digest) {
-  optimizedImageDigests.delete(digest);
-  optimizedImageDigests.add(digest);
-  if (optimizedImageDigests.size > MAX_OPTIMIZED_IMAGE_DIGESTS) {
-    optimizedImageDigests.delete(optimizedImageDigests.values().next().value);
-  }
-}
-
 export async function optimizeImageDataUrl(dataUrl, {
   maxDim = IMG_MAX_DIM,
   quality = IMG_QUALITY,
-  force = false,
   model,
   signal,
 } = {}) {
@@ -197,52 +198,60 @@ export async function optimizeImageDataUrl(dataUrl, {
   const encoded = match[2];
   const inputBytes = Buffer.byteLength(encoded, "base64");
   if (mime.includes("gif")) return dataUrl;
+  if (signal?.aborted) throw abortError(signal);
+  const constraints = imageConstraintsForModel(model, { maxDim });
+  const outputQuality = positiveInt(quality, IMG_QUALITY, 100);
+  // Hash decoded source bytes without retaining a decoded Buffer. Cache hits
+  // therefore bypass both Sharp and the global image work queue.
+  const digest = imageDigest(encoded, "base64");
+  const optimizationKey = imageOptimizationKey(digest, mime, constraints, outputQuality);
 
   try {
-    return await runGlobalImageTask(async () => {
-      const raw = Buffer.from(encoded, "base64");
-      const digest = imageDigest(raw);
-      const constraints = imageConstraintsForModel(model, { maxDim });
-      const outputQuality = positiveInt(quality, IMG_QUALITY, 100);
-      const optimizationKey = imageOptimizationKey(digest, constraints, outputQuality);
-      if (!force && touchOptimizedImage(optimizationKey)) return dataUrl;
-      const resize = await sharp();
-      const image = resize(raw, { failOn: "none", limitInputPixels: IMG_MAX_INPUT_PIXELS });
-      const metadata = await image.metadata();
-      const orientation = Number(metadata.orientation);
-      const rotated = orientation >= 5 && orientation <= 8;
-      const sourceWidth = rotated ? metadata.height : metadata.width;
-      const sourceHeight = rotated ? metadata.width : metadata.height;
-      const target = fitImageDimensions(sourceWidth, sourceHeight, constraints);
-      const resizeRequired = target
-        && (target.width < sourceWidth || target.height < sourceHeight);
-      if (raw.length < IMG_MIN_BYTES && !resizeRequired) {
-        rememberOptimizedImage(optimizationKey);
-        return dataUrl;
-      }
-      const resizeOptions = target
-        ? { ...target, fit: "inside", withoutEnlargement: true }
-        : {
-            width: constraints.maxLongEdge,
-            height: constraints.maxLongEdge,
-            fit: "inside",
-            withoutEnlargement: true,
-          };
-      const out = await image
-        .rotate()
-        .resize(resizeOptions)
-        .webp({ quality: outputQuality, effort: 4 })
-        .toBuffer();
-      if (signal?.aborted) throw abortError(signal);
-      if (out.length >= raw.length) {
-        rememberOptimizedImage(optimizationKey);
-        return dataUrl;
-      }
-      rememberOptimizedImage(imageOptimizationKey(imageDigest(out), constraints, outputQuality));
-      const ratio = ((out.length / raw.length) * 100).toFixed(1);
-      console.log(status("info", `image ${(raw.length / 1024).toFixed(0)}KB ${mime} -> ${(out.length / 1024).toFixed(0)}KB webp (${ratio}%)`));
-      return `data:image/webp;base64,${out.toString("base64")}`;
-    }, { signal });
+    return await imageResultCache.getOrCreate(optimizationKey, (sharedSignal) => (
+      runGlobalImageTask(async () => {
+        const raw = Buffer.from(encoded, "base64");
+        const resize = await sharp();
+        const image = resize(raw, { failOn: "none", limitInputPixels: IMG_MAX_INPUT_PIXELS });
+        const metadata = await image.metadata();
+        if (sharedSignal.aborted) throw abortError(sharedSignal);
+        const orientation = Number(metadata.orientation);
+        const rotated = orientation >= 5 && orientation <= 8;
+        const sourceWidth = rotated ? metadata.height : metadata.width;
+        const sourceHeight = rotated ? metadata.width : metadata.height;
+        const target = fitImageDimensions(sourceWidth, sourceHeight, constraints);
+        const resizeRequired = target
+          && (target.width < sourceWidth || target.height < sourceHeight);
+        if (raw.length < IMG_MIN_BYTES && !resizeRequired) return dataUrl;
+        const resizeOptions = target
+          ? { ...target, fit: "inside", withoutEnlargement: true }
+          : {
+              width: constraints.maxLongEdge,
+              height: constraints.maxLongEdge,
+              fit: "inside",
+              withoutEnlargement: true,
+            };
+        const out = await image
+          .rotate()
+          .resize(resizeOptions)
+          .webp({ quality: outputQuality, effort: 4 })
+          .toBuffer();
+        if (sharedSignal.aborted) throw abortError(sharedSignal);
+        if (out.length >= raw.length) return dataUrl;
+        const outputBase64 = out.toString("base64");
+        const outputDataUrl = `data:image/webp;base64,${outputBase64}`;
+        const outputKey = imageOptimizationKey(
+          imageDigest(outputBase64, "base64"),
+          "image/webp",
+          constraints,
+          outputQuality,
+        );
+        // Preserve idempotence when optimized history is submitted again.
+        imageResultCache.set(outputKey, outputDataUrl);
+        const ratio = ((out.length / raw.length) * 100).toFixed(1);
+        console.log(status("info", `image ${(raw.length / 1024).toFixed(0)}KB ${mime} -> ${(out.length / 1024).toFixed(0)}KB webp (${ratio}%)`));
+        return outputDataUrl;
+      }, { signal: sharedSignal })
+    ), { signal });
   } catch (e) {
     if (signal?.aborted || e?.name === "AbortError") throw e;
     if (inputBytes >= IMG_MIN_BYTES) {

package/src/observability.mjs

@@ -118,7 +118,7 @@ function modelRegistryStatus(modelRegistry) {
   };
 }
 
-export function runtimeStatusPayload({ metrics, admission, modelRegistry } = {}) {
+export function runtimeStatusPayload({ metrics, streamPerformance, admission, modelRegistry } = {}) {
   const memory = process.memoryUsage();
   return {
     ...adapterHealthPayload(),
@@ -131,6 +131,7 @@ export function runtimeStatusPayload({ metrics, admission, modelRegistry } = {})
       array_buffers_bytes: memory.arrayBuffers,
     },
     requests: metrics?.snapshot?.() || createRequestMetrics().snapshot(),
+    stream_performance: streamPerformance?.snapshot?.() || null,
     admission: admission?.diagnostics?.() || admission?.stats?.() || null,
     response_history: responseHistoryStats(),
     image_optimization: imageOptimizationStats(),

package/src/responses-bridge.mjs

@@ -2,6 +2,15 @@ import { randomUUID } from "node:crypto";
 import { chatCompletions } from "./copilot.mjs";
 import { webStreamLines } from "./stream.mjs";
 import { abortErrorStatusCode, isAbortLikeError } from "./http-transport.mjs";
+import {
+  incompleteUpstreamStream,
+  invalidUpstreamStream,
+  requireUpstreamEventStream,
+  ToolArgumentDeltaGuard,
+  upstreamChatStreamError,
+  withChatStreamUsage,
+} from "./stream-contract.mjs";
+import { isChatOutputDelta, markFirstOutput, markOutputTokens } from "./stream-performance.mjs";
 
 function cloneJson(value) {
   return value === undefined ? undefined : structuredClone(value);
@@ -134,7 +143,7 @@ export function chatToResponses(chatResp, model) {
 
 export async function forwardToChat(chatReq, emitEvent, onDone, onError, options = {}) {
   delete chatReq.max_tokens;
-  const upstreamReq = chatReq.stream === true ? chatReq : { ...chatReq, stream: true };
+  const upstreamReq = withChatStreamUsage(chatReq);
   const bodyText = upstreamReq === chatReq ? options.bodyText : undefined;
   let resp;
   try {
@@ -150,9 +159,16 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
     return;
   }
   if (!resp.ok) {
-    await onError(resp.status, await resp.text());
+    await onError(resp.status, await resp.text(), undefined, resp);
     return;
   }
+  try {
+    await requireUpstreamEventStream(resp);
+  } catch (error) {
+    await onError(error.statusCode, error.message, error);
+    return;
+  }
+  options.onUpstreamResponse?.(resp);
   options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
   const respId = `resp_${uid()}`;
   let actualModel = chatReq.model || "unknown";
@@ -161,6 +177,13 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
   let nextOutputIndex = 0;
   let usage = { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
   const toolCalls = new Map();
+  const toolArgumentGuard = new ToolArgumentDeltaGuard();
+  let performanceOutputSeen = false;
+  const markPerformanceOutput = () => {
+    if (performanceOutputSeen) return;
+    performanceOutputSeen = true;
+    markFirstOutput();
+  };
 
   await emitEvent("response.created", { response: { id: respId, object: "response", status: "in_progress", model: actualModel, output: [] } });
 
@@ -258,7 +281,16 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
       const data = line.slice(6).trim();
       if (data === "[DONE]") { await emitCompleted(); onDone(); return; }
       let parsed;
-      try { parsed = JSON.parse(data); } catch { continue; }
+      try {
+        parsed = JSON.parse(data);
+      } catch {
+        throw invalidUpstreamStream(
+          "Upstream Chat Completions SSE event contained invalid JSON",
+          "upstream_stream_json_invalid",
+        );
+      }
+      const upstreamError = upstreamChatStreamError(parsed);
+      if (upstreamError) throw upstreamError;
       if (parsed.model) actualModel = parsed.model;
       if (parsed.usage) {
         usage = {
@@ -268,9 +300,11 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
         };
         const cached = parsed.usage.prompt_tokens_details?.cached_tokens;
         if (cached) usage.input_tokens_details = { cached_tokens: cached };
+        markOutputTokens(usage.output_tokens);
       }
       const delta = parsed.choices?.[0]?.delta;
       if (!delta) continue;
+      if (isChatOutputDelta(delta)) markPerformanceOutput();
       if (delta.content) {
         const message = await ensureMessageItem();
         fullText += delta.content;
@@ -281,22 +315,24 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
           const { tool, created } = await ensureToolCall(tc);
           if (tc.id) tool.callId = tc.id;
           if (!created && tc.function?.name) tool.name += tc.function.name;
-          if (tc.function?.arguments) {
-            tool.arguments += tc.function.arguments;
+          const argumentDelta = tc.function?.arguments;
+          toolArgumentGuard.observe(tool.outputIndex, argumentDelta);
+          if (argumentDelta) {
+            tool.arguments += argumentDelta;
             await emitEvent("response.function_call_arguments.delta", {
               output_index: tool.outputIndex,
               item_id: tool.id,
-              delta: tc.function.arguments,
+              delta: argumentDelta,
             });
           }
         }
       }
     }
   } catch (e) {
-    const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(options.abort?.reason) : 502;
-    await onError(statusCode, e?.message || "upstream stream error");
+    const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(options.abort?.reason) : (e?.statusCode || 502);
+    await onError(statusCode, e?.message || "upstream stream error", e);
     return;
   }
-  await emitCompleted();
-  onDone();
+  const error = incompleteUpstreamStream("[DONE]");
+  await onError(error.statusCode, error.message, error);
 }

package/src/responses-chat-payload.mjs

@@ -5,6 +5,7 @@ import {
 } from "./responses-byte-budget.mjs";
 import { responsesToChat } from "./responses-bridge.mjs";
 import { readResponsesImagePart, readResponsesToolOutputParts } from "./responses-content.mjs";
+import { withChatStreamUsage } from "./stream-contract.mjs";
 
 const DEFAULT_MAX_UPSTREAM_BODY_BYTES = 30 * 1024 * 1024;
 
@@ -30,7 +31,7 @@ function chatRequest(responsesBody, stream) {
   const chatReq = responsesToChat(responsesBody);
   chatReq.stream = Boolean(stream);
   delete chatReq.max_tokens;
-  return chatReq;
+  return stream ? withChatStreamUsage(chatReq) : chatReq;
 }
 
 function adjustedResponsesTarget(limit, responsesBytes, chatBytes) {

package/src/responses-compaction.mjs

@@ -0,0 +1,113 @@
+import { randomUUID } from "node:crypto";
+import { httpError } from "./http-transport.mjs";
+
+const COMPACTION_TRIGGER_TYPE = "compaction_trigger";
+const RETAINED_MESSAGE_ROLES = new Set(["user", "assistant", "developer", "system"]);
+const RETAINED_MESSAGE_TOKEN_BUDGET = 64_000;
+const APPROX_BYTES_PER_TOKEN = 4;
+
+function compactionError(message) {
+  const error = httpError(message, 502);
+  error.code = "ccdx_invalid_compaction_response";
+  error.jsonBody = {
+    error: {
+      message,
+      type: "upstream_error",
+      code: error.code,
+    },
+  };
+  return error;
+}
+
+function normalizeMessageContent(content) {
+  if (typeof content === "string") return [{ type: "input_text", text: content }];
+  if (!Array.isArray(content)) return [];
+  return content.map((part) => {
+    if (!part || typeof part !== "object") return part;
+    return part.type === "output_text"
+      ? { ...part, type: "input_text" }
+      : structuredClone(part);
+  });
+}
+
+function approximateTextTokens(content) {
+  return content.reduce((total, part) => {
+    if (part?.type !== "input_text" || typeof part.text !== "string") return total;
+    return total + Math.ceil(Buffer.byteLength(part.text) / APPROX_BYTES_PER_TOKEN);
+  }, 0);
+}
+
+function retainedMessages(inputItems) {
+  const kept = [];
+  let usedTokens = 0;
+  for (let index = inputItems.length - 1; index >= 0; index -= 1) {
+    const item = inputItems[index];
+    if (item?.type !== "message" || !RETAINED_MESSAGE_ROLES.has(item.role)) continue;
+
+    const content = normalizeMessageContent(item.content);
+    usedTokens += Math.max(approximateTextTokens(content), 1);
+    if (usedTokens > RETAINED_MESSAGE_TOKEN_BUDGET && kept.length > 0) break;
+
+    kept.push({
+      type: "message",
+      id: `msg_${randomUUID().replaceAll("-", "")}`,
+      status: item.status ?? "completed",
+      role: item.role,
+      content,
+      ...(item.phase !== undefined ? { phase: structuredClone(item.phase) } : {}),
+    });
+  }
+  return kept.reverse();
+}
+
+export function prepareResponsesCompactionRequest(reqContext) {
+  const input = Array.isArray(reqContext?.body?.input) ? reqContext.body.input : [];
+  const compactionInputItems = compactionInputWithoutTrigger(input);
+  reqContext.body.input = [...compactionInputItems, { type: COMPACTION_TRIGGER_TYPE }];
+  reqContext.body.stream = false;
+  return reqContext;
+}
+
+export function compactionInputWithoutTrigger(input) {
+  return Array.isArray(input)
+    ? input.filter((item) => item?.type !== COMPACTION_TRIGGER_TYPE)
+    : [];
+}
+
+export function createResponsesCompactionResult(inputItems, generated) {
+  if (!generated || typeof generated !== "object" || !generated.id || !Array.isArray(generated.output)) {
+    throw compactionError("Copilot compaction returned an invalid response envelope");
+  }
+  if (Object.prototype.hasOwnProperty.call(generated, "status") && generated.status !== "completed") {
+    throw compactionError(`Copilot compaction returned status ${generated.status}`);
+  }
+
+  const compactionItems = generated.output.filter((item) => item?.type === "compaction");
+  if (!compactionItems.length) {
+    throw compactionError("Copilot compaction returned no compaction output item");
+  }
+  if (compactionItems.some((item) => (
+    typeof item.encrypted_content !== "string" || item.encrypted_content.length === 0
+  ))) {
+    throw compactionError("Copilot compaction returned an invalid compaction output item");
+  }
+
+  return {
+    ...generated,
+    object: "response.compaction",
+    output: [
+      ...retainedMessages(Array.isArray(inputItems) ? inputItems : []),
+      ...compactionItems,
+    ],
+  };
+}
+
+export function parseResponsesCompactionResult(inputItems, text) {
+  let generated;
+  try {
+    generated = JSON.parse(text);
+  } catch {
+    throw compactionError("Copilot compaction returned invalid JSON");
+  }
+  return createResponsesCompactionResult(inputItems, generated);
+}

package/src/responses-handler.mjs

@@ -15,10 +15,12 @@ import {
 } from "./models.mjs";
 import { chatToResponses, forwardToChat, responsesBodyUsesCustomTools } from "./responses-bridge.mjs";
 import { prepareResponsesChatPayload } from "./responses-chat-payload.mjs";
+import { prepareResponsesCompactionRequest } from "./responses-compaction.mjs";
 import { proxyCopilotResponses } from "./responses-proxy.mjs";
 import { prepareResponsesRequest, rememberResponseHistory } from "./responses-request.mjs";
 import { status } from "./status.mjs";
 import { endStreamWithError } from "./stream-errors.mjs";
+import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
 import { recordResponsesUsage } from "./usage.mjs";
 
 const RESPONSES_ONLY_FALLBACK = new Set([
@@ -113,20 +115,29 @@ export function createResponsesHandler(options) {
         });
         const { chatReq, bodyText } = chatPayload;
         if (parsed.stream) {
+          let streamResponseHeaders = null;
           await forwardToChat(chatReq, async (event, data) => {
-            if (!res.headersSent) res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
+            if (!res.headersSent) res.writeHead(200, {
+              ...streamResponseHeaders,
+              "Cache-Control": "no-cache",
+              Connection: "keep-alive",
+            });
             await writeOrDrain(res, `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
             if (event === "response.completed") {
               rememberResponseHistory(prepared, data.response);
               recordResponsesUsage({ surface: prepared.surface, mode: "stream", model, response: data.response, event: data });
             }
-          }, () => { if (!res.writableEnded) res.end(); }, async (statusCode, errMsg) => {
+          }, () => { if (!res.writableEnded) res.end(); }, async (statusCode, errMsg, error, upstreamResponse) => {
             if (!res.headersSent) {
-              res.writeHead(statusCode || 500, { "Content-Type": "text/plain; charset=utf-8" });
-              res.end(errMsg);
+              if (upstreamResponse) {
+                sendUpstreamError(res, upstreamResponse, errMsg);
+                return;
+              }
+              const responseError = error || Object.assign(new Error(errMsg), { statusCode });
+              sendJsonError(res, responseError, statusCode || 500);
               return;
             }
-            await endStreamWithError(res, "responses", new Error(errMsg), abort);
+            await endStreamWithError(res, "responses", error || new Error(errMsg), abort);
           }, {
             signal: abort.signal,
             abort,
@@ -134,6 +145,11 @@ export function createResponsesHandler(options) {
             chatCompletionsFn,
             releaseRequest,
             bodyText,
+            onUpstreamResponse: (upstreamResponse) => {
+              streamResponseHeaders = safeUpstreamResponseHeaders(upstreamResponse.headers, {
+                contentType: "text/event-stream",
+              });
+            },
           });
         } else {
           try {
@@ -147,7 +163,9 @@ export function createResponsesHandler(options) {
             const response = chatToResponses(JSON.parse(data), model);
             rememberResponseHistory(prepared, response);
             recordResponsesUsage({ surface: prepared.surface, mode: "json", model, response, event: response });
-            res.writeHead(200, { "Content-Type": "application/json" });
+            res.writeHead(200, safeUpstreamResponseHeaders(upstream.headers, {
+              contentType: "application/json",
+            }));
             res.end(JSON.stringify(response));
           } catch (error) {
             logRequestFailure("Responses", error, abort);
@@ -170,8 +188,6 @@ export function createResponsesCompactHandler(options) {
     acquireRequest,
     openAIModelEnv,
     responsesCompactFn,
-    streamHandshakeTimeoutMs,
-    streamIdleTimeoutMs,
     upstreamTimeoutMs,
   } = options;
 
@@ -181,22 +197,20 @@ export function createResponsesCompactHandler(options) {
     try {
       releaseRequest = await acquireRequest(req, { signal: abort.signal });
       const parsed = await readJsonBody(req);
-      abort.setTimeout(
-        parsed.stream ? streamHandshakeTimeoutMs : upstreamTimeoutMs,
-        parsed.stream ? "stream_handshake_timeout" : "upstream_timeout",
+      abort.setTimeout(upstreamTimeoutMs, "upstream_timeout");
+      const prepared = prepareResponsesCompactionRequest(
+        prepareResponsesRequest(parsed, { mutate: true }),
       );
-      const prepared = prepareResponsesRequest(parsed, { mutate: true });
       prepared.surface = "responses_compact";
       const model = parsed.model || "unknown";
       const { requestedModel, upstreamModel } = resolveOpenAIModel(model, openAIModelEnv);
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
-      console.log(status("info", `responses compact model=${requestedModel}${upstreamLog} stream=${!!parsed.stream}`));
+      console.log(status("info", `responses compact model=${requestedModel}${upstreamLog} stream=false`));
       await proxyCopilotResponses(prepared, req, res, responsesCompactFn, {
         signal: abort.signal,
         abort,
         releaseRequest,
-        streamIdleTimeoutMs,
       });
     } catch (error) {
       logRequestFailure("Responses compact", error, abort);