codex-copilot-dx 0.8.3 → 0.8.5

package/src/response-history.mjs

@@ -203,24 +203,51 @@ function makeRoomFor({ additionalBytes, additionalEntries, protectedRoots }) {
   return true;
 }
 
-export function clearResponseHistoryForTests() {
+export function clearResponseHistory() {
+  if (pinnedTrees.size > 0) {
+    const error = new Error("Response history is active; retry cleanup after current requests finish");
+    error.code = "ccdx_cache_busy";
+    throw error;
+  }
+  const removed = { entries: histories.size, bytes: totalBytes };
   histories.clear();
   childrenById.clear();
   treeLru.clear();
   pinnedTrees.clear();
   evictedIds.clear();
   totalBytes = 0;
+  return removed;
+}
+
+export function clearResponseHistoryForTests() {
+  clearResponseHistory();
   maxBytes = DEFAULT_MAX_BYTES;
   maxEntries = DEFAULT_MAX_ENTRIES;
 }
 
+export function setResponseHistoryMaxBytes(nextMaxBytes) {
+  const parsed = Number(nextMaxBytes);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+    throw new TypeError("Response history cache limit must be a positive safe integer");
+  }
+  if (parsed < totalBytes) {
+    const error = new Error(`Response history currently uses ${totalBytes} bytes, above the requested ${parsed}-byte limit`);
+    error.code = "ccdx_cache_limit_below_usage";
+    throw error;
+  }
+  const previousMaxBytes = maxBytes;
+  maxBytes = parsed;
+  return { previousMaxBytes, maxBytes };
+}
+
 export function configureResponseHistoryForTests({ maxBytes: nextMaxBytes, maxEntries: nextMaxEntries } = {}) {
   if (nextMaxBytes !== undefined) maxBytes = parsePositiveInteger(nextMaxBytes, DEFAULT_MAX_BYTES);
   if (nextMaxEntries !== undefined) maxEntries = parsePositiveInteger(nextMaxEntries, DEFAULT_MAX_ENTRIES);
 }
 
 export function responseHistoryStats() {
-  return { entries: histories.size, bytes: totalBytes, evicted: evictedIds.size };
+  return { entries: histories.size, bytes: totalBytes, evicted: evictedIds.size,
+    pinnedTrees: pinnedTrees.size, maxBytes, maxEntries };
 }
 
 export function responseHistoryRootId(responseId) {

package/src/responses-handler.mjs

@@ -89,9 +89,10 @@ function resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver) {
   return resolveOpenAIModel(model, openAIModelEnv, options);
 }
 
