codex-copilot-dx 0.1.5 → 0.4.0

package/src/adapter.mjs

@@ -1,13 +1,9 @@
 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";
-
-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";
+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";
 
 // Models that only support Responses API (not chat/completions)
 const RESPONSES_ONLY = new Set([
@@ -18,129 +14,129 @@ 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 token = await getCopilotToken();
-  const resp = await fetch(`${COPILOT_API}/v1/responses`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${token}`,
-      "Content-Type": "application/json",
-      "Editor-Version": "vscode/1.90.0",
-      "Copilot-Integration-Id": "vscode-chat",
-    },
-    body: JSON.stringify(reqBody),
-  });
+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)];
+}
+
+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();
+}
 
-  if (reqBody.stream) {
+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;
+  }
+
+  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);
+  } 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 resp = await fetch(`${COPILOT_API}/v1/responses`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${token}`,
-      "Content-Type": "application/json",
-      "Editor-Version": "vscode/1.90.0",
-      "Copilot-Integration-Id": "vscode-chat",
-    },
-    body: JSON.stringify({ ...reqBody, stream: true }),
-  });
-
-  if (!resp.ok) {
-    const err = await resp.text();
-    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 { rememberResponseHistory(reqContext, JSON.parse(data)); } 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 = [];
@@ -195,52 +191,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;
@@ -257,153 +243,147 @@ 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);
           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);
               }, () => { 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);
+                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);
+          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" });
+            await streamAnthropicFromLines(
+              webStreamLines(upstream),
+              (event, data) => res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`),
+              model,
+            );
+            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);
+            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) => {
@@ -418,7 +398,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);
     });
   });