codex-copilot-dx 0.4.23 → 0.4.26

package/src/adapter.mjs

@@ -1,7 +1,5 @@
 import http from "node:http";
 import { randomUUID } from "node:crypto";
-import { promisify } from "node:util";
-import * as zlib from "node:zlib";
 import { chatCompletions, listModels, responses as copilotResponses, responsesCompact as copilotResponsesCompact, getCachedModelEndpoints } from "./copilot.mjs";
 import { webStreamLines } from "./stream.mjs";
 import { anthropicToChat, chatToAnthropic, streamAnthropicFromLines, countTokens } from "./anthropic.mjs";
@@ -9,6 +7,37 @@ import { claudeDesktopModelsResponse, resolveAnthropicModel, modelIsResponsesOnl
 import { status } from "./status.mjs";
 import { recordAnthropicUsage, recordResponsesUsage } from "./usage.mjs";
 import { ADAPTER_HEALTH_PATH, adapterHealthPayload } from "./running-adapter.mjs";
+import {
+  abortErrorStatusCode,
+  createRequestAbort,
+  httpError,
+  isAbortLikeError,
+  logRequestFailure,
+  readJsonBody,
+  sendJsonError,
+  sendUpstreamError,
+  writeOrDrain,
+} from "./http-transport.mjs";
+import {
+  clearResponseHistoryForTests,
+  configureResponseHistoryForTests,
+  materializeResponseHistory,
+  rememberResponseHistoryNode,
+  responseHistoryStats,
+} from "./response-history.mjs";
+
+export {
+  abortErrorStatusCode,
+  createRequestAbort,
+  isAbortLikeError,
+  readJsonBody,
+  writeOrDrain,
+} from "./http-transport.mjs";
+export {
+  clearResponseHistoryForTests,
+  configureResponseHistoryForTests,
+  responseHistoryStats,
+} from "./response-history.mjs";
 
 // Fallback list for models known to only support the Responses API, used when
 // live model metadata (supported_endpoints) has not been cached yet.
@@ -37,118 +66,25 @@ function isResponsesOnlyModel(model) {
 
 // Direct Copilot Responses API proxy.
 
-const RESPONSE_HISTORY_LIMIT = 64;
-const responseHistories = new Map();
-const DEFAULT_MAX_BODY_BYTES = 128 * 1024 * 1024;
-const DEFAULT_MAX_DECODED_BODY_BYTES = 256 * 1024 * 1024;
 const DEFAULT_UPSTREAM_TIMEOUT_MS = 120 * 1000;
-const gunzipAsync = promisify(zlib.gunzip);
-const inflateAsync = promisify(zlib.inflate);
-const brotliDecompressAsync = promisify(zlib.brotliDecompress);
-const zstdDecompressAsync = zlib.zstdDecompress ? promisify(zlib.zstdDecompress) : null;
+const DEFAULT_STREAM_HANDSHAKE_TIMEOUT_MS = 120 * 1000;
+const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 120 * 1000;
 
 function positiveInt(value, fallback) {
   const n = Number.parseInt(value, 10);
   return Number.isFinite(n) && n > 0 ? n : fallback;
 }
 
-const MAX_BODY_BYTES = positiveInt(process.env.CCDX_MAX_BODY_BYTES, DEFAULT_MAX_BODY_BYTES);
-const MAX_DECODED_BODY_BYTES = positiveInt(process.env.CCDX_MAX_DECODED_BODY_BYTES, DEFAULT_MAX_DECODED_BODY_BYTES);
 const UPSTREAM_TIMEOUT_MS = positiveInt(process.env.CCDX_UPSTREAM_TIMEOUT_MS, DEFAULT_UPSTREAM_TIMEOUT_MS);
+const STREAM_HANDSHAKE_TIMEOUT_MS = positiveInt(process.env.CCDX_STREAM_HANDSHAKE_TIMEOUT_MS, DEFAULT_STREAM_HANDSHAKE_TIMEOUT_MS);
+const STREAM_IDLE_TIMEOUT_MS = positiveInt(process.env.CCDX_STREAM_IDLE_TIMEOUT_MS, DEFAULT_STREAM_IDLE_TIMEOUT_MS);
 
 export function requestPath(reqUrl) {
   return new URL(reqUrl || "/", "http://localhost").pathname;
 }
 
 function cloneJson(value) {
-  return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
-}
-
-function httpError(message, statusCode) {
-  const err = new Error(message);
-  err.statusCode = statusCode;
-  return err;
-}
-
-function payloadTooLarge(kind, maxBytes) {
-  return httpError(`${kind} request body exceeds ${maxBytes} bytes`, 413);
-}
-
-async function readRequestBuffer(req, maxBytes) {
-  const contentLength = Number.parseInt(req.headers?.["content-length"] || "", 10);
-  if (Number.isFinite(contentLength) && contentLength > maxBytes) {
-    throw payloadTooLarge("Raw", maxBytes);
-  }
-
-  const chunks = [];
-  let total = 0;
-  for await (const chunk of req) {
-    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-    total += buf.length;
-    if (total > maxBytes) throw payloadTooLarge("Raw", maxBytes);
-    chunks.push(buf);
-  }
-  return Buffer.concat(chunks);
-}
-
-async function decompressBody(decompress, buffer, maxBytes) {
-  try {
-    return await decompress(buffer, { maxOutputLength: maxBytes });
-  } catch (e) {
-    if (e?.code === "ERR_BUFFER_TOO_LARGE" || /maxOutputLength/i.test(e?.message || "")) {
-      throw payloadTooLarge("Decoded", maxBytes);
-    }
-    throw e;
-  }
-}
-
-async function decodeRequestBuffer(buffer, contentEncoding, maxBytes) {
-  const encodings = String(contentEncoding || "identity")
-    .split(",")
-    .map((v) => v.trim().toLowerCase())
-    .filter(Boolean);
-
-  let decoded = buffer;
-  for (const encoding of encodings.reverse()) {
-    if (encoding === "identity") continue;
-    if (encoding === "gzip" || encoding === "x-gzip") {
-      decoded = await decompressBody(gunzipAsync, decoded, maxBytes);
-    } else if (encoding === "deflate") {
-      decoded = await decompressBody(inflateAsync, decoded, maxBytes);
-    } else if (encoding === "br") {
-      decoded = await decompressBody(brotliDecompressAsync, decoded, maxBytes);
-    } else if (encoding === "zstd") {
-      if (!zstdDecompressAsync) throw new Error("Unsupported Content-Encoding: zstd");
-      decoded = await decompressBody(zstdDecompressAsync, decoded, maxBytes);
-    } else {
-      throw new Error(`Unsupported Content-Encoding: ${encoding}`);
-    }
-    if (decoded.length > maxBytes) throw payloadTooLarge("Decoded", maxBytes);
-  }
-  if (decoded.length > maxBytes) throw payloadTooLarge("Decoded", maxBytes);
-  return decoded;
-}
-
-export async function readJsonBody(req, {
-  maxBodyBytes = MAX_BODY_BYTES,
-  maxDecodedBodyBytes = MAX_DECODED_BODY_BYTES,
-} = {}) {
-  const buffer = await readRequestBuffer(req, maxBodyBytes);
-  const decoded = await decodeRequestBuffer(buffer, req.headers?.["content-encoding"], maxDecodedBodyBytes);
-  return JSON.parse(decoded.toString("utf8"));
-}
-
-function sendJsonError(res, err, fallbackStatus = 400) {
-  if (res.destroyed || res.writableEnded) return;
-  if (!res.headersSent) res.writeHead(err?.statusCode || fallbackStatus, { "Content-Type": "application/json" });
-  res.end(JSON.stringify({ error: err?.message || "Request failed" }));
-}
-
-function sendUpstreamError(res, resp, text) {
-  if (!res.headersSent) {
-    res.writeHead(resp.status || 502, { "Content-Type": resp.headers?.get("content-type") || "application/json" });
-  }
-  res.end(text || JSON.stringify({ error: "Upstream request failed" }));
+  return value === undefined ? undefined : structuredClone(value);
 }
 
 function bearerToken(headers = {}) {
@@ -164,85 +100,13 @@ export function shouldServeClaudeDesktopModels(req, claudeDesktopApiKey) {
   return token === claudeDesktopApiKey || xApiKey === claudeDesktopApiKey;
 }
 
-export function writeOrDrain(res, chunk) {
-  if (res.destroyed || res.writableEnded) return Promise.resolve(false);
-  if (res.write(chunk)) return Promise.resolve(true);
-  return new Promise((resolve, reject) => {
-    const cleanup = () => {
-      res.off("drain", onDrain);
-      res.off("error", onError);
-      res.off("close", onClose);
-    };
-    const onDrain = () => { cleanup(); resolve(true); };
-    const onClose = () => { cleanup(); resolve(false); };
-    const onError = (err) => { cleanup(); reject(err); };
-    res.once("drain", onDrain);
-    res.once("close", onClose);
-    res.once("error", onError);
-  });
-}
-
-export function isAbortLikeError(err) {
-  return err?.name === "AbortError" || /operation was aborted/i.test(String(err?.message || ""));
-}
-
-export function abortErrorStatusCode(reason) {
-  if (reason === "upstream_timeout") return 504;
-  if (reason === "client_aborted" || reason === "client_closed") return 499;
-  return 400;
-}
-
-export function createRequestAbort(req, res) {
-  const controller = new AbortController();
-  let timer = null;
-  let cleaned = false;
-  let reason = null;
-  const abort = (nextReason = "aborted") => {
-    if (!cleaned && !controller.signal.aborted) {
-      reason = nextReason;
-      controller.abort();
-    }
-  };
-  const onReqAborted = () => abort("client_aborted");
-  const onResClose = () => {
-    if (!res.writableEnded) abort("client_closed");
-  };
-  req.on("aborted", onReqAborted);
-  res.on("close", onResClose);
-  return {
-    signal: controller.signal,
-    get reason() { return reason; },
-    setTimeout(ms) {
-      if (timer) clearTimeout(timer);
-      if (ms > 0) timer = setTimeout(() => abort("upstream_timeout"), ms);
-    },
-    cleanup() {
-      cleaned = true;
-      if (timer) clearTimeout(timer);
-      req.off("aborted", onReqAborted);
-      res.off("close", onResClose);
-    },
-  };
-}
-
-function logRequestFailure(label, err, abort) {
-  if (!isAbortLikeError(err)) {
-    console.error(status("err", `${label} request failed: ${err.message}`));
-    return;
-  }
-
-  const reason = abort?.reason || "aborted";
-  err.statusCode ||= abortErrorStatusCode(reason);
-  const detail = reason === "upstream_timeout" ? `${reason} after ${UPSTREAM_TIMEOUT_MS}ms` : reason;
-  console.warn(status("warn", `${label} request aborted: ${detail}`));
-}
-
-function responsesInputItems(input) {
+function responsesInputItems(input, { clone = true } = {}) {
   if (input === undefined || input === null) return [];
   if (typeof input === "string") {
     return [{ type: "message", role: "user", content: [{ type: "input_text", text: input }] }];
   }
-  return Array.isArray(input) ? cloneJson(input) : [cloneJson(input)];
+  if (Array.isArray(input)) return clone ? cloneJson(input) : input;
+  return [clone ? cloneJson(input) : input];
 }
 
 export function stripInternalResponsesInputFields(inputItems) {
@@ -258,7 +122,7 @@ export function stripInternalResponsesInputFields(inputItems) {
 
 function responsesOutputItems(output) {
   if (!Array.isArray(output)) return [];
-  return cloneJson(output.filter((item) => item?.type === "message" || item?.type === "function_call"));
+  return output.filter((item) => item?.type === "message" || item?.type === "function_call");
 }
 
 function stripEncryptedReasoningValue(value, state) {
@@ -303,10 +167,16 @@ export function sanitizeEncryptedReasoningRequest(reqContext) {
     body = stripEncryptedReasoningValue(body, state);
   }
   if (!state.changed) return null;
+  const historyInputItems = Array.isArray(reqContext.historyInputItems)
+    ? reqContext.historyInputItems
+      .filter((item) => !isEncryptedReasoningInputItem(item))
+      .map((item) => stripEncryptedReasoningValue(item, { changed: false }))
+    : reqContext.historyInputItems;
   return {
     ...reqContext,
     body,
     inputItems: Array.isArray(body.input) ? body.input : reqContext.inputItems,
+    historyInputItems,
   };
 }
 
@@ -318,54 +188,82 @@ export function isEncryptedContentVerificationError(statusCode, text) {
     && (lower.includes("could not be decrypted") || lower.includes("could not be parsed"));
 }
 
-export async function openCopilotResponse(reqContext, upstream = copilotResponses, options = {}) {
-  let resp = await upstream(reqContext.body, { signal: options.signal });
-  if (resp.ok) return { resp, reqContext };
-
-  const errorText = await resp.text();
-  if (!isEncryptedContentVerificationError(resp.status, errorText)) {
-    return { resp, reqContext, errorText };
-  }
+export function isImageNamespaceCollisionError(statusCode, text) {
+  if (statusCode < 400 || !text) return false;
+  const lower = String(text).toLowerCase();
+  return lower.includes("namespace")
+    && lower.includes("image_gen")
+    && lower.includes("collid");
+}
 
-  const retryContext = sanitizeEncryptedReasoningRequest(reqContext);
-  if (!retryContext) return { resp, reqContext, errorText };
+function isImageNamespaceTool(tool, { collisionFallback = false } = {}) {
+  if (!tool || typeof tool !== "object") return false;
+  const type = String(tool.type || "").toLowerCase();
+  const name = String(tool.name || tool.function?.name || "").toLowerCase();
+  const namespace = String(tool.namespace || "").toLowerCase();
+  if (["image_gen", "image_generation"].includes(type)) return true;
+  if (["image_gen", "image_generation"].includes(name)) return true;
+  if (namespace === "image_gen" || namespace === "image_generation") return true;
+  return collisionFallback && [type, name, namespace].some((value) => value.startsWith("image_gen"));
+}
 
-  console.warn(status("warn", "encrypted reasoning rejected by upstream; retrying without encrypted reasoning"));
-  resp = await upstream(retryContext.body, { signal: options.signal });
-  if (resp.ok) return { resp, reqContext: retryContext };
-  return { resp, reqContext: retryContext, errorText: await resp.text() };
+export function sanitizeImageNamespaceCollisionRequest(reqContext) {
+  if (!Array.isArray(reqContext?.body?.tools)) return null;
+  const body = cloneJson(reqContext.body);
+  const filtered = body.tools.filter((tool) => !isImageNamespaceTool(tool, { collisionFallback: true }));
+  if (filtered.length === body.tools.length) return null;
+  if (filtered.length) body.tools = filtered;
+  else delete body.tools;
+  return { ...reqContext, body };
 }
 
-export function clearResponseHistoryForTests() {
-  responseHistories.clear();
+export async function openCopilotResponse(reqContext, upstream = copilotResponses, options = {}) {
+  let encryptedRetried = false;
+  let imageNamespaceRetried = false;
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const resp = await upstream(reqContext.body, { signal: options.signal });
+    if (resp.ok) return { resp, reqContext };
+
+    const errorText = await resp.text();
+    if (!imageNamespaceRetried && isImageNamespaceCollisionError(resp.status, errorText)) {
+      const retryContext = sanitizeImageNamespaceCollisionRequest(reqContext);
+      if (retryContext) {
+        imageNamespaceRetried = true;
+        reqContext = retryContext;
+        console.warn(status("warn", "image_gen namespace rejected by upstream; retrying without the conflicting image tool"));
+        continue;
+      }
+    }
+    if (!encryptedRetried && isEncryptedContentVerificationError(resp.status, errorText)) {
+      const retryContext = sanitizeEncryptedReasoningRequest(reqContext);
+      if (retryContext) {
+        encryptedRetried = true;
+        reqContext = retryContext;
+        console.warn(status("warn", "encrypted reasoning rejected by upstream; retrying without encrypted reasoning"));
+        continue;
+      }
+    }
+    return { resp, reqContext, errorText };
+  }
+  throw httpError("Responses compatibility retry limit exceeded", 502);
 }
 
 // The GPT (gpt-5.6) Responses backend registers a built-in `image_gen` tool
 // namespace. When the client also sends an image generation tool, the upstream
 // rejects the request with "User-defined namespace 'image_gen' collides ...".
-// Strip any built-in image tool (matched by type/name/namespace) before proxying.
+// Strip exact built-in image tools before proxying. Broader namespace variants
+// are removed only after the upstream explicitly reports a collision.
 function isBuiltinImageTool(tool) {
-  if (!tool || typeof tool !== "object") return false;
-  const candidates = [tool.type, tool.name, tool.namespace];
-  return candidates.some((v) => {
-    const s = String(v || "").toLowerCase();
-    return s === "image_gen" || s === "image_generation" || s.startsWith("image_gen");
-  });
+  return isImageNamespaceTool(tool);
 }
 
-export function prepareResponsesRequest(reqBody) {
-  const body = cloneJson(reqBody);
-  const currentInputItems = responsesInputItems(body.input);
+export function prepareResponsesRequest(reqBody, { mutate = false } = {}) {
+  const body = mutate ? reqBody : cloneJson(reqBody);
+  const currentInputItems = responsesInputItems(body.input, { clone: !mutate });
   const previousId = body.previous_response_id;
 
   if (previousId !== undefined && previousId !== null) {
-    const previousItems = responseHistories.get(previousId);
-    if (!previousItems) {
-      const err = new Error(`previous_response_id is not available in local adapter history: ${previousId}`);
-      err.statusCode = 400;
-      throw err;
-    }
-    body.input = [...cloneJson(previousItems), ...currentInputItems];
+    body.input = [...materializeResponseHistory(previousId), ...currentInputItems];
   } else {
     body.input = currentInputItems;
   }
@@ -377,17 +275,28 @@ export function prepareResponsesRequest(reqBody) {
     if (!body.tools.length) delete body.tools;
   }
   stripInternalResponsesInputFields(body.input);
+  stripInternalResponsesInputFields(currentInputItems);
 
-  return { body, inputItems: body.input };
+  return {
+    body,
+    inputItems: body.input,
+    historyParentId: previousId ?? null,
+    historyInputItems: currentInputItems,
+    takeHistoryOwnership: mutate,
+  };
 }
 
 export function rememberResponseHistory(reqContext, responseJson) {
-  if (!responseJson?.id || !Array.isArray(reqContext?.inputItems)) return;
-  const items = [...cloneJson(reqContext.inputItems), ...responsesOutputItems(responseJson.output)];
-  responseHistories.set(responseJson.id, items);
-  while (responseHistories.size > RESPONSE_HISTORY_LIMIT) {
-    responseHistories.delete(responseHistories.keys().next().value);
-  }
+  if (!responseJson?.id || !Array.isArray(reqContext?.historyInputItems || reqContext?.inputItems)) return;
+  const sourceInputItems = reqContext.historyInputItems || reqContext.inputItems;
+  const sourceOutputItems = responsesOutputItems(responseJson.output);
+  rememberResponseHistoryNode({
+    id: responseJson.id,
+    parentId: reqContext.historyParentId,
+    inputItems: sourceInputItems,
+    outputItems: sourceOutputItems,
+    takeOwnership: reqContext.takeHistoryOwnership,
+  });
 }
 
 function storeCompletedResponseFromSse(reqContext, data) {
@@ -435,6 +344,7 @@ async function proxyCopilotResponses(reqContext, req, res, upstream = copilotRes
   }
 
   if (reqContext.body.stream) {
+    options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
     res.writeHead(resp.status, {
       "Content-Type": resp.headers.get("content-type") || "text/event-stream",
       "Cache-Control": "no-cache",
@@ -443,17 +353,23 @@ async function proxyCopilotResponses(reqContext, req, res, upstream = copilotRes
     const reader = resp.body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        buffer += decoder.decode();
-        readSseEvents(buffer, (data) => storeCompletedResponseFromSse(reqContext, data));
-        res.end();
-        return;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          buffer += decoder.decode();
+          readSseEvents(buffer, (data) => storeCompletedResponseFromSse(reqContext, data));
+          res.end();
+          return;
+        }
+        options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
+        buffer += decoder.decode(value, { stream: true });
+        buffer = readSseEvents(buffer, (data) => storeCompletedResponseFromSse(reqContext, data));
+        if (!await writeOrDrain(res, value)) return;
       }
-      buffer += decoder.decode(value, { stream: true });
-      buffer = readSseEvents(buffer, (data) => storeCompletedResponseFromSse(reqContext, data));
-      await writeOrDrain(res, value);
+    } finally {
+      await reader.cancel().catch(() => {});
+      reader.releaseLock();
     }
   } else {
     const data = await resp.text();
@@ -477,22 +393,39 @@ async function proxyCopilotResponses(reqContext, req, res, upstream = copilotRes
 
 // Chat Completions conversion for older models.
 
-function responsesToChat(body) {
+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") {
-        const content =
-          typeof item.content === "string"
-            ? item.content
-            : Array.isArray(item.content)
-              ? item.content.map((p) => (p.type === "input_text" || p.type === "text" ? p.text : JSON.stringify(p))).join("")
-              : JSON.stringify(item.content);
-        messages.push({ role: item.role, content });
+        messages.push({ role: item.role, content: messageContent(item.content) });
       } else if (item.type === "function_call") {
         messages.push({
           role: "assistant",
@@ -514,10 +447,44 @@ function responsesToChat(body) {
 
   if (body.tools?.length) {
     chatReq.tools = body.tools
-      .map((t) => (t.type === "function" ? t : { type: "function", function: t }))
+      .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;
 }
 
@@ -530,55 +497,160 @@ function chatToResponses(chatResp, model) {
   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 };
 }
 
-async function forwardToChat(chatReq, emitEvent, onDone, onError, options = {}) {
+export async function forwardToChat(chatReq, emitEvent, onDone, onError, options = {}) {
   delete chatReq.max_tokens;
   let resp;
   try {
-    resp = await chatCompletions({ ...chatReq, stream: true }, { signal: options.signal });
+    const chatCompletionsFn = options.chatCompletionsFn || chatCompletions;
+    resp = await chatCompletionsFn({
+      ...chatReq,
+      stream: true,
+    }, { signal: options.signal });
   } catch (e) {
-    onError(502, e.message);
+    const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(options.abort?.reason) : 502;
+    onError(statusCode, e.message);
     return;
   }
   if (!resp.ok) {
     onError(resp.status, await resp.text());
     return;
   }
-  const respId = `resp_${uid()}`, itemId = `item_${uid()}`;
-  let actualModel = "unknown", fullText = "", toolCalls = {}, hasToolCalls = false;
+  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: [] } });
-  await emitEvent("response.output_item.added", { output_index: 0, item: { type: "message", id: itemId, role: "assistant", status: "in_progress", content: [] } });
-  await emitEvent("response.content_part.added", { output_index: 0, content_index: 0, part: { type: "output_text", text: "" } });
+
+  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 (!hasToolCalls) {
-      await emitEvent("response.output_text.done", { output_index: 0, content_index: 0, text: fullText });
-      await emitEvent("response.output_item.done", { output_index: 0, item: { type: "message", id: itemId, role: "assistant", status: "completed", content: [{ type: "output_text", text: fullText }] } });
+    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;
     }
-    const output = hasToolCalls
-      ? Object.entries(toolCalls).map(([id, tc]) => ({ type: "function_call", id, call_id: id, name: tc.name, arguments: tc.arguments, status: "completed" }))
-      : [{ type: "message", id: itemId, role: "assistant", status: "completed", content: [{ type: "output_text", text: fullText }] }];
-    await emitEvent("response.completed", { response: { id: respId, object: "response", status: "completed", model: actualModel, output, usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 } } });
+    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)) {
+    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) { fullText += delta.content; await emitEvent("response.output_text.delta", { output_index: 0, content_index: 0, delta: delta.content }); }
+      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) {
-        hasToolCalls = true;
         for (const tc of delta.tool_calls) {
-          const id = tc.id || Object.keys(toolCalls)[tc.index] || `call_${tc.index}`;
-          if (!toolCalls[id]) { toolCalls[id] = { name: "", arguments: "" }; await emitEvent("response.output_item.added", { output_index: Object.keys(toolCalls).length - 1, item: { type: "function_call", id, call_id: id, name: tc.function?.name || "", arguments: "", status: "in_progress" } }); }
-          if (tc.function?.name) toolCalls[id].name += tc.function.name;
-          if (tc.function?.arguments) toolCalls[id].arguments += tc.function.arguments;
+          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,
+            });
+          }
         }
       }
     }
@@ -590,18 +662,26 @@ async function forwardToChat(chatReq, emitEvent, onDone, onError, options = {})
   onDone();
 }
 
-// Public server entry point.
-
-export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
+// Shared request handler. Keeping this separate from the listener makes the
+// complete HTTP routing layer testable without opening a local port.
+export function createAdapterHandler(options = {}) {
   const claudeDesktopApiKey = options.claudeDesktopApiKey
     || process.env.CCDX_CLAUDE_DESKTOP_API_KEY
     || process.env.CCDX_PROXY_API_KEY
     || "";
-  const claudeDesktopModelOptions = Array.isArray(options.claudeDesktopModelDefs)
-    ? { modelDefs: options.claudeDesktopModelDefs }
-    : {};
+  const chatCompletionsFn = options.chatCompletionsFn || chatCompletions;
+  const responsesFn = options.responsesFn || copilotResponses;
+  const responsesCompactFn = options.responsesCompactFn || copilotResponsesCompact;
+  const listModelsFn = options.listModelsFn || listModels;
+  const upstreamTimeoutMs = positiveInt(options.upstreamTimeoutMs, UPSTREAM_TIMEOUT_MS);
+  const streamHandshakeTimeoutMs = positiveInt(options.streamHandshakeTimeoutMs, STREAM_HANDSHAKE_TIMEOUT_MS);
+  const streamIdleTimeoutMs = positiveInt(options.streamIdleTimeoutMs, STREAM_IDLE_TIMEOUT_MS);
+  const claudeDesktopModelOptions = () => {
+    const modelDefs = options.modelRegistry?.modelDefs || options.claudeDesktopModelDefs;
+    return Array.isArray(modelDefs) ? { modelDefs } : {};
+  };
 
-  const server = http.createServer((req, res) => {
+  return (req, res) => {
     const pathname = requestPath(req.url);
 
     if (req.method === "GET" && pathname === ADAPTER_HEALTH_PATH) {
@@ -611,17 +691,24 @@ export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
     }
 
     if (req.method === "POST" && pathname === "/v1/responses") {
-      (async () => {
+      return (async () => {
         const abort = createRequestAbort(req, res);
         try {
           const parsed = await readJsonBody(req);
-          if (!parsed.stream) abort.setTimeout(UPSTREAM_TIMEOUT_MS);
-          const prepared = prepareResponsesRequest(parsed);
+          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";
           console.log(status("info", `responses model=${model} stream=${!!parsed.stream}`));
           if (isResponsesOnlyModel(model)) {
-            await proxyCopilotResponses(prepared, req, res, copilotResponses, { signal: abort.signal });
+            await proxyCopilotResponses(prepared, req, res, responsesFn, {
+              signal: abort.signal,
+              abort,
+              streamIdleTimeoutMs,
+            });
           } else {
             const chatReq = responsesToChat(prepared.body);
             if (parsed.stream) {
@@ -632,13 +719,22 @@ export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
                   rememberResponseHistory(prepared, data.response);
                   recordResponsesUsage({ surface: prepared.surface, mode: "stream", model, response: data.response, event: data });
                 }
-              }, () => { if (!res.writableEnded) res.end(); }, (status, errMsg) => { if (!res.headersSent) res.writeHead(status || 500); res.end(errMsg); }, { signal: abort.signal });
+              }, () => { if (!res.writableEnded) res.end(); }, (status, errMsg) => { if (!res.headersSent) res.writeHead(status || 500); res.end(errMsg); }, {
+                signal: abort.signal,
+                abort,
+                streamIdleTimeoutMs,
+                chatCompletionsFn,
+              });
             } else {
               chatReq.stream = false;
               delete chatReq.max_tokens;
               try {
-                const upstream = await chatCompletions({ ...chatReq, stream: false }, { signal: abort.signal });
+                const upstream = await chatCompletionsFn({ ...chatReq, stream: false }, { signal: abort.signal });
                 const data = await upstream.text();
+                if (!upstream.ok) {
+                  sendUpstreamError(res, upstream, data);
+                  return;
+                }
                 const resp = chatToResponses(JSON.parse(data), model);
                 rememberResponseHistory(prepared, resp);
                 recordResponsesUsage({ surface: prepared.surface, mode: "json", model, response: resp, event: resp });
@@ -660,7 +756,6 @@ export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
           abort.cleanup();
         }
       })();
-      return;
     }
 
     if (req.method === "POST" && pathname === "/v1/responses/compact") {
@@ -668,12 +763,19 @@ export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
         const abort = createRequestAbort(req, res);
         try {
           const parsed = await readJsonBody(req);
-          if (!parsed.stream) abort.setTimeout(UPSTREAM_TIMEOUT_MS);
-          const prepared = prepareResponsesRequest(parsed);
+          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";
           console.log(status("info", `responses compact model=${model} stream=${!!parsed.stream}`));
-          await proxyCopilotResponses(prepared, req, res, copilotResponsesCompact, { signal: abort.signal });
+          await proxyCopilotResponses(prepared, req, res, responsesCompactFn, {
+            signal: abort.signal,
+            abort,
+            streamIdleTimeoutMs,
+          });
         } catch (e) {
           logRequestFailure("Responses compact", e, abort);
           sendJsonError(res, e);
@@ -687,12 +789,12 @@ export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
     if (req.method === "GET" && pathname === "/v1/models") {
       if (shouldServeClaudeDesktopModels(req, claudeDesktopApiKey)) {
         res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify(claudeDesktopModelsResponse(process.env, claudeDesktopModelOptions)));
+        res.end(JSON.stringify(claudeDesktopModelsResponse(process.env, claudeDesktopModelOptions())));
         return;
       }
       const abort = createRequestAbort(req, res);
-      abort.setTimeout(UPSTREAM_TIMEOUT_MS);
-      listModels({ signal: abort.signal })
+      abort.setTimeout(upstreamTimeoutMs);
+      listModelsFn({ signal: abort.signal })
         .then(({ status, body }) => { res.writeHead(status, { "Content-Type": "application/json" }); res.end(body); })
         .catch((e) => {
           logRequestFailure("Models", e, abort);
@@ -726,24 +828,30 @@ export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
         const abort = createRequestAbort(req, res);
         try {
           const parsed = await readJsonBody(req);
-          if (!parsed.stream) abort.setTimeout(UPSTREAM_TIMEOUT_MS);
-          const { requestedModel, upstreamModel } = resolveAnthropicModel(parsed.model || "unknown", process.env, claudeDesktopModelOptions);
+          abort.setTimeout(
+            parsed.stream ? streamHandshakeTimeoutMs : upstreamTimeoutMs,
+            parsed.stream ? "stream_handshake_timeout" : "upstream_timeout",
+          );
+          const { requestedModel, upstreamModel } = resolveAnthropicModel(parsed.model || "unknown", process.env, claudeDesktopModelOptions());
           const modelNote = upstreamModel === requestedModel ? requestedModel : `${requestedModel} -> ${upstreamModel}`;
           console.log(status("info", `messages model=${modelNote} stream=${!!parsed.stream}`));
           const chatReq = anthropicToChat(parsed, { upstreamModel });
           const forceRequestedModel = upstreamModel !== requestedModel;
           if (parsed.stream) {
-            const upstream = await chatCompletions({ ...chatReq, stream: true }, { signal: abort.signal });
+            const upstream = await chatCompletionsFn({ ...chatReq, stream: true }, { signal: abort.signal });
             if (!upstream.ok) {
               if (!res.headersSent) res.writeHead(upstream.status);
               res.end(await upstream.text());
               return;
             }
+            abort.setTimeout(streamIdleTimeoutMs, "stream_idle_timeout");
             res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
             let messageId;
             let usage;
             await streamAnthropicFromLines(
-              webStreamLines(upstream),
+              webStreamLines(upstream, {
+                onChunk: () => abort.setTimeout(streamIdleTimeoutMs, "stream_idle_timeout"),
+              }),
               async (event, data) => {
                 if (event === "message_start") messageId = data.message?.id;
                 if (event === "message_delta") usage = data.usage;
@@ -755,8 +863,12 @@ export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
             recordAnthropicUsage({ surface: "messages", mode: "stream", model: requestedModel, responseId: messageId, usage });
             if (!res.writableEnded) res.end();
           } else {
-            const upstream = await chatCompletions({ ...chatReq, stream: false }, { signal: abort.signal });
+            const upstream = await chatCompletionsFn({ ...chatReq, stream: false }, { signal: abort.signal });
             const data = await upstream.text();
+            if (!upstream.ok) {
+              sendUpstreamError(res, upstream, data);
+              return;
+            }
             const anthropicMsg = chatToAnthropic(JSON.parse(data), requestedModel, { forceModel: forceRequestedModel });
             recordAnthropicUsage({ surface: "messages", mode: "json", model: anthropicMsg.model, responseId: anthropicMsg.id, usage: anthropicMsg.usage });
             res.writeHead(200, { "Content-Type": "application/json" });
@@ -774,7 +886,13 @@ export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
 
     res.writeHead(404, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ error: "Not found" }));
-  });
+  };
+}
+
+// Public server entry point.
+
+export function startAdapter(port = 2026, host = "127.0.0.1", options = {}) {
+  const server = http.createServer(createAdapterHandler(options));
 
   server.on("upgrade", (req, socket) => {
     // Codex Desktop 0.130+ negotiates a "responses_websockets" server-push