codex-copilot-dx 0.4.32 → 0.4.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-copilot-dx",
-  "version": "0.4.32",
+  "version": "0.4.33",
   "description": "Use Codex Desktop, Claude Code, and Claude App with GitHub Copilot",
   "author": "Dale Xiao",
   "type": "module",
@@ -10,6 +10,7 @@
   "files": [
     "bin/",
     "src/",
+    "scripts/benchmark.mjs",
     "README.md"
   ],
   "keywords": [
@@ -41,6 +42,7 @@
     "test": "node --test",
     "test:smoke": "node scripts/offline-smoke.mjs",
     "test:e2e": "bash test/e2e.sh",
+    "bench": "node scripts/benchmark.mjs",
     "pack:check": "npm pack --dry-run --json",
     "verify": "npm test && npm run test:smoke && npm run pack:check",
     "prepublishOnly": "npm run verify"

package/scripts/benchmark.mjs

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import { setTimeout as delay } from "node:timers/promises";
+import { fileURLToPath } from "node:url";
+import sharp from "sharp";
+import { optimizeImagesInBody, prepareResponsesPayload } from "../src/image-optimization.mjs";
+
+const packageRoot = fileURLToPath(new URL("../", import.meta.url));
+
+function runProbe(source) {
+  const result = spawnSync(process.execPath, ["--expose-gc", "--input-type=module", "-e", source], {
+    cwd: packageRoot,
+    encoding: "utf8",
+  });
+  if (result.status !== 0) {
+    throw new Error(result.stderr.trim() || `benchmark probe exited with ${result.status}`);
+  }
+  return JSON.parse(result.stdout.trim());
+}
+
+function deterministicPixels(byteLength, initialSeed) {
+  const pixels = Buffer.alloc(byteLength);
+  let seed = initialSeed;
+  for (let index = 0; index < pixels.length; index += 1) {
+    seed = ((seed * 1664525) + 1013904223) >>> 0;
+    pixels[index] = seed >>> 24;
+  }
+  return pixels;
+}
+
+const adapterImport = runProbe(`
+  const started = performance.now();
+  await import("./src/adapter.mjs");
+  globalThis.gc?.();
+  const memory = process.memoryUsage();
+  console.log(JSON.stringify({
+    elapsed_ms: +(performance.now() - started).toFixed(1),
+    rss_mib: +(memory.rss / 1048576).toFixed(1),
+    heap_used_mib: +(memory.heapUsed / 1048576).toFixed(1),
+  }));
+`);
+
+const tokenCount = runProbe(`
+  const importStarted = performance.now();
+  const { countTokens } = await import("./src/anthropic.mjs");
+  const importMs = performance.now() - importStarted;
+  const body = { messages: [{ role: "user", content: "a ".repeat(50000) }] };
+  const firstStarted = performance.now();
+  const first = await countTokens(body);
+  const firstMs = performance.now() - firstStarted;
+  const warmStarted = performance.now();
+  const warm = await countTokens(body);
+  const warmMs = performance.now() - warmStarted;
+  globalThis.gc?.();
+  const memory = process.memoryUsage();
+  console.log(JSON.stringify({
+    module_import_ms: +importMs.toFixed(1),
+    first_call_ms: +firstMs.toFixed(1),
+    warm_call_ms: +warmMs.toFixed(1),
+    input_tokens: first.input_tokens,
+    deterministic: first.input_tokens === warm.input_tokens,
+    rss_mib: +(memory.rss / 1048576).toFixed(1),
+  }));
+`);
+
+const repeatedImage = "data:image/png;base64,QUJDRA==";
+const duplicateBody = {
+  input: [{
+    type: "message",
+    role: "user",
+    content: Array.from({ length: 8 }, () => ({ type: "input_image", image_url: repeatedImage })),
+  }],
+};
+let duplicateCalls = 0;
+const duplicateStarted = performance.now();
+await optimizeImagesInBody(duplicateBody, {
+  concurrency: 2,
+  optimizeImage: async (value) => {
+    duplicateCalls += 1;
+    await delay(5);
+    return value;
+  },
+});
+const duplicateImages = {
+  elapsed_ms: +(performance.now() - duplicateStarted).toFixed(1),
+  image_occurrences: 8,
+  optimizer_calls: duplicateCalls,
+};
+
+const pixels = deterministicPixels(1024 * 1024 * 3, 0x87654321);
+const webp = await sharp(pixels, { raw: { width: 1024, height: 1024, channels: 3 } })
+  .webp({ quality: 100 })
+  .toBuffer();
+const payloadBody = {
+  input: [{
+    type: "message",
+    role: "user",
+    content: [{ type: "input_image", image_url: `data:image/webp;base64,${webp.toString("base64")}` }],
+  }],
+};
+const originalLog = console.log;
+const originalWarn = console.warn;
+let oversizedPayload;
+let profilePasses = 0;
+try {
+  console.log = () => {};
+  console.warn = () => { profilePasses += 1; };
+  const started = performance.now();
+  const result = await prepareResponsesPayload(payloadBody, {
+    maxBytes: 300000,
+    profiles: [
+      { maxDim: 800, quality: 75 },
+      { maxDim: 640, quality: 65 },
+    ],
+  });
+  oversizedPayload = {
+    elapsed_ms: +(performance.now() - started).toFixed(1),
+    original_image_bytes: webp.length,
+    output_body_bytes: result.bodyBytes,
+    profile_passes: profilePasses,
+    adapted: result.adapted,
+  };
+} finally {
+  console.log = originalLog;
+  console.warn = originalWarn;
+}
+
+console.log(JSON.stringify({
+  note: "Report-only benchmark; timings vary by machine and are not pass/fail thresholds.",
+  adapter_import: adapterImport,
+  token_count_100kb: tokenCount,
+  duplicate_images: duplicateImages,
+  oversized_payload: oversizedPayload,
+}, null, 2));

package/src/adapter.mjs

@@ -890,7 +890,7 @@ export function createAdapterHandler(options = {}) {
         try {
           const parsed = await readJsonBody(req);
           res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify(countTokens(parsed)));
+          res.end(JSON.stringify(await countTokens(parsed)));
         } catch (e) {
           sendJsonError(res, e);
         } finally {

package/src/anthropic.mjs

@@ -1,5 +1,11 @@
 import { randomUUID } from "node:crypto";
-import { encode } from "gpt-tokenizer";
+
+let tokenizerModulePromise = null;
+
+async function tokenEncoder() {
+  tokenizerModulePromise ||= import("gpt-tokenizer");
+  return (await tokenizerModulePromise).encode;
+}
 
 // Anthropic Messages API to OpenAI chat/completions translation.
 // Pure functions only; network calls stay in adapter.mjs and copilot.mjs.
@@ -252,7 +258,7 @@ export async function streamAnthropicFromLines(lineIterator, emit, model, option
 }
 
 // Copilot has no count_tokens endpoint; estimate locally with gpt-tokenizer.
-export function countTokens(body) {
+export async function countTokens(body) {
   const parts = [];
   const sys = systemToText(body.system);
   if (sys) parts.push(sys);
@@ -276,5 +282,6 @@ export function countTokens(body) {
   }
 
   const text = parts.join("\n");
+  const encode = await tokenEncoder();
   return { input_tokens: encode(text).length };
 }

package/src/copilot.mjs

@@ -9,6 +9,7 @@ import { prepareResponsesPayload } from "./image-optimization.mjs";
 export {
   optimizeImageDataUrl,
   optimizeImagesInBody,
+  createTaskLimiter,
   parseImageConcurrency,
   prepareResponsesPayload,
   runWithConcurrency,
@@ -266,6 +267,7 @@ export async function refreshVSCodeVersion() {
 let copilotToken = null;
 let copilotTokenExpiry = 0;
 let copilotTokenRefresh = null;
+const modelListFlights = new Map();
 
 function getGithubToken({ home = os.homedir() } = {}) {
   const GITHUB_TOKEN_PATH = githubTokenPath(home);
@@ -343,6 +345,7 @@ export function resetCopilotTokenForTests() {
   copilotTokenExpiry = 0;
   copilotTokenRefresh = null;
   apiBase = DEFAULT_API_BASE;
+  resetModelListSingleflightForTests();
 }
 
 // chatReq is already converted by the adapter. The caller parses the raw Response.
@@ -363,7 +366,7 @@ export async function chatCompletions(chatReq, { signal, fetchImpl, retryOptions
   }, { fetchImpl, ...retryOptions });
 }
 
-export async function listModels({ signal, fetchImpl, retryOptions } = {}) {
+async function fetchModels({ signal, fetchImpl, retryOptions }) {
   const token = await getCopilotToken({ signal });
   const headers = buildHeaders({
     token, version: getVSCodeVersion(), initiator: "user", vision: false,
@@ -376,10 +379,61 @@ export async function listModels({ signal, fetchImpl, retryOptions } = {}) {
   return { status: resp.status, body };
 }
 
+function waitForModelListFlight(flight, signal) {
+  if (signal?.aborted) return Promise.reject(abortError(signal));
+  flight.waiters += 1;
+
+  return new Promise((resolve, reject) => {
+    let finished = false;
+    const finish = (handler, value) => {
+      if (finished) return;
+      finished = true;
+      signal?.removeEventListener("abort", onAbort);
+      flight.waiters -= 1;
+      if (!flight.settled && flight.waiters === 0) flight.controller.abort();
+      handler(value);
+    };
+    const onAbort = () => finish(reject, abortError(signal));
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) onAbort();
+    flight.promise.then(
+      (value) => finish(resolve, value),
+      (error) => finish(reject, error),
+    );
+  });
+}
+
+export function listModels({ signal, fetchImpl = fetch, retryOptions } = {}) {
+  if (signal?.aborted) return Promise.reject(abortError(signal));
+  let flight = modelListFlights.get(fetchImpl);
+  if (flight?.controller.signal.aborted) {
+    modelListFlights.delete(fetchImpl);
+    flight = null;
+  }
+
+  if (!flight) {
+    const controller = new AbortController();
+    flight = { controller, waiters: 0, settled: false, promise: null };
+    flight.promise = fetchModels({ signal: controller.signal, fetchImpl, retryOptions })
+      .finally(() => {
+        flight.settled = true;
+        if (modelListFlights.get(fetchImpl) === flight) modelListFlights.delete(fetchImpl);
+      });
+    modelListFlights.set(fetchImpl, flight);
+  }
+
+  return waitForModelListFlight(flight, signal);
+}
+
+export function resetModelListSingleflightForTests() {
+  for (const flight of modelListFlights.values()) flight.controller.abort();
+  modelListFlights.clear();
+}
+
 // Responses-only models go directly to Copilot's /responses endpoint.
 export async function responses(reqBody, { signal, fetchImpl, retryOptions } = {}) {
   const token = await getCopilotToken({ signal });
-  const { bodyText, bodyBytes, summary } = await prepareResponsesPayload(reqBody);
+  const { bodyText, bodyBytes, summary } = await prepareResponsesPayload(reqBody, { signal });
   console.log(status("info", `responses payload bytes=${bodyBytes} input_items=${summary.items} images=${summary.images}`));
   const headers = buildHeaders({
     token,

package/src/image-optimization.mjs

@@ -35,6 +35,66 @@ export function parseImageConcurrency(value) {
   return Number.isFinite(n) && n > 0 ? Math.min(n, IMG_MAX_CONCURRENCY) : DEFAULT_IMG_CONCURRENCY;
 }
 
+function abortError(signal) {
+  if (signal?.reason instanceof Error) return signal.reason;
+  const error = new Error("The operation was aborted");
+  error.name = "AbortError";
+  return error;
+}
+
+export function createTaskLimiter(concurrency) {
+  const limit = parseImageConcurrency(concurrency);
+  const queue = [];
+  let active = 0;
+
+  const drain = () => {
+    while (active < limit && queue.length) {
+      const entry = queue.shift();
+      if (entry.cancelled) continue;
+      entry.cleanup();
+      if (entry.signal?.aborted) {
+        entry.reject(abortError(entry.signal));
+        continue;
+      }
+      active += 1;
+      entry.resolve();
+    }
+  };
+
+  return async function runLimited(task, { signal } = {}) {
+    if (signal?.aborted) throw abortError(signal);
+    await new Promise((resolve, reject) => {
+      const entry = {
+        cancelled: false,
+        cleanup: () => signal?.removeEventListener("abort", onAbort),
+        reject,
+        resolve,
+        signal,
+      };
+      const onAbort = () => {
+        entry.cancelled = true;
+        entry.cleanup();
+        reject(abortError(signal));
+        drain();
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      queue.push(entry);
+      if (signal?.aborted) onAbort();
+      else drain();
+    });
+
+    try {
+      if (signal?.aborted) throw abortError(signal);
+      return await task();
+    } finally {
+      active -= 1;
+      drain();
+    }
+  };
+}
+
+const runGlobalImageTask = createTaskLimiter(IMG_CONCURRENCY);
+
 async function sharp() {
   sharpImport ||= import("sharp");
   const mod = await sharpImport;
@@ -63,6 +123,7 @@ export async function optimizeImageDataUrl(dataUrl, {
   maxDim = IMG_MAX_DIM,
   quality = IMG_QUALITY,
   force = false,
+  signal,
 } = {}) {
   if (IMG_OPT_DISABLED) return dataUrl;
   if (typeof dataUrl !== "string" || !dataUrl.startsWith("data:")) return dataUrl;
@@ -75,22 +136,26 @@ export async function optimizeImageDataUrl(dataUrl, {
   if (!force && touchOptimizedImage(digest)) return dataUrl;
 
   try {
-    const resize = await sharp();
-    const image = resize(raw, { failOn: "none", limitInputPixels: IMG_MAX_INPUT_PIXELS });
-    const out = await image
-      .rotate()
-      .resize(positiveInt(maxDim, IMG_MAX_DIM), positiveInt(maxDim, IMG_MAX_DIM), { fit: "inside", withoutEnlargement: true })
-      .webp({ quality: positiveInt(quality, IMG_QUALITY, 100), effort: 4 })
-      .toBuffer();
-    if (out.length >= raw.length) {
-      rememberOptimizedImage(digest);
-      return dataUrl;
-    }
-    rememberOptimizedImage(imageDigest(out));
-    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")}`;
+    return await runGlobalImageTask(async () => {
+      const resize = await sharp();
+      const image = resize(raw, { failOn: "none", limitInputPixels: IMG_MAX_INPUT_PIXELS });
+      const out = await image
+        .rotate()
+        .resize(positiveInt(maxDim, IMG_MAX_DIM), positiveInt(maxDim, IMG_MAX_DIM), { fit: "inside", withoutEnlargement: true })
+        .webp({ quality: positiveInt(quality, IMG_QUALITY, 100), effort: 4 })
+        .toBuffer();
+      if (signal?.aborted) throw abortError(signal);
+      if (out.length >= raw.length) {
+        rememberOptimizedImage(digest);
+        return dataUrl;
+      }
+      rememberOptimizedImage(imageDigest(out));
+      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 });
   } catch (e) {
+    if (signal?.aborted || e?.name === "AbortError") throw e;
     console.warn(status("warn", `image optimize failed (${mime}, ${raw.length}b): ${e.message}`));
     return dataUrl;
   }
@@ -131,19 +196,27 @@ function visitImageParts(parts, tasks, optimizeImage) {
 export async function optimizeImagesInBody(reqBody, {
   concurrency = IMG_CONCURRENCY,
   optimizeImage = optimizeImageDataUrl,
+  signal,
 } = {}) {
   if (IMG_OPT_DISABLED || !Array.isArray(reqBody.input)) return reqBody;
   const tasks = [];
   const finalize = [];
+  const optimizedByDataUrl = new Map();
+  const optimizeOnce = (dataUrl) => {
+    if (!optimizedByDataUrl.has(dataUrl)) {
+      optimizedByDataUrl.set(dataUrl, Promise.resolve().then(() => optimizeImage(dataUrl, { signal })));
+    }
+    return optimizedByDataUrl.get(dataUrl);
+  };
 
   for (const item of reqBody.input) {
     if (!item) continue;
     if (item.type === "message" && Array.isArray(item.content)) {
-      visitImageParts(item.content, tasks, optimizeImage);
+      visitImageParts(item.content, tasks, optimizeOnce);
     }
     if (item.type === "function_call_output") {
       if (Array.isArray(item.output)) {
-        visitImageParts(item.output, tasks, optimizeImage);
+        visitImageParts(item.output, tasks, optimizeOnce);
       } else if (typeof item.output === "string") {
         const trimmed = item.output.trim();
         if (trimmed.startsWith("[")) {
@@ -151,7 +224,7 @@ export async function optimizeImagesInBody(reqBody, {
             const parsed = JSON.parse(trimmed);
             if (Array.isArray(parsed)) {
               const taskCount = tasks.length;
-              visitImageParts(parsed, tasks, optimizeImage);
+              visitImageParts(parsed, tasks, optimizeOnce);
               if (tasks.length > taskCount) finalize.push(() => { item.output = JSON.stringify(parsed); });
             }
           } catch {
@@ -170,8 +243,9 @@ export async function optimizeImagesInBody(reqBody, {
 export async function prepareResponsesPayload(reqBody, {
   maxBytes = MAX_UPSTREAM_BODY_BYTES,
   profiles = OVERSIZE_IMAGE_PROFILES,
+  signal,
 } = {}) {
-  await optimizeImagesInBody(reqBody);
+  await optimizeImagesInBody(reqBody, { signal });
   let bodyText = JSON.stringify(reqBody);
   let bodyBytes = Buffer.byteLength(bodyText);
   const summary = summarizeReqBody(reqBody);
@@ -183,7 +257,8 @@ export async function prepareResponsesPayload(reqBody, {
       const beforeBytes = bodyBytes;
       bodyText = "";
       await optimizeImagesInBody(reqBody, {
-        optimizeImage: (dataUrl) => optimizeImageDataUrl(dataUrl, { ...profile, force: true }),
+        optimizeImage: (dataUrl) => optimizeImageDataUrl(dataUrl, { ...profile, force: true, signal }),
+        signal,
       });
       bodyText = JSON.stringify(reqBody);
       bodyBytes = Buffer.byteLength(bodyText);