@openhoo/hoopilot 2.1.4 → 2.1.5

package/dist/index.d.ts

@@ -40,11 +40,11 @@ declare class MetricsRegistry {
     renderPrometheus(now?: () => number): string;
 }
 /**
- * Tee `response`'s body so the client receives an unchanged copy while a
- * background reader extracts token usage. Returns a new Response carrying the
- * client-facing branch and the original status/headers. Usage extraction never
- * throws into the client stream: a parse failure or an aborted client simply
- * yields no usage. When the body is absent the response is returned untouched.
+ * Wrap `response`'s body so the client receives unchanged bytes while the same
+ * read pass extracts token usage. Returns a new Response carrying the observed
+ * body and the original status/headers. Usage extraction never throws into the
+ * client stream: a parse failure or an aborted client simply yields no usage.
+ * When the body is absent the response is returned untouched.
  *
  * Pass the request's `signal` so a client disconnect cancels the observer
  * branch; combined with the runtime cancelling the client branch, that releases

package/dist/index.js

@@ -3020,17 +3020,15 @@ function observeResponseUsage(response, fallbackModel, onUsage, signal, onOutcom
   if (!body) {
     return response;
   }
-  const [clientBranch, observerBranch] = body.tee();
   const isSse = response.headers.get("content-type")?.includes("text/event-stream") ?? false;
-  void consumeUsage(observerBranch, isSse, fallbackModel, onUsage, signal, onOutcome).catch(
-    () => {
+  return new Response(
+    streamWithUsageObservation(body, isSse, fallbackModel, onUsage, signal, onOutcome),
+    {
+      headers: response.headers,
+      status: response.status,
+      statusText: response.statusText
     }
   );
-  return new Response(clientBranch, {
-    headers: response.headers,
-    status: response.status,
-    statusText: response.statusText
-  });
 }
 function recordResponseTextUsage(text, isSse, fallbackModel, onUsage, onOutcome) {
   const accumulator = createUsageAccumulator(fallbackModel, onUsage, onOutcome);
@@ -3046,13 +3044,16 @@ function recordResponseTextUsage(text, isSse, fallbackModel, onUsage, onOutcome)
   }
   accumulator.finish();
 }
-async function consumeUsage(stream, isSse, fallbackModel, onUsage, signal, onOutcome) {
+function streamWithUsageObservation(stream, isSse, fallbackModel, onUsage, signal, onOutcome) {
   const reader = stream.getReader();
+  let aborted = signal?.aborted ?? false;
+  let released = false;
   const onAbort = () => {
+    aborted = true;
     reader.cancel().catch(() => {
     });
   };
-  if (signal?.aborted) {
+  if (aborted) {
     reader.cancel().catch(() => {
     });
   } else {
@@ -3060,7 +3061,7 @@ async function consumeUsage(stream, isSse, fallbackModel, onUsage, signal, onOut
   }
   const decoder = new TextDecoder();
   const guardedOutcome = onOutcome ? (extracted) => {
-    if (!signal?.aborted) {
+    if (!aborted) {
       onOutcome(extracted);
     }
   } : void 0;
@@ -3068,33 +3069,40 @@ async function consumeUsage(stream, isSse, fallbackModel, onUsage, signal, onOut
   let buffer = "";
   let bufferedBytes = 0;
   let overflowed = false;
-  try {
-    while (true) {
-      const result = await reader.read();
-      if (result.done) {
-        break;
+  const release = () => {
+    if (released) {
+      return;
+    }
+    released = true;
+    signal?.removeEventListener("abort", onAbort);
+    reader.releaseLock();
+  };
+  const observeChunk = (chunkBytes) => {
+    const chunk = decoder.decode(chunkBytes, { stream: true });
+    if (isSse) {
+      buffer += chunk;
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        considerSseLine(line, accumulator.consider);
       }
-      const chunk = decoder.decode(result.value, { stream: true });
-      if (isSse) {
-        buffer += chunk;
-        const lines = buffer.split(/\r?\n/);
-        buffer = lines.pop() ?? "";
-        for (const line of lines) {
-          considerSseLine(line, accumulator.consider);
-        }
-        if (buffer.length > USAGE_BUFFER_LIMIT_BYTES) {
-          buffer = "";
-        }
-      } else if (!overflowed) {
-        bufferedBytes += result.value.byteLength;
-        if (bufferedBytes > USAGE_BUFFER_LIMIT_BYTES) {
-          overflowed = true;
-          buffer = "";
-        } else {
-          buffer += chunk;
-        }
+      if (buffer.length > USAGE_BUFFER_LIMIT_BYTES) {
+        buffer = "";
       }
+      return;
+    }
+    if (overflowed) {
+      return;
     }
+    bufferedBytes += chunkBytes.byteLength;
+    if (bufferedBytes > USAGE_BUFFER_LIMIT_BYTES) {
+      overflowed = true;
+      buffer = "";
+      return;
+    }
+    buffer += chunk;
+  };
+  const finishObservation = () => {
     const finalBuffer = buffer + decoder.decode();
     if (isSse) {
       if (finalBuffer) {
@@ -3106,11 +3114,41 @@ async function consumeUsage(stream, isSse, fallbackModel, onUsage, signal, onOut
         accumulator.consider(parsed);
       }
     }
-  } finally {
-    signal?.removeEventListener("abort", onAbort);
-    reader.releaseLock();
-  }
-  accumulator.finish();
+    if (!aborted) {
+      safeFinishAccumulator(accumulator);
+    }
+  };
+  return new ReadableStream({
+    async pull(controller) {
+      const result = await reader.read().catch((error) => {
+        release();
+        controller.error(error);
+        return void 0;
+      });
+      if (!result) {
+        return;
+      }
+      if (result.done) {
+        finishObservation();
+        controller.close();
+        release();
+        return;
+      }
+      try {
+        observeChunk(result.value);
+      } catch {
+      }
+      controller.enqueue(result.value);
+    },
+    async cancel(reason) {
+      aborted = true;
+      try {
+        await reader.cancel(reason);
+      } finally {
+        release();
+      }
+    }
+  });
 }
 function createUsageAccumulator(fallbackModel, onUsage, onOutcome) {
   let model = fallbackModel;
@@ -3135,6 +3173,12 @@ function createUsageAccumulator(fallbackModel, onUsage, onOutcome) {
     }
   };
 }
+function safeFinishAccumulator(accumulator) {
+  try {
+    accumulator.finish();
+  } catch {
+  }
+}
 function considerSseLine(line, consider) {
   const trimmed = line.trim();
   if (!trimmed.startsWith("data:")) {
@@ -4065,7 +4109,18 @@ async function getVersion() {
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 4141;
 var FORBIDDEN_BROWSER_ORIGIN_MESSAGE = "Cross-origin browser requests are blocked unless the Origin is loopback or listed in HOOPILOT_ALLOWED_ORIGINS.";
-var WELL_KNOWN_DEMO_API_KEYS = /* @__PURE__ */ new Set(["local-key"]);
+var MIN_NON_LOOPBACK_API_KEY_LENGTH = 24;
+var WELL_KNOWN_DEMO_API_KEYS = /* @__PURE__ */ new Set([
+  "changeme",
+  "demo",
+  "example",
+  "hoopilot",
+  "local-key",
+  "password",
+  "password123",
+  "secret",
+  "test"
+]);
 var INVALID_JSON_MESSAGE = "Request body must be valid JSON.";
 var JSON_OBJECT_MESSAGE = "Request body must be a JSON object.";
 var MAX_REQUEST_BODY_BYTES = 16 * 1024 * 1024;
