@openhoo/hoopilot 2.1.2 → 2.1.3

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;