codex-copilot-dx 0.9.12 → 0.9.14

package/src/responses-handler.mjs

@@ -16,6 +16,7 @@ import {
   CODEX_AUTO_REVIEW_MODEL,
   modelIsResponsesOnly,
   modelSupportsChatCompletions,
+  modelContextWindowTokens,
   resolveCopilotPriorityTierModel,
   resolveOpenAIModel,
 } from "./models.mjs";
@@ -35,11 +36,13 @@ import {
 import { createRoutePlan } from "./route-plan.mjs";
 import { status } from "./status.mjs";
 import { endStreamWithError } from "./stream-errors.mjs";
+import { createSseKeepalive } from "./sse-keepalive.mjs";
 import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
 import { recordResponsesUsage } from "./usage.mjs";
 import {
   markResponseErrorOrigin,
   markResponseModel,
+  markRequestObservation,
   markResponseTerminal,
   markUpstreamHeaders,
   measureRequestStage,
@@ -90,10 +93,13 @@ function unsupportedCustomToolsError(model) {
 }
 
 function resolveRequestModel(model, openAIModelEnv, autoReviewModelResolver) {
-  const options = model === CODEX_AUTO_REVIEW_MODEL && typeof autoReviewModelResolver === "function"
-    ? { autoReviewModel: autoReviewModelResolver() }
-    : {};
-  return resolveOpenAIModel(model, openAIModelEnv, options);
+  const preference = model === CODEX_AUTO_REVIEW_MODEL && typeof autoReviewModelResolver === "function"
+    ? autoReviewModelResolver() : undefined;
+  const resolved = resolveOpenAIModel(model, openAIModelEnv, {
+    autoReviewModel: typeof preference === "string" ? preference : preference?.model,
+  });
+  return { ...resolved, reasoningEffort: preference?.model === resolved.upstreamModel
+    ? preference.reasoningEffort : undefined };
 }
 
 function stripUnsupportedGpt6ServiceTier(body, requestedModel, upstreamModel, priorityTierModel) {
@@ -112,6 +118,7 @@ export function createResponsesHandler(options) {
     chatCompletionsFn,
     getCachedModelEndpointsFn = getCachedModelEndpoints,
     imagePressure,
+    keepaliveIntervalMs,
     modelRegistry,
     openAIModelEnv,
     requestBodyTimeoutMs,
@@ -274,12 +281,13 @@ export function createResponsesHandler(options) {
       stripUnsupportedGpt6ServiceTier(prepared.body, requestedModel, upstreamModel, priorityTierModel);
       if (requestedModel === CODEX_AUTO_REVIEW_MODEL) {
         delete prepared.body.service_tier;
-        if (prepared.body.reasoning?.effort === undefined) {
-          prepared.body.reasoning = { ...prepared.body.reasoning, effort: "low" };
+        if (resolvedModel.reasoningEffort || prepared.body.reasoning?.effort === undefined) {
+          prepared.body.reasoning = { ...prepared.body.reasoning, effort: resolvedModel.reasoningEffort || "low" };
         }
       }
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
       markResponseModel(upstreamModel);
+      markRequestObservation({ context_window_tokens: modelContextWindowTokens(modelRegistry?.models, upstreamModel) });
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
       console.log(status("info", `responses model=${requestedModel}${upstreamLog} stream=${streaming}`));
       const usesCustomTools = responsesBodyUsesCustomTools(prepared.body);
@@ -310,6 +318,7 @@ export function createResponsesHandler(options) {
           releaseRequest: releaseUpstreamPayload,
           responseFailures,
           streamIdleTimeoutMs,
+          keepaliveIntervalMs,
         });
         if (result?.successful) imagePressure?.markSuccess?.(responseHistoryPressureRootId(prepared));
         else markAdaptiveHttpTimeout(result?.upstreamStatus);
@@ -327,12 +336,15 @@ export function createResponsesHandler(options) {
         };
         if (streaming) {
           let streamResponseHeaders = null;
-          const successful = await forwardToChat(chatReq, async (event, data) => {
+          const keepalive = createSseKeepalive({ res, signal: abort.signal, intervalMs: keepaliveIntervalMs });
+          let successful;
+          try { successful = await forwardToChat(chatReq, async (event, data) => {
             if (!res.headersSent) res.writeHead(200, {
               ...streamResponseHeaders,
               "Cache-Control": "no-cache",
               Connection: "keep-alive",
             });
+            keepalive.activity();
             const written = await writeOrDrain(res, `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`, { signal: abort.signal });
             if (!written) return false;
             if (event === "response.completed" || event === "response.incomplete") {
@@ -367,7 +379,7 @@ export function createResponsesHandler(options) {
                 contentType: "text/event-stream",
               });
             },
-          });
+          }); } finally { keepalive.stop(); }
           if (successful) imagePressure?.markSuccess?.(responseHistoryPressureRootId(prepared));
         } else {
           try {
@@ -544,11 +556,12 @@ export function createResponsesCompactHandler(options) {
       stripUnsupportedGpt6ServiceTier(prepared.body, requestedModel, upstreamModel, priorityTierModel);
       if (requestedModel === CODEX_AUTO_REVIEW_MODEL) {
         delete prepared.body.service_tier;
-        if (prepared.body.reasoning?.effort === undefined) {
-          prepared.body.reasoning = { ...prepared.body.reasoning, effort: "low" };
+        if (resolvedModel.reasoningEffort || prepared.body.reasoning?.effort === undefined) {
+          prepared.body.reasoning = { ...prepared.body.reasoning, effort: resolvedModel.reasoningEffort || "low" };
         }
       }
       if (upstreamModel !== requestedModel) prepared.body.model = upstreamModel;
+      markRequestObservation({ context_window_tokens: modelContextWindowTokens(modelRegistry?.models, upstreamModel) });
       const upstreamLog = upstreamModel === requestedModel ? "" : ` upstream_model=${upstreamModel}`;
       console.log(status("info", `responses compact model=${requestedModel}${upstreamLog} stream=false`));
       prepared = applyResponseHistoryRoutePlan(prepared, createRoutePlan({

package/src/responses-proxy.mjs

@@ -30,6 +30,7 @@ import {
 } from "./responses-compaction.mjs";
 import { loadRuntimeConfig } from "./runtime-config.mjs";
 import { endStreamWithError } from "./stream-errors.mjs";
+import { createSseKeepalive } from "./sse-keepalive.mjs";
 import {
   incompleteUpstreamStream,
   invalidUpstreamStream,
@@ -40,6 +41,7 @@ import {
   isResponsesOutputEvent,
   markFirstOutput,
   markOutputTokens,
+  markRequestObservation,
   markResponseErrorOrigin,
   markResponseTerminal,
   markStreamFailure,
@@ -123,6 +125,8 @@ function inspectResponseSseEvent(state, eventName, data) {
   const changed = normalizeMessageIds(state, event, eventType);
   const outputTokens = event.response?.usage?.output_tokens ?? event.usage?.output_tokens;
   if (outputTokens !== undefined) markOutputTokens(outputTokens);
+  const inputTokens = event.response?.usage?.input_tokens ?? event.usage?.input_tokens;
+  if (inputTokens !== undefined) markRequestObservation({ input_tokens: inputTokens });
   if (!state.sawOutput && isResponsesOutputEvent(event, eventType)) {
     state.sawOutput = true;
     markFirstOutput();
@@ -404,18 +408,23 @@ async function proxyStreamingResponses(opened, res, upstream, options) {
     let retryDisabledReason = holdPrelude ? null : "request_not_eligible";
     const prelude = [];
     let preludeBytes = 0;
+    const keepalive = createSseKeepalive({ res, signal: options.signal,
+      intervalMs: options.keepaliveIntervalMs,
+      canWrite: () => !holdPrelude && !streamState.sawTerminal });
     const flushPrelude = async () => {
       if (!preludeBytes) return true;
       writeHeaders();
       const body = prelude.length === 1 ? prelude[0] : Buffer.concat(prelude, preludeBytes);
       prelude.length = 0;
       preludeBytes = 0;
+      keepalive.activity();
       return writeOrDrain(res, body, { signal: options.signal });
     };
     const forwardFrame = async (frame) => {
       if (!frame) return true;
       if (!holdPrelude) {
         writeHeaders();
+        keepalive.activity();
         return writeOrDrain(res, frame, { signal: options.signal });
       }
       prelude.push(frame);
@@ -502,6 +511,7 @@ async function proxyStreamingResponses(opened, res, upstream, options) {
       await endStreamWithError(res, error, options.abort);
       return { successful: false, compacted: false };
     } finally {
+      keepalive.stop();
       await reader.cancel().catch(() => {});
       reader.releaseLock();
     }

package/src/sse-keepalive.mjs

@@ -0,0 +1,42 @@
+export const SSE_KEEPALIVE_INTERVAL_MS = 15_000;
+
+// Downstream-only SSE comments. Never read upstream, alter its deadlines, or
+// write before valid stream headers / between pieces of a partially written frame.
+export function createSseKeepalive({
+  res, signal, canWrite = () => true, intervalMs = SSE_KEEPALIVE_INTERVAL_MS,
+  now = Date.now, setTimer = setTimeout, clearTimer = clearTimeout,
+} = {}) {
+  let timer = null;
+  let stopped = false;
+  let lastWrite = now();
+  const stop = () => {
+    stopped = true;
+    if (timer !== null) clearTimer(timer);
+    timer = null;
+    signal?.removeEventListener("abort", stop);
+  };
+  const schedule = (delay) => {
+    timer = setTimer(tick, Math.max(1, delay));
+    timer?.unref?.();
+  };
+  const tick = () => {
+    timer = null;
+    if (stopped || signal?.aborted || res?.destroyed || res?.writableEnded) return stop();
+    const idle = Math.max(0, now() - lastWrite);
+    try {
+      if (idle >= intervalMs && res?.headersSent && !res.writableNeedDrain && canWrite()) {
+        // One small, complete comment is bounded even if this write reaches the
+        // high-water mark; no further comments are sent while backpressured.
+        res.write(": ccdx keepalive\n\n");
+        lastWrite = now();
+      }
+    } catch { return stop(); }
+    const elapsed = Math.max(0, now() - lastWrite);
+    schedule(elapsed >= intervalMs ? intervalMs : intervalMs - elapsed);
+  };
+  if (Number.isFinite(intervalMs) && intervalMs > 0 && !signal?.aborted) {
+    signal?.addEventListener("abort", stop, { once: true });
+    schedule(intervalMs);
+  }
+  return { activity: () => { lastWrite = now(); }, stop };
+}

package/src/stream-performance.mjs

@@ -159,6 +159,7 @@ export function createStreamPerformanceMetrics({ now = () => performance.now(),
       let headersAt = null;
       let lastActivityAt = null;
       let terminalAt = null;
+      const context = { payload_bytes: null, images: null, input_tokens: null, context_window_tokens: null };
       const elapsed = (time) => time === null ? null : Number(Math.max(0, time - requestStartedAt).toFixed(1));
 
       return {
@@ -205,6 +206,13 @@ export function createStreamPerformanceMetrics({ now = () => performance.now(),
         setModel(value) {
           model = modelLabel(value);
         },
+        observeContext(values) {
+          if (finished || !values || typeof values !== "object") return;
+          for (const key of Object.keys(context)) {
+            const value = values[key];
+            if (Number.isSafeInteger(value) && value >= 0 && (key !== "context_window_tokens" || value > 0)) context[key] = value;
+          }
+        },
         setErrorOrigin(value) {
           if (TERMINAL_ORIGINS.has(value)) errorOrigin = value;
         },
@@ -242,6 +250,7 @@ export function createStreamPerformanceMetrics({ now = () => performance.now(),
             failed: failed || aborted || (terminalOutcome !== null && terminalOutcome !== "completed"),
             http_status: Number.isInteger(statusCode) && statusCode >= 100 && statusCode <= 599 ? statusCode : null,
             upstream_attempts: attempts,
+            context: { ...context },
             timings_ms: {
               ...Object.fromEntries(PREPARATION_STAGES.map((stage) => [stage, Number(preparationMs[stage].toFixed(1))])),
               upstream_start: elapsed(firstAttemptAt), upstream_headers: elapsed(headersAt),
@@ -272,7 +281,7 @@ export function createStreamPerformanceMetrics({ now = () => performance.now(),
     snapshot() {
       return {
         by_route: Object.fromEntries(PERFORMANCE_ROUTES.map((name) => [name, routeSnapshot(routes[name])])),
-        recent_requests: recentRequests.map((entry) => ({ ...entry, timings_ms: { ...entry.timings_ms } })),
+        recent_requests: recentRequests.map((entry) => ({ ...entry, context: { ...entry.context }, timings_ms: { ...entry.timings_ms } })),
       };
     },
   };
@@ -320,6 +329,10 @@ export function markOutputTokens(value) {
   tracker()?.setOutputTokens(value);
 }
 
+export function markRequestObservation(values) {
+  tracker()?.observeContext?.(values);
+}
+
 export function markStreamFailure() {
   tracker()?.fail();
 }

package/src/usage.mjs

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import { markRequestObservation } from "./stream-performance.mjs";
 import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
@@ -180,6 +181,8 @@ export function recordUsage(record) {
 }
 
 export function recordResponsesUsage(args) {
+  const response = args.response || args.event?.response || args.event;
+  markRequestObservation({ input_tokens: response?.usage?.input_tokens });
   return recordUsage(buildResponsesUsageRecord(args));
 }
 

package/src/user-settings.mjs

@@ -2,7 +2,7 @@ import fs from "node:fs";
 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 { AUTO_REVIEW_REASONING_EFFORTS, DEFAULT_CODEX_AUTO_REVIEW_MODEL } from "./models.mjs";
 import { loadRuntimeConfig, RUNTIME_DEFAULTS } from "./runtime-config.mjs";
 import {
   MIB,
@@ -17,6 +17,7 @@ import {
 } from "./terminal-animation.mjs";
 
 const AUTO_REVIEW_MODEL_KEY = "auto_review_model";
+const AUTO_REVIEW_REASONING_KEY = "auto_review_reasoning";
 const TERMINAL_ANIMATION_KEY = "terminal_animation";
 const RESPONSE_HISTORY_MAX_MIB_KEY = "response_history_max_mib";
 const DECODED_BODY_LIMIT_MIB_KEY = "decoded_body_limit_mib";
@@ -47,6 +48,15 @@ export function readUserSettings({ env = process.env, home = os.homedir(), stric
         throw invalidSettings(filePath, `${AUTO_REVIEW_MODEL_KEY} must be a non-empty string`);
       }
     }
+    if (Object.hasOwn(parsed, AUTO_REVIEW_REASONING_KEY)) {
+      const value = parsed[AUTO_REVIEW_REASONING_KEY];
+      if (!value || typeof value !== "object" || Array.isArray(value)
+        || typeof value.model !== "string" || !value.model.trim()
+        || !(value.effort === null || AUTO_REVIEW_REASONING_EFFORTS.includes(value.effort))) {
+        if (strict) throw invalidSettings(filePath, `${AUTO_REVIEW_REASONING_KEY} must contain a model and valid effort`);
+        delete parsed[AUTO_REVIEW_REASONING_KEY];
+      }
+    }
     if (Object.hasOwn(parsed, TERMINAL_ANIMATION_KEY)) {
       const value = parsed[TERMINAL_ANIMATION_KEY];
       // Accept the retired value on read so upgrades can fall back and select a replacement.
@@ -97,12 +107,18 @@ export function savedAutoReviewModel(options = {}) {
 }
 
 export function autoReviewModelPreference({ env = process.env, home = os.homedir() } = {}) {
-  const environmentModel = String(env.CCDX_AUTO_REVIEW_MODEL || "").trim();
-  if (environmentModel) return { model: environmentModel, source: "environment" };
+  const { model, source } = autoReviewPreference({ env, home });
+  return { model, source };
+}
 
-  const savedModel = savedAutoReviewModel({ env, home });
-  if (savedModel) return { model: savedModel, source: "settings" };
-  return { model: DEFAULT_CODEX_AUTO_REVIEW_MODEL, source: "default" };
+export function autoReviewPreference({ env = process.env, home = os.homedir() } = {}) {
+  const settings = readUserSettings({ env, home });
+  const environmentModel = String(env.CCDX_AUTO_REVIEW_MODEL || "").trim();
+  const savedModel = String(settings[AUTO_REVIEW_MODEL_KEY] || "").trim();
+  const model = environmentModel || savedModel || DEFAULT_CODEX_AUTO_REVIEW_MODEL;
+  const source = environmentModel ? "environment" : savedModel ? "settings" : "default";
+  const reasoning = settings[AUTO_REVIEW_REASONING_KEY];
+  return { model, source, reasoningEffort: reasoning?.model === model ? reasoning.effort : undefined };
 }
 
 export function savedTerminalAnimationTheme(options = {}) {
@@ -183,13 +199,22 @@ export function writeResponseHistoryLimitMib(mib, { env = process.env, home = os
   return { changed, filePath, ...responseHistoryLimitPreference({ env, home }) };
 }
 
-export function writeAutoReviewModel(model, { env = process.env, home = os.homedir() } = {}) {
+export function writeAutoReviewModel(model, { env = process.env, home = os.homedir(), reasoningEffort } = {}) {
+  if (reasoningEffort !== undefined && reasoningEffort !== null
+    && !AUTO_REVIEW_REASONING_EFFORTS.includes(reasoningEffort)) {
+    throw new Error("Auto-review reasoning effort is invalid");
+  }
   const filePath = userSettingsPath({ env, home });
   const settings = readUserSettings({ env, home, strict: true });
   const value = String(model || "").trim();
   const next = { ...settings };
   if (value) next[AUTO_REVIEW_MODEL_KEY] = value;
   else delete next[AUTO_REVIEW_MODEL_KEY];
+  const selectedModel = value || DEFAULT_CODEX_AUTO_REVIEW_MODEL;
+  if (reasoningEffort !== undefined) next[AUTO_REVIEW_REASONING_KEY] = { model: selectedModel, effort: reasoningEffort };
+  else if (next[AUTO_REVIEW_REASONING_KEY]?.model !== selectedModel) {
+    delete next[AUTO_REVIEW_REASONING_KEY];
+  }
 
   const changed = atomicWriteFileIfChangedSync(filePath, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
   return { changed, filePath, model: value || DEFAULT_CODEX_AUTO_REVIEW_MODEL };