halbot 1993.2.89 → 1993.2.91

package/index.mjs

@@ -1,4 +1,4 @@
-import { alan, bot, image, web, speech, utilitas } from 'utilitas';
+import { alan, bot, gen, web, speech, utilitas } from 'utilitas';
 import * as hal from './lib/hal.mjs';
 
 await utilitas.locate(utilitas.__(import.meta.url, 'package.json'));
@@ -25,7 +25,7 @@ const init = async (options = {}) => {
             ...apiKey, model: options.openaiModel || '*',
             priority: options.openaiPriority, ...options
         });
-        await image.init(apiKey);
+        await gen.init(apiKey);
         await speech.init({ ...apiKey, ...speechOptions });
         _speech.tts = speech.tts;
     }
@@ -37,7 +37,6 @@ const init = async (options = {}) => {
             ...apiKey, provider: 'GEMINI', model: options.geminiModel || '*',
             priority: options.geminiPriority, ...options
         });
-        await image.init({ ...apiKey, provider: 'GEMINI' });
         if (!_speech.tts) {
             await speech.init({ ...apiKey, ...speechOptions });
             _speech.tts = speech.tts;
@@ -46,6 +45,13 @@ const init = async (options = {}) => {
             ...apiKey, cx: options.googleCx,
         });
     }
+    const geminiGenReady = options.googleApiKey
+        || (options.googleCredentials && options.googleProjectId);
+    geminiGenReady && await gen.init({
+        apiKey: options.googleApiKey, provider: 'GEMINI',
+        credentials: options.googleCredentials,
+        projectId: options.googleProjectId,
+    });
     if (options.anthropicApiKey) {
         await alan.init({
             provider: 'ANTHROPIC', model: options.anthropicModel || '*',
@@ -53,11 +59,11 @@ const init = async (options = {}) => {
             priority: options.anthropicPriority, ...options
         });
     }
-    if (options.anthropicCredentials && options.anthropicProjectId) {
+    if (options.googleCredentials && options.googleProjectId) {
         await alan.init({
             provider: 'VERTEX ANTHROPIC', model: options.anthropicModel || '*',
-            credentials: options.anthropicCredentials,
-            projectId: options.anthropicProjectId,
+            credentials: options.googleCredentials,
+            projectId: options.googleProjectId,
             priority: options.anthropicPriority, ...options
         });
     }
@@ -130,7 +136,8 @@ const init = async (options = {}) => {
         speech: _speech, vision,
     });
     _hal._.lang = options?.lang || 'English';
-    _hal._.image = options?.openaiApiKey && image;
+    _hal._.gen = options?.gen
+        || (options?.openaiApiKey || geminiGenReady ? gen : null);
     return _hal;
 };
 

package/lib/hal.mjs

@@ -1,8 +1,5 @@
-import {
-    alan, bot, callosum, dbio, storage, uoid, utilitas, web,
-} from 'utilitas';
-
 import { basename, join } from 'path';
+import { bot, callosum, dbio, storage, uoid, utilitas, web } from 'utilitas';
 import { parseArgs as _parseArgs } from 'node:util';
 import { readdirSync } from 'fs';
 
@@ -20,6 +17,7 @@ const isMarkdownError = e => e?.description?.includes?.("can't parse entities");
 const getFile = async (id, op) => (await web.get(await getFileUrl(id), op)).content;
 const compact = (str, op) => utilitas.ensureString(str, { ...op || {}, compact: true });
 const compactLimit = (str, op) => compact(str, { ...op || {}, limit: 140 });
