codex-copilot-dx 0.4.42 → 0.4.44

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-content.mjs

@@ -0,0 +1,86 @@
+export function isResponsesToolOutputItem(item) {
+  return item?.type === "function_call_output" || item?.type === "custom_tool_call_output";
+}
+
+const INLINE_IMAGE_DATA_URL = /^data:(image\/[a-z+.-]+);base64,(.+)$/i;
+
+export function canonicalInlineImageIdentity(dataUrl) {
+  if (typeof dataUrl !== "string") return null;
+  const match = INLINE_IMAGE_DATA_URL.exec(dataUrl);
+  if (!match) return null;
+  const canonicalMime = match[1].toLowerCase();
+  return match[1] === canonicalMime
+    ? dataUrl
+    : `data:${canonicalMime};base64,${match[2]}`;
+}
+
+function imageUrlAccessor(part) {
+  if (!part || !["input_image", "image_url"].includes(part.type)) return null;
+  if (typeof part.image_url === "string") return { owner: part, key: "image_url" };
+  if (part.image_url && typeof part.image_url === "object" && typeof part.image_url.url === "string") {
+    return { owner: part.image_url, key: "url" };
+  }
+  if (part.type === "image_url" && typeof part.url === "string") return { owner: part, key: "url" };
+  if (part.type === "image_url" && part.url && typeof part.url === "object" && typeof part.url.url === "string") {
+    return { owner: part.url, key: "url" };
+  }
+  return null;
+}
+
+export function readResponsesImagePart(part) {
+  const accessor = imageUrlAccessor(part);
+  if (accessor) {
+    return {
+      get dataUrl() {
+        return accessor.owner[accessor.key];
+      },
+      get identity() {
+        return canonicalInlineImageIdentity(accessor.owner[accessor.key]);
+      },
+      setDataUrl(value) {
+        if (typeof value !== "string" || accessor.owner[accessor.key] === value) return false;
+        accessor.owner[accessor.key] = value;
+        return true;
+      },
+    };
+  }
+
+  if (part?.type !== "image" || part.source?.type !== "base64" || typeof part.source.data !== "string") {
+    return null;
+  }
+  return {
+    get dataUrl() {
+      return `data:${part.source.media_type || "image/png"};base64,${part.source.data}`;
+    },
+    get identity() {
+      return canonicalInlineImageIdentity(`data:${part.source.media_type || "image/png"};base64,${part.source.data}`);
+    },
+    setDataUrl(value) {
+      const match = typeof value === "string" ? INLINE_IMAGE_DATA_URL.exec(value) : null;
+      if (!match) return false;
+      const mediaType = match[1].toLowerCase();
+      const data = match[2];
+      if (part.source.media_type === mediaType && part.source.data === data) return false;
+      part.source.media_type = mediaType;
+      part.source.data = data;
+      return true;
+    },
+  };
+}
+
+export function readResponsesToolOutputParts(item) {
+  if (!isResponsesToolOutputItem(item)) return null;
+  if (Array.isArray(item.output)) return { parts: item.output, commit: null };
+  if (typeof item.output !== "string" || !item.output.trim().startsWith("[")) return null;
+
+  try {
+    const parts = JSON.parse(item.output);
+    if (!Array.isArray(parts)) return null;
+    return {
+      parts,
+      commit: () => { item.output = JSON.stringify(parts); },
+    };
+  } catch {
+    return null;
+  }
+}

package/src/responses-handler.mjs

@@ -13,11 +13,14 @@ import {
   modelSupportsChatCompletions,
   resolveOpenAIModel,
 } from "./models.mjs";
-import { chatToResponses, forwardToChat, responsesToChat } from "./responses-bridge.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([
@@ -41,11 +44,34 @@ function isResponsesOnlyModel(model) {
   return RESPONSES_ONLY_FALLBACK.has(model);
 }
 
