@openhoo/hoopilot 1.3.0 → 2.0.0

package/dist/index.js

@@ -35,8 +35,12 @@ function parseUrl(rawUrl) {
   }
   return url;
 }
+var LOOPBACK_HOSTNAMES = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
+function isLoopbackHostname(host) {
+  return LOOPBACK_HOSTNAMES.has(host);
+}
 function isLoopbackHttpUrl(url) {
-  return url.protocol === "http:" && (url.hostname === "127.0.0.1" || url.hostname === "localhost" || url.hostname === "::1" || url.hostname === "[::1]");
+  return url.protocol === "http:" && isLoopbackHostname(url.hostname);
 }
 async function truncatedResponseText(response, max = 500) {
   const text = await response.text();
@@ -45,6 +49,48 @@ async function truncatedResponseText(response, max = 500) {
 function asRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function firstNumber(...values) {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function randomId() {
+  return crypto.randomUUID().replaceAll("-", "");
+}
+function removeUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0));
+}
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function parseJsonObject(text) {
+  try {
+    return asRecord(JSON.parse(text));
+  } catch {
+    return void 0;
+  }
+}
+var STREAMING_PROXY_MODES = [
+  "auto",
+  "buffer",
+  "live"
+];
+function parseStreamingProxyMode(value) {
+  if (STREAMING_PROXY_MODES.includes(value)) {
+    return value;
+  }
+  throw new Error(`Invalid stream mode: ${value}. Expected ${STREAMING_PROXY_MODES.join(", ")}.`);
+}
 
 // src/openai.ts
 var DEFAULT_MODEL = "gpt-4.1";
@@ -172,13 +218,6 @@ function compactionOutputFromResponsesSse(text) {
   }
   return deltas ? [messageOutputItem(deltas)] : [];
 }
