halbot 1993.2.23 → 1993.2.25

package/README.md

@@ -91,12 +91,6 @@ All supported configuration fields:
     // OPTIONAL, integer, default: 1.
     "chatGptPriority": "[[Custom ChatGPT Priority]]",
 
-    // Set some of these fields if you need to use custom ChatGPT API.
-    // OPTIONAL, string.
-    "chatGptApiKey": "[[Custom ChatGPT API Key]]",
-    // OPTIONAL, string.
-    "chatGptEndpoint": "[[Custom ChatGPT API endpoint]]",
-
     // Set some of these fields if you need Anthropic's Claude features.
     // OPTIONAL, string.
     "claudeApiKey": "[[Anthropic API Key]]",

package/index.mjs

@@ -1,4 +1,4 @@
-import { alan, bot, image, shot, speech, utilitas, vision } from 'utilitas';
+import { alan, bot, image, shot, speech, utilitas } from 'utilitas';
 import { parse } from 'csv-parse/sync';
 
 await utilitas.locate(utilitas.__(import.meta.url, 'package.json'));
@@ -29,40 +29,51 @@ const fetchPrompts = async () => {
 
 const init = async (options) => {
     assert(options?.telegramToken, 'Telegram Bot API Token is required.');
-    const [pkg, ai, _speech, speechOptions, engines]
-        = [await utilitas.which(), {}, {}, { tts: true, stt: true }, {}];
+    const [pkg, ai, _speech, speechOptions, engines, vision]
+        = [await utilitas.which(), {}, {}, { tts: true, stt: true }, {}, {}];
     const info = bot.lines([
         `[${bot.EMOJI_BOT} ${pkg.title}](${pkg.homepage})`, pkg.description
     ]);
     let embedding;
     // init ai engines
-    if (options?.openaiApiKey || options?.chatGptApiKey) {
-        await alan.init({
-            provider: 'OPENAI',
-            apiKey: options?.openaiApiKey || options?.chatGptApiKey,
-            ...options || {},
-        });
+    // use AI vision, AI stt if ChatGPT or Gemini is enabled
+    if (options?.openaiApiKey || options?.googleApiKey) {
+        vision.read = alan.distillFile;
+        vision.see = alan.distillFile;
+        _speech.stt = alan.distillFile;
+    }
+    // use openai embedding, dall-e, tts if openai is enabled
+    if (options?.openaiApiKey) {
+        const apiKey = { apiKey: options.openaiApiKey };
+        await alan.init({ provider: 'OPENAI', ...apiKey, ...options || {} });
         ai['ChatGPT'] = {
             engine: 'CHATGPT', priority: options?.chatGptPriority || 0,
-        };
-        engines['CHATGPT'] = {
-            // only support custom model while prompting
-            model: options?.chatGptModel,
-        };
+        }; // only support custom model while prompting:
+        engines['CHATGPT'] = { model: options?.chatGptModel, };
+        embedding = alan.createOpenAIEmbedding;
+        await image.init(apiKey);
+        await speech.init({ ...apiKey, provider: 'OPENAI', ...speechOptions });
+        _speech.tts = speech.tts;
     }
+    // use gemini embedding if gemini is enabled and chatgpt is not enabled
+    // use google tts if google api key is ready
     if (options?.googleApiKey) {
-        await alan.init({
-            provider: 'GEMINI', apiKey: options?.googleApiKey,
-            model: options?.geminiModel, // only support custom model while initiating
-            ...options || {},
+        const apiKey = { apiKey: options.googleApiKey };
+        await alan.init({ // only support custom model while initiating:
+            provider: 'GEMINI', ...apiKey,
+            model: options?.geminiModel, ...options || {},
         });
         ai['Gemini'] = {
             engine: 'GEMINI', priority: options?.geminiPriority || 1,
-        };
-        engines['GEMINI'] = {
-            // save for reference not for prompting
-            model: options?.geminiModel,
-        };
+        }; // save for reference not for prompting:
+        engines['GEMINI'] = { model: options?.geminiModel };
+        embedding || (embedding = alan.createGeminiEmbedding);
+        if (!_speech.tts) {
+            await speech.init({
+                ...apiKey, provider: 'GOOGLE', ...speechOptions,
+            });
+            _speech.tts = speech.tts;
+        }
     }
     if (options?.claudeApiKey) {
         await alan.init({
@@ -71,11 +82,8 @@ const init = async (options) => {
         });
         ai['Claude'] = {
             engine: 'CLAUDE', priority: options?.claudePriority || 2,
-        };
-        engines['CLAUDE'] = {
-            // only support custom model while prompting
-            model: options?.claudeModel,
-        };
+        }; // only support custom model while prompting:
+        engines['CLAUDE'] = { model: options?.claudeModel };
     }
     if (options?.ollamaEnabled || options?.ollamaEndpoint) {
         await alan.init({
@@ -92,27 +100,12 @@ const init = async (options) => {
     assert(utilitas.countKeys(ai), 'No AI provider is configured.');
     await alan.initChat({ engines, sessions: options?.storage });
     for (const i in ai) { ai[i].model = engines[ai[i].engine].model; }
-    // init image, speech, embedding engines
-    if (options?.openaiApiKey) {
-        const apiKey = { apiKey: options.openaiApiKey };
-        await image.init(apiKey);
-        await speech.init({ ...apiKey, provider: 'OPENAI', ...speechOptions });
-        embedding = alan.createOpenAIEmbedding;
-    } else if (options?.googleApiKey) {
-        const apiKey = { apiKey: options.googleApiKey };
-        await speech.init({ ...apiKey, provider: 'GOOGLE', ...speechOptions });
-        embedding = alan.createGeminiEmbedding;
-    }
-    // init vision / audio engine
+    // config multimodal engines
     const supportedMimeTypes = new Set(Object.values(engines).map(
         x => alan.MODELS[x.model]
     ).map(x => [
         ...x.supportedMimeTypes || [], ...x.supportedAudioTypes || [],
     ]).flat().map(x => x.toLowerCase()));
-    if (options?.googleApiKey) {
-        const apiKey = { apiKey: options.googleApiKey };
-        await vision.init(apiKey);
-    }
     // init bot
     const _bot = await bot.init({
         args: options?.args,
@@ -131,8 +124,7 @@ const init = async (options) => {
         botProvider: 'telegram',
         session: options?.storage,
         skillPath: options?.skillPath || skillPath,
-        speech: (options?.openaiApiKey || options?.googleApiKey) && speech,
-        vision: options?.googleApiKey && vision,
+        speech: _speech, vision,
     });
     _bot._.ai = ai;                                                             // Should be an array of a map of AIs.
     _bot._.lang = options?.lang || 'English';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "halbot",
   "description": "Just another `ChatGPT` / `Gemini` / `Ollama` Telegram bob, which is simple design, easy to use, extendable and fun.",
-  "version": "1993.2.23",
+  "version": "1993.2.25",
   "private": false,
   "homepage": "https://github.com/Leask/halbot",
   "type": "module",
@@ -40,7 +40,7 @@
     "csv-parse": "^5.6.0",
     "fluent-ffmpeg": "^2.1.3",
     "ioredis": "^5.4.2",
-    "js-tiktoken": "^1.0.16",
+    "js-tiktoken": "^1.0.17",
     "jsdom": "^26.0.0",
     "lorem-ipsum": "^2.0.8",
     "mime": "^4.0.6",
@@ -52,7 +52,7 @@
     "pgvector": "^0.2.0",
     "telegraf": "^4.16.3",
     "tesseract.js": "^6.0.0",
-    "utilitas": "^1998.2.6",
+    "utilitas": "^1998.2.13",
     "youtube-transcript": "^1.2.1"
   }
 }

package/skills/60_prepare.mjs

@@ -1,5 +1,21 @@
 import { alan, bot, utilitas } from 'utilitas';
 
+const checkUnsupportedMimeType = async ctx => {
+    ctx.carry.attachments = [];
+    for (const x of ctx.collected.filter(x => x.type === 'PROMPT')) {
+        let notSupported = false;
+        ctx.selectedAi.map(y => {
+            if (![
+                ...alan.MODELS[ctx._.ai[y].model]?.supportedMimeTypes || [],
+                ...alan.MODELS[ctx._.ai[y].model]?.supportedAudioTypes || [],
+            ].includes(y?.content?.mime_type)) { notSupported = true; }
+        });
+        notSupported ? await x.content.analyze() : ctx.carry.attachments.push({
+            ...x.content, analyze: undefined,
+        });
+    }
+};
+
 const action = async (ctx, next) => {
     // avatar
     if (ctx.result) {
@@ -16,9 +32,7 @@ const action = async (ctx, next) => {
         ctx.avatar = '😸';
     }
     // prompt
-    ctx.carry.attachments = ctx.collected.filter(
-        x => x.type === 'PROMPT'
-    ).map(x => x.content);
+    await checkUnsupportedMimeType(ctx);
     const maxInputTokens = alan.getMaxChatPromptLimit()
         - alan.ATTACHMENT_TOKEN_COST * ctx.carry.attachments.length;
     const additionInfo = ctx.collected.filter(
@@ -28,7 +42,7 @@ const action = async (ctx, next) => {
     while (await alan.countTokens(
         `${ctx.prompt}${additionInfo?.[0] || ''}`
     ) < maxInputTokens && additionInfo.length) {
-        ctx.prompt += ` ${additionInfo.shift()}`;
+        ctx.prompt += `${additionInfo.shift()} `;
     }
     ctx.prompt = utilitas.trim(ctx.prompt);
     additionInfo.filter(x => x).length && (ctx.prompt += '...');