@openhoo/hoopilot 2.1.3 → 2.1.4

package/dist/codexx.js

@@ -3,7 +3,7 @@ import {
   buildCodexxInvocation,
   main,
   verifyCodexxModel
-} from "./chunk-CYR6I4C3.js";
+} from "./chunk-4ZG5QEYJ.js";
 export {
   buildCodexxInvocation,
   main,

package/dist/index.d.ts

@@ -93,6 +93,8 @@ interface CopilotAuthOptions {
     env?: NodeJS.ProcessEnv;
     fetch?: FetchLike;
     githubApiBaseUrl?: string;
+    upstreamStreamIdleTimeoutMs?: number;
+    upstreamTimeoutMs?: number;
 }
 interface CopilotAccess {
     apiBaseUrl: string;

package/dist/index.js

@@ -2005,6 +2005,14 @@ var COPILOT_USAGE_API_VERSION = "2025-04-01";
 var EDITOR_PLUGIN_VERSION = "hoopilot/0.1.0";
 var EDITOR_VERSION = "Hoopilot/0.1.0";
 var HOOPILOT_USER_AGENT = "hoopilot/0.1.0";
+var DEFAULT_UPSTREAM_TIMEOUT_MS = 12e4;
+var DEFAULT_UPSTREAM_STREAM_IDLE_TIMEOUT_MS = 12e4;
+var CopilotUpstreamTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CopilotUpstreamTimeoutError";
+  }
+};
 function applyCopilotHeaders(headers, token) {
   headers.set("accept", headers.get("accept") ?? "application/json");
   headers.set("authorization", `Bearer ${token}`);
@@ -2057,6 +2065,8 @@ var CopilotClient = class {
   #allowUnsafeUpstream;
   #fetch;
   #githubApiBaseUrl;
+  #upstreamStreamIdleTimeoutMs;
+  #upstreamTimeoutMs;
   constructor(options = {}) {
     this.#auth = new CopilotAuth(options);
     this.#allowUnsafeUpstream = envValue(options.env?.HOOPILOT_ALLOW_UNSAFE_UPSTREAM) === "1";
@@ -2064,6 +2074,18 @@ var CopilotClient = class {
     this.#githubApiBaseUrl = trimTrailingSlash(
       options.githubApiBaseUrl ?? envValue(options.env?.HOOPILOT_GITHUB_API_BASE_URL) ?? DEFAULT_GITHUB_API_BASE_URL
     );
+    this.#upstreamTimeoutMs = parseTimeoutMs(
+      options.upstreamTimeoutMs,
+      options.env?.HOOPILOT_UPSTREAM_TIMEOUT_MS,
+      DEFAULT_UPSTREAM_TIMEOUT_MS,
+      "HOOPILOT_UPSTREAM_TIMEOUT_MS"
+    );
+    this.#upstreamStreamIdleTimeoutMs = parseTimeoutMs(
+      options.upstreamStreamIdleTimeoutMs,
+      options.env?.HOOPILOT_UPSTREAM_STREAM_IDLE_TIMEOUT_MS,
+      DEFAULT_UPSTREAM_STREAM_IDLE_TIMEOUT_MS,
+      "HOOPILOT_UPSTREAM_STREAM_IDLE_TIMEOUT_MS"
+    );
   }
   /**
    * Fetch the Copilot account's quota / premium-request usage from the GitHub
@@ -2082,7 +2104,7 @@ var CopilotClient = class {
     }
     const access = await this.#auth.getAccess();
     const headers = applyGithubApiHeaders(new Headers(), access.token);
-    return this.#fetch(`${this.#githubApiBaseUrl}/copilot_internal/user`, {
+    return this.#fetchWithTimeout(`${this.#githubApiBaseUrl}/copilot_internal/user`, {
       headers,
       method: "GET",
       signal
@@ -2129,12 +2151,139 @@ var CopilotClient = class {
       );
     }
     const headers = applyCopilotHeaders(new Headers(init.headers), access.token);
-    return this.#fetch(`${access.apiBaseUrl}${path}`, {
+    return this.#fetchWithTimeout(`${access.apiBaseUrl}${path}`, {
       ...init,
       headers
     });
   }
+  async #fetchWithTimeout(input, init) {
+    const timeout = abortSignalWithTimeout(init.signal ?? void 0, this.#upstreamTimeoutMs);
+    try {
+      const response = await this.#fetch(input, {
+        ...init,
+        signal: timeout.signal
+      });
+      return responseWithStreamIdleTimeout(response, this.#upstreamStreamIdleTimeoutMs, input);
+    } catch (error) {
+      if (timeout.timedOut()) {
+        throw new CopilotUpstreamTimeoutError(
+          `Copilot upstream request timed out after ${this.#upstreamTimeoutMs} ms before response headers arrived.`
+        );
+      }
+      throw error;
+    } finally {
+      timeout.cleanup();
+    }
+  }
 };
+function parseTimeoutMs(optionValue, envRaw, fallback, name) {
+  const raw = optionValue ?? envValue(envRaw);
+  if (raw === void 0) {
+    return fallback;
+  }
+  const value = typeof raw === "number" ? raw : Number(raw);
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`${name} must be a non-negative integer number of milliseconds.`);
+  }
+  return value;
+}
+function abortSignalWithTimeout(parent, timeoutMs) {
+  if (timeoutMs === 0) {
+    return { cleanup: () => {
+    }, signal: parent, timedOut: () => false };
+  }
+  const controller = new AbortController();
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    if (controller.signal.aborted) {
+      return;
+    }
+    timedOut = true;
+    controller.abort(
+      new CopilotUpstreamTimeoutError(`Copilot upstream request timed out after ${timeoutMs} ms.`)
+    );
+  }, timeoutMs);
+  const onAbort = () => controller.abort(parent?.reason);
+  if (parent?.aborted) {
+    controller.abort(parent.reason);
+  } else {
+    parent?.addEventListener("abort", onAbort, { once: true });
+  }
+  return {
+    cleanup: () => {
+      clearTimeout(timer);
+      parent?.removeEventListener("abort", onAbort);
+    },
+    signal: controller.signal,
+    timedOut: () => timedOut
+  };
+}
+function responseWithStreamIdleTimeout(response, idleTimeoutMs, input) {
+  if (!response.body || idleTimeoutMs === 0) {
+    return response;
+  }
+  return new Response(streamWithIdleTimeout(response.body, idleTimeoutMs, input), {
+    headers: response.headers,
+    status: response.status,
+    statusText: response.statusText
+  });
+}
+function streamWithIdleTimeout(body, idleTimeoutMs, input) {
+  const reader = body.getReader();
+  let released = false;
+  const release = () => {
+    if (!released) {
+      released = true;
+      reader.releaseLock();
+    }
+  };
+  return new ReadableStream({
+    async pull(controller) {
+      let timer;
+      const read = reader.read();
+      read.catch(() => {
+      });
+      try {
+        const result = await Promise.race([
+          read,
+          new Promise((_, reject) => {
+            timer = setTimeout(() => {
+              reject(
+                new CopilotUpstreamTimeoutError(
+                  `Copilot upstream stream was idle for ${idleTimeoutMs} ms while reading ${input}.`
+                )
+              );
+            }, idleTimeoutMs);
+          })
+        ]);
+        if (timer) {
+          clearTimeout(timer);
+        }
+        if (result.done) {
+          controller.close();
+          release();
+          return;
+        }
+        controller.enqueue(result.value);
+      } catch (error) {
+        if (timer) {
+          clearTimeout(timer);
+        }
+        await reader.cancel(error).catch(() => {
+        });
+        controller.error(error);
+        release();
+      }
+    },
+    async cancel(reason) {
+      try {
+        await reader.cancel(reason);
+      } finally {
+        release();
+      }
+    }
+  });
+}
 function normalizeCopilotUsage(body) {
   const record = asRecord(body);
   const quotas = {};
@@ -4089,6 +4238,13 @@ function buildApp(deps) {
       );
       return jsonError(413, "request_too_large", message);
     }
+    if (error instanceof CopilotUpstreamTimeoutError) {
+      logger.warn(
+        { err: errorDetails(error), event: "copilot.request.timeout" },
+        "copilot upstream request timed out"
+      );
+      return jsonError(504, "copilot_timeout", message);
+    }
     logger.error({ err: errorDetails(error), event: "http.request.failed" }, "request failed");
     return jsonError(500, "internal_error", message);
   }).get("/", () => jsonResponse({ name: "hoopilot", object: "health", status: "ok" })).get("/healthz", () => jsonResponse({ name: "hoopilot", object: "health", status: "ok" })).get("/metrics", () => metricsResponse(metrics)).get("/v1/usage", ({ request }) => handleUsage(metrics, readUsage, request.signal)).get(