halbot 1994.1.7 → 1995.1.2

package/pipeline/070_collect.mjs

@@ -0,0 +1,115 @@
+import { bot, hal, media, storage, utilitas, vision, web } from '../index.mjs';
+
+const collectableFiles = ['document', 'sticker', 'video_note', 'video'];
+const sendInit = async (ctx, txt) => ctx._.done.length || await ctx.ok(txt);
+
+const [API_ROOT, BUFFER_ENCODE, EMOJI_SPEECH, EMOJI_LOOK, ATTACHMENT, PROMPT]
+    = [
+        'https://api.telegram.org/', { encode: storage.BUFFER }, '👂', '👀',
+        'ATTACHMENT', 'PROMPT',
+    ];
+
+const collectableObjects = [
+    'venue', 'location', 'contact', 'poll', 'left_chat_member',
+    'new_chat_member', 'checklist'
+];
+
+const metaPrompt = "The following are meta information changes or attachment details for the current chat. Please respond appropriately. For example, if it's a poll, make a selection based on your understanding. If there are changes in group members, greet or bid farewell to the respective individuals. If it's a geographical location description, provide a suitable answer based on the context. You may also receive other types of information, for which a reasonable, human-like response is expected.";
+
+const getFileUrl = async (ctx, file_id) => {
+    assert(file_id, 'File ID is required.', 400);
+    const file = await ctx.telegram.getFile(file_id);
+    assert(file.file_path, 'Error getting file info.', 500);
+    return `${API_ROOT}file/bot${ctx.telegram.token}/${file.file_path}`;
+};
+
+const officeParser = async file => await utilitas.ignoreErrFunc(async () =>
+    await vision.parseOfficeFile(file, { input: storage.BUFFER }), { log: true }
+);
+
+const ctxExt = ctx => {
+    ctx.getFileUrl = async (file_id) => await getFileUrl(ctx, file_id);
+    ctx.getFile = async (file_id, options) => (await web.get(
+        await ctx.getFileUrl(file_id), { ...BUFFER_ENCODE, ...options }
+    )).content;
+};
+
+let mime;
+
+const collectFile = async (ctx, f) => {
+    f = { ...f };
+    f.url || (f.url = await ctx.getFileUrl(f.file_id));
+    f.file_name || (f.file_name = utilitas.basename(f.url));
+    f.data || (f.data = await ctx.getFile(f.file_id));
+    f.mime_type || (f.mime_type = (await storage.getMime(f.data, f.file_name))?.mime);
+    let text = '';
+    f.emoji && ctx.collect(f.emoji, PROMPT);
+    if (hal._.supportedMimeTypes.has(f.mime_type)) {
+        ctx.collect({ mime_type: f.mime_type, data: f.data }, ATTACHMENT);
+    } else if (await storage.isTextFile(f.data)) {
+        text = f.data.toString();
+    } else if (/^.*\.(docx|xlsx|pptx)$/.test(f.file_name)) {
+        text = await officeParser(f.data);
+    }
+    if (text) {
+        ctx.collect(bot.lines([
+            '---', `file_name: ${f.file_name}`,
+            `mime_type: ${f.mime_type}`, `type: DOCUMENT`,
+            '---', text
+        ]), PROMPT);
+    }
+};
+
+const extract = async (ctx, m) => {
+    collectableObjects.map(k => m[k] && ctx.collect(
+        bot.lines([
+            '---', metaPrompt, `type: ${k}`,
+            '---', JSON.stringify(m[k])
+        ]), PROMPT
+    ));
+    await Promise.all(collectableFiles.map(async k => {
+        if (!m[k]) { return; }
+        await sendInit(ctx, EMOJI_LOOK);
+        await collectFile(ctx, m[k]);
+    }));
+    if (m.photo?.[m.photo?.length - 1]) {
+        await sendInit(ctx, EMOJI_LOOK);
+        const f = m.photo[m.photo.length - 1];
+        await collectFile(ctx, { ...f, file_name: `${f.file_unique_id}.jpg` });
+    }
+    let a;
+    if ((a = m.voice || m.audio)) {
+        await sendInit(ctx, EMOJI_SPEECH);
+        await collectFile(ctx, {
+            ...a, mime_type: storage.MIME_WAV,
+            data: await media.convertAudioTo16kNanoPcmWave(
+                await ctx.getFile(a.file_id)
+            ),
+        });
+    }
+};
+
+const action = async (ctx, next) => {
+    // init
+    ctxExt(ctx);
+    mime || (mime = await utilitas.need('mime'));
+    // collect objects
+    await Promise.all([
+        ctx._.message, ctx._.message?.reply_to_message
+    ].filter(x => x).map(async m => await extract(ctx, m)));
+    // collect reply_to_message
+    ctx._.message.reply_to_message?.text && ctx.collect(
+        ctx._.message.reply_to_message.text, PROMPT
+    );
+    ctx._.message.reply_to_message?.caption && ctx.collect(
+        ctx._.message.reply_to_message.caption, PROMPT
+    );
+    // print(JSON.stringify(ctx.update, null, 2));
+    // print(ctx._.text);
+    // print(ctx._.collected);
+    await next();
+};
+
+export const { _NEED, name, run, priority, func } = {
+    _NEED: ['mime'], name: 'Collect', run: true, priority: 70, func: action,
+};

