@openhoo/hoopilot 0.7.1 → 0.7.3

package/dist/index.cjs

@@ -45,6 +45,7 @@ __export(index_exports, {
   authStorePath: () => authStorePath,
   chatCompletionToCompletion: () => chatCompletionToCompletion,
   chatCompletionToResponse: () => chatCompletionToResponse,
+  completionStreamFromChatStream: () => completionStreamFromChatStream,
   completionsRequestToChatCompletion: () => completionsRequestToChatCompletion,
   createHoopilotHandler: () => createHoopilotHandler,
   createHoopilotLogger: () => createHoopilotLogger,
@@ -70,33 +71,117 @@ module.exports = __toCommonJS(index_exports);
 // src/auth-store.ts
 var import_node_fs = require("fs");
 var import_node_path = require("path");
+
+// src/util.ts
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function envValue(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function isTrustedTokenBaseUrl(rawUrl, allowedHttpsHosts, allowUnsafeHttps = false) {
+  const url = parseUrl(rawUrl);
+  if (!url) {
+    return false;
+  }
+  if (url.username || url.password || url.search || url.hash) {
+    return false;
+  }
+  if (url.pathname !== "" && url.pathname !== "/") {
+    return false;
+  }
+  if (isLoopbackHttpUrl(url)) {
+    return true;
+  }
+  if (url.protocol !== "https:") {
+    return false;
+  }
+  const host = url.hostname.toLowerCase();
+  return allowedHttpsHosts.includes(host) || allowUnsafeHttps;
+}
+function parseUrl(rawUrl) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    return void 0;
+  }
+  return url;
+}
+function isLoopbackHttpUrl(url) {
+  return url.protocol === "http:" && (url.hostname === "127.0.0.1" || url.hostname === "localhost" || url.hostname === "::1" || url.hostname === "[::1]");
+}
+async function truncatedResponseText(response, max = 500) {
+  const text = await response.text();
+  return text.slice(0, max);
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
+// src/auth-store.ts
+var StoredCopilotAuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StoredCopilotAuthError";
+  }
+};
 function authStorePath(env = process.env) {
-  if (env.HOOPILOT_AUTH_FILE) {
-    return env.HOOPILOT_AUTH_FILE;
+  const explicit = envValue(env.HOOPILOT_AUTH_FILE);
+  if (explicit) {
+    return explicit;
+  }
+  const xdg = envValue(env.XDG_CONFIG_HOME);
+  if (xdg) {
+    return (0, import_node_path.join)(xdg, "hoopilot", "auth.json");
+  }
+  const appdata = envValue(env.APPDATA);
+  if (appdata) {
+    return (0, import_node_path.join)(appdata, "hoopilot", "auth.json");
+  }
+  const home = envValue(env.HOME);
+  if (!home) {
+    throw new StoredCopilotAuthError(
+      "Cannot resolve Hoopilot auth file path without HOOPILOT_AUTH_FILE, XDG_CONFIG_HOME, APPDATA, or HOME."
+    );
   }
-  const base = env.XDG_CONFIG_HOME ?? env.APPDATA ?? (env.HOME ? (0, import_node_path.join)(env.HOME, ".config") : (0, import_node_path.join)(process.cwd(), ".config"));
+  const base = (0, import_node_path.join)(home, ".config");
   return (0, import_node_path.join)(base, "hoopilot", "auth.json");
 }
 function readStoredCopilotAuth(path = authStorePath()) {
+  let text;
   try {
-    const parsed = JSON.parse((0, import_node_fs.readFileSync)(path, "utf8"));
-    if (!parsed || typeof parsed !== "object") {
+    text = (0, import_node_fs.readFileSync)(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
       return void 0;
     }
-    const token = typeof parsed.token === "string" ? parsed.token.trim() : "";
-    if (!token) {
-      return void 0;
-    }
-    return {
-      apiBaseUrl: typeof parsed.apiBaseUrl === "string" ? parsed.apiBaseUrl : void 0,
-      createdAt: typeof parsed.createdAt === "string" ? parsed.createdAt : void 0,
-      githubDomain: typeof parsed.githubDomain === "string" ? parsed.githubDomain : void 0,
-      source: typeof parsed.source === "string" ? parsed.source : void 0,
-      token
-    };
+    throw new StoredCopilotAuthError(`Could not read Hoopilot auth file at ${path}.`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
   } catch {
-    return void 0;
+    throw new StoredCopilotAuthError(
+      `Hoopilot auth file at ${path} is not valid JSON. Run \`hoopilot login\` to replace it.`
+    );
+  }
+  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 token = typeof record.token === "string" ? record.token.trim() : "";
+  if (!token) {
+    throw new StoredCopilotAuthError(`Hoopilot auth file at ${path} does not contain a token.`);
+  }
+  return {
+    apiBaseUrl: typeof record.apiBaseUrl === "string" ? record.apiBaseUrl : void 0,
+    createdAt: typeof record.createdAt === "string" ? record.createdAt : void 0,
+    githubDomain: typeof record.githubDomain === "string" ? record.githubDomain : void 0,
+    source: typeof record.source === "string" ? record.source : void 0,
+    token
+  };
 }
 function writeStoredCopilotAuth(auth, path = authStorePath()) {
   (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(path), { recursive: true });
@@ -118,18 +203,6 @@ function writeStoredCopilotAuth(auth, path = authStorePath()) {
   }
 }
 
-// src/util.ts
-function trimTrailingSlash(value) {
-  return value.replace(/\/+$/, "");
-}
-async function truncatedResponseText(response, max = 500) {
-  const text = await response.text();
-  return text.slice(0, max);
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-
 // src/auth.ts
 var DEFAULT_COPILOT_API_BASE_URL = "https://api.githubcopilot.com";
 var REFRESH_SKEW_MS = 6e4;
@@ -143,21 +216,35 @@ var CopilotAuthError = class extends Error {
 var CopilotAuth = class {
   #authStorePath;
   #copilotApiBaseUrl;
+  #hasCopilotApiBaseUrlOverride;
   #cachedAccess;
   constructor(options = {}) {
-    this.#authStorePath = options.authStorePath ?? options.env?.HOOPILOT_AUTH_FILE;
+    const envAuthStorePath = envValue(options.env?.HOOPILOT_AUTH_FILE);
+    const envCopilotApiBaseUrl = envValue(options.env?.COPILOT_API_BASE_URL);
+    this.#authStorePath = options.authStorePath ?? envAuthStorePath;
+    this.#hasCopilotApiBaseUrlOverride = Boolean(options.copilotApiBaseUrl ?? envCopilotApiBaseUrl);
     this.#copilotApiBaseUrl = trimTrailingSlash(
-      options.copilotApiBaseUrl ?? options.env?.COPILOT_API_BASE_URL ?? DEFAULT_COPILOT_API_BASE_URL
+      options.copilotApiBaseUrl ?? envCopilotApiBaseUrl ?? DEFAULT_COPILOT_API_BASE_URL
     );
   }
   async getAccess() {
     if (this.#cachedAccess && this.#cachedAccess.expiresAtMs - REFRESH_SKEW_MS > Date.now()) {
       return this.#cachedAccess;
     }
-    const stored = readStoredCopilotAuth(this.#authStorePath);
+    let stored;
+    try {
+      stored = readStoredCopilotAuth(this.#authStorePath);
+    } catch (error) {
+      if (error instanceof StoredCopilotAuthError) {
+        throw new CopilotAuthError(error.message);
+      }
+      throw error;
+    }
     if (stored) {
       return this.#cacheAccess({
-        apiBaseUrl: trimTrailingSlash(stored.apiBaseUrl ?? this.#copilotApiBaseUrl),
+        apiBaseUrl: trimTrailingSlash(
+          this.#hasCopilotApiBaseUrlOverride ? this.#copilotApiBaseUrl : stored.apiBaseUrl ?? this.#copilotApiBaseUrl
+        ),
         expiresAtMs: Date.now() + STORED_TOKEN_TTL_MS,
         source: "github-copilot-oauth",
         token: stored.token
@@ -175,6 +262,8 @@ var CopilotAuth = class {
 
 // src/copilot.ts
 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";
 function applyCopilotHeaders(headers, token) {
   headers.set("accept", headers.get("accept") ?? "application/json");
@@ -198,13 +287,15 @@ function applyGithubApiHeaders(headers, token) {
 }
 var CopilotClient = class {
   #auth;
+  #allowUnsafeUpstream;
   #fetch;
   #githubApiBaseUrl;
   constructor(options = {}) {
     this.#auth = new CopilotAuth(options);
+    this.#allowUnsafeUpstream = envValue(options.env?.HOOPILOT_ALLOW_UNSAFE_UPSTREAM) === "1";
     this.#fetch = options.fetch ?? fetch;
     this.#githubApiBaseUrl = trimTrailingSlash(
-      options.githubApiBaseUrl ?? options.env?.HOOPILOT_GITHUB_API_BASE_URL ?? DEFAULT_GITHUB_API_BASE_URL
+      options.githubApiBaseUrl ?? envValue(options.env?.HOOPILOT_GITHUB_API_BASE_URL) ?? DEFAULT_GITHUB_API_BASE_URL
     );
   }
   /**
@@ -213,9 +304,13 @@ var CopilotClient = class {
    * accepted directly here — no Copilot token exchange is required to read quota.
    */
   async usage(signal) {
-    if (!isHttpsOrLoopback(this.#githubApiBaseUrl)) {
+    if (!isTrustedTokenBaseUrl(
+      this.#githubApiBaseUrl,
+      ALLOWED_GITHUB_API_HOSTS,
+      this.#allowUnsafeUpstream
+    )) {
       throw new Error(
-        `Refusing to send the GitHub OAuth token to a non-HTTPS host: ${this.#githubApiBaseUrl}`
+        `Refusing to send the GitHub OAuth token to an untrusted GitHub API host: ${this.#githubApiBaseUrl}`
       );
     }
     const access = await this.#auth.getAccess();
@@ -257,6 +352,15 @@ var CopilotClient = class {
   }
   async fetchCopilot(path, init) {
     const access = await this.#auth.getAccess();
+    if (!isTrustedTokenBaseUrl(
+      access.apiBaseUrl,
+      ALLOWED_COPILOT_API_HOSTS,
+      this.#allowUnsafeUpstream
+    )) {
+      throw new Error(
+        `Refusing to send the GitHub OAuth token to an untrusted Copilot API host: ${access.apiBaseUrl}`
+      );
+    }
     const headers = applyCopilotHeaders(new Headers(init.headers), access.token);
     return this.#fetch(`${access.apiBaseUrl}${path}`, {
       ...init,
@@ -312,18 +416,6 @@ function usedFrom(entitlement, remaining) {
   }
   return Math.max(0, entitlement - remaining);
 }
-function isHttpsOrLoopback(rawUrl) {
-  let url;
-  try {
-    url = new URL(rawUrl);
-  } catch {
-    return false;
-  }
-  if (url.protocol === "https:") {
-    return true;
-  }
-  return url.protocol === "http:" && (url.hostname === "127.0.0.1" || url.hostname === "localhost" || url.hostname === "::1");
-}
 function numberOrUndefined(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
@@ -352,9 +444,9 @@ async function githubCopilotDeviceLogin(options = {}) {
   const fetcher = options.fetch ?? fetch;
   const sleeper = options.sleep ?? import_promises.setTimeout;
   const domain = normalizeDomain(
-    options.domain ?? env.HOOPILOT_GITHUB_DOMAIN ?? DEFAULT_GITHUB_DOMAIN
+    options.domain ?? envValue(env.HOOPILOT_GITHUB_DOMAIN) ?? DEFAULT_GITHUB_DOMAIN
   );
-  const clientId = options.clientId ?? env.HOOPILOT_GITHUB_CLIENT_ID ?? env.COPILOT_GITHUB_CLIENT_ID ?? DEFAULT_GITHUB_COPILOT_CLIENT_ID;
+  const clientId = options.clientId ?? envValue(env.HOOPILOT_GITHUB_CLIENT_ID) ?? envValue(env.COPILOT_GITHUB_CLIENT_ID) ?? DEFAULT_GITHUB_COPILOT_CLIENT_ID;
   const device = await requestDeviceCode(fetcher, domain, clientId);
   const verificationUrl = device.verification_uri;
   const userCode = device.user_code;
@@ -512,8 +604,8 @@ var noopLogger = {
 };
 function createHoopilotLogger(options = {}) {
   const env = options.env ?? process.env;
-  const level = parseLogLevel(options.level ?? env.HOOPILOT_LOG_LEVEL);
-  const format = parseLogFormat(options.format ?? env.HOOPILOT_LOG_FORMAT);
+  const level = parseLogLevel(options.level ?? envValue(env.HOOPILOT_LOG_LEVEL));
+  const format = parseLogFormat(options.format ?? envValue(env.HOOPILOT_LOG_FORMAT));
   const pinoOptions = {
     base: {
       service: "hoopilot",
@@ -563,7 +655,7 @@ function parseLogLevel(value) {
 }
 function shouldCreateLogger(options) {
   return Boolean(
-    options.logger || options.logFormat || options.logLevel || options.env?.HOOPILOT_LOG_FORMAT || options.env?.HOOPILOT_LOG_LEVEL
+    options.logger || options.logFormat || options.logLevel || envValue(options.env?.HOOPILOT_LOG_FORMAT) || envValue(options.env?.HOOPILOT_LOG_LEVEL)
   );
 }
 function errorDetails(error) {
@@ -678,6 +770,51 @@ function chatCompletionToCompletion(completion) {
     usage: completion.usage
   });
 }
+function completionStreamFromChatStream(chatStream) {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let sawTerminalEvent = false;
+  return new ReadableStream({
+    async start(controller) {
+      const enqueue = (data) => {
+        controller.enqueue(encoder.encode(encodeDataSse(data)));
+      };
+      const markTerminal = () => {
+        sawTerminalEvent = true;
+      };
+      const reader = chatStream.getReader();
+      try {
+        while (true) {
+          const result = await reader.read();
+          if (result.done) {
+            break;
+          }
+          buffer += decoder.decode(result.value, { stream: true });
+          const blocks = buffer.split(/\r?\n\r?\n/);
+          buffer = blocks.pop() ?? "";
+          for (const block of blocks) {
+            processCompletionSseBlock(block, enqueue, markTerminal);
+          }
+        }
+        const tail = `${buffer}${decoder.decode()}`;
+        if (tail.trim()) {
+          processCompletionSseBlock(tail, enqueue, markTerminal);
+        }
+        if (!sawTerminalEvent) {
+          enqueue("[DONE]");
+        }
+        controller.close();
+      } catch (error) {
+        await reader.cancel(error).catch(() => {
+        });
+        controller.error(error);
+      } finally {
+        reader.releaseLock();
+      }
+    }
+  });
+}
 function normalizeModelsResponse(upstream) {
   const record = asRecord(upstream);
   const data = Array.isArray(record.data) ? record.data : Array.isArray(upstream) ? upstream : [];
@@ -710,38 +847,99 @@ function responsesStreamFromChatStream(chatStream, options) {
   const createdAt = epochSeconds();
   let buffer = "";
   let text = "";
+  let messageOutputIndex;
+  let nextOutputIndex = 0;
+  let sequenceNumber = 0;
   const tools = /* @__PURE__ */ new Map();
   return new ReadableStream({
     async start(controller) {
       const enqueue = (event, data) => {
-        controller.enqueue(encoder.encode(encodeSse(event, data)));
+        controller.enqueue(
+          encoder.encode(
+            encodeSse(
+              event,
+              data === "[DONE]" ? data : { ...data, sequence_number: sequenceNumber++ }
+            )
+          )
+        );
       };
       enqueue("response.created", {
         response: baseStreamResponse(responseId, options.model, createdAt, "in_progress", []),
         type: "response.created"
       });
-      enqueue("response.output_item.added", {
-        item: {
-          content: [],
-          id: messageId,
-          role: "assistant",
-          status: "in_progress",
-          type: "message"
-        },
-        output_index: 0,
-        type: "response.output_item.added"
-      });
-      enqueue("response.content_part.added", {
-        content_index: 0,
-        item_id: messageId,
-        output_index: 0,
-        part: {
-          annotations: [],
-          text: "",
-          type: "output_text"
-        },
-        type: "response.content_part.added"
-      });
+      const ensureMessageStarted = () => {
+        if (messageOutputIndex !== void 0) {
+          return;
+        }
+        messageOutputIndex = nextOutputIndex++;
+        enqueue("response.output_item.added", {
+          item: {
+            content: [],
+            id: messageId,
+            role: "assistant",
+            status: "in_progress",
+            type: "message"
+          },
+          output_index: messageOutputIndex,
+          type: "response.output_item.added"
+        });
+        enqueue("response.content_part.added", {
+          content_index: 0,
+          item_id: messageId,
+          output_index: messageOutputIndex,
+          part: {
+            annotations: [],
+            text: "",
+            type: "output_text"
+          },
+          type: "response.content_part.added"
+        });
+      };
+      const appendText = (delta) => {
+        ensureMessageStarted();
+        text += delta;
+        enqueue("response.output_text.delta", {
+          content_index: 0,
+          delta,
+          item_id: messageId,
+          output_index: messageOutputIndex ?? 0,
+          type: "response.output_text.delta"
+        });
+      };
+      const appendToolCall = (toolCall) => {
+        const fn = asRecord(toolCall.function);
+        const index = typeof toolCall.index === "number" ? toolCall.index : tools.size;
+        let existing = tools.get(index);
+        const isNew = !existing;
+        existing ??= {
+          arguments: "",
+          id: contentToText(toolCall.id) || `call_${randomId()}`,
+          index,
+          itemId: `fc_${randomId()}`,
+          name: "",
+          outputIndex: nextOutputIndex++
+        };
+        existing.id = contentToText(toolCall.id) || existing.id;
+        existing.name += contentToText(fn.name);
+        tools.set(index, existing);
+        if (isNew) {
+          enqueue("response.output_item.added", {
+            item: functionCallItem(existing, "in_progress"),
+            output_index: existing.outputIndex ?? 0,
+            type: "response.output_item.added"
+          });
+        }
+        const argumentDelta = contentToText(fn.arguments);
+        if (argumentDelta) {
+          existing.arguments += argumentDelta;
+          enqueue("response.function_call_arguments.delta", {
+            delta: argumentDelta,
+            item_id: existing.itemId,
+            output_index: existing.outputIndex ?? 0,
+            type: "response.function_call_arguments.delta"
+          });
+        }
+      };
       const reader = chatStream.getReader();
       try {
         while (true) {
@@ -753,50 +951,48 @@ function responsesStreamFromChatStream(chatStream, options) {
           const lines = buffer.split(/\r?\n/);
           buffer = lines.pop() ?? "";
           for (const line of lines) {
-            processChatSseLine(messageId, line, enqueue, tools, (delta) => {
-              text += delta;
-            });
+            processChatSseLine(line, { appendText, appendToolCall });
           }
         }
         if (buffer) {
-          processChatSseLine(messageId, buffer, enqueue, tools, (delta) => {
-            text += delta;
-          });
+          processChatSseLine(buffer, { appendText, appendToolCall });
         }
-        const toolItems = [...tools.values()].map(functionCallItem);
-        const output = [messageOutputItem(text, messageId), ...toolItems];
-        enqueue("response.output_text.done", {
-          content_index: 0,
-          item_id: messageId,
-          output_index: 0,
-          text,
-          type: "response.output_text.done"
-        });
-        enqueue("response.content_part.done", {
-          content_index: 0,
-          item_id: messageId,
-          output_index: 0,
-          part: {
-            annotations: [],
+        const outputEntries = [];
+        if (messageOutputIndex !== void 0) {
+          const item = messageOutputItem(text, messageId);
+          outputEntries.push([messageOutputIndex, item]);
+          enqueue("response.output_text.done", {
+            content_index: 0,
+            item_id: messageId,
+            output_index: messageOutputIndex,
             text,
-            type: "output_text"
-          },
-          type: "response.content_part.done"
-        });
-        enqueue("response.output_item.done", {
-          item: output[0],
-          output_index: 0,
-          type: "response.output_item.done"
-        });
-        toolItems.forEach((item, index) => {
-          const outputIndex = index + 1;
-          enqueue("response.output_item.added", {
+            type: "response.output_text.done"
+          });
+          enqueue("response.content_part.done", {
+            content_index: 0,
+            item_id: messageId,
+            output_index: messageOutputIndex,
+            part: {
+              annotations: [],
+              text,
+              type: "output_text"
+            },
+            type: "response.content_part.done"
+          });
+          enqueue("response.output_item.done", {
             item,
-            output_index: outputIndex,
-            type: "response.output_item.added"
+            output_index: messageOutputIndex,
+            type: "response.output_item.done"
           });
+        }
+        for (const tool of [...tools.values()].sort(
+          (a, b) => (a.outputIndex ?? 0) - (b.outputIndex ?? 0)
+        )) {
+          const item = functionCallItem(tool);
+          const outputIndex = tool.outputIndex ?? 0;
+          outputEntries.push([outputIndex, item]);
           enqueue("response.function_call_arguments.done", {
-            arguments: item.arguments,
+            arguments: tool.arguments,
             item_id: item.id,
             output_index: outputIndex,
             type: "response.function_call_arguments.done"
@@ -806,7 +1002,8 @@ function responsesStreamFromChatStream(chatStream, options) {
             output_index: outputIndex,
             type: "response.output_item.done"
           });
-        });
+        }
+        const output = outputEntries.sort(([left], [right]) => left - right).map(([, item]) => item);
         enqueue("response.completed", {
           response: baseStreamResponse(responseId, options.model, createdAt, "completed", output),
           type: "response.completed"
@@ -989,13 +1186,13 @@ function messageOutputItem(text, id = `msg_${randomId()}`) {
     type: "message"
   };
 }
-function functionCallItem(tool) {
+function functionCallItem(tool, status = "completed") {
   return {
     arguments: tool.arguments,
     call_id: tool.id,
-    id: `fc_${randomId()}`,
+    id: tool.itemId ?? `fc_${randomId()}`,
     name: tool.name,
-    status: "completed",
+    status,
     type: "function_call"
   };
 }
@@ -1010,14 +1207,27 @@ function responseUsage(usage) {
   if (Object.keys(record).length === 0) {
     return null;
   }
+  const inputTokens = record.prompt_tokens;
+  const outputTokens = record.completion_tokens;
   return removeUndefined({
-    input_tokens: record.prompt_tokens,
-    input_tokens_details: record.prompt_tokens_details,
-    output_tokens: record.completion_tokens,
-    output_tokens_details: record.completion_tokens_details,
+    input_tokens: inputTokens,
+    input_tokens_details: responseUsageDetails(record.prompt_tokens_details, inputTokens, {
+      cached_tokens: 0
+    }),
+    output_tokens: outputTokens,
+    output_tokens_details: responseUsageDetails(record.completion_tokens_details, outputTokens, {
+      reasoning_tokens: 0
+    }),
     total_tokens: record.total_tokens
   });
 }
+function responseUsageDetails(value, tokenCount, fallback) {
+  const record = asRecord(value);
+  if (Object.keys(record).length > 0) {
+    return record;
+  }
+  return typeof tokenCount === "number" && Number.isFinite(tokenCount) ? fallback : void 0;
+}
 function extractTokenUsage(usage) {
   const record = asRecord(usage);
   const prompt = firstNumber(record.prompt_tokens, record.input_tokens);
@@ -1056,7 +1266,80 @@ function firstChoice(completion) {
   const choices = Array.isArray(completion.choices) ? completion.choices : [];
   return asRecord(choices[0]);
 }
-function processChatSseLine(messageId, line, enqueue, tools, appendText) {
+function processCompletionSseBlock(block, enqueue, markTerminal) {
+  let event = "message";
+  const dataLines = [];
+  for (const line of block.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("event:")) {
+      event = trimmed.slice("event:".length).trim() || event;
+    } else if (trimmed.startsWith("data:")) {
+      dataLines.push(trimmed.slice("data:".length).trim());
+    }
+  }
+  const data = dataLines.join("\n");
+  if (!data) {
+    return;
+  }
+  if (data === "[DONE]") {
+    markTerminal();
+    enqueue("[DONE]");
+    return;
+  }
+  const parsed = parseJson(data);
+  if (!parsed) {
+    return;
+  }
+  const error = completionStreamError(event, parsed);
+  if (error) {
+    markTerminal();
+    enqueue({ error });
+    return;
+  }
+  const choice = firstChoice(parsed);
+  const delta = asRecord(choice.delta);
+  const text = contentToText(delta.content);
+  const finishReason = choice.finish_reason ?? null;
+  const usage = asRecord(parsed.usage);
+  const hasUsage = Object.keys(usage).length > 0;
+  if (!text && finishReason === null && !hasUsage) {
+    return;
+  }
+  enqueue(
+    removeUndefined({
+      choices: text || finishReason !== null ? [
+        {
+          finish_reason: finishReason,
+          index: typeof choice.index === "number" ? choice.index : 0,
+          logprobs: null,
+          text
+        }
+      ] : [],
+      created: typeof parsed.created === "number" ? parsed.created : epochSeconds(),
+      id: contentToText(parsed.id) || `cmpl_${randomId()}`,
+      model: contentToText(parsed.model) || DEFAULT_MODEL,
+      object: "text_completion",
+      usage: hasUsage ? usage : void 0
+    })
+  );
+}
+function completionStreamError(event, parsed) {
+  const responseError = asRecord(asRecord(parsed.response).error);
+  const directError = asRecord(parsed.error);
+  const error = Object.keys(directError).length > 0 ? directError : Object.keys(responseError).length > 0 ? responseError : void 0;
+  if (error) {
+    return error;
+  }
+  if (event === "error" || parsed.type === "response.failed") {
+    return removeUndefined({
+      code: contentToText(parsed.code) || void 0,
+      message: contentToText(parsed.message) || "Upstream streaming request failed.",
+      type: contentToText(parsed.type) || "upstream_stream_error"
+    });
+  }
+  return void 0;
+}
+function processChatSseLine(line, handlers) {
   const trimmed = line.trim();
   if (!trimmed.startsWith("data:")) {
     return;
@@ -1073,30 +1356,11 @@ function processChatSseLine(messageId, line, enqueue, tools, appendText) {
   const delta = asRecord(choice.delta);
   const content = contentToText(delta.content);
   if (content) {
-    appendText(content);
-    enqueue("response.output_text.delta", {
-      content_index: 0,
-      delta: content,
-      item_id: messageId,
-      output_index: 0,
-      type: "response.output_text.delta"
-    });
+    handlers.appendText(content);
   }
   const toolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
   for (const toolCall of toolCalls) {
-    const record = asRecord(toolCall);
-    const fn = asRecord(record.function);
-    const index = typeof record.index === "number" ? record.index : tools.size;
-    const existing = tools.get(index) ?? {
-      arguments: "",
-      id: contentToText(record.id) || `call_${randomId()}`,
-      index,
-      name: ""
-    };
-    existing.id = contentToText(record.id) || existing.id;
-    existing.name += contentToText(fn.name);
-    existing.arguments += contentToText(fn.arguments);
-    tools.set(index, existing);
+    handlers.appendToolCall(asRecord(toolCall));
   }
 }
 function baseStreamResponse(id, model, createdAt, status, output) {
@@ -1126,6 +1390,14 @@ function encodeSse(event, data) {
   return `event: ${event}
 data: ${JSON.stringify(data)}
 
+`;
+}
+function encodeDataSse(data) {
+  if (data === "[DONE]") {
+    return "data: [DONE]\n\n";
+  }
+  return `data: ${JSON.stringify(data)}
+
 `;
 }
 function parseJson(data) {
@@ -1514,11 +1786,21 @@ function formatNumber(value) {
 // src/server.ts
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 4141;
+var FORBIDDEN_BROWSER_ORIGIN_MESSAGE = "Browser-origin requests require HOOPILOT_API_KEY unless the Origin is loopback.";
 var INVALID_JSON_MESSAGE = "Request body must be valid JSON.";
+var MAX_REQUEST_BODY_BYTES = 16 * 1024 * 1024;
+var REQUEST_ID_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
+var REQUEST_TOO_LARGE_MESSAGE = `Request body must be ${MAX_REQUEST_BODY_BYTES} bytes or smaller.`;
 var USAGE_CACHE_TTL_MS = 6e4;
+var RequestBodyTooLargeError = class extends Error {
+  constructor() {
+    super(REQUEST_TOO_LARGE_MESSAGE);
+    this.name = "RequestBodyTooLargeError";
+  }
+};
 function createHoopilotHandler(options = {}) {
   const client = new CopilotClient(options);
-  const apiKey = options.apiKey ?? options.env?.HOOPILOT_API_KEY;
+  const apiKey = options.apiKey ?? envValue(options.env?.HOOPILOT_API_KEY);
   const logger = serverLogger(options);
   const metrics = options.metrics ?? new MetricsRegistry();
   const readUsage = createUsageReader(client, metrics);
@@ -1544,6 +1826,14 @@ function createHoopilotHandler(options = {}) {
       route,
       startedAt
     });
+    const browserOrigin = forbiddenBrowserOrigin(request, apiKey);
+    if (browserOrigin) {
+      requestLogger.warn(
+        { event: "http.request.forbidden_origin", origin: browserOrigin },
+        "blocked unauthenticated browser-origin request"
+      );
+      return finish(jsonError(403, "forbidden_origin", FORBIDDEN_BROWSER_ORIGIN_MESSAGE));
+    }
     if (request.method === "OPTIONS") {
       return finish(new Response(null, { headers: corsHeaders() }));
     }
@@ -1596,6 +1886,12 @@ function createHoopilotHandler(options = {}) {
           "request body was invalid json"
         );
         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" },
@@ -1607,10 +1903,10 @@ function createHoopilotHandler(options = {}) {
   };
 }
 function startHoopilotServer(options = {}) {
-  const host = options.host ?? options.env?.HOST ?? DEFAULT_HOST;
-  const port = Number(options.port ?? options.env?.PORT ?? DEFAULT_PORT);
-  const apiKey = options.apiKey ?? options.env?.HOOPILOT_API_KEY;
-  const allowUnauthenticated = options.allowUnauthenticated ?? options.env?.HOOPILOT_ALLOW_UNAUTHENTICATED === "1";
+  const host = options.host ?? envValue(options.env?.HOST) ?? DEFAULT_HOST;
+  const port = normalizeServerPort(options.port ?? envValue(options.env?.PORT) ?? DEFAULT_PORT);
+  const apiKey = options.apiKey ?? envValue(options.env?.HOOPILOT_API_KEY);
+  const allowUnauthenticated = options.allowUnauthenticated ?? envValue(options.env?.HOOPILOT_ALLOW_UNAUTHENTICATED) === "1";
   if (!isLoopbackHost(host) && !apiKey && !allowUnauthenticated) {
     throw new Error(
       "Refusing to listen on a non-loopback host without HOOPILOT_API_KEY. Set an API key or pass --allow-unauthenticated."
@@ -1628,7 +1924,7 @@ function startHoopilotServer(options = {}) {
   });
   return {
     server,
-    url: `http://${host}:${server.port}`
+    url: `http://${urlHost(host)}:${server.port}`
   };
 }
 async function handleModels(client, metrics, signal, logger) {
@@ -1674,8 +1970,19 @@ async function handleCompletions(client, metrics, recordTokens, request, logger)
   }
   logUpstreamSuccess(logger, "/chat/completions", upstream.status);
   const model = normalizeRequestedModel(body.model);
-  if (isStreamingResponse(upstream)) {
-    return proxyResponse(observeResponseUsage(upstream, model, recordTokens, request.signal));
+  if (isStreamingResponse(upstream) && upstream.body) {
+    return proxyResponse(
+      observeResponseUsage(
+        new Response(completionStreamFromChatStream(upstream.body), {
+          headers: upstream.headers,
+          status: upstream.status,
+          statusText: upstream.statusText
+        }),
+        model,
+        recordTokens,
+        request.signal
+      )
+    );
   }
   const completion = asRecord(await upstream.json());
   const usage = extractTokenUsage(completion.usage);
@@ -1709,7 +2016,7 @@ async function proxyError(upstream, logger) {
     { event: "copilot.request.failed", upstreamStatus: upstream.status },
     "copilot upstream request failed"
   );
-  return jsonError(upstream.status, "copilot_error", text || upstream.statusText);
+  return upstreamErrorResponse(upstream.status, text || upstream.statusText);
 }
 function proxyResponse(upstream) {
   const headers = new Headers(upstream.headers);
@@ -1726,14 +2033,15 @@ function proxyResponse(upstream) {
   });
 }
 async function readJson(request) {
+  const text = await readRequestText(request);
   try {
-    return asRecord(await request.json());
+    return asRecord(JSON.parse(text));
   } catch {
     throw new Error(INVALID_JSON_MESSAGE);
   }
 }
 async function readJsonText(request) {
-  const text = await request.text();
+  const text = await readRequestText(request);
   try {
     JSON.parse(text);
     return text;
@@ -1741,6 +2049,40 @@ async function readJsonText(request) {
     throw new Error(INVALID_JSON_MESSAGE);
   }
 }
+async function readRequestText(request) {
+  const contentLength = request.headers.get("content-length");
+  if (contentLength) {
+    const declaredBytes = Number(contentLength);
+    if (Number.isFinite(declaredBytes) && declaredBytes > MAX_REQUEST_BODY_BYTES) {
+      throw new RequestBodyTooLargeError();
+    }
+  }
+  const body = request.body;
+  if (!body) {
+    return "";
+  }
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let bytes = 0;
+  let text = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        return `${text}${decoder.decode()}`;
+      }
+      bytes += value.byteLength;
+      if (bytes > MAX_REQUEST_BODY_BYTES) {
+        await reader.cancel().catch(() => {
+        });
+        throw new RequestBodyTooLargeError();
+      }
+      text += decoder.decode(value, { stream: true });
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
 function jsonResponse(body, status = 200) {
   return new Response(JSON.stringify(body), {
     headers: {
@@ -1762,6 +2104,13 @@ function jsonError(status, code, message) {
     status
   );
 }
+function upstreamErrorResponse(status, text) {
+  const parsedError = asRecord(asRecord(safeParseJson(text)).error);
+  if (Object.keys(parsedError).length > 0) {
+    return jsonResponse({ error: parsedError }, status);
+  }
+  return jsonError(status, "copilot_error", text);
+}
 function websocketUnsupportedResponse() {
   const response = jsonError(
     426,
@@ -1786,6 +2135,17 @@ function isAuthorized(request, apiKey) {
   const bearer = authorization.match(/^Bearer\s+(.+)$/i)?.[1];
   return bearer === apiKey || request.headers.get("x-api-key") === apiKey;
 }
+function forbiddenBrowserOrigin(request, apiKey) {
+  if (apiKey) {
+    return void 0;
+  }
+  const origin = request.headers.get("origin")?.trim();
+  if (origin) {
+    return isLoopbackOrigin(origin) ? void 0 : origin;
+  }
+  const fetchSite = request.headers.get("sec-fetch-site")?.toLowerCase();
+  return fetchSite === "cross-site" ? "cross-site" : void 0;
+}
 function isUpstreamAuthStatus(status) {
   return status === 401 || status === 403;
 }
@@ -1793,7 +2153,24 @@ 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";
+  return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]";
+}
+function urlHost(host) {
+  return host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+}
+function isLoopbackOrigin(origin) {
+  try {
+    return isLoopbackHost(new URL(origin).hostname.toLowerCase());
+  } catch {
+    return false;
+  }
+}
+function normalizeServerPort(value) {
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 0 || port > 65535) {
+    throw new Error(`Invalid port: ${value}.`);
+  }
+  return port;
 }
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -1888,7 +2265,7 @@ function logRequestCompleted(logger, status, stream, durationMs) {
 }
 function requestIdFor(request) {
   const existing = request.headers.get("x-request-id")?.trim();
-  return existing || crypto.randomUUID();
+  return existing && REQUEST_ID_PATTERN.test(existing) ? existing : crypto.randomUUID();
 }
 function canonicalApiPath(path) {
   const withoutTrailingSlash = path.length > 1 ? path.replace(/\/+$/, "") : path;
@@ -2018,6 +2395,7 @@ function safeParseJson(text) {
   authStorePath,
   chatCompletionToCompletion,
   chatCompletionToResponse,
+  completionStreamFromChatStream,
   completionsRequestToChatCompletion,
   createHoopilotHandler,
   createHoopilotLogger,