apexify.js 4.1.6 → 4.1.8

package/lib/ai/modals-chat/Gemini-flash.ts

@@ -3,185 +3,207 @@ import path from 'path';
 import fs from 'fs';
 import config from './config'; 
 import { converter } from "../../canvas/utils/general functions";
-import  { connect } from "verse.db";
+import { connect } from "verse.db";
 import axios from "axios";
 
 let currentApiKeyIndex = 0;
 
-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> {
+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> {
 
-  try { 
-    let apiKeyIndex = currentApiKeyIndex;
-    let genAI: any;
-        while (apiKeyIndex < config.apiKeys.length) {
-            const validateKey = await axios.get(`https://generativelanguage.googleapis.com/v1beta/models?key=${config.apiKeys[apiKeyIndex]}`);
-            if (validateKey.status === 200) {
-                genAI = new GoogleGenerativeAI(config.apiKeys[apiKeyIndex]);
-                
-                break;
-            } else {
-                apiKeyIndex++;
-            }
-        }
+  async function validateKey(apiKey: string) {
+    try {
+      const validateResponse = await axios.get(`https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`);
+      return validateResponse.status === 200;
+    } catch (error) {
+      console.error(`Error validating API key: ${apiKey}`, error);
+      return false;
+    }
+  }
+
+  async function getValidGenAI(apiKeys: string[], initialIndex: number): Promise<any> {
+    for (let i = initialIndex; i < apiKeys.length; i++) {
+      const apiKey = apiKeys[i];
+      if (await validateKey(apiKey)) {
+        currentApiKeyIndex = i;
+        return new GoogleGenerativeAI(apiKey);
+      }
+    }
+    return null;
+  }
+
+  async function processRequest(genAI: any): Promise<any> {
+    let personalityString = '';
 
-        if (apiKeyIndex === config.apiKeys.length) {
-            return 'All provided API keys are invalid.';
-        }
-    let personalityString: string = '';
-    
     if (AI.AiPersonality) {
-        const personalityFilePath = path.join(process.cwd(), AI.AiPersonality);
-        const personalityContent = fs.readFileSync(personalityFilePath, 'utf-8');
-        personalityString = personalityContent.split('\n').join(' ');
+      const personalityFilePath = path.join(process.cwd(), AI.AiPersonality);
+      const personalityContent = fs.readFileSync(personalityFilePath, 'utf-8');
+      personalityString = personalityContent.split('\n').join(' ');
     }
 
     const generationConfig = {
-        maxOutputTokens: 750,
+      maxOutputTokens: 750,
     };
 
     const safetySettings = [
-        {
-            category: HarmCategory.HARM_CATEGORY_HARASSMENT,
-            threshold: HarmBlockThreshold.BLOCK_ONLY_HIGH,
-        },
-        {
-            category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,
-            threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
-        },
-        {
-            category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
-            threshold: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
-        },
-        {
-            category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
-            threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
-        },
+      {
+        category: HarmCategory.HARM_CATEGORY_HARASSMENT,
+        threshold: HarmBlockThreshold.BLOCK_ONLY_HIGH,
+      },
+      {
+        category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+        threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+      },
+      {
+        category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+        threshold: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
+      },
+      {
+        category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
+        threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+      },
     ];
 
     const systemInstruction = `${personalityString}\n And working on discord in serverName: ${message.serverName} at channelName: ${message.channelName} and responding to the userName: <@${message.userId}>`;
-    const model = genAI.getGenerativeModel({ model: "gemini-1.5-pro-latest", systemInstruction, generationConfig, safetySettings });
+    const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash-latest", systemInstruction, generationConfig, safetySettings });
 
     const defaultHistory = [
-        {
-            role: "user",
-            parts: [{ text: `Hey who are you?` }],
-        },
-        {
-            role: "model",
-            parts: [{ text: `I am an AI assistant built/developed/created by Apexify.js` }],
-        },
-        {
-            role: "user",
-            parts: [{ text: `You have chat Memory?` }],
-        },
-        {
-            role: "model",
-            parts: [{ text: `Yes, i save chat history for each user if it is enabled in my configuration otherwise no data being saved.` }],
-        },
-        {
-            role: "user",
-            parts: [{ text: `How is your data/memory/chat history is managed` }],
-        },
-        {
-            role: "model",
-            parts: [{ text: `It is managed by verse.db. A database used to manage JSON/SQL/YAML/SQOL database with ease and supports schema/schemaless data.` }],
-        }
+      {
+        role: "user",
+        parts: [{ text: `Hey who are you?` }],
+      },
+      {
+        role: "model",
+        parts: [{ text: `I am an AI assistant built/developed/created by Apexify.js` }],
+      },
+      {
+        role: "user",
+        parts: [{ text: `You have chat Memory?` }],
+      },
+      {
+        role: "model",
+        parts: [{ text: `Yes, I save chat history for each user if it is enabled in my configuration otherwise no data being saved.` }],
+      },
+      {
+        role: "user",
+        parts: [{ text: `How is your data/memory/chat history managed?` }],
+      },
+      {
+        role: "model",
+        parts: [{ text: `It is managed by verse.db. A database used to manage JSON/SQL/YAML/SQOL database with ease and supports schema/schemaless data.` }],
+      }
     ];
 
     let historyData: any[] | undefined = undefined;
 
     let db: any;
     if (message.db) {
-    db = new connect({ adapter: 'json', dataPath: `${message.serverId}_ChatHistory` });
-    const data = await db.find(`${message.userId}_chatHistory`, { userId: message.userId });
-    historyData = data.results?.history || undefined;
+      db = new connect({ adapter: 'json', dataPath: `${message.serverId}_ChatHistory` });
+      const data = await db.find(`${message.userId}_chatHistory`, { userId: message.userId });
+      historyData = data.results?.history || undefined;
     }
 
     const chat = model.startChat({
       history: historyData || defaultHistory,
       generationConfig
     });
-  
+
     const imgURL = message.attachment?.url || null;
     let result: any;
 
     if (imgURL) {
-        const imageData = await urlToBase64(imgURL)
-        const image = {
-            inlineData: {
-              data: imageData,
-              mimeType: "image/png",
-            },
-          };
-        result = await chat.sendMessage([AI.userMsg, image]);
+      const imageData = await urlToBase64(imgURL);
+      const image = {
+        inlineData: {
+          data: imageData,
+          mimeType: "image/png",
+        },
+      };
+      result = await chat.sendMessage([AI.userMsg, image]);
     } else {
-        result = await chat.sendMessage(AI.userMsg);
+      result = await chat.sendMessage(AI.userMsg);
     }
 
-    const response =  await result.response.text();
+    const response = await result.response.text();
 
     if (message.db) {
-        
-        const userHistory = {
-            $push: {
-              "history": {
-                role: "user",
-                parts: [{ text: `${AI.userMsg}` }]
-              }
-            },
-        };
-
-        historyData = await db.update(`${message.userId}_chatHistory`,
-         { userId: message.userId },
-         userHistory,
-         true
-        );
-
-        const modelHistory = {
-            $push: {
-              "history": {
-                role: "model",
-                parts: [{ text: `${response}` }]
-              }
-            },
-        };
-        
-        historyData = await db.update(`${message.userId}_chatHistory`,
-         { userId: message.userId },
-         modelHistory,
-         true
-        );
+      const userHistory = {
+        $push: {
+          "history": {
+            role: "user",
+            parts: [{ text: `${AI.userMsg}` }]
+          }
+        },
+      };
+
+      historyData = await db.update(`${message.userId}_chatHistory`,
+        { userId: message.userId },
+        userHistory,
+        true
+      );
+
+      const modelHistory = {
+        $push: {
+          "history": {
+            role: "model",
+            parts: [{ text: `${response}` }]
+          }
+        },
+      };
+
+      historyData = await db.update(`${message.userId}_chatHistory`,
+        { userId: message.userId },
+        modelHistory,
+        true
+      );
     }
 
     return response;
-} catch (e: any) {
+  }
+
+  async function urlToBase64(imageURL: string) {
+    try {
+      const convertedBuffer = await converter(imageURL, 'png');
+      const base64String = convertedBuffer.toString('base64');
+      return base64String;
+    } catch (error: any) {
+      throw new Error(`Failed to fetch and convert the image: ${error.message}`);
+    }
+  }
+
+  try {
+    let genAI: any;
+
+    if (AI.API_KEY && await validateKey(AI.API_KEY)) {
+      genAI = new GoogleGenerativeAI(AI.API_KEY);
+    } else {
+      genAI = await getValidGenAI(config.apiKeys, currentApiKeyIndex);
+      if (!genAI) {
+        return 'All provided API keys are invalid.';
+      }
+    }
+
+    return await processRequest(genAI);
+  } catch (e: any) {
     if (e.message) {
-        if (e.message === '[GoogleGenerativeAI Error]: Error fetching from https://generativelanguage.googleapis.com/v1/models/gemini-pro:generateContent: [400 Bad Request] User location is not supported for the API use.') {
-          return `The hoster/bot owner/the used host isn't supported by gemini.`;
-        } else if (e.response && (e.response.status === 429 || e.response.status === 403)) {
-              return 'Ai is on a cooldown for the rest of the day. Either provide your own API key or wait for tomorrow. Check ai.google.dev for free apikeys';
-        } else if (e.message === '[GoogleGenerativeAI Error]: Candidate was blocked due to SAFETY') {
-            console.error(e);
-            return `Due to safety enabled by gemini you have been blocked.`;
+      if (e.status === 429 || e.status === 403) {
+        currentApiKeyIndex++;
+        if (currentApiKeyIndex < config.apiKeys.length) {
+          return await geminiFlash(message, AI);
         } else {
-            console.error(e);
-            return `Try again later please... Either API is on a cooldown or an internal server error has occurred. If issue persists please contact the bot developer or owner of the npm package.`;
+          return 'Ai is on a cooldown for the rest of the day. Either provide your own API key or wait for tomorrow. Check ai.google.dev for free apikeys';
         }
-    } else {
+      } else if (e.status === 400) {
+        return `The hoster/bot owner/the used host isn't supported by gemini.`;
+      } else if (e.message === '[GoogleGenerativeAI Error]: Candidate was blocked due to SAFETY') {
+        console.error(e);
+        return `Due to safety enabled by gemini you have been blocked.`;
+      } else {
         console.error(e);
-        return 'An unknown error has occurred.';
+        return `Try again later please... Either API is on a cooldown or an internal server error has occurred. If issue persists please contact the bot developer or owner of the npm package.`;
+      }
+    } else {
+      console.error(e);
+      return 'An unknown error has occurred.';
     }
   }
 }
-
-async function urlToBase64(imageURL: string) {
-    try {
-        const convertedBuffer = await converter(imageURL, 'png');
-  
-        const base64String = convertedBuffer.toString('base64');
-        return base64String;
-    } catch (error: any) {
-        throw new Error(`Failed to fetch and convert the image: ${error.message}`);
-    }
-  }
-