halbot 1993.2.90 → 1993.2.92

package/index.mjs

@@ -6,8 +6,10 @@ const skillPath = utilitas.__(import.meta.url, 'skills');
 
 const init = async (options = {}) => {
     assert(options.telegramToken, 'Telegram Bot API Token is required.');
-    const [pkg, _speech, speechOptions, vision]
-        = [await utilitas.which(), {}, { tts: true, stt: true }, {}];
+    const [pkg, _speech, speechOptions, vision] = [
+        await utilitas.which(), options?.speech || {}, { tts: true, stt: true },
+        {},
+    ];
     const info = bot.lines([
         `[${hal.EMOJI_BOT} ${pkg.title}](${pkg.homepage})`, pkg.description
     ]);
@@ -16,7 +18,7 @@ const init = async (options = {}) => {
     if (options.openaiApiKey || options.googleApiKey) {
         vision.read = alan.distillFile;
         vision.see = alan.distillFile;
-        _speech.stt = alan.distillFile;
+        _speech?.stt || (_speech.stt = alan.distillFile);
     }
     // use openai embedding, dall-e, tts if openai is enabled
     if (options.openaiApiKey) {
@@ -26,8 +28,10 @@ const init = async (options = {}) => {
             priority: options.openaiPriority, ...options
         });
         await gen.init(apiKey);
-        await speech.init({ ...apiKey, ...speechOptions });
-        _speech.tts = speech.tts;
+        if (!_speech.tts) {
+            await speech.init({ ...apiKey, ...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

package/lib/hal.mjs

@@ -1,5 +1,5 @@
 import {
-    alan, bot, callosum, dbio, storage, uoid, utilitas, web,
+    bot, callosum, dbio, media, speech, storage, uoid, utilitas, web,
 } from 'utilitas';
 
 import { basename, join } from 'path';
@@ -612,7 +612,11 @@ const subconscious = [{
                 const analyze = async () => {
                     const resp = await utilitas.ignoreErrFunc(async () => {
                         [
-                            alan.mp3, alan.mpega, alan.mp4, alan.mpeg, alan.mpga, alan.m4a, alan.wav, alan.webm, alan.ogg
+                            storage.MIME_MP3, storage.MIME_MPEGA,
+                            storage.MIME_MP4, storage.MIME_MPEG,
+                            storage.MIME_MPGA, storage.MIME_M4A,
+                            storage.MIME_WAV, storage.MIME_WEBM,
+                            storage.MIME_OGG,
                         ].includes(audio.mime_type) || (
                                 file = await media.convertAudioTo16kNanoPcmWave(
                                     file, { input: storage.BUFFER, expected: storage.BUFFER }
@@ -623,9 +627,9 @@ const subconscious = [{
                     log(`STT: '${resp}'`);
                     ctx.collect(resp);
                 };
-                if (hal._.supportedMimeTypes.has(alan.wav)) {
+                if (hal._.supportedMimeTypes.has(storage.MIME_WAV)) {
                     ctx.collect({
-                        mime_type: alan.wav, url, analyze,
+                        mime_type: storage.MIME_WAV, url, analyze,
                         data: await media.convertAudioTo16kNanoPcmWave(file, {
                             input: storage.BUFFER, expected: storage.BASE64,
                         }),
@@ -736,9 +740,10 @@ const subconscious = [{
             if (m.photo?.[m.photo?.length - 1]) {
                 const p = m.photo[m.photo.length - 1];
                 files.push({
-                    asPrompt: hal._.supportedMimeTypes.has(alan.jpeg),
+                    asPrompt: hal._.supportedMimeTypes.has(storage.MIME_JPEG),
                     file_name: `${p.file_id}.jpg`, fileId: p.file_id,
-                    mime_type: alan.jpeg, type: 'PHOTO', ocrFunc: ctx._.vision?.see,
+                    mime_type: storage.MIME_JPEG, type: 'PHOTO',
+                    ocrFunc: ctx._.vision?.see,
                 });
             }
             if (m.video_note) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "halbot",
   "description": "Just another `ChatGPT` / `Gemini` / `Claude` / `Azure` / `Jina` / `Ollama` Telegram bob, which is simple design, easy to use, extendable and fun.",
-  "version": "1993.2.90",
+  "version": "1993.2.92",
   "private": false,
   "homepage": "https://github.com/Leask/halbot",
   "type": "module",
@@ -46,12 +46,12 @@
     "mime": "^4.0.7",
     "mysql2": "^3.14.1",
     "office-text-extractor": "^3.0.3",
-    "openai": "^4.96.2",
+    "openai": "^4.97.0",
     "pg": "^8.15.6",
     "pgvector": "^0.2.0",
     "telegraf": "^4.16.3",
     "tesseract.js": "^6.0.1",
-    "utilitas": "^1999.1.60",
+    "utilitas": "^1999.1.63",
     "youtube-transcript": "^1.2.1"
   }
 }

package/skills/-8845_thread.mjs

@@ -1,6 +1,6 @@
 import { alan, hal, uoid, utilitas } from '../index.mjs';
 
-const [EMIJI_FINISH, END, NEW, THREAD] = ['☑️', '❎', '✨', '🧵'];
+const [EMIJI_FINISH, END, NEW, THREAD, CLR] = ['☑️', '❎', '✨', '🧵', '🆑'];
 
 const [CREATED, SWITCHED] = [
     `${NEW} Thread created: `, `${EMIJI_FINISH} Thread switched: `

package/skills/40_dream.mjs

@@ -1,13 +1,19 @@
-import { bot } from '../index.mjs';
+import { bot, storage } from '../index.mjs';
 
 const GEMINI = 'GEMINI';
 const types = { image: 'photo', video: 'video' };
 
 const action = async (ctx, next) => {
-    let [provider, func] = [GEMINI, 'image'];
+    let [provider, func, reference] = [GEMINI, 'image', null];
     switch (ctx.cmd.cmd) {
-        case 'gptimage': provider = 'OPENAI'; break;
-        case 'fantasy': func = 'video';
+        case 'fantasy': func = 'video'; break;
+        case 'gptimage':
+            provider = 'OPENAI';
+            reference = ctx.collected.filter(x => [
+                storage.MIME_JPEG, storage.MIME_PNG, storage.MIME_WEBP
+            ].includes(x?.content?.mime_type)).slice(0, 16).map(
+                x => x?.content?.data
+            );
     }
     if (!ctx.cmd.args) {
         return await ctx.ok('Please input your prompt.');
@@ -15,7 +21,8 @@ const action = async (ctx, next) => {
     let [objMsg, output] = [(await ctx.ok('💭'))[0], null]; //tts = null
     try {
         output = (await ctx._.gen[func](ctx.cmd.args, {
-            provider, expected: 'FILE'
+            provider, expected: 'FILE',
+            ...reference?.length ? { reference, input: 'BASE64' } : {},
         })) || [];
     } catch (err) {
         return await ctx.er(err.message || `Error generating ${func}.`,

package/skills/70_chat.mjs

@@ -8,25 +8,31 @@ const log = content => utilitas.log(content, import.meta.url);
 const action = async (ctx, next) => {
     if (!ctx.prompt && !ctx.carry.attachments.length) { return await next(); }
     let [
-        ais, YOU, msgs, tts, rsm, pms, extra, lock, sResp, lastMsg, lastSent,
-        references, audio
+        ais, YOU, msgs, pms, extra, lock, sResp, lastMsg, lastSent, references,
+        audio,
     ] = [
-            await alan.getAi(null, { all: true }), `${ctx.avatar} You:`, {}, {},
-            {}, [], { buttons: [] }, 1000 * 5, null, null, 0, null, null,
+            await alan.getAi(null, { all: true }), `${ctx.avatar} You:`, {}, [],
+            { buttons: [] }, 1000 * 5, null, null, 0, null, null,
         ];
     const packMsg = options => {
         const said = !options?.tts && ctx.result ? ctx.result : '';
         const packed = [
             ...ctx.carry?.threadInfo, ...said ? [joinL2([YOU, said])] : [],
         ];
-        const source = options?.tts ? tts : msgs;
         const pure = [];
         ctx.selectedAi.map(n => {
-            const content = source[n] || '';
+            const content = msgs[n]?.[options?.tts ? 'spoken' : 'text'] || '';
             pure.push(content);
-            packed.push(joinL2([...options?.tts ? [] : [
-                `${ais.find(x => x.id === n).name}:`
-            ], content]));
+            const ai = ais.find(x => x.id === n);
+            let aiName = ai.name;
+            const defModel = aiName.replace(/^.*\(.*\)$/, '$1');
+            const curModel = msgs[n]?.model;
+            if (defModel && curModel && defModel !== curModel) {
+                aiName = aiName.replace(/^(.*\().*(\))$/, `$1${curModel}$2`);
+            }
+            packed.push(joinL2([
+                ...options?.tts ? [] : [`${aiName}:`], content
+            ]));
         });
         return pure.join('').trim().length ? joinL1(packed) : '';
     };
@@ -56,34 +62,35 @@ const action = async (ctx, next) => {
     for (const n of ctx.selectedAi) {
         pms.push((async ai => {
             try {
-                const resp = await alan.talk(ctx.prompt || alen.ATTACHMENTS, {
+                const resp = await alan.talk(ctx.prompt || alan.ATTACHMENTS, {
                     aiId: ai, ...ctx.carry, stream: async r => {
-                        msgs[ai] = r.text;
+                        msgs[ai] = r;
                         ctx.carry.threadInfo.length || ok(onProgress);
                     },
                 });
                 references = resp.references;
                 audio = resp.audio;
-                msgs[ai] = resp.text;
-                tts[ai] = ctx.selectedAi.length === 1
-                    && !msgs[ai].split('\n').some(x => /^\s*```/.test(x))
-                    ? resp.spoken : '';
+                msgs[ai] = resp;
+                msgs[ai].spoken = ctx.selectedAi.length === 1
+                    && !resp.text.split('\n').some(x => /^\s*```/.test(x))
+                    ? resp.spoken : null;
                 for (let img of resp?.images || []) {
                     await ctx.image(img.data, { caption: `🎨 by ${resp.model}` });
                     await ctx.timeout();
                 }
                 return resp;
             } catch (err) {
-                msgs[ai] = `⚠️ ${err?.message || err}`;
-                tts[ai] = null;
-                rsm[ai] = null;
+                msgs[ai] = {
+                    ...msgs[ai], text: `⚠️ ${err?.message || err}`,
+                    spoken: null,
+                };
                 log(err);
             }
         })(n));
     }
     await Promise.all(pms);
-    if (Object.values(msgs).join('').trim()) { await ok({ final: true }); }
-    else { await ctx.deleteMessage(sResp[0].message_id); }
+    await (Object.values(msgs).map(x => x.text).join('').trim()
+        ? ok({ final: true }) : ctx.deleteMessage(sResp[0].message_id));
     ctx.tts = audio || packMsg({ tts: true });
     await next();
 };