apexify.js 3.3.10 → 3.3.11

package/lib/ai/ApexAI.ts

@@ -10,16 +10,16 @@ import {
   typeWriter,
   readImage,
 } from "./utils";
+import axios from "axios";
 import { 
   ModalBuilder,
   TextInputBuilder,
   TextInputStyle,
-  ActionRowBuilder
+  ActionRowBuilder 
 } from "discord.js";
 import { filters } from "./buttons/tools";
 import { imageTools } from "./buttons/drawMenu";
 
-
 export interface Options {
     voice?: {
        textVoice?:{
@@ -52,7 +52,7 @@ export interface Options {
         };
     };
     others?: {
-        messageType: {
+        messageType?: {
             type: string;
             intialContent: string;
         };
@@ -405,6 +405,7 @@ export async function ApexAI (message: any, aiOptions: Options) {
                 await typeWriter(message.channel, part, speed, delay);
               }
           }
+
       } else {
           if (response.length <= 2000) {
               await message.reply({
@@ -477,139 +478,106 @@ export async function ApexAI (message: any, aiOptions: Options) {
 }
 
 export async function gemmaAi_4(prompt: string) {
-  try {
-    const response = await fetch('https://api-inference.huggingface.co/models/google/gemma-7b-it', {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'Authorization': 'Bearer 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'
-        },
-        body: JSON.stringify({ inputs: prompt })
-    });
-
-    if (!response.ok) {
-        throw new Error('Network response was not ok');
+    try {
+        const response = await axios.post('https://api-inference.huggingface.co/models/google/gemma-7b-it', { inputs: prompt }, {
+            headers: { 'Authorization': `Bearer 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` }
+        });
+        return response.data[0].generated_text;
+    } catch (error: any) {
+        console.error('Error fetching response:', error.message);
+        return null;
     }
-
-    const responseData = await response.json();
-    return responseData[0].generated_text;
-  } catch (error: any) {
-    console.error('Error fetching response:', error.message);
-    return null;
-  }
 }
 
 export async function gemmaAi_3(prompt: string) {
-  try {
-      const response = await fetch('https://api-inference.huggingface.co/models/google/gemma-2b-it', {
-          method: 'POST',
-          headers: {
-              'Content-Type': 'application/json',
-              'Authorization': 'Bearer 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'
-          },
-          body: JSON.stringify({ inputs: prompt })
-      });
-
-      if (!response.ok) {
-          throw new Error('Network response was not ok');
-      }
-
-      const responseData = await response.json();
-      return responseData[0].generated_text;
-  } catch (error: any) {
-      console.error('Error fetching response:', error.message);
-      return null;
-  }
+    try {
+        const response = await axios.post('https://api-inference.huggingface.co/models/google/gemma-2b-it', { inputs: prompt }, {
+            headers: { 'Authorization': `Bearer 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` }
+        });
+        return response.data[0].generated_text;
+    } catch (error: any) {
+        console.error('Error fetching response:', error.message);
+        return null;
+    }
 }
+
 export async function apexai(prompt: string) {
-  try {
+    try {
       const messages = [
-          {"role": "user", "content": `${prompt}`}
+        {"role": "user", "content": `${prompt}`}
       ];
-      const formattedMessages = messages.map(message => `[${message.role}] ${message.content}`).join('\n');
-
-      const response = await fetch('https://api-inference.huggingface.co/models/mistralai/Mixtral-8x7B-Instruct-v0.1', {
-          method: 'POST',
-          headers: {
-              'Authorization': 'Bearer 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',
-              'Content-Type': 'application/json'
-          },
-          body: JSON.stringify({ inputs: formattedMessages })
-      });
+        const formattedMessages = messages.map(message => `[${message.role}] ${message.content}`).join('\n');
+
+        const response = await axios.post(`https://api-inference.huggingface.co/models/mistralai/Mixtral-8x7B-Instruct-v0.1`, {
+            inputs: formattedMessages
+        }, {
+            headers: {
+                'Authorization': `Bearer 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`,
+                'Content-Type': 'application/json'
+            }
+        });
 
-      if (!response.ok) {
-          throw new Error('Network response was not ok');
-      }
+        const generatedText = response.data[0].generated_text;
 
-      const responseData = await response.json();
-      const generatedText = responseData[0].generated_text;
-      const lines = generatedText.split('\n').slice(1);
-      const output = lines.join('\n');
+        const lines = generatedText.split('\n').slice(1);
 
-      return output;
-  } catch (error: any) {
-      console.error('Error:', error.message);
-      return 'Please wait i am on cooldown.';
-  }
+        const output = lines.join('\n');
+
+     return output
+    } catch (error: any) {
+      console.error('Error:', error.response.data);
+      return 'Please wait i am on cooldown.'
+    }
 }
 
 export async function starChat(prompt: string) {
-  const messages = [{"role":"user","content": `${prompt}`}];
-
-  try {
-      const response = await fetch('https://api-inference.huggingface.co/models/HuggingFaceH4/starchat2-15b-v0.1', {
-          method: 'POST',
-          headers: {
-              'Authorization': 'Bearer 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',
-              'Content-Type': 'application/json'
-          },
-          body: JSON.stringify({ inputs: messages })
-      });
-
-      if (!response.ok) {
-          throw new Error('Network response was not ok');
-      }
+  const messages = [{"role":"user","content": `${prompt}`}]
+  
+    try {
+        const response = await axios.post('https://api-inference.huggingface.co/models/HuggingFaceH4/starchat2-15b-v0.1', {
+            inputs: JSON.stringify(messages), 
+        }, {
+            headers: {
+                'Authorization': `Bearer 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`,
+            },
+        });
 
-      const responseData = await response.json();
-      const chatbotReply = responseData[0];
-      const chatbotResponseText = chatbotReply.generated_text.replace(/^.*?\n.*?\n/, '');
-      const chatbotResponseArray = JSON.parse(chatbotResponseText);
-      const chatbotResponseString = chatbotResponseArray.join(' ');
+        const chatbotReply = response.data[0];
+        const chatbotResponseText = chatbotReply.generated_text.replace(/^.*?\n.*?\n/, '');
+        const chatbotResponseArray = JSON.parse(chatbotResponseText);
+        const chatbotResponseString = chatbotResponseArray.join(' ');
 
-      return chatbotResponseString;
-  } catch (error: any) {
-      console.error('Error:', error.message);
-      return null;
-  }
+        return chatbotResponseString;
+    } catch (error: any) {
+        console.error('Error fetching response:', error.message);
+        return null;
+    }
 }
 
 export async function zephyr_beta(prompt: string) {
-  const messages = [{"role":"user","content": `${prompt}` }];
-
-  try {
-      const response = await fetch('https://api-inference.huggingface.co/models/HuggingFaceH4/zephyr-7b-beta', {
-          method: 'POST',
-          headers: {
-              'Authorization': 'Bearer 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',
-              'Content-Type': 'application/json'
-          },
-          body: JSON.stringify({ inputs: messages })
-      });
 
-      if (!response.ok) {
-          throw new Error('Network response was not ok');
-      }
+  const messages = [{"role":"user","content": `${prompt}` }]
+    try {
+        const response = await axios.post('https://api-inference.huggingface.co/models/HuggingFaceH4/zephyr-7b-beta', {
+            inputs: JSON.stringify(messages), 
+        }, {
+            headers: {
+                'Authorization': `Bearer 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`,
+            },
+        });
 
-      const responseData = await response.json();
-      const chatbotReply = responseData[0];
-      const textParts = chatbotReply.generated_text.split('\n');
-      const secondArrayString = textParts[2];
-      const chatbotResponseArray = JSON.parse(secondArrayString);
-      const chatbotResponseString = chatbotResponseArray.map((obj: any) => obj.content).join(' ');
-
-      return chatbotResponseString;
-  } catch (error: any) {
-      console.error('Error:', error.message);
-      return null;
-  }
+        const chatbotReply = response.data[0];
+
+        const textParts = chatbotReply.generated_text.split('\n');
+
+        const secondArrayString = textParts[2];
+        const chatbotResponseArray = JSON.parse(secondArrayString);
+
+        const chatbotResponseString = chatbotResponseArray.map((obj: any) => obj.content).join(' ');
+
+        return chatbotResponseString;
+    } catch (error: any) {
+        console.error('Error fetching response:', error.message);
+        return null;
+    }
 }

package/lib/ai/functions/draw.ts

@@ -1,6 +1,7 @@
 import translate from "@iamtraction/google-translate";
 import sharp from "sharp";
 import { ButtonBuilder, StringSelectMenuBuilder, StringSelectMenuOptionBuilder, ButtonStyle, ActionRowBuilder, AttachmentBuilder, AttachmentData } from "discord.js";
+import axios from "axios";
 import api from "api";
 
 const sdk: any = api("@prodia/v1.3.0#be019b2kls0gqss3"); 
@@ -87,8 +88,8 @@ async function aiImagine(
   nsfw: boolean,
   nsfwKeyWords: string[],
 ) {
-  const maxRetryAttempts = 3;
-  const retryInterval = 10000;
+  const maxRetryAttempts = 4;
+  const retryInterval = 5000;
   let response: any;
   async function retry(fn: any, retriesLeft = maxRetryAttempts) {
     try {
@@ -97,6 +98,7 @@ async function aiImagine(
       if (retriesLeft === 0) {
         throw error;
       }
+
       await new Promise((resolve) => setTimeout(resolve, retryInterval));
       return retry(fn, retriesLeft - 1);
     }
@@ -159,45 +161,38 @@ async function aiImagine(
       let buffferedImage: any;
 
       if (imageModel === "v3") {
-        const res = await retry(async () => {
-            const resp = await fetch(response.url, {
-                method: 'GET',
-                headers: {
-                    'Content-Type': 'application/octet-stream'
-                }
-            });
-            if (!resp.ok) {
-                throw new Error("Failed to fetch image data.");
-            }
-            return await resp.arrayBuffer();
-        });
-    
+        const res = await retry(() =>
+          axios.get(response.url, {
+            responseType: "arraybuffer",
+          }),
+        );
+
         await message.channel?.sendTyping();
-    
-        buffferedImage = Buffer.from(res, "binary");
-    
+
+        buffferedImage = Buffer.from(res.data, "binary");
+
         const resizedImage = await sharp(buffferedImage)
-            .resize({
-                width: 0x320,
-            })
-            .toBuffer();
-    
+          .resize({
+            width: 0x320,
+          })
+          .toBuffer();
+
         const attachment = {
-            file: resizedImage,
-            name: `image_${_0x4d7fb6 + 1}.png`,
+          file: resizedImage,
+          name: `image_${_0x4d7fb6 + 1}.png`,
         } as AttachmentData;
-    
+
         attachData.push(attachment);
-    
+
         const urlButton = new ButtonBuilder()
-            .setStyle(ButtonStyle.Link)
-            .setLabel(`Image ${_0x4d7fb6 + 1}`)
-            .setURL(response.url);
-    
+          .setStyle(ButtonStyle.Link)
+          .setLabel(`Image ${_0x4d7fb6 + 1}`)
+          .setURL(response.url);
+
         buttonsRow1.push(urlButton);
-    
+
         imageUrls.push(response.url);
-    } else {
+      } else {
         const imageUrl = response.url || response;
 
         await message.channel?.sendTyping();
@@ -392,45 +387,52 @@ async function checkJobStatus(jobId: number | string | any) {
 
 async function attemptImageCaptioning(imageUrl: string) {
   try {
-      let retryCount = 0;
-      const maxRetries = 3;
-
-      const fetchData = async () => {
-          try {
-              const response = await fetch(`https://api-inference.huggingface.co/models/Salesforce/blip-image-captioning-base`, {
-                  method: 'POST',
-                  headers: {
-                      "Content-Type": "application/json",
-                      Authorization: `Bearer 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`,
-                  },
-                  body: JSON.stringify({ image: imageUrl })
-              });
-
-              if (response.ok) {
-                  return await response.json();
-              } else {
-                  console.error(`Failed to fetch image captioning API: ${response.statusText}`);
-                  return null;
-              }
-          } catch (error: any) {
-              console.error(`Error fetching data: ${error.message}`);
-              throw error;
-          }
-      };
+    let retryCount = 0;
+    const maxRetries = 3;
 
-      while (retryCount < maxRetries) {
-          try {
-              return await fetchData();
-          } catch (error: any) {
-              retryCount++;
-          }
+    const fetchData = async () => {
+      try {
+        const response = await axios.post(
+          `https://api-inference.huggingface.co/models/Salesforce/blip-image-captioning-base`,
+          { image: imageUrl },
+          {
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer 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`,
+            },
+          },
+        );
+
+        if (response.status === 200) {
+          return response.data[0].generated_text;
+        } else {
+          console.error(
+            `Failed to fetch image captioning API: ${response.statusText}`,
+          );
+          return null;
+        }
+      } catch (error: any) {
+        console.error(`Error fetching data: ${error.message}`);
+        throw error;
       }
+    };
 
-      return null;
+    while (retryCount < maxRetries) {
+      try {
+        return await fetchData();
+      } catch (error: any) {
+        console.error(
+          `Error fetching data (Retry ${retryCount + 1}): ${error.message}`,
+        );
+        retryCount++;
+      }
+    }
+
+    return null;
   } catch (error: any) {
-      console.error(`Error in attemptImageCaptioning: ${error.message}`);
-      return null;
+    console.error(`Error in attemptImageCaptioning: ${error.message}`);
+    return null;
   }
 }
 
-export { aiImagine };
+export { aiImagine };

package/lib/ai/functions/generateVoiceResponse.ts

@@ -1,5 +1,6 @@
 import { Hercai } from "hercai";
-import translate from "@iamtraction/google-translate";
+import translate  from "@iamtraction/google-translate";
+import axios from "axios";
 import { createWorker, recognize } from "tesseract.js";
 import { chunkString } from "./chunkString";
 import { aiImagine } from "./draw";
@@ -7,7 +8,7 @@ import fs from "fs";
 
 const herc = new Hercai();
 let isProcessing = false;
-type ChatModelOption = "v3" | "v3-32k" | "turbo" | "turbo-16k" | "gemini";
+type ChatModelOption = any | "v3" | "v3-32k" | "turbo" | "turbo-16k" | "gemini" ;
 
 async function aiVoice(
   message: any,
@@ -67,16 +68,20 @@ async function aiVoice(
         setTimeout(async () => {
           const encodedChunk = encodeURIComponent(chunk);
           const url = `https://translate.google.com/translate_tts?ie=UTF-8&tl=en&client=tw-ob&q=${encodedChunk}`;
-          const response = await fetch(url, {
+          const mp3Stream = await axios.get(url, {
+            responseType: "stream",
             headers: {
               Referer: "http://translate.google.com/",
               "User-Agent": "stagefright/1.2 (Linux;Android 5.0)",
             },
           });
-          const blob = await response.blob();
-          const file = new File([blob], "respond.mp3");
           await message.reply({
-            files: [file],
+            files: [
+              {
+                attachment: mp3Stream.data,
+                name: "respond.mp3",
+              },
+            ],
             allowedMentions: { repliedUser: false },
           });
         }, delay);
@@ -89,12 +94,13 @@ async function aiVoice(
 
       const options = {
         method: "POST",
+        url: "https://text-to-speech-neural-google.p.rapidapi.com/generateAudioFiles",
         headers: {
           "content-type": "application/json",
           "X-RapidAPI-Key": apiKey,
           "X-RapidAPI-Host": "text-to-speech-neural-google.p.rapidapi.com",
         },
-        body: JSON.stringify({
+        data: {
           audioFormat: "ogg",
           paragraphChunks: [msg],
           voiceParams: {
@@ -102,13 +108,13 @@ async function aiVoice(
             engine: "google",
             languageCode: "en-US",
           },
-        }),
+        },
       };
 
       try {
-        const response = await fetch("https://text-to-speech-neural-google.p.rapidapi.com/generateAudioFiles", options);
-        const audioData = await response.json();
-        fs.writeFileSync("output.ogg", Buffer.from(audioData.audioStream, "base64"));
+        const response = await axios.request(options);
+        const audioData = response.data.audioStream;
+        fs.writeFileSync("output.ogg", Buffer.from(audioData, "base64"));
         await message.reply({
           files: [
             {
@@ -136,18 +142,19 @@ async function aiVoice(
 
       const options = {
         method: "POST",
+        url: "https://cloudlabs-text-to-speech.p.rapidapi.com/synthesize",
         headers: {
           "content-type": "application/x-www-form-urlencoded",
           "X-RapidAPI-Key": apiKey,
           "X-RapidAPI-Host": "cloudlabs-text-to-speech.p.rapidapi.com",
         },
-        body: encodedParams.toString(),
+        data: encodedParams,
       };
 
       try {
-        const response = await fetch("https://cloudlabs-text-to-speech.p.rapidapi.com/synthesize", options);
-        const { result: { audio_url } } = await response.json();
-        await message.reply(audio_url, {
+        const response = await axios.request(options);
+        const audioUrl = response.data.result.audio_url;
+        await message.reply(audioUrl, {
           allowedMentions: { repliedUser: false },
         });
       } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "apexify.js",
-    "version": "3.3.10",
+    "version": "3.3.11",
     "description": "Ai and Canvas library. Supports typescript and javascript",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",