codex-copilot-dx 0.1.6 → 0.4.1

package/src/copilot.mjs

@@ -0,0 +1,316 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { randomUUID } from "node:crypto";
+import { status } from "./status.mjs";
+
+const GITHUB_TOKEN_PATH = path.join(os.homedir(), ".local", "share", "copilot-api", "github_token");
+export const DEFAULT_API_BASE = "https://api.githubcopilot.com";
+let apiBase = DEFAULT_API_BASE;
+const IMG_MAX_DIM = parseInt(process.env.CCDX_IMG_MAX_DIM || "2048", 10);
+const IMG_QUALITY = parseInt(process.env.CCDX_IMG_QUALITY || "85", 10);
+const IMG_MIN_BYTES = parseInt(process.env.CCDX_IMG_MIN_BYTES || "100000", 10);
+const IMG_OPT_DISABLED = process.env.CCDX_DISABLE_IMG_OPT === "1";
+let sharpImport = null;
+
+export function parseApiBase(data) {
+  return (data && data.endpoints && typeof data.endpoints.api === "string" && data.endpoints.api)
+    ? data.endpoints.api
+    : DEFAULT_API_BASE;
+}
+
+export function getApiBase() {
+  return apiBase;
+}
+
+export function responsesEndpointPath() {
+  return "/responses";
+}
+const GITHUB_API = "https://api.github.com";
+
+async function sharp() {
+  sharpImport ||= import("sharp");
+  const mod = await sharpImport;
+  return mod.default || mod;
+}
+
+export async function optimizeImageDataUrl(dataUrl) {
+  if (IMG_OPT_DISABLED) return dataUrl;
+  if (typeof dataUrl !== "string" || !dataUrl.startsWith("data:")) return dataUrl;
+  const match = /^data:(image\/[a-z+.-]+);base64,(.+)$/i.exec(dataUrl);
+  if (!match) return dataUrl;
+  const mime = match[1].toLowerCase();
+  const raw = Buffer.from(match[2], "base64");
+  if (raw.length < IMG_MIN_BYTES || mime.includes("gif")) return dataUrl;
+
+  try {
+    const resize = await sharp();
+    const out = await resize(raw, { failOn: "none" })
+      .rotate()
+      .resize(IMG_MAX_DIM, IMG_MAX_DIM, { fit: "inside", withoutEnlargement: true })
+      .webp({ quality: IMG_QUALITY, effort: 4 })
+      .toBuffer();
+    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")}`;
+  } catch (e) {
+    console.warn(status("warn", `image optimize failed (${mime}, ${raw.length}b): ${e.message}`));
+    return dataUrl;
+  }
+}
+
+function visitImageParts(parts, tasks) {
+  if (!Array.isArray(parts)) return;
+  for (const part of parts) {
+    if (!part) continue;
+    if (part.type === "input_image" && typeof part.image_url === "string") {
+      tasks.push((async () => { part.image_url = await optimizeImageDataUrl(part.image_url); })());
+    } else if (part.type === "image" && part.source?.type === "base64" && part.source?.data) {
+      tasks.push((async () => {
+        const dataUrl = `data:${part.source.media_type || "image/png"};base64,${part.source.data}`;
+        const opt = await optimizeImageDataUrl(dataUrl);
+        const match = /^data:([^;]+);base64,(.+)$/.exec(opt);
+        if (match) {
+          part.source.media_type = match[1];
+          part.source.data = match[2];
+        }
+      })());
+    }
+  }
+}
+
+export async function optimizeImagesInBody(reqBody) {
+  if (IMG_OPT_DISABLED || !Array.isArray(reqBody.input)) return reqBody;
+  const tasks = [];
+
+  for (const item of reqBody.input) {
+    if (!item) continue;
+    if (item.type === "message" && Array.isArray(item.content)) {
+      visitImageParts(item.content, tasks);
+    }
+    if (item.type === "function_call_output") {
+      if (Array.isArray(item.output)) {
+        visitImageParts(item.output, tasks);
+      } else if (typeof item.output === "string") {
+        const trimmed = item.output.trim();
+        if (trimmed.startsWith("[")) {
+          try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+              const before = tasks.length;
+              visitImageParts(parsed, tasks);
+              const localTasks = tasks.slice(before);
+              if (localTasks.length) {
+                tasks.push(Promise.all(localTasks).then(() => {
+                  item.output = JSON.stringify(parsed);
+                }));
+              }
+            }
+          } catch {
+            // Leave non-JSON tool output untouched.
+          }
+        }
+      }
+    }
+  }
+
+  if (tasks.length) await Promise.all(tasks);
+  return reqBody;
+}
+
+export function summarizeReqBody(reqBody) {
+  try {
+    const input = reqBody.input;
+    if (!Array.isArray(input)) return { items: 0, images: 0, biggest: 0, biggestKind: "n/a" };
+    let biggest = 0;
+    let biggestKind = "";
+    let images = 0;
+    const countImages = (parts) => {
+      if (!Array.isArray(parts)) return;
+      for (const part of parts) {
+        if (part?.type === "input_image" || part?.type === "image") images++;
+      }
+    };
+
+    for (const item of input) {
+      const size = JSON.stringify(item).length;
+      if (size > biggest) {
+        biggest = size;
+        biggestKind = item?.type || "?";
+      }
+      if (item?.type === "message") countImages(item.content);
+      if (item?.type === "function_call_output") {
+        if (Array.isArray(item.output)) {
+          countImages(item.output);
+        } else if (typeof item.output === "string" && item.output.trim().startsWith("[")) {
+          try {
+            const parsed = JSON.parse(item.output);
+            if (Array.isArray(parsed)) countImages(parsed);
+          } catch {
+            // Ignore non-JSON tool output.
+          }
+        }
+      }
+    }
+
+    return { items: input.length, images, biggest, biggestKind };
+  } catch {
+    return { items: -1, images: -1, biggest: -1, biggestKind: "err" };
+  }
+}
+
+export function computeInitiator(messages) {
+  const isAgent = Array.isArray(messages)
+    && messages.some((m) => m && ["assistant", "tool"].includes(m.role));
+  return isAgent ? "agent" : "user";
+}
+
+export function computeVision(messages) {
+  return Array.isArray(messages) && messages.some(
+    (m) => m && typeof m.content !== "string"
+      && Array.isArray(m.content)
+      && m.content.some((p) => p && p.type === "image_url"),
+  );
+}
+
+export function buildHeaders({ token, version, initiator, vision }) {
+  const h = {
+    "Authorization": `Bearer ${token}`,
+    "Content-Type": "application/json",
+    "Copilot-Integration-Id": "vscode-chat",
+    "Editor-Version": `vscode/${version}`,
+    "Editor-Plugin-Version": "copilot-chat/0.26.7",
+    "User-Agent": "GitHubCopilotChat/0.26.7",
+    "Openai-Intent": "conversation-panel",
+    "X-Github-Api-Version": "2025-04-01",
+    "X-Request-Id": randomUUID(),
+    "X-Vscode-User-Agent-Library-Version": "electron-fetch",
+    "X-Initiator": initiator,
+  };
+  if (vision) h["Copilot-Vision-Request"] = "true";
+  return h;
+}
+
+export const FALLBACK_VSCODE_VERSION = "1.122.1";
+
+let cachedVersion = FALLBACK_VSCODE_VERSION;
+
+export function parseVSCodeVersion(json) {
+  return (json && typeof json.productVersion === "string" && json.productVersion)
+    ? json.productVersion
+    : FALLBACK_VSCODE_VERSION;
+}
+
+export function getVSCodeVersion() {
+  return cachedVersion;
+}
+
+// Refresh the VS Code version asynchronously; keep the fallback on failure.
+export async function refreshVSCodeVersion() {
+  try {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 5000);
+    const resp = await fetch(
+      "https://update.code.visualstudio.com/api/update/darwin-arm64/stable/latest",
+      { signal: ctrl.signal },
+    );
+    clearTimeout(timer);
+    if (resp.ok) {
+      cachedVersion = parseVSCodeVersion(await resp.json());
+      console.log(status("info", `VS Code version: ${cachedVersion}`));
+    }
+  } catch {
+    // Keep the fallback quietly.
+  }
+  return cachedVersion;
+}
+
+let copilotToken = null;
+let copilotTokenExpiry = 0;
+
+function getGithubToken() {
+  if (!fs.existsSync(GITHUB_TOKEN_PATH)) {
+    throw new Error("GitHub token not found. Run the tool once to log in.");
+  }
+  return fs.readFileSync(GITHUB_TOKEN_PATH, "utf-8").trim();
+}
+
+export async function getCopilotToken() {
+  if (copilotToken && Date.now() < copilotTokenExpiry - 60000) return copilotToken;
+  const ghToken = getGithubToken();
+  const resp = await fetch(`${GITHUB_API}/copilot_internal/v2/token`, {
+    headers: { Authorization: `token ${ghToken}`, Accept: "application/json" },
+  });
+  if (!resp.ok) throw new Error(`Failed to get Copilot token: ${resp.status}`);
+  const data = await resp.json();
+  if (!data.token) throw new Error("Copilot token response missing token field");
+  copilotToken = data.token;
+  apiBase = parseApiBase(data);
+  copilotTokenExpiry = typeof data.expires_at === "number"
+    ? data.expires_at * 1000
+    : Date.now() + 25 * 60 * 1000; // fallback if expires_at absent: refresh in ~25min
+  console.log(status("ok", "Copilot token refreshed"));
+  return copilotToken;
+}
+
+// chatReq is already converted by the adapter. The caller parses the raw Response.
+export async function chatCompletions(chatReq) {
+  const token = await getCopilotToken();
+  const messages = chatReq.messages || [];
+  const headers = buildHeaders({
+    token,
+    version: getVSCodeVersion(),
+    initiator: computeInitiator(messages),
+    vision: computeVision(messages),
+  });
+  return fetch(`${getApiBase()}/chat/completions`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(chatReq),
+  });
+}
+
+export async function listModels() {
+  const token = await getCopilotToken();
+  const headers = buildHeaders({
+    token, version: getVSCodeVersion(), initiator: "user", vision: false,
+  });
+  const resp = await fetch(`${getApiBase()}/models`, { headers });
+  return { status: resp.status, body: await resp.text() };
+}
+
+// Responses-only models go directly to Copilot's /responses endpoint.
+export async function responses(reqBody) {
+  const token = await getCopilotToken();
+  const beforeBytes = Buffer.byteLength(JSON.stringify(reqBody));
+  await optimizeImagesInBody(reqBody);
+  const bodyBuf = Buffer.from(JSON.stringify(reqBody), "utf8");
+  const summary = summarizeReqBody(reqBody);
+  console.log(status("info", `responses payload bytes=${bodyBuf.length} was=${beforeBytes} input_items=${summary.items} images=${summary.images} biggest_item=${summary.biggest}b (${summary.biggestKind})`));
+  const headers = buildHeaders({
+    token,
+    version: getVSCodeVersion(),
+    initiator: "user",
+    vision: false,
+  });
+  headers["Content-Type"] = "application/json; charset=utf-8";
+  headers["Content-Length"] = String(bodyBuf.length);
+  headers["Accept"] = reqBody.stream ? "text/event-stream" : "application/json";
+
+  try {
+    return await fetch(`${getApiBase()}${responsesEndpointPath()}`, {
+      method: "POST",
+      headers,
+      body: bodyBuf,
+    });
+  } catch (e) {
+    const cause = e?.cause;
+    const causeText = cause ? ` (${[cause.code, cause.message].filter(Boolean).join(": ")})` : "";
+    throw new Error(`Copilot responses fetch failed: ${e.message}${causeText}`);
+  }
+}
+
+export async function responsesCompact(reqBody) {
+  // GitHub Copilot accepts Codex compact payloads on the regular Responses endpoint.
+  return responses(reqBody);
+}

