codex-copilot-dx 0.6.13 → 0.6.14

package/README.md

@@ -7,7 +7,7 @@ Use [Codex Desktop](https://openai.com/codex), [Claude Code](https://claude.com/
 A single in-process adapter (port `2026`) exposes both APIs over one Copilot
 account by default, or over isolated Codex and Claude accounts when configured:
 
-- **Codex** -> OpenAI Responses API (`/v1/responses`, `/v1/responses/compact`); Responses-only models and compaction proxy directly, chat models convert to Chat Completions.
+- **Codex** -> OpenAI Responses API (`/v1/responses`, `/v1/responses/compact`); Responses-only models and compaction proxy directly, while chat models convert the text, image, and function-tool subset and explicitly reject incompatible top-level items, tools, and tool choices.
 - **Claude Code** -> Anthropic Messages API (`/v1/messages`, `/v1/messages/count_tokens`), translated to/from Chat Completions.
 - **Claude App** -> optional Claude Desktop App gateway profile using the same local Messages API plus local model discovery for the configured gateway key.
 - **PM Studio** -> optional macOS app patch that keeps the active PM profile for GPT models while routing enabled Claude models through an isolated CCDX Claude account.
@@ -301,7 +301,7 @@ To actively verify the protocol path through an already-running adapter, run:
 ccdx doctor --compat
 ```
 
-The compatibility doctor sends a few minimal Copilot requests to check Codex Auto-review, native Responses, streaming history, compaction, image tool namespace handling, and Anthropic streaming. It consumes a small amount of Copilot usage, never starts the adapter or device flow, and does not change client configuration. Combine it with `--online` when both the saved-token entitlement check and the adapter protocol checks are needed.
+The compatibility doctor sends a few minimal Copilot requests to check Codex Auto-review, native Responses, streaming history, compaction, and Anthropic streaming. It consumes a small amount of Copilot usage, never starts the adapter or device flow, and does not change client configuration. Combine it with `--online` when both the saved-token entitlement check and the adapter protocol checks are needed.
 
 For a read-only summary of the running adapter, use:
 
@@ -438,9 +438,9 @@ Before image encoding, CCDX leaves ordinary visual history byte-for-byte unchang
 
 When expanded Responses history exceeds Copilot's 50-image request limit, the adapter removes older duplicate image occurrences first, then keeps the 50 most recent images. This applies only to the forwarded request: local history remains complete, current images are preferred over older history, and requests at or below the limit are unchanged.
 
-For `/v1/responses/compact`, the adapter sends one terminal `compaction_trigger` in unary mode, validates that Copilot returned completed compaction state, and rebuilds a replayable snapshot from recent system, developer, user, and assistant messages plus every compaction item. Only a validated snapshot becomes a new local history root. Later turns continue from it without re-expanding pre-compaction history; existing older response branches remain available until normal history eviction.
+For `/v1/responses/compact`, the adapter sends one terminal `compaction_trigger` in unary mode, validates that Copilot returned completed compaction state, and preserves the complete upstream compacted window as the canonical next context. Only a validated window becomes a new local history root. Later turns continue from it without re-expanding pre-compaction history; existing older response branches remain available until normal history eviction.
 
-Successful streaming responses are accepted only when the upstream body is SSE and reaches its protocol terminal event. Unexpected EOF becomes a protocol-native stream error, and repeated blank tool-argument deltas are stopped per tool call. Inference responses forward safe quota, retry, model, trace, and upstream request-ID metadata; cookies, authorization, body-length, and encoding headers are not forwarded.
+Successful streaming responses are accepted only when the upstream body is SSE and reaches its protocol terminal event; bytes after that terminal are not forwarded. Unexpected EOF becomes a protocol-native stream error, and repeated blank tool-argument deltas are stopped per tool call. Inference responses forward safe quota, retry, model, trace, and upstream request-ID metadata; cookies, authorization, body-length, and encoding headers are not forwarded.
 
 Newer ChatGPT/Codex clients can advertise an `image_gen` namespace that already exists upstream. The adapter removes that exact conflicting client tool before forwarding and retries once only when Copilot explicitly reports an image namespace collision. Image inputs and screenshot optimization remain enabled.
 
@@ -456,4 +456,4 @@ npm run verify
 npm run bench:payload
 ```
 
-`npm test` runs the unit and handler-level suite. `npm run test:smoke` starts a real local HTTP adapter with fully injected offline upstreams. `npm run bench:check` enforces relative token-counting performance and request-admission resource limits. `npm run pack:check` verifies the npm tarball contents without publishing. `npm run bench:payload` remains a report-only, isolated-process benchmark for 5-60 MiB image payloads and does not contact Copilot. The CI workflow runs the verification checks on supported Node.js release lines.
+`npm test` runs the unit and handler-level suite. `npm run test:smoke` starts a real local HTTP adapter with fully injected offline upstreams. `npm run bench:check` enforces relative token-counting performance, linear SSE scanning, and request-admission resource limits. `npm run pack:check` verifies the npm tarball contents without publishing. `npm run bench:payload` remains a report-only, isolated-process benchmark for 5-60 MiB image payloads and does not contact Copilot. The CI workflow runs the verification checks on supported Node.js release lines.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.6.13",
+  "version": "0.6.14",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",

package/scripts/benchmark.mjs

@@ -31,6 +31,65 @@ function median(values) {
     : ordered[middle];
 }
 
+function sseLinearityProbe() {
+  return runProbe(`
+    import { webStreamLines } from "./src/stream.mjs";
+
+    const chunkBytes = 16 * 1024;
+    const maxBufferBytes = 8 * 1024 * 1024;
+    const chunk = new TextEncoder().encode("x".repeat(chunkBytes));
+    const results = [];
+    for (const inputMiB of [1, 2, 4, 8]) {
+      const inputBytes = inputMiB * 1024 * 1024;
+      let remaining = inputBytes;
+      const response = {
+        body: new ReadableStream({
+          pull(controller) {
+            if (remaining === 0) {
+              controller.close();
+              return;
+            }
+            const nextBytes = Math.min(chunk.byteLength, remaining);
+            controller.enqueue(nextBytes === chunk.byteLength ? chunk : chunk.subarray(0, nextBytes));
+            remaining -= nextBytes;
+          },
+        }, { highWaterMark: 0 }),
+      };
+      const originalByteLength = Buffer.byteLength;
+      let byteLengthCalls = 0;
+      let scannedBytes = 0;
+      Buffer.byteLength = function trackedByteLength(value, ...args) {
+        const bytes = originalByteLength(value, ...args);
+        byteLengthCalls += 1;
+        scannedBytes += bytes;
+        return bytes;
+      };
+      let lines = 0;
+      let outputBytes = 0;
+      const started = performance.now();
+      try {
+        for await (const line of webStreamLines(response, { maxBufferBytes })) {
+          lines += 1;
+          outputBytes += originalByteLength(line);
+        }
+      } finally {
+        Buffer.byteLength = originalByteLength;
+      }
+      results.push({
+        input_mib: inputMiB,
+        chunks: Math.ceil(inputBytes / chunkBytes),
+        lines,
+        output_bytes: outputBytes,
+        byte_length_calls: byteLengthCalls,
+        scanned_bytes: scannedBytes,
+        scan_ratio: +(scannedBytes / inputBytes).toFixed(3),
+        elapsed_ms: +(performance.now() - started).toFixed(1),
+      });
+    }
+    process.stdout.write(JSON.stringify({ chunk_kib: chunkBytes / 1024, max_buffer_mib: 8, results }));
+  `);
+}
+
 function deterministicPixels(byteLength, initialSeed) {
   const pixels = Buffer.alloc(byteLength);
   let seed = initialSeed;
@@ -422,6 +481,7 @@ const report = {
 };
 
 if (checkMode) {
+  report.sse_linearity = sseLinearityProbe();
   report.large_token_count = {
     proxy: largeTokenCountProbe("proxy"),
     materialized_array: largeTokenCountProbe("array"),
@@ -466,6 +526,20 @@ if (checkMode) {
   if (report.tool_output_parse_cache.parse_calls !== 1) {
     failures.push(`stringified tool output parsed ${report.tool_output_parse_cache.parse_calls} times instead of once`);
   }
+  const expectedSseSizes = [1, 2, 4, 8];
+  if (report.sse_linearity.results.length !== expectedSseSizes.length
+    || report.sse_linearity.results.some((sample, index) => sample.input_mib !== expectedSseSizes[index])) {
+    failures.push("SSE linearity probe did not cover 1/2/4/8 MiB inputs");
+  }
+  for (const sample of report.sse_linearity.results) {
+    const inputBytes = sample.input_mib * 1024 * 1024;
+    if (sample.lines !== 1 || sample.output_bytes !== inputBytes) {
+      failures.push(`SSE parser changed the ${sample.input_mib}MiB fragmented line`);
+    }
+    if (sample.scanned_bytes > inputBytes * 1.01 || sample.byte_length_calls > sample.chunks + 1) {
+      failures.push(`SSE parser scan complexity is not linear at ${sample.input_mib}MiB`);
+    }
+  }
   for (const payload of report.large_payload_peak) {
     if (payload.admission_max_active_mib > payload.admission_budget_mib) {
       failures.push(`request admission exceeded its budget at ${payload.target_request_mib}MiB x${payload.concurrency}`);

package/src/anthropic.mjs

@@ -130,6 +130,14 @@ export function anthropicToChat(body, options = {}) {
 
 function uid() { return randomUUID().replace(/-/g, ""); }
 
+function invalidToolArguments(toolName) {
+  const name = String(toolName || "unknown").slice(0, 100);
+  return invalidUpstreamStream(
+    `Upstream Chat Completions tool "${name}" did not return valid JSON object arguments`,
+    "upstream_tool_arguments_json_invalid",
+  );
+}
+
 export function chatToAnthropic(openaiResp, model, options = {}) {
   const choice = openaiResp.choices?.[0];
   const msg = choice?.message || {};
@@ -138,8 +146,20 @@ export function chatToAnthropic(openaiResp, model, options = {}) {
   if (msg.content) content.push({ type: "text", text: msg.content });
   if (Array.isArray(msg.tool_calls)) {
     for (const tc of msg.tool_calls) {
-      let input = {};
-      try { input = JSON.parse(tc.function.arguments || "{}"); } catch { input = {}; }
+      const rawArguments = tc.function?.arguments;
+      let input;
+      if (rawArguments === undefined || rawArguments === null || rawArguments === "") {
+        input = {};
+      } else {
+        try {
+          input = JSON.parse(rawArguments);
+        } catch {
+          throw invalidToolArguments(tc.function?.name);
+        }
+        if (!input || typeof input !== "object" || Array.isArray(input)) {
+          throw invalidToolArguments(tc.function?.name);
+        }
+      }
       content.push({ type: "tool_use", id: tc.id, name: tc.function.name, input });
     }
   }

package/src/config.mjs

@@ -9,8 +9,39 @@ const CONFIG_PATH = path.join(os.homedir(), ".codex", "config.toml");
 const MODEL_CONTEXT_WINDOW = 1_000_000;
 const MODEL_AUTO_COMPACT_TOKEN_LIMIT = 900_000;
 
+function isTomlTableHeader(line) {
+  const source = line.trimStart();
+  const openingBrackets = source.startsWith("[[") ? 2 : source.startsWith("[") ? 1 : 0;
+  if (!openingBrackets) return false;
+
+  let quote = "";
+  let escaped = false;
+  for (let index = openingBrackets; index < source.length; index += 1) {
+    const char = source[index];
+    if (quote) {
+      if (quote === '"' && char === "\\" && !escaped) {
+        escaped = true;
+        continue;
+      }
+      if (char === quote && !escaped) quote = "";
+      escaped = false;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char !== "]" || (openingBrackets === 2 && source[index + 1] !== "]")) continue;
+
+    if (!source.slice(openingBrackets, index).trim()) return false;
+    const tail = source.slice(index + openingBrackets).trim();
+    return tail === "" || tail.startsWith("#");
+  }
+  return false;
+}
+
 function setTopLevelTomlDefault(lines, key, value) {
-  let end = lines.findIndex((line) => /^\s*\[[^\]]+\]\s*$/.test(line));
+  let end = lines.findIndex(isTomlTableHeader);
   if (end === -1) end = lines.length;
 
   const keyRe = new RegExp(`^\\s*${key}\\s*=`);
@@ -28,7 +59,7 @@ function setTomlKey(lines, sectionName, key, value) {
 
   let end = lines.length;
   for (let i = start + 1; i < lines.length; i++) {
-    if (/^\s*\[[^\]]+\]\s*$/.test(lines[i])) {
+    if (isTomlTableHeader(lines[i])) {
       end = i;
       break;
     }
@@ -57,7 +88,11 @@ export function computeUpdatedCodexConfig(content, adapterPort = 2026, adapterHo
 
   let changed = false;
   const openaiLine = `openai_base_url = "${baseUrl}"`;
-  const openaiIndex = lines.findIndex((line) => /^openai_base_url\s*=/.test(line));
+  const firstSection = lines.findIndex(isTomlTableHeader);
+  const topLevelEnd = firstSection === -1 ? lines.length : firstSection;
+  const openaiIndex = lines.findIndex((line, index) => (
+    index < topLevelEnd && /^\s*openai_base_url\s*=/.test(line)
+  ));
   if (openaiIndex === -1) {
     lines.unshift(openaiLine);
     changed = true;

package/src/doctor.mjs

@@ -181,13 +181,12 @@ export async function inspectAdapterCompatibility({
   });
 
   if (firstResponse) {
-    await runCompatibilityCheck(checks, "Responses stream, history, and image tool compatibility", async () => {
+    await runCompatibilityCheck(checks, "Responses stream and history compatibility", async () => {
       const text = await compatibilityRequest(fetchImpl, `${baseUrl}/v1/responses`, {
         model: responsesModel,
         stream: true,
         previous_response_id: firstResponse.id,
         input: "Reply with OK again.",
-        tools: [{ type: "image_generation" }],
       }, timeoutMs);
       if (!/^event:\s*response\.completed\s*$/m.test(text)) throw new Error("stream did not contain response.completed");
     });

package/src/responses-bridge.mjs

@@ -38,6 +38,23 @@ export function responsesBodyUsesCustomTools(body) {
     && body.input.some((item) => item?.type === "custom_tool_call" || item?.type === "custom_tool_call_output");
 }
 
+function chatCompatibilityError(kind, itemType) {
+  const type = typeof itemType === "string" && itemType ? itemType : "unknown";
+  const message = `Responses ${kind} type "${type}" cannot be represented by Chat Completions`;
+  const error = new Error(message);
+  error.statusCode = 400;
+  error.code = "ccdx_responses_chat_incompatible";
+  error.jsonBody = {
+    error: {
+      message,
+      type: "invalid_request_error",
+      code: error.code,
+      item_type: type,
+    },
+  };
+  return error;
+}
+
 export function responsesToChat(body) {
   const messages = [];
   if (body.instructions) messages.push({ role: "system", content: body.instructions });
@@ -65,19 +82,36 @@ export function responsesToChat(body) {
   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") {
+    for (let index = 0; index < body.input.length; index += 1) {
+      const item = body.input[index];
+      const isEasyMessage = item?.type === undefined
+        && ["user", "assistant", "system", "developer"].includes(item?.role)
+        && Object.prototype.hasOwnProperty.call(item, "content");
+      if (item?.type === "message" || isEasyMessage) {
         messages.push({ role: item.role, content: messageContent(item.content) });
-      } else if (["input_image", "image_url", "image"].includes(item.type)) {
+      } else if (["input_image", "image_url", "image"].includes(item?.type)) {
         messages.push({ role: "user", content: messageContent([item]) });
-      } else if (item.type === "function_call") {
+      } else if (item?.type === "function_call") {
+        const toolCalls = [];
+        while (index < body.input.length && body.input[index]?.type === "function_call") {
+          const call = body.input[index];
+          toolCalls.push({
+            id: call.call_id || randomUUID(),
+            type: "function",
+            function: { name: call.name, arguments: call.arguments },
+          });
+          index += 1;
+        }
+        index -= 1;
         messages.push({
           role: "assistant",
           content: null,
-          tool_calls: [{ id: item.call_id || randomUUID(), type: "function", function: { name: item.name, arguments: item.arguments } }],
+          tool_calls: toolCalls,
         });
-      } else if (item.type === "function_call_output") {
+      } 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) });
+      } else {
+        throw chatCompatibilityError("input item", item?.type);
       }
     }
   }
@@ -90,9 +124,10 @@ export function responsesToChat(body) {
   if (maxTok !== undefined) chatReq.max_completion_tokens = maxTok;
 
   if (body.tools?.length) {
+    const unsupportedTool = body.tools.find((tool) => tool?.type !== "function");
+    if (unsupportedTool) throw chatCompatibilityError("tool", unsupportedTool?.type);
     chatReq.tools = body.tools
       .map((tool) => {
-        if (tool?.type !== "function") return null;
         if (tool.function?.name) return cloneJson(tool);
         const fn = {
           name: tool.name,
@@ -112,6 +147,8 @@ export function responsesToChat(body) {
       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 } };
+    } else {
+      throw chatCompatibilityError("tool choice", body.tool_choice?.type);
     }
   }
   if (body.parallel_tool_calls !== undefined) chatReq.parallel_tool_calls = body.parallel_tool_calls;

package/src/responses-compaction.mjs

@@ -1,10 +1,6 @@
-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);
@@ -19,47 +15,6 @@ function compactionError(message) {
   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);
@@ -74,7 +29,7 @@ export function compactionInputWithoutTrigger(input) {
     : [];
 }
 
-export function createResponsesCompactionResult(inputItems, generated) {
+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");
   }
@@ -95,10 +50,6 @@ export function createResponsesCompactionResult(inputItems, generated) {
   return {
     ...generated,
     object: "response.compaction",
-    output: [
-      ...retainedMessages(Array.isArray(inputItems) ? inputItems : []),
-      ...compactionItems,
-    ],
   };
 }
 

package/src/responses-proxy.mjs

@@ -81,15 +81,38 @@ function inspectResponseSseEvent(state, eventName, data) {
   state.completed = { response, event };
 }
 
-function readSseEvents(buffer, onEvent) {
-  while (true) {
-    const match = buffer.match(/\r?\n\r?\n/);
-    if (!match) return buffer;
-    const chunk = buffer.slice(0, match.index);
-    if (Buffer.byteLength(chunk) > MAX_SSE_BUFFER_BYTES) {
+function createResponseSseInspector(state) {
+  let eventBuffer = Buffer.allocUnsafe(Math.min(4096, MAX_SSE_BUFFER_BYTES + 4));
+  let eventLength = 0;
+  let previous1 = -1;
+  let previous2 = -1;
+  let previous3 = -1;
+
+  const ensureCapacity = (required) => {
+    if (required > MAX_SSE_BUFFER_BYTES + 4) {
+      throw httpError(`Upstream SSE buffer exceeds ${MAX_SSE_BUFFER_BYTES} bytes`, 502);
+    }
+    if (required <= eventBuffer.length) return;
+    let capacity = eventBuffer.length;
+    while (capacity < required) capacity = Math.min(MAX_SSE_BUFFER_BYTES + 4, Math.max(capacity * 2, required));
+    const next = Buffer.allocUnsafe(capacity);
+    eventBuffer.copy(next, 0, 0, eventLength);
+    eventBuffer = next;
+  };
+
+  const append = (bytes) => {
+    if (!bytes.byteLength) return;
+    ensureCapacity(eventLength + bytes.byteLength);
+    eventBuffer.set(bytes, eventLength);
+    eventLength += bytes.byteLength;
+  };
+
+  const inspectEvent = (delimiterLength) => {
+    const contentLength = eventLength - delimiterLength;
+    if (contentLength > MAX_SSE_BUFFER_BYTES) {
       throw httpError(`Upstream SSE buffer exceeds ${MAX_SSE_BUFFER_BYTES} bytes`, 502);
     }
-    buffer = buffer.slice(match.index + match[0].length);
+    const chunk = eventBuffer.subarray(0, contentLength).toString("utf8");
     const lines = chunk.split(/\r?\n/);
     const eventName = lines
       .find((line) => line.startsWith("event:"))
@@ -99,8 +122,73 @@ function readSseEvents(buffer, onEvent) {
       .filter((line) => line.startsWith("data:"))
       .map((line) => line.slice(5).trimStart())
       .join("\n");
-    if (data) onEvent(eventName, data);
+    if (data) inspectResponseSseEvent(state, eventName, data);
+    eventLength = 0;
+    previous1 = -1;
+    previous2 = -1;
+    previous3 = -1;
+  };
+
+  return {
+    push(value) {
+      let segmentStart = 0;
+      for (let index = 0; index < value.byteLength; index += 1) {
+        const byte = value[index];
+        let delimiterLength = 0;
+        if (byte === 0x0a && previous1 === 0x0a) {
+          delimiterLength = previous2 === 0x0d ? 3 : 2;
+        } else if (byte === 0x0a && previous1 === 0x0d && previous2 === 0x0a) {
+          delimiterLength = previous3 === 0x0d ? 4 : 3;
+        }
+        if (delimiterLength) {
+          append(value.subarray(segmentStart, index + 1));
+          inspectEvent(delimiterLength);
+          segmentStart = index + 1;
+          if (state.sawTerminal) return index + 1;
+          continue;
+        }
+        previous3 = previous2;
+        previous2 = previous1;
+        previous1 = byte;
+      }
+      append(value.subarray(segmentStart));
+      if (eventLength > MAX_SSE_BUFFER_BYTES + 3) {
+        throw httpError(`Upstream SSE buffer exceeds ${MAX_SSE_BUFFER_BYTES} bytes`, 502);
+      }
+      return null;
+    },
+  };
+}
+
+function invalidResponsesResponse(message) {
+  const error = httpError(message, 502);
+  error.code = "ccdx_invalid_responses_response";
+  error.jsonBody = {
+    error: {
+      message,
+      type: "upstream_error",
+      code: error.code,
+    },
+  };
+  return error;
+}
+
+function parseSuccessfulResponsesResult(text) {
+  let response;
+  try {
+    response = JSON.parse(text);
+  } catch {
+    throw invalidResponsesResponse("Copilot Responses returned invalid JSON");
+  }
+  if (!response
+    || typeof response !== "object"
+    || Array.isArray(response)
+    || typeof response.id !== "string"
+    || response.id.length === 0
+    || !Array.isArray(response.output)) {
+    throw invalidResponsesResponse("Copilot Responses returned an invalid response envelope");
   }
+  return response;
 }
 
 function storeCompletedResponse(reqContext, completed) {
@@ -138,35 +226,26 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
       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(),
     };
+    const inspector = createResponseSseInspector(streamState);
     try {
       while (true) {
         const { done, value } = await reader.read();
         if (done) {
-          buffer += decoder.decode();
-          if (Buffer.byteLength(buffer) > MAX_SSE_BUFFER_BYTES) {
-            throw httpError(`Upstream SSE buffer exceeds ${MAX_SSE_BUFFER_BYTES} bytes`, 502);
-          }
-          readSseEvents(buffer, (eventName, data) => inspectResponseSseEvent(streamState, eventName, data));
           if (!streamState.sawTerminal) throw incompleteUpstreamStream("a terminal Responses event");
           storeCompletedResponse(reqContext, streamState.completed);
           res.end();
           return { successful: Boolean(streamState.completed), compacted: false };
         }
         options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
-        buffer += decoder.decode(value, { stream: true });
-        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;
+        const terminalOffset = inspector.push(value);
+        const forwarded = terminalOffset === null ? value : value.subarray(0, terminalOffset);
+        if (forwarded.byteLength > 0 && !await writeOrDrain(res, forwarded)) return;
         if (streamState.sawTerminal) {
           storeCompletedResponse(reqContext, streamState.completed);
           res.end();
@@ -202,24 +281,26 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
       res.end(JSON.stringify(response));
       return { successful: true, compacted: true };
     }
+    if (resp.ok) {
+      const response = parseSuccessfulResponsesResult(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(data);
+      return { successful: true, compacted: false };
+    }
     res.writeHead(resp.status, safeUpstreamResponseHeaders(resp.headers, {
       contentType: "application/json",
     }));
     res.end(data);
-    if (resp.ok) {
-      try {
-        const response = JSON.parse(data);
-        rememberResponseHistory(reqContext, response);
-        recordResponsesUsage({
-          surface: reqContext.surface,
-          mode: "json",
-          model: reqContext.body?.model,
-          response,
-          event: response,
-        });
-        return { successful: true, compacted: false };
-      } catch {}
-    }
     return { successful: false, compacted: false };
   }
 }

package/src/responses-request.mjs

@@ -46,7 +46,7 @@ export function stripInternalResponsesInputFields(inputItems, { assertActive } =
 
 function responsesOutputItems(output) {
   if (!Array.isArray(output)) return [];
-  return output.filter((item) => ["message", "function_call", "custom_tool_call"].includes(item?.type));
+  return output.filter((item) => item && typeof item === "object");
 }
 
 function isCompactedResponsesOutput(output) {
@@ -62,8 +62,7 @@ function isSuccessfulCompactionResponse(response) {
 }
 
 function replayableResponsesOutputItems(output) {
-  if (!Array.isArray(output)) return [];
-  return output.filter((item) => item && typeof item === "object");
+  return responsesOutputItems(output);
 }
 
 function isEncryptedContentPart(value) {

package/src/stream.mjs

@@ -4,33 +4,47 @@ import { loadRuntimeConfig } from "./runtime-config.mjs";
 
 const MAX_SSE_BUFFER_BYTES = loadRuntimeConfig().maxSseBufferBytes;
 
-function assertSseBufferLimit(buffer, maxBufferBytes) {
-  if (Buffer.byteLength(buffer) > maxBufferBytes) {
+function appendLineFragment(parts, fragment, currentBytes, maxBufferBytes) {
+  if (!fragment) return currentBytes;
+  const nextBytes = currentBytes + Buffer.byteLength(fragment);
+  if (nextBytes > maxBufferBytes) {
     throw new Error(`Upstream SSE buffer exceeds ${maxBufferBytes} bytes`);
   }
+  parts.push(fragment);
+  return nextBytes;
 }
 
 export async function* webStreamLines(response, { onChunk, maxBufferBytes = MAX_SSE_BUFFER_BYTES } = {}) {
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
-  let buf = "";
+  let lineParts = [];
+  let lineBytes = 0;
   try {
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
       onChunk?.(value);
-      buf += decoder.decode(value, { stream: true });
-      const lines = buf.split("\n");
-      buf = lines.pop();
-      assertSseBufferLimit(buf, maxBufferBytes);
-      for (const line of lines) {
-        assertSseBufferLimit(line, maxBufferBytes);
-        yield line.replace(/\r$/, "");
+      const decoded = decoder.decode(value, { stream: true });
+      let start = 0;
+      while (start < decoded.length) {
+        const newline = decoded.indexOf("\n", start);
+        if (newline === -1) {
+          lineBytes = appendLineFragment(lineParts, decoded.slice(start), lineBytes, maxBufferBytes);
+          break;
+        }
+        lineBytes = appendLineFragment(lineParts, decoded.slice(start, newline), lineBytes, maxBufferBytes);
+        const line = lineParts.length > 1 ? lineParts.join("") : (lineParts[0] || "");
+        yield line.endsWith("\r") ? line.slice(0, -1) : line;
+        lineParts = [];
+        lineBytes = 0;
+        start = newline + 1;
       }
     }
-    buf += decoder.decode();
-    assertSseBufferLimit(buf, maxBufferBytes);
-    if (buf.length > 0) yield buf.replace(/\r$/, "");
+    lineBytes = appendLineFragment(lineParts, decoder.decode(), lineBytes, maxBufferBytes);
+    if (lineParts.length > 0) {
+      const line = lineParts.length > 1 ? lineParts.join("") : lineParts[0];
+      yield line.endsWith("\r") ? line.slice(0, -1) : line;
+    }
   } finally {
     await reader.cancel().catch(() => {});
     reader.releaseLock();