codex-copilot-dx 0.7.2 → 0.7.3

package/README.md

@@ -283,6 +283,8 @@ For `/v1/responses/compact`, CCDX sends one terminal `compaction_trigger`, valid
 
 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. Safe quota, retry, model, trace, and upstream request-ID metadata are forwarded; cookies, authorization, body-length, and encoding headers are not.
 
+CCDX 0.7.3 keeps each native Responses message on its first upstream ID when Copilot changes that ID during streaming. Message deltas, completion events, and cached history stay consistent, preventing duplicate live messages in Codex App. Tool identities, reasoning/encrypted content, message phases, and speed-tier routing are unchanged. Stable events retain their original SSE bytes; changed events are rewritten with bounded, backpressured streaming.
+
 Newer Codex App builds can advertise an `image_gen` namespace that already exists upstream. CCDX removes that exact conflicting client tool before forwarding and retries once only when Copilot explicitly reports an image namespace collision. Image input and screenshot optimization remain enabled.
 
 ## Development
@@ -295,6 +297,8 @@ npm run bench:payload
 
 `npm test` runs unit and handler-level tests. `npm run test:smoke` starts a real local adapter with fully injected offline upstreams. `npm run bench:check` enforces linear SSE scanning, image/tool processing, and request-admission resource limits. `npm run pack:check` verifies npm tarball contents without publishing. `npm run bench:payload` is a report-only isolated-process benchmark for 5–60 MiB image payloads and does not contact Copilot. CI runs verification on the supported Node.js release lines.
 
+From a source checkout, `node scripts/codex-message-id-replay.mjs --codex /absolute/path/to/codex` checks message identity against an installed Codex runtime using only synthetic SSE, a local mock server, and automatically cleaned temporary Codex directories. It does not use the real client configuration or call Copilot.
+
 ## License
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "description": "Use Codex App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",

package/src/responses-proxy.mjs

@@ -32,12 +32,56 @@ import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
 import { recordResponsesUsage } from "./usage.mjs";
 
 const MAX_SSE_BUFFER_BYTES = loadRuntimeConfig().maxSseBufferBytes;
+const SSE_WRITE_BATCH_BYTES = 64 * 1024;
 const RESPONSES_TERMINAL_EVENT_TYPES = new Set([
   "response.completed",
   "response.incomplete",
   "response.failed",
   "error",
 ]);
+const MESSAGE_CONTENT_EVENT_TYPES = new Set([
+  "response.content_part.added",
+  "response.content_part.done",
+  "response.output_text.delta",
+  "response.output_text.done",
+  "response.output_text.annotation.added",
+  "response.refusal.delta",
+  "response.refusal.done",
+]);
+
+function normalizeMessageIds(state, event, eventType) {
+  let changed = false;
+  const replaceId = (object, field, id) => {
+    if (id && typeof object?.[field] === "string" && object[field] !== id) {
+      object[field] = id;
+      changed = true;
+    }
+  };
+  const index = event.output_index;
+  if (Number.isSafeInteger(index) && index >= 0) {
+    // Bind only confirmed message items, using the full output index (including tools).
+    // IDs are opaque: retain the first upstream ID without decoding or synthesizing one.
+    if (eventType === "response.output_item.added" && event.item?.type === "message"
+      && typeof event.item.id === "string" && event.item.id.length > 0
+      && !state.messageIds.has(index)) {
+      state.messageIds.set(index, event.item.id);
+    }
+    const id = state.messageIds.get(index);
+    if (["response.output_item.added", "response.output_item.done"].includes(eventType)
+      && event.item?.type === "message") {
+      replaceId(event.item, "id", id);
+    } else if (MESSAGE_CONTENT_EVENT_TYPES.has(eventType)) {
+      replaceId(event, "item_id", id);
+    }
+  }
+  if (RESPONSES_TERMINAL_EVENT_TYPES.has(eventType) && Array.isArray(event.response?.output)) {
+    for (let index = 0; index < event.response.output.length; index += 1) {
+      const item = event.response.output[index];
+      if (item?.type === "message") replaceId(item, "id", state.messageIds.get(index));
+    }
+  }
+  return changed;
+}
 
 function inspectResponseSseEvent(state, eventName, data) {
   if (!data || state.sawTerminal) return;
@@ -57,6 +101,7 @@ function inspectResponseSseEvent(state, eventName, data) {
     );
   }
   const eventType = event.type || eventName;