package/pipeline/080_history.mjs

@@ -0,0 +1,111 @@
+import { bot, dbio, hal, utilitas } from '../index.mjs';
+
+const compact = (str, op) => utilitas.ensureString(str, { ...op || {}, compact: true });
+const compactLimit = (str, op) => compact(str, { ...op || {}, limit: 140 });
+
+const memorize = async (ctx) => {
+    // https://limits.tginfo.me/en
+    if (!ctx._.chatId || ctx._.cmd?.cmd) { return; }
+    const received = ctx.update;
+    const received_text = ctx._.request || ctx._.text || '';
+    const id = received.update_id;
+    let response = {};
+    ctx._.done.map(m => m?.text && (response[m.message_id] = m));
+    response = Object.values(response).sort((a, b) => a.message_id - b.message_id);
+    const response_text = ctx?._.response || response.map(x => x.text).join('\n');
+    const collected = ctx._.collected.filter(x => String.isString(x.content));
+    const distilled = compact(bot.lines([
+        received_text, response_text, ...collected.map(x => x.content)
+    ]));
+    if (!ctx._.messageId || !distilled) { return; }
+    const event = {
+        id, bot_id: ctx.botInfo.id, chat_id: ctx._.chatId,
+        chat_type: ctx._.chatType, message_id: ctx._.messageId,
+        received: JSON.stringify(received), received_text,
+        response: JSON.stringify(response), response_text,
+        collected: JSON.stringify(collected), distilled,
+    };
+    await utilitas.ignoreErrFunc(async () => {
+        event.distilled_vector = hal._.embed
+            ? await hal._.embed(event.distilled) : [];
+        switch (hal._.storage?.provider) {
+            case dbio.MYSQL:
+                event.distilled_vector = JSON.stringify(event.distilled_vector);
+                break;
+        }
+        await hal._.storage?.client?.upsert?.(hal.table, event, { skipEcho: true });
+    }, hal.logOptions);
+    // TODO: 調整，如果命令執行過，應該更新菜單 ！？
+    await utilitas.ignoreErrFunc(async () => await hal._.bot.telegram.setMyCommands([
+        ...hal._.cmds, ...Object.keys(ctx._.message.prompts || {}).map(
+            command => hal.newCommand(command, ctx._.message.prompts[command])
+        )
+    ].sort((x, y) =>
+        (ctx._.message?.cmds?.[y.command.toLowerCase()]?.touchedAt || 0)
+        - (ctx._.message?.cmds?.[x.command.toLowerCase()]?.touchedAt || 0)
+    ).slice(0, hal.COMMAND_LIMIT), {
+        scope: { type: 'chat', chat_id: ctx._.chatId },
+    }), hal.logOptions);
+};
+
+const ctxExt = ctx => {
+    ctx.memorize = async () => await memorize(ctx);
+    ctx.recall = async (keyword, offset = 0, limit = hal.SEARCH_LIMIT, options = {}) =>
+        await recall(ctx._.chatId, keyword, offset, limit, options);
+    // ctx.getContext = async (offset = 0, limit = hal.SEARCH_LIMIT, options = {}) =>
+    //     await getContext(ctx._.chatId, offset, limit, options);
+};
+
+const action = async (ctx, next) => {
+    ctxExt(ctx);
+    switch (ctx._.cmd?.cmd) {
+        case 'search':
+            (ctx._.type === 'callback_query')
+                && await ctx.deleteMessage(ctx._.message.message_id);
+            const regex = '[-—]+skip=[0-9]*';
+            const keywords = ctx._.cmd.args.replace(new RegExp(regex, 'i'), '').trim();
+            let catchArgs = ctx._.cmd.args.replace(new RegExp(`^.*(${regex}).*$`, 'i'), '$1');
+            catchArgs === ctx._.cmd.args && (catchArgs = '');
+            const offset = ~~catchArgs.replace(/^.*=([0-9]*).*$/i, '$1');
+            if (!keywords) { return await ctx.er('Topic is required.'); }
+            const result = await ctx.recall(keywords, offset);
+            for (const i in result) {
+                const content = bot.lines([
+                    '```↩️', compactLimit(result[i].response_text), '```',
+                    [`${utilitas.getTimeIcon(result[i].created_at)} ${result[i].created_at.toLocaleString()}`,
+                    `🏆 ${(Math.round(result[i].score * 100) / 100).toFixed(2)}`].join('  '),
+                ]);
+                await ctx.resp(content, true, {
+                    reply_parameters: {
+                        message_id: result[i].message_id,
+                    }, disable_notification: ~~i > 0,
+                });
+                await ctx.timeout();
+            }
+            // TODO: NEED MORE DEBUG
+            result.length === hal.SEARCH_LIMIT && await ctx.resp(
+                '___', true, ctx.getExtra({
+                    buttons: [{
+                        label: '🔍 More',
+                        text: `/search@${ctx.botInfo.username} ${keywords} `
+                            + `--skip=${offset + result.length}`,
+                    }]
+                }));
+            result.length || await ctx.err('No more records.');
+            break;
+        default:
+            await next();
+            break;
+    }
+};
+
+export const { name, run, priority, func, help, cmdx } = {
+    name: 'History', run: true, priority: 80, func: action,
+    help: bot.lines([
+        '¶ Search history.',
+        'Example 1: /search Answer to the Ultimate Question',
+        'Example 2: /search Answer to the Ultimate Question --skip=10',
+    ]), cmdx: {
+        search: 'Usage: /search `ANYTHING` --skip=`OFFSET`',
+    }
+};

