@openhoo/hoopilot 2.1.2 → 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

@@ -195,7 +195,7 @@ function chatCompletionToResponse(completion, responseId) {
 }
 function responsesCompactionResult(upstreamText, isSse) {
   const summary = compactionSummaryText(upstreamText, isSse);
-  return { output: [compactionSummaryMessageItem(summary)] };
+  return { output: [compactionSummaryOutputMessageItem(summary)] };
 }
 function isResponsesCompactionRequest(request) {
   return responseInputItems(request.input).some(
@@ -839,8 +839,14 @@ function messageOutputItem(text, id = `msg_${randomId()}`) {
     type: "message"
   };
 }
-function compactionSummaryMessageItem(text, id = `msg_${randomId()}`) {
-  return {
+function compactionSummaryOutputMessageItem(text) {
+  return compactionSummaryMessageItem(text, `msg_${randomId()}`);
+}
+function compactionSummaryInputMessageItem(text) {
+  return compactionSummaryMessageItem(text);
+}
+function compactionSummaryMessageItem(text, id) {
+  return removeUndefined({
     content: [
       {
         text: `${COMPACTION_SUMMARY_PREFIX}
@@ -851,7 +857,7 @@ ${text}`,
     id,
     role: "user",
     type: "message"
-  };
+  });
 }
 function compactionOutputItem(text, id = `cmpct_${randomId()}`) {
   return {
@@ -875,7 +881,7 @@ function normalizeCompactionInputForCopilot(input, options) {
     if (type === "compaction" || type === "compaction_summary" || type === "context_compaction") {
       const text = contentToText(record.encrypted_content);
       if (text) {
-        normalized.push(compactionSummaryMessageItem(text));
+        normalized.push(compactionSummaryInputMessageItem(text));
       }
       continue;
     }
@@ -956,6 +962,7 @@ function extractTokenUsage(usage) {
     asRecord(record.output_tokens_details).reasoning_tokens
   );
   const cached = firstNumber(
+    record.cache_read_input_tokens,
     asRecord(record.prompt_tokens_details).cached_tokens,
     asRecord(record.input_tokens_details).cached_tokens
   );
@@ -1128,9 +1135,10 @@ var AnthropicCompatibilityError = class extends Error {
   }
 };
 function anthropicMessagesToResponsesRequest(request) {
-  return removeUndefined({
-    input: anthropicMessagesToResponsesInput(request.messages),
-    instructions: anthropicSystemToInstructions(request.system),
+  const system = anthropicSystemToResponses(request.system);
+  const response = removeUndefined({
+    input: [...system.input, ...anthropicMessagesToResponsesInput(request.messages)],
+    instructions: system.instructions,
     max_output_tokens: typeof request.max_tokens === "number" && Number.isFinite(request.max_tokens) ? request.max_tokens : void 0,
     metadata: request.metadata,
     model: normalizeRequestedModel(request.model),
@@ -1143,6 +1151,8 @@ function anthropicMessagesToResponsesRequest(request) {
     tools: anthropicTools(request.tools),
     top_p: request.top_p
   });
+  applyCacheControlToLastBlock(response, anthropicCacheControl(request.cache_control));
+  return response;
 }
 function responsesResponseToAnthropicMessage(response, fallbackModel) {
   const content = anthropicContentFromResponsesOutput(response);
@@ -1239,6 +1249,7 @@ function anthropicMessagesToResponsesInput(messages) {
     throw new AnthropicCompatibilityError("Anthropic Messages requests require messages[].");
   }
   const input = [];
+  let fallbackToolCallIndex = 0;
   for (const message of messages) {
     const record = asRecord(message);
     const role = anthropicRole(record.role);
@@ -1260,10 +1271,13 @@ function anthropicMessagesToResponsesInput(messages) {
       if (type === "text") {
         const text = textValue(part.text);
         if (text) {
-          messageParts.push({
-            text,
-            type: role === "assistant" ? "output_text" : "input_text"
-          });
+          messageParts.push(
+            removeUndefined({
+              cache_control: anthropicCacheControl(part.cache_control),
+              text,
+              type: role === "assistant" ? "output_text" : "input_text"
+            })
+          );
         }
         continue;
       }
@@ -1278,21 +1292,27 @@ function anthropicMessagesToResponsesInput(messages) {
       }
       if (type === "tool_use") {
         flushMessage();
-        input.push({
-          arguments: JSON.stringify(asRecord(part.input)),
-          call_id: textValue(part.id) || `call_${randomId()}`,
-          name: textValue(part.name),
-          type: "function_call"
-        });
+        input.push(
+          removeUndefined({
+            arguments: JSON.stringify(asRecord(part.input)),
+            cache_control: anthropicCacheControl(part.cache_control),
+            call_id: textValue(part.id) || `call_hoopilot_${fallbackToolCallIndex++}`,
+            name: textValue(part.name),
+            type: "function_call"
+          })
+        );
         continue;
       }
       if (type === "tool_result") {
         flushMessage();
-        input.push({
-          call_id: textValue(part.tool_use_id),
-          output: anthropicToolResultOutput(part.content),
-          type: "function_call_output"
-        });
+        input.push(
+          removeUndefined({
+            cache_control: anthropicCacheControl(part.cache_control),
+            call_id: textValue(part.tool_use_id),
+            output: anthropicToolResultOutput(part.content),
+            type: "function_call_output"
+          })
+        );
         continue;
       }
       if (type === "thinking" || type === "redacted_thinking") {
@@ -1339,22 +1359,24 @@ function anthropicImageToResponsesPart(part) {
     if (!data) {
       throw new AnthropicCompatibilityError("Anthropic base64 image content requires source.data.");
     }
-    return {
+    return removeUndefined({
+      cache_control: anthropicCacheControl(part.cache_control),
       detail: "auto",
       image_url: `data:${mediaType};base64,${data}`,
       type: "input_image"
-    };
+    });
   }
   if (sourceType === "url") {
     const url = textValue(source.url);
     if (!url) {
       throw new AnthropicCompatibilityError("Anthropic URL image content requires source.url.");
     }
-    return {
+    return removeUndefined({
+      cache_control: anthropicCacheControl(part.cache_control),
       detail: "auto",
       image_url: url,
       type: "input_image"
-    };
+    });
   }
   throw new AnthropicCompatibilityError(
     `Anthropic image source type "${sourceType || "unknown"}" is not supported.`
@@ -1375,15 +1397,42 @@ function anthropicToolResultOutput(content) {
   }
   return typeof content === "object" ? JSON.stringify(content) : String(content);
 }
-function anthropicSystemToInstructions(system) {
+function anthropicSystemToResponses(system) {
   if (typeof system === "string") {
-    return system || void 0;
+    return { input: [], instructions: system || void 0 };
   }
   if (!Array.isArray(system)) {
+    return { input: [] };
+  }
+  const parts = system.map((part) => anthropicSystemPartToResponsesPart(part)).filter((part) => part !== void 0);
+  if (parts.length === 0) {
+    return { input: [] };
+  }
+  if (parts.some((part) => part.cache_control !== void 0)) {
+    return {
+      input: [
+        {
+          content: parts,
+          role: "system",
+          type: "message"
+        }
+      ]
+    };
+  }
+  const text = parts.map((part) => textValue(part.text)).filter(Boolean).join("\n");
+  return { input: [], instructions: text || void 0 };
+}
+function anthropicSystemPartToResponsesPart(part) {
+  const record = asRecord(part);
+  const text = textValue(record.text) || textValue(part);
+  if (!text) {
     return void 0;
   }
-  const text = system.map((part) => textValue(asRecord(part).text) || textValue(part)).filter(Boolean).join("\n");
-  return text || void 0;
+  return removeUndefined({
+    cache_control: anthropicCacheControl(record.cache_control),
+    text,
+    type: "input_text"
+  });
 }
 function anthropicTools(tools) {
   if (!Array.isArray(tools)) {
@@ -1392,6 +1441,7 @@ function anthropicTools(tools) {
   const converted = tools.map((tool) => {
     const record = asRecord(tool);
     return removeUndefined({
+      cache_control: anthropicCacheControl(record.cache_control),
       description: record.description,
       name: record.name,
       parameters: record.input_schema,
@@ -1401,6 +1451,55 @@ function anthropicTools(tools) {
   });
   return converted.length > 0 ? converted : void 0;
 }
+function anthropicCacheControl(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const record = asRecord(value);
+  const type = textValue(record.type);
+  if (type !== "ephemeral") {
+    throw new AnthropicCompatibilityError(
+      `Anthropic cache_control type "${type || "unknown"}" is not supported.`
+    );
+  }
+  const ttl = textValue(record.ttl);
+  if (ttl && ttl !== "5m" && ttl !== "1h") {
+    throw new AnthropicCompatibilityError(`Anthropic cache_control ttl "${ttl}" is not supported.`);
+  }
+  return removeUndefined({
+    ttl: ttl || void 0,
+    type
+  });
+}
+function applyCacheControlToLastBlock(request, cacheControl) {
+  if (!cacheControl) {
+    return;
+  }
+  const input = Array.isArray(request.input) ? request.input : [];
+  for (let itemIndex = input.length - 1; itemIndex >= 0; itemIndex -= 1) {
+    const item = asRecord(input[itemIndex]);
+    const content = Array.isArray(item.content) ? item.content : [];
+    for (let partIndex = content.length - 1; partIndex >= 0; partIndex -= 1) {
+      const part = asRecord(content[partIndex]);
+      if (part.cache_control === void 0 && isCacheableResponsesPart(part)) {
+        part.cache_control = cacheControl;
+        return;
+      }
+    }
+  }
+  const tools = Array.isArray(request.tools) ? request.tools : [];
+  for (let index = tools.length - 1; index >= 0; index -= 1) {
+    const tool = asRecord(tools[index]);
+    if (tool.cache_control === void 0) {
+      tool.cache_control = cacheControl;
+      return;
+    }
+  }
+}
+function isCacheableResponsesPart(part) {
+  const type = textValue(part.type);
+  return type === "input_text" || type === "output_text" || type === "text" || type === "input_image";
+}
 function anthropicToolChoice(toolChoice) {
   if (toolChoice === void 0 || toolChoice === null) {
     return void 0;
@@ -1906,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}`);
@@ -1958,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";
@@ -1965,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
@@ -1983,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
@@ -2030,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 = {};
@@ -3990,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(