190proof 1.0.8 → 1.0.9

package/dist/index.mjs

@@ -31418,8 +31418,15 @@ var {
 function timeout(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function isHeicImage(name, mime) {
+  var _a3;
+  const extension = ((_a3 = name.split(".").pop()) == null ? void 0 : _a3.toLowerCase()) || "";
+  return ["heic", "heif", "heics"].includes(extension) || !!(mime && ["image/heic", "image/heif", "image/heic-sequence"].includes(mime));
+}
 
 // index.ts
+var sharp = __require("sharp");
+var decode = __require("heic-decode");
 function parseStreamedResponse(identifier, paragraph, functionCallName, functionCallArgs, allowedFunctionNames) {
   let functionCall = null;
   if (functionCallName && functionCallArgs) {
@@ -31863,7 +31870,7 @@ async function callWithRetries(identifier, aiPayload, aiConfig, retries = 5, chu
     console.log(identifier, "Delegating call to Anthropic API");
     return await callAnthropicWithRetries(
       identifier,
-      prepareAnthropicPayload(aiPayload),
+      await prepareAnthropicPayload(aiPayload),
       aiConfig,
       retries
     );
@@ -31871,14 +31878,17 @@ async function callWithRetries(identifier, aiPayload, aiConfig, retries = 5, chu
     console.log(identifier, "Delegating call to OpenAI API");
     return await callOpenAiWithRetries(
       identifier,
-      prepareOpenAIPayload(aiPayload),
+      await prepareOpenAIPayload(aiPayload),
       aiConfig,
       retries,
       chunkTimeoutMs
     );
   } else if (isGroqPayload(aiPayload)) {
     console.log(identifier, "Delegating call to Groq API");
-    return await callGroqWithRetries(identifier, prepareGroqPayload(aiPayload));
+    return await callGroqWithRetries(
+      identifier,
+      await prepareGroqPayload(aiPayload)
+    );
   } else {
     throw new Error("Invalid AI payload: Unknown model type.");
   }
@@ -31886,31 +31896,110 @@ async function callWithRetries(identifier, aiPayload, aiConfig, retries = 5, chu
 function isAnthropicPayload(payload) {
   return Object.values(ClaudeModel).includes(payload.model);
 }
-function prepareAnthropicPayload(payload) {
-  return {
+async function prepareAnthropicPayload(payload) {
+  const preparedPayload = {
     model: payload.model,
-    messages: payload.messages.map((message) => ({
-      role: message.role,
-      content: message.content
-      // TODO: Handle files
-    })),
+    messages: [],
     functions: payload.functions
   };
+  for (const message of payload.messages) {
+    const anthropicContentBlocks = [];
+    if (message.content) {
+      anthropicContentBlocks.push({
+        type: "text",
+        text: message.content
+      });
+    }
+    for (const file of message.files || []) {
+      if (!file.mimetype.startsWith("image")) {
+        console.warn(
+          "Anthropic API does not support non-image file types. Skipping file."
+        );
+        continue;
+      }
+      if (file.url) {
+        anthropicContentBlocks.push({
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: "image/png",
+            data: await getNormalizedBase64PNG(file.url, file.mimetype)
+          }
+        });
+      } else if (file.data) {
+        if (!["image/png", "image/jpeg", "image/gif", "image/webp"].includes(
+          file.mimetype
+        )) {
+          throw new Error(
+            "Invalid image mimetype. Supported types are: image/png, image/jpeg, image/gif, image/webp"
+          );
+        }
+        anthropicContentBlocks.push({
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: file.mimetype,
+            data: file.data
+          }
+        });
+      }
+    }
+    preparedPayload.messages.push({
+      role: message.role,
+      content: anthropicContentBlocks
+    });
+  }
+  return preparedPayload;
 }
 function isOpenAiPayload(payload) {
   return Object.values(GPTModel).includes(payload.model);
 }
-function prepareOpenAIPayload(payload) {
-  return {
+async function prepareOpenAIPayload(payload) {
+  const preparedPayload = {
     model: payload.model,
-    messages: payload.messages.map((message) => ({
-      role: message.role,
-      content: normalizeMessageContent(message.content)
-      // TODO: Handle files
-    })),
-    functions: payload.functions,
-    function_call: payload.function_call
+    messages: [],
+    functions: payload.functions
   };
+  for (const message of payload.messages) {
+    const openAIContentBlocks = [];
+    if (message.content) {
+      openAIContentBlocks.push({
+        type: "text",
+        text: message.content
+      });
+    }
+    for (const file of message.files || []) {
+      if (!file.mimetype.startsWith("image")) {
+        console.warn(
+          "OpenAI API does not support non-image file types. Skipping file."
+        );
+        continue;
+      }
+      if (file.url) {
+        openAIContentBlocks.push({
+          type: "image_url",
+          image_url: {
+            url: `data:image/png;base64,${await getNormalizedBase64PNG(
+              file.url,
+              file.mimetype
+            )}`
+          }
+        });
+      } else if (file.data) {
+        openAIContentBlocks.push({
+          type: "image_url",
+          image_url: {
+            url: `data:${file.mimetype};base64,${file.data}`
+          }
+        });
+      }
+    }
+    preparedPayload.messages.push({
+      role: message.role,
+      content: openAIContentBlocks
+    });
+  }
+  return preparedPayload;
 }
 function isGroqPayload(payload) {
   return Object.values(GroqModel).includes(payload.model);
@@ -31992,6 +32081,25 @@ async function callGroqWithRetries(identifier, payload, retries = 5) {
   error.response = lastResponse;
   throw error;
 }
+async function getNormalizedBase64PNG(url2, mime) {
+  console.log("Normalizing image", url2);
+  const response = await axios_default.get(url2, { responseType: "arraybuffer" });
+  let imageBuffer = Buffer.from(response.data);
+  let sharpOptions = {};
+  if (isHeicImage(url2, mime)) {
+    const imageData = await decode({ buffer: imageBuffer });
+    imageBuffer = Buffer.from(imageData.data);
+    sharpOptions = {
+      raw: {
+        width: imageData.width,
+        height: imageData.height,
+        channels: 4
+      }
+    };
+  }
+  const resizedBuffer = await sharp(imageBuffer, sharpOptions).withMetadata().resize(1024, 1024, { fit: "inside", withoutEnlargement: true }).png().toBuffer();
+  return resizedBuffer.toString("base64");
+}
 export {
   ClaudeModel,
   GPTModel,