@openhoo/hoopilot 2.1.8 → 2.1.10

package/dist/index.js

@@ -3,6 +3,7 @@ import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync }
 import { dirname, join } from "path";
 
 // src/util.ts
+import { isIP } from "net";
 function trimTrailingSlash(value) {
   return value.replace(/\/+$/, "");
 }
@@ -39,9 +40,16 @@ 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);
+  const normalized = host.trim().toLowerCase();
+  const address = normalized.startsWith("[") && normalized.endsWith("]") ? normalized.slice(1, -1) : normalized;
+  if (address === "localhost") {
+    return true;
+  }
+  if (isIP(address) === 4) {
+    return address.startsWith("127.");
+  }
+  return isIP(address) === 6 && (address === "::1" || address === "0:0:0:0:0:0:0:1");
 }
 function isLoopbackHttpUrl(url) {
   return url.protocol === "http:" && isLoopbackHostname(url.hostname);
@@ -89,12 +97,38 @@ var STREAMING_PROXY_MODES = [
   "buffer",
   "live"
 ];
+var USAGE_ACCOUNTING_MODES = [
+  "basic",
+  "full",
+  "off"
+];
 function parseStreamingProxyMode(value) {
   if (STREAMING_PROXY_MODES.includes(value)) {
     return value;
   }
   throw new Error(`Invalid stream mode: ${value}. Expected ${STREAMING_PROXY_MODES.join(", ")}.`);
 }
+function parseUsageAccountingMode(value) {
+  if (USAGE_ACCOUNTING_MODES.includes(value)) {
+    return value;
+  }
+  throw new Error(
+    `Invalid usage accounting mode: ${value}. Expected ${USAGE_ACCOUNTING_MODES.join(", ")}.`
+  );
+}
+function parseBooleanEnv(value, name) {
+  const raw = envValue(value)?.toLowerCase();
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (raw === "1" || raw === "true" || raw === "yes" || raw === "on") {
+    return true;
+  }
+  if (raw === "0" || raw === "false" || raw === "no" || raw === "off") {
+    return false;
+  }
+  throw new Error(`${name} must be one of: 1, 0, true, false, yes, no, on, off.`);
+}
 
 // src/auth-store.ts
 var StoredCopilotAuthError = class extends Error {
@@ -1506,6 +1540,8 @@ function epochSeconds() {
 var PROMETHEUS_CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8";
 var DURATION_BUCKETS_SECONDS = [0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60];
 var USAGE_BUFFER_LIMIT_BYTES = 16 * 1024 * 1024;
+var PROMETHEUS_CACHE_TTL_MS = 1e3;
+var PROMETHEUS_CACHE_NEUTRAL_ROUTES = /* @__PURE__ */ new Set(["metrics"]);
 var MAX_TRACKED_MODELS = 200;
 var MAX_MODEL_LABEL_LENGTH = 200;
 var MAX_TRACKED_RATELIMIT_RESOURCES = 32;
@@ -1514,6 +1550,9 @@ var UNKNOWN_MODEL = "unknown";
 function emptyModelTotals() {
   return { cached: 0, completion: 0, prompt: 0, reasoning: 0, requests: 0, total: 0 };
 }
+function isPrometheusCacheNeutralRoute(route) {
+  return route !== void 0 && PROMETHEUS_CACHE_NEUTRAL_ROUTES.has(route);
+}
 var MetricsRegistry = class {
   #startedAtMs;
   #inFlight = 0;
@@ -1525,11 +1564,16 @@ var MetricsRegistry = class {
   #copilotQuota;
   #githubRateLimit = /* @__PURE__ */ new Map();
   #extraction = { extracted: 0, missing: 0 };
+  #generation = 0;
+  #prometheusCache;
   constructor(options = {}) {
     this.#startedAtMs = (options.now ?? Date.now)();
   }
   /** Mark a request as started; pair with exactly one {@link observe}. */
   startRequest(route) {
+    if (!isPrometheusCacheNeutralRoute(route)) {
+      this.#changed();
+    }
     this.#inFlight += 1;
     if (route) {
       this.#inFlightByRoute.set(route, (this.#inFlightByRoute.get(route) ?? 0) + 1);
@@ -1537,6 +1581,9 @@ var MetricsRegistry = class {
   }
   /** Record a completed request and clear its in-flight slot. */
   observe(observation) {
+    if (!isPrometheusCacheNeutralRoute(observation.route)) {
+      this.#changed();
+    }
     if (this.#inFlight > 0) {
       this.#inFlight -= 1;
     }
@@ -1557,6 +1604,7 @@ var MetricsRegistry = class {
    * rising miss rate flags clients whose token usage is going unaccounted.
    */
   recordTokenExtraction(extracted) {
+    this.#changed();
     if (extracted) {
       this.#extraction.extracted += 1;
     } else {
@@ -1565,6 +1613,7 @@ var MetricsRegistry = class {
   }
   /** Accumulate token counts for a model from one upstream completion. */
   recordTokens(model, usage) {
+    this.#changed();
     const name = this.#modelLabel(model);
     const totals = this.#tokens.get(name) ?? emptyModelTotals();
     totals.requests += 1;
@@ -1577,11 +1626,13 @@ var MetricsRegistry = class {
   }
   /** Record one upstream Copilot call and whether it succeeded. */
   recordUpstream(path, ok) {
+    this.#changed();
     const key = labelKey(path, ok ? "ok" : "error");
     this.#upstream.set(key, (this.#upstream.get(key) ?? 0) + 1);
   }
   /** Store the latest Copilot quota so /metrics can expose it as gauges. */
   recordCopilotQuota(usage) {
+    this.#changed();
     this.#copilotQuota = usage;
   }
   /**
@@ -1593,6 +1644,7 @@ var MetricsRegistry = class {
     if (!rateLimit) {
       return;
     }
+    this.#changed();
     const resource = this.#rateLimitResource(rateLimit.resource);
     this.#githubRateLimit.set(resource, { ...rateLimit, resource });
   }
@@ -1629,6 +1681,9 @@ var MetricsRegistry = class {
     }
     this.#durations.set(route, entry);
   }
+  #changed() {
+    this.#generation += 1;
+  }
   /** A JSON-friendly view of the current counters. */
   snapshot(nowOrOptions = Date.now) {
     const options = typeof nowOrOptions === "function" ? { now: nowOrOptions } : nowOrOptions;
@@ -1732,13 +1787,18 @@ var MetricsRegistry = class {
   }
   /** Render the Prometheus text exposition format (version 0.0.4). */
   renderPrometheus(now = Date.now) {
+    const nowMs = now();
+    const cached = this.#prometheusCache;
+    if (cached && cached.generation === this.#generation && nowMs - cached.renderedAtMs < PROMETHEUS_CACHE_TTL_MS) {
+      return cached.text;
+    }
     const lines = [];
     lines.push("# HELP hoopilot_process_start_time_seconds Unix epoch when the proxy started.");
     lines.push("# TYPE hoopilot_process_start_time_seconds gauge");
     lines.push(`hoopilot_process_start_time_seconds ${this.#startedAtMs / 1e3}`);
     lines.push("# HELP hoopilot_uptime_seconds Seconds since the proxy started.");
     lines.push("# TYPE hoopilot_uptime_seconds gauge");
-    lines.push(`hoopilot_uptime_seconds ${Math.max(0, (now() - this.#startedAtMs) / 1e3)}`);
+    lines.push(`hoopilot_uptime_seconds ${Math.max(0, (nowMs - this.#startedAtMs) / 1e3)}`);
     lines.push("# HELP hoopilot_requests_in_flight Requests currently being served.");
     lines.push("# TYPE hoopilot_requests_in_flight gauge");
     lines.push(`hoopilot_requests_in_flight ${this.#inFlight}`);
@@ -1804,8 +1864,10 @@ var MetricsRegistry = class {
     }
     this.#renderGithubRateLimit(lines);
     this.#renderCopilotQuota(lines);
-    return `${lines.join("\n")}
+    const text = `${lines.join("\n")}
 `;
+    this.#prometheusCache = { generation: this.#generation, renderedAtMs: nowMs, text };
+    return text;
   }
   #renderGithubRateLimit(lines) {
     const entries = [...this.#githubRateLimit.values()];
@@ -1940,21 +2002,6 @@ var MetricsRegistry = class {
     }
   }
 };
-function observeResponseUsage(response, fallbackModel, onUsage, signal, onOutcome) {
-  const body = response.body;
-  if (!body) {
-    return response;
-  }
-  const isSse = response.headers.get("content-type")?.includes("text/event-stream") ?? false;
-  return new Response(
-    streamWithUsageObservation(body, isSse, fallbackModel, onUsage, signal, onOutcome),
-    {
-      headers: response.headers,
-      status: response.status,
-      statusText: response.statusText
-    }
-  );
-}
 function recordResponseTextUsage(text, isSse, fallbackModel, onUsage, onOutcome) {
   const accumulator = createUsageAccumulator(fallbackModel, onUsage, onOutcome);
   if (isSse) {
@@ -1969,9 +2016,10 @@ function recordResponseTextUsage(text, isSse, fallbackModel, onUsage, onOutcome)
   }
   accumulator.finish();
 }
-function streamWithUsageObservation(stream, isSse, fallbackModel, onUsage, signal, onOutcome) {
+function streamWithUsageObservation(stream, isSse, fallbackModel, onUsage, signal, onOutcome, onComplete) {
   const reader = stream.getReader();
   let aborted = signal?.aborted ?? false;
+  let completed = false;
   let released = false;
   const onAbort = () => {
     aborted = true;
@@ -2000,6 +2048,10 @@ function streamWithUsageObservation(stream, isSse, fallbackModel, onUsage, signa
     }
     released = true;
     signal?.removeEventListener("abort", onAbort);
+    if (!completed) {
+      completed = true;
+      onComplete?.();
+    }
     reader.releaseLock();
   };
   const observeChunk = (chunkBytes) => {
@@ -2109,6 +2161,9 @@ function considerSseLine(line, consider) {
   if (!data || data === "[DONE]") {
     return;
   }
+  if (!data.includes('"usage"')) {
+    return;
+  }
   const parsed = safeJsonParse(data);
   if (parsed !== void 0) {
     consider(parsed);
@@ -2362,7 +2417,7 @@ function anthropicMessagesToResponsesInput(messages) {
             arguments: JSON.stringify(asRecord(part.input)),
             cache_control: anthropicCacheControl(part.cache_control),
             call_id: textValue(part.id) || `call_hoopilot_${fallbackToolCallIndex++}`,
-            name: textValue(part.name),
+            name: requiredAnthropicText(part.name, "tool_use name"),
             type: "function_call"
           })
         );
@@ -2508,7 +2563,7 @@ function anthropicTools(tools) {
     return removeUndefined({
       cache_control: anthropicCacheControl(record.cache_control),
       description: record.description,
-      name: record.name,
+      name: requiredAnthropicText(record.name, "tool name"),
       parameters: record.input_schema,
       strict: record.strict,
       type: "function"
@@ -2581,12 +2636,19 @@ function anthropicToolChoice(toolChoice) {
     return "none";
   }
   if (type === "tool") {
-    return { name: textValue(record.name), type: "function" };
+    return { name: requiredAnthropicText(record.name, "tool_choice name"), type: "function" };
   }
   throw new AnthropicCompatibilityError(
     `Anthropic tool_choice type "${type || "unknown"}" is not supported.`
   );
 }
+function requiredAnthropicText(value, field) {
+  const text = textValue(value).trim();
+  if (!text) {
+    throw new AnthropicCompatibilityError(`Anthropic ${field} is required.`);
+  }
+  return text;
+}
 function anthropicThinkingToReasoning(thinking) {
   const record = asRecord(thinking);
   if (Object.keys(record).length === 0) {
@@ -3875,6 +3937,17 @@ function isLoopbackOrigin(origin) {
 }
 
 // src/http/responses.ts
+var HOP_BY_HOP_HEADERS = [
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+];
+var STALE_BODY_HEADERS = ["content-encoding", "content-length"];
 function jsonResponse(body, status = 200) {
   return new Response(JSON.stringify(body), {
     headers: {
@@ -3914,9 +3987,7 @@ function responseFromText(source, text) {
 }
 function proxyResponse(upstream) {
   const headers = new Headers(upstream.headers);
-  headers.delete("content-encoding");
-  headers.delete("content-length");
-  headers.delete("transfer-encoding");
+  stripProxyUnsafeHeaders(headers);
   for (const [key, value] of Object.entries(corsHeaders())) {
     headers.set(key, value);
   }
@@ -3942,6 +4013,23 @@ function websocketUnsupportedResponse() {
   response.headers.set("upgrade", "websocket");
   return response;
 }
+function stripProxyUnsafeHeaders(headers) {
+  const connection = headers.get("connection");
+  if (connection) {
+    for (const name of connection.split(",")) {
+      const trimmed = name.trim();
+      if (trimmed) {
+        headers.delete(trimmed);
+      }
+    }
+  }
+  for (const name of HOP_BY_HOP_HEADERS) {
+    headers.delete(name);
+  }
+  for (const name of STALE_BODY_HEADERS) {
+    headers.delete(name);
+  }
+}
 
 // src/version.ts
 var BAKED_VERSION = typeof HOOPILOT_VERSION !== "undefined" ? HOOPILOT_VERSION : void 0;
@@ -3991,17 +4079,28 @@ function createHoopilotHandler(options = {}) {
   const recordTokens = (model, usage) => metrics.recordTokens(model, usage);
   const recordExtraction = (extracted) => metrics.recordTokenExtraction(extracted);
   const bufferProxyBodies = shouldBufferProxyBodies(resolveStreamingProxyMode(options));
+  const usageAccountingMode = resolveUsageAccountingMode(options);
+  const accessLog = resolveAccessLog(options);
+  const responseUsage = /* @__PURE__ */ new WeakMap();
+  const markUsage = (response, fallbackModel, cost) => {
+    if (shouldExtractUsage(usageAccountingMode, cost)) {
+      responseUsage.set(response, { fallbackModel, recordExtraction, recordTokens });
+    }
+    return response;
+  };
   const requestContext = /* @__PURE__ */ new WeakMap();
   const app = buildApp({
     apiKey,
     allowedOrigins,
     bufferProxyBodies,
     client,
+    markUsage,
     metrics,
     readUsage,
     recordExtraction,
     recordTokens,
-    requestContext
+    requestContext,
+    usageAccountingMode
   });
   return async (request) => {
     const startedAt = performance.now();
@@ -4037,11 +4136,14 @@ function createHoopilotHandler(options = {}) {
     }
     return finishResponse(response, {
       corsOrigin,
+      accessLog,
       logger: requestLogger,
       method: request.method,
       metrics,
       requestId,
+      signal: request.signal,
       route,
+      usageObservation: responseUsage.get(response),
       startedAt,
       closeConnection: bufferProxyBodies,
       trackStreamingBody: !bufferProxyBodies
@@ -4054,11 +4156,13 @@ function buildApp(deps) {
     allowedOrigins,
     bufferProxyBodies,
     client,
+    markUsage,
     metrics,
     readUsage,
     recordExtraction,
     recordTokens,
-    requestContext
+    requestContext,
+    usageAccountingMode
   } = deps;
   const contextFor = (request) => {
     const stored = requestContext.get(request);
@@ -4146,11 +4250,13 @@ function buildApp(deps) {
     ({ request }) => handleAnthropicMessages(
       client,
       metrics,
+      markUsage,
       recordTokens,
       recordExtraction,
       request,
       loggerFor(request),
-      bufferProxyBodies
+      bufferProxyBodies,
+      usageAccountingMode
     ),
     noBody
   ).post(
@@ -4162,11 +4268,13 @@ function buildApp(deps) {
     ({ request }) => handleChatCompletions(
       client,
       metrics,
+      markUsage,
       recordTokens,
       recordExtraction,
       request,
       loggerFor(request),
-      bufferProxyBodies
+      bufferProxyBodies,
+      usageAccountingMode
     ),
     noBody
   ).post(
@@ -4174,11 +4282,13 @@ function buildApp(deps) {
     ({ request }) => handleCompletions(
       client,
       metrics,
+      markUsage,
       recordTokens,
       recordExtraction,
       request,
       loggerFor(request),
-      bufferProxyBodies
+      bufferProxyBodies,
+      usageAccountingMode
     ),
     noBody
   ).post(
@@ -4189,7 +4299,8 @@ function buildApp(deps) {
       recordTokens,
       recordExtraction,
       request,
-      loggerFor(request)
+      loggerFor(request),
+      usageAccountingMode
     ),
     noBody
   ).post(
@@ -4197,11 +4308,13 @@ function buildApp(deps) {
     ({ request }) => handleResponses(
       client,
       metrics,
+      markUsage,
       recordTokens,
       recordExtraction,
       request,
       loggerFor(request),
-      bufferProxyBodies
+      bufferProxyBodies,
+      usageAccountingMode
     ),
     noBody
   );
@@ -4254,7 +4367,7 @@ function startHoopilotServer(options = {}) {
     url: `http://${urlHost(host)}:${server.port}`
   };
 }
-async function handleAnthropicMessages(client, metrics, recordTokens, recordExtraction, request, logger, bufferProxyBodies) {
+async function handleAnthropicMessages(client, metrics, markUsage, recordTokens, recordExtraction, request, logger, bufferProxyBodies, usageAccountingMode) {
   const anthropicRequest = await readJson(request);
   const responsesRequest = anthropicMessagesToResponsesRequest(anthropicRequest);
   const upstream = await client.responses(JSON.stringify(responsesRequest), request.signal);
@@ -4267,36 +4380,32 @@ async function handleAnthropicMessages(client, metrics, recordTokens, recordExtr
   if (isStreamingResponse(upstream) && upstream.body) {
     if (bufferProxyBodies) {
       const text = await upstream.text();
-      recordResponseTextUsage(text, true, model, recordTokens, recordExtraction);
+      recordBufferedUsage(text, true, model, usageAccountingMode, recordTokens, recordExtraction);
       return proxyResponse(
         responseFromText(upstream, responsesSseTextToAnthropicSseText(text, { model }))
       );
     }
-    const observed = observeResponseUsage(
-      upstream,
+    return markUsage(
+      proxyResponse(
+        new Response(responsesStreamToAnthropicStream(upstream.body, { model }), {
+          headers: upstream.headers,
+          status: upstream.status,
+          statusText: upstream.statusText
+        })
+      ),
       model,
-      recordTokens,
-      request.signal,
-      recordExtraction
-    );
-    if (!observed.body) {
-      return proxyResponse(observed);
-    }
-    return proxyResponse(
-      new Response(responsesStreamToAnthropicStream(observed.body, { model }), {
-        headers: observed.headers,
-        status: observed.status,
-        statusText: observed.statusText
-      })
+      "body"
     );
   }
   const body = asRecord(await upstream.json());
-  const usage = extractTokenUsage(body.usage);
-  if (usage) {
-    const responseModel = typeof body.model === "string" ? body.model.trim() : "";
-    recordTokens(responseModel || model, usage);
-  }
-  recordExtraction(usage !== void 0);
+  recordParsedUsage(
+    body.usage,
+    typeof body.model === "string" ? body.model.trim() : model,
+    model,
+    usageAccountingMode,
+    recordTokens,
+    recordExtraction
+  );
   return jsonResponse(responsesResponseToAnthropicMessage(body, model));
 }
 async function handleAnthropicCountTokens(request) {
@@ -4323,7 +4432,7 @@ async function handleModels(client, metrics, signal, logger) {
   logUpstreamSuccess(logger, "/models", upstream.status);
   return jsonResponse(normalizeModelsResponse(await upstream.json()));
 }
-async function handleChatCompletions(client, metrics, recordTokens, recordExtraction, request, logger, bufferProxyBodies) {
+async function handleChatCompletions(client, metrics, markUsage, recordTokens, recordExtraction, request, logger, bufferProxyBodies, usageAccountingMode) {
   const chatRequest = normalizeChatCompletionRequest(await readJson(request));
   const upstream = await client.chatCompletions(chatRequest, request.signal);
   metrics.recordUpstream("/chat/completions", upstream.ok);
@@ -4332,18 +4441,17 @@ async function handleChatCompletions(client, metrics, recordTokens, recordExtrac
   }
   logUpstreamSuccess(logger, "/chat/completions", upstream.status);
   const model = normalizeRequestedModel(chatRequest.model);
-  return proxyResponse(
-    await responseWithObservedUsage(
-      upstream,
-      model,
-      recordTokens,
-      request.signal,
-      bufferProxyBodies,
-      recordExtraction
-    )
+  return proxiedResponseWithOptionalUsage(
+    upstream,
+    model,
+    markUsage,
+    usageAccountingMode,
+    recordTokens,
+    recordExtraction,
+    bufferProxyBodies
   );
 }
-async function handleCompletions(client, metrics, recordTokens, recordExtraction, request, logger, bufferProxyBodies) {
+async function handleCompletions(client, metrics, markUsage, recordTokens, recordExtraction, request, logger, bufferProxyBodies, usageAccountingMode) {
   const body = await readJson(request);
   const upstream = await client.chatCompletions(
     completionsRequestToChatCompletion(body),
@@ -4358,34 +4466,41 @@ async function handleCompletions(client, metrics, recordTokens, recordExtraction
   if (isStreamingResponse(upstream) && upstream.body) {
     if (bufferProxyBodies) {
       const upstreamText = await upstream.text();
-      recordResponseTextUsage(upstreamText, true, model, recordTokens, recordExtraction);
+      recordBufferedUsage(
+        upstreamText,
+        true,
+        model,
+        usageAccountingMode,
+        recordTokens,
+        recordExtraction
+      );
       const text = completionSseTextFromChatSseText(upstreamText);
       return proxyResponse(responseFromText(upstream, text));
     }
-    return proxyResponse(
-      observeResponseUsage(
+    return markUsage(
+      proxyResponse(
         new Response(completionStreamFromChatStream(upstream.body), {
           headers: upstream.headers,
           status: upstream.status,
           statusText: upstream.statusText
-        }),
-        model,
-        recordTokens,
-        request.signal,
-        recordExtraction
-      )
+        })
+      ),
+      model,
+      "body"
     );
   }
   const completion = asRecord(await upstream.json());
-  const usage = extractTokenUsage(completion.usage);
-  if (usage) {
-    const responseModel = typeof completion.model === "string" ? completion.model.trim() : "";
-    recordTokens(responseModel || model, usage);
-  }
-  recordExtraction(usage !== void 0);
+  recordParsedUsage(
+    completion.usage,
+    typeof completion.model === "string" ? completion.model.trim() : model,
+    model,
+    usageAccountingMode,
+    recordTokens,
+    recordExtraction
+  );
   return jsonResponse(chatCompletionToCompletion(completion));
 }
-async function handleResponses(client, metrics, recordTokens, recordExtraction, request, logger, bufferProxyBodies) {
+async function handleResponses(client, metrics, markUsage, recordTokens, recordExtraction, request, logger, bufferProxyBodies, usageAccountingMode) {
   const { json, text: body } = await readJsonText(request);
   if (isResponsesCompactionRequest(json)) {
     return handleResponsesCompactionV2(
@@ -4395,7 +4510,8 @@ async function handleResponses(client, metrics, recordTokens, recordExtraction,
       recordExtraction,
       json,
       request,
-      logger
+      logger,
+      usageAccountingMode
     );
   }
   const upstream = await client.responses(
@@ -4408,18 +4524,17 @@ async function handleResponses(client, metrics, recordTokens, recordExtraction,
   }
   logUpstreamSuccess(logger, "/responses", upstream.status);
   const model = normalizeRequestedModel(json.model);
-  return proxyResponse(
-    await responseWithObservedUsage(
-      upstream,
-      model,
-      recordTokens,
-      request.signal,
-      bufferProxyBodies,
-      recordExtraction
-    )
+  return proxiedResponseWithOptionalUsage(
+    upstream,
+    model,
+    markUsage,
+    usageAccountingMode,
+    recordTokens,
+    recordExtraction,
+    bufferProxyBodies
   );
 }
-async function handleResponsesCompact(client, metrics, recordTokens, recordExtraction, request, logger) {
+async function handleResponsesCompact(client, metrics, recordTokens, recordExtraction, request, logger, usageAccountingMode) {
   const body = await readJson(request);
   const upstream = await client.responses(responsesCompactionRequestBody(body), request.signal);
   metrics.recordUpstream("/responses", upstream.ok);
@@ -4429,16 +4544,17 @@ async function handleResponsesCompact(client, metrics, recordTokens, recordExtra
   logUpstreamSuccess(logger, "/responses", upstream.status);
   const isSse = isStreamingResponse(upstream);
   const text = await upstream.text();
-  recordResponseTextUsage(
+  recordBufferedUsage(
     text,
     isSse,
     normalizeRequestedModel(body.model),
+    usageAccountingMode,
     recordTokens,
     recordExtraction
   );
   return jsonResponse(responsesCompactionResult(text, isSse));
 }
-async function handleResponsesCompactionV2(client, metrics, recordTokens, recordExtraction, json, request, logger) {
+async function handleResponsesCompactionV2(client, metrics, recordTokens, recordExtraction, json, request, logger, usageAccountingMode) {
   const upstream = await client.responses(responsesCompactionRequestBody(json), request.signal);
   metrics.recordUpstream("/responses", upstream.ok);
   if (!upstream.ok) {
@@ -4448,20 +4564,43 @@ async function handleResponsesCompactionV2(client, metrics, recordTokens, record
   const isSse = isStreamingResponse(upstream);
   const text = await upstream.text();
   const model = normalizeRequestedModel(json.model);
-  recordResponseTextUsage(text, isSse, model, recordTokens, recordExtraction);
+  recordBufferedUsage(text, isSse, model, usageAccountingMode, recordTokens, recordExtraction);
   if (json.stream === true) {
     return textResponse(responsesCompactionSseText(text, isSse, model), "text/event-stream");
   }
   return jsonResponse(responsesCompactionResponse(text, isSse, model));
 }
-async function responseWithObservedUsage(response, fallbackModel, recordTokens, signal, bufferBody, recordExtraction) {
+async function proxiedResponseWithOptionalUsage(response, fallbackModel, markUsage, usageAccountingMode, recordTokens, recordExtraction, bufferProxyBodies) {
   const isSse = isStreamingResponse(response);
-  if (bufferBody && response.body) {
+  if (bufferProxyBodies && response.body) {
     const text = await response.text();
-    recordResponseTextUsage(text, isSse, fallbackModel, recordTokens, recordExtraction);
-    return responseFromText(response, text);
+    recordBufferedUsage(
+      text,
+      isSse,
+      fallbackModel,
+      usageAccountingMode,
+      recordTokens,
+      recordExtraction
+    );
+    return proxyResponse(responseFromText(response, text));
   }
-  return observeResponseUsage(response, fallbackModel, recordTokens, signal, recordExtraction);
+  return markUsage(proxyResponse(response), fallbackModel, "body");
+}
+function recordParsedUsage(rawUsage, responseModel, fallbackModel, usageAccountingMode, recordTokens, recordExtraction) {
+  if (!shouldExtractUsage(usageAccountingMode, "parsed")) {
+    return;
+  }
+  const usage = extractTokenUsage(rawUsage);
+  if (usage) {
+    recordTokens(responseModel || fallbackModel, usage);
+  }
+  recordExtraction(usage !== void 0);
+}
+function recordBufferedUsage(text, isSse, fallbackModel, usageAccountingMode, recordTokens, recordExtraction) {
+  if (!shouldExtractUsage(usageAccountingMode, "buffered")) {
+    return;
+  }
+  recordResponseTextUsage(text, isSse, fallbackModel, recordTokens, recordExtraction);
 }
 async function proxyError(upstream, logger) {
   const text = await upstream.text();
@@ -4517,7 +4656,24 @@ function shouldBufferProxyBodies(mode) {
   }
   return process.platform === "win32" && IS_STANDALONE_BINARY;
 }
+function resolveUsageAccountingMode(options) {
+  const value = options.usageAccountingMode ?? envValue(options.env?.HOOPILOT_USAGE_ACCOUNTING) ?? "basic";
+  return parseUsageAccountingMode(value);
+}
+function resolveAccessLog(options) {
+  return options.accessLog ?? parseBooleanEnv(options.env?.HOOPILOT_ACCESS_LOG, "HOOPILOT_ACCESS_LOG") ?? false;
+}
+function shouldExtractUsage(mode, cost) {
+  if (mode === "off") {
+    return false;
+  }
+  if (mode === "basic") {
+    return cost === "parsed";
+  }
+  return true;
+}
 function finishResponse(response, options) {
+  const usageObservation = options.usageObservation;
   const withRequestId = responseWithRequestId(
     response,
     options.requestId,
@@ -4526,11 +4682,36 @@ function finishResponse(response, options) {
   );
   const stream = isStreamingResponse(withRequestId);
   const status = withRequestId.status;
+  let completed = false;
   const complete = () => {
+    if (completed) {
+      return;
+    }
+    completed = true;
     const durationMs = Math.round((performance.now() - options.startedAt) * 100) / 100;
     options.metrics.observe({ durationMs, method: options.method, route: options.route, status });
-    logRequestCompleted(options.logger, status, stream, durationMs);
+    logRequestCompleted(options.logger, status, stream, durationMs, options.accessLog);
   };
+  if (withRequestId.body && usageObservation) {
+    const shouldTrackCompletion = stream && options.trackStreamingBody;
+    const observedBody = streamWithUsageObservation(
+      withRequestId.body,
+      stream,
+      usageObservation.fallbackModel,
+      usageObservation.recordTokens,
+      options.signal,
+      usageObservation.recordExtraction,
+      shouldTrackCompletion ? complete : void 0
+    );
+    if (!shouldTrackCompletion) {
+      complete();
+    }
+    return new Response(observedBody, {
+      headers: withRequestId.headers,
+      status,
+      statusText: withRequestId.statusText
+    });
+  }
   if (stream && withRequestId.body && options.trackStreamingBody) {
     return new Response(trackStreamCompletion(withRequestId.body, complete), {
       headers: withRequestId.headers,
@@ -4600,7 +4781,7 @@ function trackStreamCompletion(body, onComplete) {
     }
   });
 }
-function logRequestCompleted(logger, status, stream, durationMs) {
+function logRequestCompleted(logger, status, stream, durationMs, accessLog) {
   const fields = {
     durationMs,
     event: "http.request.completed",
@@ -4615,6 +4796,9 @@ function logRequestCompleted(logger, status, stream, durationMs) {
     logger.warn(fields, "request completed with client error");
     return;
   }
+  if (!accessLog) {
+    return;
+  }
   logger.info(fields, "request completed");
 }
 function requestIdFor(request) {
@@ -4659,11 +4843,17 @@ var API_ROUTES = [
   { method: "POST", path: "/v1/responses/compact", name: "responses_compact" },
   { method: "POST", path: "/v1/responses", name: "responses" }
 ];
+var ROUTE_NAMES = new Map(
+  API_ROUTES.map((entry) => [routeKey(entry.method, entry.path), entry.name])
+);
 function routeFor(method, path) {
   if (method === "OPTIONS") {
     return "cors.preflight";
   }
-  return API_ROUTES.find((entry) => entry.method === method && entry.path === path)?.name ?? "not_found";
+  return ROUTE_NAMES.get(routeKey(method, path)) ?? "not_found";
+}
+function routeKey(method, path) {
+  return `${method} ${path}`;
 }
 function isStreamingResponse(response) {
   return response.headers.get("content-type")?.includes("text/event-stream") ?? false;
@@ -4702,7 +4892,7 @@ function dashboardResponse() {
 }
 async function handleUsage(metrics, readUsage, request) {
   const view = new URL(request.url).searchParams.get("view");
-  const { copilot, error } = await readUsage(request.signal);
+  const { copilot, error } = await readUsage();
   const proxy = view === DASHBOARD_USAGE_VIEW ? metrics.snapshot({
     excludeRoutes: DASHBOARD_EXCLUDED_ROUTES,
     excludeUpstreamPaths: DASHBOARD_EXCLUDED_UPSTREAM_PATHS
@@ -4721,12 +4911,24 @@ async function handleUsage(metrics, readUsage, request) {
 function createUsageReader(client, metrics, now = Date.now, ttlMs = USAGE_CACHE_TTL_MS) {
   const usagePath = "/copilot_internal/user";
   let cache;
-  return async (signal) => {
+  let inFlight;
+  return async () => {
     if (cache && now() - cache.atMs < ttlMs) {
       return cache.result;
     }
+    if (inFlight) {
+      return inFlight;
+    }
+    inFlight = readFreshUsage();
+    try {
+      return await inFlight;
+    } finally {
+      inFlight = void 0;
+    }
+  };
+  async function readFreshUsage() {
     try {
-      const upstream = await client.usage(signal);
+      const upstream = await client.usage();
       metrics.recordUpstream(usagePath, upstream.ok);
       metrics.recordGithubRateLimit(parseRateLimitHeaders(upstream.headers, now()));
       if (!upstream.ok) {
@@ -4748,7 +4950,7 @@ function createUsageReader(client, metrics, now = Date.now, ttlMs = USAGE_CACHE_
       cache = { atMs: now(), result };
       return result;
     }
-  };
+  }
 }
 export {
   COPILOT_USAGE_API_VERSION,