@openhoo/hoopilot 0.8.2 → 0.8.4

package/dist/index.cjs

@@ -276,6 +276,25 @@ function completionStreamFromChatStream(chatStream) {
     }
   });
 }
+function completionSseTextFromChatSseText(text) {
+  const chunks = [];
+  let sawTerminalEvent = false;
+  const enqueue = (data) => {
+    chunks.push(encodeDataSse(data));
+  };
+  const markTerminal = () => {
+    sawTerminalEvent = true;
+  };
+  for (const block of text.split(/\r?\n\r?\n/)) {
+    if (block.trim()) {
+      processCompletionSseBlock(block, enqueue, markTerminal);
+    }
+  }
+  if (!sawTerminalEvent) {
+    enqueue("[DONE]");
+  }
+  return chunks.join("");
+}
 function normalizeModelsResponse(upstream) {
   const record = asRecord(upstream);
   const data = Array.isArray(record.data) ? record.data : Array.isArray(upstream) ? upstream : [];
@@ -994,16 +1013,7 @@ function responsesStreamToAnthropicStream(stream, options) {
   const decoder = new TextDecoder();
   const encoder = new TextEncoder();
   let buffer = "";
-  const state = {
-    blocks: /* @__PURE__ */ new Map(),
-    completed: false,
-    messageId: options.messageId ?? `msg_${randomId2()}`,
-    model: options.model,
-    nextBlockIndex: 0,
-    sawToolUse: false,
-    started: false,
-    usage: anthropicUsage(void 0)
-  };
+  const state = createAnthropicStreamState(options);
   return new ReadableStream({
     async start(controller) {
       const enqueue = (event, data) => {
@@ -1039,6 +1049,20 @@ function responsesStreamToAnthropicStream(stream, options) {
     }
   });
 }
+function responsesSseTextToAnthropicSseText(text, options) {
+  const chunks = [];
+  const state = createAnthropicStreamState(options);
+  const enqueue = (event, data) => {
+    chunks.push(encodeSse2(event, data));
+  };
+  for (const block of text.split(/\r?\n\r?\n/)) {
+    if (block.trim()) {
+      processResponsesSseBlock(block, state, enqueue);
+    }
+  }
+  finishAnthropicStream(state, enqueue);
+  return chunks.join("");
+}
 function estimateAnthropicMessageTokens(request) {
   const chars = estimatedTextSize(request.system) + estimatedTextSize(request.messages) + estimatedTextSize(request.tools) + estimatedTextSize(request.tool_choice) + estimatedTextSize(request.thinking);
   const messageCount = Array.isArray(request.messages) ? request.messages.length : 1;
@@ -1049,6 +1073,18 @@ function estimateAnthropicMessageTokens(request) {
     total_tokens: inputTokens
   };
 }
+function createAnthropicStreamState(options) {
+  return {
+    blocks: /* @__PURE__ */ new Map(),
+    completed: false,
+    messageId: options.messageId ?? `msg_${randomId2()}`,
+    model: options.model,
+    nextBlockIndex: 0,
+    sawToolUse: false,
+    started: false,
+    usage: anthropicUsage(void 0)
+  };
+}
 function anthropicMessagesToResponsesInput(messages) {
   if (!Array.isArray(messages)) {
     throw new AnthropicCompatibilityError("Anthropic Messages requests require messages[].");
@@ -2466,6 +2502,20 @@ function observeResponseUsage(response, fallbackModel, onUsage, signal) {
     statusText: response.statusText
   });
 }
+function recordResponseTextUsage(text, isSse, fallbackModel, onUsage) {
+  const accumulator = createUsageAccumulator(fallbackModel, onUsage);
+  if (isSse) {
+    for (const line of text.split(/\r?\n/)) {
+      considerSseLine(line, accumulator.consider);
+    }
+  } else {
+    const parsed = safeParse(text);
+    if (parsed !== void 0) {
+      accumulator.consider(parsed);
+    }
+  }
+  accumulator.finish();
+}
 async function consumeUsage(stream, isSse, fallbackModel, onUsage, signal) {
   const reader = stream.getReader();
   const onAbort = () => {
@@ -2479,22 +2529,10 @@ async function consumeUsage(stream, isSse, fallbackModel, onUsage, signal) {
     signal?.addEventListener("abort", onAbort, { once: true });
   }
   const decoder = new TextDecoder();
-  let model = fallbackModel;
-  let usage;
+  const accumulator = createUsageAccumulator(fallbackModel, onUsage);
   let buffer = "";
   let bufferedBytes = 0;
   let overflowed = false;
-  const consider = (payload) => {
-    const record = asRecord(payload);
-    const found = extractTokenUsage(record.usage) ?? extractTokenUsage(asRecord(record.response).usage);
-    if (found) {
-      usage = found;
-    }
-    const candidateModel = modelText(record.model) || modelText(asRecord(record.response).model);
-    if (candidateModel) {
-      model = candidateModel;
-    }
-  };
   try {
     while (true) {
       const result = await reader.read();
@@ -2507,7 +2545,7 @@ async function consumeUsage(stream, isSse, fallbackModel, onUsage, signal) {
         const lines = buffer.split(/\r?\n/);
         buffer = lines.pop() ?? "";
         for (const line of lines) {
-          considerSseLine(line, consider);
+          considerSseLine(line, accumulator.consider);
         }
         if (buffer.length > USAGE_BUFFER_LIMIT_BYTES) {
           buffer = "";
@@ -2525,21 +2563,41 @@ async function consumeUsage(stream, isSse, fallbackModel, onUsage, signal) {
     const finalBuffer = buffer + decoder.decode();
     if (isSse) {
       if (finalBuffer) {
-        considerSseLine(finalBuffer, consider);
+        considerSseLine(finalBuffer, accumulator.consider);
       }
     } else if (!overflowed && finalBuffer) {
       const parsed = safeParse(finalBuffer);
       if (parsed !== void 0) {
-        consider(parsed);
+        accumulator.consider(parsed);
       }
     }
   } finally {
     signal?.removeEventListener("abort", onAbort);
     reader.releaseLock();
   }
-  if (usage) {
-    onUsage(model, usage);
-  }
+  accumulator.finish();
+}
+function createUsageAccumulator(fallbackModel, onUsage) {
+  let model = fallbackModel;
+  let usage;
+  return {
+    consider(payload) {
+      const record = asRecord(payload);
+      const found = extractTokenUsage(record.usage) ?? extractTokenUsage(asRecord(record.response).usage);
+      if (found) {
+        usage = found;
+      }
+      const candidateModel = modelText(record.model) || modelText(asRecord(record.response).model);
+      if (candidateModel) {
+        model = candidateModel;
+      }
+    },
+    finish() {
+      if (usage) {
+        onUsage(model, usage);
+      }
+    }
+  };
 }
 function considerSseLine(line, consider) {
   const trimmed = line.trim();
@@ -2586,6 +2644,10 @@ function formatNumber(value) {
   return Number.isInteger(value) ? value.toString() : String(value);
 }
 
+// src/version.ts
+var BAKED_VERSION = typeof HOOPILOT_VERSION !== "undefined" ? HOOPILOT_VERSION : void 0;
+var IS_STANDALONE_BINARY = BAKED_VERSION !== void 0;
+
 // src/server.ts
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 4141;
@@ -2609,6 +2671,8 @@ function createHoopilotHandler(options = {}) {
   const metrics = options.metrics ?? new MetricsRegistry();
   const readUsage = createUsageReader(client, metrics);
   const recordTokens = (model, usage) => metrics.recordTokens(model, usage);
+  const streamingProxyMode = resolveStreamingProxyMode(options);
+  const bufferProxyBodies = shouldBufferProxyBodies(streamingProxyMode);
   return async (request) => {
     const startedAt = performance.now();
     const url = new URL(request.url);
@@ -2628,7 +2692,9 @@ function createHoopilotHandler(options = {}) {
       metrics,
       requestId,
       route,
-      startedAt
+      startedAt,
+      closeConnection: bufferProxyBodies,
+      trackStreamingBody: !bufferProxyBodies
     });
     const browserOrigin = forbiddenBrowserOrigin(request, apiKey);
     if (browserOrigin) {
@@ -2663,7 +2729,14 @@ function createHoopilotHandler(options = {}) {
       }
       if (request.method === "POST" && apiPath === "/v1/messages") {
         return finish(
-          await handleAnthropicMessages(client, metrics, recordTokens, request, requestLogger)
+          await handleAnthropicMessages(
+            client,
+            metrics,
+            recordTokens,
+            request,
+            requestLogger,
+            bufferProxyBodies
+          )
         );
       }
       if (request.method === "POST" && apiPath === "/v1/messages/count_tokens") {
@@ -2671,16 +2744,39 @@ function createHoopilotHandler(options = {}) {
       }
       if (request.method === "POST" && apiPath === "/v1/chat/completions") {
         return finish(
-          await handleChatCompletions(client, metrics, recordTokens, request, requestLogger)
+          await handleChatCompletions(
+            client,
+            metrics,
+            recordTokens,
+            request,
+            requestLogger,
+            bufferProxyBodies
+          )
         );
       }
       if (request.method === "POST" && apiPath === "/v1/completions") {
         return finish(
-          await handleCompletions(client, metrics, recordTokens, request, requestLogger)
+          await handleCompletions(
+            client,
+            metrics,
+            recordTokens,
+            request,
+            requestLogger,
+            bufferProxyBodies
+          )
         );
       }
       if (request.method === "POST" && apiPath === "/v1/responses") {
-        return finish(await handleResponses(client, metrics, recordTokens, request, requestLogger));
+        return finish(
+          await handleResponses(
+            client,
+            metrics,
+            recordTokens,
+            request,
+            requestLogger,
+            bufferProxyBodies
+          )
+        );
       }
       return finish(jsonError(404, "not_found", `No route for ${request.method} ${url.pathname}.`));
     } catch (error) {
@@ -2745,7 +2841,7 @@ function startHoopilotServer(options = {}) {
     url: `http://${urlHost(host)}:${server.port}`
   };
 }
-async function handleAnthropicMessages(client, metrics, recordTokens, request, logger) {
+async function handleAnthropicMessages(client, metrics, recordTokens, request, logger, bufferProxyBodies) {
   const anthropicRequest = await readJson(request);
   const responsesRequest = anthropicMessagesToResponsesRequest(anthropicRequest);
   const upstream = await client.responses(JSON.stringify(responsesRequest), request.signal);
@@ -2756,6 +2852,13 @@ async function handleAnthropicMessages(client, metrics, recordTokens, request, l
   logUpstreamSuccess(logger, "/responses", upstream.status);
   const model = normalizeRequestedModel(responsesRequest.model);
   if (isStreamingResponse(upstream) && upstream.body) {
+    if (bufferProxyBodies) {
+      const text = await upstream.text();
+      recordResponseTextUsage(text, true, model, recordTokens);
+      return proxyResponse(
+        responseFromText(upstream, responsesSseTextToAnthropicSseText(text, { model }))
+      );
+    }
     const observed = observeResponseUsage(upstream, model, recordTokens, request.signal);
     if (!observed.body) {
       return proxyResponse(observed);
@@ -2799,7 +2902,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, request, logger) {
+async function handleChatCompletions(client, metrics, recordTokens, request, logger, bufferProxyBodies) {
   const chatRequest = normalizeChatCompletionRequest(await readJson(request));
   const upstream = await client.chatCompletions(chatRequest, request.signal);
   metrics.recordUpstream("/chat/completions", upstream.ok);
@@ -2808,9 +2911,17 @@ async function handleChatCompletions(client, metrics, recordTokens, request, log
   }
   logUpstreamSuccess(logger, "/chat/completions", upstream.status);
   const model = normalizeRequestedModel(chatRequest.model);
-  return proxyResponse(observeResponseUsage(upstream, model, recordTokens, request.signal));
+  return proxyResponse(
+    await responseWithObservedUsage(
+      upstream,
+      model,
+      recordTokens,
+      request.signal,
+      bufferProxyBodies
+    )
+  );
 }
-async function handleCompletions(client, metrics, recordTokens, request, logger) {
+async function handleCompletions(client, metrics, recordTokens, request, logger, bufferProxyBodies) {
   const body = await readJson(request);
   const upstream = await client.chatCompletions(
     completionsRequestToChatCompletion(body),
@@ -2823,6 +2934,12 @@ async function handleCompletions(client, metrics, recordTokens, request, logger)
   logUpstreamSuccess(logger, "/chat/completions", upstream.status);
   const model = normalizeRequestedModel(body.model);
   if (isStreamingResponse(upstream) && upstream.body) {
+    if (bufferProxyBodies) {
+      const upstreamText = await upstream.text();
+      recordResponseTextUsage(upstreamText, true, model, recordTokens);
+      const text = completionSseTextFromChatSseText(upstreamText);
+      return proxyResponse(responseFromText(upstream, text));
+    }
     return proxyResponse(
       observeResponseUsage(
         new Response(completionStreamFromChatStream(upstream.body), {
@@ -2844,7 +2961,7 @@ async function handleCompletions(client, metrics, recordTokens, request, logger)
   }
   return jsonResponse(chatCompletionToCompletion(completion));
 }
-async function handleResponses(client, metrics, recordTokens, request, logger) {
+async function handleResponses(client, metrics, recordTokens, request, logger, bufferProxyBodies) {
   const body = await readJsonText(request);
   const upstream = await client.responses(body, request.signal);
   metrics.recordUpstream("/responses", upstream.ok);
@@ -2853,7 +2970,31 @@ async function handleResponses(client, metrics, recordTokens, request, logger) {
   }
   logUpstreamSuccess(logger, "/responses", upstream.status);
   const model = normalizeRequestedModel(asRecord(safeParseJson(body)).model);
-  return proxyResponse(observeResponseUsage(upstream, model, recordTokens, request.signal));
+  return proxyResponse(
+    await responseWithObservedUsage(
+      upstream,
+      model,
+      recordTokens,
+      request.signal,
+      bufferProxyBodies
+    )
+  );
+}
+async function responseWithObservedUsage(response, fallbackModel, recordTokens, signal, bufferBody) {
+  const isSse = isStreamingResponse(response);
+  if (bufferBody && response.body) {
+    const text = await response.text();
+    recordResponseTextUsage(text, isSse, fallbackModel, recordTokens);
+    return responseFromText(response, text);
+  }
+  return observeResponseUsage(response, fallbackModel, recordTokens, signal);
+}
+function responseFromText(source, text) {
+  return new Response(text, {
+    headers: source.headers,
+    status: source.status,
+    statusText: source.statusText
+  });
 }
 async function proxyError(upstream, logger) {
   const text = await upstream.text();
@@ -3045,8 +3186,24 @@ function serverLogger(options) {
   }
   return noopLogger;
 }
+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.`);
+}
+function shouldBufferProxyBodies(mode) {
+  if (mode === "buffer") {
+    return true;
+  }
+  if (mode === "live") {
+    return false;
+  }
+  return process.platform === "win32" && IS_STANDALONE_BINARY;
+}
 function finishResponse(response, options) {
-  const withRequestId = responseWithRequestId(response, options.requestId);
+  const withRequestId = responseWithRequestId(response, options.requestId, options.closeConnection);
   const stream = isStreamingResponse(withRequestId);
   const status = withRequestId.status;
   const complete = () => {
@@ -3054,7 +3211,7 @@ function finishResponse(response, options) {
     options.metrics.observe({ durationMs, method: options.method, route: options.route, status });
     logRequestCompleted(options.logger, status, stream, durationMs);
   };
-  if (stream && withRequestId.body) {
+  if (stream && withRequestId.body && options.trackStreamingBody) {
     return new Response(trackStreamCompletion(withRequestId.body, complete), {
       headers: withRequestId.headers,
       status,
@@ -3064,9 +3221,12 @@ function finishResponse(response, options) {
   complete();
   return withRequestId;
 }
-function responseWithRequestId(response, requestId) {
+function responseWithRequestId(response, requestId, closeConnection) {
   const headers = new Headers(response.headers);
   headers.set("x-request-id", requestId);
+  if (closeConnection) {
+    headers.set("connection", "close");
+  }
   return new Response(response.body, {
     headers,
     status: response.status,