+function cachedModelSupportsResponses(model) {
+  const endpoints = getCachedModelEndpoints(model);
+  return Array.isArray(endpoints)
+    && (endpoints.includes("/responses") || endpoints.includes("/v1/responses"));
+}
+
+function unsupportedCustomToolsError(model) {
+  const message = `Model ${model} has custom tool items that cannot be represented by Chat Completions, and cached endpoint metadata does not confirm Responses support`;
+  const error = new Error(message);
+  error.statusCode = 400;
+  error.code = "ccdx_custom_tools_require_responses";
+  error.jsonBody = {
+    error: {
+      message,
+      type: "invalid_request_error",
+      code: error.code,
+      model,
+    },
+  };
+  return error;
+}
+
 export function createResponsesHandler(options) {
   const {
     acquireRequest,
     chatCompletionsFn,
     openAIModelEnv,
+    responsesPayloadOptions,
     responsesFn,
     streamHandshakeTimeoutMs,
     streamIdleTimeoutMs,
@@ -69,7 +95,12 @@ export function createResponsesHandler(options) {
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
       console.log(status("info", `responses model=${requestedModel}${upstreamLog} stream=${!!parsed.stream}`));
-      if (requestedModel === CODEX_AUTO_REVIEW_MODEL || isResponsesOnlyModel(upstreamModel)) {
+      const usesCustomTools = responsesBodyUsesCustomTools(prepared.body);
+      const useNativeResponses = requestedModel === CODEX_AUTO_REVIEW_MODEL
+        || isResponsesOnlyModel(upstreamModel)
+        || (usesCustomTools && cachedModelSupportsResponses(upstreamModel));
+      if (usesCustomTools && !useNativeResponses) throw unsupportedCustomToolsError(upstreamModel);
+      if (useNativeResponses) {
         await proxyCopilotResponses(prepared, req, res, responsesFn, {
           signal: abort.signal,
           abort,
@@ -77,34 +108,52 @@ export function createResponsesHandler(options) {
           streamIdleTimeoutMs,
         });
       } else {
-        const chatReq = responsesToChat(prepared.body);
+        const chatPayload = await prepareResponsesChatPayload(prepared, {
+          payloadOptions: responsesPayloadOptions,
+          signal: abort.signal,
+          stream: parsed.stream,
+        });
+        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,
             streamIdleTimeoutMs,
             chatCompletionsFn,
             releaseRequest,
+            bodyText,
+            onUpstreamResponse: (upstreamResponse) => {
+              streamResponseHeaders = safeUpstreamResponseHeaders(upstreamResponse.headers, {
+                contentType: "text/event-stream",
+              });
+            },
           });
         } else {
-          chatReq.stream = false;
-          delete chatReq.max_tokens;
           try {
-            const upstream = await chatCompletionsFn({ ...chatReq, stream: false }, { signal: abort.signal });
+            const upstream = await chatCompletionsFn(chatReq, { signal: abort.signal, bodyText });
             releaseRequest();
             const data = await upstream.text();
             if (!upstream.ok) {
@@ -114,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);
@@ -137,8 +188,6 @@ export function createResponsesCompactHandler(options) {
     acquireRequest,
     openAIModelEnv,
     responsesCompactFn,
-    streamHandshakeTimeoutMs,
-    streamIdleTimeoutMs,
     upstreamTimeoutMs,
   } = options;
 
@@ -148,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);

package/src/responses-image-limit.mjs

@@ -1,3 +1,5 @@
+import { readResponsesImagePart, readResponsesToolOutputParts } from "./responses-content.mjs";
+
 export const MAX_UPSTREAM_IMAGES = 50;
 
 function isImagePart(part) {
@@ -8,13 +10,13 @@ function isImagePart(part) {
 function imageIdentity(part) {
   if (!isImagePart(part)) return null;
 
+  const inlineIdentity = readResponsesImagePart(part)?.identity;
+  if (inlineIdentity) return { kind: "inline:data", value: inlineIdentity };
+
   if (part.type === "image") {
     const source = part.source;
-    if (typeof source?.data === "string") {
-      return { kind: `image:${source.type || "base64"}:${source.media_type || ""}`, value: source.data };
-    }
     if (typeof source?.url === "string") {
-      return { kind: `image:url:${part.detail || ""}`, value: source.url };
+      return { kind: `url:${part.detail || ""}`, value: source.url };
     }
   }
 
@@ -22,10 +24,10 @@ function imageIdentity(part) {
   const url = typeof raw === "string" ? raw : raw?.url;
   if (typeof url === "string") {
     const detail = part.detail ?? raw?.detail ?? "";
-    return { kind: `${part.type}:url:${detail}`, value: url };
+    return { kind: `url:${detail}`, value: url };
   }
   if (typeof part.file_id === "string") {
-    return { kind: `${part.type}:file`, value: part.file_id };
+    return { kind: "file", value: part.file_id };
   }
   return null;
 }
@@ -100,26 +102,13 @@ function collectImages(inputItems) {
       });
     }
 
-    if (item.type !== "function_call_output") continue;
-    if (Array.isArray(item.output)) {
-      addPartContainer(records, refs, item.output, {
-        kind: "tool-output",
-        itemIndex,
-      });
-      continue;
-    }
-    if (typeof item.output !== "string" || !item.output.trim().startsWith("[")) continue;
-    try {
-      const parsed = JSON.parse(item.output);
-      if (!Array.isArray(parsed)) continue;
-      addPartContainer(records, refs, parsed, {
-        kind: "tool-output",
-        itemIndex,
-        commit: () => { item.output = JSON.stringify(parsed); },
-      });
-    } catch {
-      // Preserve non-JSON tool output unchanged.
-    }
+    const toolOutput = readResponsesToolOutputParts(item);
+    if (!toolOutput) continue;
+    addPartContainer(records, refs, toolOutput.parts, {
+      kind: "tool-output",
+      itemIndex,
+      commit: toolOutput.commit,
+    });
   }
 
   if (hasTopLevelImages) records.push(topLevelRecord);

package/src/responses-proxy.mjs

@@ -6,33 +6,82 @@ import {
   writeOrDrain,
 } from "./http-transport.mjs";
 import { openCopilotResponse, rememberResponseHistory } from "./responses-request.mjs";
+import {
+  compactionInputWithoutTrigger,
+  parseResponsesCompactionResult,
+} from "./responses-compaction.mjs";
 import { loadRuntimeConfig } from "./runtime-config.mjs";
 import { endStreamWithError } from "./stream-errors.mjs";
+import {
+  incompleteUpstreamStream,
+  invalidUpstreamStream,
+  requireUpstreamEventStream,
+  ToolArgumentDeltaGuard,
+} from "./stream-contract.mjs";
+import {
+  isResponsesOutputEvent,
+  markFirstOutput,
+  markOutputTokens,
+  markStreamFailure,
+} from "./stream-performance.mjs";
+import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
 import { recordResponsesUsage } from "./usage.mjs";
 
 const MAX_SSE_BUFFER_BYTES = loadRuntimeConfig().maxSseBufferBytes;
+const RESPONSES_TERMINAL_EVENT_TYPES = new Set([
+  "response.completed",
+  "response.incomplete",
+  "response.failed",
+  "error",
+]);
 
-function storeCompletedResponseFromSse(reqContext, data) {
-  if (!data || data === "[DONE]") return;
+function inspectResponseSseEvent(state, eventName, data) {
+  if (!data || state.sawTerminal) return;
+  if (data === "[DONE]") {
+    throw invalidUpstreamStream(
+      "Upstream sent [DONE] before a terminal Responses event",
+      "upstream_stream_terminal_missing",
+    );
+  }
+  let event;
   try {
-    const event = JSON.parse(data);
-    const response = event.response;
-    if (response?.id && response.status === "completed") {
-      rememberResponseHistory(reqContext, response);
-      recordResponsesUsage({
-        surface: reqContext.surface,
-        mode: "stream",
-        model: reqContext.body?.model,
-        response,
-        event,
-      });
-    }
+    event = JSON.parse(data);
   } catch {
-    // Ignore non-JSON stream fragments.
+    throw invalidUpstreamStream(
+      "Upstream Responses SSE event contained invalid JSON",
+      "upstream_stream_json_invalid",
+    );
+  }
+  const eventType = event.type || eventName;
+  const outputTokens = event.response?.usage?.output_tokens ?? event.usage?.output_tokens;
+  if (outputTokens !== undefined) markOutputTokens(outputTokens);
+  if (!state.sawOutput && isResponsesOutputEvent(event, eventType)) {
+    state.sawOutput = true;
+    markFirstOutput();
+  }
+  if (["response.function_call_arguments.delta", "response.custom_tool_call_input.delta"].includes(eventType)) {
+    state.toolArgumentGuard.observe(event.output_index ?? event.item_id ?? event.call_id, event.delta);
   }
+  if (!RESPONSES_TERMINAL_EVENT_TYPES.has(eventType)) return;
+  const expectedStatus = {
+    "response.completed": "completed",
+    "response.incomplete": "incomplete",
+    "response.failed": "failed",
+  }[eventType];
+  if (expectedStatus && (!event.response?.id || event.response.status !== expectedStatus)) {
+    throw invalidUpstreamStream(
+      `Upstream ${eventType} event contained an invalid response resource`,
+      "upstream_stream_terminal_invalid",
+    );
+  }
+  state.sawTerminal = true;
+  if (eventType === "response.failed" || eventType === "error") markStreamFailure();
+  if (eventType !== "response.completed") return;
+  const response = event.response;
+  state.completed = { response, event };
 }
 
-function readSseEvents(buffer, onData) {
+function readSseEvents(buffer, onEvent) {
   while (true) {
     const match = buffer.match(/\r?\n\r?\n/);
     if (!match) return buffer;
@@ -41,15 +90,31 @@ function readSseEvents(buffer, onData) {
       throw httpError(`Upstream SSE buffer exceeds ${MAX_SSE_BUFFER_BYTES} bytes`, 502);
     }
     buffer = buffer.slice(match.index + match[0].length);
-    const data = chunk
-      .split(/\r?\n/)
+    const lines = chunk.split(/\r?\n/);
+    const eventName = lines
+      .find((line) => line.startsWith("event:"))
+      ?.slice(6)
+      .trim();
+    const data = lines
       .filter((line) => line.startsWith("data:"))
       .map((line) => line.slice(5).trimStart())
       .join("\n");
-    if (data) onData(data);
+    if (data) onEvent(eventName, data);
   }
 }
 
+function storeCompletedResponse(reqContext, completed) {
+  if (!completed) return;
+  rememberResponseHistory(reqContext, completed.response);
+  recordResponsesUsage({
+    surface: reqContext.surface,
+    mode: "stream",
+    model: reqContext.body?.model,
+    response: completed.response,
+    event: completed.event,
+  });
+}
+
 export async function proxyCopilotResponses(reqContext, req, res, upstream = copilotResponses, options = {}) {
   let opened;
   try {
@@ -65,15 +130,22 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
   }
 
   if (reqContext.body.stream) {
+    await requireUpstreamEventStream(resp);
     options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
     res.writeHead(resp.status, {
-      "Content-Type": resp.headers.get("content-type") || "text/event-stream",
+      ...safeUpstreamResponseHeaders(resp.headers, { defaultContentType: "text/event-stream" }),
       "Cache-Control": "no-cache",
       Connection: "keep-alive",
     });
     const reader = resp.body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
+    const streamState = {
+      completed: null,
+      sawTerminal: false,
+      sawOutput: false,
+      toolArgumentGuard: new ToolArgumentDeltaGuard(),
+    };
     try {
       while (true) {
         const { done, value } = await reader.read();
@@ -82,17 +154,24 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
           if (Buffer.byteLength(buffer) > MAX_SSE_BUFFER_BYTES) {
             throw httpError(`Upstream SSE buffer exceeds ${MAX_SSE_BUFFER_BYTES} bytes`, 502);
           }
-          readSseEvents(buffer, (data) => storeCompletedResponseFromSse(reqContext, data));
+          readSseEvents(buffer, (eventName, data) => inspectResponseSseEvent(streamState, eventName, data));
+          if (!streamState.sawTerminal) throw incompleteUpstreamStream("a terminal Responses event");
+          storeCompletedResponse(reqContext, streamState.completed);
           res.end();
           return;
         }
         options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
         buffer += decoder.decode(value, { stream: true });
-        buffer = readSseEvents(buffer, (data) => storeCompletedResponseFromSse(reqContext, data));
+        buffer = readSseEvents(buffer, (eventName, data) => inspectResponseSseEvent(streamState, eventName, data));
         if (Buffer.byteLength(buffer) > MAX_SSE_BUFFER_BYTES) {
           throw httpError(`Upstream SSE buffer exceeds ${MAX_SSE_BUFFER_BYTES} bytes`, 502);
         }
         if (!await writeOrDrain(res, value)) return;
+        if (streamState.sawTerminal) {
+          storeCompletedResponse(reqContext, streamState.completed);
+          res.end();
+          return;
+        }
       }
     } catch (e) {
       logRequestFailure("Responses", e, options.abort);
@@ -103,7 +182,28 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
     }
   } else {
     const data = await resp.text();
-    res.writeHead(resp.status, { "Content-Type": "application/json" });
+    if (resp.ok && reqContext.surface === "responses_compact") {
+      const response = parseResponsesCompactionResult(
+        compactionInputWithoutTrigger(reqContext.body.input),
+        data,
+      );
+      rememberResponseHistory(reqContext, response);
+      recordResponsesUsage({
+        surface: reqContext.surface,
+        mode: "json",
+        model: reqContext.body?.model,
+        response,
+        event: response,
+      });
+      res.writeHead(resp.status, safeUpstreamResponseHeaders(resp.headers, {
+        contentType: "application/json",
+      }));
+      res.end(JSON.stringify(response));
+      return;
+    }
+    res.writeHead(resp.status, safeUpstreamResponseHeaders(resp.headers, {
+      contentType: "application/json",
+    }));
     res.end(data);
     if (resp.ok) {
       try {