codex-copilot-dx 0.4.0 → 0.4.1

package/README.md

@@ -47,6 +47,16 @@ Environment variables:
 | `CCDX_IMG_QUALITY` | `85` | WebP quality used when re-encoding images |
 | `CCDX_IMG_MIN_BYTES` | `100000` | Images smaller than this are left untouched |
 | `CCDX_DISABLE_IMG_OPT` | unset | Set to `1` to disable image optimization |
+| `CCDX_USAGE_PATH` | `~/.local/share/codex-copilot-dx/usage.jsonl` | Local JSONL token usage log |
+| `CCDX_DISABLE_USAGE` | unset | Set to `1` to disable usage logging |
+
+### Usage logging
+
+The adapter records token usage metadata to `~/.local/share/codex-copilot-dx/usage.jsonl` when upstream responses include usage fields. It logs counts, model names, API surface, and response IDs only; it does not log prompts, completions, tool arguments, or image content.
+
+```bash
+codex-copilot-dx usage
+```
 
 ### Image optimization
 

package/bin/cli.mjs

@@ -6,9 +6,15 @@ import { ensureClaudeConfig } from "../src/claude-config.mjs";
 import { startAdapter } from "../src/adapter.mjs";
 import { refreshVSCodeVersion } from "../src/copilot.mjs";
 import { status } from "../src/status.mjs";
+import { printUsageSummary } from "../src/usage.mjs";
 
 const ADAPTER_PORT = parseInt(process.env.ADAPTER_PORT || "2026");
 
+if (process.argv[2] === "usage") {
+  await printUsageSummary();
+  process.exit(0);
+}
+
 console.log(`
   codex-copilot-dx
   Use Codex Desktop with GitHub Copilot

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Use Codex Desktop app with your GitHub Copilot subscription",
   "type": "module",
   "bin": {

package/src/adapter.mjs

@@ -4,6 +4,7 @@ import { chatCompletions, listModels, responses as copilotResponses, responsesCo
 import { webStreamLines } from "./stream.mjs";
 import { anthropicToChat, chatToAnthropic, streamAnthropicFromLines, countTokens } from "./anthropic.mjs";
 import { status } from "./status.mjs";
+import { recordAnthropicUsage, recordResponsesUsage } from "./usage.mjs";
 
 // Models that only support Responses API (not chat/completions)
 const RESPONSES_ONLY = new Set([
@@ -81,7 +82,16 @@ function storeCompletedResponseFromSse(reqContext, data) {
   try {
     const event = JSON.parse(data);
     const response = event.response;
-    if (response?.id && response.status === "completed") rememberResponseHistory(reqContext, response);
+    if (response?.id && response.status === "completed") {
+      rememberResponseHistory(reqContext, response);
+      recordResponsesUsage({
+        surface: reqContext.surface,
+        mode: "stream",
+        model: reqContext.body?.model,
+        response,
+        event,
+      });
+    }
   } catch {
     // Ignore non-JSON stream fragments.
   }
@@ -131,7 +141,17 @@ async function proxyCopilotResponses(reqContext, req, res, upstream = copilotRes
     res.writeHead(resp.status, { "Content-Type": "application/json" });
     res.end(data);
     if (resp.ok) {
-      try { rememberResponseHistory(reqContext, JSON.parse(data)); } catch {}
+      try {
+        const response = JSON.parse(data);
+        rememberResponseHistory(reqContext, response);
+        recordResponsesUsage({
+          surface: reqContext.surface,
+          mode: "json",
+          model: reqContext.body?.model,
+          response,
+          event: response,
+        });
+      } catch {}
     }
   }
 }
@@ -264,6 +284,7 @@ export function startAdapter(port = 2026) {
         try {
           const parsed = JSON.parse(body);
           const prepared = prepareResponsesRequest(parsed);
+          prepared.surface = "responses";
           const model = parsed.model || "unknown";
           console.log(status("info", `responses model=${model} stream=${!!parsed.stream}`));
           if (RESPONSES_ONLY.has(model)) {
@@ -274,7 +295,10 @@ export function startAdapter(port = 2026) {
               forwardToChat(chatReq, (event, data) => {
                 if (!res.headersSent) res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
                 res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
-                if (event === "response.completed") rememberResponseHistory(prepared, data.response);
+                if (event === "response.completed") {
+                  rememberResponseHistory(prepared, data.response);
+                  recordResponsesUsage({ surface: prepared.surface, mode: "stream", model, response: data.response, event: data });
+                }
               }, () => { if (!res.writableEnded) res.end(); }, (status, errMsg) => { if (!res.headersSent) res.writeHead(status || 500); res.end(errMsg); });
             } else {
               chatReq.stream = false;
@@ -284,6 +308,7 @@ export function startAdapter(port = 2026) {
                 const data = await upstream.text();
                 const resp = chatToResponses(JSON.parse(data), model);
                 rememberResponseHistory(prepared, resp);
+                recordResponsesUsage({ surface: prepared.surface, mode: "json", model, response: resp, event: resp });
                 res.writeHead(200, { "Content-Type": "application/json" });
                 res.end(JSON.stringify(resp));
               } catch (e) {
@@ -308,6 +333,7 @@ export function startAdapter(port = 2026) {
         try {
           const parsed = JSON.parse(body);
           const prepared = prepareResponsesRequest(parsed);
+          prepared.surface = "responses_compact";
           const model = parsed.model || "unknown";
           console.log(status("info", `responses compact model=${model} stream=${!!parsed.stream}`));
           await proxyCopilotResponses(prepared, req, res, copilotResponsesCompact);
@@ -360,16 +386,24 @@ export function startAdapter(port = 2026) {
               return;
             }
             res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive" });
+            let messageId;
+            let usage;
             await streamAnthropicFromLines(
               webStreamLines(upstream),
-              (event, data) => res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`),
+              (event, data) => {
+                if (event === "message_start") messageId = data.message?.id;
+                if (event === "message_delta") usage = data.usage;
+                res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+              },
               model,
             );
+            recordAnthropicUsage({ surface: "messages", mode: "stream", model, responseId: messageId, usage });
             if (!res.writableEnded) res.end();
           } else {
             const upstream = await chatCompletions({ ...chatReq, stream: false });
             const data = await upstream.text();
             const anthropicMsg = chatToAnthropic(JSON.parse(data), model);
+            recordAnthropicUsage({ surface: "messages", mode: "json", model: anthropicMsg.model, responseId: anthropicMsg.id, usage: anthropicMsg.usage });
             res.writeHead(200, { "Content-Type": "application/json" });
             res.end(JSON.stringify(anthropicMsg));
           }

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)}`);
+  }
+}