codex-copilot-dx 0.4.43 → 0.5.0

package/src/cli-options.mjs

@@ -1,6 +1,7 @@
 const HELP_COMMANDS = new Set(["help", "--help", "-h"]);
 const VERSION_COMMANDS = new Set(["version", "--version", "-v"]);
 const START_OPTIONS = new Set(["--configure-claude-desktop", "--show-request-id"]);
+const CLI_COMMANDS = new Set(["ccdx", "codex-copilot-dx"]);
 
 function unexpectedArgs(args) {
   throw new Error(`Unexpected argument${args.length === 1 ? "" : "s"}: ${args.join(" ")}`);
@@ -17,6 +18,10 @@ export function parseCliArgs(args = []) {
     if (rest.length) unexpectedArgs(rest);
     return { command: "version", configureClaudeDesktop: false, showRequestId: false, online: false, compat: false };
   }
+  if (command === "status" || command === "--status") {
+    if (rest.length) unexpectedArgs(rest);
+    return { command: "status", configureClaudeDesktop: false, showRequestId: false, online: false, compat: false };
+  }
   if (command === "usage") {
     if (rest.length) unexpectedArgs(rest);
     return { command: "usage", configureClaudeDesktop: false, showRequestId: false, online: false, compat: false };
@@ -80,11 +85,30 @@ export function parseRuntimeOptions(env = process.env) {
   };
 }
 
-export function cliHelp() {
+export function parseAdapterProbeOptions(env = process.env) {
+  return {
+    adapterPort: integerEnv(env, "ADAPTER_PORT", 2026, { min: 1, max: 65535 }),
+    adapterHost: String(env.ADAPTER_HOST || "127.0.0.1").trim() || "127.0.0.1",
+    existingAdapterTimeoutMs: integerEnv(env, "CCDX_EXISTING_ADAPTER_TIMEOUT_MS", 500, { min: 1 }),
+  };
+}
+
+export function cliCommandName(executable = process.argv[1]) {
+  const name = String(executable || "").split(/[\\/]/).pop();
+  if (name === "codex-copilot-dx.mjs") return "codex-copilot-dx";
+  return CLI_COMMANDS.has(name) ? name : "ccdx";
+}
+
+export function cliHelp(commandName = "ccdx") {
+  const name = CLI_COMMANDS.has(commandName) ? commandName : "ccdx";
+  const alias = name === "ccdx" ? "codex-copilot-dx" : "ccdx";
   return `Usage:
-  codex-copilot-dx [--configure-claude-desktop] [--show-request-id]
-  codex-copilot-dx doctor [--online] [--compat]
-  codex-copilot-dx usage
-  codex-copilot-dx --version
-  codex-copilot-dx --help`;
+  ${name} [--configure-claude-desktop] [--show-request-id]
+  ${name} doctor [--online] [--compat]
+  ${name} status
+  ${name} usage
+  ${name} --version
+  ${name} --help
+
+Equivalent command: ${alias}`;
 }

package/src/cli-status.mjs

@@ -0,0 +1,122 @@
+import { ADAPTER_STATUS_PATH, adapterBaseUrl } from "./running-adapter.mjs";
+import { status } from "./status.mjs";
+
+function finiteNumber(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+
+function count(value) {
+  const number = finiteNumber(value);
+  return number === null ? "n/a" : String(Math.max(0, Math.round(number)));
+}
+
+function duration(value) {
+  const milliseconds = finiteNumber(value);
+  if (milliseconds === null) return "n/a";
+  const seconds = Math.max(0, Math.round(milliseconds / 1000));
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor((seconds % 86400) / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const remainder = seconds % 60;
+  if (days) return `${days}d ${hours}h`;
+  if (hours) return `${hours}h ${minutes}m`;
+  if (minutes) return `${minutes}m ${remainder}s`;
+  return `${remainder}s`;
+}
+
+function latency(value) {
+  const milliseconds = finiteNumber(value);
+  if (milliseconds === null) return "n/a";
+  if (milliseconds >= 1000) return `${(milliseconds / 1000).toFixed(2)}s`;
+  return `${milliseconds.toFixed(1)}ms`;
+}
+
+function mebibytes(value) {
+  const bytes = finiteNumber(value);
+  return bytes === null ? "n/a" : `${(bytes / (1024 * 1024)).toFixed(1)}MiB`;
+}
+
+function tpot(metric) {
+  const average = finiteNumber(metric?.avg);
+  if (average === null) return "n/a";
+  const milliseconds = metric?.unit === "us" ? average / 1000 : average;
+  return `${milliseconds.toFixed(2)}ms/token`;
+}
+
+function cacheHitRate(cache = {}) {
+  const hits = finiteNumber(cache.cache_hits);
+  const misses = finiteNumber(cache.cache_misses);
+  if (hits === null || misses === null || hits + misses <= 0) return "n/a";
+  return `${((hits / (hits + misses)) * 100).toFixed(1)}%`;
+}
+
+export async function readAdapterStatus({
+  host = "127.0.0.1",
+  port = 2026,
+  timeoutMs = 500,
+  fetchImpl = fetch,
+} = {}) {
+  const baseUrl = adapterBaseUrl(host, port);
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const response = await fetchImpl(`${baseUrl}${ADAPTER_STATUS_PATH}`, {
+      headers: { Accept: "application/json" },
+      redirect: "error",
+      signal: ctrl.signal,
+    });
+    if (!response.ok) throw new Error(`returned HTTP ${response.status}`);
+
+    let data;
+    try {
+      data = await response.json();
+    } catch {
+      throw new Error("returned invalid JSON");
+    }
+    if (data?.ok !== true
+      || data?.name !== "codex-copilot-dx"
+      || typeof data.version !== "string"
+      || !Number.isInteger(data.pid)) {
+      throw new Error("returned an incompatible status payload");
+    }
+    return { baseUrl, data };
+  } catch (error) {
+    const reason = ctrl.signal.aborted
+      ? `timed out after ${timeoutMs}ms`
+      : error?.cause?.code === "ECONNREFUSED"
+        ? "adapter is not running"
+        : error?.message || String(error);
+    throw new Error(`Could not read adapter status at ${baseUrl}: ${reason}`);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export function formatAdapterStatus({ baseUrl, data }, { commandName = "ccdx", cliVersion = data.version } = {}) {
+  const requests = data.requests || {};
+  const performance = data.stream_performance?.by_route?.responses || {};
+  const admission = data.admission || {};
+  const history = data.response_history || {};
+  const images = data.image_optimization || {};
+  const models = data.models || {};
+  const copilot = data.copilot || {};
+  const limits = data.limits || {};
+  const processStats = data.process || {};
+  const adapterLine = data.version === cliVersion
+    ? status("ok", `Adapter ${data.version} is running at ${baseUrl} (PID ${data.pid}, uptime ${duration(data.uptime_ms)})`)
+    : status("warn", `Adapter ${data.version} is running at ${baseUrl}, but this CLI is ${cliVersion}; stop the running adapter before switching versions`);
+
+  return [
+    `${commandName} status`,
+    adapterLine,
+    status("info", `Requests: ${count(requests.completed)}/${count(requests.total)} completed, ${count(requests.active)} active, ${count(requests.status_4xx)} 4xx, ${count(requests.status_5xx)} 5xx, ${count(requests.aborted)} aborted`),
+    status("info", `Responses stream: TTFT avg ${latency(performance.ttft_ms?.avg)} (${count(performance.ttft_ms?.samples)} samples), TPOT avg ${tpot(performance.tpot_us)}`),
+    status("info", `Admission: ${count(admission.activeRequests)} active, ${count(admission.queued)} queued, ${count(admission.rejected)} rejected, ${count(admission.timedOut)} timed out, wait avg ${latency(admission.waitMsAvg)}`),
+    status("info", `Memory: RSS ${mebibytes(processStats.rss_bytes)}, heap ${mebibytes(processStats.heap_used_bytes)}`),
+    status("info", `History: ${mebibytes(history.bytes)} / ${mebibytes(limits.response_history_max_bytes)}, ${count(history.entries)} entries, ${count(history.evicted)} evicted`),
+    status("info", `Image cache: ${count(images.cache_entries)} entries, ${cacheHitRate(images)} hits, ${mebibytes(images.cache_bytes)} / ${mebibytes(images.cache_max_bytes)}`),
+    status("info", `Models: ${count(models.models)} total, ${count(models.claude_models)} Claude; Copilot token ${copilot.token_cached ? `cached (${duration(copilot.token_expires_in_ms)} remaining)` : "not cached"}`),
+    status("info", `Limits: request body ${mebibytes(limits.max_body_bytes)}, decoded body ${mebibytes(limits.max_decoded_body_bytes)}`),
+  ].join("\n");
+}

package/src/copilot.mjs

@@ -19,6 +19,8 @@ import {
 } from "./github-identity.mjs";
 import { prepareResponsesPayload, summarizeReqBody } from "./image-optimization.mjs";
 import { enforceResponsesPayloadByteBudget } from "./responses-byte-budget.mjs";
+import { withChatStreamUsage } from "./stream-contract.mjs";
+import { markUpstreamStarted } from "./stream-performance.mjs";
 
 export {
   optimizeImageDataUrl,
@@ -317,7 +319,7 @@ export function copilotRuntimeStatus(now = Date.now()) {
 function getGithubToken({ home = os.homedir() } = {}) {
   const GITHUB_TOKEN_PATH = githubTokenPath(home);
   if (!fs.existsSync(GITHUB_TOKEN_PATH)) {
-    throw new Error("GitHub token not found. Run codex-copilot-dx again to log in.");
+    throw new Error("GitHub token not found. Run ccdx again to log in.");
   }
   const token = fs.readFileSync(GITHUB_TOKEN_PATH, "utf-8").trim();
   if (!token) throw new Error(githubReauthMessage("GitHub token file is empty."));
@@ -343,7 +345,7 @@ function cacheCopilotTokenData(data, {
   const tokenChanged = Boolean(copilotTokenGithubFingerprint && fingerprint !== copilotTokenGithubFingerprint);
   if (!allowAccountSwitch && copilotTokenGithubIdentity && identity
     && !githubIdentitiesEqual(copilotTokenGithubIdentity, identity)) {
-    throw new Error(`Refusing to switch GitHub Copilot account from ${githubIdentityLabel(copilotTokenGithubIdentity)} to ${githubIdentityLabel(identity)} while the adapter is running. Restart codex-copilot-dx to switch accounts intentionally.`);
+    throw new Error(`Refusing to switch GitHub Copilot account from ${githubIdentityLabel(copilotTokenGithubIdentity)} to ${githubIdentityLabel(identity)} while the adapter is running. Restart ccdx to switch accounts intentionally.`);
   }
   if (!allowAccountSwitch && copilotTokenGithubIdentity && tokenChanged && !identity) {
     const error = new Error("The saved GitHub token changed, but its account could not be verified. Keeping the running adapter bound to the existing GitHub account.");
@@ -508,8 +510,11 @@ export async function chatCompletions(chatReq, {
   bodyText,
 } = {}) {
   const token = await getCopilotToken({ signal });
-  const messages = chatReq.messages || [];
-  const serializedBody = typeof bodyText === "string" ? bodyText : JSON.stringify(chatReq);
+  const upstreamReq = chatReq.stream === true ? withChatStreamUsage(chatReq) : chatReq;
+  const messages = upstreamReq.messages || [];
+  const serializedBody = typeof bodyText === "string" && upstreamReq === chatReq
+    ? bodyText
+    : JSON.stringify(upstreamReq);
   const headers = buildHeaders({
     token,
     version: getVSCodeVersion(),
@@ -517,6 +522,7 @@ export async function chatCompletions(chatReq, {
     vision: computeVision(messages),
   });
   headers["Content-Length"] = String(Buffer.byteLength(serializedBody));
+  if (upstreamReq.stream === true) markUpstreamStarted();
   return fetchCopilotUpstream(`${getApiBase()}/chat/completions`, {
     method: "POST",
     headers,
@@ -624,6 +630,7 @@ export async function responses(reqBody, {
   headers["Accept"] = reqBody.stream ? "text/event-stream" : "application/json";
 
   try {
+    if (reqBody.stream === true) markUpstreamStarted();
     return await fetchCopilotUpstream(`${getApiBase()}${responsesEndpointPath()}`, {
       method: "POST",
       headers,

package/src/doctor.mjs

@@ -124,6 +124,15 @@ function parseResponseObject(text) {
   return response;
 }
 
+function parseCompactionResponse(text) {
+  const response = parseResponseObject(text);
+  if (response.object !== "response.compaction"
+    || !response.output.some((item) => item?.type === "compaction")) {
+    throw new Error("response body is missing valid compaction state");
+  }
+  return response;
+}
+
 export async function inspectAdapterCompatibility({
   host = "127.0.0.1",
   port = 2026,
@@ -184,7 +193,7 @@ export async function inspectAdapterCompatibility({
       stream: false,
       input: "Compact this short context.",
     }, timeoutMs);
-    parseResponseObject(text);
+    parseCompactionResponse(text);
   });
 
   if (!claudeModel) {
@@ -446,7 +455,7 @@ export async function collectDoctorChecks({
 export async function runDoctor(options = {}) {
   const log = options.log || console.log;
   const flags = [options.online ? "--online" : "", options.compat ? "--compat" : ""].filter(Boolean);
-  log(`codex-copilot-dx doctor${flags.length ? ` ${flags.join(" ")}` : ""}`);
+  log(`${options.commandName || "ccdx"} doctor${flags.length ? ` ${flags.join(" ")}` : ""}`);
   const checks = await collectDoctorChecks(options);
   for (const check of checks) log(status(check.kind, check.message));
   return checks;

package/src/http-transport.mjs

@@ -2,6 +2,7 @@ import { promisify } from "node:util";
 import * as zlib from "node:zlib";
 import { loadRuntimeConfig, parsePositiveInteger } from "./runtime-config.mjs";
 import { status } from "./status.mjs";
+import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
 
 const COMPRESSED_BODY_WEIGHT_MULTIPLIER = 4;
 const gunzipAsync = promisify(zlib.gunzip);
@@ -296,7 +297,9 @@ export function sendJsonError(res, err, fallbackStatus = 400) {
 
 export function sendUpstreamError(res, response, text) {
   if (!res.headersSent) {
-    res.writeHead(response.status || 502, { "Content-Type": response.headers?.get("content-type") || "application/json" });
+    res.writeHead(response.status || 502, safeUpstreamResponseHeaders(response.headers, {
+      defaultContentType: "application/json",
+    }));
   }
   res.end(text || JSON.stringify({ error: "Upstream request failed" }));
 }

package/src/image-optimization.mjs

@@ -4,17 +4,19 @@ import {
   readResponsesImagePart,
   readResponsesToolOutputParts,
 } from "./responses-content.mjs";
+import { createBoundedResultCache } from "./bounded-result-cache.mjs";
 import { status } from "./status.mjs";
 
 const DEFAULT_IMG_CONCURRENCY = 2;
 const IMG_MAX_CONCURRENCY = 12;
 const DEFAULT_IMG_MAX_INPUT_PIXELS = 40 * 1000 * 1000;
+const DEFAULT_IMG_CACHE_MAX_BYTES = 64 * 1024 * 1024;
 const DEFAULT_MAX_UPSTREAM_BODY_BYTES = 30 * 1024 * 1024;
-const MAX_OPTIMIZED_IMAGE_DIGESTS = 4096;
 const IMG_MAX_DIM = positiveInt(process.env.CCDX_IMG_MAX_DIM, 2048);
 const IMG_QUALITY = positiveInt(process.env.CCDX_IMG_QUALITY, 82, 100);
 const IMG_MIN_BYTES = nonNegativeInt(process.env.CCDX_IMG_MIN_BYTES, 100000);
 const IMG_MAX_INPUT_PIXELS = positiveInt(process.env.CCDX_IMG_MAX_INPUT_PIXELS, DEFAULT_IMG_MAX_INPUT_PIXELS);
+const IMG_CACHE_MAX_BYTES = nonNegativeInt(process.env.CCDX_IMG_CACHE_MAX_BYTES, DEFAULT_IMG_CACHE_MAX_BYTES);
 const MAX_UPSTREAM_BODY_BYTES = positiveInt(process.env.CCDX_MAX_UPSTREAM_BODY_BYTES, DEFAULT_MAX_UPSTREAM_BODY_BYTES);
 const IMG_OPT_DISABLED = process.env.CCDX_DISABLE_IMG_OPT === "1";
 const IMG_CONCURRENCY = parseImageConcurrency(process.env.CCDX_IMG_CONCURRENCY);
@@ -22,7 +24,8 @@ const OVERSIZE_IMAGE_PROFILES = [
   { maxDim: Math.min(IMG_MAX_DIM, 1600), quality: Math.min(IMG_QUALITY, 75) },
   { maxDim: Math.min(IMG_MAX_DIM, 1280), quality: Math.min(IMG_QUALITY, 65) },
 ];
-const optimizedImageDigests = new Set();
+const IMAGE_ENCODER_CONFIG = "webp:v1:effort=4:autorotate=1:fit=inside:without_enlargement=1";
+const imageResultCache = createBoundedResultCache({ maxBytes: IMG_CACHE_MAX_BYTES });
 let sharpImport = null;
 
 function positiveInt(value, fallback, max = Number.MAX_SAFE_INTEGER) {
@@ -140,52 +143,50 @@ export function createTaskLimiter(concurrency) {
 const runGlobalImageTask = createTaskLimiter(IMG_CONCURRENCY);
 
 export function imageOptimizationStats() {
+  const cache = imageResultCache.stats();
   return {
     ...runGlobalImageTask.stats(),
     disabled: IMG_OPT_DISABLED,
-    cache_entries: optimizedImageDigests.size,
+    cache_entries: cache.entries,
+    cache_bytes: cache.bytes,
+    cache_max_bytes: cache.max_bytes,
+    cache_hits: cache.hits,
+    cache_misses: cache.misses,
+    cache_evictions: cache.evictions,
+    cache_inflight: cache.inflight,
     sharp_loaded: sharpImport !== null,
   };
 }
 
+export function resetImageOptimizationCacheForTests() {
+  imageResultCache.clear();
+}
+
 async function sharp() {
   sharpImport ||= import("sharp");
   const mod = await sharpImport;
   return mod.default || mod;
 }
 
-function imageDigest(raw) {
-  return createHash("sha256").update(raw).digest("base64url");
+function imageDigest(value, encoding) {
+  return createHash("sha256").update(value, encoding).digest("base64url");
 }
 
-function imageOptimizationKey(digest, constraints, quality) {
+function imageOptimizationKey(digest, mime, constraints, quality) {
   return [
     digest,
+    mime,
     constraints.maxLongEdge || "",
     constraints.maxShortEdge || "",
     constraints.maxArea || "",
     quality,
+    IMAGE_ENCODER_CONFIG,
   ].join(":");
 }
 
-function touchOptimizedImage(digest) {
-  if (!optimizedImageDigests.delete(digest)) return false;
-  optimizedImageDigests.add(digest);
-  return true;
-}
-
-function rememberOptimizedImage(digest) {
-  optimizedImageDigests.delete(digest);
-  optimizedImageDigests.add(digest);
-  if (optimizedImageDigests.size > MAX_OPTIMIZED_IMAGE_DIGESTS) {
-    optimizedImageDigests.delete(optimizedImageDigests.values().next().value);
-  }
-}
-
 export async function optimizeImageDataUrl(dataUrl, {
   maxDim = IMG_MAX_DIM,
   quality = IMG_QUALITY,
-  force = false,
   model,
   signal,
 } = {}) {
@@ -197,52 +198,60 @@ export async function optimizeImageDataUrl(dataUrl, {
   const encoded = match[2];
   const inputBytes = Buffer.byteLength(encoded, "base64");
   if (mime.includes("gif")) return dataUrl;
+  if (signal?.aborted) throw abortError(signal);
+  const constraints = imageConstraintsForModel(model, { maxDim });
+  const outputQuality = positiveInt(quality, IMG_QUALITY, 100);
+  // Hash decoded source bytes without retaining a decoded Buffer. Cache hits
+  // therefore bypass both Sharp and the global image work queue.
+  const digest = imageDigest(encoded, "base64");
+  const optimizationKey = imageOptimizationKey(digest, mime, constraints, outputQuality);
 
   try {
-    return await runGlobalImageTask(async () => {
-      const raw = Buffer.from(encoded, "base64");
-      const digest = imageDigest(raw);
-      const constraints = imageConstraintsForModel(model, { maxDim });
-      const outputQuality = positiveInt(quality, IMG_QUALITY, 100);
-      const optimizationKey = imageOptimizationKey(digest, constraints, outputQuality);
-      if (!force && touchOptimizedImage(optimizationKey)) return dataUrl;
-      const resize = await sharp();
-      const image = resize(raw, { failOn: "none", limitInputPixels: IMG_MAX_INPUT_PIXELS });
-      const metadata = await image.metadata();
-      const orientation = Number(metadata.orientation);
-      const rotated = orientation >= 5 && orientation <= 8;
-      const sourceWidth = rotated ? metadata.height : metadata.width;
-      const sourceHeight = rotated ? metadata.width : metadata.height;
-      const target = fitImageDimensions(sourceWidth, sourceHeight, constraints);
-      const resizeRequired = target
-        && (target.width < sourceWidth || target.height < sourceHeight);
-      if (raw.length < IMG_MIN_BYTES && !resizeRequired) {
-        rememberOptimizedImage(optimizationKey);
-        return dataUrl;
-      }
-      const resizeOptions = target
-        ? { ...target, fit: "inside", withoutEnlargement: true }
-        : {
-            width: constraints.maxLongEdge,
-            height: constraints.maxLongEdge,
-            fit: "inside",
-            withoutEnlargement: true,
-          };
-      const out = await image
-        .rotate()
-        .resize(resizeOptions)
-        .webp({ quality: outputQuality, effort: 4 })
-        .toBuffer();
-      if (signal?.aborted) throw abortError(signal);
-      if (out.length >= raw.length) {
-        rememberOptimizedImage(optimizationKey);
-        return dataUrl;
-      }
-      rememberOptimizedImage(imageOptimizationKey(imageDigest(out), constraints, outputQuality));
-      const ratio = ((out.length / raw.length) * 100).toFixed(1);
-      console.log(status("info", `image ${(raw.length / 1024).toFixed(0)}KB ${mime} -> ${(out.length / 1024).toFixed(0)}KB webp (${ratio}%)`));
-      return `data:image/webp;base64,${out.toString("base64")}`;
-    }, { signal });
+    return await imageResultCache.getOrCreate(optimizationKey, (sharedSignal) => (
+      runGlobalImageTask(async () => {
+        const raw = Buffer.from(encoded, "base64");
+        const resize = await sharp();
+        const image = resize(raw, { failOn: "none", limitInputPixels: IMG_MAX_INPUT_PIXELS });
+        const metadata = await image.metadata();
+        if (sharedSignal.aborted) throw abortError(sharedSignal);
+        const orientation = Number(metadata.orientation);
+        const rotated = orientation >= 5 && orientation <= 8;
+        const sourceWidth = rotated ? metadata.height : metadata.width;
+        const sourceHeight = rotated ? metadata.width : metadata.height;
+        const target = fitImageDimensions(sourceWidth, sourceHeight, constraints);
+        const resizeRequired = target
+          && (target.width < sourceWidth || target.height < sourceHeight);
+        if (raw.length < IMG_MIN_BYTES && !resizeRequired) return dataUrl;
+        const resizeOptions = target
+          ? { ...target, fit: "inside", withoutEnlargement: true }
+          : {
+              width: constraints.maxLongEdge,
+              height: constraints.maxLongEdge,
+              fit: "inside",
+              withoutEnlargement: true,
+            };
+        const out = await image
+          .rotate()
+          .resize(resizeOptions)
+          .webp({ quality: outputQuality, effort: 4 })
+          .toBuffer();
+        if (sharedSignal.aborted) throw abortError(sharedSignal);
+        if (out.length >= raw.length) return dataUrl;
+        const outputBase64 = out.toString("base64");
+        const outputDataUrl = `data:image/webp;base64,${outputBase64}`;
+        const outputKey = imageOptimizationKey(
+          imageDigest(outputBase64, "base64"),
+          "image/webp",
+          constraints,
+          outputQuality,
+        );
+        // Preserve idempotence when optimized history is submitted again.
+        imageResultCache.set(outputKey, outputDataUrl);
+        const ratio = ((out.length / raw.length) * 100).toFixed(1);
+        console.log(status("info", `image ${(raw.length / 1024).toFixed(0)}KB ${mime} -> ${(out.length / 1024).toFixed(0)}KB webp (${ratio}%)`));
+        return outputDataUrl;
+      }, { signal: sharedSignal })
+    ), { signal });
   } catch (e) {
     if (signal?.aborted || e?.name === "AbortError") throw e;
     if (inputBytes >= IMG_MIN_BYTES) {

package/src/observability.mjs

@@ -1,11 +1,11 @@
 import { isIP } from "node:net";
-import { adapterHealthPayload } from "./running-adapter.mjs";
+import { ADAPTER_STATUS_PATH, 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";
+export { ADAPTER_STATUS_PATH };
 const OBSERVABILITY_RUNTIME_CONFIG = loadRuntimeConfig();
 
 const ROUTE_NAMES = Object.freeze([
@@ -118,7 +118,7 @@ function modelRegistryStatus(modelRegistry) {
   };
 }
 
-export function runtimeStatusPayload({ metrics, admission, modelRegistry } = {}) {
+export function runtimeStatusPayload({ metrics, streamPerformance, admission, modelRegistry } = {}) {
   const memory = process.memoryUsage();
   return {
     ...adapterHealthPayload(),
@@ -131,6 +131,7 @@ export function runtimeStatusPayload({ metrics, admission, modelRegistry } = {})
       array_buffers_bytes: memory.arrayBuffers,
     },
     requests: metrics?.snapshot?.() || createRequestMetrics().snapshot(),
+    stream_performance: streamPerformance?.snapshot?.() || null,
     admission: admission?.diagnostics?.() || admission?.stats?.() || null,
     response_history: responseHistoryStats(),
     image_optimization: imageOptimizationStats(),

package/src/responses-bridge.mjs

@@ -2,6 +2,15 @@ import { randomUUID } from "node:crypto";
 import { chatCompletions } from "./copilot.mjs";
 import { webStreamLines } from "./stream.mjs";
 import { abortErrorStatusCode, isAbortLikeError } from "./http-transport.mjs";
+import {
+  incompleteUpstreamStream,
+  invalidUpstreamStream,
+  requireUpstreamEventStream,
+  ToolArgumentDeltaGuard,
+  upstreamChatStreamError,
+  withChatStreamUsage,
+} from "./stream-contract.mjs";
+import { isChatOutputDelta, markFirstOutput, markOutputTokens } from "./stream-performance.mjs";
 
 function cloneJson(value) {
   return value === undefined ? undefined : structuredClone(value);
@@ -134,7 +143,7 @@ export function chatToResponses(chatResp, model) {
 
 export async function forwardToChat(chatReq, emitEvent, onDone, onError, options = {}) {
   delete chatReq.max_tokens;
-  const upstreamReq = chatReq.stream === true ? chatReq : { ...chatReq, stream: true };
+  const upstreamReq = withChatStreamUsage(chatReq);
   const bodyText = upstreamReq === chatReq ? options.bodyText : undefined;
   let resp;
   try {
@@ -150,9 +159,16 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
     return;
   }
   if (!resp.ok) {
-    await onError(resp.status, await resp.text());
+    await onError(resp.status, await resp.text(), undefined, resp);
     return;
   }
+  try {
+    await requireUpstreamEventStream(resp);
+  } catch (error) {
+    await onError(error.statusCode, error.message, error);
+    return;
+  }
+  options.onUpstreamResponse?.(resp);
   options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
   const respId = `resp_${uid()}`;
   let actualModel = chatReq.model || "unknown";
@@ -161,6 +177,13 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
   let nextOutputIndex = 0;
   let usage = { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
   const toolCalls = new Map();
+  const toolArgumentGuard = new ToolArgumentDeltaGuard();
+  let performanceOutputSeen = false;
+  const markPerformanceOutput = () => {
+    if (performanceOutputSeen) return;
+    performanceOutputSeen = true;
+    markFirstOutput();
+  };
 
   await emitEvent("response.created", { response: { id: respId, object: "response", status: "in_progress", model: actualModel, output: [] } });
 
@@ -258,7 +281,16 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
       const data = line.slice(6).trim();
       if (data === "[DONE]") { await emitCompleted(); onDone(); return; }
       let parsed;
-      try { parsed = JSON.parse(data); } catch { continue; }
+      try {
+        parsed = JSON.parse(data);
+      } catch {
+        throw invalidUpstreamStream(
+          "Upstream Chat Completions SSE event contained invalid JSON",
+          "upstream_stream_json_invalid",
+        );
+      }
+      const upstreamError = upstreamChatStreamError(parsed);
+      if (upstreamError) throw upstreamError;
       if (parsed.model) actualModel = parsed.model;
       if (parsed.usage) {
         usage = {
@@ -268,9 +300,11 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
         };
         const cached = parsed.usage.prompt_tokens_details?.cached_tokens;
         if (cached) usage.input_tokens_details = { cached_tokens: cached };
+        markOutputTokens(usage.output_tokens);
       }
       const delta = parsed.choices?.[0]?.delta;
       if (!delta) continue;
+      if (isChatOutputDelta(delta)) markPerformanceOutput();
       if (delta.content) {
         const message = await ensureMessageItem();
         fullText += delta.content;
@@ -281,22 +315,24 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
           const { tool, created } = await ensureToolCall(tc);
           if (tc.id) tool.callId = tc.id;
           if (!created && tc.function?.name) tool.name += tc.function.name;
-          if (tc.function?.arguments) {
-            tool.arguments += tc.function.arguments;
+          const argumentDelta = tc.function?.arguments;
+          toolArgumentGuard.observe(tool.outputIndex, argumentDelta);
+          if (argumentDelta) {
+            tool.arguments += argumentDelta;
             await emitEvent("response.function_call_arguments.delta", {
               output_index: tool.outputIndex,
               item_id: tool.id,
-              delta: tc.function.arguments,
+              delta: argumentDelta,
             });
           }
         }
       }
     }
   } catch (e) {
-    const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(options.abort?.reason) : 502;
-    await onError(statusCode, e?.message || "upstream stream error");
+    const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(options.abort?.reason) : (e?.statusCode || 502);
+    await onError(statusCode, e?.message || "upstream stream error", e);
     return;
   }
-  await emitCompleted();
-  onDone();
+  const error = incompleteUpstreamStream("[DONE]");
+  await onError(error.statusCode, error.message, error);
 }

package/src/responses-chat-payload.mjs

@@ -5,6 +5,7 @@ import {
 } from "./responses-byte-budget.mjs";
 import { responsesToChat } from "./responses-bridge.mjs";
 import { readResponsesImagePart, readResponsesToolOutputParts } from "./responses-content.mjs";
+import { withChatStreamUsage } from "./stream-contract.mjs";
 
 const DEFAULT_MAX_UPSTREAM_BODY_BYTES = 30 * 1024 * 1024;
 
@@ -30,7 +31,7 @@ function chatRequest(responsesBody, stream) {
   const chatReq = responsesToChat(responsesBody);
   chatReq.stream = Boolean(stream);
   delete chatReq.max_tokens;
-  return chatReq;
+  return stream ? withChatStreamUsage(chatReq) : chatReq;
 }
 
 function adjustedResponsesTarget(limit, responsesBytes, chatBytes) {