codex-copilot-dx 0.1.6 → 0.4.1

package/src/adapter.mjs

@@ -1,142 +1,10 @@
 import http from "node:http";
-import https from "node:https";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import { randomUUID, createHash } from "node:crypto";
-import sharp from "sharp";
-
-const COPILOT_API_PORT = parseInt(process.env.COPILOT_API_PORT || "4141");
-const COPILOT_API = "https://api.githubcopilot.com";
-const GITHUB_API = "https://api.github.com";
-
-// Image optimization knobs
-const IMG_MAX_DIM = parseInt(process.env.CCDX_IMG_MAX_DIM || "2048");
-const IMG_QUALITY = parseInt(process.env.CCDX_IMG_QUALITY || "85");
-const IMG_MIN_BYTES = parseInt(process.env.CCDX_IMG_MIN_BYTES || "100000");
-const IMG_OPT_DISABLED = process.env.CCDX_DISABLE_IMG_OPT === "1";
-const CCDX_DEBUG = process.env.CCDX_DEBUG === "1";
-
-async function optimizeImageDataUrl(dataUrl) {
-  if (IMG_OPT_DISABLED) return dataUrl;
-  if (typeof dataUrl !== "string" || !dataUrl.startsWith("data:")) return dataUrl;
-  const m = /^data:(image\/[a-z+.-]+);base64,(.+)$/i.exec(dataUrl);
-  if (!m) return dataUrl;
-  const mime = m[1].toLowerCase();
-  const b64 = m[2];
-  const raw = Buffer.from(b64, "base64");
-  if (raw.length < IMG_MIN_BYTES) return dataUrl;
-  // Skip animated formats — sharp will pick first frame and lose animation; better to leave alone
-  if (mime.includes("gif")) return dataUrl;
-  try {
-    const out = await sharp(raw, { failOn: "none" })
-      .rotate() // honor EXIF orientation
-      .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(`[codex-copilot-dx] 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(`[codex-copilot-dx] image optimize failed (${mime}, ${raw.length}b): ${e.message}`);
-    return dataUrl;
-  }
-}
-
-async function optimizeImagesInBody(reqBody) {
-  if (IMG_OPT_DISABLED) return reqBody;
-  if (!Array.isArray(reqBody.input)) return reqBody;
-  const tasks = [];
-
-  const visitParts = (parts) => {
-    if (!Array.isArray(parts)) return;
-    for (const part of parts) {
-      if (!part) continue;
-      // Responses API image part shape: { type: "input_image", image_url: "data:..." }
-      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) {
-        // Anthropic style
-        tasks.push((async () => {
-          const dataUrl = `data:${part.source.media_type || "image/png"};base64,${part.source.data}`;
-          const opt = await optimizeImageDataUrl(dataUrl);
-          const m = /^data:([^;]+);base64,(.+)$/.exec(opt);
-          if (m) { part.source.media_type = m[1]; part.source.data = m[2]; }
-        })());
-      }
-    }
-  };
-
-  for (const item of reqBody.input) {
-    if (!item) continue;
-    // Plain user/assistant message
-    if (item.type === "message" && Array.isArray(item.content)) {
-      visitParts(item.content);
-    }
-    // computer-use / tool results: function_call_output.output can be a
-    // structured array of parts (input_text, input_image, ...) carrying screenshots.
-    if (item.type === "function_call_output") {
-      if (Array.isArray(item.output)) {
-        visitParts(item.output);
-      } else if (typeof item.output === "string") {
-        // Some tools stringify a JSON array of parts. Parse, optimize images
-        // inside, then re-serialize AFTER all image tasks for this array finish.
-        const trimmed = item.output.trim();
-        if (trimmed.startsWith("[")) {
-          try {
-            const parsed = JSON.parse(trimmed);
-            if (Array.isArray(parsed)) {
-              const before = tasks.length;
-              visitParts(parsed);
-              const localTasks = tasks.slice(before); // tasks added by visitParts
-              if (localTasks.length) {
-                tasks.push(
-                  Promise.all(localTasks).then(() => {
-                    item.output = JSON.stringify(parsed);
-                  })
-                );
-              }
-            }
-          } catch { /* not JSON, leave it */ }
-        }
-      }
-    }
-  }
-  if (tasks.length) await Promise.all(tasks);
-  return reqBody;
-}
-
-function summarizeReqBody(reqBody) {
-  try {
-    const inp = reqBody.input;
-    if (!Array.isArray(inp)) return { items: 0, images: 0, biggest: 0, biggestKind: "n/a" };
-    let biggest = 0, biggestKind = "", biggestItem = null, images = 0;
-    const countImages = (parts) => {
-      if (!Array.isArray(parts)) return;
-      for (const p of parts) {
-        if (p?.type === "input_image" || p?.type === "image") images++;
-      }
-    };
-    for (const it of inp) {
-      const s = JSON.stringify(it);
-      if (s.length > biggest) { biggest = s.length; biggestKind = it.type || "?"; biggestItem = it; }
-      if (it?.type === "message") countImages(it.content);
-      if (it?.type === "function_call_output") {
-        if (Array.isArray(it.output)) countImages(it.output);
-        else if (typeof it.output === "string" && it.output.trim().startsWith("[")) {
-          try { const p = JSON.parse(it.output); if (Array.isArray(p)) countImages(p); } catch {}
-        }
-      }
-    }
-    // Diagnostic: peek at the biggest function_call_output to see if it embeds images
-    let biggestPeek = "";
-    if (CCDX_DEBUG && biggestItem?.type === "function_call_output") {
-      const out = typeof biggestItem.output === "string" ? biggestItem.output : JSON.stringify(biggestItem.output);
-      biggestPeek = out.slice(0, 200);
-    }
-    return { items: inp.length, images, biggest, biggestKind, biggestPeek };
-  } catch { return { items: -1, images: -1, biggest: -1, biggestKind: "err", biggestPeek: "" }; }
-}
+import { randomUUID } from "node:crypto";
+import { chatCompletions, listModels, responses as copilotResponses, responsesCompact as copilotResponsesCompact } from "./copilot.mjs";
+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([
@@ -147,162 +15,148 @@ const RESPONSES_ONLY = new Set([
   "gpt-5.2-codex",
 ]);
 
-// ── Copilot Token ──
+// Direct Copilot Responses API proxy.
 
-let copilotToken = null;
-let copilotTokenExpiry = 0;
+const RESPONSE_HISTORY_LIMIT = 64;
+const responseHistories = new Map();
 
-function getGithubToken() {
-  const p = path.join(os.homedir(), ".local", "share", "copilot-api", "github_token");
-  if (!fs.existsSync(p)) throw new Error("GitHub token not found. Run: npx copilot-api auth");
-  return fs.readFileSync(p, "utf-8").trim();
+export function requestPath(reqUrl) {
+  return new URL(reqUrl || "/", "http://localhost").pathname;
 }
 
-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();
-  copilotToken = data.token;
-  copilotTokenExpiry = data.expires_at * 1000;
-  console.log("[codex-copilot-dx] Copilot token refreshed");
-  return copilotToken;
+function cloneJson(value) {
+  return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
 }
 
-// ── Direct Copilot Responses API proxy ──
-
-async function proxyCopilotResponses(reqBody, req, res) {
-  const beforeBytes = Buffer.byteLength(JSON.stringify(reqBody));
-  await optimizeImagesInBody(reqBody);
-  const token = await getCopilotToken();
-  const bodyStr = JSON.stringify(reqBody);
-  const bodyBuf = Buffer.from(bodyStr, "utf-8");
-  const summary = summarizeReqBody(reqBody);
-  console.log(`[codex-copilot-dx] → responses model=${reqBody.model} stream=${!!reqBody.stream} bytes=${bodyBuf.length} (was ${beforeBytes}) input_items=${summary.items} images=${summary.images} biggest_item=${summary.biggest}b (${summary.biggestKind})`);
-  if (summary.biggestPeek) console.log(`[codex-copilot-dx]   peek: ${JSON.stringify(summary.biggestPeek)}`);
-
-  const resp = await fetch(`${COPILOT_API}/v1/responses`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${token}`,
-      "Content-Type": "application/json; charset=utf-8",
-      "Content-Length": String(bodyBuf.length),
-      "Editor-Version": "vscode/1.90.0",
-      "Copilot-Integration-Id": "vscode-chat",
-      "Accept": reqBody.stream ? "text/event-stream" : "application/json",
-    },
-    body: bodyBuf,
-  });
+function responsesInputItems(input) {
+  if (input === undefined || input === null) return [];
+  if (typeof input === "string") {
+    return [{ type: "message", role: "user", content: [{ type: "input_text", text: input }] }];
+  }
+  return Array.isArray(input) ? cloneJson(input) : [cloneJson(input)];
+}
 
