@openhoo/hoopilot 0.9.0 → 0.9.2

package/README.md

@@ -162,6 +162,14 @@ chat-completions endpoint. Before starting Codex, `codexx` checks
 not advertise the requested model. Set `CODEXX_MODEL` to one of the listed models,
 or log in with a Copilot account that has `gpt-5.5`.
 
+When Codex compacts a long session it POSTs to `/v1/responses/compact` — a server-side
+endpoint it expects from `OpenAI`- and Azure-named providers and for which it has no
+local fallback, so an unhandled route would abort compaction. Hoopilot handles it by
+running the supplied conversation through Copilot's Responses endpoint as a unary
+request and returning the resulting `{ "output": [...] }` summary, so compaction works
+whether Codex points at Hoopilot through `codexx` or through a plain `OPENAI_BASE_URL`
+override of the built-in `openai` provider.
+
 If no `HOOPILOT_API_KEY` is configured, Hoopilot accepts local requests without client authentication. Binding to a non-loopback host requires `HOOPILOT_API_KEY` unless `--allow-unauthenticated` is set.
 
 ## Logging

package/dist/cli.js

@@ -626,6 +626,48 @@ function normalizeRequestedModel(model) {
   const requested = contentToText(model).trim();
   return requested || DEFAULT_MODEL;
 }
+function responsesCompactionResult(upstreamText, isSse) {
+  const output = isSse ? compactionOutputFromResponsesSse(upstreamText) : compactionOutputFromResponse(asRecord(safeJsonParse(upstreamText)));
+  return { output };
+}
+function compactionOutputFromResponse(response) {
+  if (Array.isArray(response.output) && response.output.length > 0) {
+    return response.output;
+  }
+  const text = contentToText(response.output_text);
+  return text ? [messageOutputItem(text)] : [];
+}
+function compactionOutputFromResponsesSse(text) {
+  let deltas = "";
+  let completedOutput;
+  for (const block of text.split(/\r?\n\r?\n/)) {
+    const data = block.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim()).join("");
+    if (!data || data === "[DONE]") {
+      continue;
+    }
+    const record = asRecord(safeJsonParse(data));
+    const type = contentToText(record.type);
+    if (type === "response.output_text.delta") {
+      deltas += contentToText(record.delta);
+    } else if (type === "response.completed" || type === "response.incomplete") {
+      const response = asRecord(record.response);
+      if (Array.isArray(response.output)) {
+        completedOutput = response.output;
+      }
+    }
+  }
+  if (completedOutput && completedOutput.length > 0) {
+    return completedOutput;
+  }
+  return deltas ? [messageOutputItem(deltas)] : [];
+}
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
 function chatCompletionToCompletion(completion) {
   return removeUndefined({
     choices: completionChoices(completion).map((choice, index) => {
@@ -788,6 +830,21 @@ function contentToText(content) {
   }
   return "";
 }
+function messageOutputItem(text, id = `msg_${randomId()}`) {
+  return {
+    content: [
+      {
+        annotations: [],
+        text,
+        type: "output_text"
+      }
+    ],
+    id,
+    role: "assistant",
+    status: "completed",
+    type: "message"
+  };
+}
 function extractTokenUsage(usage) {
   const record = asRecord(usage);
   const prompt = firstNumber(record.prompt_tokens, record.input_tokens);
@@ -2165,6 +2222,11 @@ function createHoopilotHandler(options = {}) {
           )
         );
       }
+      if (request.method === "POST" && apiPath === "/v1/responses/compact") {
+        return finish(
+          await handleResponsesCompact(client, metrics, recordTokens, request, requestLogger)
+        );
+      }
       if (request.method === "POST" && apiPath === "/v1/responses") {
         return finish(
           await handleResponses(
@@ -2379,6 +2441,22 @@ async function handleResponses(client, metrics, recordTokens, request, logger, b
     )
   );
 }
+async function handleResponsesCompact(client, metrics, recordTokens, request, logger) {
+  const body = await readJson(request);
+  const upstream = await client.responses(
+    JSON.stringify({ ...body, stream: false }),
+    request.signal
+  );
+  metrics.recordUpstream("/responses", upstream.ok);
+  if (!upstream.ok) {
+    return proxyError(upstream, logger);
+  }
+  logUpstreamSuccess(logger, "/responses", upstream.status);
+  const isSse = isStreamingResponse(upstream);
+  const text = await upstream.text();
+  recordResponseTextUsage(text, isSse, normalizeRequestedModel(body.model), recordTokens);
+  return jsonResponse(responsesCompactionResult(text, isSse));
+}
 async function responseWithObservedUsage(response, fallbackModel, recordTokens, signal, bufferBody) {
   const isSse = isStreamingResponse(response);
   if (bufferBody && response.body) {
@@ -2698,6 +2776,8 @@ function canonicalApiPath(path) {
       return "/v1/messages/count_tokens";
     case "/responses":
       return "/v1/responses";
+    case "/responses/compact":
+      return "/v1/responses/compact";
     case "/usage":
       return "/v1/usage";
     default:
@@ -2732,6 +2812,9 @@ function routeFor(method, path) {
   if (method === "POST" && path === "/v1/completions") {
     return "completions";
   }
+  if (method === "POST" && path === "/v1/responses/compact") {
+    return "responses_compact";
+  }
   if (method === "POST" && path === "/v1/responses") {
     return "responses";
   }