-function safeJsonParse(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return void 0;
-  }
-}
 function chatCompletionToCompletion(completion) {
   return removeUndefined({
     choices: completionChoices(completion).map((choice, index) => {
@@ -372,7 +411,7 @@ function responsesStreamFromChatStream(chatStream, options) {
         if (isNew) {
           enqueue("response.output_item.added", {
             item: functionCallItem(existing, "in_progress"),
-            output_index: existing.outputIndex ?? 0,
+            output_index: existing.outputIndex,
             type: "response.output_item.added"
           });
         }
@@ -382,7 +421,7 @@ function responsesStreamFromChatStream(chatStream, options) {
           enqueue("response.function_call_arguments.delta", {
             delta: argumentDelta,
             item_id: existing.itemId,
-            output_index: existing.outputIndex ?? 0,
+            output_index: existing.outputIndex,
             type: "response.function_call_arguments.delta"
           });
         }
@@ -432,11 +471,9 @@ function responsesStreamFromChatStream(chatStream, options) {
             type: "response.output_item.done"
           });
         }
-        for (const tool of [...tools.values()].sort(
-          (a, b) => (a.outputIndex ?? 0) - (b.outputIndex ?? 0)
-        )) {
+        for (const tool of [...tools.values()].sort((a, b) => a.outputIndex - b.outputIndex)) {
           const item = functionCallItem(tool);
-          const outputIndex = tool.outputIndex ?? 0;
+          const outputIndex = tool.outputIndex;
           outputEntries.push([outputIndex, item]);
           enqueue("response.function_call_arguments.done", {
             arguments: tool.arguments,
@@ -679,7 +716,6 @@ function outputItemsFromMessage(message) {
       functionCallItem({
         arguments: contentToText(fn.arguments),
         id: contentToText(record.id) || `call_${randomId()}`,
-        index: output.length,
         name: contentToText(fn.name)
       })
     );
@@ -761,21 +797,18 @@ function extractTokenUsage(usage) {
     asRecord(record.prompt_tokens_details).cached_tokens,
     asRecord(record.input_tokens_details).cached_tokens
   );
-  return removeUndefined({
-    cachedTokens: cached,
+  const result = {
     completionTokens,
     promptTokens,
-    reasoningTokens: reasoning,
     totalTokens: total ?? promptTokens + completionTokens
-  });
-}
-function firstNumber(...values) {
-  for (const value of values) {
-    if (typeof value === "number" && Number.isFinite(value)) {
-      return value;
-    }
+  };
+  if (cached !== void 0) {
+    result.cachedTokens = cached;
   }
-  return void 0;
+  if (reasoning !== void 0) {
+    result.reasoningTokens = reasoning;
+  }
+  return result;
 }
 function firstChoice(completion) {
   return completionChoices(completion)[0] ?? {};
@@ -804,7 +837,7 @@ function processCompletionSseBlock(block, enqueue, markTerminal) {
     enqueue("[DONE]");
     return;
   }
-  const parsed = parseJson(data);
+  const parsed = parseJsonObject(data);
   if (!parsed) {
     return;
   }
@@ -869,7 +902,7 @@ function processChatSseLine(line, handlers) {
   if (!data || data === "[DONE]") {
     return;
   }
-  const parsed = parseJson(data);
+  const parsed = parseJsonObject(data);
   if (!parsed) {
     return;
   }
@@ -921,19 +954,6 @@ function encodeDataSse(data) {
 
 `;
 }
-function parseJson(data) {
-  try {
-    return asRecord(JSON.parse(data));
-  } catch {
-    return void 0;
-  }
-}
-function removeUndefined(record) {
-  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== void 0));
-}
-function randomId() {
-  return crypto.randomUUID().replaceAll("-", "");
-}
 function epochSeconds() {
   return Math.floor(Date.now() / 1e3);
 }
@@ -946,13 +966,13 @@ var AnthropicCompatibilityError = class extends Error {
   }
 };
 function anthropicMessagesToResponsesRequest(request) {
-  return removeUndefined2({
+  return removeUndefined({
     input: anthropicMessagesToResponsesInput(request.messages),
     instructions: anthropicSystemToInstructions(request.system),
     max_output_tokens: typeof request.max_tokens === "number" && Number.isFinite(request.max_tokens) ? request.max_tokens : void 0,
     metadata: request.metadata,
     model: normalizeRequestedModel(request.model),
-    parallel_tool_calls: true,
+    parallel_tool_calls: asRecord(request.tool_choice).disable_parallel_tool_use !== true,
     reasoning: anthropicThinkingToReasoning(request.thinking),
     stop: anthropicStopSequences(request.stop_sequences),
     stream: request.stream === true,
@@ -967,7 +987,7 @@ function responsesResponseToAnthropicMessage(response, fallbackModel) {
   const usage = anthropicUsage(response.usage);
   return {
     content,
-    id: textValue(response.id) || `msg_${randomId2()}`,
+    id: textValue(response.id) || `msg_${randomId()}`,
     model: textValue(response.model) || fallbackModel,
     role: "assistant",
     stop_reason: anthropicStopReason(response, content),
@@ -1044,7 +1064,7 @@ function createAnthropicStreamState(options) {
   return {
     blocks: /* @__PURE__ */ new Map(),
     completed: false,
-    messageId: options.messageId ?? `msg_${randomId2()}`,
+    messageId: options.messageId ?? `msg_${randomId()}`,
     model: options.model,
     nextBlockIndex: 0,
     sawToolUse: false,
@@ -1098,7 +1118,7 @@ function anthropicMessagesToResponsesInput(messages) {
         flushMessage();
         input.push({
           arguments: JSON.stringify(asRecord(part.input)),
-          call_id: textValue(part.id) || `call_${randomId2()}`,
+          call_id: textValue(part.id) || `call_${randomId()}`,
           name: textValue(part.name),
           type: "function_call"
         });
@@ -1209,7 +1229,7 @@ function anthropicTools(tools) {
   }
   const converted = tools.map((tool) => {
     const record = asRecord(tool);
-    return removeUndefined2({
+    return removeUndefined({
       description: record.description,
       name: record.name,
       parameters: record.input_schema,
@@ -1280,7 +1300,7 @@ function anthropicContentFromResponsesOutput(response) {
     }
     if (type === "function_call") {
       content.push({
-        id: textValue(record.call_id) || textValue(record.id) || `call_${randomId2()}`,
+        id: textValue(record.call_id) || textValue(record.id) || `call_${randomId()}`,
         input: parseToolInput(textValue(record.arguments)),
         name: textValue(record.name),
         type: "tool_use"
@@ -1307,12 +1327,12 @@ function anthropicStopReason(response, content) {
 }
 function anthropicUsage(usage) {
   const record = asRecord(usage);
-  const inputTokens = firstNumber2(record.input_tokens, record.prompt_tokens) ?? 0;
-  const outputTokens = firstNumber2(record.output_tokens, record.completion_tokens) ?? 0;
+  const inputTokens = firstNumber(record.input_tokens, record.prompt_tokens) ?? 0;
+  const outputTokens = firstNumber(record.output_tokens, record.completion_tokens) ?? 0;
   const details = asRecord(record.input_tokens_details);
-  return removeUndefined2({
-    cache_creation_input_tokens: firstNumber2(record.cache_creation_input_tokens),
-    cache_read_input_tokens: firstNumber2(record.cache_read_input_tokens, details.cached_tokens) ?? void 0,
+  return removeUndefined({
+    cache_creation_input_tokens: firstNumber(record.cache_creation_input_tokens),
+    cache_read_input_tokens: firstNumber(record.cache_read_input_tokens, details.cached_tokens) ?? void 0,
     input_tokens: inputTokens,
     output_tokens: outputTokens
   });
@@ -1494,7 +1514,7 @@ function ensureToolBlock(state, payload, item, enqueue) {
     state.blocks.set(key, block);
     enqueue("content_block_start", {
       content_block: {
-        id: textValue(item.call_id) || textValue(item.id) || `call_${randomId2()}`,
+        id: textValue(item.call_id) || textValue(item.id) || `call_${randomId()}`,
         input: {},
         name: textValue(item.name),
         type: "tool_use"
@@ -1528,13 +1548,6 @@ function parseSseBlock(block) {
   }
   return { data: data.join("\n"), event };
 }
-function parseJsonObject(text) {
-  try {
-    return asRecord(JSON.parse(text));
-  } catch {
-    return void 0;
-  }
-}
 function parseToolInput(argumentsText) {
   const parsed = parseJsonObject(argumentsText);
   return parsed ?? {};
@@ -1566,32 +1579,18 @@ function textValue(value) {
   }
   return "";
 }
-function firstNumber2(...values) {
-  for (const value of values) {
-    if (typeof value === "number" && Number.isFinite(value)) {
-      return value;
-    }
-  }
-  return void 0;
-}
 function indexValue(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
-function removeUndefined2(record) {
-  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== void 0));
-}
 function encodeSse2(event, data) {
   return `event: ${event}
 data: ${JSON.stringify(data)}
 
 `;
 }
-function randomId2() {
-  return crypto.randomUUID().replaceAll("-", "");
-}
 
 // src/auth-store.ts
-import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 var StoredCopilotAuthError = class extends Error {
   constructor(message) {
@@ -1642,7 +1641,7 @@ function readStoredCopilotAuth(path = authStorePath()) {
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new StoredCopilotAuthError(`Hoopilot auth file at ${path} must contain a JSON object.`);
   }
-  const record = parsed;
+  const record = asRecord(parsed);
   const token = typeof record.token === "string" ? record.token.trim() : "";
   if (!token) {
     throw new StoredCopilotAuthError(`Hoopilot auth file at ${path} does not contain a token.`);
@@ -1668,7 +1667,15 @@ function writeStoredCopilotAuth(auth, path = authStorePath()) {
 `;
   const tmpPath = `${path}.${process.pid}.tmp`;
   writeFileSync(tmpPath, data, { mode: 384 });
-  renameSync(tmpPath, path);
+  try {
+    renameSync(tmpPath, path);
+  } catch (error) {
+    try {
+      rmSync(tmpPath, { force: true });
+    } catch {
+    }
+    throw error;
+  }
   try {
     chmodSync(path, 384);
   } catch {
@@ -1713,23 +1720,20 @@ var CopilotAuth = class {
       throw error;
     }
     if (stored) {
-      return this.#cacheAccess({
+      this.#cachedAccess = {
         apiBaseUrl: trimTrailingSlash(
           this.#hasCopilotApiBaseUrlOverride ? this.#copilotApiBaseUrl : stored.apiBaseUrl ?? this.#copilotApiBaseUrl
         ),
         expiresAtMs: Date.now() + STORED_TOKEN_TTL_MS,
         source: "github-copilot-oauth",
         token: stored.token
-      });
+      };
+      return this.#cachedAccess;
     }
     throw new CopilotAuthError(
       "No GitHub Copilot OAuth credential found. Run `hoopilot login` to sign in through your browser."
     );
   }
-  #cacheAccess(access) {
-    this.#cachedAccess = access;
-    return access;
-  }
 };
 
 // src/copilot.ts
@@ -1737,23 +1741,26 @@ var DEFAULT_GITHUB_API_BASE_URL = "https://api.github.com";
 var ALLOWED_COPILOT_API_HOSTS = ["api.githubcopilot.com"];
 var ALLOWED_GITHUB_API_HOSTS = ["api.github.com"];
 var COPILOT_USAGE_API_VERSION = "2025-04-01";
+var EDITOR_PLUGIN_VERSION = "hoopilot/0.1.0";
+var EDITOR_VERSION = "Hoopilot/0.1.0";
+var HOOPILOT_USER_AGENT = "hoopilot/0.1.0";
 function applyCopilotHeaders(headers, token) {
   headers.set("accept", headers.get("accept") ?? "application/json");
   headers.set("authorization", `Bearer ${token}`);
   headers.set("copilot-integration-id", "vscode-chat");
-  headers.set("editor-plugin-version", "hoopilot/0.1.0");
-  headers.set("editor-version", "Hoopilot/0.1.0");
+  headers.set("editor-plugin-version", EDITOR_PLUGIN_VERSION);
+  headers.set("editor-version", EDITOR_VERSION);
   headers.set("openai-intent", "conversation-panel");
-  headers.set("user-agent", "hoopilot/0.1.0");
+  headers.set("user-agent", HOOPILOT_USER_AGENT);
   headers.set("x-github-api-version", "2026-06-01");
   return headers;
 }
 function applyGithubApiHeaders(headers, token) {
   headers.set("accept", headers.get("accept") ?? "application/json");
   headers.set("authorization", `token ${token}`);
-  headers.set("editor-plugin-version", "hoopilot/0.1.0");
-  headers.set("editor-version", "Hoopilot/0.1.0");
-  headers.set("user-agent", "hoopilot/0.1.0");
+  headers.set("editor-plugin-version", EDITOR_PLUGIN_VERSION);
+  headers.set("editor-version", EDITOR_VERSION);
+  headers.set("user-agent", HOOPILOT_USER_AGENT);
   headers.set("x-github-api-version", COPILOT_USAGE_API_VERSION);
   return headers;
 }
@@ -1766,7 +1773,7 @@ function parseRateLimitHeaders(headers, nowMs = Date.now()) {
   if (limit === void 0 && remaining === void 0 && used === void 0 && resetEpochSeconds === void 0 && retryAfterSeconds === void 0) {
     return void 0;
   }
-  return removeUndefinedRateLimit({
+  return removeUndefined({
     limit,
     observedAtMs: nowMs,
     remaining,
@@ -1784,11 +1791,6 @@ function headerInt(headers, name) {
   const value = Number.parseInt(raw.trim(), 10);
   return Number.isFinite(value) && value >= 0 ? value : void 0;
 }
-function removeUndefinedRateLimit(rateLimit) {
-  return Object.fromEntries(
-    Object.entries(rateLimit).filter(([, value]) => value !== void 0)
-  );
-}
 var CopilotClient = class {
   #auth;
   #allowUnsafeUpstream;
@@ -1885,7 +1887,7 @@ function normalizeCopilotUsage(body) {
     for (const category of /* @__PURE__ */ new Set([...Object.keys(remaining), ...Object.keys(monthly)])) {
       const entitlement = numberOrUndefined(monthly[category]);
       const left = numberOrUndefined(remaining[category]);
-      quotas[category] = removeUndefinedQuota({
+      quotas[category] = removeUndefined({
         entitlement,
         percentRemaining: entitlement !== void 0 && entitlement > 0 && left !== void 0 ? left / entitlement * 100 : void 0,
         remaining: left,
@@ -1893,7 +1895,7 @@ function normalizeCopilotUsage(body) {
       });
     }
   }
-  return removeUndefinedUsage({
+  return removeUndefined({
     accessTypeSku: stringOrUndefined(record.access_type_sku),
     chatEnabled: typeof record.chat_enabled === "boolean" ? record.chat_enabled : void 0,
     plan: stringOrUndefined(record.copilot_plan),
@@ -1905,7 +1907,7 @@ function normalizeQuotaDetail(detail) {
   const entitlement = numberOrUndefined(detail.entitlement);
   const overageCount = numberOrUndefined(detail.overage_count);
   const remaining = numberOrUndefined(detail.remaining) ?? numberOrUndefined(detail.quota_remaining);
-  return removeUndefinedQuota({
+  return removeUndefined({
     entitlement,
     hasQuota: typeof detail.has_quota === "boolean" ? detail.has_quota : void 0,
     overageCount,
@@ -1929,21 +1931,10 @@ function usedFrom(entitlement, remaining, overageCount) {
   const overage = remaining === 0 ? overageCount ?? 0 : 0;
   return Math.max(0, base + overage);
 }
-function numberOrUndefined(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
+var numberOrUndefined = firstNumber;
 function stringOrUndefined(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function removeUndefinedQuota(quota) {
-  return Object.fromEntries(
-    Object.entries(quota).filter(([, value]) => value !== void 0)
-  );
-}
-function removeUndefinedUsage(usage) {
-  const entries = Object.entries(usage).filter(([, value]) => value !== void 0);
-  return Object.fromEntries(entries);
-}
 
 // src/github-device.ts
 import { setTimeout as sleep } from "timers/promises";
@@ -2075,11 +2066,16 @@ function positiveSeconds(value, fallback) {
 }
 async function parseJsonResponse(response, context) {
   const text = await response.text();
+  let value;
   try {
-    return JSON.parse(text);
+    value = JSON.parse(text);
   } catch {
     throw new Error(`${context}: ${text.slice(0, 500)}`);
   }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${context}: ${text.slice(0, 500)}`);
+  }
+  return value;
 }
 
 // src/logger.ts
@@ -2143,21 +2139,29 @@ function createHoopilotLogger(options = {}) {
     timestamp: pino.stdTimeFunctions.isoTime
   };
   if (format === "pretty") {
-    return pino(
-      pinoOptions,
-      pretty({
-        colorize: options.colorize ?? process.stderr.isTTY,
-        destination: options.stream ?? 1,
-        ignore: "pid,hostname",
-        singleLine: true,
-        translateTime: "SYS:standard"
-      })
+    return asHoopilotLogger(
+      pino(
+        pinoOptions,
+        pretty({
+          // Probe the same sink we write to (stdout / fd 1), so colors are not
+          // emitted into a redirected file when only stderr is a TTY. A custom
+          // stream's TTY-ness is unknown, so default to no color there.
+          colorize: options.colorize ?? (options.stream ? false : process.stdout.isTTY),
+          destination: options.stream ?? 1,
+          ignore: "pid,hostname",
+          singleLine: true,
+          translateTime: "SYS:standard"
+        })
+      )
     );
   }
   if (options.stream) {
-    return pino(pinoOptions, options.stream);
+    return asHoopilotLogger(pino(pinoOptions, options.stream));
   }
-  return pino(pinoOptions);
+  return asHoopilotLogger(pino(pinoOptions));
+}
+function asHoopilotLogger(logger) {
+  return logger;
 }
 function parseLogFormat(value) {
   if (!value) {
@@ -2283,26 +2287,23 @@ var MetricsRegistry = class {
     const resource = this.#rateLimitResource(rateLimit.resource);
     this.#githubRateLimit.set(resource, { ...rateLimit, resource });
   }
-  // Sanitize the model into a bounded label. The model can originate from a
-  // client request, so cap its length, strip characters that would corrupt the
-  // exposition format, and fold overflow past the cardinality limit into
-  // UNKNOWN_MODEL to keep the series count bounded.
-  #modelLabel(model) {
-    const cleaned = cleanLabel(model).slice(0, MAX_MODEL_LABEL_LENGTH) || UNKNOWN_MODEL;
-    if (!this.#tokens.has(cleaned) && this.#tokens.size >= MAX_TRACKED_MODELS) {
+  // Clean a raw value into a bounded exposition-format label: cap its length,
+  // strip characters that would corrupt the format, and fold overflow past the
+  // cardinality limit into UNKNOWN_MODEL so the series count stays bounded.
+  #boundedLabel(value, tracked, maxEntries) {
+    const cleaned = cleanLabel(value).slice(0, MAX_MODEL_LABEL_LENGTH) || UNKNOWN_MODEL;
+    if (!tracked.has(cleaned) && tracked.size >= maxEntries) {
       return UNKNOWN_MODEL;
     }
     return cleaned;
   }
-  // The resource comes from a trusted upstream header, but clean and bound it
-  // with the same discipline as model labels: strip control characters that
-  // would corrupt the exposition format and fold overflow into "unknown".
+  // The model can originate from a (possibly hostile) client request.
+  #modelLabel(model) {
+    return this.#boundedLabel(model, this.#tokens, MAX_TRACKED_MODELS);
+  }
+  // The resource comes from a trusted upstream header, but is bounded the same way.
   #rateLimitResource(resource) {
-    const cleaned = cleanLabel(resource).slice(0, MAX_MODEL_LABEL_LENGTH) || UNKNOWN_MODEL;
-    if (!this.#githubRateLimit.has(cleaned) && this.#githubRateLimit.size >= MAX_TRACKED_RATELIMIT_RESOURCES) {
-      return UNKNOWN_MODEL;
-    }
-    return cleaned;
+    return this.#boundedLabel(resource, this.#githubRateLimit, MAX_TRACKED_RATELIMIT_RESOURCES);
   }
   #observeDuration(route, seconds) {
     const value = Number.isFinite(seconds) && seconds >= 0 ? seconds : 0;
@@ -2628,7 +2629,7 @@ function recordResponseTextUsage(text, isSse, fallbackModel, onUsage, onOutcome)
       considerSseLine(line, accumulator.consider);
     }
   } else {
-    const parsed = safeParse(text);
+    const parsed = safeJsonParse(text);
     if (parsed !== void 0) {
       accumulator.consider(parsed);
     }
@@ -2690,7 +2691,7 @@ async function consumeUsage(stream, isSse, fallbackModel, onUsage, signal, onOut
         considerSseLine(finalBuffer, accumulator.consider);
       }
     } else if (!overflowed && finalBuffer) {
-      const parsed = safeParse(finalBuffer);
+      const parsed = safeJsonParse(finalBuffer);
       if (parsed !== void 0) {
         accumulator.consider(parsed);
       }
@@ -2733,18 +2734,11 @@ function considerSseLine(line, consider) {
   if (!data || data === "[DONE]") {
     return;
   }
-  const parsed = safeParse(data);
+  const parsed = safeJsonParse(data);
   if (parsed !== void 0) {
     consider(parsed);
   }
 }
-function safeParse(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return void 0;
-  }
-}
 function modelText(value) {
   return typeof value === "string" ? value.trim() : "";
 }
@@ -2820,6 +2814,10 @@ function formatNumber(value) {
   return Number.isInteger(value) ? value.toString() : String(value);
 }
 
+// src/server.ts
+import { createHash, timingSafeEqual } from "crypto";
+import { Elysia } from "elysia";
+
 // src/dashboard.ts
 var DASHBOARD_HTML = `<!doctype html>
 <html lang="en">
@@ -3220,21 +3218,24 @@ footer.foot .end { margin-left:auto; }
   function mk(tag, cls, txt){ var e = document.createElement(tag); if (cls) e.className = cls; if (txt !== undefined && txt !== null) e.textContent = txt; return e; }
 
   // Set numeric text and flash on discrete change.
-  function setNum(id, value, kind){
+  function setNum(id, value, kind, num){
     var el = byId(id); if (!el) return;
     el.classList.remove("skel");
     var s = String(value);
     if (el.textContent !== s){
       el.textContent = s;
+      // Compare on the raw number (num) when provided, so directional flash works
+      // even when value is a pre-formatted display string.
+      var n = (num !== undefined) ? num : value;
       var prev = lastRender[id];
       if (prev !== undefined){
         var cls = "flash";
-        if (kind === "delta" && typeof value === "number" && typeof prev === "number"){
-          cls = value > prev ? "flash-up" : (value < prev ? "flash-down" : null);
+        if (kind === "delta" && typeof n === "number" && typeof prev === "number"){
+          cls = n > prev ? "flash-up" : (n < prev ? "flash-down" : null);
         }
         if (cls){ el.classList.remove("flash","flash-up","flash-down"); void el.offsetWidth; el.classList.add(cls); }
       }
-      lastRender[id] = value;
+      lastRender[id] = n;
     }
   }
   function setText(id, s){ var el = byId(id); if (el){ el.classList.remove("skel"); el.textContent = s; } }
@@ -3315,7 +3316,7 @@ footer.foot .end { margin-left:auto; }
     if (beat && dot){ dot.classList.remove("heartbeat"); void dot.offsetWidth; dot.classList.add("heartbeat"); }
   }
   function showBanner(text, ok){
-    var b = byId("banner"); b.textContent = text; b.className = "banner show" + (ok ? " ok" : ""); b.classList.add("show");
+    var b = byId("banner"); b.textContent = text; b.className = "show" + (ok ? " ok" : "");
     if (ok){ setTimeout(function(){ b.classList.remove("show"); }, 2000); }
   }
   function hideBanner(){ byId("banner").classList.remove("show"); }
@@ -3422,7 +3423,7 @@ footer.foot .end { margin-left:auto; }
     if (isFinite(reqPerSec)){ pushHist(hist.req, reqPerSec); setNum("req-num", rate(reqPerSec)); } else setText("req-num","\\u2014");
     if (isFinite(tokPerSec)){ pushHist(hist.tok, tokPerSec); setNum("tok-num", humanInt(tokPerSec)); } else setText("tok-num","\\u2014");
     var inflight = proxy.inFlight || 0;
-    pushHist(hist.inflight, inflight); setNum("inflight-num", String(inflight), "delta");
+    pushHist(hist.inflight, inflight); setNum("inflight-num", String(inflight), "delta", inflight);
     byId("v-inflight").classList.toggle("active", inflight > 0);
     setText("uptime-num", fmtUptime(proxy.uptimeSeconds || 0));
 
@@ -3565,7 +3566,7 @@ footer.foot .end { margin-left:auto; }
 
   function renderUpstream(up, delta, restarted){
     setNum("up-total", humanInt(up.total||0));
-    setNum("up-errors", humanInt(up.errors||0), "delta");
+    setNum("up-errors", humanInt(up.errors||0), "delta", up.errors||0);
     var er = up.total ? (up.errors/up.total*100) : 0;
     var rt = byId("up-rate"); rt.textContent = pct(er); rt.className = "v rate " + (er > 5 ? "danger" : er > 1 ? "warn" : "ok");
     byId("up-errblk").classList.toggle("hot", (up.errors||0) > 0);
@@ -3639,8 +3640,9 @@ async function getVersion() {
     resolved = BAKED_VERSION;
   } else {
     try {
-      const manifest = await Bun.file(new URL("../package.json", import.meta.url)).json();
-      resolved = typeof manifest.version === "string" ? manifest.version : "0.0.0";
+      const manifest = asRecord(await Bun.file(new URL("../package.json", import.meta.url)).json());
+      const version = manifest.version;
+      resolved = typeof version === "string" ? version : "0.0.0";
     } catch {
       resolved = "0.0.0";
     }
@@ -3666,6 +3668,18 @@ var RequestBodyTooLargeError = class extends Error {
     this.name = "RequestBodyTooLargeError";
   }
 };
+var InvalidJsonError = class extends Error {
+  constructor() {
+    super(INVALID_JSON_MESSAGE);
+    this.name = "InvalidJsonError";
+  }
+};
+var JsonNotObjectError = class extends Error {
+  constructor() {
+    super(JSON_OBJECT_MESSAGE);
+    this.name = "JsonNotObjectError";
+  }
+};
 function createHoopilotHandler(options = {}) {
   const client = new CopilotClient(options);
   const apiKey = options.apiKey ?? envValue(options.env?.HOOPILOT_API_KEY);
@@ -3675,8 +3689,19 @@ function createHoopilotHandler(options = {}) {
   const readUsage = createUsageReader(client, metrics);
   const recordTokens = (model, usage) => metrics.recordTokens(model, usage);
   const recordExtraction = (extracted) => metrics.recordTokenExtraction(extracted);
-  const streamingProxyMode = resolveStreamingProxyMode(options);
-  const bufferProxyBodies = shouldBufferProxyBodies(streamingProxyMode);
+  const bufferProxyBodies = shouldBufferProxyBodies(resolveStreamingProxyMode(options));
+  const requestContext = /* @__PURE__ */ new WeakMap();
+  const app = buildApp({
+    apiKey,
+    allowedOrigins,
+    bufferProxyBodies,
+    client,
+    metrics,
+    readUsage,
+    recordExtraction,
+    recordTokens,
+    requestContext
+  });
   return async (request) => {
     const startedAt = performance.now();
     const url = new URL(request.url);
@@ -3692,7 +3717,24 @@ function createHoopilotHandler(options = {}) {
     metrics.startRequest();
     const origin = request.headers.get("origin")?.trim() || void 0;
     const corsOrigin = resolveCorsAllowOrigin(origin, allowedOrigins);
-    const finish = (response) => finishResponse(response, {
+    const inner = normalizeInnerRequest(request, apiPath, url);
+    requestContext.set(inner, {
+      apiPath,
+      logger: requestLogger,
+      origin,
+      originalPath: url.pathname
+    });
+    let response;
+    try {
+      response = await app.handle(inner);
+    } catch (error) {
+      requestLogger.error(
+        { err: errorDetails(error), event: "http.request.failed" },
+        "request failed"
+      );
+      response = jsonError(500, "internal_error", errorMessage(error));
+    }
+    return finishResponse(response, {
       corsOrigin,
       logger: requestLogger,
       method: request.method,
@@ -3703,144 +3745,175 @@ function createHoopilotHandler(options = {}) {
       closeConnection: bufferProxyBodies,
       trackStreamingBody: !bufferProxyBodies
     });
+  };
+}
+function buildApp(deps) {
+  const {
+    apiKey,
+    allowedOrigins,
+    bufferProxyBodies,
+    client,
+    metrics,
+    readUsage,
+    recordExtraction,
+    recordTokens,
+    requestContext
+  } = deps;
+  const contextFor = (request) => {
+    const stored = requestContext.get(request);
+    if (stored) {
+      return stored;
+    }
+    const originalPath = new URL(request.url).pathname;
+    return {
+      apiPath: canonicalApiPath(originalPath),
+      logger: noopLogger,
+      origin: request.headers.get("origin")?.trim() || void 0,
+      originalPath
+    };
+  };
+  const loggerFor = (request) => contextFor(request).logger;
+  const noBody = { parse: "none" };
+  return new Elysia().onRequest(({ request }) => {
+    const { apiPath, logger, origin } = contextFor(request);
     const browserOrigin = forbiddenBrowserOrigin(origin, request, allowedOrigins);
     if (browserOrigin) {
-      requestLogger.warn(
+      logger.warn(
         { event: "http.request.forbidden_origin", origin: browserOrigin },
         "blocked cross-origin browser request"
       );
-      return finish(jsonError(403, "forbidden_origin", FORBIDDEN_BROWSER_ORIGIN_MESSAGE));
+      return jsonError(403, "forbidden_origin", FORBIDDEN_BROWSER_ORIGIN_MESSAGE);
     }
     if (request.method === "OPTIONS") {
-      return finish(new Response(null, { headers: corsHeaders() }));
+      return new Response(null, { headers: corsHeaders() });
     }
     if (request.method === "GET" && apiPath === "/dashboard") {
-      return finish(dashboardResponse());
+      return dashboardResponse();
     }
     if (!isAuthorized(request, apiKey)) {
-      requestLogger.warn({ event: "http.request.unauthorized" }, "invalid hoopilot api key");
-      return finish(jsonError(401, "invalid_api_key", "Invalid or missing Hoopilot API key."));
+      logger.warn({ event: "http.request.unauthorized" }, "invalid hoopilot api key");
+      return jsonError(401, "invalid_api_key", "Invalid or missing Hoopilot API key.");
     }
-    try {
-      if (request.method === "GET" && (apiPath === "/" || apiPath === "/healthz")) {
-        return finish(jsonResponse({ name: "hoopilot", object: "health", status: "ok" }));
-      }
-      if (request.method === "GET" && apiPath === "/metrics") {
-        return finish(metricsResponse(metrics));
-      }
-      if (request.method === "GET" && apiPath === "/v1/usage") {
-        return finish(await handleUsage(metrics, readUsage, request.signal));
-      }
-      if (request.method === "GET" && apiPath === "/v1/responses") {
-        return finish(websocketUnsupportedResponse());
-      }
-      if (request.method === "GET" && apiPath === "/v1/models") {
-        return finish(await handleModels(client, metrics, request.signal, requestLogger));
-      }
-      if (request.method === "POST" && apiPath === "/v1/messages") {
-        return finish(
-          await handleAnthropicMessages(
-            client,
-            metrics,
-            recordTokens,
-            recordExtraction,
-            request,
-            requestLogger,
-            bufferProxyBodies
-          )
-        );
-      }
-      if (request.method === "POST" && apiPath === "/v1/messages/count_tokens") {
-        return finish(handleAnthropicCountTokens(await readJson(request)));
-      }
-      if (request.method === "POST" && apiPath === "/v1/chat/completions") {
-        return finish(
-          await handleChatCompletions(
-            client,
-            metrics,
-            recordTokens,
-            recordExtraction,
-            request,
-            requestLogger,
-            bufferProxyBodies
-          )
-        );
-      }
-      if (request.method === "POST" && apiPath === "/v1/completions") {
-        return finish(
-          await handleCompletions(
-            client,
-            metrics,
-            recordTokens,
-            recordExtraction,
-            request,
-            requestLogger,
-            bufferProxyBodies
-          )
-        );
-      }
-      if (request.method === "POST" && apiPath === "/v1/responses/compact") {
-        return finish(
-          await handleResponsesCompact(
-            client,
-            metrics,
-            recordTokens,
-            recordExtraction,
-            request,
-            requestLogger
-          )
-        );
-      }
-      if (request.method === "POST" && apiPath === "/v1/responses") {
-        return finish(
-          await handleResponses(
-            client,
-            metrics,
-            recordTokens,
-            recordExtraction,
-            request,
-            requestLogger,
-            bufferProxyBodies
-          )
-        );
-      }
-      return finish(jsonError(404, "not_found", `No route for ${request.method} ${url.pathname}.`));
-    } catch (error) {
-      if (error instanceof CopilotAuthError) {
-        requestLogger.warn(
-          { err: errorDetails(error), event: "copilot.auth.missing" },
-          "copilot auth failed"
-        );
-        return finish(jsonError(401, "copilot_auth_error", error.message));
-      }
-      const message = errorMessage(error);
-      if (message === INVALID_JSON_MESSAGE || message === JSON_OBJECT_MESSAGE) {
-        requestLogger.warn(
-          { err: errorDetails(error), event: "http.request.failed" },
-          "request body was not usable json"
-        );
-        return finish(jsonError(400, "invalid_request_error", message));
-      } else if (error instanceof OpenAICompatibilityError || error instanceof AnthropicCompatibilityError) {
-        requestLogger.warn(
-          { err: errorDetails(error), event: "http.request.failed" },
-          "request body used unsupported compatibility fields"
-        );
-        return finish(jsonError(400, "invalid_request_error", message));
-      } else if (error instanceof RequestBodyTooLargeError) {
-        requestLogger.warn(
-          { err: errorDetails(error), event: "http.request.failed" },
-          "request body exceeded size limit"
-        );
-        return finish(jsonError(413, "request_too_large", message));
-      } else {
-        requestLogger.error(
-          { err: errorDetails(error), event: "http.request.failed" },
-          "request failed"
-        );
-      }
-      return finish(jsonError(500, "internal_error", message));
+  }).onError(({ code, error, request }) => {
+    const { logger, originalPath } = contextFor(request);
+    if (code === "NOT_FOUND") {
+      return jsonError(404, "not_found", `No route for ${request.method} ${originalPath}.`);
+    }
+    if (error instanceof CopilotAuthError) {
+      logger.warn(
+        { err: errorDetails(error), event: "copilot.auth.missing" },
+        "copilot auth failed"
+      );
+      return jsonError(401, "copilot_auth_error", error.message);
+    }
+    const message = errorMessage(error);
+    if (error instanceof InvalidJsonError || error instanceof JsonNotObjectError) {
+      logger.warn(
+        { err: errorDetails(error), event: "http.request.failed" },
+        "request body was not usable json"
+      );
+      return jsonError(400, "invalid_request_error", message);
+    }
+    if (error instanceof OpenAICompatibilityError || error instanceof AnthropicCompatibilityError) {
+      logger.warn(
+        { err: errorDetails(error), event: "http.request.failed" },
+        "request body used unsupported compatibility fields"
+      );
+      return jsonError(400, "invalid_request_error", message);
     }
+    if (error instanceof RequestBodyTooLargeError) {
+      logger.warn(
+        { err: errorDetails(error), event: "http.request.failed" },
+        "request body exceeded size limit"
+      );
+      return jsonError(413, "request_too_large", message);
+    }
+    logger.error({ err: errorDetails(error), event: "http.request.failed" }, "request failed");
+    return jsonError(500, "internal_error", message);
+  }).get("/", () => jsonResponse({ name: "hoopilot", object: "health", status: "ok" })).get("/healthz", () => jsonResponse({ name: "hoopilot", object: "health", status: "ok" })).get("/metrics", () => metricsResponse(metrics)).get("/v1/usage", ({ request }) => handleUsage(metrics, readUsage, request.signal)).get(
+    "/v1/models",
+    ({ request }) => handleModels(client, metrics, request.signal, loggerFor(request))
+  ).get("/v1/responses", () => websocketUnsupportedResponse()).post(
+    "/v1/messages",
+    ({ request }) => handleAnthropicMessages(
+      client,
+      metrics,
+      recordTokens,
+      recordExtraction,
+      request,
+      loggerFor(request),
+      bufferProxyBodies
+    ),
+    noBody
+  ).post(
+    "/v1/messages/count_tokens",
+    ({ request }) => handleAnthropicCountTokens(request),
+    noBody
+  ).post(
+    "/v1/chat/completions",
+    ({ request }) => handleChatCompletions(
+      client,
+      metrics,
+      recordTokens,
+      recordExtraction,
+      request,
+      loggerFor(request),
+      bufferProxyBodies
+    ),
+    noBody
+  ).post(
+    "/v1/completions",
+    ({ request }) => handleCompletions(
+      client,
+      metrics,
+      recordTokens,
+      recordExtraction,
+      request,
+      loggerFor(request),
+      bufferProxyBodies
+    ),
+    noBody
+  ).post(
+    "/v1/responses/compact",
+    ({ request }) => handleResponsesCompact(
+      client,
+      metrics,
+      recordTokens,
+      recordExtraction,
+      request,
+      loggerFor(request)
+    ),
+    noBody
+  ).post(
+    "/v1/responses",
+    ({ request }) => handleResponses(
+      client,
+      metrics,
+      recordTokens,
+      recordExtraction,
+      request,
+      loggerFor(request),
+      bufferProxyBodies
+    ),
+    noBody
+  );
+}
+function normalizeInnerRequest(request, canonicalPath, url) {
+  if (canonicalPath === url.pathname) {
+    return request;
+  }
+  const target = new URL(url);
+  target.pathname = canonicalPath;
+  const init = {
+    headers: request.headers,
+    method: request.method,
+    signal: request.signal
   };
+  if (request.body) {
+    init.body = request.body;
+    init.duplex = "half";
+  }
+  return new Request(target, init);
 }
 function startHoopilotServer(options = {}) {
   const host = options.host ?? envValue(options.env?.HOST) ?? DEFAULT_HOST;
@@ -3919,7 +3992,8 @@ async function handleAnthropicMessages(client, metrics, recordTokens, recordExtr
   recordExtraction(usage !== void 0);
   return jsonResponse(responsesResponseToAnthropicMessage(body, model));
 }
-function handleAnthropicCountTokens(body) {
+async function handleAnthropicCountTokens(request) {
+  const body = await readJson(request);
   return jsonResponse(estimateAnthropicMessageTokens(body));
 }
 async function handleModels(client, metrics, signal, logger) {
@@ -4005,14 +4079,14 @@ async function handleCompletions(client, metrics, recordTokens, recordExtraction
   return jsonResponse(chatCompletionToCompletion(completion));
 }
 async function handleResponses(client, metrics, recordTokens, recordExtraction, request, logger, bufferProxyBodies) {
-  const body = await readJsonText(request);
+  const { json, text: body } = await readJsonText(request);
   const upstream = await client.responses(body, request.signal);
   metrics.recordUpstream("/responses", upstream.ok);
   if (!upstream.ok) {
     return proxyError(upstream, logger);
   }
   logUpstreamSuccess(logger, "/responses", upstream.status);
-  const model = normalizeRequestedModel(asRecord(safeParseJson(body)).model);
+  const model = normalizeRequestedModel(json.model);
   return proxyResponse(
     await responseWithObservedUsage(
       upstream,
@@ -4100,17 +4174,16 @@ function parseJsonObject2(text) {
   try {
     parsed = JSON.parse(text);
   } catch {
-    throw new Error(INVALID_JSON_MESSAGE);
+    throw new InvalidJsonError();
   }
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(JSON_OBJECT_MESSAGE);
+    throw new JsonNotObjectError();
   }
   return parsed;
 }
 async function readJsonText(request) {
   const text = await readRequestText(request);
-  parseJsonObject2(text);
-  return text;
+  return { json: parseJsonObject2(text), text };
 }
 async function readRequestText(request) {
   const contentLength = request.headers.get("content-length");
@@ -4168,7 +4241,7 @@ function jsonError(status, code, message) {
   );
 }
 function upstreamErrorResponse(status, text) {
-  const parsedError = asRecord(asRecord(safeParseJson(text)).error);
+  const parsedError = asRecord(asRecord(safeJsonParse(text)).error);
   if (Object.keys(parsedError).length > 0) {
     return jsonResponse({ error: parsedError }, status);
   }
@@ -4190,13 +4263,18 @@ function corsHeaders() {
     "access-control-expose-headers": "x-request-id"
   };
 }
+function secretEquals(candidate, secret) {
+  const a = createHash("sha256").update(candidate).digest();
+  const b = createHash("sha256").update(secret).digest();
+  return timingSafeEqual(a, b);
+}
 function isAuthorized(request, apiKey) {
   if (!apiKey) {
     return true;
   }
   const authorization = request.headers.get("authorization") ?? "";
   const bearer = authorization.match(/^Bearer\s+(.+)$/i)?.[1];
-  return bearer === apiKey || request.headers.get("x-api-key") === apiKey;
+  return bearer !== void 0 && secretEquals(bearer, apiKey) || secretEquals(request.headers.get("x-api-key") ?? "", apiKey);
 }
 function forbiddenBrowserOrigin(origin, request, allowedOrigins) {
   if (origin) {
@@ -4233,7 +4311,7 @@ function upstreamAuthMessage(message) {
   return `GitHub Copilot rejected the credential or account access: ${message}`;
 }
 function isLoopbackHost(host) {
-  return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]";
+  return isLoopbackHostname(host);
 }
 function urlHost(host) {
   return host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
@@ -4252,9 +4330,6 @@ function normalizeServerPort(value) {
   }
   return port;
 }
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 function serverLogger(options) {
   if (options.logger) {
     return options.logger.child({ component: "server" });
@@ -4270,10 +4345,7 @@ function serverLogger(options) {
 }
 function resolveStreamingProxyMode(options) {
   const value = options.streamingProxyMode ?? envValue(options.env?.HOOPILOT_STREAM_MODE) ?? envValue(options.env?.HOOPILOT_STREAMING_PROXY_MODE) ?? "auto";
-  if (value === "auto" || value === "buffer" || value === "live") {
-    return value;
-  }
-  throw new Error(`Invalid stream mode: ${value}. Expected auto, live, or buffer.`);
+  return parseStreamingProxyMode(value);
 }
 function shouldBufferProxyBodies(mode) {
   if (mode === "buffer") {
@@ -4331,11 +4403,13 @@ function responseWithRequestId(response, requestId, closeConnection, corsOrigin)
 function trackStreamCompletion(body, onComplete) {
   const reader = body.getReader();
   let fired = false;
-  const fire = () => {
-    if (!fired) {
-      fired = true;
-      onComplete();
+  const release = () => {
+    if (fired) {
+      return;
     }
+    fired = true;
+    onComplete();
+    reader.releaseLock();
   };
   return new ReadableStream({
     async pull(controller) {
@@ -4343,18 +4417,25 @@ function trackStreamCompletion(body, onComplete) {
         const { done, value } = await reader.read();
         if (done) {
           controller.close();
-          fire();
+          release();
           return;
         }
         controller.enqueue(value);
       } catch (error) {
-        fire();
+        release();
         controller.error(error);
       }
     },
-    cancel(reason) {
-      fire();
-      return reader.cancel(reason);
+    async cancel(reason) {
+      if (!fired) {
+        fired = true;
+        onComplete();
+      }
+      try {
+        await reader.cancel(reason);
+      } finally {
+        reader.releaseLock();
+      }
     }
   });
 }
@@ -4402,47 +4483,26 @@ function canonicalApiPath(path) {
       return withoutTrailingSlash;
   }
 }
+var API_ROUTES = [
+  { method: "GET", path: "/", name: "health" },
+  { method: "GET", path: "/healthz", name: "health" },
+  { method: "GET", path: "/dashboard", name: "dashboard" },
+  { method: "GET", path: "/metrics", name: "metrics" },
+  { method: "GET", path: "/v1/usage", name: "usage" },
+  { method: "GET", path: "/v1/models", name: "models" },
+  { method: "GET", path: "/v1/responses", name: "responses_websocket" },
+  { method: "POST", path: "/v1/messages", name: "anthropic_messages" },
+  { method: "POST", path: "/v1/messages/count_tokens", name: "anthropic_count_tokens" },
+  { method: "POST", path: "/v1/chat/completions", name: "chat_completions" },
+  { method: "POST", path: "/v1/completions", name: "completions" },
+  { method: "POST", path: "/v1/responses/compact", name: "responses_compact" },
+  { method: "POST", path: "/v1/responses", name: "responses" }
+];
 function routeFor(method, path) {
   if (method === "OPTIONS") {
     return "cors.preflight";
   }
-  if (method === "GET" && (path === "/" || path === "/healthz")) {
-    return "health";
-  }
-  if (method === "GET" && path === "/dashboard") {
-    return "dashboard";
-  }
-  if (method === "GET" && path === "/metrics") {
-    return "metrics";
-  }
-  if (method === "GET" && path === "/v1/usage") {
-    return "usage";
-  }
-  if (method === "GET" && path === "/v1/models") {
-    return "models";
-  }
-  if (method === "POST" && path === "/v1/messages") {
-    return "anthropic_messages";
-  }
-  if (method === "POST" && path === "/v1/messages/count_tokens") {
-    return "anthropic_count_tokens";
-  }
-  if (method === "POST" && path === "/v1/chat/completions") {
-    return "chat_completions";
-  }
-  if (method === "POST" && path === "/v1/completions") {
-    return "completions";
-  }
-  if (method === "POST" && path === "/v1/responses/compact") {
-    return "responses_compact";
-  }
-  if (method === "POST" && path === "/v1/responses") {
-    return "responses";
-  }
-  if (method === "GET" && path === "/v1/responses") {
-    return "responses_websocket";
-  }
-  return "not_found";
+  return API_ROUTES.find((entry) => entry.method === method && entry.path === path)?.name ?? "not_found";
 }
 function isStreamingResponse(response) {
   return response.headers.get("content-type")?.includes("text/event-stream") ?? false;
@@ -4520,24 +4580,19 @@ function createUsageReader(client, metrics, now = Date.now, ttlMs = USAGE_CACHE_
     }
   };
 }
-function safeParseJson(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return void 0;
-  }
-}
 export {
   AnthropicCompatibilityError,
   COPILOT_USAGE_API_VERSION,
   CopilotAuth,
   CopilotAuthError,
   CopilotClient,
+  DEFAULT_COPILOT_API_BASE_URL,
   DEFAULT_GITHUB_API_BASE_URL,
   DEFAULT_LOG_FORMAT,
   DEFAULT_LOG_LEVEL,
   DEFAULT_MODEL,
   MetricsRegistry,
+  OpenAICompatibilityError,
   PROMETHEUS_CONTENT_TYPE,
   anthropicMessagesToResponsesRequest,
   applyCopilotHeaders,
@@ -4563,6 +4618,7 @@ export {
   parseLogLevel,
   parseRateLimitHeaders,
   readStoredCopilotAuth,
+  recordResponseTextUsage,
   responsesCompactionResult,
   responsesRequestToChatCompletion,
   responsesResponseToAnthropicMessage,