190proof 1.0.76 → 1.0.77

package/dist/index.mjs

@@ -101,15 +101,42 @@ function isHeicImage(name, mime) {
 
 // index.ts
 import { GoogleGenAI } from "@google/genai";
-var { GoogleGenerativeAI } = __require("@google/generative-ai");
 var sharp = __require("sharp");
 var decode = __require("heic-decode");
+async function withRetries(identifier, apiName, fn, options = {}) {
+  var _a;
+  const { retries = 5, baseDelayMs = 125, onError } = options;
+  logger_default.log(identifier, `Calling ${apiName} API with retries`);
+  let lastError;
+  for (let attempt = 0; attempt < retries; attempt++) {
+    try {
+      return await fn();
+    } catch (error3) {
+      lastError = error3;
+      if (onError) {
+        onError(error3, attempt);
+      } else {
+        logger_default.error(
+          identifier,
+          `Retry #${attempt} error: ${error3.message}`,
+          ((_a = error3.response) == null ? void 0 : _a.data) || error3
+        );
+      }
+      await timeout(baseDelayMs * attempt);
+    }
+  }
+  const error2 = new Error(
+    `Failed to call ${apiName} API after ${retries} attempts`
+  );
+  error2.cause = lastError;
+  throw error2;
+}
 function parseStreamedResponse(identifier, paragraph, functionCallName, functionCallArgs, allowedFunctionNames) {
   let functionCall = null;
   if (functionCallName && functionCallArgs) {
     if (allowedFunctionNames && !allowedFunctionNames.has(functionCallName)) {
       throw new Error(
-        "Stream error: received function call with unknown name: " + functionCallName
+        `Stream error: received function call with unknown name: ${functionCallName}`
       );
     }
     try {
@@ -120,7 +147,7 @@ function parseStreamedResponse(identifier, paragraph, functionCallName, function
     } catch (error2) {
       logger_default.error(
         identifier,
-        "Error parsing functionCallArgs:",
+        "Error parsing function call arguments:",
         functionCallArgs
       );
       throw error2;
@@ -129,7 +156,7 @@ function parseStreamedResponse(identifier, paragraph, functionCallName, function
   if (!paragraph && !functionCall) {
     logger_default.error(
       identifier,
-      "Stream error: received message without content or function_call, raw:",
+      "Stream error: received message without content or function_call:",
       JSON.stringify({ paragraph, functionCallName, functionCallArgs })
     );
     throw new Error(
@@ -143,328 +170,252 @@ function parseStreamedResponse(identifier, paragraph, functionCallName, function
     files: []
   };
 }
-async function callOpenAiWithRetries(identifier, openAiPayload, openAiConfig, retries = 5, chunkTimeoutMs = 15e3) {
-  var _a, _b;
-  logger_default.log(
-    identifier,
-    "Calling OpenAI API with retries:",
-    openAiConfig == null ? void 0 : openAiConfig.service,
-    openAiPayload.model
-  );
-  let errorObj;
-  for (let i = 0; i <= retries; i++) {
-    try {
-      const timerId = `timer:${identifier}:${Date.now()}:callOpenAi:${openAiConfig == null ? void 0 : openAiConfig.service}-${openAiPayload.model}-${openAiConfig == null ? void 0 : openAiConfig.orgId}`;
-      if (openAiPayload.model === "o1-mini" /* O1_MINI */ || openAiPayload.model === "o1-preview" /* O1_PREVIEW */) {
-        return await callOpenAI(identifier, openAiPayload, openAiConfig);
-      } else {
-        return await callOpenAIStream(
-          identifier,
-          openAiPayload,
-          openAiConfig,
-          chunkTimeoutMs
-        );
-      }
-    } catch (error2) {
-      logger_default.error(
-        identifier,
-        `Retry #${i} error: ${error2.message}`,
-        ((_a = error2.response) == null ? void 0 : _a.data) || error2.data || error2
-      );
-      const errorCode = (_b = error2.data) == null ? void 0 : _b.code;
-      if (errorCode === "content_policy_violation") {
-        logger_default.log(
-          identifier,
-          "Removing images due to content policy violation error"
-        );
-        openAiPayload.messages.forEach((message) => {
-          if (Array.isArray(message.content)) {
-            message.content = message.content.filter(
-              (content) => content.type === "text"
-            );
-          }
-        });
-      }
-      if (i >= 2 && (openAiConfig == null ? void 0 : openAiConfig.service) === "azure" && errorCode === "content_filter") {
-        logger_default.log(
-          identifier,
-          "Switching to OpenAI service due to content filter error"
-        );
-        openAiConfig.service = "openai";
-      }
-      if (i === 3) {
-        if ((openAiConfig == null ? void 0 : openAiConfig.service) === "azure") {
-          logger_default.log(
-            identifier,
-            "Switching to OpenAI service due to Azure service error"
-          );
-          openAiConfig.service = "openai";
-        }
-      }
-      if (i === 4) {
-        if (openAiPayload.tools) {
-          logger_default.log(
-            identifier,
-            "Switching to no tool choice due to persistent error"
-          );
-          openAiPayload.tool_choice = "none";
+function truncatePayload(payload) {
+  return JSON.stringify(
+    {
+      ...payload,
+      messages: payload.messages.map((message) => {
+        const truncatedMessage = { ...message };
+        if (typeof truncatedMessage.content === "string") {
+          truncatedMessage.content = truncatedMessage.content.slice(0, 100);
+        } else if (Array.isArray(truncatedMessage.content)) {
+          truncatedMessage.content = truncatedMessage.content.map((block) => {
+            if (block.type === "image_url") {
+              return {
+                ...block,
+                image_url: { url: block.image_url.url.slice(0, 100) }
+              };
+            }
+            return block;
+          });
         }
+        return truncatedMessage;
+      })
+    },
+    null,
+    2
+  );
+}
+async function getNormalizedBase64PNG(url, mime) {
+  const response = await axios.get(url, { responseType: "arraybuffer" });
+  let imageBuffer = Buffer.from(response.data);
+  let sharpOptions = {};
+  if (isHeicImage(url, mime)) {
+    const imageData = await decode({ buffer: imageBuffer });
+    imageBuffer = Buffer.from(imageData.data);
+    sharpOptions = {
+      raw: {
+        width: imageData.width,
+        height: imageData.height,
+        channels: 4
       }
-      await timeout(250);
-    }
+    };
   }
-  logger_default.error(
-    identifier,
-    `Failed to call OpenAI API after ${retries} attempts. Please lookup OpenAI status for active issues.`,
-    errorObj
-  );
-  throw new Error(
-    `${identifier}: Failed to call OpenAI API after ${retries} attempts. Please lookup OpenAI status for active issues.`
-  );
+  const resizedBuffer = await sharp(imageBuffer, sharpOptions).withMetadata().resize(1024, 1024, { fit: "inside", withoutEnlargement: true }).png().toBuffer();
+  return resizedBuffer.toString("base64");
 }
-async function callOpenAIStream(identifier, openAiPayload, openAiConfig, chunkTimeoutMs) {
-  var _a, _b, _c, _d, _e, _f, _g;
-  const functionNames = openAiPayload.tools ? new Set(openAiPayload.tools.map((fn) => fn.function.name)) : null;
-  if (!openAiConfig) {
-    openAiConfig = {
+var ALLOWED_IMAGE_MIME_TYPES = [
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp"
+];
+function buildOpenAIRequestConfig(identifier, model, config) {
+  if (!config) {
+    config = {
       service: "openai",
       apiKey: process.env.OPENAI_API_KEY,
       baseUrl: ""
     };
   }
-  let response;
-  const controller = new AbortController();
-  if (openAiConfig.service === "azure") {
-    logger_default.log(identifier, "Using Azure OpenAI service", openAiPayload.model);
-    const model = openAiPayload.model;
-    if (!openAiConfig.modelConfigMap) {
+  if (config.service === "azure") {
+    logger_default.log(identifier, "Using Azure OpenAI service:", model);
+    if (!config.modelConfigMap) {
       throw new Error(
         "OpenAI config modelConfigMap is required when using Azure OpenAI service."
       );
     }
-    const azureConfig = openAiConfig.modelConfigMap[model];
-    let endpoint;
-    if (azureConfig.endpoint) {
-      endpoint = `${azureConfig.endpoint}/openai/deployments/${azureConfig.deployment}/chat/completions?api-version=${azureConfig.apiVersion}`;
-    } else {
+    const azureConfig = config.modelConfigMap[model];
+    if (!(azureConfig == null ? void 0 : azureConfig.endpoint)) {
       throw new Error("Azure OpenAI endpoint is required in modelConfigMap.");
     }
-    logger_default.log(identifier, "Using endpoint", endpoint);
-    try {
-      const stringifiedPayload = JSON.stringify({
-        ...openAiPayload,
-        stream: true
-      });
-      const parsedPayload = JSON.parse(stringifiedPayload);
-    } catch (error2) {
-      logger_default.error(
-        identifier,
-        "Stream error: Azure OpenAI JSON parsing error:",
-        error2
-      );
-    }
-    response = await fetch(endpoint, {
-      method: "POST",
+    const endpoint = `${azureConfig.endpoint}/openai/deployments/${azureConfig.deployment}/chat/completions?api-version=${azureConfig.apiVersion}`;
+    logger_default.log(identifier, "Using endpoint:", endpoint);
+    return {
+      endpoint,
       headers: {
         "Content-Type": "application/json",
         "api-key": azureConfig.apiKey
-      },
-      body: JSON.stringify({
-        ...openAiPayload,
-        stream: true
-      }),
-      signal: controller.signal
-    });
-  } else {
-    logger_default.log(identifier, "Using OpenAI service", openAiPayload.model);
-    const endpoint = `https://api.openai.com/v1/chat/completions`;
-    if (openAiConfig.orgId) {
-      logger_default.log(identifier, "Using orgId", openAiConfig.orgId);
+      }
+    };
+  }
+  logger_default.log(identifier, "Using OpenAI service:", model);
+  if (config.orgId) {
+    logger_default.log(identifier, "Using orgId:", config.orgId);
+  }
+  return {
+    endpoint: "https://api.openai.com/v1/chat/completions",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.apiKey}`,
+      ...config.orgId ? { "OpenAI-Organization": config.orgId } : {}
     }
-    response = await fetch(endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${openAiConfig.apiKey}`,
-        ...openAiConfig.orgId ? { "OpenAI-Organization": openAiConfig.orgId } : {}
-      },
-      body: JSON.stringify({
-        ...openAiPayload,
-        stream: true
-      }),
-      signal: controller.signal
+  };
+}
+async function prepareOpenAIPayload(identifier, payload) {
+  var _a;
+  const preparedPayload = {
+    model: payload.model,
+    messages: [],
+    tools: (_a = payload.functions) == null ? void 0 : _a.map((fn) => ({
+      type: "function",
+      function: fn
+    })),
+    tool_choice: payload.function_call ? typeof payload.function_call === "string" ? payload.function_call : { type: "function", function: payload.function_call } : void 0
+  };
+  for (const message of payload.messages) {
+    const contentBlocks = [];
+    if (message.content) {
+      contentBlocks.push({ type: "text", text: message.content });
+    }
+    for (const file of message.files || []) {
+      if (ALLOWED_IMAGE_MIME_TYPES.includes(file.mimeType)) {
+        if (file.url) {
+          contentBlocks.push({
+            type: "image_url",
+            image_url: { url: file.url }
+          });
+          contentBlocks.push({ type: "text", text: `Image (${file.url})` });
+        } else if (file.data) {
+          contentBlocks.push({
+            type: "image_url",
+            image_url: { url: `data:${file.mimeType};base64,${file.data}` }
+          });
+        }
+      } else if (file.url) {
+        contentBlocks.push({
+          type: "text",
+          text: `File (${file.url})`
+        });
+      }
+    }
+    preparedPayload.messages.push({
+      role: message.role,
+      content: contentBlocks
     });
   }
-  if (response.body) {
-    let rawStreamedBody = "";
-    let paragraph = "";
-    let functionCallName = "";
-    let functionCallArgs = "";
-    const reader = response.body.getReader();
-    let partialChunk = "";
-    let abortTimeout = null;
-    const startAbortTimeout = () => {
-      abortTimeout && clearTimeout(abortTimeout);
-      return setTimeout(() => {
-        logger_default.error(identifier, `Stream timeout after ${chunkTimeoutMs}ms`);
-        controller.abort();
-      }, chunkTimeoutMs);
-    };
-    let chunkIndex = -1;
-    while (true) {
-      chunkIndex++;
-      const abortTimeout2 = startAbortTimeout();
-      const { done, value } = await reader.read();
-      clearTimeout(abortTimeout2);
-      if (done) {
-        logger_default.error(
-          identifier,
-          `Stream ended prematurely after ${chunkIndex + 1} chunks`
+  return preparedPayload;
+}
+async function callOpenAIStream(id, openAiPayload, openAiConfig, chunkTimeoutMs) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const functionNames = openAiPayload.tools ? new Set(openAiPayload.tools.map((fn) => fn.function.name)) : null;
+  const { endpoint, headers } = buildOpenAIRequestConfig(
+    id,
+    openAiPayload.model,
+    openAiConfig
+  );
+  const controller = new AbortController();
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ ...openAiPayload, stream: true }),
+    signal: controller.signal
+  });
+  if (!response.body) {
+    throw new Error("Stream error: no response body");
+  }
+  let paragraph = "";
+  let functionCallName = "";
+  let functionCallArgs = "";
+  const reader = response.body.getReader();
+  let partialChunk = "";
+  let chunkIndex = -1;
+  const createAbortTimeout = () => setTimeout(() => {
+    logger_default.error(id, `Stream timeout after ${chunkTimeoutMs}ms`);
+    controller.abort();
+  }, chunkTimeoutMs);
+  while (true) {
+    chunkIndex++;
+    const abortTimeout = createAbortTimeout();
+    const { done, value } = await reader.read();
+    clearTimeout(abortTimeout);
+    if (done) {
+      logger_default.error(id, `Stream ended prematurely after ${chunkIndex + 1} chunks`);
+      throw new Error("Stream error: ended prematurely");
+    }
+    let chunk = new TextDecoder().decode(value);
+    if (partialChunk) {
+      chunk = partialChunk + chunk;
+      partialChunk = "";
+    }
+    const jsonStrings = chunk.split(/^data: /gm);
+    for (const jsonString of jsonStrings) {
+      if (!jsonString)
+        continue;
+      if (jsonString.includes("[DONE]")) {
+        return parseStreamedResponse(
+          id,
+          paragraph,
+          functionCallName,
+          functionCallArgs,
+          functionNames
         );
-        throw new Error("Stream error: ended prematurely");
       }
-      let chunk = new TextDecoder().decode(value);
-      rawStreamedBody += chunk + "\n";
-      if (partialChunk) {
-        chunk = partialChunk + chunk;
-        partialChunk = "";
+      let json;
+      try {
+        json = JSON.parse(jsonString.trim());
+      } catch (e) {
+        partialChunk = jsonString;
+        continue;
       }
-      let jsonStrings = chunk.split(/^data: /gm);
-      for (let jsonString of jsonStrings) {
-        if (!jsonString) {
-          continue;
-        }
-        if (jsonString.includes("[DONE]")) {
-          try {
-            return parseStreamedResponse(
-              identifier,
-              paragraph,
-              functionCallName,
-              functionCallArgs,
-              functionNames
-            );
-          } catch (error2) {
-            logger_default.error(identifier, "Stream error: parsing response");
-            throw error2;
-          }
+      if (!((_a = json.choices) == null ? void 0 : _a.length)) {
+        if (json.error) {
+          logger_default.error(id, "Stream error from OpenAI:", json.error);
+          const error2 = new Error("Stream error: OpenAI error");
+          error2.data = json.error;
+          error2.requestBody = truncatePayload(openAiPayload);
+          throw error2;
         }
-        let json;
-        try {
-          json = JSON.parse(jsonString.trim());
-        } catch (error2) {
-          partialChunk = jsonString;
-          continue;
-        }
-        if (!json.choices || !json.choices.length) {
-          if (json.error) {
-            logger_default.error(identifier, "Stream error: OpenAI error:", json.error);
-            const error2 = new Error("Stream error: OpenAI error");
-            error2.data = json.error;
-            error2.requestBody = truncatePayload(openAiPayload);
-            throw error2;
-          }
-          if (chunkIndex !== 0) {
-            logger_default.error(identifier, "Stream error: no choices in JSON:", json);
-          }
-          continue;
-        }
-        const dToolCall = (_d = (_c = (_b = (_a = json.choices) == null ? void 0 : _a[0]) == null ? void 0 : _b.delta) == null ? void 0 : _c.tool_calls) == null ? void 0 : _d[0];
-        if (dToolCall) {
-          const toolCallIndex = dToolCall.index || 0;
-          if (toolCallIndex === 0) {
-            const dFn = dToolCall.function || {};
-            if (dFn.name)
-              functionCallName += dFn.name;
-            if (dFn.arguments)
-              functionCallArgs += dFn.arguments;
-          }
-        }
-        const text = (_g = (_f = (_e = json.choices) == null ? void 0 : _e[0]) == null ? void 0 : _f.delta) == null ? void 0 : _g.content;
-        if (text) {
-          paragraph += text;
+        if (chunkIndex !== 0) {
+          logger_default.error(id, "Stream error: no choices in JSON:", json);
         }
+        continue;
       }
+      const toolCall = (_d = (_c = (_b = json.choices[0]) == null ? void 0 : _b.delta) == null ? void 0 : _c.tool_calls) == null ? void 0 : _d[0];
+      if ((toolCall == null ? void 0 : toolCall.index) === 0 || (toolCall == null ? void 0 : toolCall.index) === void 0) {
+        if ((_e = toolCall == null ? void 0 : toolCall.function) == null ? void 0 : _e.name)
+          functionCallName += toolCall.function.name;
+        if ((_f = toolCall == null ? void 0 : toolCall.function) == null ? void 0 : _f.arguments)
+          functionCallArgs += toolCall.function.arguments;
+      }
+      const text = (_h = (_g = json.choices[0]) == null ? void 0 : _g.delta) == null ? void 0 : _h.content;
+      if (text)
+        paragraph += text;
     }
-  } else {
-    throw new Error("Stream error: no response body");
   }
 }
-async function callOpenAI(identifier, openAiPayload, openAiConfig) {
-  const functionNames = openAiPayload.tools ? new Set(openAiPayload.tools.map((fn) => fn.function.name)) : null;
-  if (!openAiConfig) {
-    openAiConfig = {
-      service: "openai",
-      apiKey: process.env.OPENAI_API_KEY,
-      baseUrl: ""
-    };
-  }
-  let response;
-  if (openAiConfig.service === "azure") {
-    logger_default.log(identifier, "Using Azure OpenAI service", openAiPayload.model);
-    const model = openAiPayload.model;
-    if (!openAiConfig.modelConfigMap) {
-      throw new Error(
-        "OpenAI config modelConfigMap is required when using Azure OpenAI service."
-      );
-    }
-    const azureConfig = openAiConfig.modelConfigMap[model];
-    let endpoint;
-    if (azureConfig.endpoint) {
-      endpoint = `${azureConfig.endpoint}/openai/deployments/${azureConfig.deployment}/chat/completions?api-version=${azureConfig.apiVersion}`;
-    } else {
-      throw new Error("Azure OpenAI endpoint is required in modelConfigMap.");
-    }
-    logger_default.log(identifier, "Using endpoint", endpoint);
-    try {
-      const stringifiedPayload = JSON.stringify({
-        ...openAiPayload,
-        stream: false
-      });
-      const parsedPayload = JSON.parse(stringifiedPayload);
-    } catch (error2) {
-      logger_default.error(identifier, "OpenAI JSON parsing error:", error2);
-      throw error2;
-    }
-    response = await fetch(endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "api-key": azureConfig.apiKey
-      },
-      body: JSON.stringify({
-        ...openAiPayload,
-        stream: false
-      })
-    });
-  } else {
-    logger_default.log(identifier, "Using OpenAI service", openAiPayload.model);
-    const endpoint = `https://api.openai.com/v1/chat/completions`;
-    if (openAiConfig.orgId) {
-      logger_default.log(identifier, "Using orgId", openAiConfig.orgId);
-    }
-    response = await fetch(endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${openAiConfig.apiKey}`,
-        ...openAiConfig.orgId ? { "OpenAI-Organization": openAiConfig.orgId } : {}
-      },
-      body: JSON.stringify({
-        ...openAiPayload,
-        stream: false
-      })
-    });
-  }
+async function callOpenAI(id, openAiPayload, openAiConfig) {
+  var _a;
+  const { endpoint, headers } = buildOpenAIRequestConfig(
+    id,
+    openAiPayload.model,
+    openAiConfig
+  );
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ ...openAiPayload, stream: false })
+  });
   if (!response.ok) {
     const errorData = await response.json();
-    logger_default.error(identifier, "OpenAI API error:", errorData);
+    logger_default.error(id, "OpenAI API error:", errorData);
     throw new Error(`OpenAI API Error: ${errorData.error.message}`);
   }
   const data = await response.json();
-  if (!data.choices || !data.choices.length) {
+  if (!((_a = data.choices) == null ? void 0 : _a.length)) {
     if (data.error) {
-      logger_default.error(identifier, "OpenAI error:", data.error);
-      throw new Error("OpenAI error: " + data.error.message);
+      logger_default.error(id, "OpenAI error:", data.error);
+      throw new Error(`OpenAI error: ${data.error.message}`);
     }
     throw new Error("OpenAI error: No choices returned.");
   }
@@ -480,94 +431,167 @@ async function callOpenAI(identifier, openAiPayload, openAiConfig) {
     files: []
   };
 }
-function truncatePayload(payload) {
-  return JSON.stringify(
+async function callOpenAiWithRetries(id, openAiPayload, openAiConfig, retries = 5, chunkTimeoutMs = 15e3) {
+  logger_default.log(
+    id,
+    "Calling OpenAI API with retries:",
+    openAiConfig == null ? void 0 : openAiConfig.service,
+    openAiPayload.model
+  );
+  const useStreaming = openAiPayload.model !== "o1-mini" /* O1_MINI */ && openAiPayload.model !== "o1-preview" /* O1_PREVIEW */;
+  return withRetries(
+    id,
+    "OpenAI",
+    async () => {
+      if (useStreaming) {
+        return callOpenAIStream(id, openAiPayload, openAiConfig, chunkTimeoutMs);
+      } else {
+        return callOpenAI(id, openAiPayload, openAiConfig);
+      }
+    },
     {
-      ...payload,
-      messages: payload.messages.map((message) => {
-        if (typeof message.content === "string") {
-          message.content = message.content.slice(0, 100);
-        } else if (Array.isArray(message.content)) {
-          message.content = message.content.map((block) => {
-            if (block.type === "image_url") {
-              block.image_url.url = block.image_url.url.slice(0, 100);
+      retries,
+      baseDelayMs: 250,
+      onError: (error2, attempt) => {
+        var _a, _b;
+        logger_default.error(
+          id,
+          `Retry #${attempt} error: ${error2.message}`,
+          ((_a = error2.response) == null ? void 0 : _a.data) || error2.data || error2
+        );
+        if (((_b = error2.data) == null ? void 0 : _b.code) === "content_policy_violation") {
+          logger_default.log(id, "Removing images due to content policy violation");
+          openAiPayload.messages.forEach((message) => {
+            if (Array.isArray(message.content)) {
+              message.content = message.content.filter(
+                (content) => content.type === "text"
+              );
             }
-            return block;
           });
         }
-        return message;
-      })
-    },
-    null,
-    2
+      }
+    }
   );
 }
-async function callAnthropicWithRetries(identifier, AiPayload, AiConfig, attempts = 5) {
-  var _a, _b, _c, _d;
-  logger_default.log(identifier, "Calling Anthropic API with retries");
-  let lastResponse;
-  for (let i = 0; i < attempts; i++) {
-    try {
-      lastResponse = await callAnthropic(identifier, AiPayload, AiConfig);
-      return lastResponse;
-    } catch (e) {
-      logger_default.error(
-        identifier,
-        `Retry #${i} error: ${e.message}`,
-        ((_a = e.response) == null ? void 0 : _a.data) || e
-      );
-      if (((_d = (_c = (_b = e.response) == null ? void 0 : _b.data) == null ? void 0 : _c.error) == null ? void 0 : _d.type) === "rate_limit_error") {
+function jigAnthropicMessages(messages) {
+  var _a, _b;
+  let jiggedMessages = messages.slice();
+  if (((_a = jiggedMessages[0]) == null ? void 0 : _a.role) !== "user") {
+    jiggedMessages = [{ role: "user", content: "..." }, ...jiggedMessages];
+  }
+  jiggedMessages = jiggedMessages.reduce((acc, message) => {
+    if (acc.length === 0)
+      return [message];
+    const lastMessage = acc[acc.length - 1];
+    if (lastMessage.role === message.role) {
+      const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [{ type: "text", text: lastMessage.content }];
+      const newContent = Array.isArray(message.content) ? message.content : [{ type: "text", text: message.content }];
+      lastMessage.content = [
+        ...lastContent,
+        { type: "text", text: "\n\n---\n\n" },
+        ...newContent
+      ];
+      return acc;
+    }
+    if (typeof message.content === "string") {
+      message.content = [{ type: "text", text: message.content }];
+    }
+    return [...acc, message];
+  }, []);
+  if (((_b = jiggedMessages[jiggedMessages.length - 1]) == null ? void 0 : _b.role) === "assistant") {
+    jiggedMessages.push({ role: "user", content: "..." });
+  }
+  return jiggedMessages;
+}
+async function prepareAnthropicPayload(_identifier, payload) {
+  const preparedPayload = {
+    model: payload.model,
+    messages: [],
+    functions: payload.functions,
+    temperature: payload.temperature
+  };
+  for (const message of payload.messages) {
+    if (message.role === "system") {
+      preparedPayload.system = message.content;
+      continue;
+    }
+    const contentBlocks = [];
+    if (message.content) {
+      contentBlocks.push({ type: "text", text: message.content });
+    }
+    for (const file of message.files || []) {
+      if (ALLOWED_IMAGE_MIME_TYPES.includes(file.mimeType)) {
+        if (file.url) {
+          contentBlocks.push({
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: "image/png",
+              data: await getNormalizedBase64PNG(file.url, file.mimeType)
+            }
+          });
+          contentBlocks.push({ type: "text", text: `Image (${file.url})` });
+        } else if (file.data) {
+          contentBlocks.push({
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: file.mimeType,
+              data: file.data
+            }
+          });
+        }
+      } else if (file.url) {
+        contentBlocks.push({
+          type: "text",
+          text: `File (${file.url})`
+        });
       }
-      await timeout(125 * i);
     }
+    preparedPayload.messages.push({
+      role: message.role,
+      content: contentBlocks
+    });
   }
-  const error2 = new Error(
-    `Failed to call Anthropic API after ${attempts} attempts`
-  );
-  error2.response = lastResponse;
-  throw error2;
+  return preparedPayload;
 }
-async function callAnthropic(identifier, AiPayload, AiConfig) {
-  var _a, _b;
-  const anthropicMessages = jigAnthropicMessages(AiPayload.messages);
+async function callAnthropic(id, payload, config) {
+  var _a;
+  const anthropicMessages = jigAnthropicMessages(payload.messages);
+  const tools = (_a = payload.functions) == null ? void 0 : _a.map((f) => ({
+    ...f,
+    input_schema: f.parameters,
+    parameters: void 0
+  }));
   let data;
-  let response;
-  if ((AiConfig == null ? void 0 : AiConfig.service) === "bedrock") {
+  if ((config == null ? void 0 : config.service) === "bedrock") {
     const AWS_REGION = "us-east-1";
     const MODEL_ID = "anthropic.claude-3-haiku-20240307-v1:0";
     const client = new BedrockRuntimeClient({ region: AWS_REGION });
-    const payload = {
+    const bedrockPayload = {
       anthropic_version: "bedrock-2023-05-31",
       max_tokens: 4096,
       messages: anthropicMessages,
-      tools: (_a = AiPayload.functions) == null ? void 0 : _a.map((f) => ({
-        ...f,
-        input_schema: f.parameters,
-        parameters: void 0
-      }))
+      tools
     };
-    const response2 = await client.send(
+    const response = await client.send(
       new InvokeModelCommand({
         contentType: "application/json",
-        body: JSON.stringify(payload),
+        body: JSON.stringify(bedrockPayload),
         modelId: MODEL_ID
       })
     );
-    const decodedResponseBody = new TextDecoder().decode(response2.body);
+    const decodedResponseBody = new TextDecoder().decode(response.body);
     data = JSON.parse(decodedResponseBody);
   } else {
-    const response2 = await axios.post(
+    const response = await axios.post(
       "https://api.anthropic.com/v1/messages",
       {
-        model: AiPayload.model,
+        model: payload.model,
         messages: anthropicMessages,
-        tools: (_b = AiPayload.functions) == null ? void 0 : _b.map((f) => ({
-          ...f,
-          input_schema: f.parameters,
-          parameters: void 0
-        })),
-        temperature: AiPayload.temperature,
-        system: AiPayload.system,
+        tools,
+        temperature: payload.temperature,
+        system: payload.system,
         max_tokens: 4096
       },
       {
@@ -580,120 +604,64 @@ async function callAnthropic(identifier, AiPayload, AiConfig) {
         timeout: 6e4
       }
     );
-    data = response2.data;
+    data = response.data;
   }
   const answers = data.content;
-  if (!answers[0]) {
-    logger_default.error(identifier, "Missing answer in Anthropic API:", data);
+  if (!(answers == null ? void 0 : answers[0])) {
+    logger_default.error(id, "Missing answer in Anthropic API response:", data);
     throw new Error("Missing answer in Anthropic API");
   }
   let textResponse = "";
-  let functionCalls = [];
+  const functionCalls = [];
   for (const answer of answers) {
     if (!answer.type) {
-      logger_default.error(identifier, "Missing answer type in Anthropic API:", data);
+      logger_default.error(id, "Missing answer type in Anthropic API response:", data);
       throw new Error("Missing answer type in Anthropic API");
     }
-    let text = "";
     if (answer.type === "text") {
-      text = answer.text.replace(/<thinking>.*?<\/thinking>/gs, "").replace(/<answer>|<\/answer>/gs, "").trim();
+      let text = answer.text.replace(/<thinking>.*?<\/thinking>/gs, "").replace(/<answer>|<\/answer>/gs, "").trim();
       if (!text) {
         text = answer.text.replace(
           /<thinking>|<\/thinking>|<answer>|<\/answer>/gs,
           ""
         );
-        logger_default.log(
-          identifier,
-          "No text in answer, returning text within tags:",
-          text
-        );
+        logger_default.log(id, "No text in answer, returning text within tags:", text);
       }
-      if (textResponse) {
-        textResponse += `
+      textResponse = textResponse ? `${textResponse}
 
-${text}`;
-      } else {
-        textResponse = text;
-      }
+${text}` : text;
     } else if (answer.type === "tool_use") {
-      const call = {
+      functionCalls.push({
         name: answer.name,
         arguments: answer.input
-      };
-      functionCalls.push(call);
+      });
     }
   }
   if (!textResponse && !functionCalls.length) {
-    logger_default.error(
-      identifier,
-      "Missing text & fns in Anthropic API response:",
-      data
-    );
-    throw new Error("Missing text & fns in Anthropic API response");
+    logger_default.error(id, "Missing text & functions in Anthropic API response:", data);
+    throw new Error("Missing text & functions in Anthropic API response");
   }
   return {
     role: "assistant",
     content: textResponse,
-    function_call: functionCalls[0],
+    function_call: functionCalls[0] || null,
     files: []
   };
 }
-function jigAnthropicMessages(messages) {
-  var _a, _b;
-  let jiggedMessages = messages.slice();
-  if (((_a = jiggedMessages[0]) == null ? void 0 : _a.role) !== "user") {
-    jiggedMessages = [
-      {
-        role: "user",
-        content: "..."
-      },
-      ...jiggedMessages
-    ];
-  }
-  jiggedMessages = jiggedMessages.reduce((acc, message) => {
-    if (acc.length === 0) {
-      return [message];
-    }
-    const lastMessage = acc[acc.length - 1];
-    if (lastMessage.role === message.role) {
-      const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [{ type: "text", text: lastMessage.content }];
-      const newContent = Array.isArray(message.content) ? message.content : [{ type: "text", text: message.content }];
-      lastMessage.content = [
-        ...lastContent,
-        { type: "text", text: "\n\n---\n\n" },
-        ...newContent
-      ];
-      return acc;
-    }
-    if (typeof message.content === "string") {
-      message.content = [{ type: "text", text: message.content }];
-    }
-    return [...acc, message];
-  }, []);
-  if (((_b = jiggedMessages[jiggedMessages.length - 1]) == null ? void 0 : _b.role) === "assistant") {
-    jiggedMessages.push({
-      role: "user",
-      content: "..."
-    });
-  }
-  return jiggedMessages;
+async function callAnthropicWithRetries(id, payload, config, retries = 5) {
+  return withRetries(id, "Anthropic", () => callAnthropic(id, payload, config), {
+    retries
+  });
 }
 function jigGoogleMessages(messages) {
   var _a, _b;
   let jiggedMessages = messages.slice();
   if (((_a = jiggedMessages[0]) == null ? void 0 : _a.role) === "model") {
-    jiggedMessages = [
-      {
-        role: "user",
-        parts: [{ text: "..." }]
-      },
-      ...jiggedMessages
-    ];
+    jiggedMessages = [{ role: "user", parts: [{ text: "..." }] }, ...jiggedMessages];
   }
   jiggedMessages = jiggedMessages.reduce((acc, message) => {
-    if (acc.length === 0) {
+    if (acc.length === 0)
       return [message];
-    }
     const lastMessage = acc[acc.length - 1];
     if (lastMessage.role === message.role) {
       lastMessage.parts = [...lastMessage.parts, ...message.parts];
@@ -702,15 +670,11 @@ function jigGoogleMessages(messages) {
     return [...acc, message];
   }, []);
   if (((_b = jiggedMessages[jiggedMessages.length - 1]) == null ? void 0 : _b.role) === "model") {
-    jiggedMessages.push({
-      role: "user",
-      parts: [{ text: "..." }]
-    });
+    jiggedMessages.push({ role: "user", parts: [{ text: "..." }] });
   }
   return jiggedMessages;
 }
-async function prepareGoogleAIPayload(payload) {
-  var _a;
+async function prepareGoogleAIPayload(_identifier, payload) {
   const preparedPayload = {
     model: payload.model,
     messages: [],
@@ -718,7 +682,6 @@ async function prepareGoogleAIPayload(payload) {
       functionDeclarations: payload.functions.map((fn) => ({
         name: fn.name,
         parameters: {
-          // Google puts their description in the parameters object rather than in a top-level field
           description: fn.description,
           ...fn.parameters
         }
@@ -730,61 +693,47 @@ async function prepareGoogleAIPayload(payload) {
       preparedPayload.systemInstruction = message.content;
       continue;
     }
-    const googleAIContentParts = [];
+    const parts = [];
     if (message.content) {
-      googleAIContentParts.push({
-        text: message.content
-      });
+      parts.push({ text: message.content });
     }
     for (const file of message.files || []) {
-      if (!((_a = file.mimeType) == null ? void 0 : _a.startsWith("image"))) {
-        logger_default.warn(
-          "payload",
-          "Google AI API does not support non-image file types. Skipping file."
-        );
-        continue;
-      }
-      if (file.url) {
-        googleAIContentParts.push({
-          inlineData: {
-            mimeType: "image/png",
-            data: await getNormalizedBase64PNG(file.url, file.mimeType)
-          }
-        });
-        googleAIContentParts.push({
-          text: `Image URL: ${file.url}`
-        });
-      } 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"
-          );
+      if (ALLOWED_IMAGE_MIME_TYPES.includes(file.mimeType)) {
+        if (file.url) {
+          parts.push({
+            inlineData: {
+              mimeType: "image/png",
+              data: await getNormalizedBase64PNG(file.url, file.mimeType)
+            }
+          });
+          parts.push({ text: `Image (${file.url})` });
+        } else if (file.data) {
+          parts.push({
+            inlineData: {
+              mimeType: file.mimeType,
+              data: file.data
+            }
+          });
         }
-        googleAIContentParts.push({
-          inlineData: {
-            mimeType: file.mimeType,
-            data: file.data
-          }
+      } else if (file.url) {
+        parts.push({
+          text: `File (${file.url})`
         });
       }
     }
     preparedPayload.messages.push({
       role: message.role === "assistant" ? "model" : message.role,
-      parts: googleAIContentParts
+      parts
     });
   }
   return preparedPayload;
 }
-async function callGoogleAI(identifier, payload) {
-  var _a, _b, _c, _d;
+async function callGoogleAI(id, payload) {
+  var _a, _b, _c, _d, _e, _f;
   const googleMessages = jigGoogleMessages(payload.messages);
   const history = googleMessages.slice(0, -1);
   const lastMessage = googleMessages.slice(-1)[0];
-  const genAI = new GoogleGenAI({
-    apiKey: process.env.GEMINI_API_KEY
-  });
+  const genAI = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
   const chat = genAI.chats.create({
     model: payload.model,
     history,
@@ -794,296 +743,84 @@ async function callGoogleAI(identifier, payload) {
       systemInstruction: payload.systemInstruction
     }
   });
-  const response = await chat.sendMessage({
-    message: lastMessage.parts
-  });
+  const response = await chat.sendMessage({ message: lastMessage.parts });
   let text = "";
   const files = [];
   for (const part of ((_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) || []) {
-    if (part.text) {
+    if (part.text)
       text += part.text;
-    }
-    if (part.inlineData) {
-      const imageData = part.inlineData.data;
-      if (imageData) {
-        files.push({
-          mimeType: "image/png",
-          data: imageData
-        });
-      }
+    if ((_d = part.inlineData) == null ? void 0 : _d.data) {
+      files.push({ mimeType: "image/png", data: part.inlineData.data });
     }
   }
-  const functionCalls = response.functionCalls;
-  const parsedFunctionCalls = functionCalls == null ? void 0 : functionCalls.map((fc) => {
+  const functionCalls = (_e = response.functionCalls) == null ? void 0 : _e.map((fc) => {
     var _a2, _b2;
     return {
       name: (_a2 = fc.name) != null ? _a2 : "",
       arguments: (_b2 = fc.args) != null ? _b2 : {}
     };
   });
-  if (!text && !(parsedFunctionCalls == null ? void 0 : parsedFunctionCalls.length) && !files.length) {
-    const candidate = (_d = response.candidates) == null ? void 0 : _d[0];
+  if (!text && !(functionCalls == null ? void 0 : functionCalls.length) && !files.length) {
+    const candidate = (_f = response.candidates) == null ? void 0 : _f[0];
     const finishReason = candidate == null ? void 0 : candidate.finishReason;
-    const safetyRatings = candidate == null ? void 0 : candidate.safetyRatings;
-    const usageMetadata = response.usageMetadata;
-    const modelVersion = response.modelVersion;
-    logger_default.error(
-      identifier,
-      "Missing text & fns in Google AI API response:",
-      {
-        finishReason,
-        safetyRatings,
-        usageMetadata,
-        modelVersion,
-        candidateContent: candidate == null ? void 0 : candidate.content,
-        promptFeedback: response.promptFeedback,
-        fullResponse: JSON.stringify(response)
-      }
-    );
-    let errorMessage = "Missing text & fns in Google AI API response";
+    logger_default.error(id, "Missing text & functions in Google AI API response:", {
+      finishReason,
+      safetyRatings: candidate == null ? void 0 : candidate.safetyRatings,
+      usageMetadata: response.usageMetadata,
+      modelVersion: response.modelVersion,
+      candidateContent: candidate == null ? void 0 : candidate.content,
+      promptFeedback: response.promptFeedback
+    });
+    let errorMessage = "Missing text & functions in Google AI API response";
     if (finishReason) {
-      errorMessage += `: finishReason=${finishReason}`;
-      if (finishReason === "MALFORMED_FUNCTION_CALL") {
-        errorMessage += " (Google could not generate valid function call arguments)";
-      } else if (finishReason === "SAFETY") {
-        errorMessage += " (blocked by safety filters)";
-      } else if (finishReason === "RECITATION") {
-        errorMessage += " (blocked due to recitation)";
-      } else if (finishReason === "MAX_TOKENS") {
-        errorMessage += " (response truncated due to max tokens)";
-      }
+      const reasonDescriptions = {
+        MALFORMED_FUNCTION_CALL: "(Google could not generate valid function call arguments)",
+        SAFETY: "(blocked by safety filters)",
+        RECITATION: "(blocked due to recitation)",
+        MAX_TOKENS: "(response truncated due to max tokens)"
+      };
+      errorMessage += `: finishReason=${finishReason} ${reasonDescriptions[finishReason] || ""}`;
     }
     const error2 = new Error(errorMessage);
     error2.finishReason = finishReason;
-    error2.safetyRatings = safetyRatings;
-    error2.usageMetadata = usageMetadata;
-    error2.modelVersion = modelVersion;
-    error2.candidateContent = candidate == null ? void 0 : candidate.content;
-    error2.promptFeedback = response.promptFeedback;
+    error2.safetyRatings = candidate == null ? void 0 : candidate.safetyRatings;
+    error2.usageMetadata = response.usageMetadata;
     throw error2;
   }
   return {
     role: "assistant",
     content: text || null,
     files,
-    function_call: (parsedFunctionCalls == null ? void 0 : parsedFunctionCalls[0]) || null
+    function_call: (functionCalls == null ? void 0 : functionCalls[0]) || null
   };
 }
-async function callGoogleAIWithRetries(identifier, payload, retries = 5) {
-  logger_default.log(identifier, "Calling Google AI API with retries");
-  let lastError;
-  for (let i = 0; i < retries; i++) {
-    try {
-      return await callGoogleAI(identifier, payload);
-    } catch (e) {
-      lastError = e;
+async function callGoogleAIWithRetries(id, payload, retries = 5) {
+  return withRetries(id, "Google AI", () => callGoogleAI(id, payload), {
+    retries,
+    onError: (error2, attempt) => {
       const errorDetails = {
-        message: e.message,
-        finishReason: e.finishReason,
-        modelVersion: e.modelVersion
+        message: error2.message,
+        finishReason: error2.finishReason,
+        modelVersion: error2.modelVersion
       };
-      if (e.safetyRatings) {
-        errorDetails.safetyRatings = e.safetyRatings;
-      }
-      if (e.usageMetadata) {
-        errorDetails.usageMetadata = e.usageMetadata;
-      }
-      if (e.promptFeedback) {
-        errorDetails.promptFeedback = e.promptFeedback;
-      }
-      if (e.status || e.statusText) {
-        errorDetails.httpStatus = e.status;
-        errorDetails.httpStatusText = e.statusText;
-      }
-      if (e.code) {
-        errorDetails.errorCode = e.code;
-      }
-      if (e.details) {
-        errorDetails.errorDetails = e.details;
-      }
-      logger_default.error(identifier, `Retry #${i} error: ${e.message}`, errorDetails);
-      if (e.finishReason === "MALFORMED_FUNCTION_CALL" && i >= 3) {
-        logger_default.log(
-          identifier,
-          "Removing tools due to persistent MALFORMED_FUNCTION_CALL errors"
-        );
-        payload.tools = void 0;
-      }
-      await timeout(125 * i);
+      if (error2.safetyRatings)
+        errorDetails.safetyRatings = error2.safetyRatings;
+      if (error2.usageMetadata)
+        errorDetails.usageMetadata = error2.usageMetadata;
+      if (error2.promptFeedback)
+        errorDetails.promptFeedback = error2.promptFeedback;
+      if (error2.status)
+        errorDetails.httpStatus = error2.status;
+      if (error2.code)
+        errorDetails.errorCode = error2.code;
+      if (error2.details)
+        errorDetails.errorDetails = error2.details;
+      logger_default.error(id, `Retry #${attempt} error: ${error2.message}`, errorDetails);
     }
-  }
-  const error2 = new Error(
-    `Failed to call Google AI API after ${retries} attempts`
-  );
-  error2.cause = lastError;
-  error2.finishReason = lastError == null ? void 0 : lastError.finishReason;
-  error2.usageMetadata = lastError == null ? void 0 : lastError.usageMetadata;
-  error2.safetyRatings = lastError == null ? void 0 : lastError.safetyRatings;
-  throw error2;
-}
-async function callWithRetries(identifier, aiPayload, aiConfig, retries = 5, chunkTimeoutMs = 15e3) {
-  const id = identifier;
-  if (isAnthropicPayload(aiPayload)) {
-    return await callAnthropicWithRetries(
-      id,
-      await prepareAnthropicPayload(aiPayload),
-      aiConfig,
-      retries
-    );
-  } else if (isOpenAiPayload(aiPayload)) {
-    return await callOpenAiWithRetries(
-      id,
-      await prepareOpenAIPayload(aiPayload),
-      aiConfig,
-      retries,
-      chunkTimeoutMs
-    );
-  } else if (isGroqPayload(aiPayload)) {
-    return await callGroqWithRetries(id, await prepareGroqPayload(aiPayload));
-  } else if (isGoogleAIPayload(aiPayload)) {
-    return await callGoogleAIWithRetries(
-      id,
-      await prepareGoogleAIPayload(aiPayload),
-      retries
-    );
-  } else {
-    throw new Error("Invalid AI payload: Unknown model type.");
-  }
-}
-function isAnthropicPayload(payload) {
-  return Object.values(ClaudeModel).includes(payload.model);
-}
-async function prepareAnthropicPayload(payload) {
-  var _a;
-  const preparedPayload = {
-    model: payload.model,
-    messages: [],
-    functions: payload.functions,
-    temperature: payload.temperature
-  };
-  for (const message of payload.messages) {
-    const anthropicContentBlocks = [];
-    if (message.role === "system") {
-      preparedPayload.system = message.content;
-      continue;
-    }
-    if (message.content) {
-      anthropicContentBlocks.push({
-        type: "text",
-        text: message.content
-      });
-    }
-    for (const file of message.files || []) {
-      if (!((_a = file.mimeType) == null ? void 0 : _a.startsWith("image"))) {
-        logger_default.warn(
-          "payload",
-          "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);
-}
-async function prepareOpenAIPayload(payload) {
-  var _a;
-  const preparedPayload = {
-    model: payload.model,
-    messages: [],
-    tools: (_a = payload.functions) == null ? void 0 : _a.map((fn) => ({
-      type: "function",
-      function: fn
-    })),
-    tool_choice: payload.function_call ? typeof payload.function_call === "string" ? payload.function_call : {
-      type: "function",
-      function: payload.function_call
-    } : void 0
-  };
-  for (const message of payload.messages) {
-    const openAIContentBlocks = [];
-    if (message.content) {
-      openAIContentBlocks.push({
-        type: "text",
-        text: message.content
-      });
-    }
-    const allowedFileMimeTypes = [
-      "image/png",
-      "image/jpeg",
-      "image/gif",
-      "image/webp"
-    ];
-    for (const file of message.files || []) {
-      if (allowedFileMimeTypes.includes(file.mimeType)) {
-        if (file.url) {
-          openAIContentBlocks.push({
-            type: "image_url",
-            image_url: {
-              url: file.url
-            }
-          });
-          openAIContentBlocks.push({
-            type: "text",
-            text: `Image URL: ${file.url}`
-          });
-        } else if (file.data) {
-          openAIContentBlocks.push({
-            type: "image_url",
-            image_url: {
-              url: `data:${file.mimeType};base64,${file.data}`
-            }
-          });
-        }
-      } else {
-        logger_default.warn(
-          "payload",
-          "Skipping file in message. File or image type not supported by OpenAI API:",
-          file.mimeType
-        );
-      }
-    }
-    preparedPayload.messages.push({
-      role: message.role,
-      content: openAIContentBlocks
-    });
-  }
-  return preparedPayload;
+  });
 }
-function isGroqPayload(payload) {
-  return Object.values(GroqModel).includes(payload.model);
+function normalizeMessageContent(content) {
+  return Array.isArray(content) ? content.map((c) => c.type === "text" ? c.text : `[${c.type}]`).join("\n") : content;
 }
 function prepareGroqPayload(payload) {
   var _a;
@@ -1097,20 +834,12 @@ function prepareGroqPayload(payload) {
       type: "function",
       function: fn
     })),
-    tool_choice: payload.function_call ? typeof payload.function_call === "string" ? payload.function_call : {
-      type: "function",
-      function: payload.function_call
-    } : void 0,
+    tool_choice: payload.function_call ? typeof payload.function_call === "string" ? payload.function_call : { type: "function", function: payload.function_call } : void 0,
     temperature: payload.temperature
   };
 }
-function normalizeMessageContent(content) {
-  return Array.isArray(content) ? content.map((c) => c.type === "text" ? c.text : `[${c.type}]`).join("\n") : content;
-}
-function isGoogleAIPayload(payload) {
-  return Object.values(GeminiModel).includes(payload.model);
-}
-async function callGroq(identifier, payload) {
+async function callGroq(id, payload) {
+  var _a, _b;
   const response = await axios.post(
     "https://api.groq.com/openai/v1/chat/completions",
     payload,
@@ -1121,15 +850,13 @@ async function callGroq(identifier, payload) {
       }
     }
   );
-  const data = response.data;
-  const answer = data.choices[0].message;
+  const answer = (_a = response.data.choices[0]) == null ? void 0 : _a.message;
   if (!answer) {
-    logger_default.error(identifier, "Missing answer in Groq API:", data);
+    logger_default.error(id, "Missing answer in Groq API response:", response.data);
     throw new Error("Missing answer in Groq API");
   }
-  const textResponse = answer.content || null;
   let functionCall = null;
-  if (answer.tool_calls && answer.tool_calls.length) {
+  if ((_b = answer.tool_calls) == null ? void 0 : _b.length) {
     const toolCall = answer.tool_calls[0];
     functionCall = {
       name: toolCall.function.name,
@@ -1138,51 +865,55 @@ async function callGroq(identifier, payload) {
   }
   return {
     role: "assistant",
-    content: textResponse,
+    content: answer.content || null,
     function_call: functionCall,
     files: []
   };
 }
-async function callGroqWithRetries(identifier, payload, retries = 5) {
-  var _a;
-  logger_default.log(identifier, "Calling Groq API with retries");
-  let lastResponse;
-  for (let i = 0; i < retries; i++) {
-    try {
-      lastResponse = await callGroq(identifier, payload);
-      return lastResponse;
-    } catch (e) {
-      logger_default.error(
-        identifier,
-        `Retry #${i} error: ${e.message}`,
-        ((_a = e.response) == null ? void 0 : _a.data) || e
-      );
-      await timeout(125 * i);
-    }
-  }
-  const error2 = new Error(
-    `Failed to call Groq API after ${retries} attempts`
-  );
-  error2.response = lastResponse;
-  throw error2;
+async function callGroqWithRetries(id, payload, retries = 5) {
+  return withRetries(id, "Groq", () => callGroq(id, payload), { retries });
 }
-async function getNormalizedBase64PNG(url, mime) {
-  const response = await axios.get(url, { responseType: "arraybuffer" });
-  let imageBuffer = Buffer.from(response.data);
-  let sharpOptions = {};
-  if (isHeicImage(url, mime)) {
-    const imageData = await decode({ buffer: imageBuffer });
-    imageBuffer = Buffer.from(imageData.data);
-    sharpOptions = {
-      raw: {
-        width: imageData.width,
-        height: imageData.height,
-        channels: 4
-      }
-    };
+function isAnthropicPayload(payload) {
+  return Object.values(ClaudeModel).includes(payload.model);
+}
+function isOpenAiPayload(payload) {
+  return Object.values(GPTModel).includes(payload.model);
+}
+function isGroqPayload(payload) {
+  return Object.values(GroqModel).includes(payload.model);
+}
+function isGoogleAIPayload(payload) {
+  return Object.values(GeminiModel).includes(payload.model);
+}
+async function callWithRetries(id, aiPayload, aiConfig, retries = 5, chunkTimeoutMs = 15e3) {
+  if (isAnthropicPayload(aiPayload)) {
+    return callAnthropicWithRetries(
+      id,
+      await prepareAnthropicPayload(id, aiPayload),
+      aiConfig,
+      retries
+    );
   }
-  const resizedBuffer = await sharp(imageBuffer, sharpOptions).withMetadata().resize(1024, 1024, { fit: "inside", withoutEnlargement: true }).png().toBuffer();
-  return resizedBuffer.toString("base64");
+  if (isOpenAiPayload(aiPayload)) {
+    return callOpenAiWithRetries(
+      id,
+      await prepareOpenAIPayload(id, aiPayload),
+      aiConfig,
+      retries,
+      chunkTimeoutMs
+    );
+  }
+  if (isGroqPayload(aiPayload)) {
+    return callGroqWithRetries(id, prepareGroqPayload(aiPayload), retries);
+  }
+  if (isGoogleAIPayload(aiPayload)) {
+    return callGoogleAIWithRetries(
+      id,
+      await prepareGoogleAIPayload(id, aiPayload),
+      retries
+    );
+  }
+  throw new Error("Invalid AI payload: Unknown model type.");
 }
 export {
   ClaudeModel,