@openhoo/hoopilot 2.1.0 → 2.1.2

package/dist/codexx.js

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

package/dist/index.js

@@ -94,6 +94,16 @@ function parseStreamingProxyMode(value) {
 
 // src/openai.ts
 var DEFAULT_MODEL = "gpt-4.1";
+var COMPACTION_SUMMARIZATION_PROMPT = `You are performing a CONTEXT CHECKPOINT COMPACTION. Create a handoff summary for another LLM that will resume the task.
+
+Include:
+- Current progress and key decisions made
+- Important context, constraints, or user preferences
+- What remains to be done (clear next steps)
+- Any critical data, examples, or references needed to continue
+
+Be concise, structured, and focused on helping the next LLM seamlessly continue the work.`;
+var COMPACTION_SUMMARY_PREFIX = "Another language model started to solve this problem and produced a summary of its thinking process. You also have access to the state of the tools that were used by that language model. Use this to build on the work that has already been done and avoid duplicating work. Here is the summary produced by the other language model, use the information in this summary to assist with your own analysis:";
 var OpenAICompatibilityError = class extends Error {
   constructor(message) {
     super(message);
@@ -184,19 +194,111 @@ function chatCompletionToResponse(completion, responseId) {
   });
 }
 function responsesCompactionResult(upstreamText, isSse) {
-  const output = isSse ? compactionOutputFromResponsesSse(upstreamText) : compactionOutputFromResponse(asRecord(safeJsonParse(upstreamText)));
-  return { output };
+  const summary = compactionSummaryText(upstreamText, isSse);
+  return { output: [compactionSummaryMessageItem(summary)] };
+}
+function isResponsesCompactionRequest(request) {
+  return responseInputItems(request.input).some(
+    (item) => contentToText(asRecord(item).type) === "compaction_trigger"
+  );
+}
+function responsesCompactionRequestBody(request) {
+  return JSON.stringify(
+    removeUndefined({
+      ...request,
+      input: [
+        ...compactionInputItemsForCopilot(request.input),
+        {
+          content: [{ text: COMPACTION_SUMMARIZATION_PROMPT, type: "input_text" }],
+          role: "user",
+          type: "message"
+        }
+      ],
+      parallel_tool_calls: false,
+      stream: false,
+      tool_choice: "none",
+      tools: []
+    })
+  );
+}
+function normalizeResponsesRequestForCopilotBody(request) {
+  return JSON.stringify(
+    removeUndefined({
+      ...request,
+      input: normalizeCompactionInputForCopilot(request.input, { dropTrigger: false })
+    })
+  );
+}
+function responsesRequestNeedsCopilotNormalization(request) {
+  return responseInputItems(request.input).some((item) => {
+    const type = contentToText(asRecord(item).type);
+    return type === "compaction" || type === "compaction_summary" || type === "context_compaction";
+  });
+}
+function responsesCompactionResponse(upstreamText, isSse, model) {
+  const output = [compactionOutputItem(compactionSummaryText(upstreamText, isSse))];
+  return removeUndefined({
+    created_at: epochSeconds(),
+    error: null,
+    id: `resp_${randomId()}`,
+    incomplete_details: null,
+    instructions: null,
+    max_output_tokens: null,
+    metadata: {},
+    model,
+    object: "response",
+    output,
+    output_text: "",
+    parallel_tool_calls: false,
+    status: "completed",
+    temperature: null,
+    tool_choice: "none",
+    tools: [],
+    top_p: null
+  });
+}
+function responsesCompactionSseText(upstreamText, isSse, model) {
+  const responseId = `resp_${randomId()}`;
+  const item = compactionOutputItem(compactionSummaryText(upstreamText, isSse));
+  const createdAt = epochSeconds();
+  let sequenceNumber = 0;
+  const event = (name, data) => encodeSse(name, data === "[DONE]" ? data : { ...data, sequence_number: sequenceNumber++ });
+  return [
+    event("response.created", {
+      response: baseStreamResponse(responseId, model, createdAt, "in_progress", []),
+      type: "response.created"
+    }),
+    event("response.output_item.done", {
+      item,
+      output_index: 0,
+      type: "response.output_item.done"
+    }),
+    event("response.completed", {
+      response: baseStreamResponse(responseId, model, createdAt, "completed", [item]),
+      type: "response.completed"
+    }),
+    event("done", "[DONE]")
+  ].join("");
 }
-function compactionOutputFromResponse(response) {
-  if (Array.isArray(response.output) && response.output.length > 0) {
-    return response.output;
+function compactionSummaryText(upstreamText, isSse) {
+  const summary = isSse ? compactionSummaryTextFromResponsesSse(upstreamText) : compactionSummaryTextFromResponse(asRecord(safeJsonParse(upstreamText)));
+  return summary.trim() || "(no summary available)";
+}
+function compactionSummaryTextFromResponse(response) {
+  const output = Array.isArray(response.output) ? response.output.map((item) => asRecord(item)) : [];
+  const compaction = output.find((item) => contentToText(item.type) === "compaction");
+  if (compaction) {
+    return contentToText(compaction.encrypted_content);
+  }
+  const text = outputText(output);
+  if (text) {
+    return text;
   }
-  const text = contentToText(response.output_text);
-  return text ? [messageOutputItem(text)] : [];
+  return contentToText(response.output_text);
 }
-function compactionOutputFromResponsesSse(text) {
+function compactionSummaryTextFromResponsesSse(text) {
   let deltas = "";
-  let completedOutput;
+  let completedResponse;
   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]") {
@@ -207,16 +309,16 @@ function compactionOutputFromResponsesSse(text) {
     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;
-      }
+      completedResponse = asRecord(record.response);
     }
   }
-  if (completedOutput && completedOutput.length > 0) {
-    return completedOutput;
+  if (completedResponse) {
+    const summary = compactionSummaryTextFromResponse(completedResponse);
+    if (summary) {
+      return summary;
+    }
   }
-  return deltas ? [messageOutputItem(deltas)] : [];
+  return deltas;
 }
 function chatCompletionToCompletion(completion) {
   return removeUndefined({
@@ -737,6 +839,66 @@ function messageOutputItem(text, id = `msg_${randomId()}`) {
     type: "message"
   };
 }
+function compactionSummaryMessageItem(text, id = `msg_${randomId()}`) {
+  return {
+    content: [
+      {
+        text: `${COMPACTION_SUMMARY_PREFIX}
+${text}`,
+        type: "input_text"
+      }
+    ],
+    id,
+    role: "user",
+    type: "message"
+  };
+}
+function compactionOutputItem(text, id = `cmpct_${randomId()}`) {
+  return {
+    encrypted_content: text,
+    id,
+    type: "compaction"
+  };
+}
+function normalizeCompactionInputForCopilot(input, options) {
+  const items = responseInputItems(input);
+  if (items.length === 0) {
+    return input;
+  }
+  const normalized = [];
+  for (const item of items) {
+    const record = asRecord(item);
+    const type = contentToText(record.type);
+    if (type === "compaction_trigger" && options.dropTrigger) {
+      continue;
+    }
+    if (type === "compaction" || type === "compaction_summary" || type === "context_compaction") {
+      const text = contentToText(record.encrypted_content);
+      if (text) {
+        normalized.push(compactionSummaryMessageItem(text));
+      }
+      continue;
+    }
+    normalized.push(item);
+  }
+  return normalized;
+}
+function compactionInputItemsForCopilot(input) {
+  if (Array.isArray(input)) {
+    return normalizeCompactionInputForCopilot(input, { dropTrigger: true });
+  }
+  const text = contentToText(input);
+  return text ? [
+    {
+      content: [{ text, type: "input_text" }],
+      role: "user",
+      type: "message"
+    }
+  ] : [];
+}
+function responseInputItems(input) {
+  return Array.isArray(input) ? input : [];
+}
 function functionCallItem(tool, status = "completed") {
   return {
     arguments: tool.arguments,
@@ -4080,7 +4242,21 @@ async function handleCompletions(client, metrics, recordTokens, recordExtraction
 }
 async function handleResponses(client, metrics, recordTokens, recordExtraction, request, logger, bufferProxyBodies) {
   const { json, text: body } = await readJsonText(request);
-  const upstream = await client.responses(body, request.signal);
+  if (isResponsesCompactionRequest(json)) {
+    return handleResponsesCompactionV2(
+      client,
+      metrics,
+      recordTokens,
+      recordExtraction,
+      json,
+      request,
+      logger
+    );
+  }
+  const upstream = await client.responses(
+    responsesRequestNeedsCopilotNormalization(json) ? normalizeResponsesRequestForCopilotBody(json) : body,
+    request.signal
+  );
   metrics.recordUpstream("/responses", upstream.ok);
   if (!upstream.ok) {
     return proxyError(upstream, logger);
@@ -4100,10 +4276,7 @@ async function handleResponses(client, metrics, recordTokens, recordExtraction,
 }
 async function handleResponsesCompact(client, metrics, recordTokens, recordExtraction, request, logger) {
   const body = await readJson(request);
-  const upstream = await client.responses(
-    JSON.stringify({ ...body, stream: false }),
-    request.signal
-  );
+  const upstream = await client.responses(responsesCompactionRequestBody(body), request.signal);
   metrics.recordUpstream("/responses", upstream.ok);
   if (!upstream.ok) {
     return proxyError(upstream, logger);
@@ -4120,6 +4293,22 @@ async function handleResponsesCompact(client, metrics, recordTokens, recordExtra
   );
   return jsonResponse(responsesCompactionResult(text, isSse));
 }
+async function handleResponsesCompactionV2(client, metrics, recordTokens, recordExtraction, json, request, logger) {
+  const upstream = await client.responses(responsesCompactionRequestBody(json), 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();
+  const model = normalizeRequestedModel(json.model);
+  recordResponseTextUsage(text, isSse, model, recordTokens, recordExtraction);
+  if (json.stream === true) {
+    return textResponse(responsesCompactionSseText(text, isSse, model), "text/event-stream");
+  }
+  return jsonResponse(responsesCompactionResponse(text, isSse, model));
+}
 async function responseWithObservedUsage(response, fallbackModel, recordTokens, signal, bufferBody, recordExtraction) {
   const isSse = isStreamingResponse(response);
   if (bufferBody && response.body) {
@@ -4228,6 +4417,15 @@ function jsonResponse(body, status = 200) {
     status
   });
 }
+function textResponse(body, contentType, status = 200) {
+  return new Response(body, {
+    headers: {
+      ...corsHeaders(),
+      "content-type": `${contentType}; charset=utf-8`
+    },
+    status
+  });
+}
 function jsonError(status, code, message) {
   return jsonResponse(
     {