codex-copilot-dx 0.4.35 → 0.4.37

package/src/responses-proxy.mjs

@@ -0,0 +1,122 @@
+import { responses as copilotResponses } from "./copilot.mjs";
+import {
+  httpError,
+  logRequestFailure,
+  sendUpstreamError,
+  writeOrDrain,
+} from "./http-transport.mjs";
+import { openCopilotResponse, rememberResponseHistory } from "./responses-request.mjs";
+import { loadRuntimeConfig } from "./runtime-config.mjs";
+import { endStreamWithError } from "./stream-errors.mjs";
+import { recordResponsesUsage } from "./usage.mjs";
+
+const MAX_SSE_BUFFER_BYTES = loadRuntimeConfig().maxSseBufferBytes;
+
+function storeCompletedResponseFromSse(reqContext, data) {
+  if (!data || data === "[DONE]") return;
+  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,
+      });
+    }
+  } catch {
+    // Ignore non-JSON stream fragments.
+  }
+}
+
+function readSseEvents(buffer, onData) {
+  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) {
+      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/)
+      .filter((line) => line.startsWith("data:"))
+      .map((line) => line.slice(5).trimStart())
+      .join("\n");
+    if (data) onData(data);
+  }
+}
+
+export async function proxyCopilotResponses(reqContext, req, res, upstream = copilotResponses, options = {}) {
+  let opened;
+  try {
+    opened = await openCopilotResponse(reqContext, upstream, options);
+  } finally {
+    options.releaseRequest?.();
+  }
+  const { resp, errorText } = opened;
+  reqContext = opened.reqContext;
+  if (errorText !== undefined) {
+    sendUpstreamError(res, resp, errorText);
+    return;
+  }
+
+  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",
+      Connection: "keep-alive",
+    });
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    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, (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 (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;
+      }
+    } catch (e) {
+      logRequestFailure("Responses", e, options.abort);
+      await endStreamWithError(res, "responses", e, options.abort);
+    } finally {
+      await reader.cancel().catch(() => {});
+      reader.releaseLock();
+    }
+  } else {
+    const data = await resp.text();
+    res.writeHead(resp.status, { "Content-Type": "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,
+        });
+      } catch {}
+    }
+  }
+}

package/src/responses-request.mjs

