codex-copilot-dx 0.4.35 → 0.4.37

package/src/observability.mjs

@@ -0,0 +1,147 @@
+import { isIP } from "node:net";
+import { adapterHealthPayload } from "./running-adapter.mjs";
+import { copilotRuntimeStatus } from "./copilot.mjs";
+import { imageOptimizationStats } from "./image-optimization.mjs";
+import { responseHistoryStats } from "./response-history.mjs";
+import { loadRuntimeConfig } from "./runtime-config.mjs";
+
+export const ADAPTER_STATUS_PATH = "/_ccdx/status";
+const OBSERVABILITY_RUNTIME_CONFIG = loadRuntimeConfig();
+
+const ROUTE_NAMES = Object.freeze([
+  "responses",
+  "responses_compact",
+  "models",
+  "messages",
+  "messages_count_tokens",
+  "not_found",
+]);
+
+function emptyCounter() {
+  return {
+    total: 0,
+    active: 0,
+    completed: 0,
+    errors: 0,
+    aborted: 0,
+    duration_ms_total: 0,
+    duration_ms_max: 0,
+    status_2xx: 0,
+    status_3xx: 0,
+    status_4xx: 0,
+    status_5xx: 0,
+  };
+}
+
+function statusBucket(statusCode) {
+  if (statusCode >= 200 && statusCode < 300) return "status_2xx";
+  if (statusCode >= 300 && statusCode < 400) return "status_3xx";
+  if (statusCode >= 400 && statusCode < 500) return "status_4xx";
+  if (statusCode >= 500) return "status_5xx";
+  return null;
+}
+
+function counterSnapshot(counter) {
+  return {
+    ...counter,
+    duration_ms_avg: counter.completed > 0
+      ? Number((counter.duration_ms_total / counter.completed).toFixed(1))
+      : 0,
+  };
+}
+
+export function createRequestMetrics({ now = Date.now } = {}) {
+  const total = emptyCounter();
+  const routes = Object.fromEntries(ROUTE_NAMES.map((name) => [name, emptyCounter()]));
+
+  const begin = (routeName) => {
+    const route = routes[routeName] || routes.not_found;
+    const startedAt = now();
+    total.total += 1;
+    total.active += 1;
+    route.total += 1;
+    route.active += 1;
+    let completed = false;
+
+    return ({ statusCode = 0, aborted = false } = {}) => {
+      if (completed) return;
+      completed = true;
+      const durationMs = Math.max(0, now() - startedAt);
+      for (const counter of [total, route]) {
+        counter.active = Math.max(0, counter.active - 1);
+        counter.completed += 1;
+        counter.duration_ms_total += durationMs;
+        counter.duration_ms_max = Math.max(counter.duration_ms_max, durationMs);
+        if (aborted) counter.aborted += 1;
+        if (statusCode >= 400) counter.errors += 1;
+        const bucket = statusBucket(statusCode);
+        if (bucket) counter[bucket] += 1;
+      }
+    };
+  };
+
+  return {
+    begin,
+    snapshot() {
+      return {
+        ...counterSnapshot(total),
+        by_route: Object.fromEntries(ROUTE_NAMES.map((name) => [name, counterSnapshot(routes[name])])),
+      };
+    },
+  };
+}
+
+export function classifyAdapterRoute(method, pathname) {
+  if (method === "POST" && pathname === "/v1/responses") return "responses";
+  if (method === "POST" && pathname === "/v1/responses/compact") return "responses_compact";
+  if (method === "GET" && pathname === "/v1/models") return "models";
+  if (method === "POST" && pathname === "/v1/messages") return "messages";
+  if (method === "POST" && pathname === "/v1/messages/count_tokens") return "messages_count_tokens";
+  return "not_found";
+}
+
+export function isLoopbackAddress(address) {
+  const normalized = String(address || "").trim().toLowerCase();
+  if (normalized === "::1" || normalized === "[::1]") return true;
+  const ipv4 = normalized.startsWith("::ffff:") ? normalized.slice(7) : normalized;
+  return isIP(ipv4) === 4 && ipv4.startsWith("127.");
+}
+
+function modelRegistryStatus(modelRegistry) {
+  const modelData = Array.isArray(modelRegistry?.models)
+    ? modelRegistry.models
+    : modelRegistry?.models?.data;
+  return {
+    source: String(modelRegistry?.source || "built-in"),
+    models: Array.isArray(modelData) ? modelData.length : 0,
+    claude_models: Array.isArray(modelRegistry?.modelDefs) ? modelRegistry.modelDefs.length : 0,
+  };
+}
+
+export function runtimeStatusPayload({ metrics, admission, modelRegistry } = {}) {
+  const memory = process.memoryUsage();
+  return {
+    ...adapterHealthPayload(),
+    uptime_ms: Math.round(process.uptime() * 1000),
+    process: {
+      rss_bytes: memory.rss,
+      heap_used_bytes: memory.heapUsed,
+      heap_total_bytes: memory.heapTotal,
+      external_bytes: memory.external,
+      array_buffers_bytes: memory.arrayBuffers,
+    },
+    requests: metrics?.snapshot?.() || createRequestMetrics().snapshot(),
+    admission: admission?.diagnostics?.() || admission?.stats?.() || null,
+    response_history: responseHistoryStats(),
+    image_optimization: imageOptimizationStats(),
+    copilot: copilotRuntimeStatus(),
+    models: modelRegistryStatus(modelRegistry),
+    limits: {
+      max_body_bytes: OBSERVABILITY_RUNTIME_CONFIG.maxBodyBytes,
+      max_decoded_body_bytes: OBSERVABILITY_RUNTIME_CONFIG.maxDecodedBodyBytes,
+      max_sse_buffer_bytes: OBSERVABILITY_RUNTIME_CONFIG.maxSseBufferBytes,
+      response_history_max_bytes: OBSERVABILITY_RUNTIME_CONFIG.responseHistoryMaxBytes,
+      response_history_max_entries: OBSERVABILITY_RUNTIME_CONFIG.responseHistoryMaxEntries,
+    },
+  };
+}

