halbot 1994.1.8 → 1995.1.3

package/README.md

@@ -133,10 +133,6 @@ All supported configuration fields:
     // To restrict the bot to PRIVATE, set chat/group/channel ids in this array.
     "private": ["[[CHAT_ID]]", "[[GROUP_ID]]", "[[CHANNEL_ID]]", ...],
 
-    // OPTIONAL, string.
-    // Set some of these fields if you want to use a `magic word` to authenticate the bot.
-    "magicWord": "[[Your Magic Word here]]",
-
     // OPTIONAL, string.
     // Use a HOME GROUP to authentication users.
     // Anyone in this group can access the bot.

package/bin/halbot.mjs

@@ -10,7 +10,7 @@ const _getConfig = async () => await _storage.getConfig();
 const getConfig = async key => (await _getConfig())?.config?.[key];
 
 let storage = {
-    provider: 'FILE',
+    provider: _storage.FILE,
     get: async key => (await getConfig(MEMORY))?.[key],
     set: async (k, v) => await _storage.setConfig({ [MEMORY]: { [k]: v } }),
 };

package/index.mjs

@@ -1,63 +1,65 @@
-import { alan, bot, embedding, gen, web, speech, utilitas } from 'utilitas';
+import { alan, bot, rag, web, utilitas } from 'utilitas';
 import * as hal from './lib/hal.mjs';
 
 await utilitas.locate(utilitas.__(import.meta.url, 'package.json'));
