@openhoo/hoopilot 2.1.7 → 2.1.9

package/dist/cli.js

@@ -9,14 +9,16 @@ import {
   isTrustedTokenBaseUrl,
   main,
   modelIdsFromResponse,
+  parseBooleanEnv,
   parseJsonObject,
   parseStreamingProxyMode,
+  parseUsageAccountingMode,
   randomId,
   removeUndefined,
   safeJsonParse,
   trimTrailingSlash,
   truncatedResponseText
-} from "./chunk-2GLKVNAA.js";
+} from "./chunk-FH6WSFOC.js";
 
 // src/cli.ts
 import { spawn } from "child_process";
@@ -667,6 +669,32 @@ var DEFAULT_LOG_FORMAT = "pretty";
 var DEFAULT_LOG_LEVEL = "info";
 var LOG_FORMATS = ["json", "pretty"];
 var LOG_LEVELS = ["trace", "debug", "info", "warn", "error", "fatal", "silent"];
+var PRETTY_INLINE_FIELDS = [
+  "component",
+  "command",
+  "event",
+  "method",
+  "path",
+  "status",
+  "durationMs",
+  "stream",
+  "route",
+  "requestId",
+  "upstreamPath",
+  "upstreamStatus",
+  "url",
+  "baseUrl",
+  "origin",
+  "currentVersion",
+  "installKind",
+  "latestVersion",
+  "assetName",
+  "count",
+  "plan",
+  "apiBaseUrl",
+  "authStorePath"
+];
+var PRETTY_IGNORED_FIELDS = ["pid", "hostname", "service", ...PRETTY_INLINE_FIELDS];
 var REDACT_PATHS = [
   "apiKey",
   "authorization",
@@ -730,9 +758,11 @@ function createHoopilotLogger(options = {}) {
           // 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",
+          ignore: PRETTY_IGNORED_FIELDS.join(","),
+          levelFirst: true,
+          messageFormat: formatPrettyMessage,
           singleLine: true,
-          translateTime: "SYS:standard"
+          translateTime: "SYS:HH:MM:ss"
         })
       )
     );
@@ -778,6 +808,45 @@ function errorDetails(error) {
   }
   return { message: String(error) };
 }
+function formatPrettyMessage(log, messageKey) {
+  const message = formatPrettyLogMessage(log[messageKey]);
+  const fields = PRETTY_INLINE_FIELDS.flatMap((field) => {
+    const value = log[field];
+    if (value === void 0) {
+      return [];
+    }
+    return `${prettyFieldLabel(field)}=${formatPrettyFieldValue(field, value)}`;
+  });
+  return fields.length > 0 ? `${message} ${fields.join(" ")}` : message;
+}
+function formatPrettyLogMessage(value) {
+  return typeof value === "string" ? value : formatPrettyValue(value);
+}
+function prettyFieldLabel(field) {
+  return field === "durationMs" ? "duration" : field;
+}
+function formatPrettyFieldValue(field, value) {
+  const formatted = formatPrettyValue(value);
+  return field === "durationMs" && typeof value === "number" ? `${formatted}ms` : formatted;
+}
+function formatPrettyValue(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? String(value) : JSON.stringify(value);
+  }
+  if (typeof value === "boolean") {
+    return String(value);
+  }
+  if (typeof value === "string") {
+    return isBarePrettyValue(value) ? value : JSON.stringify(value);
+  }
+  if (value === null) {
+    return "null";
+  }
+  return JSON.stringify(value) ?? String(value);
+}
+function isBarePrettyValue(value) {
+  return /^[A-Za-z0-9._~:/?#[\]@!$&'()*+,;=%-]+$/.test(value);
+}
 function isLogFormat(value) {
   return LOG_FORMATS.includes(value);
 }
@@ -3118,6 +3187,8 @@ function websocketUnsupportedResponse() {
 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;
@@ -3126,6 +3197,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;
@@ -3137,11 +3211,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);
@@ -3149,6 +3228,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;
     }