+  const changed = normalizeMessageIds(state, event, eventType);
   const outputTokens = event.response?.usage?.output_tokens ?? event.usage?.output_tokens;
   if (outputTokens !== undefined) markOutputTokens(outputTokens);
   if (!state.sawOutput && isResponsesOutputEvent(event, eventType)) {
@@ -66,7 +111,7 @@ function inspectResponseSseEvent(state, eventName, data) {
   if (["response.function_call_arguments.delta", "response.custom_tool_call_input.delta"].includes(eventType)) {
     state.toolArgumentGuard.observe(event.output_index ?? event.item_id ?? event.call_id, event.delta);
   }
-  if (!RESPONSES_TERMINAL_EVENT_TYPES.has(eventType)) return;
+  if (!RESPONSES_TERMINAL_EVENT_TYPES.has(eventType)) return changed ? event : null;
   const expectedStatus = {
     "response.completed": "completed",
     "response.incomplete": "incomplete",
@@ -80,12 +125,14 @@ function inspectResponseSseEvent(state, eventName, data) {
   }
   state.sawTerminal = true;
   if (eventType === "response.failed" || eventType === "error") markStreamFailure();
-  if (eventType !== "response.completed") return;
-  const response = event.response;
-  state.completed = { response, event };
+  if (eventType === "response.completed") {
+    const response = event.response;
+    state.completed = { response, event };
+  }
+  return changed ? event : null;
 }
 
-function createResponseSseInspector(state) {
+function createResponseSseTransformer(state) {
   let eventBuffer = Buffer.allocUnsafe(Math.min(4096, MAX_SSE_BUFFER_BYTES + 4));
   let eventLength = 0;
   let previous1 = -1;
@@ -111,12 +158,12 @@ function createResponseSseInspector(state) {
     eventLength += bytes.byteLength;
   };
 
-  const inspectEvent = (delimiterLength) => {
-    const contentLength = eventLength - delimiterLength;
+  const inspectEvent = (frame, delimiterLength) => {
+    const contentLength = frame.byteLength - delimiterLength;
     if (contentLength > MAX_SSE_BUFFER_BYTES) {
       throw httpError(`Upstream SSE buffer exceeds ${MAX_SSE_BUFFER_BYTES} bytes`, 502);
     }
-    const chunk = eventBuffer.subarray(0, contentLength).toString("utf8");
+    const chunk = frame.subarray(0, contentLength).toString("utf8");
     const lines = chunk.split(/\r?\n/);
     const eventName = lines
       .find((line) => line.startsWith("event:"))
@@ -126,15 +173,31 @@ function createResponseSseInspector(state) {
       .filter((line) => line.startsWith("data:"))
       .map((line) => line.slice(5).trimStart())
       .join("\n");
-    if (data) inspectResponseSseEvent(state, eventName, data);
-    eventLength = 0;
-    previous1 = -1;
-    previous2 = -1;
-    previous3 = -1;
+    const changed = data && inspectResponseSseEvent(state, eventName, data);
+    if (!changed) return frame;
+    let wroteData = false;
+    const rewritten = lines.filter((line) => {
+      if (!line.startsWith("data:")) return true;
+      if (wroteData) return false;
+      wroteData = true;
+      return true;
+    }).map((line) => line.startsWith("data:") ? `data: ${JSON.stringify(changed)}` : line);
+    return Buffer.from(rewritten.join(chunk.includes("\r\n") ? "\r\n" : "\n")
+      + frame.subarray(contentLength).toString("ascii"));
   };
 
   return {
     push(value) {
+      // Fetch exposes Uint8Array chunks; use a zero-copy Buffer view for UTF-8 decoding.
+      if (!Buffer.isBuffer(value)) value = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+      let pending = [];
+      let pendingBytes = 0;
+      const flush = () => {
+        const output = pending.length === 1 ? pending[0] : Buffer.concat(pending, pendingBytes);
+        pending = [];
+        pendingBytes = 0;
+        return output;
+      };
       let segmentStart = 0;
       for (let index = 0; index < value.byteLength; index += 1) {
         const byte = value[index];
@@ -145,10 +208,32 @@ function createResponseSseInspector(state) {
           delimiterLength = previous3 === 0x0d ? 4 : 3;
         }
         if (delimiterLength) {
-          append(value.subarray(segmentStart, index + 1));
-          inspectEvent(delimiterLength);
+          let frame = value.subarray(segmentStart, index + 1);
+          if (eventLength > 0) {
+            append(frame);
+            // Writes may retain a Buffer after returning; never expose the reusable buffer.
+            if (eventLength > SSE_WRITE_BATCH_BYTES) {
+              frame = eventBuffer.subarray(0, eventLength);
+              eventBuffer = Buffer.allocUnsafe(Math.min(4096, MAX_SSE_BUFFER_BYTES + 4));
+            } else {
+              frame = Buffer.from(eventBuffer.subarray(0, eventLength));
+            }
+          }
+          eventLength = 0;
+          previous1 = -1;
+          previous2 = -1;
+          previous3 = -1;
           segmentStart = index + 1;
-          if (state.sawTerminal) return index + 1;
+          const forwarded = inspectEvent(frame, delimiterLength);
+          const last = pending.at(-1);
+          if (last && last.buffer === forwarded.buffer
+            && last.byteOffset + last.byteLength === forwarded.byteOffset) {
+            pending[pending.length - 1] = Buffer.from(last.buffer, last.byteOffset, last.byteLength + forwarded.byteLength);
+          } else {
+            pending.push(forwarded);
+          }
+          pendingBytes += forwarded.byteLength;
+          if (state.sawTerminal) return flush();
           continue;
         }
         previous3 = previous2;
@@ -159,7 +244,7 @@ function createResponseSseInspector(state) {
       if (eventLength > MAX_SSE_BUFFER_BYTES + 3) {
         throw httpError(`Upstream SSE buffer exceeds ${MAX_SSE_BUFFER_BYTES} bytes`, 502);
       }
-      return null;
+      return pendingBytes > 0 ? flush() : null;
     },
   };
 }
@@ -235,8 +320,9 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
       sawTerminal: false,
       sawOutput: false,
       toolArgumentGuard: new ToolArgumentDeltaGuard(),
+      messageIds: new Map(),
     };
-    const inspector = createResponseSseInspector(streamState);
+    const transformer = createResponseSseTransformer(streamState);
     try {
       while (true) {
         const { done, value } = await reader.read();
@@ -247,9 +333,12 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
           return { successful: Boolean(streamState.completed), compacted: false };
         }
         options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
-        const terminalOffset = inspector.push(value);
-        const forwarded = terminalOffset === null ? value : value.subarray(0, terminalOffset);
-        if (forwarded.byteLength > 0 && !await writeOrDrain(res, forwarded)) return;
+        // Batch within this read, not across reads, and await drain before processing more.
+        for (let offset = 0; offset < value.byteLength; offset += SSE_WRITE_BATCH_BYTES) {
+          const frame = transformer.push(value.subarray(offset, offset + SSE_WRITE_BATCH_BYTES));
+          if (frame && !await writeOrDrain(res, frame)) return;
+          if (streamState.sawTerminal) break;
+        }
         if (streamState.sawTerminal) {
           storeCompletedResponse(reqContext, streamState.completed);
           res.end();