-const skillPath = utilitas.__(import.meta.url, 'skills');
+const pipelinePath = utilitas.__(import.meta.url, 'pipeline');
 
 const init = async (options = {}) => {
     assert(options.telegramToken, 'Telegram Bot API Token is required.');
-    let [pkg, _speech, _embedding, speechOptions, vision, opts] = [
-        await utilitas.which(), options?.speech || {}, options?.embedding,
-        { tts: true, stt: true }, {}, null,
-    ];
+    let [pkg, _embed, _rerank, opts] =
+        [await utilitas.which(), options?.embed, options?.rerank, null];
     const info = bot.lines([
-        `[${hal.EMOJI_BOT} ${pkg.title}](${pkg.homepage})`, pkg.description
+        `[${bot.BOT} ${pkg.title}](${pkg.homepage})`, pkg.description
     ]);
-    // use AI vision, AI stt if OpenRouter, Gemini or OpenAI is enabled
-    if (options.openrouterApiKey
-        || options.openaiApiKey || options.googleApiKey) {
-        vision.read = alan.distillFile;
-        vision.see = alan.distillFile;
-        _speech?.stt || (_speech.stt = alan.distillFile);
-    }
-    // use embedding if OpenRouter is enabled
-    if (options.openrouterApiKey && !_embedding) {
-        await embedding.init({
-            provider: 'OPENROUTER', apiKey: options.openrouterApiKey,
-        });
-        _embedding = embedding.embed;
+    // use google's search if google is enabled
+    options.googleApiKey && options.googleCx && await web.initSearch({
+        provider: 'GOOGLE', apiKey: options.googleApiKey, cx: options.googleCx,
+    });
+    // use openrouter's AI models, embedding if OpenRouter is enabled
+    if (options.openrouterApiKey) {
+        opts = { provider: 'OPENROUTER', apiKey: options.openrouterApiKey };
+        await alan.init({
+            ...opts,
+            model: options.openrouterModel || '*',
+            priority: options.openrouterPriority, ...options,
+        })
+        if (!_embed) {
+            await rag.initEmbedding(opts);
+            _embed = rag.embed;
+        }
     }
-    // use google's imagen, veo, search, tts if google is enabled
+    // use google's imagen, veo, tts if google is enabled
     if (options.googleApiKey) {
         opts = { provider: 'GOOGLE', apiKey: options.googleApiKey };
-        await gen.init(opts);
-        options.googleCx && await web.initSearch({
-            ...opts, cx: options.googleCx,
+        await alan.init({
+            ...opts, model: options.googleModel || '*',
+            priority: options.googlePriority, ...options,
         });
-        if (!_speech.tts) {
-            await speech.init({ ...opts, ...speechOptions });
-            _speech.tts = speech.tts;
-        }
     }
-    // use openai's dall-e, embedding, tts if openai is enabled, and google is not
+    // use openai's embedding, tts if openai is enabled, and google is not
     if (options.openaiApiKey) {
         opts = { provider: 'OPENAI', apiKey: options.openaiApiKey };
-        await gen.init(opts);
-        if (!_embedding) {
-            await embedding.init(opts);
-            _embedding = embedding.embed;
+        await alan.init({
+            ...opts, model: options.openaiModel || '*',
+            priority: options.openaiPriority, ...options,
+        });
+        if (!_embed) {
+            await rag.initEmbedding(opts);
+            _embed = rag.embed;
         }
-        if (!_speech.tts) {
-            await speech.init({ ...opts, ...speechOptions });
-            _speech.tts = speech.tts;
+    }
+    // use google rerank if google is enabled
+    if (options?.googleCredentials && options.googleProjectId) {
+        opts = {
+            provider: 'GOOGLE', credentials: options.googleCredentials,
+            projectId: options.googleProjectId,
+        };
+        if (!_rerank) {
+            await rag.initReranker(opts);
+            _rerank = rag.rerank;
         }
     }
-    // init ai providers
-    options.openrouterApiKey && await alan.init({
-        provider: 'OPENROUTER', apiKey: options.openrouterApiKey,
-        model: options.openrouterModel || '*',
-        priority: options.openrouterPriority, ...options,
-    });
+    // init other ai providers
     options.siliconflowApiKey && await alan.init({
         provider: 'SILICONFLOW', apiKey: options.siliconflowApiKey,
         model: options.siliconflowModel || '*',
@@ -70,6 +72,10 @@ const init = async (options = {}) => {
             priority: options.jinaPriority, ...options
         });
         await web.initSearch(opts);
+        if (!_rerank) {
+            await rag.initReranker(opts);
+            _rerank = rag.rerank;
+        }
     }
     if (options?.ollamaEnabled || options?.ollamaEndpoint) {
         await alan.init({
@@ -78,41 +84,26 @@ const init = async (options = {}) => {
             host: options?.ollamaEndpoint, ...options
         });
     }
-    const { ais } = await alan.initChat({ sessions: options?.storage });
-    const cmds = options?.cmds || [];
-    // config multimodal engines
-    const supportedMimeTypes = new Set(Object.values(ais).map(x => {
-        // init instant ai selection
-        cmds.push(hal.newCommand(`ai_${x.id}`, `${x.name}: ${x.features}`));
-        return x.model;
-    }).map(x => [
-        ...x.supportedMimeTypes,
-        ...x.supportedDocTypes,
-        ...x.supportedAudioTypes,
-    ]).flat().map(x => x.toLowerCase()));
     // init hal
     const _hal = await hal.init({
         args: options?.args,
         auth: options?.auth,
         botToken: options?.telegramToken,
         chatType: options?.chatType,
-        cmds,
-        database: options?.storage?.client && options?.storage,
-        supportedMimeTypes,
+        cmds: options?.cmds,
+        embed: _embed,
         hello: options?.hello,
         help: options?.help,
         homeGroup: options?.homeGroup,
         info: options?.info || info,
-        magicWord: options?.magicWord,
+        lang: options?.lang || 'English',
+        pipeline: options?.pipeline,
+        pipelinePath: options?.pipelinePath || pipelinePath,
         private: options?.private,
         provider: 'telegram',
-        session: options?.storage,
-        skillPath: options?.skillPath || skillPath,
-        embedding: _embedding, speech: _speech, vision,
+        rerank: _rerank,
+        storage: options?.storage,
     });
-    _hal._.lang = options?.lang || 'English';
-    _hal._.gen = options?.gen
-        || (options?.openaiApiKey || geminiGenReady ? gen : null);
     return _hal;
 };