@openhoo/hoopilot 2.1.1 → 2.1.3

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: [compactionSummaryOutputMessageItem(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 compactionSummaryText(upstreamText, isSse) {
+  const summary = isSse ? compactionSummaryTextFromResponsesSse(upstreamText) : compactionSummaryTextFromResponse(asRecord(safeJsonParse(upstreamText)));
+  return summary.trim() || "(no summary available)";
 }
-function compactionOutputFromResponse(response) {
-  if (Array.isArray(response.output) && response.output.length > 0) {
-    return response.output;
+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 = contentToText(response.output_text);
-  return text ? [messageOutputItem(text)] : [];
+  const text = outputText(output);
+  if (text) {
+    return 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,72 @@ function messageOutputItem(text, id = `msg_${randomId()}`) {
     type: "message"
   };
 }
+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}
+${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(compactionSummaryInputMessageItem(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,
@@ -794,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
   );
@@ -966,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),
@@ -981,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);
@@ -1077,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);
@@ -1098,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;
       }
@@ -1116,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") {
@@ -1177,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.`
@@ -1213,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)) {
@@ -1230,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,
@@ -1239,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;
@@ -4080,7 +4341,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 +4375,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 +4392,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 +4516,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(
     {