apexify.js 4.4.36 → 4.5.1

package/lib/ai/functions/generateVoiceResponse.ts

@@ -28,7 +28,7 @@ async function aiVoice(
   enhancer: any,
   buttons: any[],
   RespondMessage: any,
-  imgKey: string
+  imageAPIS?: { groqAPI?: string, rsnAPI?: string, prodiaAPI?: string, freesedGPTApi?: string }
 ) {
   if (message.author.bot || isProcessing || !message.guild) {
     return;
@@ -40,7 +40,7 @@ async function aiVoice(
     let msg = message.content;
 
     if (drawValid) {
-      return await aiImagine(message, numOfImages, finalText, hercai, imageModal, nsfw, nsfwKeyWords, deepCheck, enhancer, buttons, RespondMessage, imgKey);
+      return await aiImagine(message, numOfImages, finalText, hercai, imageModal, nsfw, nsfwKeyWords, deepCheck, enhancer, buttons, RespondMessage, { rsnAPI: imageAPIS?.rsnAPI, groqAPI: imageAPIS?.groqAPI, prodiaAPI: imageAPIS?.prodiaAPI,  freesedGPTApi: imageAPIS?.freesedGPTApi as string});
     }
 
     if (message.attachments.size > 0) {

package/lib/ai/functions/validOptions.ts

@@ -3,20 +3,20 @@ import api from "api";
 const sdk = api("@prodia/v1.3.0#be019b2kls0gqss3");
 sdk.auth('43435e1c-cab1-493f-a224-f51e4b97ce8d');
 
-async function initializeValidOptions() {
-    const [SDModals, SDXLModals, samplers] = await Promise.all([
-        sdModals(),
-        sdxlModals(),
+export const hercChatModels = ["v3" , "v3-32k" , "turbo" , "turbo-16k" , "gemini" , "llama3-70b" , "llama3-8b" , "mixtral-8x7b" , "gemma-7b" , "gemma2-9b"];
+export const groqChatModels = ['gemma-7b-it', 'gemma2-9b-it', 'llama3-groq-70b-8192-tool-use-preview', 'llama3-groq-8b-8192-tool-use-preview', 'llama-3.1-70b-versatile', 'llama-3.1-8b-instant', 'llama-guard-3-8b', 'llama3-70b-8192', 'llama3-8b-8192', 'mixtral-8x7b-32768'];
+export const rsnChatModels = ['bard', 'bing', 'codellama', 'gemini', 'llama', 'mixtral', 'openchat', 'gpt4', 'dalle'];
+export const otherChatModel = ['apexai', 'facebook_ai', 'yi_34b', 'starChat'];
+export const fresedgptModels = ['real-cartoon-xl-v6', 'flux-schnell', 'gpt-4o'];
+
+  async function initializeValidOptions() {
+    const [SDModels, SDXLModels, samplers] = await Promise.all([
+        sdModels(),
+        sdxlModels(),
         sampler()
     ]);
 
-    const ApexAIModals = ['v4', 'gemmini-pro', 'gemini-flash', 'gemini', 'v3', 'v3-32k', 'turbo', 'turbo-16k', 'llama',  'apexChat', 'openChat', 'yi-ai', 'facebook-ai', 'starChat', 'mixtral'];
-    const ApexChatModals = ['v4', 'gemini-v2', 'gemini', 'v3', 'v3-32k', 'turbo', 'turbo-16k', 'llama',  'apexChat', 'openChat', 'yi-ai', 'facebook-ai', 'starChat', 'mixtral', 'codellama', 'bing', 'bard'];
-
-    const HercModals = [
-        "v1",
-        "v2",
-        "v2-beta",
+    const HercImageModels = [
         "v3",
         "lexica",
         "prodia",
@@ -24,41 +24,42 @@ async function initializeValidOptions() {
         "simurg",
         "animefy",
         "raava",
-        "shonin"
+        "shonin",
     ];
 
-    const others = ['cartoon', 'flux'];
 
     return {
-        validApexAI: ApexAIModals,
-        validApexChat: ApexChatModals,
-        validHercaiModals: HercModals,
-        validProdiaModals: SDModals,
-        otherImageModals: others,
+        validHercChatModels: hercChatModels,
+        validgroqChatModels: groqChatModels,
+        validRSNChatModels: rsnChatModels,
+        validHercaiModels: HercImageModels,
+        validProdiaModels: SDModels,
+        validotherChatModels: otherChatModel,
+        validfresedgptModels: fresedgptModels,
         validEnhancers: [
             "ESRGAN_4x", "Lanczos", "Nearest", "LDSR", "R-ESRGAN 4x+",
             "R-ESRGAN 4x+ Anime6B", "ScuNET GAN", "ScuNET PSNR", "SwinIR 4x"
         ],
         validSamplers: samplers,
-        validSXDL: SDXLModals,
+        validSXDL: SDXLModels,
         validImgStyle: [
             "3d-model", "analog-film", "anime", "cinematic", "comic-book",
             "digital-art", "enhance", "isometric", "fantasy-art", "isometric",
             "line-art", "low-poly", "neon-punk", "origami", "photographic",
             "pixel-art", "texture", "craft-clay"
         ],
-        allModals: [...SDModals, ...SDXLModals, ...HercModals, ...ApexAIModals, ...ApexChatModals, ...others]
+        allModels: [...SDModels, ...SDXLModels, ...HercImageModels, ...fresedgptModels, ...hercChatModels, ...otherChatModel, ...groqChatModels, ...rsnChatModels]
     };
 }
 
-export const validOptions = initializeValidOptions();
+export const validateModels = initializeValidOptions();
 
-async function sdModals(): Promise<string[]> {
+async function sdModels(): Promise<string[]> {
     const SDModals = await sdk.listModels();
     return SDModals.data;
 }
 
-async function sdxlModals(): Promise<string[]> {
+async function sdxlModels(): Promise<string[]> {
     const SDXLModals = await sdk.listSdxlModels();
     return SDXLModals.data;
 }

package/lib/ai/modals-chat/electronHub/imageModels.ts

@@ -0,0 +1,26 @@
+import axios from 'axios';
+
+export async function electronImagine({ ApiKey, prompt, modelName, count = 1 }: { ApiKey?: string, prompt: string, modelName: string, count?: number }) {
+  try {
+    const response = await axios.post(
+      'https://api.electronhub.top/v1/images/generate',
+      {
+        model: modelName,
+        prompt: prompt,
+        n: count
+      },
+      {
+        headers: {
+          'Authorization': `Bearer ${ApiKey || 'ek-nFO8tz6qiu5cJ31lwCfPZNNrxFZLsJYou6yx4X1FS2Jyr2dm0a'}`,
+          'Content-Type': 'application/json'
+        }
+      }
+    );
+
+    const imagesUrl = response.data;
+    return imagesUrl; 
+  } catch (e: any) {
+    console.error('Error generating images:', e.response ? e.response.data : e.message);
+    throw e;
+  }
+}

package/lib/ai/{modals-images → modals-chat/freesedgpt}/cartoon.ts

@@ -1,6 +1,6 @@
 import axios from 'axios';
 
-export async function cartoon(prompt: string) {
+export async function cartoon(prompt: string, apiKey: string) {
     try {
     const response = await axios.post(
         'https://fresedgpt.space/v1/images/generations',
@@ -11,13 +11,13 @@ export async function cartoon(prompt: string) {
         },
         {
             headers: {
-                'Authorization': 'Bearer fresed-Dtm2TBDA9vXcaHFdrDL1apbF2fnOIQ',
+                'Authorization': `Bearer ${ apiKey || 'fresed-Dtm2TBDA9vXcaHFdrDL1apbF2fnOIQ' }`,
                 'Content-Type': 'application/json'
             }
         }
     );
 
-        return response.data.data[0].url;
+        return response.data.data[0].url || null;
     } catch (e: any) {
         return null
     }

package/lib/ai/modals-chat/freesedgpt/chat.ts

@@ -0,0 +1,31 @@
+import axios from 'axios';
+const API_URL = 'https://fresedgpt.space/v1/chat/completions';
+
+export async function gpt4o({ prompt, ApiKey}: { prompt: string, ApiKey?: string}) {
+  try {
+    const API_KEY = ApiKey || 'fresed-Dtm2TBDA9vXcaHFdrDL1apbF2fnOIQ';
+    const response = await axios.post(
+      API_URL,
+      {
+        messages: [{ role: 'user', content: `${prompt}` }],
+        model: 'chatgpt-4o-latest',
+        stream: false
+      },
+      {
+        headers: {
+          'Authorization': `Bearer ${API_KEY}`,
+          'Content-Type': 'application/json'
+        }
+      }
+    );
+
+    const responseData = response.data;
+    const assistantContent = responseData.choices[0]?.message?.content || 'No response content available';
+
+    return assistantContent || null;
+
+  } catch (error) {
+    console.error('Error creating chat completion:', error);
+  }
+}
+

package/lib/ai/{modals-images → modals-chat/freesedgpt}/flux.ts

@@ -1,6 +1,6 @@
 import axios from 'axios';
 
-export async function flux(prompt: string) {
+export async function flux(prompt: string, apiKey: string) {
     try {
         const response = await axios.post(
             'https://fresedgpt.space/v1/images/generations',
@@ -11,13 +11,13 @@ export async function flux(prompt: string) {
             },
             {
                 headers: {
-                    'Authorization': 'Bearer fresed-Dtm2TBDA9vXcaHFdrDL1apbF2fnOIQ',
+                    'Authorization': `Bearer ${ apiKey || 'fresed-Dtm2TBDA9vXcaHFdrDL1apbF2fnOIQ' }`,
                     'Content-Type': 'application/json'
                 }
             }
         );
     
-        return response.data.data[0].url;
+        return response.data.data[0].url || null;
     } catch (e: any) {
         return null
     }

package/lib/ai/modals-chat/{Gemini-flash.ts → gemini/Gemini-flash.ts}

@@ -1,11 +1,11 @@
 import { GoogleGenerativeAI, HarmCategory, HarmBlockThreshold } from "@google/generative-ai";
-import { converter } from "../../canvas/utils/general functions";
+import { converter } from "../../../canvas/utils/general functions";
 import { connect } from "verse.db";
 import config from './config';
 import axios from "axios";
 import path from 'path';
 import fs from 'fs';
-import { readFile } from "../utils";
+import { readFile } from "../../utils";
 
 export async function geminiFlash(message: { userId: string, serverName: string, serverId: string, channelName: string, attachment: any, db: boolean }, AI: { AiPersonality: string | null, userMsg: string, API_KEY: string | null }): Promise<any> {
 

package/lib/ai/modals-chat/{Gemini-pro.ts → gemini/Gemini-pro.ts}

@@ -1,5 +1,5 @@
 import { GoogleGenerativeAI, HarmCategory, HarmBlockThreshold } from "@google/generative-ai";
-import { converter } from "../../canvas/utils/general functions";
+import { converter } from "../../../canvas/utils/general functions";
 import { GoogleAIFileManager } from "@google/generative-ai/server";
 
 import { connect } from "verse.db";
@@ -7,7 +7,7 @@ import config from './config';
 import axios from "axios";
 import path from 'path';
 import fs from 'fs';
-import { readFile } from "../utils";
+import { readFile } from "../../utils";
 
 export async function geminiPro(message: { userId: string, serverName: string, serverId: string, channelName: string, attachment: any, db: boolean }, AI: { AiPersonality: string | null, userMsg: string, API_KEY: string | null }): Promise<any> {
 

package/lib/ai/modals-chat/groq/chatgroq.ts

@@ -0,0 +1,68 @@
+import Groq from 'groq-sdk';
+
+interface groqOptions {
+  API_KEY?: string;
+  prompt: string;
+  apiName: string;
+  instruction?: string;
+}
+
+// Define your own type for message parameters
+interface ChatCompletionMessageParam {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+}
+
+const validGroqApiNames = ['gemma-7b-it', 'llama3-70b-8192', 'llama3-8b-8192', 'mixtral-8x7b-32768'];
+
+export async function chatGroq({ API_KEY, prompt, apiName, instruction }: groqOptions): Promise<string> {
+  if (!validGroqApiNames.includes(apiName)) {
+    return `Invalid API name: ${apiName}. Please provide one of the following: ${validGroqApiNames.join(', ')}`;
+  }
+
+  try {
+    const groq = new Groq({
+      apiKey: API_KEY || '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',
+    });
+
+    const messages: ChatCompletionMessageParam[] = [];
+
+    if (instruction) {
+      messages.push({
+        role: 'system',
+        content: instruction,
+      });
+    }
+
+    messages.push({
+      role: 'user',
+      content: prompt,
+    });
+
+    const chatCompletion = await groq.chat.completions.create({
+      messages: messages,
+      model: apiName,
+      max_tokens: 8192,
+    });
+
+    const response = chatCompletion.choices[0]?.message?.content || 'Rate limit';
+    return response;
+
+  } catch (err: any) {
+    if (err instanceof Groq.APIError) {
+      if (err.status === 400) {
+        return 'Bad request. Try again after a minute please.';
+      } else if (err.status === 429) {
+        return 'Rate limit. Try again after one minute or provide your own API key.';
+      } else if (err.status === 401 || !err.status) {
+        throw new Error('Invalid API key provided.');
+      } else {
+        console.error(err);
+        return 'Unknown error occurred.';
+      }
+    } else {
+      console.error(err);
+      return 'Unknown error occurred.';
+    }
+  }
+}

package/lib/ai/modals-chat/groq/imageAnalyzer.ts

@@ -0,0 +1,68 @@
+import Groq from 'groq-sdk';
+
+interface GroqAnalyzerOptions {
+  imgURL: string;
+  ApiKey?: string;
+  prompt?: string;
+}
+
+async function convertUrlToDataUrl(url: string): Promise<string> {
+    try {
+      const response = await fetch(url);
+      const blob = await response.blob();
+      const reader = new FileReader();
+      
+      return new Promise<string>((resolve, reject) => {
+        reader.onloadend = () => {
+          resolve(reader.result as string);
+        };
+        reader.onerror = reject;
+        reader.readAsDataURL(blob);
+      });
+    } catch (error) {
+      console.error('Error converting URL to Data URL:', error);
+      throw new Error('Failed to convert image URL to data URL');
+    }
+  }
+
+export async function groqAnalyzer({ imgURL, ApiKey, prompt }: GroqAnalyzerOptions): Promise<string> {
+  try {
+    const groq = new Groq({
+      apiKey: ApiKey || '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',
+    });
+
+    const imageDataUrl = await convertUrlToDataUrl(imgURL);
+
+    // @ts-ignore
+    const chatCompletion = await groq.chat.completions.create({
+      messages: [
+        {
+          role: 'user',
+          content: {
+            type: 'text',
+            text: prompt || '',
+          },
+        },
+        {
+          role: 'user',
+          content: {
+            type: 'image_url',
+            image_url: imageDataUrl,
+          },
+        },
+      ],
+      model: 'llava-v1.5-7b-4096-preview',
+      temperature: 0,
+      max_tokens: 1024,
+      top_p: 1,
+      stream: false,
+      stop: null,
+    });
+
+    return chatCompletion.choices[0].message.content as string;
+  } catch (error) {
+    console.error('Error in groqAnalyzer:', error);
+    return 'Error occurred at the api'
+  }
+}
+

package/lib/ai/modals-chat/{whisper.ts → groq/whisper.ts}

@@ -10,7 +10,7 @@ function getFileSize(filePath: string): number {
 }
 
 async function createReadableStream(filepathOrUrl: string): Promise<NodeJS.ReadableStream | string> {
-  const maxFileSizeBytes = 25 * 1024 * 1024; // 25MB in bytes
+  const maxFileSizeBytes = 25 * 1024 * 1024;
 
   if (filepathOrUrl.startsWith('http')) {
     const parsedUrl = new URL(filepathOrUrl);
@@ -66,7 +66,7 @@ export async function whisper(prompt: string, filepath: string, lang?: string, A
       apiKey: API_KEY || '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',
     });
 
-    const fileStream = await createReadableStream(filepath);
+    const fileStream = await createReadableStream(path.join(process.cwd(), filepath));
 
     if (typeof fileStream === 'string') {
       return fileStream; 

package/lib/ai/modals-chat/hercai/chatModels.ts

@@ -0,0 +1,20 @@
+import { Hercai } from "hercai";
+const hercai = new Hercai('6eZZOdDwm6Epdzn8mnhcX9SBDkxvoNYcNj9ILS0P44=');
+type hercaiModels = "v3" | "v3-32k" | "turbo" | "turbo-16k" | "gemini" | "llama3-70b" | "llama3-8b" | "mixtral-8x7b" | "gemma-7b" | "gemma2-9b"
+
+export async function chatHercai(prompt: string, model: hercaiModels, instructions?: string, memory?: { enable?: boolean, id?: string}): Promise<string> {
+    try {
+
+        if (memory && memory.enable && memory.id) {
+            return (await hercai.betaQuestion({ content: prompt, user: memory.id })).reply;
+        } else if (prompt === ( "v3" || "v3-32k" || "turbo" || "turbo-16k" || "gemini" || "llama3-70b" || "llama3-8b" || "mixtral-8x7b" || "gemma-7b" || "gemma2-9b" )) {
+            
+            return (await hercai.question({ model, content: prompt, personality: instructions })).reply;
+        } else {
+            throw new Error('Invalid model name.');
+        }
+    } catch (e: any) {
+        console.error(e.message);
+        return 'An Error has occurred in the API';
+    }
+}

package/lib/ai/modals-chat/others/otherModels.ts

@@ -0,0 +1,99 @@
+import axios from 'axios';
+
+interface AiOptions {
+  modelName: 'apexai' | 'facebook_ai' | 'starChat' | 'yi_34b';
+  prompt: string;
+}
+
+const apiUrls = {
+  apexai: 'https://api-inference.huggingface.co/models/mistralai/Mixtral-8x7B-Instruct-v0.1',
+  facebook_ai: 'https://api-inference.huggingface.co/models/facebook/blenderbot-400M-distill',
+  starChat: 'https://api-inference.huggingface.co/models/HuggingFaceH4/starchat2-15b-v0.1',
+  yi_34b: 'https://api-inference.huggingface.co/models/01-ai/Yi-1.5-34B-Chat',
+};
+
+const apiKey = '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';
+
+export async function otherChatModels({ modelName, prompt }: AiOptions): Promise<string> {
+  try {
+    switch (modelName) {
+      case 'apexai': {
+        const messages = [{ role: 'user', content: prompt }];
+        const formattedMessages = messages.map(message => `[${message.role}] ${message.content}`).join('\n');
+
+        const response = await axios.post(apiUrls.apexai, {
+          inputs: formattedMessages,
+        }, {
+          headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+          },
+        });
+
+        const generatedText = response.data[0].generated_text;
+        const lines = generatedText.split('\n').slice(1);
+        return lines.map((line: string) => line.replace(/^\[.*?\]\s*/, '')).join('\n');
+      }
+
+      case 'facebook_ai': {
+        const response = await axios.post(apiUrls.facebook_ai, { inputs: prompt }, {
+          headers: { 'Authorization': `Bearer ${apiKey}` },
+        });
+
+        return response.data[0].generated_text;
+      }
+
+      case 'starChat': {
+        const messages = [{ role: 'assistant', content: prompt }];
+        const response = await axios.post(apiUrls.starChat, {
+          inputs: JSON.stringify(messages),
+        }, {
+          headers: {
+            'Authorization': `Bearer ${apiKey}`,
+          },
+        });
+
+        let chatbotReply = response.data[0].generated_text.replace(/^.*?\n.*?\n/, '');
+        if (chatbotReply.startsWith('[' || '{')) {
+          chatbotReply = JSON.parse(chatbotReply).join(' ');
+        }
+
+        return chatbotReply;
+      }
+
+      case 'yi_34b': {
+        const messages = [{ role: 'user', content: prompt }];
+        const formattedMessages = messages.map(message => `[${message.role}] ${message.content}`).join('\n');
+
+        const response = await axios.post(apiUrls.yi_34b, {
+          inputs: formattedMessages,
+        }, {
+          headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+          },
+        });
+
+        const generatedText = response.data[0].generated_text;
+        const botIndex = generatedText.indexOf('[bot]', generatedText.indexOf('[user]'));
+
+        if (botIndex !== -1) {
+          let botResponse = generatedText.substring(botIndex);
+          const nextBotIndex = botResponse.indexOf('[bot]', 1);
+          const nextUserIndex = botResponse.indexOf('[user]', 1);
+          const endIndex = Math.min(nextBotIndex !== -1 ? nextBotIndex : botResponse.length, nextUserIndex !== -1 ? nextUserIndex : botResponse.length);
+          botResponse = botResponse.substring(0, endIndex).substring(botResponse.indexOf('[bot]') + 5).trim();
+          return botResponse;
+        } else {
+          return generatedText;
+        }
+      }
+
+      default:
+        return 'Invalid model name provided.';
+    }
+  } catch (error: any) {
+    console.error(`Error fetching response for ${modelName}:`, error.message || error.response?.data);
+    return 'Please wait, I am on cooldown.';
+  }
+}

package/lib/ai/modals-chat/rsn/rsnChat.ts

@@ -0,0 +1,74 @@
+import axios, { AxiosResponse } from 'axios';
+
+interface aiOptions {
+  API_KEY?: string | null;
+  prompt: string;
+  apiName: string;
+}
+
+const validApiNames = [
+  'bard',
+  'bing',
+  'codellama',
+  'gemini',
+  'llama',
+  'mixtral',
+  'openchat',
+  'gpt4',
+  'dalle'
+];
+
+export async function rsnAPI({ API_KEY, prompt, apiName }: aiOptions): Promise<string> {
+
+  if (!validApiNames.includes(apiName)) {
+    return `Invalid API name: ${apiName}. Please provide one of the following: ${validApiNames.join(', ')}`;
+  }
+
+  const apiKey: string = API_KEY || 'rsnai_SbLbFcwdT2h2KoYet2LS0F34';
+  const apiUrl = `https://api.rnilaweera.lk/api/v1/user/${apiName}`;
+
+  try {
+    const payload = { prompt };
+    const response: AxiosResponse = await axios.post(apiUrl, payload, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+    });
+
+    if (apiName === 'dalle') return response.data?.image.url;
+
+    return response.data.message;
+  } catch (e: any) {
+    if (e.response && e.response.data.message === 'Invalid API key.') {
+      try {
+        const defaultResponse = await axios.post(apiUrl, { prompt }, {
+          headers: { Authorization: `Bearer rsnai_SbLbFcwdT2h2KoYet2LS0F34` },
+        });
+
+        if (apiName === 'dalle') return defaultResponse.data?.image.url;
+
+        return defaultResponse.data.message;
+      } catch (err) {
+        console.log(err);
+        return 'An error occurred while using the default API key.';
+      }
+    }
+    else if (e.response && e.response.status === 500) {
+      try {
+        const backupResponse = await axios.post(apiUrl, { prompt }, {
+          headers: { Authorization: `Bearer rsnai_lvIch9Z7apBHqfXYqOiXwzm7` },
+        });
+        
+        if (apiName === 'dalle') return backupResponse.data?.image.url;
+
+        return backupResponse.data.message;
+      } catch (err) {
+        console.log(err);
+        return 'An error occurred while using the backup API key.';
+      }
+    } else {
+      console.log(e);
+      return 'The API is on cooldown for 50 seconds.';
+    }
+  }
+}
+
+

package/lib/ai/utils.ts

@@ -6,17 +6,14 @@ import { aiImagine } from "./functions/draw";
 import { readFile } from "./functions/readFiles";
 import { ApexChat, ApexImagine, ApexListener } from "./ApexModules";
 import { typeWriter } from "./functions/typeWriter" ;
-import { readImage } from  "./functions/imageAnalysis";
-import { geminiPro } from "./modals-chat/Gemini-pro";
-import { mixtral } from "./modals-chat/mixtral";
-import { openChat } from "./modals-chat/openChat";
-import { llamaChat } from "./modals-chat/llama";
-import { v4 } from "./modals-chat/v4";
+import { groqAnalyzer } from "./modals-chat/groq/imageAnalyzer";
+import { geminiFlash } from "./modals-chat/gemini/Gemini-flash";
+import { geminiPro } from "./modals-chat/gemini/Gemini-pro";
+
 
 export {
   chunkString,
   imageReader,
-  readImage,
   toDraw,
   aiVoice,
   aiImagine,
@@ -25,9 +22,7 @@ export {
   ApexImagine,
   ApexListener,
   typeWriter,
-  geminiPro,
-  v4,
-  llamaChat,
-  mixtral,
-  openChat
+  groqAnalyzer,
+  geminiFlash,
+  geminiPro
 };

package/lib/index.ts

@@ -29,16 +29,18 @@ fetch("https://registry.npmjs.com/-/v1/search?text=apexify.js")
     .catch(function(error: any) {});
 
 import { ApexAI, ApexChat, ApexImagine, ApexPainter, ApexListener, readFile, imageReader } from "./utils";
-import { validOptions } from "./ai/functions/validOptions";
+import { validateModels } from "./ai/functions/validOptions";
+import { groqAnalyzer } from "./ai/utils";
 export * from './canvas/utils/utils';
 export * from './canvas/utils/types';
 
 const ApexFileReader = readFile;
 const ApexImageReader = imageReader
-export { ApexPainter, ApexAI, ApexImagine, ApexChat, validOptions, ApexListener, ApexFileReader, ApexImageReader };
+const ApexImageAnalyzer = groqAnalyzer
+export { ApexPainter, ApexAI, ApexImagine, ApexChat, validateModels, ApexListener, ApexFileReader, ApexImageReader, ApexImageAnalyzer };
 
 const Apexify = {
-    ApexPainter, ApexAI, ApexImagine, ApexChat, validOptions, ApexListener, ApexFileReader, ApexImageReader
+    ApexPainter, ApexAI, ApexImagine, ApexChat, validateModels, ApexListener, ApexFileReader, ApexImageReader, ApexImageAnalyzer
 };
 
 export default Apexify;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apexify.js",
-  "version": "4.4.36",
+  "version": "4.5.1",
   "description": "Ai and Canvas library. Supports ts & js (supports front/back end).",
   "main": "./dist/index.js",
   "author": "zenith-79",

package/dist/ai/functions/imageAnalysis.d.ts

@@ -1,2 +0,0 @@
-export declare function readImage(imageUrl: string): Promise<any>;
-//# sourceMappingURL=imageAnalysis.d.ts.map