codex-copilot-dx 0.9.13 → 0.9.14

package/src/cli-options.mjs

@@ -344,7 +344,7 @@ function topicHelp(name, topic) {
     start: `Usage:\n  ${name} [start] [--show-request-id]\n\nStarts or reuses the local adapter, updates Codex configuration, and attempts to open Codex App when auto-launch is enabled and supported.`,
     auth: `Usage:\n  ${name} auth status [--online] [--format table|plain]\n\nShows the saved GitHub Copilot account without exposing credentials. --online also verifies its entitlement and model catalog.`,
     "auth status": `Usage:\n  ${name} auth status [--online] [--format table|plain]\n\nShows the saved GitHub Copilot account without exposing credentials. --online also verifies its entitlement and model catalog. Interactive terminals use a table by default.`,
-    doctor: `Usage:\n  ${name} doctor [--online] [--compat]\n  ${name} doctor config\n\nChecks the local credential, Codex configuration, and adapter. --online validates account entitlement; --compat sends minimal inference requests and consumes a small amount of Copilot usage. The config subcommand checks only the local file and previews startup changes, without network, authentication, or file writes.`,
+    doctor: `Usage:\n  ${name} doctor [--online] [--compat]\n  ${name} doctor config\n\nChecks the local credential, Codex configuration, adapter, installed App version, running App identities and observed client catalog. App-internal cache is not externally verified. No processes are killed or client files changed. --online validates account entitlement; --compat sends minimal inference requests and consumes a small amount of Copilot usage. The config subcommand checks only the local file and previews startup changes, without network, authentication, file writes or process inspection.`,
     "doctor config": `Usage:\n  ${name} doctor config\n\nReads ~/.codex/config.toml, checks TOML syntax and CCDX-managed settings, and previews the existing startup writer's changes. Does not merge Codex profiles or validate the complete installed Codex schema. No authentication, network requests, file writes, or adapter/GUI startup. Existing context_management=false is valid. Exit 1 for errors, 0 for OK/warnings; unsupported arguments exit 2.`,
     status: `Usage:\n  ${name} status\n\nShows bounded runtime, routing, performance, queue, and cache metrics from a running adapter.`,
     models: `Usage:\n  ${name} models [--format table|plain]\n\nPerforms a fresh, read-only Copilot model-directory lookup for the saved account. Interactive terminals use a table by default.`,

package/src/cli-status.mjs

@@ -195,5 +195,8 @@ export function formatAdapterStatus({ baseUrl, data }, { commandName = "ccdx", c
     lines.push(status("info", `Routing: /v1/responses -> ${routingTarget(data.routing.responses)}`));
   }
   lines.push(status("info", `Limits: request body ${mebibytes(limits.max_body_bytes)}, decoded body ${mebibytes(limits.max_decoded_body_bytes)}`));
+  const recentContext = data.stream_performance?.recent_requests?.at(-1)?.context;
+  const contextValue = (value, format) => value === null || value === undefined ? "n/a" : format(value);
+  if (recentContext) lines.push(status("info", `Latest request context: wire ${contextValue(recentContext.payload_bytes, mebibytes)}, ${contextValue(recentContext.images, count)} images, input ${contextValue(recentContext.input_tokens, count)} tokens / window ${contextValue(recentContext.context_window_tokens, count)} (reported metadata, not live session occupancy)`));
   return lines.join("\n");
 }

package/src/codex-client-doctor.mjs

@@ -0,0 +1,67 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { readAdapterStatus } from "./cli-status.mjs";
+
+export function parseRunningCodexApps(stdout) {
+  const apps = new Map();
+  for (const line of String(stdout).split("\n")) {
+    const match = /^\s*(\d+)\s+.*\/(ChatGPT|Codex)\.app\/Contents\//.exec(line);
+    if (!match) continue;
+    const name = `${match[2]}.app`;
+    const pids = apps.get(name) || [];
+    if (pids.length < 8) pids.push(Number(match[1]));
+    apps.set(name, pids);
+  }
+  return [...apps].map(([name, pids]) => ({ name, pids }));
+}
+
+export async function inspectCodexClient({
+  home = os.homedir(), platform = process.platform, running,
+  host, port, fetchImpl = fetch, readFileFn = fs.readFileSync,
+  execFileFn = promisify(execFile), readStatus = readAdapterStatus,
+} = {}) {
+  const checks = [];
+  if (platform === "darwin") {
+    const seen = new Set();
+    for (const root of ["/Applications", path.join(home, "Applications")]) {
+      for (const name of ["ChatGPT.app", "Codex.app"]) {
+        try {
+          const plist = readFileFn(path.join(root, name, "Contents", "Info.plist"), "utf8");
+          const version = /<key>CFBundleShortVersionString<\/key>\s*<string>([0-9A-Za-z.+_-]{1,64})<\/string>/.exec(plist)?.[1];
+          if (version && !seen.has(`${name}/${version}`)) {
+            checks.push({ kind: "info", message: `Installed ${name}: App version ${version}` });
+            seen.add(`${name}/${version}`);
+          }
+        } catch {}
+      }
+    }
+    try {
+      // comm contains executable names, never command-line arguments or environments.
+      const { stdout } = await execFileFn("ps", ["-axo", "pid=,comm="], { timeout: 1500, maxBuffer: 256 * 1024, encoding: "utf8" });
+      const apps = parseRunningCodexApps(stdout);
+      for (const app of apps) checks.push({ kind: "info", message: `Running ${app.name}: PID ${app.pids.join(", ")}; fully quit with Command-Q before reopening (closing the window may keep it running)` });
+      if (!apps.length) checks.push({ kind: "info", message: "No running Codex/ChatGPT App process observed" });
+    } catch { checks.push({ kind: "info", message: "Running Codex App processes could not be inspected" }); }
+  }
+  if (running?.ok || running?.incompatible) {
+    try {
+      const { data } = await readStatus({ host, port, fetchImpl, timeoutMs: 1500 });
+      const source = ["live", "cache", "built-in"].includes(data.models?.source) ? data.models.source : "unknown";
+      checks.push({ kind: "info", message: `Running adapter ${data.version}; upstream model directory source: ${source}` });
+      const catalog = data.models?.client_catalog;
+      const observed = catalog?.last_request;
+      if (!catalog) {
+        checks.push({ kind: "info", message: "Running adapter does not expose client-catalog diagnostics; upgrade and restart CCDX" });
+      } else if (observed) {
+        const version = /^[0-9]+\.[0-9]+\.[0-9]+$/.test(observed.client_version || "") ? observed.client_version : "unknown";
+        const app = ["ChatGPT.app", "Codex.app", "custom binary"].includes(observed.application) ? observed.application : "unknown App";
+        checks.push({ kind: "info", message: `Last catalog request: client ${version}, ${app}, ${observed.source === "bundled" ? "bundled" : "unavailable"}; version match ${observed.matched === true ? "observed" : "not verified"}` });
+      } else checks.push({ kind: "info", message: "No client model-catalog request observed by this adapter" });
+    } catch { checks.push({ kind: "info", message: "Client model-catalog diagnostics unavailable from the running adapter" }); }
+  }
+  checks.push({ kind: "info", message: "App-internal model cache is not externally verified; process age alone does not prove a stale catalog" });
+  return checks;
+}

package/src/codex-model-catalog.mjs

@@ -248,6 +248,7 @@ export function createCodexModelCatalog({
   const catalogFailures = new Map();
   const catalogPending = new Map();
   let activeBinaryKeys = new Set();
+  let lastObservation = null;
 
   function retainCurrentEntries(map) {
     for (const key of map.keys()) {
@@ -341,8 +342,21 @@ export function createCodexModelCatalog({
 
   async function load({ clientVersion = "" } = {}) {
     const candidate = await selectBinary(clientVersion);
-    return candidate ? loadCatalog(candidate) : null;
+    const catalog = candidate ? await loadCatalog(candidate) : null;
+    const app = candidate?.binaryPath.match(/(?:^|\/)(ChatGPT|Codex)\.app\//)?.[1];
+    lastObservation = {
+      client_version: wholeSemver(clientVersion) || null,
+      application: app ? `${app}.app` : candidate ? "custom binary" : null,
+      source: catalog ? "bundled" : "unavailable",
+      matched: Boolean(catalog && wholeSemver(clientVersion)),
+      observed_at: new Date(now()).toISOString(),
+    };
+    return catalog;
   }
 
-  return { load };
+  return { load, snapshot: () => ({
+    last_request: lastObservation ? { ...lastObservation } : null,
+    observed_versions: [...new Set(versionCache.values())].slice(0, 8),
+    client_cache_verified: false,
+  }) };
 }

package/src/copilot-client.mjs

@@ -5,7 +5,7 @@ import { debugLog } from "./log.mjs";
 import { enforceResponsesPayloadByteBudget } from "./responses-byte-budget.mjs";
 import { status } from "./status.mjs";
 import { withChatStreamUsage } from "./stream-contract.mjs";
-import { markUpstreamStarted } from "./stream-performance.mjs";
+import { markRequestObservation, markUpstreamStarted } from "./stream-performance.mjs";
 
 function abortError(signal) {
   if (signal?.reason instanceof Error) return signal.reason;
@@ -178,6 +178,7 @@ export function createCopilotClientRuntime({
       ? preparedPayload.summary
       : summarizeReqBody(reqBody);
     console.log(status("info", `responses payload bytes=${bodyBytes} input_items=${summary.items} images=${summary.images}`));
+    markRequestObservation({ payload_bytes: bodyBytes, images: summary.images });
     if (adapted) debugLog(`responses payload adapted stage=${stage} bytes=${bodyBytes}/${preparedPayload.targetBytes}`);
     const headers = buildHeaders({ token, version: getVSCodeVersion(), initiator: "user", vision: false });
     headers["Content-Type"] = "application/json; charset=utf-8";

package/src/copilot-responses-policy.mjs

@@ -44,27 +44,44 @@ function toolName(tool) {
 // the removal. Revalidate against Copilot before deleting or broadening it.
 // Reference: https://github.com/Menci/Floway/blob/ac2bbb04352033a7d9d74574a9d465d40395ef06/packages/provider-copilot/src/interceptors/openai-responses/strip-image-generation.ts
 export function applyCopilotResponsesRequestPolicies(body, options = {}) {
-  if (!Array.isArray(body?.tools)) return false;
+  if (!body || typeof body !== "object") return false;
   const removedNames = new Set();
-  const filtered = body.tools.filter((tool) => {
-    const removed = isCopilotImageNamespaceTool(tool, options);
-    if (removed) {
+  const survivingNames = new Set();
+  let survivingTools = 0;
+  let changed = false;
+  const filter = (container, topLevel = false) => {
+    if (!Array.isArray(container?.tools)) return;
+    const tools = container.tools;
+    const filtered = tools.filter((tool) => {
+      const removed = isCopilotImageNamespaceTool(tool, options);
       const name = toolName(tool);
-      if (name) removedNames.add(name);
-    }
-    return !removed;
-  });
-  if (filtered.length === body.tools.length) return false;
-  if (filtered.length) body.tools = filtered;
-  else delete body.tools;
+      if (removed && name) removedNames.add(name);
+      if (!removed) {
+        survivingTools += 1;
+        if (name) survivingNames.add(name);
+      }
+      return !removed;
+    });
+    if (filtered.length === tools.length) return;
+    changed = true;
+    if (topLevel && !filtered.length) delete container.tools;
+    else container.tools = filtered;
+  };
+  filter(body, true);
+  for (const item of Array.isArray(body.input) ? body.input : []) {
+    if (["additional_tools", "tool_search_output"].includes(item?.type)) filter(item);
+  }
+  if (!changed) return false;
 
-  const choiceName = toolName(body.tool_choice);
-  const choiceTargetsRemovedTool = choiceName
-    && removedNames.has(choiceName)
-    && !filtered.some((tool) => toolName(tool) === choiceName);
-  if (isCopilotImageNamespaceTool(body.tool_choice, options)
-    || choiceTargetsRemovedTool
-    || (body.tool_choice === "required" && !body.tools)) {
+  const removedChoice = (choice) => isCopilotImageNamespaceTool(choice, options)
+    || (removedNames.has(toolName(choice)) && !survivingNames.has(toolName(choice)));
+  if (body.tool_choice?.type === "allowed_tools" && Array.isArray(body.tool_choice.tools)) {
+    const choices = body.tool_choice.tools.filter((choice) => !removedChoice(choice));
+    body.tool_choice = choices.length ? { ...body.tool_choice, tools: choices } : "none";
+  } else if (removedChoice(body.tool_choice)) {
+    if (survivingTools) body.tool_choice = "none";
+    else delete body.tool_choice;
+  } else if (body.tool_choice === "required" && !survivingTools) {
     delete body.tool_choice;
   }
   return true;

package/src/dashboard/index.html

@@ -48,6 +48,13 @@
           </article>
         </section>
 
+        <details class="panel dashboard-section" id="request-context">
+          <summary data-i18n>RECENT REQUEST CONTEXT</summary>
+          <p id="context-note" class="table-note">—</p>
+          <div class="table-wrap"><table><thead><tr><th scope="col" data-i18n>MODEL</th><th scope="col" data-i18n>WIRE MiB</th><th scope="col" data-i18n>IMAGES</th><th scope="col" data-i18n>INPUT TOKENS</th><th scope="col" data-i18n>MODEL WINDOW</th><th scope="col" data-i18n>INPUT / WINDOW</th><th scope="col" data-i18n>OUTCOME</th></tr></thead><tbody id="context-body"><tr><td colspan="7" data-i18n>No observed request metadata.</td></tr></tbody></table></div>
+          <p class="hint" data-i18n>Recent upstream request metadata, not exact live session occupancy. Missing values are unknown. No prompt or image content is retained.</p>
+        </details>
+
         <section class="panel dashboard-section" aria-label="Live upstream models" data-i18n-label>
           <div class="panel-heading"><h2 data-i18n>UPSTREAM GPT MODELS</h2><div class="heading-actions"><span id="models-state" data-i18n>CHECKING LIVE</span><button id="refresh-models" type="button" data-i18n>Refresh</button></div></div>
           <p id="models-note" class="table-note" data-i18n>Querying GitHub Copilot…</p>

package/src/dashboard/language.js

@@ -10,6 +10,17 @@
     "Switch to light mode": "切换为日间模式",
     "Switch to dark mode": "切换为夜间模式",
     "Overview": "概览",
+    "RECENT REQUEST CONTEXT": "近期请求上下文",
+    "WIRE MiB": "上游请求 MiB",
+    "IMAGES": "图片数",
+    "INPUT TOKENS": "输入 Token",
+    "MODEL WINDOW": "模型窗口",
+    "INPUT / WINDOW": "输入 / 窗口",
+    "OUTCOME": "终态",
+    "Unknown": "未知",
+    "No observed request metadata.": "暂无已观察到的请求元数据。",
+    "20 latest finished requests / compactions: {completed} completed, {incomplete} incomplete, {failed} failed": "最近 20 次已结束请求 / 压缩：{completed} 已完成、{incomplete} 未完成、{failed} 失败",
+    "Recent upstream request metadata, not exact live session occupancy. Missing values are unknown. No prompt or image content is retained.": "近期上游请求元数据，不等同于会话实时精确占用。缺失值表示未知；不保留提示词或图片内容。",
     "Runtime details": "运行详情",
     "ADAPTER": "适配服务",
     "KNOWN MODELS": "已知模型",

package/src/dashboard/ui.js

@@ -16,6 +16,8 @@ const finite = (value) => value !== null && value !== undefined && Number.isFini
 const number = (value) => finite(value) ? Math.max(0, Math.round(Number(value))).toLocaleString() : "—";
 const mib = (value) => finite(value) ? `${(Number(value) / 1048576).toFixed(1)} MiB` : "—";
 let authLoading = false;
+let contextRequests = [];
+let contextCompactions = {};
 
 function renderAuth(data) {
   const account = data.login ? `@${data.login}` : data.id ? `ID ${data.id}` : phrase("account unknown");
@@ -156,9 +158,36 @@ function render(data) {
     : "Setup state unknown / ccdx image-status", { active: number(image?.active), failed: number(image?.failed), delivery: number(image?.delivery_failures) });
 
   renderFailures(data.response_failures?.recent, data.stream_performance?.recent_requests);
+  renderContext(data.stream_performance);
   text("updated", "Snapshot {time}", { time: new Date().toLocaleTimeString() });
 }
 
+function renderContext(performance) {
+  if (performance !== undefined) {
+    contextRequests = Array.isArray(performance?.recent_requests) ? performance.recent_requests.slice(-20).reverse() : [];
+    contextCompactions = performance?.by_route?.responses_compact?.terminal_outcomes?.totals || {};
+  }
+  const body = element("context-body");
+  if (!body) return;
+  text("context-note", "20 latest finished requests / compactions: {completed} completed, {incomplete} incomplete, {failed} failed", {
+    completed: number(contextCompactions.completed), incomplete: number(contextCompactions.incomplete), failed: number(contextCompactions.failed),
+  });
+  if (element("request-context")?.open === false) return;
+  body.replaceChildren();
+  for (const request of contextRequests) {
+    const context = request.context || {};
+    const outcome = ["completed", "incomplete", "failed", "cancelled"].includes(request.outcome)
+      ? request.outcome[0].toUpperCase() + request.outcome.slice(1) : "Unknown";
+    const ratio = finite(context.input_tokens) && finite(context.context_window_tokens) && Number(context.context_window_tokens) > 0
+      ? `${(100 * Number(context.input_tokens) / Number(context.context_window_tokens)).toFixed(1)}%` : "—";
+    body.append(tableRow([String(request.model || "unknown").slice(0, 80),
+      finite(context.payload_bytes) ? (Number(context.payload_bytes) / 1048576).toFixed(2) : "—",
+      number(context.images), number(context.input_tokens), number(context.context_window_tokens), ratio,
+      outcome], { labels: [6] }));
+  }
+  if (!contextRequests.length) emptyTable("context-body", 7, "No observed request metadata.");
+}
+
 async function refresh() {
   const button = element("refresh");
   button.disabled = true;
@@ -186,6 +215,7 @@ async function refresh() {
 }
 
 element("refresh").addEventListener("click", () => { refresh(); loadAuth(); });
+element("request-context").addEventListener("toggle", () => { if (element("request-context").open) renderContext(); });
 refresh();
 loadAuth();
 

package/src/doctor.mjs

@@ -312,6 +312,7 @@ export async function collectDoctorChecks({
   onlineTimeoutMs = 10000,
   compatTimeoutMs = 120000,
   inspectAdapterCompatibilityFn = inspectAdapterCompatibility,
+  inspectCodexClientFn,
 } = {}) {
   if (configOnly) return inspectCodexConfig({ home, host, port });
   checkedDoctorProfile(profile);
@@ -353,6 +354,8 @@ export async function collectDoctorChecks({
           fix: "ccdx start",
         });
     }
+    const inspectClient = inspectCodexClientFn || (await import("./codex-client-doctor.mjs")).inspectCodexClient;
+    checks.push(...await inspectClient({ home, host, port, fetchImpl, running }));
   }
 
   if (compat) {

package/src/image-optimization.mjs

@@ -546,7 +546,7 @@ export function summarizeReqBody(reqBody) {
 
     for (const item of input) {
       if (["input_image", "image", "image_url"].includes(item?.type)) countImages([item]);
-      if (item?.type === "message") countImages(item.content);
+      if (item?.type === "message" || item?.type === "agent_message") countImages(item.content);
       const toolOutput = readResponsesToolOutputParts(item);
       if (toolOutput) countImages(toolOutput.parts);
     }

package/src/models.mjs

@@ -56,6 +56,12 @@ function copilotModelData(models) {
   return Array.isArray(data) ? data : [];
 }
 
+export function modelContextWindowTokens(models, id) {
+  const model = copilotModelData(models).find((entry) => String(entry?.id || "").trim() === id);
+  const limit = model?.capabilities?.limits?.max_context_window_tokens;
+  return Number.isSafeInteger(limit) && limit > 0 ? limit : null;
+}
+
 function uniqueIds(models, predicate) {
   const ids = [];
   const seen = new Set();

package/src/observability.mjs

@@ -178,10 +178,27 @@ export function runtimeStatusPayload({
   modelRegistry,
   codexClient,
   codexModelRegistry,
+  codexModelCatalog,
 } = {}) {
   const memory = process.memoryUsage();
   const codexRuntime = safeClientRuntimeStatus(codexClient);
   const codexModels = modelRegistryStatus(codexModelRegistry || modelRegistry);
+  if (typeof codexModelCatalog?.snapshot === "function") {
+    const snapshot = codexModelCatalog.snapshot();
+    const observed = snapshot?.last_request;
+    const version = (value) => /^\d+\.\d+\.\d+$/.test(value || "") ? value : null;
+    codexModels.client_catalog = {
+      last_request: observed ? {
+        client_version: version(observed.client_version),
+        application: ["ChatGPT.app", "Codex.app", "custom binary"].includes(observed.application) ? observed.application : null,
+        source: observed.source === "bundled" ? "bundled" : "unavailable",
+        matched: observed.matched === true,
+        observed_at: typeof observed.observed_at === "string" && /^\d{4}-\d{2}-\d{2}T[0-9:.]+Z$/.test(observed.observed_at) ? observed.observed_at : null,
+      } : null,
+      observed_versions: (Array.isArray(snapshot?.observed_versions) ? snapshot.observed_versions : []).filter(version).slice(0, 8),
+      client_cache_verified: false,
+    };
+  }
   const history = responseHistoryStats();
   return {
     ...adapterHealthPayload(),

package/src/responses-bridge.mjs

@@ -49,7 +49,7 @@ export function responsesBodyUsesCustomTools(body) {
   if (body?.tool_choice?.type === "custom") return true;
   if (Array.isArray(body?.tools) && body.tools.some((tool) => tool?.type === "custom")) return true;
   return Array.isArray(body?.input)
-    && body.input.some((item) => item?.type === "custom_tool_call" || item?.type === "custom_tool_call_output");
+    && body.input.some((item) => ["custom_tool_call", "custom_tool_call_output", "additional_tools", "tool_search_output"].includes(item?.type));
 }
 
 function chatCompatibilityError(kind, itemType) {

package/src/responses-chat-payload.mjs

@@ -6,7 +6,7 @@ import {
 import { responsesToChat } from "./responses-bridge.mjs";
 import { readResponsesImagePart, readResponsesToolOutputParts } from "./responses-content.mjs";
 import { withChatStreamUsage } from "./stream-contract.mjs";
-import { measureRequestStage } from "./stream-performance.mjs";
+import { markRequestObservation, measureRequestStage } from "./stream-performance.mjs";
 
 const DEFAULT_MAX_UPSTREAM_BODY_BYTES = 30 * 1024 * 1024;
 
@@ -74,6 +74,7 @@ function checkedChatPayload(chatReq, payload, limit, stage, adapted, assertActiv
     stage: stage === "chat" ? stage : `${stage}+chat`,
     targetBytes: limit,
   }, { assertActive });
+  markRequestObservation({ payload_bytes: payload.bodyBytes });
   return { chatReq, ...payload, adapted, stage };
 }
 

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,
@@ -115,6 +118,7 @@ export function createResponsesHandler(options) {
     chatCompletionsFn,
     getCachedModelEndpointsFn = getCachedModelEndpoints,
     imagePressure,
+    keepaliveIntervalMs,
     modelRegistry,
     openAIModelEnv,
     requestBodyTimeoutMs,
@@ -283,6 +287,7 @@ export function createResponsesHandler(options) {
       }
       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);
@@ -313,6 +318,7 @@ export function createResponsesHandler(options) {
           releaseRequest: releaseUpstreamPayload,
           responseFailures,
           streamIdleTimeoutMs,
+          keepaliveIntervalMs,
         });
         if (result?.successful) imagePressure?.markSuccess?.(responseHistoryPressureRootId(prepared));
         else markAdaptiveHttpTimeout(result?.upstreamStatus);
@@ -330,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") {
@@ -370,7 +379,7 @@ export function createResponsesHandler(options) {
                 contentType: "text/event-stream",
               });
             },
-          });
+          }); } finally { keepalive.stop(); }
           if (successful) imagePressure?.markSuccess?.(responseHistoryPressureRootId(prepared));
         } else {
           try {
@@ -552,6 +561,7 @@ export function createResponsesCompactHandler(options) {
         }
       }
       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));
 }