@@ -0,0 +1,202 @@
+import { responses as copilotResponses } from "./copilot.mjs";
+import { httpError } from "./http-transport.mjs";
+import { materializeResponseHistory, rememberResponseHistoryNode } from "./response-history.mjs";
+import { status } from "./status.mjs";
+
+function cloneJson(value) {
+  return value === undefined ? undefined : structuredClone(value);
+}
+
+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 }] }];
+  }
+  if (Array.isArray(input)) return clone ? cloneJson(input) : input;
+  return [clone ? cloneJson(input) : input];
+}
+
+export function stripInternalResponsesInputFields(inputItems) {
+  if (!Array.isArray(inputItems)) return inputItems;
+  for (const item of inputItems) {
+    if (!item || typeof item !== "object") continue;
+    for (const key of Object.keys(item)) {
+      if (key.startsWith("internal_")) delete item[key];
+    }
+  }
+  return inputItems;
+}
+
+function responsesOutputItems(output) {
+  if (!Array.isArray(output)) return [];
+  return output.filter((item) => item?.type === "message" || item?.type === "function_call");
+}
+
+function stripEncryptedReasoningValue(value, state) {
+  if (Array.isArray(value)) {
+    return value.map((item) => stripEncryptedReasoningValue(item, state));
+  }
+
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      if (key === "encrypted_content") {
+        state.changed = true;
+        continue;
+      }
+      out[key] = stripEncryptedReasoningValue(child, state);
+    }
+    return out;
+  }
+
+  return value;
+}
+
+function isEncryptedReasoningInputItem(item) {
+  return item && typeof item === "object"
+    && (item.type === "reasoning" || Object.prototype.hasOwnProperty.call(item, "encrypted_content"));
+}
+
+export function sanitizeEncryptedReasoningRequest(reqContext) {
+  const state = { changed: false };
+  let body = cloneJson(reqContext.body);
+  if (Array.isArray(body.input)) {
+    const input = [];
+    for (const item of body.input) {
+      if (isEncryptedReasoningInputItem(item)) {
+        state.changed = true;
+        continue;
+      }
+      input.push(stripEncryptedReasoningValue(item, state));
+    }
+    body.input = input;
+  } else {
+    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,
+  };
+}
+
+export function isEncryptedContentVerificationError(statusCode, text) {
+  if (statusCode < 400 || !text) return false;
+  const lower = String(text).toLowerCase();
+  return lower.includes("encrypted content")
+    && lower.includes("could not be verified")
+    && (lower.includes("could not be decrypted") || lower.includes("could not be parsed"));
+}
+
+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");
+}
+
+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"));
+}
+
+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 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);
+}
+
+function isBuiltinImageTool(tool) {
+  return isImageNamespaceTool(tool);
+}
+
+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) {
+    body.input = [...materializeResponseHistory(previousId), ...currentInputItems];
+  } else {
+    body.input = currentInputItems;
+  }
+
+  delete body.previous_response_id;
+  delete body.store;
+  if (Array.isArray(body.tools)) {
+    body.tools = body.tools.filter((tool) => !isBuiltinImageTool(tool));
+    if (!body.tools.length) delete body.tools;
+  }
+  stripInternalResponsesInputFields(body.input);
+  stripInternalResponsesInputFields(currentInputItems);
+
+  return {
+    body,
+    inputItems: body.input,
+    historyParentId: previousId ?? null,
+    historyInputItems: currentInputItems,
+    takeHistoryOwnership: mutate,
+  };
+}
+
+export function rememberResponseHistory(reqContext, responseJson) {
+  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,
+  });
+}

package/src/runtime-config.mjs

@@ -0,0 +1,38 @@
+export const RUNTIME_DEFAULTS = Object.freeze({
+  upstreamTimeoutMs: 120 * 1000,
+  streamHandshakeTimeoutMs: 120 * 1000,
+  streamIdleTimeoutMs: 120 * 1000,
+  maxSseBufferBytes: 8 * 1024 * 1024,
+  maxBodyBytes: 64 * 1024 * 1024,
+  maxDecodedBodyBytes: 128 * 1024 * 1024,
+  maxInflightBodyBytes: 32 * 1024 * 1024,
+  maxQueuedRequests: 16,
+  requestQueueTimeoutMs: 120 * 1000,
+  responseHistoryMaxBytes: 64 * 1024 * 1024,
+  responseHistoryMaxEntries: 4096,
+  tokenLockTimeoutMs: 10 * 60 * 1000,
+  tokenLockStaleMs: 15 * 60 * 1000,
+});
+
+export function parsePositiveInteger(value, fallback, max = Number.POSITIVE_INFINITY) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.min(parsed, max) : fallback;
+}
+
+export function loadRuntimeConfig(env = process.env) {
+  return Object.freeze({
+    upstreamTimeoutMs: parsePositiveInteger(env.CCDX_UPSTREAM_TIMEOUT_MS, RUNTIME_DEFAULTS.upstreamTimeoutMs),
+    streamHandshakeTimeoutMs: parsePositiveInteger(env.CCDX_STREAM_HANDSHAKE_TIMEOUT_MS, RUNTIME_DEFAULTS.streamHandshakeTimeoutMs),
+    streamIdleTimeoutMs: parsePositiveInteger(env.CCDX_STREAM_IDLE_TIMEOUT_MS, RUNTIME_DEFAULTS.streamIdleTimeoutMs),
+    maxSseBufferBytes: parsePositiveInteger(env.CCDX_MAX_SSE_BUFFER_BYTES, RUNTIME_DEFAULTS.maxSseBufferBytes),
+    maxBodyBytes: parsePositiveInteger(env.CCDX_MAX_BODY_BYTES, RUNTIME_DEFAULTS.maxBodyBytes),
+    maxDecodedBodyBytes: parsePositiveInteger(env.CCDX_MAX_DECODED_BODY_BYTES, RUNTIME_DEFAULTS.maxDecodedBodyBytes),
+    maxInflightBodyBytes: parsePositiveInteger(env.CCDX_MAX_INFLIGHT_BODY_BYTES, RUNTIME_DEFAULTS.maxInflightBodyBytes),
+    maxQueuedRequests: parsePositiveInteger(env.CCDX_MAX_QUEUED_REQUESTS, RUNTIME_DEFAULTS.maxQueuedRequests),
+    requestQueueTimeoutMs: parsePositiveInteger(env.CCDX_REQUEST_QUEUE_TIMEOUT_MS, RUNTIME_DEFAULTS.requestQueueTimeoutMs),
+    responseHistoryMaxBytes: parsePositiveInteger(env.CCDX_RESPONSE_HISTORY_MAX_BYTES, RUNTIME_DEFAULTS.responseHistoryMaxBytes),
+    responseHistoryMaxEntries: parsePositiveInteger(env.CCDX_RESPONSE_HISTORY_MAX_ENTRIES, RUNTIME_DEFAULTS.responseHistoryMaxEntries),
+    tokenLockTimeoutMs: parsePositiveInteger(env.CCDX_TOKEN_LOCK_TIMEOUT_MS, RUNTIME_DEFAULTS.tokenLockTimeoutMs),
+    tokenLockStaleMs: parsePositiveInteger(env.CCDX_TOKEN_LOCK_STALE_MS, RUNTIME_DEFAULTS.tokenLockStaleMs),
+  });
+}