-  if (!resp.ok) {
-    const errText = await resp.text();
-    console.error(`[codex-copilot-dx] ✗ upstream ${resp.status} ${resp.statusText}`);
-    console.error(`[codex-copilot-dx]   headers:`, Object.fromEntries(resp.headers));
-    console.error(`[codex-copilot-dx]   body:`, errText.slice(0, 2000));
-    res.writeHead(resp.status, { "Content-Type": resp.headers.get("content-type") || "application/json" });
-    res.end(errText);
-    return;
+function responsesOutputItems(output) {
+  if (!Array.isArray(output)) return [];
+  return cloneJson(output.filter((item) => item?.type === "message" || item?.type === "function_call"));
+}
+
+export function clearResponseHistoryForTests() {
+  responseHistories.clear();
+}
+
+export function prepareResponsesRequest(reqBody) {
+  const body = cloneJson(reqBody);
+  const currentInputItems = responsesInputItems(body.input);
+  const previousId = body.previous_response_id;
+
+  if (previousId !== undefined && previousId !== null) {
+    const previousItems = responseHistories.get(previousId);
+    if (!previousItems) {
+      const err = new Error(`previous_response_id is not available in local adapter history: ${previousId}`);
+      err.statusCode = 400;
+      throw err;
+    }
+    body.input = [...cloneJson(previousItems), ...currentInputItems];
+  } else {
+    body.input = currentInputItems;
   }
 
-  if (reqBody.stream) {
+  delete body.previous_response_id;
+  delete body.store;
+
+  return { body, inputItems: body.input };
+}
+
+export function rememberResponseHistory(reqContext, responseJson) {
+  if (!responseJson?.id || !Array.isArray(reqContext?.inputItems)) return;
+  const items = [...cloneJson(reqContext.inputItems), ...responsesOutputItems(responseJson.output)];
+  responseHistories.set(responseJson.id, items);
+  while (responseHistories.size > RESPONSE_HISTORY_LIMIT) {
+    responseHistories.delete(responseHistories.keys().next().value);
+  }
+}
+
+function storeCompletedResponseFromSse(reqContext, data) {
+  if (!data || data === "[DONE]") return;
+  try {
+    const event = JSON.parse(data);
+    const response = event.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.
+  }
+}
+
+function readSseEvents(buffer, onData) {
+  while (true) {
+    const match = buffer.match(/\r?\n\r?\n/);
+    if (!match) return buffer;
+    const chunk = buffer.slice(0, match.index);
+    buffer = buffer.slice(match.index + match[0].length);
+    const data = chunk
+      .split(/\r?\n/)
+      .filter((line) => line.startsWith("data:"))
+      .map((line) => line.slice(5).trimStart())
+      .join("\n");
+    if (data) onData(data);
+  }
+}
+
+async function proxyCopilotResponses(reqContext, req, res, upstream = copilotResponses) {
+  const resp = await upstream(reqContext.body);
+
+  if (reqContext.body.stream) {
     res.writeHead(resp.status, {
       "Content-Type": resp.headers.get("content-type") || "text/event-stream",
       "Cache-Control": "no-cache",
       Connection: "keep-alive",
     });
     const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
     while (true) {
       const { done, value } = await reader.read();
-      if (done) { res.end(); return; }
+      if (done) {
+        buffer += decoder.decode();
+        readSseEvents(buffer, (data) => storeCompletedResponseFromSse(reqContext, data));
+        res.end();
+        return;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      buffer = readSseEvents(buffer, (data) => storeCompletedResponseFromSse(reqContext, data));
       res.write(value);
     }
   } else {
     const data = await resp.text();
     res.writeHead(resp.status, { "Content-Type": "application/json" });
     res.end(data);
-  }
-}
-
-async function proxyCopilotResponsesWS(reqBody, wsSend, onDone) {
-  const token = await getCopilotToken();
-  const payload = { ...reqBody, stream: true };
-  const beforeBytes = Buffer.byteLength(JSON.stringify(payload));
-  await optimizeImagesInBody(payload);
-  const bodyStr = JSON.stringify(payload);
-  const bodyBuf = Buffer.from(bodyStr, "utf-8");
-  const summary = summarizeReqBody(payload);
-  console.log(`[codex-copilot-dx] → responses (ws) model=${payload.model} bytes=${bodyBuf.length} (was ${beforeBytes}) input_items=${summary.items} images=${summary.images} biggest_item=${summary.biggest}b (${summary.biggestKind})`);
-
-  const resp = await fetch(`${COPILOT_API}/v1/responses`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${token}`,
-      "Content-Type": "application/json; charset=utf-8",
-      "Content-Length": String(bodyBuf.length),
-      "Editor-Version": "vscode/1.90.0",
-      "Copilot-Integration-Id": "vscode-chat",
-      "Accept": "text/event-stream",
-    },
-    body: bodyBuf,
-  });
-
-  if (!resp.ok) {
-    const err = await resp.text();
-    console.error(`[codex-copilot-dx] ✗ upstream(ws) ${resp.status} ${resp.statusText}`);
-    console.error(`[codex-copilot-dx]   headers:`, Object.fromEntries(resp.headers));
-    console.error(`[codex-copilot-dx]   body:`, err.slice(0, 2000));
-    wsSend(JSON.stringify({ type: "error", error: { message: err, code: resp.status } }));
-    onDone();
-    return;
-  }
-
-  const reader = resp.body.getReader();
-  const decoder = new TextDecoder();
-  let buf = "";
-  let currentEvent = null;
-  let sawCompleted = false;
-  let lastResponseId = `resp_${uid()}`;
-  let lastModel = reqBody.model || "unknown";
-  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) {
-        if (line.startsWith("event: ")) { currentEvent = line.slice(7).trim(); continue; }
-        if (!line.startsWith("data: ")) { if (line === "") currentEvent = null; continue; }
-        const data = line.slice(6).trim();
-        if (data === "[DONE]") continue;
-        let parsed;
-        try { parsed = JSON.parse(data); } catch { continue; }
-        if (!parsed.type && currentEvent) parsed.type = currentEvent;
-        if (!parsed.type) continue;
-        if (parsed.response?.id) lastResponseId = parsed.response.id;
-        if (parsed.response?.model) lastModel = parsed.response.model;
-        if (parsed.type === "response.completed") sawCompleted = true;
-        wsSend(JSON.stringify(parsed));
-      }
+    if (resp.ok) {
+      try {
+        const response = JSON.parse(data);
+        rememberResponseHistory(reqContext, response);
+        recordResponsesUsage({
+          surface: reqContext.surface,
+          mode: "json",
+          model: reqContext.body?.model,
+          response,
+          event: response,
+        });
+      } catch {}
     }
-  } catch (e) {
-    wsSend(JSON.stringify({ type: "error", error: { message: e.message || String(e), code: 500 } }));
-    onDone();
-    return;
-  }
-  if (!sawCompleted) {
-    wsSend(JSON.stringify({
-      type: "response.completed",
-      response: { id: lastResponseId, object: "response", status: "completed", model: lastModel, output: [], usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 } },
-    }));
   }
-  onDone();
 }
 
-// ── Chat Completions conversion (for older models via copilot-api) ──
+// Chat Completions conversion for older models.
 
 function responsesToChat(body) {
   const messages = [];
@@ -357,52 +211,42 @@ function chatToResponses(chatResp, model) {
   return { id, object: "response", status: "completed", model: chatResp.model || model, output, usage: chatResp.usage ? { input_tokens: chatResp.usage.prompt_tokens || 0, output_tokens: chatResp.usage.completion_tokens || 0, total_tokens: chatResp.usage.total_tokens || 0 } : undefined };
 }
 
-function processStream(upstreamRes, emitEvent, onDone) {
+async function forwardToChat(chatReq, emitEvent, onDone, onError) {
+  delete chatReq.max_tokens;
+  let resp;
+  try {
+    resp = await chatCompletions({ ...chatReq, stream: true });
+  } catch (e) {
+    onError(502, e.message);
+    return;
+  }
+  if (!resp.ok) {
+    onError(resp.status, await resp.text());
+    return;
+  }
   const respId = `resp_${uid()}`, itemId = `item_${uid()}`;
-  let actualModel = "unknown";
+  let actualModel = "unknown", fullText = "", toolCalls = {}, hasToolCalls = false;
 
   emitEvent("response.created", { response: { id: respId, object: "response", status: "in_progress", model: actualModel, output: [] } });
   emitEvent("response.output_item.added", { output_index: 0, item: { type: "message", id: itemId, role: "assistant", status: "in_progress", content: [] } });
   emitEvent("response.content_part.added", { output_index: 0, content_index: 0, part: { type: "output_text", text: "" } });
 
-  let buf = "", fullText = "", toolCalls = {}, hasToolCalls = false, finished = false;
-
-  const finish = (errMsg) => {
-    if (finished) return;
-    finished = true;
-    if (errMsg) {
-      emitEvent("error", { error: { message: errMsg, code: 500 } });
-    } else {
+  const emitCompleted = () => {
+    if (!hasToolCalls) {
       emitEvent("response.output_text.done", { output_index: 0, content_index: 0, text: fullText });
       emitEvent("response.output_item.done", { output_index: 0, item: { type: "message", id: itemId, role: "assistant", status: "completed", content: [{ type: "output_text", text: fullText }] } });
-      const output = hasToolCalls
-        ? Object.entries(toolCalls).map(([id, tc]) => ({ type: "function_call", id, call_id: id, name: tc.name, arguments: tc.arguments, status: "completed" }))
-        : [{ type: "message", id: itemId, role: "assistant", status: "completed", content: [{ type: "output_text", text: fullText }] }];
-      emitEvent("response.completed", { response: { id: respId, object: "response", status: "completed", model: actualModel, output, usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 } } });
     }
-    onDone();
+    const output = hasToolCalls
+      ? Object.entries(toolCalls).map(([id, tc]) => ({ type: "function_call", id, call_id: id, name: tc.name, arguments: tc.arguments, status: "completed" }))
+      : [{ type: "message", id: itemId, role: "assistant", status: "completed", content: [{ type: "output_text", text: fullText }] }];
+    emitEvent("response.completed", { response: { id: respId, object: "response", status: "completed", model: actualModel, output, usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 } } });
   };
 
-  upstreamRes.on("data", (chunk) => {
-    buf += chunk.toString();
-    let lines = buf.split("\n");
-    buf = lines.pop();
-    for (const line of lines) {
+  try {
+    for await (const line of webStreamLines(resp)) {
       if (!line.startsWith("data: ")) continue;
       const data = line.slice(6).trim();
-      if (data === "[DONE]") {
-        if (!hasToolCalls) {
-          emitEvent("response.output_text.done", { output_index: 0, content_index: 0, text: fullText });
-          emitEvent("response.output_item.done", { output_index: 0, item: { type: "message", id: itemId, role: "assistant", status: "completed", content: [{ type: "output_text", text: fullText }] } });
-        }
-        const output = hasToolCalls
-          ? Object.entries(toolCalls).map(([id, tc]) => ({ type: "function_call", id, call_id: id, name: tc.name, arguments: tc.arguments, status: "completed" }))
-          : [{ type: "message", id: itemId, role: "assistant", status: "completed", content: [{ type: "output_text", text: fullText }] }];
-        emitEvent("response.completed", { response: { id: respId, object: "response", status: "completed", model: actualModel, output, usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 } } });
-        finished = true;
-        onDone();
-        return;
-      }
+      if (data === "[DONE]") { emitCompleted(); onDone(); return; }
       let parsed;
       try { parsed = JSON.parse(data); } catch { continue; }
       if (parsed.model) actualModel = parsed.model;
@@ -419,153 +263,161 @@ function processStream(upstreamRes, emitEvent, onDone) {
         }
       }
     }
-  });
-  upstreamRes.on("end", () => finish());
-  upstreamRes.on("error", (e) => finish(e?.message || "upstream stream error"));
-}
-
-function forwardToChat(chatReq, emitEvent, onDone, onError) {
-  delete chatReq.max_tokens;
-  const body = JSON.stringify(chatReq);
-  const opts = { hostname: "localhost", port: COPILOT_API_PORT, path: "/v1/chat/completions", method: "POST", headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } };
-  const proxy = http.request(opts, (upRes) => {
-    if (upRes.statusCode !== 200) { let d = ""; upRes.on("data", c => d += c); upRes.on("end", () => onError(upRes.statusCode, d)); return; }
-    processStream(upRes, emitEvent, onDone);
-  });
-  proxy.on("error", (e) => onError(502, e.message));
-  proxy.write(body);
-  proxy.end();
-}
-
-// ── WebSocket (RFC 6455 minimal) ──
-
-function wsRead(socket) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    const onData = (data) => {
-      chunks.push(data);
-      const buf = Buffer.concat(chunks);
-      if (buf.length < 2) return;
-      const masked = (buf[1] & 0x80) !== 0;
-      let payloadLen = buf[1] & 0x7f, offset = 2;
-      if (payloadLen === 126) { if (buf.length < 4) return; payloadLen = buf.readUInt16BE(2); offset = 4; }
-      else if (payloadLen === 127) { if (buf.length < 10) return; payloadLen = Number(buf.readBigUInt64BE(2)); offset = 10; }
-      const maskLen = masked ? 4 : 0;
-      if (buf.length < offset + maskLen + payloadLen) return;
-      let payload = buf.slice(offset + maskLen, offset + maskLen + payloadLen);
-      if (masked) { const mask = buf.slice(offset, offset + 4); for (let i = 0; i < payload.length; i++) payload[i] ^= mask[i % 4]; }
-      socket.removeListener("data", onData);
-      const opcode = buf[0] & 0x0f;
-      if (opcode === 0x8) resolve(null);
-      else if (opcode === 0x9) { wsSend(socket, "", 0xa); chunks.length = 0; socket.on("data", onData); }
-      else resolve(payload.toString("utf-8"));
-    };
-    socket.on("data", onData);
-    socket.on("error", reject);
-    socket.on("close", () => resolve(null));
-  });
-}
-
-function wsSend(socket, data, opcode = 0x1) {
-  const payload = typeof data === "string" ? Buffer.from(data) : data;
-  const len = payload.length;
-  let header;
-  if (len < 126) { header = Buffer.alloc(2); header[0] = 0x80 | opcode; header[1] = len; }
-  else if (len < 65536) { header = Buffer.alloc(4); header[0] = 0x80 | opcode; header[1] = 126; header.writeUInt16BE(len, 2); }
-  else { header = Buffer.alloc(10); header[0] = 0x80 | opcode; header[1] = 127; header.writeBigUInt64BE(BigInt(len), 2); }
-  try { socket.write(Buffer.concat([header, payload])); } catch {}
-}
-
-async function handleWebSocket(req, socket) {
-  let rawKey = req.headers["sec-websocket-key"];
-  if (Array.isArray(rawKey)) rawKey = rawKey[0];
-  const key = (rawKey || "").trim();
-  const upgrade = String(req.headers["upgrade"] || "").toLowerCase();
-  const connection = String(req.headers["connection"] || "").toLowerCase();
-  if (!key || upgrade !== "websocket" || !connection.includes("upgrade")) {
-    socket.write("HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n");
-    socket.destroy();
+  } catch (e) {
+    onError(500, e?.message || "upstream stream error");
     return;
   }
-  const accept = createHash("sha1").update(key + "258EAFA5-E914-47DA-95CA-5AB9FC6AB199").digest("base64");
-  socket.write("HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: " + accept + "\r\n\r\n");
-
-  while (true) {
-    const msg = await wsRead(socket);
-    if (msg === null) break;
-    let parsed;
-    try { parsed = JSON.parse(msg); } catch { continue; }
-    let reqBody = parsed;
-    if (parsed.type === "response.create" && parsed.response) reqBody = parsed.response;
-    const model = reqBody.model || "unknown";
-
-    if (RESPONSES_ONLY.has(model)) {
-      proxyCopilotResponsesWS(reqBody, (d) => wsSend(socket, d), () => {}).catch((e) => {
-        wsSend(socket, JSON.stringify({ type: "error", error: { message: e.message, code: 500 } }));
-      });
-    } else {
-      const chatReq = responsesToChat(reqBody);
-      chatReq.stream = true;
-      forwardToChat(chatReq, (event, data) => wsSend(socket, JSON.stringify({ type: event, ...data })), () => {}, (status, errMsg) => {
-        wsSend(socket, JSON.stringify({ type: "error", error: { message: errMsg, code: status } }));
-      });
-    }
-  }
-}
-
-// ── HTTP passthrough ──
-
-function proxyPassthrough(req, res) {
-  const opts = { hostname: "localhost", port: COPILOT_API_PORT, path: req.url, method: req.method, headers: { ...req.headers, host: `localhost:${COPILOT_API_PORT}` } };
-  const proxy = http.request(opts, (upRes) => { res.writeHead(upRes.statusCode, upRes.headers); upRes.pipe(res); });
-  proxy.on("error", () => { if (!res.headersSent) res.writeHead(502); res.end("Bad Gateway"); });
-  req.pipe(proxy);
+  emitCompleted();
+  onDone();
 }
 
-// ── Export ──
+// Public server entry point.
 
-export function startAdapter(port = 4142) {
+export function startAdapter(port = 2026) {
   const server = http.createServer((req, res) => {
-    if (req.method === "POST" && req.url?.startsWith("/v1/responses")) {
+    const pathname = requestPath(req.url);
+
+    if (req.method === "POST" && pathname === "/v1/responses") {
       let body = "";
       req.on("data", (c) => (body += c));
       req.on("end", async () => {
         try {
           const parsed = JSON.parse(body);
+          const prepared = prepareResponsesRequest(parsed);
+          prepared.surface = "responses";
           const model = parsed.model || "unknown";
-          console.log(`[codex-copilot-dx] ${model} stream=${!!parsed.stream}`);
+          console.log(status("info", `responses model=${model} stream=${!!parsed.stream}`));
           if (RESPONSES_ONLY.has(model)) {
-            await proxyCopilotResponses(parsed, req, res);
+            await proxyCopilotResponses(prepared, req, res);
           } else {
-            const chatReq = responsesToChat(parsed);
+            const chatReq = responsesToChat(prepared.body);
             if (parsed.stream) {
               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);
+                  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;
               delete chatReq.max_tokens;
-              const reqBody = JSON.stringify(chatReq);
-              const opts = { hostname: "localhost", port: COPILOT_API_PORT, path: "/v1/chat/completions", method: "POST", headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(reqBody) } };
-              const proxy = http.request(opts, (upRes) => {
-                let data = ""; upRes.on("data", (c) => (data += c));
-                upRes.on("end", () => { try { const resp = chatToResponses(JSON.parse(data), model); res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify(resp)); } catch { res.writeHead(500).end("Parse error"); } });
-              });
-              proxy.on("error", () => res.writeHead(502).end("Bad Gateway"));
-              proxy.write(reqBody);
-              proxy.end();
+              try {
+                const upstream = await chatCompletions({ ...chatReq, stream: false });
+                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) {
+                if (!res.headersSent) res.writeHead(502);
+                res.end("Bad Gateway");
+              }
+            }
+          }
+        } catch (e) {
+          console.error(status("err", `Responses request failed: ${e.message}`));
+          if (!res.headersSent) res.writeHead(400);
+          res.end(JSON.stringify({ error: e.message }));
+        }
+      });
+      return;
+    }
+
+    if (req.method === "POST" && pathname === "/v1/responses/compact") {
+      let body = "";
+      req.on("data", (c) => (body += c));
+      req.on("end", async () => {
+        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);
+        } catch (e) {
+          console.error(status("err", `Responses compact request failed: ${e.message}`));
+          if (!res.headersSent) res.writeHead(400);
+          res.end(JSON.stringify({ error: e.message }));
+        }
+      });
+      return;
+    }
+
+    if (req.method === "GET" && pathname === "/v1/models") {
+      listModels()
+        .then(({ status, body }) => { res.writeHead(status, { "Content-Type": "application/json" }); res.end(body); })
+        .catch((e) => { if (!res.headersSent) res.writeHead(502); res.end(JSON.stringify({ error: e.message })); });
+      return;
+    }
+
+    if (req.method === "POST" && pathname === "/v1/messages/count_tokens") {
+      let body = "";
+      req.on("data", (c) => (body += c));
+      req.on("end", () => {
+        try {
+          const parsed = JSON.parse(body);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(countTokens(parsed)));
+        } catch (e) {
+          if (!res.headersSent) res.writeHead(400);
+          res.end(JSON.stringify({ error: e.message }));
+        }
+      });
+      return;
+    }
+
+    if (req.method === "POST" && pathname === "/v1/messages") {
+      let body = "";
+      req.on("data", (c) => (body += c));
+      req.on("end", async () => {
+        try {
+          const parsed = JSON.parse(body);
+          const model = parsed.model || "unknown";
+          console.log(status("info", `messages model=${model} stream=${!!parsed.stream}`));
+          const chatReq = anthropicToChat(parsed);
+          if (parsed.stream) {
+            const upstream = await chatCompletions({ ...chatReq, stream: true });
+            if (!upstream.ok) {
+              if (!res.headersSent) res.writeHead(upstream.status);
+              res.end(await upstream.text());
+              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) => {
+                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));
           }
         } catch (e) {
-          console.error("[codex-copilot-dx] error:", e.message);
+          console.error(status("err", `Messages request failed: ${e.message}`));
           if (!res.headersSent) res.writeHead(400);
           res.end(JSON.stringify({ error: e.message }));
         }
       });
       return;
     }
-    proxyPassthrough(req, res);
+
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
   });
 
   server.on("upgrade", (req, socket) => {
@@ -580,7 +432,7 @@ export function startAdapter(port = 4142) {
 
   return new Promise((resolve) => {
     server.listen(port, () => {
-      console.log(`[codex-copilot-dx] Adapter listening on http://localhost:${port}`);
+      console.log(status("ok", `Adapter listening on http://localhost:${port}`));
       resolve(server);
     });
   });