codex-copilot-dx 0.6.15 → 0.6.19

package/src/runtime-config.mjs

@@ -7,6 +7,8 @@ export const RUNTIME_DEFAULTS = Object.freeze({
   maxBodyBytes: 64 * 1024 * 1024,
   maxDecodedBodyBytes: 128 * 1024 * 1024,
   maxInflightBodyBytes: 32 * 1024 * 1024,
+  maxUpstreamChatResponseBytes: 64 * 1024 * 1024,
+  maxUpstreamResponsesResponseBytes: 256 * 1024 * 1024,
   maxQueuedRequests: 16,
   requestQueueTimeoutMs: 120 * 1000,
   responseHistoryMaxBytes: 64 * 1024 * 1024,
@@ -30,6 +32,14 @@ export function loadRuntimeConfig(env = process.env) {
     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),
+    maxUpstreamChatResponseBytes: parsePositiveInteger(
+      env.CCDX_MAX_UPSTREAM_CHAT_RESPONSE_BYTES,
+      RUNTIME_DEFAULTS.maxUpstreamChatResponseBytes,
+    ),
+    maxUpstreamResponsesResponseBytes: parsePositiveInteger(
+      env.CCDX_MAX_UPSTREAM_RESPONSES_RESPONSE_BYTES,
+      RUNTIME_DEFAULTS.maxUpstreamResponsesResponseBytes,
+    ),
     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),

package/src/token-counter-service.mjs

@@ -0,0 +1,188 @@
+import { Worker } from "node:worker_threads";
+import { anthropicTokenText } from "./anthropic.mjs";
+
+export const DEFAULT_TOKEN_COUNTER_TIMEOUT_MS = 120 * 1000;
+export const DEFAULT_TOKEN_COUNTER_MAX_QUEUED = 16;
+
+function serviceError(message, statusCode) {
+  return Object.assign(new Error(message), { statusCode });
+}
+
+function positiveInteger(value, fallback) {
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+
+function abortError(signal) {
+  if (signal?.reason instanceof Error) return signal.reason;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  return error;
+}
+
+export function tokenCounterWorkerExecArgv(execArgv = process.execArgv) {
+  const filtered = [];
+  for (let index = 0; index < execArgv.length; index += 1) {
+    const value = execArgv[index];
+    if (value === "--input-type") {
+      index += 1;
+      continue;
+    }
+    if (value.startsWith("--input-type=")) continue;
+    filtered.push(value);
+  }
+  return filtered;
+}
+
+function createTokenCounterWorker() {
+  const execArgv = tokenCounterWorkerExecArgv();
+  const options = execArgv.length === process.execArgv.length ? undefined : { execArgv };
+  return new Worker(new URL("./token-counter-worker.mjs", import.meta.url), options);
+}
+
+export function createTokenCounterService({
+  timeoutMs = DEFAULT_TOKEN_COUNTER_TIMEOUT_MS,
+  maxQueued = DEFAULT_TOKEN_COUNTER_MAX_QUEUED,
+  workerFactory = createTokenCounterWorker,
+} = {}) {
+  timeoutMs = positiveInteger(timeoutMs, DEFAULT_TOKEN_COUNTER_TIMEOUT_MS);
+  maxQueued = positiveInteger(maxQueued, DEFAULT_TOKEN_COUNTER_MAX_QUEUED);
+  const queue = [];
+  let worker = null;
+  let active = null;
+  let nextId = 1;
+  let closed = false;
+
+  const finish = (job, callback, value) => {
+    if (job.finished) return;
+    job.finished = true;
+    if (job.timer) clearTimeout(job.timer);
+    job.signal?.removeEventListener("abort", job.onAbort);
+    callback(value);
+  };
+
+  const retireWorker = () => {
+    const retired = worker;
+    worker = null;
+    if (!retired) return;
+    retired.removeAllListeners();
+    retired.on("error", () => {});
+    Promise.resolve(retired.terminate()).catch(() => {});
+  };
+
+  const pump = () => {
+    if (closed || active || queue.length === 0) return;
+    if (!worker) {
+      try {
+        worker = workerFactory();
+      } catch {
+        const job = queue.shift();
+        if (job) finish(job, job.reject, serviceError("Token counter worker failed", 500));
+        queueMicrotask(pump);
+        return;
+      }
+      worker.on("message", (message) => {
+        if (!active || message?.id !== active.id) return;
+        const job = active;
+        active = null;
+        if (message.error) {
+          retireWorker();
+          finish(job, job.reject, serviceError("Token counter worker failed", 500));
+        } else {
+          finish(job, job.resolve, message.result);
+        }
+        pump();
+      });
+      worker.on("error", () => {
+        const job = active;
+        active = null;
+        retireWorker();
+        if (job) finish(job, job.reject, serviceError("Token counter worker failed", 500));
+        pump();
+      });
+      worker.on("exit", () => {
+        const job = active;
+        active = null;
+        worker = null;
+        if (job) finish(job, job.reject, serviceError("Token counter worker failed", 500));
+        pump();
+      });
+      worker.unref?.();
+    }
+    const job = queue.shift();
+    if (!job || job.finished) return pump();
+    active = job;
+    try {
+      worker.postMessage({ id: job.id, text: job.text });
+      job.text = null;
+    } catch {
+      active = null;
+      retireWorker();
+      finish(job, job.reject, serviceError("Token counter worker failed", 500));
+      pump();
+    }
+  };
+
+  const cancel = (job, error) => {
+    if (job.finished) return;
+    const queuedIndex = queue.indexOf(job);
+    if (queuedIndex >= 0) queue.splice(queuedIndex, 1);
+    if (active === job) {
+      active = null;
+      retireWorker();
+    }
+    finish(job, job.reject, error);
+    pump();
+  };
+
+  return {
+    count(body, { signal, deadlineMs = timeoutMs } = {}) {
+      if (closed) return Promise.reject(serviceError("Token counter service is closed", 503));
+      if (signal?.aborted) return Promise.reject(abortError(signal));
+      let text;
+      try {
+        text = anthropicTokenText(body);
+      } catch {
+        return Promise.reject(serviceError("Invalid count_tokens request", 400));
+      }
+      if (active && queue.length >= maxQueued) {
+        return Promise.reject(serviceError(`Token counter queue is full (${maxQueued} waiting)`, 503));
+      }
+      return new Promise((resolve, reject) => {
+        deadlineMs = positiveInteger(deadlineMs, timeoutMs);
+        const job = {
+          id: nextId++,
+          text,
+          signal,
+          resolve,
+          reject,
+          finished: false,
+          timer: null,
+          onAbort: null,
+        };
+        job.onAbort = () => cancel(job, abortError(signal));
+        signal?.addEventListener("abort", job.onAbort, { once: true });
+        job.timer = setTimeout(() => {
+          cancel(job, serviceError(`Token counting timed out after ${deadlineMs}ms`, 504));
+        }, deadlineMs);
+        queue.push(job);
+        if (signal?.aborted) job.onAbort();
+        else pump();
+      });
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      const error = serviceError("Token counter service is closed", 503);
+      if (active) {
+        const job = active;
+        active = null;
+        finish(job, job.reject, error);
+      }
+      for (const job of queue.splice(0)) finish(job, job.reject, error);
+      retireWorker();
+    },
+    stats() {
+      return { active: active ? 1 : 0, queued: queue.length, worker: worker ? 1 : 0 };
+    },
+  };
+}

package/src/token-counter-worker.mjs

@@ -0,0 +1,10 @@
+import { parentPort } from "node:worker_threads";
+import { countTokenText } from "./anthropic.mjs";
+
+parentPort.on("message", async ({ id, text }) => {
+  try {
+    parentPort.postMessage({ id, result: await countTokenText(text) });
+  } catch {
+    parentPort.postMessage({ id, error: true });
+  }
+});

package/src/usage.mjs

@@ -150,7 +150,7 @@ export async function flushUsageWrites() {
   await writeQueue;
 }
 
-async function* iterateUsageRecords(filePath) {
+async function* iterateUsageRecords(filePath, { warn = console.error } = {}) {
   let input;
   try {
     input = fs.createReadStream(filePath, { encoding: "utf8" });
@@ -165,14 +165,31 @@ async function* iterateUsageRecords(filePath) {
   }
 
   const lines = readline.createInterface({ input, crlfDelay: Infinity });
+  let invalidRecords = 0;
   for await (const line of lines) {
-    if (line) yield JSON.parse(line);
+    if (!line) continue;
+    try {
+      const record = JSON.parse(line);
+      if (!record || typeof record !== "object" || Array.isArray(record)) {
+        invalidRecords += 1;
+        continue;
+      }
+      yield record;
+    } catch {
+      invalidRecords += 1;
+    }
+  }
+  if (invalidRecords > 0) {
+    try {
+      const safePath = terminalCell(JSON.stringify(filePath));
+      warn(`codex-copilot-dx usage log ignored ${invalidRecords} invalid record${invalidRecords === 1 ? "" : "s"} in ${safePath}`);
+    } catch {}
   }
 }
 
-export async function readUsageRecords(filePath = usageLogPath()) {
+export async function readUsageRecords(filePath = usageLogPath(), { warn = console.error } = {}) {
   const records = [];
-  for await (const record of iterateUsageRecords(filePath)) records.push(record);
+  for await (const record of iterateUsageRecords(filePath, { warn })) records.push(record);
   return records;
 }
 
@@ -200,10 +217,10 @@ export function summarizeUsage(records) {
   return summary;
 }
 
-export async function summarizeUsageLogs(filePath = usageLogPath()) {
+export async function summarizeUsageLogs(filePath = usageLogPath(), { warn = console.error } = {}) {
   const summary = { requests: 0, totals: {}, byModel: {} };
   for (const candidate of [rotatedFilePath(filePath), filePath]) {
-    for await (const record of iterateUsageRecords(candidate)) {
+    for await (const record of iterateUsageRecords(candidate, { warn })) {
       const one = summarizeUsage([record]);
       summary.requests += one.requests;
       addUsageTotals(summary.totals, one.totals);
@@ -324,7 +341,8 @@ export async function printUsageSummary({
   format = "auto",
   output = process.stdout,
   log = console.log,
+  warn = console.error,
 } = {}) {
-  const summary = await summarizeUsageLogs(filePath);
+  const summary = await summarizeUsageLogs(filePath, { warn });
   log(formatUsageSummary(summary, { filePath, format, output }));
 }