package/src/status.mjs

@@ -1,3 +1,5 @@
+import { currentRequestContext } from "./request-context.mjs";
+
 const LABELS = {
   info: "[INFO]",
   ok: "[OK]",
@@ -8,5 +10,8 @@ const LABELS = {
 };
 
 export function status(kind, message) {
-  return `${LABELS[kind] || LABELS.info} ${message}`;
+  const requestContext = currentRequestContext();
+  const requestId = requestContext?.showRequestId ? requestContext.requestId : "";
+  const context = requestId ? ` request_id=${requestId}` : "";
+  return `${LABELS[kind] || LABELS.info}${context} ${message}`;
 }

package/src/stream-errors.mjs

@@ -0,0 +1,17 @@
+import { writeOrDrain } from "./http-transport.mjs";
+
+function streamErrorData(protocol, error, abort) {
+  const code = abort?.reason || "upstream_stream_error";
+  const message = `${code}: ${error?.message || "Upstream stream failed"}`;
+  if (protocol === "anthropic") {
+    return { type: "error", error: { type: "api_error", message } };
+  }
+  return { type: "error", code, message, param: null };
+}
+
+export async function endStreamWithError(res, protocol, error, abort) {
+  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);
+  if (!res.destroyed && !res.writableEnded) res.end();
+}

package/src/stream.mjs

@@ -1,13 +1,8 @@
 // Yield fetch Response body lines while preserving SSE semantics for callers.
 // Strip CRLF tails and release the reader if iteration stops early.
-const DEFAULT_MAX_SSE_BUFFER_BYTES = 8 * 1024 * 1024;
+import { loadRuntimeConfig } from "./runtime-config.mjs";
 
-function positiveInt(value, fallback) {
-  const n = Number.parseInt(value, 10);
-  return Number.isFinite(n) && n > 0 ? n : fallback;
-}
-
-const MAX_SSE_BUFFER_BYTES = positiveInt(process.env.CCDX_MAX_SSE_BUFFER_BYTES, DEFAULT_MAX_SSE_BUFFER_BYTES);
+const MAX_SSE_BUFFER_BYTES = loadRuntimeConfig().maxSseBufferBytes;
 
 function assertSseBufferLimit(buffer, maxBufferBytes) {
   if (Buffer.byteLength(buffer) > maxBufferBytes) {