@@ -3169,6 +3251,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 {
@@ -3177,6 +3260,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;
@@ -3189,11 +3273,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;
   }
   /**
@@ -3205,6 +3291,7 @@ var MetricsRegistry = class {
     if (!rateLimit) {
       return;
     }
+    this.#changed();
     const resource = this.#rateLimitResource(rateLimit.resource);
     this.#githubRateLimit.set(resource, { ...rateLimit, resource });
   }
@@ -3241,6 +3328,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;
@@ -3344,13 +3434,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}`);
@@ -3416,8 +3511,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()];
@@ -3552,21 +3649,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) {
@@ -3581,9 +3663,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;
@@ -3612,6 +3695,10 @@ function streamWithUsageObservation(stream, isSse, fallbackModel, onUsage, signa
     }
     released = true;
     signal?.removeEventListener("abort", onAbort);
+    if (!completed) {
+      completed = true;
+      onComplete?.();
+    }
     reader.releaseLock();
   };
   const observeChunk = (chunkBytes) => {
@@ -3721,6 +3808,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);
@@ -3850,17 +3940,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();
@@ -3896,11 +3997,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
@@ -3913,11 +4017,13 @@ function buildApp(deps) {
     allowedOrigins,
     bufferProxyBodies,
     client,
+    markUsage,
     metrics,
     readUsage,
     recordExtraction,
     recordTokens,
-    requestContext
+    requestContext,
+    usageAccountingMode
   } = deps;
   const contextFor = (request) => {
     const stored = requestContext.get(request);
@@ -4005,11 +4111,13 @@ function buildApp(deps) {
     ({ request }) => handleAnthropicMessages(
       client,
       metrics,
+      markUsage,
       recordTokens,
       recordExtraction,
       request,
       loggerFor(request),
-      bufferProxyBodies
+      bufferProxyBodies,
+      usageAccountingMode
     ),
     noBody
   ).post(
@@ -4021,11 +4129,13 @@ function buildApp(deps) {
     ({ request }) => handleChatCompletions(
       client,
       metrics,
+      markUsage,
       recordTokens,
       recordExtraction,
       request,
       loggerFor(request),
-      bufferProxyBodies
+      bufferProxyBodies,
+      usageAccountingMode
     ),
     noBody
   ).post(
@@ -4033,11 +4143,13 @@ function buildApp(deps) {
     ({ request }) => handleCompletions(
       client,
       metrics,
+      markUsage,
       recordTokens,
       recordExtraction,
       request,
       loggerFor(request),
-      bufferProxyBodies
+      bufferProxyBodies,
+      usageAccountingMode
     ),
     noBody
   ).post(
@@ -4048,7 +4160,8 @@ function buildApp(deps) {
       recordTokens,
       recordExtraction,
       request,
-      loggerFor(request)
+      loggerFor(request),
+      usageAccountingMode
     ),
     noBody
   ).post(
@@ -4056,11 +4169,13 @@ function buildApp(deps) {
     ({ request }) => handleResponses(
       client,
       metrics,
+      markUsage,
       recordTokens,
       recordExtraction,
       request,
       loggerFor(request),
-      bufferProxyBodies
+      bufferProxyBodies,
+      usageAccountingMode
     ),
     noBody
   );
@@ -4113,7 +4228,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);
@@ -4126,36 +4241,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) {
@@ -4182,7 +4293,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);
@@ -4191,18 +4302,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),
@@ -4217,34 +4327,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(
@@ -4254,7 +4371,8 @@ async function handleResponses(client, metrics, recordTokens, recordExtraction,
       recordExtraction,
       json,
       request,
-      logger
+      logger,
+      usageAccountingMode
     );
   }
   const upstream = await client.responses(
@@ -4267,18 +4385,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);
@@ -4288,16 +4405,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) {
@@ -4307,20 +4425,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 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;
   }
-  return observeResponseUsage(response, fallbackModel, recordTokens, signal, recordExtraction);
+  recordResponseTextUsage(text, isSse, fallbackModel, recordTokens, recordExtraction);
 }
 async function proxyError(upstream, logger) {
   const text = await upstream.text();
@@ -4376,7 +4517,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,
@@ -4385,11 +4543,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,
@@ -4459,7 +4642,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",
@@ -4474,6 +4657,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) {
@@ -4518,11 +4704,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;
@@ -4580,12 +4772,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) {
@@ -4607,7 +4811,7 @@ function createUsageReader(client, metrics, now = Date.now, ttlMs = USAGE_CACHE_
       cache = { atMs: now(), result };
       return result;
     }
-  };
+  }
 }
 
 // src/update.ts
@@ -5279,6 +5483,14 @@ function parseArgs(argv) {
       args.allowUnauthenticated = true;
       continue;
     }
+    if (arg === "--access-log") {
+      args.accessLog = true;
+      continue;
+    }
+    if (arg === "--no-access-log") {
+      args.accessLog = false;
+      continue;
+    }
     if (arg === "--no-update-check") {
       args.noUpdateCheck = true;
       continue;
@@ -5313,6 +5525,9 @@ function parseArgs(argv) {
       case "--stream-mode":
         args.streamingProxyMode = parseStreamingProxyMode(optionValue(name, inlineValue, rest));
         break;
+      case "--usage-accounting":
+        args.usageAccountingMode = parseUsageAccountingMode(optionValue(name, inlineValue, rest));
+        break;
       case "--host":
         args.host = optionValue(name, inlineValue, rest);
         break;
@@ -5617,6 +5832,9 @@ Options:
       --log-level <level>           trace, debug, info, warn, error, fatal, or silent
       --log-format <format>         json or pretty. Default: pretty
       --stream-mode <mode>          auto, live, or buffer. Auto buffers Windows standalone streams.
+      --usage-accounting <mode>     basic, full, or off. Default: basic
+      --access-log                  Log successful requests
+      --no-access-log               Do not log successful requests. Default
       --no-update-check             Do not check GitHub for a newer release
       --allow-unauthenticated       Allow non-loopback bind without --api-key
   -h, --help                        Show help
@@ -5630,6 +5848,8 @@ Environment:
   HOOPILOT_LOG_FORMAT               json or pretty. Default: pretty
   HOOPILOT_LOG_LEVEL                trace, debug, info, warn, error, fatal, or silent
   HOOPILOT_STREAM_MODE              auto, live, or buffer
+  HOOPILOT_USAGE_ACCOUNTING         basic, full, or off
+  HOOPILOT_ACCESS_LOG               1/0, true/false, yes/no, or on/off
   COPILOT_API_BASE_URL
   HOOPILOT_GITHUB_API_BASE_URL      GitHub REST base for the usage/quota lookup. Default: https://api.github.com
   HOOPILOT_ALLOW_UNSAFE_UPSTREAM    Set to 1 to allow nonstandard HTTPS token hosts