package/pipeline/090_ai.mjs

@@ -0,0 +1,77 @@
+import { alan, bot, hal, utilitas } from '../index.mjs';
+
+const ais = await alan.getAi(null, { all: true });
+const TOP = 'top';
+
+const listAIs = async ctx => {
+    const lastMessageId = ctx?.update?.callback_query?.message?.message_id;
+    const message = `Features:\n`
+        + hal.uList(Object.entries(alan.FEATURE_ICONS).map(
+            x => `${x[1]} ${x[0]}`
+        )) + `\n\nAI${ais.length > 0 ? 's' : ''}:\n`;
+    const buttons = ais.map((x, i) => ({
+        label: `${ctx._.session.config?.ai === x.id
+            || (!ctx._.session.config?.ai && i === 0) ? `${hal.CHECK} `
+            : ''}${x.name}: ${x.features}`,
+        text: `/set --ai=${x.id}`,
+    }));
+    return await ctx.ok(message, { lastMessageId, buttons });
+};
+
+const action = async (ctx, next) => {
+    ctx._.ais = ais;
+    switch (ctx._.cmd?.cmd) {
+        case 'ai':
+            return await listAIs(ctx);
+        case TOP:
+            ctx.hello(ctx._.cmd.args);
+            ctx._.aiId = TOP;
+            break;
+        default:
+            ctx._.aiId = ctx._.session.config?.ai;
+    }
+    await next();
+};
+
+const validateAi = async (val, ctx) => {
+    for (let name of [...ais.map(x => x.id), '', TOP]) {
+        if (utilitas.insensitiveCompare(val, name)) {
+            ctx && (ctx.sendConfig = async (_c, _o) => await listAIs(ctx));
+            return name;
+        }
+    }
+    utilitas.throwError('No AI engine matched.');
+};
+
+export const { name, run, priority, func, help, args, cmdx } = {
+    name: 'AI',
+    run: true,
+    priority: 90,
+    func: action,
+    help: bot.lines([
+        '¶ Set initial prompt to the AI model.',
+        "Tip 1: Set `hello=''` to reset to default initial prompt.",
+        '¶ Select between AI models.',
+        "Tip 2: Set `ai=''` to use default AI model.",
+        'Tip 3: Set `ai=[AI_ID]` to use specific AI model.',
+        'Tip 4: Set `ai=top` to configure to use the top 3 AI models simultaneously.',
+        '¶ Use an AI model `temporary` without touching your settings.',
+        'Tip 5: `/[AI_ID]` Tell me a joke.',
+        'Tip 6: `/all` Use the top 3 AI models simultaneously, for current prompt.',
+    ]),
+    args: {
+        hello: {
+            type: 'string', short: 's', default: 'Hello!',
+            desc: "Change initial prompt: /set --hello 'Bonjour!'",
+        },
+        ai: {
+            type: 'string', short: 'a', default: '',
+            desc: "`(AI_ID, ..., @)` Select AI model.",
+            validate: validateAi,
+        },
+    },
+    cmdx: {
+        ai: 'List all available AIs.',
+        all: 'Use the top 3 AI models simultaneously: /all Say hello to all AIs!',
+    }
+};