package/src/request-context.mjs

@@ -0,0 +1,16 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+
+const requestContextStorage = new AsyncLocalStorage();
+
+export function createRequestId() {
+  return randomUUID();
+}
+
+export function runWithRequestContext(context, callback) {
+  return requestContextStorage.run(context, callback);
+}
+
+export function currentRequestContext() {
+  return requestContextStorage.getStore() || null;
+}

package/src/response-history.mjs

@@ -1,12 +1,8 @@
 import { httpError } from "./http-transport.mjs";
+import { loadRuntimeConfig, parsePositiveInteger, RUNTIME_DEFAULTS } from "./runtime-config.mjs";
 
-const DEFAULT_MAX_BYTES = 64 * 1024 * 1024;
-const DEFAULT_MAX_ENTRIES = 4096;
-
-function positiveInt(value, fallback) {
-  const n = Number.parseInt(value, 10);
-  return Number.isFinite(n) && n > 0 ? n : fallback;
-}
+const DEFAULT_MAX_BYTES = RUNTIME_DEFAULTS.responseHistoryMaxBytes;
+const DEFAULT_MAX_ENTRIES = RUNTIME_DEFAULTS.responseHistoryMaxEntries;
 
 function cloneJson(value) {
   return value === undefined ? undefined : structuredClone(value);
@@ -76,8 +72,9 @@ const childrenById = new Map();
 const treeLru = new Map();
 const evictedIds = new Set();
 let totalBytes = 0;
-let maxBytes = positiveInt(process.env.CCDX_RESPONSE_HISTORY_MAX_BYTES, DEFAULT_MAX_BYTES);
-let maxEntries = positiveInt(process.env.CCDX_RESPONSE_HISTORY_MAX_ENTRIES, DEFAULT_MAX_ENTRIES);
+const HISTORY_RUNTIME_CONFIG = loadRuntimeConfig();
+let maxBytes = HISTORY_RUNTIME_CONFIG.responseHistoryMaxBytes;
+let maxEntries = HISTORY_RUNTIME_CONFIG.responseHistoryMaxEntries;
 
 function rememberEvictedId(id) {
   evictedIds.add(id);
@@ -169,8 +166,8 @@ export function clearResponseHistoryForTests() {
 }
 
 export function configureResponseHistoryForTests({ maxBytes: nextMaxBytes, maxEntries: nextMaxEntries } = {}) {
-  if (nextMaxBytes !== undefined) maxBytes = positiveInt(nextMaxBytes, DEFAULT_MAX_BYTES);
-  if (nextMaxEntries !== undefined) maxEntries = positiveInt(nextMaxEntries, DEFAULT_MAX_ENTRIES);
+  if (nextMaxBytes !== undefined) maxBytes = parsePositiveInteger(nextMaxBytes, DEFAULT_MAX_BYTES);
+  if (nextMaxEntries !== undefined) maxEntries = parsePositiveInteger(nextMaxEntries, DEFAULT_MAX_ENTRIES);
 }
 
 export function responseHistoryStats() {

package/src/responses-bridge.mjs

@@ -0,0 +1,282 @@
+import { randomUUID } from "node:crypto";
+import { chatCompletions } from "./copilot.mjs";
+import { webStreamLines } from "./stream.mjs";
+import { abortErrorStatusCode, isAbortLikeError } from "./http-transport.mjs";
+
+function cloneJson(value) {
+  return value === undefined ? undefined : structuredClone(value);
+}
+
+export function responsesToChat(body) {
+  const messages = [];
+  if (body.instructions) messages.push({ role: "system", content: body.instructions });
+
+  const messageContent = (content) => {
+    if (typeof content === "string") return content;
+    if (!Array.isArray(content)) return JSON.stringify(content);
+    const parts = [];
+    for (const part of content) {
+      if (!part || typeof part !== "object") continue;
+      if (["input_text", "output_text", "text"].includes(part.type)) {
+        parts.push({ type: "text", text: String(part.text || "") });
+      } else if (part.type === "input_image" || part.type === "image_url") {
+        const raw = part.image_url ?? part.url;
+        const imageUrl = typeof raw === "string"
+          ? { url: raw }
+          : raw && typeof raw === "object" ? cloneJson(raw) : null;
+        if (imageUrl && part.detail !== undefined && imageUrl.detail === undefined) imageUrl.detail = part.detail;
+        if (imageUrl?.url) parts.push({ type: "image_url", image_url: imageUrl });
+      } else {
+        parts.push({ type: "text", text: JSON.stringify(part) });
+      }
+    }
+    if (parts.length === 1 && parts[0].type === "text") return parts[0].text;
+    return parts;
+  };
+
+  if (typeof body.input === "string") {
+    messages.push({ role: "user", content: body.input });
+  } else if (Array.isArray(body.input)) {
+    for (const item of body.input) {
+      if (item.type === "message") {
+        messages.push({ role: item.role, content: messageContent(item.content) });
+      } else if (item.type === "function_call") {
+        messages.push({
+          role: "assistant",
+          content: null,
+          tool_calls: [{ id: item.call_id || randomUUID(), type: "function", function: { name: item.name, arguments: item.arguments } }],
+        });
+      } else if (item.type === "function_call_output") {
+        messages.push({ role: "tool", tool_call_id: item.call_id, content: typeof item.output === "string" ? item.output : JSON.stringify(item.output) });
+      }
+    }
+  }
+
+  const chatReq = { model: body.model, messages, stream: true };
+  for (const k of ["temperature", "top_p", "stop", "presence_penalty", "frequency_penalty"]) {
+    if (body[k] !== undefined) chatReq[k] = body[k];
+  }
+  const maxTok = body.max_output_tokens ?? body.max_tokens ?? body.max_completion_tokens;
+  if (maxTok !== undefined) chatReq.max_completion_tokens = maxTok;
+
+  if (body.tools?.length) {
+    chatReq.tools = body.tools
+      .map((tool) => {
+        if (tool?.type !== "function") return null;
+        if (tool.function?.name) return cloneJson(tool);
+        const fn = {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters,
+          strict: tool.strict,
+        };
+        for (const key of Object.keys(fn)) if (fn[key] === undefined) delete fn[key];
+        return { type: "function", function: fn };
+      })
+      .filter(Boolean)
+      .filter((t) => t.function?.name);
+    if (!chatReq.tools.length) delete chatReq.tools;
+  }
+  if (body.tool_choice !== undefined) {
+    if (typeof body.tool_choice === "string") {
+      chatReq.tool_choice = body.tool_choice;
+    } else if (body.tool_choice?.type === "function" && body.tool_choice.name) {
+      chatReq.tool_choice = { type: "function", function: { name: body.tool_choice.name } };
+    }
+  }
+  if (body.parallel_tool_calls !== undefined) chatReq.parallel_tool_calls = body.parallel_tool_calls;
+  const textFormat = body.text?.format;
+  if (textFormat?.type === "json_schema") {
+    chatReq.response_format = {
+      type: "json_schema",
+      json_schema: Object.fromEntries(Object.entries({
+        name: textFormat.name,
+        description: textFormat.description,
+        schema: textFormat.schema,
+        strict: textFormat.strict,
+      }).filter(([, value]) => value !== undefined)),
+    };
+  } else if (textFormat?.type === "json_object") {
+    chatReq.response_format = { type: "json_object" };
+  }
+  return chatReq;
+}
+
+function uid() { return randomUUID().replace(/-/g, ""); }
+
+export function chatToResponses(chatResp, model) {
+  const id = `resp_${uid()}`, choice = chatResp.choices?.[0], msg = choice?.message, output = [];
+  if (msg?.content) output.push({ type: "message", id: `msg_${uid()}`, role: "assistant", status: "completed", content: [{ type: "output_text", text: msg.content }] });
+  if (msg?.tool_calls) for (const tc of msg.tool_calls) output.push({ type: "function_call", id: tc.id, call_id: tc.id, name: tc.function.name, arguments: tc.function.arguments, status: "completed" });
+  return { id, object: "response", status: "completed", model: chatResp.model || model, output, usage: chatResp.usage ? { input_tokens: chatResp.usage.prompt_tokens || 0, output_tokens: chatResp.usage.completion_tokens || 0, total_tokens: chatResp.usage.total_tokens || 0 } : undefined };
+}
+
+export async function forwardToChat(chatReq, emitEvent, onDone, onError, options = {}) {
+  delete chatReq.max_tokens;
+  let resp;
+  try {
+    const chatCompletionsFn = options.chatCompletionsFn || chatCompletions;
+    try {
+      resp = await chatCompletionsFn({
+        ...chatReq,
+        stream: true,
+      }, { signal: options.signal });
+    } finally {
+      options.releaseRequest?.();
+    }
+  } catch (e) {
+    const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(options.abort?.reason) : 502;
+    await onError(statusCode, e.message);
+    return;
+  }
+  if (!resp.ok) {
+    await onError(resp.status, await resp.text());
+    return;
+  }
+  options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
+  const respId = `resp_${uid()}`;
+  let actualModel = chatReq.model || "unknown";
+  let fullText = "";
+  let messageItem = null;
+  let nextOutputIndex = 0;
+  let usage = { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
+  const toolCalls = new Map();
+
+  await emitEvent("response.created", { response: { id: respId, object: "response", status: "in_progress", model: actualModel, output: [] } });
+
+  const ensureMessageItem = async () => {
+    if (messageItem) return messageItem;
+    messageItem = { id: `msg_${uid()}`, outputIndex: nextOutputIndex++ };
+    await emitEvent("response.output_item.added", {
+      output_index: messageItem.outputIndex,
+      item: { type: "message", id: messageItem.id, role: "assistant", status: "in_progress", content: [] },
+    });
+    await emitEvent("response.content_part.added", {
+      output_index: messageItem.outputIndex,
+      content_index: 0,
+      part: { type: "output_text", text: "" },
+    });
+    return messageItem;
+  };
+
+  const ensureToolCall = async (chunk) => {
+    const key = Number.isInteger(chunk.index) ? `index:${chunk.index}` : `id:${chunk.id || toolCalls.size}`;
+    if (toolCalls.has(key)) return { tool: toolCalls.get(key), created: false };
+    const id = chunk.id || `call_${uid()}`;
+    const tool = {
+      id,
+      callId: id,
+      name: chunk.function?.name || "",
+      arguments: "",
+      outputIndex: nextOutputIndex++,
+    };
+    toolCalls.set(key, tool);
+    await emitEvent("response.output_item.added", {
+      output_index: tool.outputIndex,
+      item: {
+        type: "function_call",
+        id: tool.id,
+        call_id: tool.callId,
+        name: tool.name,
+        arguments: "",
+        status: "in_progress",
+      },
+    });
+    return { tool, created: true };
+  };
+
+  const emitCompleted = async () => {
+    if (!messageItem && toolCalls.size === 0) await ensureMessageItem();
+    const output = [];
+    if (messageItem) {
+      const item = {
+        type: "message",
+        id: messageItem.id,
+        role: "assistant",
+        status: "completed",
+        content: [{ type: "output_text", text: fullText }],
+      };
+      await emitEvent("response.output_text.done", { output_index: messageItem.outputIndex, content_index: 0, text: fullText });
+      await emitEvent("response.content_part.done", { output_index: messageItem.outputIndex, content_index: 0, part: item.content[0] });
+      await emitEvent("response.output_item.done", { output_index: messageItem.outputIndex, item });
+      output[messageItem.outputIndex] = item;
+    }
+    for (const tool of toolCalls.values()) {
+      const item = {
+        type: "function_call",
+        id: tool.id,
+        call_id: tool.callId,
+        name: tool.name,
+        arguments: tool.arguments,
+        status: "completed",
+      };
+      await emitEvent("response.function_call_arguments.done", {
+        output_index: tool.outputIndex,
+        item_id: tool.id,
+        arguments: tool.arguments,
+      });
+      await emitEvent("response.output_item.done", { output_index: tool.outputIndex, item });
+      output[tool.outputIndex] = item;
+    }
+    await emitEvent("response.completed", {
+      response: {
+        id: respId,
+        object: "response",
+        status: "completed",
+        model: actualModel,
+        output: output.filter(Boolean),
+        usage,
+      },
+    });
+  };
+
+  try {
+    for await (const line of webStreamLines(resp, {
+      onChunk: () => options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout"),
+    })) {
+      if (!line.startsWith("data: ")) continue;
+      const data = line.slice(6).trim();
+      if (data === "[DONE]") { await emitCompleted(); onDone(); return; }
+      let parsed;
+      try { parsed = JSON.parse(data); } catch { continue; }
+      if (parsed.model) actualModel = parsed.model;
+      if (parsed.usage) {
+        usage = {
+          input_tokens: parsed.usage.prompt_tokens || 0,
+          output_tokens: parsed.usage.completion_tokens || 0,
+          total_tokens: parsed.usage.total_tokens || 0,
+        };
+        const cached = parsed.usage.prompt_tokens_details?.cached_tokens;
+        if (cached) usage.input_tokens_details = { cached_tokens: cached };
+      }
+      const delta = parsed.choices?.[0]?.delta;
+      if (!delta) continue;
+      if (delta.content) {
+        const message = await ensureMessageItem();
+        fullText += delta.content;
+        await emitEvent("response.output_text.delta", { output_index: message.outputIndex, content_index: 0, delta: delta.content });
+      }
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          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;
+            await emitEvent("response.function_call_arguments.delta", {
+              output_index: tool.outputIndex,
+              item_id: tool.id,
+              delta: tc.function.arguments,
+            });
+          }
+        }
+      }
+    }
+  } catch (e) {
+    const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(options.abort?.reason) : 502;
+    await onError(statusCode, e?.message || "upstream stream error");
+    return;
+  }
+  await emitCompleted();
+  onDone();
+}

package/src/responses-handler.mjs

@@ -0,0 +1,176 @@
+import { getCachedModelEndpoints } from "./copilot.mjs";
+import {
+  createRequestAbort,
+  logRequestFailure,
+  readJsonBody,
+  sendJsonError,
+  sendUpstreamError,
+  writeOrDrain,
+} from "./http-transport.mjs";
+import {
+  CODEX_AUTO_REVIEW_MODEL,
+  modelIsResponsesOnly,
+  modelSupportsChatCompletions,
+  resolveOpenAIModel,
+} from "./models.mjs";
+import { chatToResponses, forwardToChat, responsesToChat } from "./responses-bridge.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 { recordResponsesUsage } from "./usage.mjs";
+
+const RESPONSES_ONLY_FALLBACK = new Set([
+  "gpt-5.6-luna",
+  "gpt-5.6-sol",
+  "gpt-5.6-terra",
+  "gpt-5.5",
+  "gpt-5.4",
+  "gpt-5.4-mini",
+  "gpt-5.3-codex",
+  "gpt-5.2-codex",
+]);
+
+function isResponsesOnlyModel(model) {
+  const endpoints = getCachedModelEndpoints(model);
+  if (endpoints) {
+    const fakeModel = { supported_endpoints: endpoints };
+    if (modelSupportsChatCompletions(fakeModel)) return false;
+    if (modelIsResponsesOnly(fakeModel)) return true;
+  }
+  return RESPONSES_ONLY_FALLBACK.has(model);
+}
+
+export function createResponsesHandler(options) {
+  const {
+    acquireRequest,
+    chatCompletionsFn,
+    openAIModelEnv,
+    responsesFn,
+    streamHandshakeTimeoutMs,
+    streamIdleTimeoutMs,
+    upstreamTimeoutMs,
+  } = options;
+
+  return async function handleResponses(req, res) {
+    const abort = createRequestAbort(req, res);
+    let releaseRequest = () => {};
+    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",
+      );
+      const prepared = prepareResponsesRequest(parsed, { mutate: true });
+      prepared.surface = "responses";
+      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 model=${requestedModel}${upstreamLog} stream=${!!parsed.stream}`));
+      if (requestedModel === CODEX_AUTO_REVIEW_MODEL || isResponsesOnlyModel(upstreamModel)) {
+        await proxyCopilotResponses(prepared, req, res, responsesFn, {
+          signal: abort.signal,
+          abort,
+          releaseRequest,
+          streamIdleTimeoutMs,
+        });
+      } else {
+        const chatReq = responsesToChat(prepared.body);
+        if (parsed.stream) {
+          await forwardToChat(chatReq, async (event, data) => {
+            if (!res.headersSent) res.writeHead(200, { "Content-Type": "text/event-stream", "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.headersSent) {
+              res.writeHead(statusCode || 500, { "Content-Type": "text/plain; charset=utf-8" });
+              res.end(errMsg);
+              return;
+            }
+            await endStreamWithError(res, "responses", new Error(errMsg), abort);
+          }, {
+            signal: abort.signal,
+            abort,
+            streamIdleTimeoutMs,
+            chatCompletionsFn,
+            releaseRequest,
+          });
+        } else {
+          chatReq.stream = false;
+          delete chatReq.max_tokens;
+          try {
+            const upstream = await chatCompletionsFn({ ...chatReq, stream: false }, { signal: abort.signal });
+            releaseRequest();
+            const data = await upstream.text();
+            if (!upstream.ok) {
+              sendUpstreamError(res, upstream, data);
+              return;
+            }
+            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.end(JSON.stringify(response));
+          } catch (error) {
+            logRequestFailure("Responses", error, abort);
+            sendJsonError(res, error, 502);
+          }
+        }
+      }
+    } catch (error) {
+      logRequestFailure("Responses", error, abort);
+      sendJsonError(res, error, 502);
+    } finally {
+      releaseRequest();
+      abort.cleanup();
+    }
+  };
+}
+
+export function createResponsesCompactHandler(options) {
+  const {
+    acquireRequest,
+    openAIModelEnv,
+    responsesCompactFn,
+    streamHandshakeTimeoutMs,
+    streamIdleTimeoutMs,
+    upstreamTimeoutMs,
+  } = options;
+
+  return async function handleResponsesCompact(req, res) {
+    const abort = createRequestAbort(req, res);
+    let releaseRequest = () => {};
+    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",
+      );
+      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}`));
+      await proxyCopilotResponses(prepared, req, res, responsesCompactFn, {
+        signal: abort.signal,
+        abort,
+        releaseRequest,
+        streamIdleTimeoutMs,
+      });
+    } catch (error) {
+      logRequestFailure("Responses compact", error, abort);
+      sendJsonError(res, error, 502);
+    } finally {
+      releaseRequest();
+      abort.cleanup();
+    }
+  };
+}