codex-copilot-dx 0.6.21 → 0.7.1

package/src/usage.mjs

@@ -56,20 +56,6 @@ function normalizeResponsesUsage(usage) {
   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 = {};
@@ -112,19 +98,6 @@ export function buildResponsesUsageRecord({ surface = "responses", mode, model,
   });
 }
 
-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,
-  });
-}
-
 function takePendingWrites(filePath, maxBytes) {
   const batch = [];
   let retained = 0;
@@ -188,10 +161,6 @@ export function recordResponsesUsage(args) {
   return recordUsage(buildResponsesUsageRecord(args));
 }
 
-export function recordAnthropicUsage(args) {
-  return recordUsage(buildAnthropicUsageRecord(args));
-}
-
 export async function flushUsageWritesForTests() {
   while (writeDrain || pendingWrites.length > 0) {
     if (writeDrain) await writeDrain;

package/src/user-settings.mjs

@@ -3,8 +3,14 @@ import os from "node:os";
 import path from "node:path";
 import { atomicWriteFileIfChangedSync } from "./atomic-file.mjs";
 import { DEFAULT_CODEX_AUTO_REVIEW_MODEL } from "./models.mjs";
+import {
+  DEFAULT_TERMINAL_ANIMATION_THEME,
+  isTerminalAnimationTheme,
+  TERMINAL_ANIMATION_THEMES,
+} from "./terminal-animation.mjs";
 
 const AUTO_REVIEW_MODEL_KEY = "auto_review_model";
+const TERMINAL_ANIMATION_KEY = "terminal_animation";
 
 export function userSettingsPath({ env = process.env, home = os.homedir() } = {}) {
   const xdgConfigHome = String(env.XDG_CONFIG_HOME || "").trim();
@@ -29,6 +35,16 @@ export function readUserSettings({ env = process.env, home = os.homedir(), stric
         throw invalidSettings(filePath, `${AUTO_REVIEW_MODEL_KEY} must be a non-empty string`);
       }
     }
+    if (Object.hasOwn(parsed, TERMINAL_ANIMATION_KEY)) {
+      const value = parsed[TERMINAL_ANIMATION_KEY];
+      if (!isTerminalAnimationTheme(value)) {
+        const choices = TERMINAL_ANIMATION_THEMES.map(({ id }) => id).join(", ");
+        if (strict) {
+          throw invalidSettings(filePath, `${TERMINAL_ANIMATION_KEY} must be one of: ${choices}`);
+        }
+        delete parsed[TERMINAL_ANIMATION_KEY];
+      }
+    }
     return parsed;
   } catch (error) {
     if (error?.code === "ENOENT") return {};
@@ -54,6 +70,18 @@ export function autoReviewModelPreference({ env = process.env, home = os.homedir
   return { model: DEFAULT_CODEX_AUTO_REVIEW_MODEL, source: "default" };
 }
 
+export function savedTerminalAnimationTheme(options = {}) {
+  const settings = readUserSettings(options);
+  const theme = settings[TERMINAL_ANIMATION_KEY];
+  return isTerminalAnimationTheme(theme) ? theme : "";
+}
+
+export function terminalAnimationPreference({ env = process.env, home = os.homedir() } = {}) {
+  const savedTheme = savedTerminalAnimationTheme({ env, home });
+  if (savedTheme) return { theme: savedTheme, source: "settings" };
+  return { theme: DEFAULT_TERMINAL_ANIMATION_THEME, source: "default" };
+}
+
 export function writeAutoReviewModel(model, { env = process.env, home = os.homedir() } = {}) {
   const filePath = userSettingsPath({ env, home });
   const settings = readUserSettings({ env, home, strict: true });
@@ -65,3 +93,25 @@ export function writeAutoReviewModel(model, { env = process.env, home = os.homed
   const changed = atomicWriteFileIfChangedSync(filePath, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
   return { changed, filePath, model: value || DEFAULT_CODEX_AUTO_REVIEW_MODEL };
 }
+
+export function writeTerminalAnimationTheme(theme, { env = process.env, home = os.homedir() } = {}) {
+  if (!isTerminalAnimationTheme(theme)) {
+    const choices = TERMINAL_ANIMATION_THEMES.map(({ id }) => id).join(", ");
+    throw new Error(`Terminal animation must be one of: ${choices}`);
+  }
+
+  const filePath = userSettingsPath({ env, home });
+  const settings = readUserSettings({ env, home, strict: true });
+  const next = { ...settings };
+  if (theme === DEFAULT_TERMINAL_ANIMATION_THEME) {
+    if (!Object.hasOwn(next, TERMINAL_ANIMATION_KEY)) {
+      return { changed: false, filePath, theme };
+    }
+    delete next[TERMINAL_ANIMATION_KEY];
+  } else {
+    next[TERMINAL_ANIMATION_KEY] = theme;
+  }
+
+  const changed = atomicWriteFileIfChangedSync(filePath, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+  return { changed, filePath, theme };
+}

package/src/anthropic-handler.mjs

@@ -1,195 +0,0 @@
-import {
-  anthropicToChat,
-  chatToAnthropic,
-  countTokens,
-  streamAnthropicFromLines,
-} from "./anthropic.mjs";
-import {
-  createRequestAbort,
-  logRequestFailure,
-  MAX_UPSTREAM_CHAT_SUCCESS_BODY_BYTES,
-  MAX_UPSTREAM_ERROR_BODY_BYTES,
-  readJsonBody,
-  readBoundedResponseText,
-  sendJsonError,
-  sendUpstreamError,
-  writeOrDrain,
-} from "./http-transport.mjs";
-import { resolveAnthropicModel } from "./models.mjs";
-import { status } from "./status.mjs";
-import { webStreamLines } from "./stream.mjs";
-import { endStreamWithError } from "./stream-errors.mjs";
-import { requireUpstreamEventStream, withChatStreamUsage } from "./stream-contract.mjs";
-import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
-import { recordAnthropicUsage } from "./usage.mjs";
-
-const PROMPT_TOO_LONG_MESSAGE = "prompt is too long: your prompt is too long. Please reduce the number of messages or use a model with a larger context window.";
-const DOWNSTREAM_CLOSED = Symbol("downstream-closed");
-
-function contextWindowErrorBody(text) {
-  let error;
-  try {
-    const parsed = JSON.parse(text);
-    error = parsed && typeof parsed === "object" ? parsed.error : null;
-  } catch {
-    error = { message: text };
-  }
-  if (!error || typeof error !== "object") return null;
-  const code = error.code;
-  const message = typeof error.message === "string" ? error.message.toLowerCase() : "";
-  const matches = code === "context_length_exceeded"
-    || code === "model_max_prompt_tokens_exceeded"
-    || message.includes("exceeds the context window of this model")
-    || message.includes("maximum context length is")
-    || message.includes("request body is too large for model context window");
-  if (!matches) return null;
-  return JSON.stringify({
-    type: "error",
-    error: { type: "invalid_request_error", message: PROMPT_TOO_LONG_MESSAGE },
-  });
-}
-
-function sendAnthropicUpstreamError(res, response, text) {
-  const rewritten = contextWindowErrorBody(text);
-  if (!rewritten) {
-    sendUpstreamError(res, response, text);
-    return;
-  }
-  const headers = new Headers(response.headers);
-  headers.set("content-type", "application/json");
-  sendUpstreamError(res, { status: response.status, headers }, rewritten);
-}
-
-export function createAnthropicCountTokensHandler(options) {
-  const { acquireRequest, requestBodyTimeoutMs, countTokensFn = countTokens } = options;
-
-  return async function handleAnthropicCountTokens(req, res) {
-    const abort = createRequestAbort(req, res);
-    let releaseRequest = () => {};
-    try {
-      releaseRequest = await acquireRequest(req, { signal: abort.signal });
-      abort.setTimeout(requestBodyTimeoutMs, "request_body_timeout");
-      const parsed = await readJsonBody(req, { admission: releaseRequest, signal: abort.signal });
-      abort.clearTimeout();
-      const result = await countTokensFn(parsed, { signal: abort.signal });
-      releaseRequest();
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify(result));
-    } catch (error) {
-      sendJsonError(res, error, abort.reason === "request_body_timeout" ? 408 : 500);
-    } finally {
-      releaseRequest();
-      abort.cleanup();
-    }
-  };
-}
-
-export function createAnthropicMessagesHandler(options) {
-  const {
-    acquireRequest,
-    chatCompletionsFn,
-    environment,
-    modelOptions,
-    requestBodyTimeoutMs,
-    streamHandshakeTimeoutMs,
-    streamIdleTimeoutMs,
-    upstreamTimeoutMs,
-  } = options;
-
-  return async function handleAnthropicMessages(req, res) {
-    const abort = createRequestAbort(req, res);
-    let releaseRequest = () => {};
-    try {
-      releaseRequest = await acquireRequest(req, { signal: abort.signal });
-      abort.setTimeout(requestBodyTimeoutMs, "request_body_timeout");
-      const parsed = await readJsonBody(req, { admission: releaseRequest, signal: abort.signal });
-      abort.setTimeout(
-        parsed.stream ? streamHandshakeTimeoutMs : upstreamTimeoutMs,
-        parsed.stream ? "stream_handshake_timeout" : "upstream_timeout",
-      );
-      const { requestedModel, upstreamModel } = resolveAnthropicModel(parsed.model || "unknown", environment, modelOptions());
-      const modelNote = upstreamModel === requestedModel ? requestedModel : `${requestedModel} -> ${upstreamModel}`;
-      console.log(status("info", `messages model=${modelNote} stream=${!!parsed.stream}`));
-      const chatReq = anthropicToChat(parsed, { upstreamModel });
-      const forceRequestedModel = upstreamModel !== requestedModel;
-      if (parsed.stream) {
-        const upstream = await chatCompletionsFn(withChatStreamUsage(chatReq), { signal: abort.signal });
-        releaseRequest();
-        if (!upstream.ok) {
-          sendAnthropicUpstreamError(res, upstream, await readBoundedResponseText(upstream, {
-            maxBytes: MAX_UPSTREAM_ERROR_BODY_BYTES,
-            label: "Copilot Chat error body",
-          }));
-          return;
-        }
-        await requireUpstreamEventStream(upstream);
-        abort.setTimeout(streamIdleTimeoutMs, "stream_idle_timeout");
-        res.writeHead(200, {
-          ...safeUpstreamResponseHeaders(upstream.headers, { contentType: "text/event-stream" }),
-          "Cache-Control": "no-cache",
-          Connection: "keep-alive",
-        });
-        let messageId;
-        let usage;
-        try {
-          await streamAnthropicFromLines(
-            webStreamLines(upstream, {
-              onChunk: () => abort.setTimeout(streamIdleTimeoutMs, "stream_idle_timeout"),
-            }),
-            async (event, data) => {
-              if (event === "message_start") messageId = data.message?.id;
-              if (event === "message_delta") usage = data.usage;
-              if (!await writeOrDrain(res, `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`)) {
-                throw DOWNSTREAM_CLOSED;
-              }
-            },
-            requestedModel,
-            { forceModel: forceRequestedModel },
-          );
-        } catch (error) {
-          if (error === DOWNSTREAM_CLOSED) return;
-          logRequestFailure("Messages", error, abort);
-          await endStreamWithError(res, "anthropic", error, abort);
-          return;
-        }
-        recordAnthropicUsage({ surface: "messages", mode: "stream", model: requestedModel, responseId: messageId, usage });
-        if (!res.writableEnded) res.end();
-      } else {
-        const upstream = await chatCompletionsFn({ ...chatReq, stream: false }, { signal: abort.signal });
-        releaseRequest();
-        const data = upstream.ok
-          ? await readBoundedResponseText(upstream, {
-            maxBytes: MAX_UPSTREAM_CHAT_SUCCESS_BODY_BYTES,
-            label: "Copilot Chat success body",
-            signal: abort.signal,
-          })
-          : await readBoundedResponseText(upstream, {
-            maxBytes: MAX_UPSTREAM_ERROR_BODY_BYTES,
-            label: "Copilot Chat error body",
-          });
-        if (!upstream.ok) {
-          sendAnthropicUpstreamError(res, upstream, data);
-          return;
-        }
-        const anthropicMessage = chatToAnthropic(JSON.parse(data), requestedModel, { forceModel: forceRequestedModel });
-        recordAnthropicUsage({
-          surface: "messages",
-          mode: "json",
-          model: anthropicMessage.model,
-          responseId: anthropicMessage.id,
-          usage: anthropicMessage.usage,
-        });
-        res.writeHead(200, safeUpstreamResponseHeaders(upstream.headers, {
-          contentType: "application/json",
-        }));
-        res.end(JSON.stringify(anthropicMessage));
-      }
-    } catch (error) {
-      logRequestFailure("Messages", error, abort);
-      sendJsonError(res, error, 502);
-    } finally {
-      releaseRequest();
-      abort.cleanup();
-    }
-  };
-}