package/pipeline/100_chat.mjs

@@ -0,0 +1,65 @@
+import { alan } from '../index.mjs';
+
+const _name = 'Chat';
+const log = (c, o) => utilitas.log(c, _name, { time: 1, ...o || {} });
+
+const generate = async (ctx) => {
+    try {
+        let [resp, extra, lock, sResp, lastMsg, lastSent] =
+            [null, { buttons: [] }, 1000 * 5, null, null, 0];
+        const ok = async options => {
+            const curTime = Date.now();
+            if (options?.processing && (
+                curTime - lastSent < ctx._.limit || lastMsg === resp.text
+            )) { return; }
+            [lastSent, lastMsg] = [curTime + lock, resp.text];
+            if (!options?.processing) {
+                (resp.annotations || []).map((x, i) => extra.buttons.push({
+                    label: `${i + 1}. ${x.title}`, url: x.url,
+                }));
+            }
+            sResp = await ctx.ok(resp.text, {
+                ...ctx._.keyboards ? { keyboards: ctx._.keyboards } : {},
+                md: true, ...extra, ...options || {},
+            });
+            lastSent = curTime;
+            return sResp;
+        };
+        resp = await alan.talk(ctx._.text, {
+            ...ctx._, sessionId: ctx._.chatId, // THIS LINE IS IMPORTANT
+            stream: async rsp => { resp = rsp; ok({ processing: true }); }, // Never await, it will block the stream.
+        });
+        for (let image of resp?.images || []) {
+            await ctx.timeout();
+            await ctx.image(image.data, { caption: image.caption });
+        }
+        for (let video of resp?.videos || []) {
+            await ctx.timeout();
+            await ctx.video(video.data, { caption: video.caption });
+        }
+        for (let audio of resp?.audios || []) {
+            await ctx.timeout();
+            await ctx.audio(audio.data, { caption: audio.caption });
+        }
+        // print(resp);
+        await resp.text.trim() ? ok({ processing: false })
+            : ctx.deleteMessage(ctx._.done[0].message_id);
+        ctx._.request = resp.request;
+        ctx._.response = resp.response;
+        ctx.memorize && await ctx.memorize();
+    } catch (err) { log(err); }
+};
+
+const action = async (ctx, next) => {
+    ctx.finish();
+    await next();
+    if (!ctx._.text && !ctx._.collected.length) { return; }
+    generate(ctx);
+};
+
+export const { name, run, priority, func } = {
+    name: _name,
+    run: true,
+    priority: 100,
+    func: action,
+};