package/src/launcher.mjs

@@ -1,90 +1,19 @@
-import { spawn, execSync } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import net from "node:net";
+import { spawn } from "node:child_process";
+import { status } from "./status.mjs";
 
-const GITHUB_TOKEN_PATH = path.join(os.homedir(), ".local", "share", "copilot-api", "github_token");
-
-function isPortAccepting(port) {
-  return new Promise((resolve) => {
-    const sock = net.connect(port, "127.0.0.1");
-    let done = false;
-    const finish = (v) => { if (done) return; done = true; sock.destroy(); resolve(v); };
-    sock.once("connect", () => finish(true));
-    sock.once("error", () => finish(false));
-    sock.setTimeout(1000, () => finish(false));
-  });
-}
-
-export async function ensureAuth() {
-  if (fs.existsSync(GITHUB_TOKEN_PATH)) {
-    console.log("[codex-copilot-dx] GitHub token found");
-    return;
-  }
-  console.log("[codex-copilot-dx] No GitHub token. Running auth...");
-  const copilotApiBin = findCopilotApi();
-  execSync(`${copilotApiBin} auth`, { stdio: "inherit" });
-}
-
-function findCopilotApi() {
-  try {
-    return execSync("which copilot-api", { encoding: "utf-8" }).trim();
-  } catch {
-    // Try npx path
-    const npxPath = path.join(os.homedir(), ".npm/_npx");
-    if (fs.existsSync(npxPath)) {
-      for (const dir of fs.readdirSync(npxPath)) {
-        const bin = path.join(npxPath, dir, "node_modules/.bin/copilot-api");
-        if (fs.existsSync(bin)) return bin;
-      }
-    }
-    return "npx copilot-api";
-  }
-}
-
-export async function startCopilotApi(port = 4141) {
-  if (await isPortAccepting(port)) {
-    console.log(`[codex-copilot-dx] copilot-api already running on :${port}`);
-    return null;
-  }
-  console.log(`[codex-copilot-dx] Starting copilot-api on :${port}...`);
-  const copilotApiBin = findCopilotApi();
-  const child = spawn(copilotApiBin, ["start", "--port", String(port)], {
-    stdio: "pipe",
-    detached: false,
-  });
-  child.stdout?.on("data", (d) => {
-    const line = d.toString().trim();
-    if (line) console.log(`[copilot-api] ${line}`);
-  });
-  child.stderr?.on("data", (d) => {
-    const line = d.toString().trim();
-    if (line) console.log(`[copilot-api] ${line}`);
-  });
-
-  // Wait for it to be ready
-  for (let i = 0; i < 30; i++) {
-    await new Promise((r) => setTimeout(r, 500));
-    if (await isPortAccepting(port)) {
-      console.log(`[codex-copilot-dx] copilot-api ready on :${port}`);
-      return child;
-    }
-  }
-  throw new Error("copilot-api failed to start");
-}
+export { ensureAuth } from "./auth.mjs";
 
 export function openCodex() {
   if (process.platform === "darwin") {
     try {
       spawn("open", ["/Applications/Codex.app"], { detached: true, stdio: "ignore" });
-      console.log("[codex-copilot-dx] Codex app launched");
+      console.log(status("ok", "Codex app launched"));
     } catch {
-      console.log("[codex-copilot-dx] Codex app not found at /Applications/Codex.app");
-      console.log("  Download from: https://openai.com/codex");
+      console.log(status("warn", "Codex app not found at /Applications/Codex.app"));
+      console.log(status("info", "Download Codex from https://openai.com/codex"));
     }
   } else {
-    console.log("[codex-copilot-dx] Auto-launch not supported on this platform.");
-    console.log("  Open Codex manually, it will connect to the adapter.");
+    console.log(status("warn", "Auto-launch is not supported on this platform"));
+    console.log(status("info", "Open Codex manually; it will connect to the adapter."));
   }
 }

