halbot 1993.2.53 → 1993.2.55

package/README.md

@@ -35,7 +35,7 @@ alt="Halbot live demo" width="240" height="180" border="10" /></a>
 - Text-to-Image by DALL·E (`OpenAI` API key required, or your own engine)
 - OCR/OBJECT_DETECT (`OpenAI` or `Google Cloud` API key required, or your own engine)
 - Feeding webpage and [YouTube](https://www.youtube.com/) to enhance your prompt
-- Custom prompt and [🧠 Awesome ChatGPT Prompts](https://github.com/f/awesome-chatgpt-prompts) at your fingertips
+- Custom prompt at your fingertips
 - Support `private` and `public` mode, with multiple authenticate methods.
 - `Middleware` style workflow, easy to extend.
 - Built-in support parsing webpages, `YouTube` videos, PDFs, images, Office documents, code files, text files...

package/index.mjs

@@ -1,56 +1,31 @@
-import { parse } from 'csv-parse/sync';
 import { alan, bot, image, shot, speech, utilitas } from 'utilitas';
 
 await utilitas.locate(utilitas.__(import.meta.url, 'package.json'));
-const log = content => utilitas.log(content, 'halbot');
 const skillPath = utilitas.__(import.meta.url, 'skills');
 
-const promptSource = new Set([
-    // 'https://raw.githubusercontent.com/f/awesome-chatgpt-prompts/main/prompts.csv',
-    'https://raw.githubusercontent.com/f/awesome-chatgpt-prompts/82f15563c9284c01ca54f0b915ae1aeda5a0fc3a/prompts.csv'
-]);
-
-const fetchPrompts = async () => {
-    const prompts = {};
-    for (let source of promptSource) {
-        try {
-            const resp = (await shot.get(source)).content;
-            const pmts = parse(resp, { columns: true, skip_empty_lines: true });
-            assert(pmts?.length, `Failed to load external prompts: ${source}.`);
-            pmts.filter(x => x.act && x.prompt).map(x => {
-                const { command, description } = bot.newCommand(x.act, x.act);
-                prompts[command] = { ...x, command, act: description };
-            });
-        } catch (err) { log(err?.message || err); }
-    }
-    log(`Awesome ChatGPT Prompts: fetch ${utilitas.countKeys(prompts)} items.`);
-    return prompts;
-};
-
-const init = async (options) => {
-    assert(options?.telegramToken, 'Telegram Bot API Token is required.');
-    const [pkg, ai, _speech, speechOptions, engines, vision]
-        = [await utilitas.which(), {}, {}, { tts: true, stt: true }, {}, {}];
+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 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) {
+    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) {
+    if (options.openaiApiKey) {
         const apiKey = { apiKey: options.openaiApiKey };
-        await alan.init({ provider: 'OPENAI', ...apiKey, ...options || {} });
-        ai['ChatGPT'] = {
-            engine: 'CHATGPT', priority: options?.chatGptPriority || 0,
-        }; // only support custom model while prompting:
-        engines['CHATGPT'] = { model: options?.chatGptModel, };
-        embedding = alan.createOpenAIEmbedding;
+        const ai = await alan.init({
+            id: 'ChatGPT', provider: 'OPENAI', model: options?.chatGptModel,
+            ...apiKey, priority: options?.chatGptPriority || 0, ...options
+        });
+        embedding = ai.embedding;
         await image.init(apiKey);
         await speech.init({ ...apiKey, provider: 'OPENAI', ...speechOptions });
         _speech.tts = speech.tts;
@@ -59,15 +34,11 @@ const init = async (options) => {
     // use google tts if google api key is ready
     if (options?.googleApiKey) {
         const apiKey = { apiKey: options.googleApiKey };
-        await alan.init({ // only support custom model while initiating:
-            provider: 'GEMINI', ...apiKey,
-            model: options?.geminiModel, ...options || {},
+        const ai = await alan.init({
+            id: 'Gemini', provider: 'GEMINI', model: options?.geminiModel,
+            ...apiKey, priority: options?.geminiPriority || 1, ...options
         });
-        ai['Gemini'] = {
-            engine: 'GEMINI', priority: options?.geminiPriority || 1,
-        }; // save for reference not for prompting:
-        engines['GEMINI'] = { model: options?.geminiModel };
-        embedding || (embedding = alan.createGeminiEmbedding);
+        embedding || (embedding = ai.embedding);
         if (!_speech.tts) {
             await speech.init({
                 ...apiKey, provider: 'GOOGLE', ...speechOptions,
@@ -78,45 +49,34 @@ const init = async (options) => {
             apiKey: options.googleApiKey, cx: options.googleCx
         });
     }
-    if (options?.claudeApiKey || (options?.claudeCredentials && options?.claudeProjectId)) {
+    if (options?.anthropicApiKey
+        || (options?.anthropicCredentials && options?.anthropicProjectId)) {
         await alan.init({
-            provider: 'CLAUDE', apiKey: options?.claudeApiKey,
-            credentials: options?.claudeCredentials,
-            projectId: options?.claudeProjectId, ...options || {},
+            id: 'Claude', provider: 'VERTEX ANTHROPIC', model: options?.anthropicModel,
+            apiKey: options?.anthropicApiKey,
+            credentials: options?.anthropicCredentials,
+            projectId: options?.anthropicProjectId,
+            priority: options?.anthropicPriority || 2, ...options
         });
-        ai['Claude'] = {
-            engine: 'CLAUDE', priority: options?.claudePriority || 2,
-        }; // only support custom model while prompting:
-        engines['CLAUDE'] = { model: options?.claudeModel };
     }
     if (options?.azureApiKey && options?.azureEndpoint) {
         await alan.init({
-            provider: 'Azure', apiKey: options?.azureApiKey,
-            baseURL: options?.azureEndpoint, ...options || {},
+            id: 'Azure', provider: 'AZURE', model: options?.azureModel,
+            apiKey: options?.azureApiKey, priority: options?.azurePriority || 3,
+            baseURL: options?.azureEndpoint, ...options
         });
-        ai['Azure'] = {
-            engine: 'AZURE', priority: options?.azurePriority || 3,
-        }; // only support custom model while prompting:
-        engines['AZURE'] = { model: options?.azureModel };
     }
     if (options?.ollamaEnabled || options?.ollamaEndpoint) {
         await alan.init({
-            provider: 'OLLAMA', host: options?.ollamaEndpoint,
+            id: 'Ollama', provider: 'OLLAMA', model: options?.ollamaModel,
+            priority: options?.ollamaPriority || 99,
+            host: options?.ollamaEndpoint, ...options
         });
-        ai['Ollama'] = {
-            engine: 'OLLAMA', priority: options?.ollamaPriority || 3,
-        };
-        engines['OLLAMA'] = {
-            // only support custom model while prompting
-            model: options?.ollamaModel || alan.DEFAULT_MODELS['OLLAMA'],
-        };
     }
-    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; }
+    const { ais } = await alan.initChat({ sessions: options?.storage });
     // config multimodal engines
-    const supportedMimeTypes = new Set(Object.values(engines).map(
-        x => alan.MODELS[x.model]
+    const supportedMimeTypes = new Set(Object.values(ais).map(
+        x => x.model
     ).map(x => [
         ...x.supportedMimeTypes || [], ...x.supportedAudioTypes || [],
     ]).flat().map(x => x.toLowerCase()));
@@ -140,10 +100,8 @@ const init = async (options) => {
         skillPath: options?.skillPath || skillPath,
         speech: _speech, vision,
     });
-    _bot._.ai = ai;                                                             // Should be an array of a map of AIs.
     _bot._.lang = options?.lang || 'English';
     _bot._.image = options?.openaiApiKey && image;
-    _bot._.prompts = await fetchPrompts();
     return _bot;
 };
 

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.53",
+  "version": "1993.2.55",
   "private": false,
   "homepage": "https://github.com/Leask/halbot",
   "type": "module",
@@ -38,7 +38,6 @@
     "@google-cloud/vision": "^4.3.3",
     "@google/generative-ai": "^0.24.0",
     "@mozilla/readability": "^0.6.0",
-    "csv-parse": "^5.6.0",
     "fluent-ffmpeg": "^2.1.3",
     "ioredis": "^5.6.0",
     "js-tiktoken": "^1.0.19",
@@ -47,13 +46,12 @@
     "mime": "^4.0.6",
     "mysql2": "^3.13.0",
     "office-text-extractor": "^3.0.3",
-    "ollama": "^0.5.14",
     "openai": "^4.87.3",
     "pg": "^8.14.0",
     "pgvector": "^0.2.0",
     "telegraf": "^4.16.3",
     "tesseract.js": "^6.0.0",
-    "utilitas": "^1998.2.52",
+    "utilitas": "^1999.1.6",
     "youtube-transcript": "^1.2.1"
   }
 }

package/skills/-8845_thread.mjs

@@ -137,7 +137,7 @@ const action = async (ctx, next) => {
                     ).map(x => x.id), { ignoreRequest: bot.HELLO }
                 );
                 return await sendList(sNames, resp[0]?.message_id);
-            });
+            }, { log: true });
             return resp;
         case 'end':
             const id = findSession(

package/skills/10_engine.mjs

@@ -7,63 +7,56 @@ const NAME_HACK = {
 const NAME_HACK_REVERSE = utilitas.reverseKeyValues(NAME_HACK);
 const AI_CMD = '/set --ai=';
 
-let configuredAi;
-
 const action = async (ctx, next) => {
-    ctx.isDefaultAi = name => name === ctx.firstAi;
-    const arrSort = (configuredAi = Object.keys(ctx._.ai)).map(
-        k => [k, ctx._.ai[k].priority]
-    ).sort((x, y) => x[1] - y[1]);
-    ctx.firstAi = arrSort[0][0];
+    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(configuredAi.slice(0, 3).map(
-            x => ({ text: `${AI_CMD}${NAME_HACK[x] || x}` })
+        ctx.carry.keyboards.unshift(ais.slice(0, 3).map(
+            x => ({ text: `${AI_CMD}${NAME_HACK[x.id] || x.id}` })
         ));
     }
     switch (ctx.session.config?.ai) {
-        case '@': ctx.selectedAi = configuredAi; break;
+        case '@': ctx.selectedAi = ais.map(x => x.id); break;
         default:
             ctx.selectedAi = [ctx.session.config?.ai];
-            const foundAi = configuredAi.includes(ctx.session.config?.ai);
+            const foundAi = ais.map(x => x.id).includes(ctx.session.config?.ai);
             if (foundAi) {
             } else if (!ctx.collected?.length) {
-                ctx.selectedAi = [ctx.firstAi];
+                ctx.selectedAi = [ais[0].id];
             } else {
                 const supported = {};
-                for (const i of configuredAi) {
+                for (const x of ais) {
                     const supportedMimeTypes = [
-                        ...alan.MODELS[ctx._.ai[i].model]?.supportedMimeTypes || [],
-                        ...alan.MODELS[ctx._.ai[i].model]?.supportedAudioTypes || [],
+                        ...x.model.supportedMimeTypes || [],
+                        ...x.model.supportedAudioTypes || [],
                     ];
-                    for (const j of ctx.collected) {
-                        supported[i] || (supported[i] = 0);
-                        if (supportedMimeTypes.includes(j?.content?.mime_type)) {
-                            supported[i]++;
+                    for (const i of ctx.collected) {
+                        supported[x.id] || (supported[x.id] = 0);
+                        if (supportedMimeTypes.includes(i?.content?.mime_type)) {
+                            supported[x.id]++;
                         }
-                        if (ctx.checkSpeech() && (alan.MODELS[
-                            ctx._.ai[i].model
-                        ]?.supportedAudioTypes || []).includes(j?.content?.mime_type)) {
+                        if (ctx.checkSpeech() && (
+                            x.model.supportedAudioTypes || []
+                        ).includes(i?.content?.mime_type)) {
                             ctx.carry.audioMode = true;
-                            if (alan.MODELS[ctx._.ai[i].model]?.audio) {
-                                supported[i]++; // Priority for audio models
-                            }
+                            x.model.audio && (supported[x.id]++); // Priority for audio models
                         }
                     }
                 }
                 ctx.selectedAi = [Object.keys(supported).sort(
                     (x, y) => supported[y] - supported[x]
-                )?.[0] || ctx.firstAi];
+                )?.[0] || ais[0].id];
             }
     }
     await next();
 };
 
-const validateAi = val => {
-    assert(configuredAi, 'Preparing data for this option. Please try later.');
+const validateAi = async val => {
     NAME_HACK_REVERSE[val] && (val = NAME_HACK_REVERSE[val]);
-    for (let name of [...configuredAi, '', '@']) {
+    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.');

package/skills/20_instant.mjs

@@ -1,7 +1,8 @@
-import { bot, utilitas } from 'utilitas';
+import { alan, bot, utilitas } from 'utilitas';
 
 const action = async (ctx, next) => {
-    const allAi = Object.keys(ctx._.ai);
+    const ais = await alan.getAi(null, { all: true });
+    const allAi = ais.map(x => x.id);
     switch (ctx.cmd.cmd) {
         case 'all':
             ctx.selectedAi = allAi;

package/skills/50_prompt.mjs

@@ -1,7 +1,5 @@
 import { bot, utilitas } from 'utilitas';
 
-const ACP = '[🧠 Awesome ChatGPT Prompts](https://github.com/f/awesome-chatgpt-prompts)';
-
 const action = async (ctx, next) => {
     ctx.session.prompts || (ctx.session.prompts = {});
     const cmd = ctx.cmd?.cmd;
@@ -35,19 +33,6 @@ const action = async (ctx, next) => {
                 await ctx.ok('Prompt not found.');
             }
             return;
-        case 'acplist':
-            const list = bot.uList(Object.keys(ctx._.prompts || {}).map(
-                x => `/${ctx._.prompts[x].command}: ${ctx._.prompts[x].act}`
-            ));
-            return await ctx.ok(list || 'Data not found.');
-        case 'acpdetail':
-            const details = bot.lines2(Object.keys(ctx._.prompts || {}).map(
-                x => bot.lines([
-                    `- /${ctx._.prompts[x].command}: ${ctx._.prompts[x].act}`,
-                    ctx._.prompts[x].prompt
-                ])
-            ));
-            return await ctx.ok(details || 'Data not found.');
         default:
             const prompt = ctx.session.prompts?.[cmd] || ctx._.prompts?.[cmd]?.prompt;
             !ctx.context && prompt && (ctx.context = { cmd, prompt });
@@ -65,14 +50,11 @@ export const { name, run, priority, func, help, cmds, cmdx } = {
         '¶ Maintain custom prompts.',
         'Example 1: /add `code` > `Code with me.`',
         'Example 2: /del `code`',
-        `¶ Get interesting prompts from ${ACP}.`,
     ]),
     cmds: {
         prompts: 'List all custom prompts.',
         add: 'Add or edit a custom prompt: /add `COMMAND` > `PROMPT`.',
         del: 'Delete a custom prompt: /del `COMMAND`.',
-        acplist: `List prompts from ${ACP}.`,
-        acpdetail: `Show details of ${ACP}.`,
     },
     cmdx: {},
 };

package/skills/60_prepare.mjs

@@ -2,13 +2,15 @@ import { alan, bot, utilitas } from 'utilitas';
 
 const checkUnsupportedMimeType = async ctx => {
     ctx.carry.attachments = [];
+    const ais = await alan.getAi(null, { all: true });
     for (const x of ctx.collected.filter(x => x.type === 'PROMPT')) {
         let notSupported = false;
         ctx.selectedAi.map(y => {
+            const ai = ais.find(z => z.id === y);
             if (![
-                ...alan.MODELS[ctx._.ai[y].model]?.supportedMimeTypes || [],
-                ...alan.MODELS[ctx._.ai[y].model]?.supportedAudioTypes || [],
-            ].includes(y?.content?.mime_type)) { notSupported = true; }
+                ...ai.model.supportedMimeTypes || [],
+                ...ai.model.supportedAudioTypes || [],
+            ].includes(x?.content?.mime_type)) { notSupported = true; }
         });
         notSupported ? await x.content.analyze() : ctx.carry.attachments.push({
             ...x.content, analyze: undefined,

package/skills/70_chat.mjs

@@ -33,9 +33,10 @@ const action = async (ctx, next) => {
     };
     const ok = async options => {
         const [curTime, curMsg] = [Date.now(), packMsg(options)];
-        if (options?.onProgress && (curTime - lastSent < (
-            ctx.limit * (curTime - firstResp > 1000 * 60 ? 2 : 1)
-        ) || lastMsg === curMsg)) { return; }
+        if (options?.onProgress && (
+            (curTime - lastSent) < (ctx.limit * (curTime - firstResp > 1000 * 60 ? 2 : 1))
+            || lastMsg === curMsg
+        )) { return; }
         [lastSent, lastMsg] = [curTime, curMsg];
         const cmd = ctx.session.context?.cmd;
         if (options?.final) {
@@ -56,10 +57,9 @@ const action = async (ctx, next) => {
         pms.push((async ai => {
             try {
                 const resp = await alan.talk(ctx.prompt, {
-                    engine: ctx._.ai[ai].engine, ...ctx.carry,
-                    stream: async r => {
+                    id: ai, ...ctx.carry, stream: async r => {
                         msgs[ai] = r.text;
-                        ctx.carry.threadInfo.length || await ok(onProgress);
+                        ctx.carry.threadInfo.length || ok(onProgress);
                     },
                 });
                 references = resp.references;