package/skills/-8845_thread.mjs

@@ -1,185 +0,0 @@
-import { alan, hal, uoid, utilitas } from '../index.mjs';
-
-const [EMIJI_FINISH, END, NEW, THREAD, CLR] = ['☑️', '❎', '✨', '🧵', '🆑'];
-
-const [CREATED, SWITCHED] = [
-    `${NEW} Thread created: `, `${EMIJI_FINISH} Thread switched: `
-];
-
-// https://stackoverflow.com/questions/69924954/an-error-is-issued-when-opening-the-telebot-keyboard
-const keyboards = [[
-    { text: `/ai ${hal.EMOJI_BOT}` },
-    { text: `/new ${NEW}` },
-    { text: `/end ${END}` },
-    { text: `/list ${THREAD}` },
-], [
-    { text: '/polish ❇️' },
-    { text: '/to 🇨🇳' },
-    { text: '/to 🇺🇸' },
-], [
-    { text: '/help 🛟' },
-    { text: '/set --tts=🔇' },
-    { text: '/set --tts=🔊' },
-]];
-
-const action = async (ctx, next) => {
-    // reset session storage
-    const resetSession = () => ctx.session.sessionId = uoid.create({
-        type: `ALAN_SESSION_${ctx.chatId}`, security: true,
-    });
-    const resetSessions = () => ctx.session.sessions = [];
-    const resetContext = context => ctx.session.context = context || {};
-    const now = Date.now();
-    const preSessionId = ctx.session.sessionId || resetSession();
-    ctx.session.sessions || resetSessions();
-    ctx.session.context || resetContext();
-    ctx.carry || (ctx.carry = {});
-    ctx.carry.threadInfo || (ctx.carry.threadInfo = []);
-    // load functions
-    ctx.clear = async context => {
-        await alan.resetSession(
-            ctx.session.sessionId,
-            { systemPrompt: context?.prompt } // @todo: switch to real system prompt
-        );
-        resetContext(context);
-        const id = findSession(ctx.session.sessionId);
-        ctx.cmd && (ctx.cmd.ignored = true);
-        ctx.session.sessions?.[id] && (
-            ctx.session.sessions[id].context = ctx.session.context
-        );
-        ctx.hello();
-    };
-    const switchSession = async () => {
-        let resp;
-        for (const session of ctx.session.sessions) {
-            if (session.id === ctx.session.sessionId) {
-                ctx.session.sessionId = session.id;
-                ctx.session.context = session.context;
-                session.touchedAt = now;
-                resp = session;
-                preSessionId !== ctx.session.sessionId
-                    && ctx.carry.threadInfo.push(SWITCHED
-                        + getLabel(findSession(ctx.session.sessionId)));
-                break;
-            }
-        }
-        if (!resp) {
-            ctx.session.sessions.push(resp = {
-                id: resetSession(),
-                createdAt: now, touchedAt: now, context: {},
-            });
-            ctx.carry.threadInfo.push(CREATED
-                + `\`${getLabel(findSession(ctx.session.sessionId))}\``);
-            await ctx.clear();
-        }
-        ctx.carry.sessionId = ctx.session.sessionId;
-        ctx.carry.threadInfo.length && (ctx.carry.keyboards = keyboards);
-        return resp;
-    };
-    const defauleTitle = i => (ctx.session.sessions[i]?.context?.cmd
-        ? `\`${ctx.session.sessions[i].context.cmd}\` ` : 'Untitled thread '
-    ) + `(${new Date(ctx.session.sessions[i].createdAt).toLocaleString()})`;
-    const getLabel = i => ctx.session.sessions[i].label || defauleTitle(i);
-    const findSession = id => {
-        for (let i = 0; i < ctx.session.sessions.length; i++) {
-            if (ctx.session.sessions[i].id === utilitas.trim(id)) {
-                return i;
-            }
-        }
-    };
-    const ok = async (message, options) => await ctx.ok(message, {
-        ...options || {},
-        ...options?.buttons ? {} : (options?.keyboards || { keyboards }),
-    });
-    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) => {
-            names?.[x.id]
-                && (ctx.session.sessions[i].label = names[x.id])
-                && (ctx.session.sessions[i].labelUpdatedAt = now);
-            return {
-                label: `${ctx.session.sessions[i].id === ctx.session.sessionId
-                    ? `${EMIJI_FINISH} ` : ''}${getLabel(i)}`,
-                text: `/switch ${x.id}`,
-            };
-        });
-        return await ok(message, { lastMessageId: lastMsgId, buttons });
-    };
-    const switched = async (preTitle, newThread) => await ok(
-        `${preTitle ? `${END} Thread ended: \`${preTitle}\`\n\n` : ''}`
-        + (newThread ? CREATED : SWITCHED)
-        + `\`${getLabel(findSession(ctx.session.sessionId))}\``,
-        { pageBreak: true }
-    );
-    // handle commands
-    switch (ctx.cmd?.cmd) {
-        case 'clearkb':
-            return await ok(EMIJI_FINISH, { keyboards: [] });
-        case 'clear':
-            ctx.carry.threadInfo.push(`${CLR} Thread cleared: \``
-                + `${getLabel(findSession(ctx.session.sessionId))}\``);
-            await ctx.clear();
-            break;
-        case 'endall':
-            ctx.carry.threadInfo.push(`🔄 All threads have been cleared.`);
-            resetSessions();
-            break;
-        case 'new':
-            resetSession();
-            break;
-        case 'list':
-            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: hal.HELLO }
-                );
-                return await listThreads(sNames, resp[0]?.message_id);
-            }, { log: true });
-            return resp;
-        case 'end':
-            const id = findSession(
-                ctx.cmd.args.startsWith('ALAN_SESSION_')
-                && utilitas.trim(ctx.cmd.args) || ctx.session.sessionId
-            );
-            let preTitle = '';
-            ctx.session.sessions?.[id] && (preTitle = getLabel(id))
-                && (ctx.session.sessions.splice(id, 1));
-            const newThread = ctx.session.sessions.length === 0
-            const sorted = ctx.session.sessions.slice().sort(
-                (x, y) => y.touchedAt - x.touchedAt
-            );
-            ctx.session.sessionId = sorted?.[0]?.id;
-            await switchSession();
-            return await switched(preTitle, newThread);
-        case 'switch':
-            ctx.session.sessionId = utilitas.trim(ctx.cmd.args);
-            await switchSession();
-            await listThreads();
-            return await switched();
-        case 'factory':
-        case 'reset':
-            await alan.resetSession(ctx.session.sessionId);
-            break;
-    }
-    await switchSession();
-    await next();
-};
-
-export const { name, run, priority, func, help, cmdx } = {
-    name: 'Thread',
-    run: true,
-    priority: -8845,
-    func: action,
-    help: '¶ Thread management.',
-    cmdx: {
-        clear: 'Clear current thread.',
-        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_ai.mjs

@@ -1,97 +0,0 @@
-import { alan, bot, hal, utilitas } from '../index.mjs';
-
-const ais = await alan.getAi(null, { all: true });
-const EMIJI_FINISH = '☑️';
-
-const listAIs = async ctx => {
-    const lastMessageId = ctx?.update?.callback_query?.message?.message_id;
-    const message = `Features:\n`
-        + hal.uList(Object.entries(alan.FEATURE_ICONS).map(
-            x => `${x[1]} ${x[0]}`
-        )) + `\n\nAI${ais.length > 0 ? 's' : ''}:\n`;
-    const buttons = ais.map(x => ({
-        label: `${ctx.session.config?.ai === x.id
-            ? `${EMIJI_FINISH} ` : ''}${x.name}: ${x.features}`,
-        text: `/set --ai=${x.id}`,
-    }));
-    return await ctx.ok(message, { lastMessageId, buttons });
-};
-
-const action = async (ctx, next) => {
-    switch (ctx.cmd?.cmd) {
-        case 'ai': return await listAIs(ctx);
-    }
-    if (ctx.session.config?.ai === '@') {
-        ctx.selectedAi = ais.map(x => x.id);
-    } else if (ctx.collected?.length) {
-        const supported = {};
-        for (const x of ais) {
-            const supportedMimeTypes = [
-                ...x.model.supportedMimeTypes,
-                ...x.model.supportedDocTypes,
-                ...x.model.supportedAudioTypes,
-            ];
-            for (const i of ctx.collected) {
-                supported[x.id] || (supported[x.id] = 0);
-                // Priority for supported mime types
-                supportedMimeTypes.includes(i?.content?.mime_type)
-                    && supported[x.id]++;
-                // Priority for user selected AI
-                x.id === ctx.session.config?.ai && supported[x.id]++;
-                // Priority for audio models
-                ctx.checkSpeech() && (
-                    x.model.supportedAudioTypes || []
-                ).includes(i?.content?.mime_type)
-                    && (ctx.carry.audioMode = true)
-                    && x.model.audio && supported[x.id]++;
-            }
-        }
-        ctx.selectedAi = [Object.keys(supported).sort(
-            (x, y) => supported[y] - supported[x]
-        )?.[0] || ais[0].id];
-    } else if (ais.map(x => x.id).includes(ctx.session.config?.ai)) {
-        ctx.selectedAi = [ctx.session.config.ai];
-    } else {
-        ctx.selectedAi = [ais[0].id];
-    }
-    await next();
-};
-
-const validateAi = async (val, ctx) => {
-    for (let name of [...ais.map(x => x.id), '', '@']) {
-        if (utilitas.insensitiveCompare(val, name)) {
-            ctx && (ctx.sendConfig = async (_c, _o, ctx) => await listAIs(ctx));
-            return name;
-        }
-    }
-    utilitas.throwError('No AI engine matched.');
-};
-
-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=[AI_ID]` to use specific AI engine.',
-        'Tip 4: Set `ai=@` to use all AI engines simultaneously.',
-    ]),
-    args: {
-        hello: {
-            type: 'string', short: 's', default: 'Hello!',
-            desc: "Change initial prompt: /set --hello 'Bonjour!'",
-        },
-        ai: {
-            type: 'string', short: 'a', default: '',
-            desc: "`(AI_ID, ..., @)` Select AI engine.",
-            validate: validateAi,
-        },
-    },
-    cmdx: {
-        ai: 'List all available AIs.',
-    }
-};

package/skills/20_instant.mjs

@@ -1,25 +0,0 @@
-import { alan, bot } from '../index.mjs';
-
-const action = async (ctx, next) => {
-    const ais = await alan.getAi(null, { all: true });
-    const allAi = ais.map(x => x.id);
-    switch (ctx.cmd.cmd) {
-        case 'all':
-            ctx.selectedAi = allAi;
-            ctx.hello(ctx.cmd.args);
-    }
-    await next();
-};
-
-export const { name, run, priority, func, help, cmds } = {
-    name: 'Instant',
-    run: true,
-    priority: 20,
-    func: action,
-    help: bot.lines([
-        '¶ Use an AI engine `temporary` without touching your settings.',
-    ]),
-    cmds: {
-        all: 'Use all AI engines simultaneously: /all Say hello to all AIs!',
-    },
-};