-function stripUnsupportedGpt6ServiceTier(body, requestedModel, upstreamModel) {
-  if (requestedModel === CODEX_GPT6_MODEL
+function stripUnsupportedGpt6ServiceTier(body, requestedModel, upstreamModel, priorityTierModel) {
+  if (requestedModel.startsWith("gpt-6-")
     && upstreamModel === requestedModel
+    && !priorityTierModel
     && body.service_tier === "priority") {
     delete body.service_tier;
   }
@@ -263,7 +264,7 @@ export function createResponsesHandler(options) {
         upstreamModel = priorityTierModel;
         delete prepared.body.service_tier;
       }
-      stripUnsupportedGpt6ServiceTier(prepared.body, requestedModel, upstreamModel);
+      stripUnsupportedGpt6ServiceTier(prepared.body, requestedModel, upstreamModel, priorityTierModel);
       if (requestedModel === CODEX_AUTO_REVIEW_MODEL) delete prepared.body.service_tier;
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
@@ -319,7 +320,7 @@ export function createResponsesHandler(options) {
               "Cache-Control": "no-cache",
               Connection: "keep-alive",
             });
-            const written = await writeOrDrain(res, `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+            const written = await writeOrDrain(res, `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`, { signal: abort.signal });
             if (!written) return false;
             if (event === "response.completed") {
               rememberResponseHistory(prepared, data.response);
@@ -516,7 +517,7 @@ export function createResponsesCompactHandler(options) {
         upstreamModel = priorityTierModel;
         delete prepared.body.service_tier;
       }
-      stripUnsupportedGpt6ServiceTier(prepared.body, requestedModel, upstreamModel);
+      stripUnsupportedGpt6ServiceTier(prepared.body, requestedModel, upstreamModel, priorityTierModel);
       if (requestedModel === CODEX_AUTO_REVIEW_MODEL) delete prepared.body.service_tier;
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;

package/src/responses-proxy.mjs

@@ -403,13 +403,13 @@ async function proxyStreamingResponses(opened, res, upstream, options) {
       const body = prelude.length === 1 ? prelude[0] : Buffer.concat(prelude, preludeBytes);
       prelude.length = 0;
       preludeBytes = 0;
-      return writeOrDrain(res, body);
+      return writeOrDrain(res, body, { signal: options.signal });
     };
     const forwardFrame = async (frame) => {
       if (!frame) return true;
       if (!holdPrelude) {
         writeHeaders();
-        return writeOrDrain(res, frame);
+        return writeOrDrain(res, frame, { signal: options.signal });
       }
       prelude.push(frame);
       preludeBytes += frame.byteLength;

package/src/running-adapter.mjs

@@ -3,9 +3,9 @@ import { localPackageVersion } from "./version.mjs";
 
 export const ADAPTER_HEALTH_PATH = "/_ccdx/health";
 export const ADAPTER_STATUS_PATH = "/_ccdx/status";
-export const ADAPTER_PROTOCOL_VERSION = 3;
+export const ADAPTER_PROTOCOL_VERSION = 4;
 export const ADAPTER_VERSION = localPackageVersion();
-export const ADAPTER_CAPABILITIES = Object.freeze([]);
+export const ADAPTER_CAPABILITIES = Object.freeze(["cache-control-v1"]);
 const ADAPTER_INSTANCE_ID = randomUUID();
 
 export function adapterHealthPayload() {

package/src/stream-errors.mjs

@@ -11,6 +11,10 @@ export async function endStreamWithError(res, error, abort) {
   markStreamFailure();
   if (res.destroyed || res.writableEnded) return;
   const data = streamErrorData(error, abort);
-  await writeOrDrain(res, `event: error\ndata: ${JSON.stringify(data)}\n\n`).catch(() => false);
+  // Allow a final error frame after an upstream timeout, but never wait forever
+  // for a client that has stopped reading (including protocol-error paths).
+  await writeOrDrain(res, `event: error\ndata: ${JSON.stringify(data)}\n\n`, {
+    signal: AbortSignal.timeout(1000),
+  }).catch(() => false);
   if (!res.destroyed && !res.writableEnded) res.end();
 }

package/src/usage.mjs

@@ -3,7 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
 import { cliOutputFormat, cliOutputWidth, formatResponsiveCliTable, terminalCell } from "./cli-table.mjs";
-import { parseByteLimit, rotateFileIfNeededSync, rotatedFilePath } from "./file-rotation.mjs";
+import { appendRotatingLines, parseByteLimit, rotatedFilePath } from "./file-rotation.mjs";
 import { withFileLock } from "./lock.mjs";
 
 const DEFAULT_USAGE_PATH = path.join(os.homedir(), ".local", "share", "codex-copilot-dx", "usage.jsonl");
@@ -15,6 +15,17 @@ const USAGE_FLUSH_TIMEOUT_MS = 1_500;
 
 const pendingWrites = [];
 let writeDrain = null;
+const USAGE_QUEUE_MAX_RECORDS = 4096;
+const USAGE_QUEUE_MAX_BYTES = 4 * 1024 * 1024;
+let pendingRecords = 0;
+let pendingBytes = 0;
+let droppedRecords = 0;
+let writeFailures = 0;
+
+export function usageLoggingStats() {
+  return { pending_records: pendingRecords, pending_bytes: pendingBytes, dropped_records: droppedRecords,
+    write_failures: writeFailures, max_records: USAGE_QUEUE_MAX_RECORDS, max_bytes: USAGE_QUEUE_MAX_BYTES };
+}
 
 export function usageLogPath() {
   return process.env.CCDX_USAGE_PATH || DEFAULT_USAGE_PATH;
@@ -114,10 +125,7 @@ async function writeUsageBatch(batch) {
   await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
   await withFileLock(`${path.resolve(filePath)}.lock`, async () => {
     batch.push(...takePendingWrites(filePath, maxBytes));
-    for (const { line } of batch) {
-      rotateFileIfNeededSync(filePath, Buffer.byteLength(line), maxBytes);
-      await fs.promises.appendFile(filePath, line, { encoding: "utf8", mode: 0o600 });
-    }
+    await appendRotatingLines(filePath, batch.map(({ line }) => line), maxBytes);
   }, {
     timeoutMs: USAGE_WRITE_LOCK_TIMEOUT_MS,
     staleMs: USAGE_WRITE_LOCK_STALE_MS,
@@ -134,10 +142,15 @@ function scheduleUsageWriteDrain() {
       try {
         await writeUsageBatch(batch);
       } catch (error) {
+        writeFailures += 1;
         batch.push(...takePendingWrites(first.filePath, first.maxBytes));
         console.error(`codex-copilot-dx usage log write failed: ${error.message}`);
       } finally {
-        for (const entry of batch) entry.resolve();
+        for (const entry of batch) {
+          pendingRecords -= 1;
+          pendingBytes -= entry.bytes;
+          entry.resolve();
+        }
       }
     }
   }).finally(() => {
@@ -150,8 +163,16 @@ export function recordUsage(record) {
   if (!record || process.env.CCDX_DISABLE_USAGE === "1") return Promise.resolve();
   const filePath = usageLogPath();
   const line = `${JSON.stringify(record)}\n`;
+  const bytes = Buffer.byteLength(line);
+  if (pendingRecords >= USAGE_QUEUE_MAX_RECORDS || pendingBytes + bytes > USAGE_QUEUE_MAX_BYTES) {
+    droppedRecords += 1;
+    if (droppedRecords === 1) console.error("codex-copilot-dx usage queue is full; excess usage records are dropped, inference is unaffected (see ccdx status)");
+    return Promise.resolve();
+  }
+  pendingRecords += 1;
+  pendingBytes += bytes;
   const completed = new Promise((resolve) => {
-    pendingWrites.push({ filePath, line, maxBytes: usageLogMaxBytes(), resolve });
+    pendingWrites.push({ filePath, line, bytes, maxBytes: usageLogMaxBytes(), resolve });
   });
   scheduleUsageWriteDrain();
   return completed;

package/src/user-settings.mjs

@@ -3,6 +3,13 @@ import os from "node:os";
 import path from "node:path";
 import { atomicWriteFileIfChangedSync } from "./atomic-file.mjs";
 import { DEFAULT_CODEX_AUTO_REVIEW_MODEL } from "./models.mjs";
+import { loadRuntimeConfig } from "./runtime-config.mjs";
+import {
+  MIB,
+  RESPONSE_HISTORY_DEFAULT_MIB,
+  RESPONSE_HISTORY_MAX_MIB,
+  RESPONSE_HISTORY_MIN_MIB,
+} from "./cache-limits.mjs";
 import {
   DEFAULT_TERMINAL_ANIMATION_THEME,
   isTerminalAnimationTheme,
@@ -11,6 +18,8 @@ import {
 
 const AUTO_REVIEW_MODEL_KEY = "auto_review_model";
 const TERMINAL_ANIMATION_KEY = "terminal_animation";
+const RESPONSE_HISTORY_MAX_MIB_KEY = "response_history_max_mib";
+export { RESPONSE_HISTORY_MAX_MIB, RESPONSE_HISTORY_MIN_MIB };
 
 export function userSettingsPath({ env = process.env, home = os.homedir() } = {}) {
   const xdgConfigHome = String(env.XDG_CONFIG_HOME || "").trim();
@@ -46,6 +55,17 @@ export function readUserSettings({ env = process.env, home = os.homedir(), stric
         delete parsed[TERMINAL_ANIMATION_KEY];
       }
     }
+    if (Object.hasOwn(parsed, RESPONSE_HISTORY_MAX_MIB_KEY)) {
+      const value = parsed[RESPONSE_HISTORY_MAX_MIB_KEY];
+      if (!Number.isSafeInteger(value)
+        || value < RESPONSE_HISTORY_MIN_MIB
+        || value > RESPONSE_HISTORY_MAX_MIB) {
+        if (strict) {
+          throw invalidSettings(filePath, `${RESPONSE_HISTORY_MAX_MIB_KEY} must be an integer from ${RESPONSE_HISTORY_MIN_MIB} to ${RESPONSE_HISTORY_MAX_MIB}`);
+        }
+        delete parsed[RESPONSE_HISTORY_MAX_MIB_KEY];
+      }
+    }
     return parsed;
   } catch (error) {
     if (error?.code === "ENOENT") return {};
@@ -83,6 +103,39 @@ export function terminalAnimationPreference({ env = process.env, home = os.homed
   return { theme: DEFAULT_TERMINAL_ANIMATION_THEME, source: "default" };
 }
 
+export function responseHistoryLimitPreference({ env = process.env, home = os.homedir() } = {}) {
+  const environment = String(env.CCDX_RESPONSE_HISTORY_MAX_BYTES || "").trim();
+  if (environment) {
+    return { bytes: loadRuntimeConfig(env).responseHistoryMaxBytes, source: "environment" };
+  }
+  const settings = readUserSettings({ env, home });
+  const mib = settings[RESPONSE_HISTORY_MAX_MIB_KEY];
+  if (Number.isSafeInteger(mib)) return { bytes: mib * MIB, mib, source: "settings" };
+  return { bytes: RESPONSE_HISTORY_DEFAULT_MIB * MIB, mib: RESPONSE_HISTORY_DEFAULT_MIB, source: "default" };
+}
+
+export function writeResponseHistoryLimitMib(mib, { env = process.env, home = os.homedir() } = {}) {
+  const filePath = userSettingsPath({ env, home });
+  const settings = readUserSettings({ env, home, strict: true });
+  const next = { ...settings };
+  if (mib === null || mib === undefined || mib === "") {
+    if (!Object.hasOwn(next, RESPONSE_HISTORY_MAX_MIB_KEY)) {
+      return { changed: false, filePath, ...responseHistoryLimitPreference({ env, home }) };
+    }
+    delete next[RESPONSE_HISTORY_MAX_MIB_KEY];
+  } else {
+    const parsed = Number(mib);
+    if (!Number.isSafeInteger(parsed)
+      || parsed < RESPONSE_HISTORY_MIN_MIB
+      || parsed > RESPONSE_HISTORY_MAX_MIB) {
+      throw new Error(`History cache limit must be an integer from ${RESPONSE_HISTORY_MIN_MIB} to ${RESPONSE_HISTORY_MAX_MIB} MiB`);
+    }
+    next[RESPONSE_HISTORY_MAX_MIB_KEY] = parsed;
+  }
+  const changed = atomicWriteFileIfChangedSync(filePath, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+  return { changed, filePath, ...responseHistoryLimitPreference({ env, home }) };
+}
+
 export function writeAutoReviewModel(model, { env = process.env, home = os.homedir() } = {}) {
   const filePath = userSettingsPath({ env, home });
   const settings = readUserSettings({ env, home, strict: true });