package/src/status.mjs

@@ -0,0 +1,11 @@
+const LABELS = {
+  info: "[INFO]",
+  ok: "[OK]",
+  wait: "[WAIT]",
+  warn: "[WARN]",
+  err: "[ERR]",
+};
+
+export function status(kind, message) {
+  return `${LABELS[kind] || LABELS.info} ${message}`;
+}

package/src/stream.mjs

@@ -0,0 +1,22 @@
+// Yield fetch Response body lines while preserving SSE semantics for callers.
+// Strip CRLF tails and release the reader if iteration stops early.
+export async function* webStreamLines(response) {
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split("\n");
+      buf = lines.pop();
+      for (const line of lines) yield line.replace(/\r$/, "");
+    }
+    buf += decoder.decode();
+    if (buf.length > 0) yield buf.replace(/\r$/, "");
+  } finally {
+    await reader.cancel().catch(() => {});
+    reader.releaseLock();
+  }
+}

package/src/usage.mjs

@@ -0,0 +1,192 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const DEFAULT_USAGE_PATH = path.join(os.homedir(), ".local", "share", "codex-copilot-dx", "usage.jsonl");
+
+let writeQueue = Promise.resolve();
+
+export function usageLogPath() {
+  return process.env.CCDX_USAGE_PATH || DEFAULT_USAGE_PATH;
+}
+
+function numberOrUndefined(value) {
+  return Number.isFinite(value) ? value : undefined;
+}
+
+function positiveNumber(value) {
+  const n = numberOrUndefined(value);
+  return n && n > 0 ? n : undefined;
+}
+
+function compactObject(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined && v !== null));
+}
+
+function hasPositiveTokenValue(usage) {
+  return Object.entries(usage || {}).some(([k, v]) => k.endsWith("_tokens") && Number.isFinite(v) && v > 0);
+}
+
+function normalizeResponsesUsage(usage) {
+  if (!usage || typeof usage !== "object") return undefined;
+  const out = compactObject({
+    input_tokens: positiveNumber(usage.input_tokens),
+    cached_input_tokens: positiveNumber(usage.cached_input_tokens ?? usage.input_tokens_details?.cached_tokens),
+    output_tokens: positiveNumber(usage.output_tokens),
+    reasoning_output_tokens: positiveNumber(usage.reasoning_output_tokens ?? usage.output_tokens_details?.reasoning_tokens),
+    total_tokens: positiveNumber(usage.total_tokens),
+  });
+  if (out.total_tokens === undefined && (out.input_tokens !== undefined || out.output_tokens !== undefined)) {
+    out.total_tokens = (out.input_tokens || 0) + (out.output_tokens || 0);
+  }
+  return hasPositiveTokenValue(out) ? out : undefined;
+}
+
+function normalizeAnthropicUsage(usage) {
+  if (!usage || typeof usage !== "object") return undefined;
+  const out = compactObject({
+    input_tokens: positiveNumber(usage.input_tokens),
+    cache_read_input_tokens: positiveNumber(usage.cache_read_input_tokens),
+    cache_creation_input_tokens: positiveNumber(usage.cache_creation_input_tokens),
+    output_tokens: positiveNumber(usage.output_tokens),
+  });
+  if (out.input_tokens !== undefined || out.cache_read_input_tokens !== undefined || out.cache_creation_input_tokens !== undefined || out.output_tokens !== undefined) {
+    out.total_tokens = (out.input_tokens || 0) + (out.cache_read_input_tokens || 0) + (out.cache_creation_input_tokens || 0) + (out.output_tokens || 0);
+  }
+  return hasPositiveTokenValue(out) ? out : undefined;
+}
+
+function normalizeCopilotUsage(copilotUsage) {
+  if (!copilotUsage || typeof copilotUsage !== "object") return undefined;
+  const out = {};
+  for (const detail of copilotUsage.token_details || []) {
+    const tokens = positiveNumber(detail?.token_count);
+    if (!tokens) continue;
+    switch (detail.token_type) {
+      case "input":
+        out.input_tokens = (out.input_tokens || 0) + tokens;
+        break;
+      case "cache_read":
+        out.cache_read_tokens = (out.cache_read_tokens || 0) + tokens;
+        break;
+      case "output":
+        out.output_tokens = (out.output_tokens || 0) + tokens;
+        break;
+      default:
+        out[`${detail.token_type || "unknown"}_tokens`] = (out[`${detail.token_type || "unknown"}_tokens`] || 0) + tokens;
+        break;
+    }
+  }
+  out.total_tokens = (out.input_tokens || 0) + (out.cache_read_tokens || 0) + (out.output_tokens || 0);
+  if (Number.isFinite(copilotUsage.total_nano_aiu)) out.total_nano_aiu = copilotUsage.total_nano_aiu;
+  return hasPositiveTokenValue(out) ? out : undefined;
+}
+
+export function buildResponsesUsageRecord({ surface = "responses", mode, model, response, event } = {}) {
+  const responseObj = response || event?.response;
+  const usage = normalizeResponsesUsage(responseObj?.usage);
+  const copilotUsage = normalizeCopilotUsage(event?.copilot_usage || responseObj?.copilot_usage);
+  if (!usage && !copilotUsage) return null;
+  return compactObject({
+    ts: new Date().toISOString(),
+    surface,
+    mode,
+    model: responseObj?.model || model,
+    response_id: responseObj?.id,
+    usage,
+    copilot_usage: copilotUsage,
+  });
+}
+
+export function buildAnthropicUsageRecord({ surface = "messages", mode, model, responseId, usage } = {}) {
+  const normalized = normalizeAnthropicUsage(usage);
+  if (!normalized) return null;
+  return compactObject({
+    ts: new Date().toISOString(),
+    surface,
+    mode,
+    model,
+    response_id: responseId,
+    usage: normalized,
+  });
+}
+
+export function recordUsage(record) {
+  if (!record || process.env.CCDX_DISABLE_USAGE === "1") return Promise.resolve();
+  const filePath = usageLogPath();
+  const line = `${JSON.stringify(record)}\n`;
+  writeQueue = writeQueue
+    .catch(() => {})
+    .then(async () => {
+      await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+      await fs.promises.appendFile(filePath, line, { encoding: "utf8", mode: 0o600 });
+    })
+    .catch((e) => console.error(`codex-copilot-dx usage log write failed: ${e.message}`));
+  return writeQueue;
+}
+
+export function recordResponsesUsage(args) {
+  return recordUsage(buildResponsesUsageRecord(args));
+}
+
+export function recordAnthropicUsage(args) {
+  return recordUsage(buildAnthropicUsageRecord(args));
+}
+
+export async function flushUsageWritesForTests() {
+  await writeQueue;
+}
+
+export async function readUsageRecords(filePath = usageLogPath()) {
+  try {
+    const text = await fs.promises.readFile(filePath, "utf8");
+    return text.split(/\n/).filter(Boolean).map((line) => JSON.parse(line));
+  } catch (e) {
+    if (e.code === "ENOENT") return [];
+    throw e;
+  }
+}
+
+function addUsageTotals(target, usage = {}) {
+  for (const [key, value] of Object.entries(usage)) {
+    if (Number.isFinite(value)) target[key] = (target[key] || 0) + value;
+  }
+}
+
+export function summarizeUsage(records) {
+  const totals = {};
+  const byModel = new Map();
+  for (const record of records) {
+    addUsageTotals(totals, record.usage);
+    if (record.copilot_usage) {
+      totals.copilot_total_tokens = (totals.copilot_total_tokens || 0) + (record.copilot_usage.total_tokens || 0);
+      totals.total_nano_aiu = (totals.total_nano_aiu || 0) + (record.copilot_usage.total_nano_aiu || 0);
+    }
+    const model = record.model || "unknown";
+    if (!byModel.has(model)) byModel.set(model, { requests: 0 });
+    const modelTotals = byModel.get(model);
+    modelTotals.requests += 1;
+    addUsageTotals(modelTotals, record.usage);
+  }
+  return { requests: records.length, totals, byModel: Object.fromEntries(byModel) };
+}
+
+function fmt(n) {
+  return Number.isFinite(n) ? n.toLocaleString("en-US") : "0";
+}
+
+export async function printUsageSummary() {
+  const records = await readUsageRecords();
+  const summary = summarizeUsage(records);
+  console.log(`Usage log: ${usageLogPath()}`);
+  if (summary.requests === 0) {
+    console.log("No usage records yet.");
+    return;
+  }
+  console.log(`Requests: ${fmt(summary.requests)}`);
+  console.log(`Tokens: input=${fmt(summary.totals.input_tokens)} cache_read=${fmt(summary.totals.cache_read_input_tokens || summary.totals.cached_input_tokens)} output=${fmt(summary.totals.output_tokens)} total=${fmt(summary.totals.total_tokens)}`);
+  console.log("\nBy model:");
+  for (const [model, row] of Object.entries(summary.byModel)) {
+    console.log(`  ${model}: requests=${fmt(row.requests)} input=${fmt(row.input_tokens)} cache_read=${fmt(row.cache_read_input_tokens || row.cached_input_tokens)} output=${fmt(row.output_tokens)} total=${fmt(row.total_tokens)}`);
+  }
+}

