codex-copilot-dx 0.4.43 → 0.5.0

package/src/responses-compaction.mjs

@@ -0,0 +1,113 @@
+import { randomUUID } from "node:crypto";
+import { httpError } from "./http-transport.mjs";
+
+const COMPACTION_TRIGGER_TYPE = "compaction_trigger";
+const RETAINED_MESSAGE_ROLES = new Set(["user", "assistant", "developer", "system"]);
+const RETAINED_MESSAGE_TOKEN_BUDGET = 64_000;
+const APPROX_BYTES_PER_TOKEN = 4;
+
+function compactionError(message) {
+  const error = httpError(message, 502);
+  error.code = "ccdx_invalid_compaction_response";
+  error.jsonBody = {
+    error: {
+      message,
+      type: "upstream_error",
+      code: error.code,
+    },
+  };
+  return error;
+}
+
+function normalizeMessageContent(content) {
+  if (typeof content === "string") return [{ type: "input_text", text: content }];
+  if (!Array.isArray(content)) return [];
+  return content.map((part) => {
+    if (!part || typeof part !== "object") return part;
+    return part.type === "output_text"
+      ? { ...part, type: "input_text" }
+      : structuredClone(part);
+  });
+}
+
+function approximateTextTokens(content) {
+  return content.reduce((total, part) => {
+    if (part?.type !== "input_text" || typeof part.text !== "string") return total;
+    return total + Math.ceil(Buffer.byteLength(part.text) / APPROX_BYTES_PER_TOKEN);
+  }, 0);
+}
+
+function retainedMessages(inputItems) {
+  const kept = [];
+  let usedTokens = 0;
+  for (let index = inputItems.length - 1; index >= 0; index -= 1) {
+    const item = inputItems[index];
+    if (item?.type !== "message" || !RETAINED_MESSAGE_ROLES.has(item.role)) continue;
+
+    const content = normalizeMessageContent(item.content);
+    usedTokens += Math.max(approximateTextTokens(content), 1);
+    if (usedTokens > RETAINED_MESSAGE_TOKEN_BUDGET && kept.length > 0) break;
+
+    kept.push({
+      type: "message",
+      id: `msg_${randomUUID().replaceAll("-", "")}`,
+      status: item.status ?? "completed",
+      role: item.role,
+      content,
+      ...(item.phase !== undefined ? { phase: structuredClone(item.phase) } : {}),
+    });
+  }
+  return kept.reverse();
+}
+
+export function prepareResponsesCompactionRequest(reqContext) {
+  const input = Array.isArray(reqContext?.body?.input) ? reqContext.body.input : [];
+  const compactionInputItems = compactionInputWithoutTrigger(input);
+  reqContext.body.input = [...compactionInputItems, { type: COMPACTION_TRIGGER_TYPE }];
+  reqContext.body.stream = false;
+  return reqContext;
+}
+
+export function compactionInputWithoutTrigger(input) {
+  return Array.isArray(input)
+    ? input.filter((item) => item?.type !== COMPACTION_TRIGGER_TYPE)
+    : [];
+}
+
+export function createResponsesCompactionResult(inputItems, generated) {
+  if (!generated || typeof generated !== "object" || !generated.id || !Array.isArray(generated.output)) {
+    throw compactionError("Copilot compaction returned an invalid response envelope");
+  }
+  if (Object.prototype.hasOwnProperty.call(generated, "status") && generated.status !== "completed") {
+    throw compactionError(`Copilot compaction returned status ${generated.status}`);
+  }
+
+  const compactionItems = generated.output.filter((item) => item?.type === "compaction");
+  if (!compactionItems.length) {
+    throw compactionError("Copilot compaction returned no compaction output item");
+  }
+  if (compactionItems.some((item) => (
+    typeof item.encrypted_content !== "string" || item.encrypted_content.length === 0
+  ))) {
+    throw compactionError("Copilot compaction returned an invalid compaction output item");
+  }
+
+  return {
+    ...generated,
+    object: "response.compaction",
+    output: [
+      ...retainedMessages(Array.isArray(inputItems) ? inputItems : []),
+      ...compactionItems,
+    ],
+  };
+}
+
+export function parseResponsesCompactionResult(inputItems, text) {
+  let generated;
+  try {
+    generated = JSON.parse(text);
+  } catch {
+    throw compactionError("Copilot compaction returned invalid JSON");
+  }
+  return createResponsesCompactionResult(inputItems, generated);
+}

package/src/responses-handler.mjs

@@ -15,10 +15,12 @@ import {
 } from "./models.mjs";
 import { chatToResponses, forwardToChat, responsesBodyUsesCustomTools } from "./responses-bridge.mjs";
 import { prepareResponsesChatPayload } from "./responses-chat-payload.mjs";
