codex-copilot-dx 0.4.34 → 0.4.36

package/src/http-transport.mjs

@@ -1,21 +1,20 @@
 import { promisify } from "node:util";
 import * as zlib from "node:zlib";
+import { loadRuntimeConfig, parsePositiveInteger } from "./runtime-config.mjs";
 import { status } from "./status.mjs";
 
-const DEFAULT_MAX_BODY_BYTES = 64 * 1024 * 1024;
-const DEFAULT_MAX_DECODED_BODY_BYTES = 128 * 1024 * 1024;
+const COMPRESSED_BODY_WEIGHT_MULTIPLIER = 4;
 const gunzipAsync = promisify(zlib.gunzip);
 const inflateAsync = promisify(zlib.inflate);
 const brotliDecompressAsync = promisify(zlib.brotliDecompress);
 const zstdDecompressAsync = zlib.zstdDecompress ? promisify(zlib.zstdDecompress) : null;
 
-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 HTTP_RUNTIME_CONFIG = loadRuntimeConfig();
+const MAX_BODY_BYTES = HTTP_RUNTIME_CONFIG.maxBodyBytes;
+const MAX_DECODED_BODY_BYTES = HTTP_RUNTIME_CONFIG.maxDecodedBodyBytes;
+const MAX_INFLIGHT_BODY_BYTES = HTTP_RUNTIME_CONFIG.maxInflightBodyBytes;
+const MAX_QUEUED_REQUESTS = HTTP_RUNTIME_CONFIG.maxQueuedRequests;
+const REQUEST_QUEUE_TIMEOUT_MS = HTTP_RUNTIME_CONFIG.requestQueueTimeoutMs;
 
 export function httpError(message, statusCode) {
   const err = new Error(message);
@@ -31,6 +30,152 @@ function requestContentLength(req) {
   return Number.parseInt(req.headers?.["content-length"] || "", 10);
 }
 
+function requestAdmissionWeight(req, maxBytes) {
+  const encodings = contentEncodings(req.headers?.["content-encoding"]);
+  const contentLength = requestContentLength(req);
+  if (!Number.isFinite(contentLength) || contentLength < 0) return maxBytes;
+  const compressed = encodings.some((encoding) => encoding !== "identity");
+  const weightedLength = compressed ? contentLength * COMPRESSED_BODY_WEIGHT_MULTIPLIER : contentLength;
+  return Math.max(1, Math.min(weightedLength, maxBytes));
+}
+
+function admissionAbortError(signal) {
+  if (signal?.reason instanceof Error) return signal.reason;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  return error;
+}
+
+export function createRequestAdmission({
+  maxBytes = MAX_INFLIGHT_BODY_BYTES,
+  maxQueued = MAX_QUEUED_REQUESTS,
+  waitTimeoutMs = REQUEST_QUEUE_TIMEOUT_MS,
+} = {}) {
+  const byteLimit = parsePositiveInteger(maxBytes, MAX_INFLIGHT_BODY_BYTES);
+  const queueLimit = parsePositiveInteger(maxQueued, MAX_QUEUED_REQUESTS);
+  const timeoutMs = parsePositiveInteger(waitTimeoutMs, REQUEST_QUEUE_TIMEOUT_MS);
+  const queue = [];
+  let activeBytes = 0;
+  let activeRequests = 0;
+  const counters = {
+    total: 0,
+    activated: 0,
+    queued: 0,
+    rejected: 0,
+    timedOut: 0,
+    aborted: 0,
+    waitMsTotal: 0,
+    waitMsMax: 0,
+  };
+
+  const remove = (entry) => {
+    const index = queue.indexOf(entry);
+    if (index >= 0) queue.splice(index, 1);
+  };
+
+  const activate = (entry) => {
+    entry.cleanup();
+    activeBytes += entry.weight;
+    activeRequests += 1;
+    counters.activated += 1;
+    const waitMs = Math.max(0, Date.now() - entry.startedAt);
+    counters.waitMsTotal += waitMs;
+    counters.waitMsMax = Math.max(counters.waitMsMax, waitMs);
+    let released = false;
+    entry.resolve(() => {
+      if (released) return;
+      released = true;
+      activeBytes = Math.max(0, activeBytes - entry.weight);
+      activeRequests = Math.max(0, activeRequests - 1);
+      drain();
+    });
+  };
+
+  const drain = () => {
+    for (let index = 0; index < queue.length;) {
+      const entry = queue[index];
+      if (entry.cancelled) {
+        queue.splice(index, 1);
+        continue;
+      }
+      if (activeBytes + entry.weight > byteLimit) {
+        index += 1;
+        continue;
+      }
+      queue.splice(index, 1);
+      activate(entry);
+    }
+  };
+
+  const acquire = (req, { signal } = {}) => {
+    counters.total += 1;
+    if (signal?.aborted) {
+      counters.aborted += 1;
+      return Promise.reject(admissionAbortError(signal));
+    }
+    const weight = requestAdmissionWeight(req, byteLimit);
+    if (queue.length >= queueLimit && activeBytes + weight > byteLimit) {
+      counters.rejected += 1;
+      return Promise.reject(httpError(`Request queue is full (${queueLimit} waiting)`, 503));
+    }
+    if (activeBytes + weight > byteLimit) counters.queued += 1;
+
+    return new Promise((resolve, reject) => {
+      let timer;
+      const entry = {
+        cancelled: false,
+        startedAt: Date.now(),
+        weight,
+        resolve,
+        cleanup: () => {
+          if (timer) clearTimeout(timer);
+          signal?.removeEventListener("abort", onAbort);
+        },
+      };
+      const cancel = (error, reason) => {
+        if (entry.cancelled) return;
+        entry.cancelled = true;
+        if (reason === "aborted") counters.aborted += 1;
+        if (reason === "timed_out") counters.timedOut += 1;
+        entry.cleanup();
+        remove(entry);
+        reject(error);
+        drain();
+      };
+      const onAbort = () => cancel(admissionAbortError(signal), "aborted");
+      signal?.addEventListener("abort", onAbort, { once: true });
+      timer = setTimeout(() => {
+        cancel(httpError(`Request admission timed out after ${timeoutMs}ms`, 503), "timed_out");
+      }, timeoutMs);
+      timer.unref?.();
+      queue.push(entry);
+      if (signal?.aborted) onAbort();
+      else drain();
+    });
+  };
+
+  acquire.stats = () => ({ activeBytes, queued: queue.length, maxBytes: byteLimit });
+  acquire.diagnostics = () => ({
+    activeBytes,
+    activeRequests,
+    queued: queue.length,
+    maxBytes: byteLimit,
+    maxQueued: queueLimit,
+    waitTimeoutMs: timeoutMs,
+    total: counters.total,
+    activated: counters.activated,
+    queuedTotal: counters.queued,
+    rejected: counters.rejected,
+    timedOut: counters.timedOut,
+    aborted: counters.aborted,
+    waitMsAvg: counters.activated > 0
+      ? Number((counters.waitMsTotal / counters.activated).toFixed(1))
+      : 0,
+    waitMsMax: counters.waitMsMax,
+  });
+  return acquire;
+}
+
 async function readRequestBuffer(req, maxBytes) {
   const contentLength = requestContentLength(req);
   if (Number.isFinite(contentLength) && contentLength > maxBytes) {

package/src/image-optimization.mjs

@@ -61,7 +61,7 @@ export function createTaskLimiter(concurrency) {
     }
   };
 
-  return async function runLimited(task, { signal } = {}) {
+  const runLimited = async function runLimited(task, { signal } = {}) {
     if (signal?.aborted) throw abortError(signal);
     await new Promise((resolve, reject) => {
       const entry = {
@@ -91,10 +91,25 @@ export function createTaskLimiter(concurrency) {
       drain();
     }
   };
+  runLimited.stats = () => ({
+    active,
+    queued: queue.reduce((count, entry) => count + (entry.cancelled ? 0 : 1), 0),
+    limit,
+  });
+  return runLimited;
 }
 
 const runGlobalImageTask = createTaskLimiter(IMG_CONCURRENCY);
 
+export function imageOptimizationStats() {
+  return {
+    ...runGlobalImageTask.stats(),
+    disabled: IMG_OPT_DISABLED,
+    cache_entries: optimizedImageDigests.size,
+    sharp_loaded: sharpImport !== null,
+  };
+}
+
 async function sharp() {
   sharpImport ||= import("sharp");
   const mod = await sharpImport;
@@ -130,13 +145,16 @@ export async function optimizeImageDataUrl(dataUrl, {
   const match = /^data:(image\/[a-z+.-]+);base64,(.+)$/i.exec(dataUrl);
   if (!match) return dataUrl;
   const mime = match[1].toLowerCase();
-  const raw = Buffer.from(match[2], "base64");
-  if (raw.length < IMG_MIN_BYTES || mime.includes("gif")) return dataUrl;
-  const digest = imageDigest(raw);
-  if (!force && touchOptimizedImage(digest)) return dataUrl;
+  const encoded = match[2];
+  const inputBytes = Buffer.byteLength(encoded, "base64");
+  if (inputBytes < IMG_MIN_BYTES || mime.includes("gif")) return dataUrl;
 
   try {
     return await runGlobalImageTask(async () => {
+      const raw = Buffer.from(encoded, "base64");
+      if (raw.length < IMG_MIN_BYTES) return dataUrl;
+      const digest = imageDigest(raw);
+      if (!force && touchOptimizedImage(digest)) return dataUrl;
       const resize = await sharp();
       const image = resize(raw, { failOn: "none", limitInputPixels: IMG_MAX_INPUT_PIXELS });
       const out = await image
@@ -156,7 +174,7 @@ export async function optimizeImageDataUrl(dataUrl, {
     }, { signal });
   } catch (e) {
     if (signal?.aborted || e?.name === "AbortError") throw e;
-    console.warn(status("warn", `image optimize failed (${mime}, ${raw.length}b): ${e.message}`));
+    console.warn(status("warn", `image optimize failed (${mime}, ${inputBytes}b): ${e.message}`));
     return dataUrl;
   }
 }

package/src/models.mjs

@@ -225,6 +225,19 @@ export function resolveOpenAIModel(model, env = process.env) {
   };
 }
 
+export function codexAutoReviewModelStatus(models, env = process.env) {
+  const { upstreamModel } = resolveOpenAIModel(CODEX_AUTO_REVIEW_MODEL, env);
+  const model = copilotModelData(models).find((entry) => String(entry?.id || "").trim() === upstreamModel);
+  if (!model) return { available: false, upstreamModel, reason: "model is not advertised" };
+  const endpoints = modelEndpoints(model);
+  const available = endpoints.includes("/responses") || endpoints.includes("/v1/responses");
+  return {
+    available,
+    upstreamModel,
+    reason: available ? "" : "model does not advertise a Responses endpoint",
+  };
+}
+
 export function anthropicModelInfo(model) {
   return {
     id: model.id,

package/src/observability.mjs

@@ -0,0 +1,147 @@
+import { isIP } from "node:net";
+import { adapterHealthPayload } from "./running-adapter.mjs";
+import { copilotRuntimeStatus } from "./copilot.mjs";
+import { imageOptimizationStats } from "./image-optimization.mjs";
+import { responseHistoryStats } from "./response-history.mjs";
+import { loadRuntimeConfig } from "./runtime-config.mjs";
+
+export const ADAPTER_STATUS_PATH = "/_ccdx/status";
+const OBSERVABILITY_RUNTIME_CONFIG = loadRuntimeConfig();
+
+const ROUTE_NAMES = Object.freeze([
+  "responses",
+  "responses_compact",
+  "models",
+  "messages",
+  "messages_count_tokens",
+  "not_found",
+]);
+
+function emptyCounter() {
+  return {
+    total: 0,
+    active: 0,
+    completed: 0,
+    errors: 0,
+    aborted: 0,
+    duration_ms_total: 0,
+    duration_ms_max: 0,
+    status_2xx: 0,
+    status_3xx: 0,
+    status_4xx: 0,
+    status_5xx: 0,
+  };
+}
+
+function statusBucket(statusCode) {
+  if (statusCode >= 200 && statusCode < 300) return "status_2xx";
+  if (statusCode >= 300 && statusCode < 400) return "status_3xx";
+  if (statusCode >= 400 && statusCode < 500) return "status_4xx";
+  if (statusCode >= 500) return "status_5xx";
+  return null;
+}
+
+function counterSnapshot(counter) {
+  return {
+    ...counter,
+    duration_ms_avg: counter.completed > 0
+      ? Number((counter.duration_ms_total / counter.completed).toFixed(1))
+      : 0,
+  };
+}
+
+export function createRequestMetrics({ now = Date.now } = {}) {
+  const total = emptyCounter();
+  const routes = Object.fromEntries(ROUTE_NAMES.map((name) => [name, emptyCounter()]));
+
+  const begin = (routeName) => {
+    const route = routes[routeName] || routes.not_found;
+    const startedAt = now();
+    total.total += 1;
+    total.active += 1;
+    route.total += 1;
+    route.active += 1;
+    let completed = false;
+
+    return ({ statusCode = 0, aborted = false } = {}) => {
+      if (completed) return;
+      completed = true;
+      const durationMs = Math.max(0, now() - startedAt);
+      for (const counter of [total, route]) {
+        counter.active = Math.max(0, counter.active - 1);
+        counter.completed += 1;
+        counter.duration_ms_total += durationMs;
+        counter.duration_ms_max = Math.max(counter.duration_ms_max, durationMs);
+        if (aborted) counter.aborted += 1;
+        if (statusCode >= 400) counter.errors += 1;
+        const bucket = statusBucket(statusCode);
+        if (bucket) counter[bucket] += 1;
+      }
+    };
+  };
+
+  return {
+    begin,
+    snapshot() {
+      return {
+        ...counterSnapshot(total),
+        by_route: Object.fromEntries(ROUTE_NAMES.map((name) => [name, counterSnapshot(routes[name])])),
+      };
+    },
+  };
+}
+
+export function classifyAdapterRoute(method, pathname) {
+  if (method === "POST" && pathname === "/v1/responses") return "responses";
+  if (method === "POST" && pathname === "/v1/responses/compact") return "responses_compact";
+  if (method === "GET" && pathname === "/v1/models") return "models";
+  if (method === "POST" && pathname === "/v1/messages") return "messages";
+  if (method === "POST" && pathname === "/v1/messages/count_tokens") return "messages_count_tokens";
+  return "not_found";
+}
+
+export function isLoopbackAddress(address) {
+  const normalized = String(address || "").trim().toLowerCase();
+  if (normalized === "::1" || normalized === "[::1]") return true;
+  const ipv4 = normalized.startsWith("::ffff:") ? normalized.slice(7) : normalized;
+  return isIP(ipv4) === 4 && ipv4.startsWith("127.");
+}
+
+function modelRegistryStatus(modelRegistry) {
+  const modelData = Array.isArray(modelRegistry?.models)
+    ? modelRegistry.models
+    : modelRegistry?.models?.data;
+  return {
+    source: String(modelRegistry?.source || "built-in"),
+    models: Array.isArray(modelData) ? modelData.length : 0,
+    claude_models: Array.isArray(modelRegistry?.modelDefs) ? modelRegistry.modelDefs.length : 0,
+  };
+}
+
+export function runtimeStatusPayload({ metrics, admission, modelRegistry } = {}) {
+  const memory = process.memoryUsage();
+  return {
+    ...adapterHealthPayload(),
+    uptime_ms: Math.round(process.uptime() * 1000),
+    process: {
+      rss_bytes: memory.rss,
+      heap_used_bytes: memory.heapUsed,
+      heap_total_bytes: memory.heapTotal,
+      external_bytes: memory.external,
+      array_buffers_bytes: memory.arrayBuffers,
+    },
+    requests: metrics?.snapshot?.() || createRequestMetrics().snapshot(),
+    admission: admission?.diagnostics?.() || admission?.stats?.() || null,
+    response_history: responseHistoryStats(),
+    image_optimization: imageOptimizationStats(),
+    copilot: copilotRuntimeStatus(),
+    models: modelRegistryStatus(modelRegistry),
+    limits: {
+      max_body_bytes: OBSERVABILITY_RUNTIME_CONFIG.maxBodyBytes,
+      max_decoded_body_bytes: OBSERVABILITY_RUNTIME_CONFIG.maxDecodedBodyBytes,
+      max_sse_buffer_bytes: OBSERVABILITY_RUNTIME_CONFIG.maxSseBufferBytes,
+      response_history_max_bytes: OBSERVABILITY_RUNTIME_CONFIG.responseHistoryMaxBytes,
+      response_history_max_entries: OBSERVABILITY_RUNTIME_CONFIG.responseHistoryMaxEntries,
+    },
+  };
+}

package/src/request-context.mjs

@@ -0,0 +1,16 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+
+const requestContextStorage = new AsyncLocalStorage();
+
+export function createRequestId() {
+  return randomUUID();
+}
+
+export function runWithRequestContext(context, callback) {
+  return requestContextStorage.run(context, callback);
+}
+
+export function currentRequestContext() {
+  return requestContextStorage.getStore() || null;
+}

package/src/response-history.mjs

@@ -1,12 +1,8 @@
 import { httpError } from "./http-transport.mjs";
+import { loadRuntimeConfig, parsePositiveInteger, RUNTIME_DEFAULTS } from "./runtime-config.mjs";
 
-const DEFAULT_MAX_BYTES = 64 * 1024 * 1024;
-const DEFAULT_MAX_ENTRIES = 4096;
-
-function positiveInt(value, fallback) {
-  const n = Number.parseInt(value, 10);
-  return Number.isFinite(n) && n > 0 ? n : fallback;
-}
+const DEFAULT_MAX_BYTES = RUNTIME_DEFAULTS.responseHistoryMaxBytes;
+const DEFAULT_MAX_ENTRIES = RUNTIME_DEFAULTS.responseHistoryMaxEntries;
 
 function cloneJson(value) {
   return value === undefined ? undefined : structuredClone(value);
@@ -76,8 +72,9 @@ const childrenById = new Map();
 const treeLru = new Map();
 const evictedIds = new Set();
 let totalBytes = 0;
-let maxBytes = positiveInt(process.env.CCDX_RESPONSE_HISTORY_MAX_BYTES, DEFAULT_MAX_BYTES);
-let maxEntries = positiveInt(process.env.CCDX_RESPONSE_HISTORY_MAX_ENTRIES, DEFAULT_MAX_ENTRIES);
+const HISTORY_RUNTIME_CONFIG = loadRuntimeConfig();
+let maxBytes = HISTORY_RUNTIME_CONFIG.responseHistoryMaxBytes;
+let maxEntries = HISTORY_RUNTIME_CONFIG.responseHistoryMaxEntries;
 
 function rememberEvictedId(id) {
   evictedIds.add(id);
@@ -169,8 +166,8 @@ export function clearResponseHistoryForTests() {
 }
 
 export function configureResponseHistoryForTests({ maxBytes: nextMaxBytes, maxEntries: nextMaxEntries } = {}) {
-  if (nextMaxBytes !== undefined) maxBytes = positiveInt(nextMaxBytes, DEFAULT_MAX_BYTES);
-  if (nextMaxEntries !== undefined) maxEntries = positiveInt(nextMaxEntries, DEFAULT_MAX_ENTRIES);
+  if (nextMaxBytes !== undefined) maxBytes = parsePositiveInteger(nextMaxBytes, DEFAULT_MAX_BYTES);
+  if (nextMaxEntries !== undefined) maxEntries = parsePositiveInteger(nextMaxEntries, DEFAULT_MAX_ENTRIES);
 }
 
 export function responseHistoryStats() {