+const getKey = s => s?.toLowerCase?.()?.startsWith?.('http') ? 'url' : 'source';
 const SEARCH_LIMIT = 10;
 
 const [ // https://limits.tginfo.me/en
@@ -362,18 +360,26 @@ const subconscious = [{
         ctx.complete = async (options) => await ctx.ok('☑️', options);
         ctx.json = async (obj, options) => await ctx.ok(json(obj), options);
         ctx.list = async (list, options) => await ctx.ok(uList(list), options);
-        ctx.media = async (fnc, src, options) => ctx.done.push(await ctx[fnc]({
-            [src?.toLowerCase?.()?.startsWith?.('http') ? 'url' : 'source']: src
-        }, getExtra(ctx, options)));
-        ctx.audio = async (sr, op) => await ctx.media('replyWithAudio', sr, op);
-        ctx.image = async (sr, op) => await ctx.media('replyWithPhoto', sr, op);
-        ctx.sendConfig = async (obj, options, _ctx) => await ctx.ok(utilitas.prettyJson(
-            obj, { code: true, md: true }
-        ), options);
+        ctx.replyWith = async (func, src, options) => ctx.done.push(
+            await ctx[func]({ [getKey(src)]: src }, getExtra(ctx, options))
+        );
+        ctx.audio = async (s, o) => await ctx.replyWith('replyWithAudio', s, o);
+        ctx.image = async (s, o) => await ctx.replyWith('replyWithPhoto', s, o);
+        ctx.video = async (s, o) => await ctx.replyWith('replyWithVideo', s, o);
+        ctx.media = async (srs, options) => await ctx.done.push(
+            await ctx.replyWithMediaGroup(srs.map(x => ({
+                type: x.type || 'photo', media: { [getKey(x.src)]: x.src },
+            })), getExtra(ctx, options))
+        );
+        ctx.sendConfig = async (obj, options, _ctx) => await ctx.ok(
+            utilitas.prettyJson(obj, { code: true, md: true }), options
+        );
         ctx.speech = async (cnt, options) => {
             let file;
             if (Buffer.isBuffer(cnt)) {
-                file = await storage.convert(cnt, { input: storage.BUFFER, expected: storage.FILE });
+                file = await storage.convert(cnt, {
+                    input: storage.BUFFER, expected: storage.FILE,
+                });
             } else if (cnt.length <= speech.OPENAI_TTS_MAX_LENGTH) {
                 file = await utilitas.ignoreErrFunc(async () => await ctx._.speech.tts(
                     cnt, { expected: 'file' }
@@ -603,7 +609,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 }
@@ -614,9 +624,9 @@ const subconscious = [{
                     log(`STT: '${resp}'`);
                     ctx.collect(resp);
                 };
-                if (hal._.supportedMimeTypes.has(alan.wav)) {
+                if (hal._.supportedMimeTypes.has(MIME_WAV)) {
                     ctx.collect({
-                        mime_type: alan.wav, url, analyze,
+                        mime_type: MIME_WAV, url, analyze,
                         data: await media.convertAudioTo16kNanoPcmWave(file, {
                             input: storage.BUFFER, expected: storage.BASE64,
                         }),
@@ -727,9 +737,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.89",
+  "version": "1993.2.91",
   "private": false,
   "homepage": "https://github.com/Leask/halbot",
   "type": "module",
@@ -36,7 +36,7 @@
     "@google-cloud/speech": "^7.0.1",
     "@google-cloud/text-to-speech": "^6.0.1",
     "@google-cloud/vision": "^5.1.0",
-    "@google/genai": "^0.10.0",
+    "@google/genai": "^0.12.0",
     "@mozilla/readability": "^0.6.0",
     "fluent-ffmpeg": "^2.1.3",
     "ioredis": "^5.6.1",
@@ -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.54",
+    "utilitas": "^1999.1.61",
     "youtube-transcript": "^1.2.1"
   }
 }

package/skills/40_dream.mjs

@@ -1,29 +1,39 @@
-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 = '';
+    let [provider, func, reference] = [GEMINI, 'image', null];
     switch (ctx.cmd.cmd) {
-        case 'gptimage': provider = 'OPENAI'; break;
-        case 'dream': case 'imagen': default: provider = 'GEMINI';
+        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.');
     }
-    let [objMsg, images] = [(await ctx.ok('💭'))[0], null]; //tts = null
+    let [objMsg, output] = [(await ctx.ok('💭'))[0], null]; //tts = null
     try {
-        images = await ctx._.image.generate(ctx.cmd.args, {
-            provider, expected: 'FILE'
-        });
+        output = (await ctx._.gen[func](ctx.cmd.args, {
+            provider, expected: 'FILE',
+            ...reference?.length ? { reference, input: 'BASE64' } : {},
+        })) || [];
     } catch (err) {
-        return await ctx.er(err.message || 'Error generating image.',
+        return await ctx.er(err.message || `Error generating ${func}.`,
             { lastMessageId: objMsg.message_id });
     }
     await ctx.deleteMessage(objMsg.message_id);
-    for (let image of images || []) {
-        // tts = image.tts || '';
-        await ctx.image(image.data, { caption: image.caption || '' });
-        await ctx.timeout();
-    }
+    await ctx.media(
+        output.map(x => ({ type: types[func], src: x.data })),
+        { caption: output[0]?.caption || '' }
+    );
+    // tts = output.tts || '';
     // await ctx.shouldSpeech(tts);
 };
 
@@ -35,13 +45,16 @@ export const { name, run, priority, func, cmds, help } = {
     help: bot.lines([
         '¶ Use Google `Imagen` (default) or OpenAI `GPT Image` to generate images.',
         'Example 1: /dream a cat in a rocket',
+        '¶ Use Google `Veo` to generate videos.',
+        'Example 2: /fantasy two cats are kissing each other',
         '¶ Use `Imagen` to generate images.',
-        'Example 2: /imagen a cat in a car',
+        'Example 3: /imagen a cat in a car',
         '¶ Use `GPT Image` to generate images.',
-        'Example: /gptimage a cat on a bike',
+        'Example 4: /gptimage a cat on a bike',
     ]),
     cmds: {
         dream: 'Generate images with default model: /dream `PROMPT`',
+        fantasy: 'Generate videos with `Veo`: /fantasy `PROMPT`',
         imagen: 'Generate images with `Imagen`: /imagen `PROMPT`',
         gptimage: 'Generate images with `GPT Image`: /gptimage `PROMPT`',
     },