@@ -4343,10 +4398,9 @@ function startHoopilotServer(options = {}) {
         "Refusing to listen on a non-loopback host without HOOPILOT_API_KEY. Set an API key or pass --allow-unauthenticated."
       );
     }
-    if (apiKey && isWellKnownDemoApiKey(apiKey)) {
-      throw new Error(
-        "Refusing to listen on a non-loopback host with a well-known demo HOOPILOT_API_KEY. Set a strong, unique API key."
-      );
+    const rejection = apiKey ? apiKeyRejectionReason(apiKey) : void 0;
+    if (rejection) {
+      throw new Error(`Refusing to listen on a non-loopback host: ${rejection}`);
     }
   }
   const server = Bun.serve({
@@ -4644,12 +4698,16 @@ async function readRequestText(request) {
   const reader = body.getReader();
   const decoder = new TextDecoder();
   let bytes = 0;
-  let text = "";
+  const chunks = [];
   try {
     while (true) {
       const { done, value } = await reader.read();
       if (done) {
-        return `${text}${decoder.decode()}`;
+        const tail = decoder.decode();
+        if (tail) {
+          chunks.push(tail);
+        }
+        return chunks.join("");
       }
       bytes += value.byteLength;
       if (bytes > MAX_REQUEST_BODY_BYTES) {
@@ -4657,7 +4715,7 @@ async function readRequestText(request) {
         });
         throw new RequestBodyTooLargeError();
       }
-      text += decoder.decode(value, { stream: true });
+      chunks.push(decoder.decode(value, { stream: true }));
     }
   } finally {
     reader.releaseLock();
@@ -4754,8 +4812,18 @@ function resolveCorsAllowOrigin(origin, allowedOrigins) {
   }
   return isAllowedOrigin(origin, allowedOrigins) ? origin : void 0;
 }
-function isWellKnownDemoApiKey(apiKey) {
-  return WELL_KNOWN_DEMO_API_KEYS.has(apiKey.trim().toLowerCase());
+function apiKeyRejectionReason(apiKey) {
+  const normalized = apiKey.trim();
+  if (WELL_KNOWN_DEMO_API_KEYS.has(normalized.toLowerCase())) {
+    return "HOOPILOT_API_KEY is a well-known demo value. Set a strong, unique API key.";
+  }
+  if (normalized.length < MIN_NON_LOOPBACK_API_KEY_LENGTH) {
+    return `HOOPILOT_API_KEY must be at least ${MIN_NON_LOOPBACK_API_KEY_LENGTH} characters when listening on a non-loopback host.`;
+  }
+  if (/^(.)\1+$/.test(normalized)) {
+    return "HOOPILOT_API_KEY must not be a repeated single character. Set a strong, unique API key.";
+  }
+  return void 0;
 }
 function isUpstreamAuthStatus(status) {
   return status === 401 || status === 403;