package/CHANGELOG.md

@@ -1,19 +0,0 @@
-# Changelog
-
-## 0.1.6
-
-### Fixed
-- **413 Payload Too Large** on `/v1/responses` for long computer-use sessions. The Codex Desktop computer-use tool embeds screenshots as `input_image` parts inside `function_call_output.output` (sometimes as a stringified JSON array). After dozens of tool turns these accumulate to >5MB and hit GitHub Copilot's request size limit. The adapter now walks tool outputs, decodes embedded base64 images, and re-encodes them as WebP at long-edge ≤ 2048px before forwarding to the upstream.
-
-### Added
-- Automatic image optimization with `sharp`. Tunable via env vars:
-  - `CCDX_IMG_MAX_DIM` (default `2048`) – max long edge in pixels
-  - `CCDX_IMG_QUALITY` (default `85`) – WebP quality
-  - `CCDX_IMG_MIN_BYTES` (default `100000`) – skip images smaller than this
-  - `CCDX_DISABLE_IMG_OPT=1` – disable optimization entirely
-  - `CCDX_DEBUG=1` – verbose diagnostics
-- Per-request log line with byte counts before/after optimization, image count, and biggest item size.
-- Upstream error responses (status, headers, body) are now logged when non-2xx, making 413/auth issues much easier to diagnose.
-
-### Internal
-- Request headers to Copilot now set explicit `Content-Length`, `Content-Type: application/json; charset=utf-8`, and `Accept` to avoid undici picking chunked transfer for large bodies.