+import { prepareResponsesCompactionRequest } from "./responses-compaction.mjs";
 import { proxyCopilotResponses } from "./responses-proxy.mjs";
 import { prepareResponsesRequest, rememberResponseHistory } from "./responses-request.mjs";
 import { status } from "./status.mjs";
 import { endStreamWithError } from "./stream-errors.mjs";
+import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
 import { recordResponsesUsage } from "./usage.mjs";
 
 const RESPONSES_ONLY_FALLBACK = new Set([
@@ -113,20 +115,29 @@ export function createResponsesHandler(options) {
         });
         const { chatReq, bodyText } = chatPayload;
         if (parsed.stream) {
+          let streamResponseHeaders = null;
           await forwardToChat(chatReq, async (event, data) => {
-            if (!res.headersSent) res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
+            if (!res.headersSent) res.writeHead(200, {
+              ...streamResponseHeaders,
+              "Cache-Control": "no-cache",
+              Connection: "keep-alive",
+            });
             await writeOrDrain(res, `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
             if (event === "response.completed") {
               rememberResponseHistory(prepared, data.response);
               recordResponsesUsage({ surface: prepared.surface, mode: "stream", model, response: data.response, event: data });
             }
-          }, () => { if (!res.writableEnded) res.end(); }, async (statusCode, errMsg) => {
+          }, () => { if (!res.writableEnded) res.end(); }, async (statusCode, errMsg, error, upstreamResponse) => {
             if (!res.headersSent) {
-              res.writeHead(statusCode || 500, { "Content-Type": "text/plain; charset=utf-8" });
-              res.end(errMsg);
+              if (upstreamResponse) {
+                sendUpstreamError(res, upstreamResponse, errMsg);
+                return;
+              }
+              const responseError = error || Object.assign(new Error(errMsg), { statusCode });
+              sendJsonError(res, responseError, statusCode || 500);
               return;
             }
-            await endStreamWithError(res, "responses", new Error(errMsg), abort);
+            await endStreamWithError(res, "responses", error || new Error(errMsg), abort);
           }, {
             signal: abort.signal,
             abort,
@@ -134,6 +145,11 @@ export function createResponsesHandler(options) {
             chatCompletionsFn,
             releaseRequest,
             bodyText,
+            onUpstreamResponse: (upstreamResponse) => {
+              streamResponseHeaders = safeUpstreamResponseHeaders(upstreamResponse.headers, {
+                contentType: "text/event-stream",
+              });
+            },
           });
         } else {
           try {
@@ -147,7 +163,9 @@ export function createResponsesHandler(options) {
             const response = chatToResponses(JSON.parse(data), model);
             rememberResponseHistory(prepared, response);
             recordResponsesUsage({ surface: prepared.surface, mode: "json", model, response, event: response });
-            res.writeHead(200, { "Content-Type": "application/json" });
+            res.writeHead(200, safeUpstreamResponseHeaders(upstream.headers, {
+              contentType: "application/json",
+            }));
             res.end(JSON.stringify(response));
           } catch (error) {
             logRequestFailure("Responses", error, abort);
@@ -170,8 +188,6 @@ export function createResponsesCompactHandler(options) {
     acquireRequest,
     openAIModelEnv,
     responsesCompactFn,
-    streamHandshakeTimeoutMs,
-    streamIdleTimeoutMs,
     upstreamTimeoutMs,
   } = options;
 
@@ -181,22 +197,20 @@ export function createResponsesCompactHandler(options) {
     try {
       releaseRequest = await acquireRequest(req, { signal: abort.signal });
       const parsed = await readJsonBody(req);
-      abort.setTimeout(
-        parsed.stream ? streamHandshakeTimeoutMs : upstreamTimeoutMs,
-        parsed.stream ? "stream_handshake_timeout" : "upstream_timeout",
+      abort.setTimeout(upstreamTimeoutMs, "upstream_timeout");
+      const prepared = prepareResponsesCompactionRequest(
+        prepareResponsesRequest(parsed, { mutate: true }),
       );
-      const prepared = prepareResponsesRequest(parsed, { mutate: true });
       prepared.surface = "responses_compact";
       const model = parsed.model || "unknown";
       const { requestedModel, upstreamModel } = resolveOpenAIModel(model, openAIModelEnv);
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
-      console.log(status("info", `responses compact model=${requestedModel}${upstreamLog} stream=${!!parsed.stream}`));
+      console.log(status("info", `responses compact model=${requestedModel}${upstreamLog} stream=false`));
       await proxyCopilotResponses(prepared, req, res, responsesCompactFn, {
         signal: abort.signal,
         abort,
         releaseRequest,
-        streamIdleTimeoutMs,
       });
     } catch (error) {
       logRequestFailure("Responses compact", error, abort);

package/src/responses-proxy.mjs

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

package/src/running-adapter.mjs

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { localPackageVersion } from "./version.mjs";
 
 export const ADAPTER_HEALTH_PATH = "/_ccdx/health";
+export const ADAPTER_STATUS_PATH = "/_ccdx/status";
 export const ADAPTER_PROTOCOL_VERSION = 2;
 export const ADAPTER_VERSION = localPackageVersion();
 const ADAPTER_INSTANCE_ID = randomUUID();

package/src/stream-contract.mjs

@@ -0,0 +1,102 @@
+const DEFAULT_BLANK_TOOL_ARGUMENT_LIMIT = 20;
+
+function streamProtocolError(message, code) {
+  const error = new Error(message);
+  error.statusCode = 502;
+  error.code = code;
+  error.jsonBody = {
+    error: {
+      message,
+      type: "upstream_protocol_error",
+      code,
+    },
+  };
+  return error;
+}
+
+export function invalidUpstreamStream(message, code = "upstream_stream_invalid") {
+  return streamProtocolError(message, code);
+}
+
+export function withChatStreamUsage(request) {
+  const streamOptions = request?.stream_options && typeof request.stream_options === "object"
+    ? request.stream_options
+    : {};
+  if (request?.stream === true && streamOptions.include_usage === true) return request;
+  return {
+    ...request,
+    stream: true,
+    stream_options: { ...streamOptions, include_usage: true },
+  };
+}
+
+export async function requireUpstreamEventStream(response) {
+  let error = null;
+  if (!response?.body) {
+    error = streamProtocolError(
+      "Upstream returned a successful streaming response without a body",
+      "upstream_stream_body_missing",
+    );
+  } else {
+    const contentType = response.headers?.get?.("content-type") || "";
+    const mediaType = contentType.split(";", 1)[0].trim().toLowerCase();
+    if (mediaType !== "text/event-stream") {
+      error = streamProtocolError(
+        "Upstream returned a successful streaming response with a non-SSE Content-Type",
+        "upstream_stream_content_type_invalid",
+      );
+    }
+  }
+
+  if (!error) return;
+  await response?.body?.cancel?.().catch(() => {});
+  throw error;
+}
+
+export function incompleteUpstreamStream(expectedTerminator) {
+  return streamProtocolError(
+    `Upstream stream ended before ${expectedTerminator}`,
+    "upstream_stream_incomplete",
+  );
+}
+
+export function upstreamChatStreamError(event) {
+  const payload = event?.error;
+  if (!payload || typeof payload !== "object") return null;
+  const type = typeof payload.type === "string" && payload.type ? `${payload.type}: ` : "";
+  const message = typeof payload.message === "string" && payload.message
+    ? payload.message.slice(0, 500)
+    : "Upstream stream error";
+  return streamProtocolError(
+    `Upstream Chat Completions SSE error: ${type}${message}`,
+    "upstream_chat_stream_error",
+  );
+}
+
+export class ToolArgumentDeltaGuard {
+  constructor(limit = DEFAULT_BLANK_TOOL_ARGUMENT_LIMIT) {
+    this.limit = limit;
+    this.whitespaceRuns = new Map();
+  }
+
+  observe(callIndex, delta) {
+    if (typeof delta !== "string") return;
+    const key = callIndex ?? "unknown";
+    let count = this.whitespaceRuns.get(key) || 0;
+    for (const character of delta) {
+      if (character === "\r" || character === "\n" || character === "\t") {
+        count += 1;
+        if (count > this.limit) {
+          this.whitespaceRuns.set(key, count);
+          throw streamProtocolError(
+            `Upstream sent more than ${this.limit} consecutive line-break or tab characters in tool arguments`,
+            "upstream_tool_arguments_stalled",
+          );
+        }
+      } else if (character !== " ") {
+        count = 0;
+      }
+    }
+    this.whitespaceRuns.set(key, count);
+  }
+}

package/src/stream-errors.mjs

@@ -1,7 +1,8 @@
 import { writeOrDrain } from "./http-transport.mjs";
+import { markStreamFailure } from "./stream-performance.mjs";
 
 function streamErrorData(protocol, error, abort) {
-  const code = abort?.reason || "upstream_stream_error";
+  const code = abort?.reason || error?.code || "upstream_stream_error";
   const message = `${code}: ${error?.message || "Upstream stream failed"}`;
   if (protocol === "anthropic") {
     return { type: "error", error: { type: "api_error", message } };
@@ -10,6 +11,7 @@ function streamErrorData(protocol, error, abort) {
 }
 
 export async function endStreamWithError(res, protocol, error, abort) {
+  markStreamFailure();
   if (res.destroyed || res.writableEnded) return;
   const data = streamErrorData(protocol, error, abort);
   await writeOrDrain(res, `event: error\ndata: ${JSON.stringify(data)}\n\n`).catch(() => false);