halbot 1993.2.59 → 1993.2.61

package/index.mjs

@@ -1,4 +1,4 @@
-import { alan, bot, image, shot, speech, utilitas } from 'utilitas';
+import { alan, bot, image, web, speech, utilitas } from 'utilitas';
 
 await utilitas.locate(utilitas.__(import.meta.url, 'package.json'));
 const skillPath = utilitas.__(import.meta.url, 'skills');
@@ -10,7 +10,6 @@ const init = async (options = {}) => {
     const info = bot.lines([
         `[${bot.EMOJI_BOT} ${pkg.title}](${pkg.homepage})`, pkg.description
     ]);
-    let embedding;
     // init ai engines
     // use AI vision, AI stt if ChatGPT or Gemini is enabled
     if (options.openaiApiKey || options.googleApiKey) {
@@ -21,55 +20,74 @@ const init = async (options = {}) => {
     // use openai embedding, dall-e, tts if openai is enabled
     if (options.openaiApiKey) {
         const apiKey = { apiKey: options.openaiApiKey };
-        const ai = await alan.init({
-            id: 'ChatGPT', provider: 'OPENAI', model: options?.chatGptModel,
-            ...apiKey, priority: options?.chatGptPriority || 0, ...options
+        await alan.init({
+            provider: 'OPENAI', model: options.openaiModel || '*',
+            ...apiKey, priority: options.openaiPriority, ...options
         });
-        embedding = ai.embedding;
         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) {
+    if (options.googleApiKey) {
         const apiKey = { apiKey: options.googleApiKey };
-        const ai = await alan.init({
-            id: 'Gemini', provider: 'GEMINI', model: options?.geminiModel,
-            ...apiKey, priority: options?.geminiPriority || 1, ...options
+        await alan.init({
+            provider: 'GEMINI', model: options.geminiModel || '*',
+            ...apiKey, priority: options.geminiPriority, ...options
         });
-        embedding || (embedding = ai.embedding);
         if (!_speech.tts) {
             await speech.init({
-                ...apiKey, provider: 'GOOGLE', ...speechOptions,
+                provider: 'GOOGLE', ...apiKey, ...speechOptions,
             });
             _speech.tts = speech.tts;
         }
-        options?.googleCx && await shot.initSearch({
-            apiKey: options.googleApiKey, cx: options.googleCx
+        options.googleCx && await web.initSearch({
+            provider: 'GOOGLE', ...apiKey, cx: options.googleCx
+        });
+    }
+    if (options.anthropicApiKey) {
+        await alan.init({
+            provider: 'ANTHROPIC', model: options.anthropicModel || '*',
+            apiKey: options.anthropicApiKey,
+            priority: options.anthropicPriority, ...options
+        });
+    }
+    if (options.anthropicCredentials && options.anthropicProjectId) {
+        await alan.init({
+            provider: 'VERTEX ANTHROPIC', model: options.anthropicModel || '*',
+            credentials: options.anthropicCredentials,
+            projectId: options.anthropicProjectId,
+            priority: options.anthropicPriority, ...options
+        });
+    }
+    if (options.jinaApiKey) {
+        const apiKey = { apiKey: options.jinaApiKey };
+        await alan.init({
+            provider: 'JINA', model: options.jinaModel || '*',
+            ...apiKey, priority: options.jinaPriority, ...options
         });
+        await web.initSearch({ provider: 'Jina', ...apiKey });
     }
-    if (options?.anthropicApiKey
-        || (options?.anthropicCredentials && options?.anthropicProjectId)) {
+    if (options.azureApiKey && options.azureEndpoint) {
         await alan.init({
-            id: 'Claude', provider: 'VERTEX ANTHROPIC', model: options?.anthropicModel,
-            apiKey: options?.anthropicApiKey,
-            credentials: options?.anthropicCredentials,
-            projectId: options?.anthropicProjectId,
-            priority: options?.anthropicPriority || 2, ...options
+            provider: 'AZURE', model: options.azureModel,
+            apiKey: options.azureApiKey, priority: options.azurePriority,
+            baseURL: options.azureEndpoint, ...options
         });
     }
-    if (options?.azureApiKey && options?.azureEndpoint) {
+    if (options.azureOpenaiApiKey && options.azureOpenaiEndpoint) {
         await alan.init({
-            id: 'Azure', provider: 'AZURE', model: options?.azureModel,
-            apiKey: options?.azureApiKey, priority: options?.azurePriority || 3,
-            baseURL: options?.azureEndpoint, ...options
+            provider: 'AZURE OPENAI', model: options.azureOpenaiModel,
+            apiKey: options.azureOpenaiApiKey,
+            priority: options.azureOpenaiPriority,
+            endpoint: options.azureOpenaiEndpoint, ...options
         });
     }
     if (options?.ollamaEnabled || options?.ollamaEndpoint) {
         await alan.init({
-            id: 'Ollama', provider: 'OLLAMA', model: options?.ollamaModel,
-            priority: options?.ollamaPriority || 99,
+            provider: 'OLLAMA', model: options?.ollamaModel || '*',
+            priority: options?.ollamaPriority,
             host: options?.ollamaEndpoint, ...options
         });
     }
@@ -88,7 +106,8 @@ const init = async (options = {}) => {
         chatType: options?.chatType,
         cmds: options?.cmds,
         database: options?.storage?.client && options?.storage,
-        embedding, supportedMimeTypes,
+        embedding: ais.find(x => x.embedding)?.embedding,
+        supportedMimeTypes,
         hello: options?.hello,
         help: options?.help,
         homeGroup: options?.homeGroup,

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.59",
+  "version": "1993.2.61",
   "private": false,
   "homepage": "https://github.com/Leask/halbot",
   "type": "module",
@@ -33,10 +33,10 @@
     "@anthropic-ai/vertex-sdk": "^0.7.0",
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
     "@ffprobe-installer/ffprobe": "^2.1.2",
-    "@google-cloud/speech": "^6.7.1",
-    "@google-cloud/text-to-speech": "^5.8.1",
-    "@google-cloud/vision": "^4.3.3",
-    "@google/generative-ai": "^0.24.0",
+    "@google-cloud/speech": "^7.0.0",
+    "@google-cloud/text-to-speech": "^6.0.0",
+    "@google-cloud/vision": "^5.0.0",
+    "@google/genai": "^0.4.0",
     "@mozilla/readability": "^0.6.0",
     "fluent-ffmpeg": "^2.1.3",
     "ioredis": "^5.6.0",
@@ -46,12 +46,12 @@
     "mime": "^4.0.6",
     "mysql2": "^3.13.0",
     "office-text-extractor": "^3.0.3",
-    "openai": "^4.87.3",
-    "pg": "^8.14.0",
+    "openai": "^4.87.4",
+    "pg": "^8.14.1",
     "pgvector": "^0.2.0",
     "telegraf": "^4.16.3",
     "tesseract.js": "^6.0.0",
-    "utilitas": "^1999.1.10",
+    "utilitas": "^1999.1.24",
     "youtube-transcript": "^1.2.1"
   }
 }

package/skills/-8845_thread.mjs

@@ -1,6 +1,6 @@
 import { alan, bot, uoid, utilitas } from 'utilitas';
 
-const [EMIJI_FINISH, END, NEW, THREAD, CLR] = ['☑️', '❎', '✨', '🧵', '🆑'];
+const [EMIJI_FINISH, END, NEW, THREAD] = ['☑️', '❎', '✨', '🧵'];
 
 const [CREATED, SWITCHED] = [
     `${NEW} Thread created: `, `${EMIJI_FINISH} Thread switched: `
@@ -8,14 +8,14 @@ const [CREATED, SWITCHED] = [
 
 // moved to help and configs
 const keyboards = [[
-    { text: `/clear ${CLR}` },
+    { text: `/ai ${bot.EMOJI_BOT}` },
+    { text: `/new ${NEW}` },
     { text: `/end ${END}` },
     { text: `/list ${THREAD}` },
-    { text: `/new ${NEW}` },
 ], [
     { text: '/polish ❇️' },
-    { text: '/translate 🇨🇳' },
-    { text: '/translate 🇺🇸' },
+    { text: '/to 🇨🇳' },
+    { text: '/to 🇺🇸' },
 ], [
     { text: '/help 🛟' },
     { text: '/set --tts=🔇' },
@@ -91,7 +91,7 @@ const action = async (ctx, next) => {
         ...options || {},
         ...options?.buttons ? {} : (options?.keyboards || { keyboards }),
     });
-    const sendList = async (names, lastMsgId) => {
+    const listThreads = async (names, lastMsgId) => {
         lastMsgId = lastMsgId || ctx.update?.callback_query?.message?.message_id;
         const message = `${THREAD} Thread${ctx.session.sessions.length > 0 ? 's' : ''}:`;
         const buttons = ctx.session.sessions.map((x, i) => {
@@ -121,7 +121,7 @@ const action = async (ctx, next) => {
                 + `${getLabel(findSession(ctx.session.sessionId))}\``);
             await ctx.clear();
             break;
-        case 'clearall':
+        case 'endall':
             ctx.carry.threadInfo.push(`🔄 All threads have been cleared.`);
             resetSessions();
             break;
@@ -129,14 +129,14 @@ const action = async (ctx, next) => {
             resetSession();
             break;
         case 'list':
-            const resp = await sendList();
+            const resp = await listThreads();
             utilitas.ignoreErrFunc(async () => {
                 const sNames = await alan.analyzeSessions(
                     ctx.session.sessions.filter(
                         x => (x.labelUpdatedAt || 0) < x.touchedAt
                     ).map(x => x.id), { ignoreRequest: bot.HELLO }
                 );
-                return await sendList(sNames, resp[0]?.message_id);
+                return await listThreads(sNames, resp[0]?.message_id);
             }, { log: true });
             return resp;
         case 'end':
@@ -157,7 +157,7 @@ const action = async (ctx, next) => {
         case 'switch':
             ctx.session.sessionId = utilitas.trim(ctx.cmd.args);
             await switchSession();
-            await sendList();
+            await listThreads();
             return await switched();
         case 'factory':
         case 'reset':
@@ -168,18 +168,18 @@ const action = async (ctx, next) => {
     await next();
 };
 
-export const { name, run, priority, func, help, cmds, cmdx } = {
+export const { name, run, priority, func, help, cmdx } = {
     name: 'Thread',
     run: true,
     priority: -8845,
     func: action,
     help: 'Thread management.',
     cmdx: {
-        new: 'Create a new thread.',
-        end: 'End current thread.',
-        switch: 'Switch to a thread. Usage: /switch `THREAD_ID`.',
         clear: 'Clear current thread.',
-        clearall: 'Clear all threads.',
+        end: 'End current thread.',
+        endall: 'End all threads.',
         list: 'List all threads.',
+        new: 'Create a new thread.',
+        switch: 'Switch to a thread. Usage: /switch `THREAD_ID`.',
     },
 };

package/skills/{10_engine.mjs → 10_ai.mjs}

@@ -1,20 +1,26 @@
 import { alan, bot, utilitas } from 'utilitas';
 
-const NAME_HACK = {
-    'ChatGPT': '⚛️', 'Gemini': '♊️', 'Claude': '✴️', 'Ollama': '🦙', 'Azure': '☁️',
-};
-
-const NAME_HACK_REVERSE = utilitas.reverseKeyValues(NAME_HACK);
-const AI_CMD = '/set --ai=';
+const EMIJI_FINISH = '☑️';
 
 const action = async (ctx, next) => {
     const ais = await alan.getAi(null, { all: true });
-    if (ctx.carry?.keyboards?.length && !ctx.carry.keyboards.find(
-        x => x.find(y => y.text.includes(AI_CMD))
-    )) {
-        ctx.carry.keyboards.unshift(ais.slice(0, 3).map(
-            x => ({ text: `${AI_CMD}${NAME_HACK[x.id] || x.id}` })
-        ));
+    const listAIs = async () => {
+        const lastMessageId = ctx.update?.callback_query?.message?.message_id;
+        const message = `${bot.EMOJI_BOT} AI${ais.length > 0 ? 's' : ''}:`;
+        const buttons = ais.map(x => ({
+            label: `${ctx.session.config?.ai === x.id
+                ? `${EMIJI_FINISH} ` : ''}${x.name}: ${x.features}`,
+            text: `/ai ${x.id}`,
+        }));
+        return await ctx.ok(message, { lastMessageId, buttons });
+    };
+    switch (ctx.cmd?.cmd) {
+        case 'ai':
+            const aiId = utilitas.trim(ctx.cmd.args);
+            if (!aiId || aiId === bot.EMOJI_BOT) { return await listAIs(); }
+            assert(ais.find(x => x.id === aiId), 'No AI engine matched.');
+            ctx.session.config.ai = aiId;
+            return await listAIs();
     }
     switch (ctx.session.config?.ai) {
         case '@': ctx.selectedAi = ais.map(x => x.id); break;
@@ -52,37 +58,22 @@ const action = async (ctx, next) => {
     await next();
 };
 
-const validateAi = async val => {
-    NAME_HACK_REVERSE[val] && (val = NAME_HACK_REVERSE[val]);
-    for (let name of [...(
-        await alan.getAi(null, { all: true })
-    ).map(x => x.id), '', '@']) {
-        if (utilitas.insensitiveCompare(val, name)) { return name; }
-    }
-    utilitas.throwError('No AI engine matched.');
-};
-
-export const { name, run, priority, func, help, args } = {
-    name: 'Engine',
+export const { name, run, priority, func, help, args, cmdx } = {
+    name: 'AI',
     run: true,
     priority: 10,
     func: action,
     help: bot.lines([
         '¶ Set initial prompt to the AI engine.',
         "Tip 1: Set `hello=''` to reset to default initial prompt.",
-        '¶ Select between AI engines.',
-        "Tip 2: Set `ai=''` to use default AI engine.",
-        'Tip 3: Set `ai=@` to use all AI engines simultaneously.',
     ]),
     args: {
         hello: {
             type: 'string', short: 's', default: 'You are a helpful assistant.',
             desc: "Change initial prompt: /set --hello 'Bonjour!'",
         },
-        ai: {
-            type: 'string', short: 'a', default: '',
-            desc: "`(ChatGPT, Gemini, Claude, Azure, Ollama, @)` Select AI engine.",
-            validate: validateAi,
-        },
     },
+    cmdx: {
+        ai: 'List all available AIs.',
+    }
 };

package/skills/30_wording.mjs

@@ -37,7 +37,7 @@ const action = async (ctx, next) => {
             ctx.result = bot.map(cnf);
             ctx.hello();
             break;
-        case 'translate': promptTranslate(ctx, ctx.cmd.args || ctx.session.config?.lang || ctx._.lang); break;
+        case 'to': promptTranslate(ctx, ctx.cmd.args || ctx.session.config?.lang || ctx._.lang); break;
         case 'polish': promptPolish(ctx); break;
         case 'toen': promptTranslate(ctx, 'English'); break;
         case 'tofr': promptTranslate(ctx, 'French'); break;

package/skills/70_chat.mjs

@@ -1,16 +1,12 @@
-import { alan, bot, storage, utilitas } from 'utilitas';
+import { alan, utilitas } from 'utilitas';
 
 const onProgress = { onProgress: true };
+const LN2 = '\n\n';
 const [joinL1, joinL2] = [a => a.join(LN2), a => a.join(LN2)];
 const log = content => utilitas.log(content, import.meta.url);
-const enrich = m => m ? ` ${BOTS[m.split(':')[0]]
-    ? `| ${BOTS[m.split(':')[0]]} ${m}` : `(${m})`}` : '';
-const [BOT, BOTS, LN2] = [`${bot.EMOJI_BOT} `, {
-    ChatGPT: '⚛️', Gemini: '♊️', Claude: '✴️', Ollama: '🦙', 'deepseek-r1': '🐳',
-    Azure: '☁️',
-}, '\n\n'];
 
 const action = async (ctx, next) => {
+    const ais = await alan.getAi(null, { all: true });
     if (!ctx.prompt && !ctx.carry.attachments.length) { return await next(); }
     const [YOU, msgs, tts, rsm, pms, extra, lock]
         = [`${ctx.avatar} You:`, {}, {}, {}, [], { buttons: [] }, 1000 * 5];
@@ -26,7 +22,7 @@ const action = async (ctx, next) => {
             const content = source[n] || '';
             pure.push(content);
             packed.push(joinL2([...options?.tts ? [] : [
-                `${BOTS[n]} ${n}${enrich(rsm[n])}:`
+                `${ais.find(x => x.id === n).name}:`
             ], content]));
         });
         return pure.join('').trim().length ? joinL1(packed) : '';
@@ -69,7 +65,6 @@ const action = async (ctx, next) => {
                 tts[ai] = ctx.selectedAi.length === 1
                     && !msgs[ai].split('\n').some(x => /^\s*```/.test(x))
                     ? resp.spoken : '';
-                rsm[ai] = resp.model;
                 for (let img of resp?.images || []) {
                     await ctx.image(img.data, { caption: `🎨 by ${resp.model}` });
                     await ctx.timeout();