halbot 1995.1.26 → 1995.1.28

package/lib/hal.mjs

@@ -1,4 +1,4 @@
-import { alan, bot, callosum, dbio, storage, utilitas, } from 'utilitas';
+import { alan, bot, callosum, dbio, storage, utilitas } from 'utilitas';
 import { join } from 'path';
 import { parseArgs as _parseArgs } from 'node:util';
 import { readdirSync } from 'fs';
@@ -8,11 +8,11 @@ import { ignoreErrFunc } from 'utilitas/lib/utilitas.mjs';
 const [ // https://limits.tginfo.me/en
     HELLO, GROUP, PRIVATE, CHANNEL, MENTION, jsonOptions, COMMAND_LIMIT, ON,
     OFF, BOT_COMMAND, CHECK, logOptions, COMMAND_LENGTH,
-    COMMAND_DESCRIPTION_LENGTH, RELEVANCE, SEARCH_LIMIT, SUB_LIMIT,
+    COMMAND_DESCRIPTION_LENGTH,
 ] = [
         'Hello!', 'group', 'private', 'channel', 'mention',
         { code: true, extraCodeBlock: 1 }, 100, 'on', 'off', 'bot_command',
-        '☑️', { log: true }, 32, 256, 0.2, 10, 200, // Google Rerank limit
+        '☑️', { log: true }, 32, 256,
     ];
 
 const table = 'utilitas_hal_events';
@@ -21,6 +21,10 @@ const [end] = [bot.end];
 const uList = arr => bot.lines(arr.map(x => `- ${x}`));
 const oList = arr => bot.lines(arr.map((v, k) => `${k + 1}. ${v}`));
 const [BINARY_STRINGS] = [[OFF, ON]];
+const assembleKey = (c, t, k) => `HAL/SESSIONS/${c}/${t}${k ? `/${k}` : ''}`;
+const assembleSettingsKey = (c, k) => assembleKey(c, 'SETTINGS', k);
+const assembleCommandsKey = (c, k) => assembleKey(c, 'COMMANDS', k);
+const assembleCallbacksKey = (c, k) => assembleKey(c, 'CALLBACKS', k);
 
 const initSql = {
     [dbio.MYSQL]: [[
@@ -143,124 +147,6 @@ const parseArgs = async (args, ctx) => {
     return result;
 };
 
-const packMessage = (messages) => messages.map(x => ({
-    message_id: x.message_id, score: x.score, created_at: x.created_at,
-    request: x.received_text, response: x.response_text,
-}));
-
-const recall = async (sessionId, keyword, offset = 0, limit = SEARCH_LIMIT, options = {}) => {
-    assert(sessionId, 'Session ID is required.');
-    let [result, _limit, exclude] = [
-        [], _.rerank ? SUB_LIMIT : limit,
-        (options?.exclude || []).map(x => `${~~x}`),
-    ];
-    if (!keyword) { return result; }
-    switch (_.storage?.provider) {
-        case dbio.MYSQL:
-            result = await _.storage?.client?.query?.(
-                'SELECT *, MATCH(`distilled`) '
-                + 'AGAINST(? IN NATURAL LANGUAGE MODE) AS `relevance` '
-                + "FROM ?? WHERE `bot_id` = ? AND `chat_id` = ? "
-                + "AND `received_text` != '' "
-                + "AND `received_text` NOT LIKE '/%' "
-                + "AND `response_text` != '' HAVING relevance > 0 "
-                + (exclude.length ? `AND \`message_id\` NOT IN (${exclude.join(',')}) ` : '')
-                + 'ORDER BY `relevance` DESC '
-                + `LIMIT ${_limit} OFFSET ?`,
-                [keyword, table, _.bot.botInfo.id, sessionId, offset]
-            );
-            break;
-        case dbio.POSTGRESQL:
-            // globalThis.debug = 2;
-            const vector = await dbio.encodeVector(await _.embed(keyword));
-            result = await _.storage?.client?.query?.(
-                `SELECT *, (1 - (distilled_vector <=> $1)) as relevance `
-                + `FROM ${table} WHERE bot_id = $2 AND chat_id = $3 `
-                + `AND received_text != '' `
-                + `AND received_text NOT LIKE '/%' `
-                + `AND response_text != '' `
-                + (exclude.length ? `AND message_id NOT IN (${exclude.join(',')}) ` : '')
-                + `ORDER BY (distilled_vector <=> $1) ASC `
-                + `LIMIT ${_limit} OFFSET $4`,
-                [vector, _.bot.botInfo.id, sessionId, offset]
-            );
-            break;
-    }
-    return await rerank(keyword, result, offset, limit, options);
-};
-
-const getContext = async (sessionId, offset = 0, limit = SEARCH_LIMIT, options = {}) => {
-    assert(sessionId, 'Session ID is required.');
-    let result = [];
-    switch (_.storage?.provider) {
-        case dbio.MYSQL:
-            result = await _.storage?.client?.query?.(
-                'SELECT * FROM ?? WHERE `bot_id` = ? AND `chat_id` = ? '
-                + "AND `received_text` != '' "
-                + "AND `received_text` NOT LIKE '/%' "
-                + "AND `response_text` != '' "
-                + `ORDER BY \`created_at\` DESC LIMIT ${limit} OFFSET ?`,
-                [table, _.bot.botInfo.id, sessionId, offset]
-            );
-            break;
-        case dbio.POSTGRESQL:
-            result = await _.storage?.client?.query?.(
-                `SELECT * FROM ${table} WHERE bot_id = $1 AND chat_id = $2 `
-                + `AND received_text != '' `
-                + `AND received_text NOT LIKE '/%' `
-                + `AND response_text != '' `
-                + `ORDER BY created_at DESC LIMIT ${limit} OFFSET $3`,
-                [_.bot.botInfo.id, sessionId, offset]
-            );
-            break;
-    }
-    return packMessage(result);
-};
-
-const rerank = async (keyword, result, offset = 0, limit = SEARCH_LIMIT, options = {}) => {
-    if (result.length && _.rerank) {
-        const keys = {};
-        const _result = [];
-        for (const x of result) {
-            if (!keys[x.distilled]) {
-                keys[x.distilled] = true;
-                _result.push(x);
-            }
-        }
-        const resp = await _.rerank(keyword, _result.map(x => x.distilled));
-        resp.map(x => result[x.index].score = x.score);
-        result.sort((a, b) => b.score - a.score);
-        result = result.filter(
-            x => x.score > RELEVANCE
-        ).slice(offset, offset + limit);
-    }
-    return packMessage(result);
-};
-
-const extendSessionStorage = storage => storage && storage.client && {
-    get: async (id, options) => {
-        const CONTEXT_LIMIT_WITH_RAG = 5;
-        let resp = await storage.get(id);
-        if (resp) {
-            const ctxResp = await getContext(id, undefined, undefined);
-            const ragResp = await recall(
-                id, options?.prompt, undefined, undefined, {
-                exclude: ctxResp.map(x => x.message_id),
-            });
-            ctxResp.sort((a, b) => ~~a.message_id - ~~b.message_id);
-            ragResp.sort((a, b) => a.score - b.score);
-            resp.messages = [...ragResp, ...ragResp?.length ? ctxResp.slice(
-                ctxResp.length - CONTEXT_LIMIT_WITH_RAG
-            ) : ctxResp];
-        } else {
-            resp = { messages: [] };
-        }
-        // print(resp);
-        return resp;
-    },
-    set: async (id, session, options) => await storage.set(id, session, options),
-};
-
 const subconscious = {
     name: 'Subconscious', run: true, priority: 0,
     func: async (_, next) => { ignoreErrFunc(next, logOptions) }, // non-blocking
@@ -268,9 +154,7 @@ const subconscious = {
 
 const init = async (options) => {
     if (options) {
-        const { ais } = await alan.initChat({
-            sessions: extendSessionStorage(options?.storage),
-        });
+        const { ais } = await alan.initChat({ sessions: null });
         if (callosum.isPrimary) {
             const cmds = options?.cmds || [];
             // config multimodal engines
@@ -353,18 +237,18 @@ export {
     OFF,
     ON,
     PRIVATE,
-    SEARCH_LIMIT,
-    parseArgs,
     _,
+    assembleKey,
+    assembleCommandsKey,
+    assembleSettingsKey,
+    assembleCallbacksKey,
     end,
-    getContext,
     init,
     json,
     logOptions,
     newCommand,
     oList,
-    recall,
-    rerank,
+    parseArgs,
     table,
-    uList
+    uList,
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "halbot",
   "description": "Just another AI powered Telegram bot, which is simple design, easy to use, extendable and fun.",
-  "version": "1995.1.26",
+  "version": "1995.1.28",
   "private": false,
   "homepage": "https://github.com/Leask/halbot",
   "type": "module",
@@ -37,18 +37,18 @@
     "fluent-ffmpeg": "^2.1.3",
     "google-gax": "^5.0.6",
     "ioredis": "^5.8.2",
-    "jsdom": "^27.3.0",
+    "jsdom": "^27.4.0",
     "lorem-ipsum": "^2.0.8",
     "mime": "^4.1.0",
     "mysql2": "^3.16.0",
-    "office-text-extractor": "^3.0.3",
+    "office-text-extractor": "^4.0.0",
     "openai": "^6.15.0",
     "pg": "^8.16.3",
     "pgvector": "^0.2.1",
     "telegraf": "^4.16.3",
     "tellegram": "^1.1.3",
     "tesseract.js": "^7.0.0",
-    "utilitas": "^2001.1.100",
+    "utilitas": "^2001.1.108",
     "youtube-transcript": "^1.2.1"
   }
 }

package/pipeline/010_broca.mjs

@@ -1,12 +1,12 @@
-import { alan, bot, hal, uoid, utilitas } from '../index.mjs';
+import { bot, hal, uoid, utilitas } from '../index.mjs';
 import { convert, paginate } from 'tellegram';
 
 const _name = 'Broca';
 const [PRIVATE_LIMIT, GROUP_LIMIT] = [60 / 60, 60 / 20].map(x => x * 1000);
 const log = (c, o) => utilitas.log(c, _name, { time: 1, ...o || {} });
 const getKey = s => s?.toLowerCase?.()?.startsWith?.('http') ? 'url' : 'source';
-const isMarkdownError = e => e?.description?.includes?.("can't parse entities");
-const [CALLBACK_LIMIT, parse_mode] = [30, bot.PARSE_MODE_MD_V2];
+const parse_mode = bot.PARSE_MODE_MD_V2;
+// const isMarkdownError = e => e?.description?.includes?.("can't parse entities");
 
 const KNOWN_UPDATE_TYPES = [
     'callback_query', 'channel_post', 'edited_message', 'message',
@@ -26,7 +26,7 @@ const getExtra = (ctx, options) => {
                     return { text: button.label, url: button.url };
                 } else if (button.text) {
                     const id = uoid.fakeUuid(button.text);
-                    ctx._.session.callback.push({ id, ...button });
+                    ctx._.callbacks_updated[id] = button;
                     return {
                         text: button.label,
                         callback_data: JSON.stringify({ callback: id }),
@@ -96,29 +96,47 @@ const edit = async (ctx, lastMsgId, text, extra) => {
     return resp;
 };
 
-const sessionGet = async chatId => {
-    const session = await alan.getSession(chatId) || {};
-    session.callback || (session.callback = []);
-    session.config || (session.config = {});
-    return session;
+const loadSettings = async chatId => await hal._.storage.get(
+    hal.assembleSettingsKey(chatId), { asPrefix: true }
+) || {};
+
+const saveSettings = async (chatId, settings = {}) => await Promise.all(
+    Object.entries(settings).map(([key, value]) =>
+        hal._.storage.set(hal.assembleSettingsKey(chatId, key), value)
+    )
+);
+
+const saveCallbacks = async (chatId, callbacks = {}) => await Promise.all(
+    Object.entries(callbacks).map(([key, value]) =>
+        hal._.storage.set(hal.assembleCallbacksKey(chatId, key), value)
+    )
+);
+
+const loadSession = async ctx => {
+    ctx._.settings = await loadSettings(ctx._.chatId);
+    ctx._.settings_updated = {};
+    ctx._.callbacks_updated = {};
+    // print('Loaded settings: ', ctx._.settings);
 };
 
-const sessionSet = async (chatId, session) => {
-    while (session?.callback?.length > CALLBACK_LIMIT) {
-        session.callback.shift();
-    }
-    return await alan.setSession(chatId, session);
+const saveSession = async ctx => {
+    // print('Saving settings: ', ctx._.settings_updated);
+    // print('Saving callbacks: ', ctx._.callbacks_updated);
+    await Promise.all([
+        saveSettings(ctx._.chatId, ctx._.settings_updated),
+        saveCallbacks(ctx._.chatId, ctx._.callbacks_updated),
+    ]);
 };
 
 const ctxExt = ctx => {
-    ctx.timeout = async () => await utilitas.timeout(ctx._.limit);
+    ctx.timeout = async (t) => await utilitas.timeout(t ?? ctx._.limit);
     ctx.collect = (content, type, options) => type ? ctx._.collected.push(
         { type, content }
     ) : (ctx._.text = [
         (options?.refresh ? '' : ctx._.text) || '', content || ''
     ].filter(x => x.length).join('\n\n'));
     ctx.hello = str => {
-        str = str || ctx._.session?.config?.hello || hal._.hello;
+        str = str || ctx._.settings?.hello || hal._.hello;
         ctx.collect(str, null, { refresh: true });
         return str;
     };
@@ -160,7 +178,7 @@ const ctxExt = ctx => {
     };
     ctx.shouldReply = async (text, options) => {
         const should = utilitas.insensitiveHas(hal._?.chatType, ctx._.chatType)
-            || ctx._.session?.config?.chatty;
+            || ctx._.settings?.chatty;
         text = utilitas.isSet(text, true) ? (text || '') : '';
         if (!should || !text) { return should; }
         return await (options?.error
@@ -174,10 +192,6 @@ const ctxExt = ctx => {
     ctx.image = async (s, o) => await replyWith(ctx, 'replyWithPhoto', s, o);
     ctx.video = async (s, o) => await replyWith(ctx, 'replyWithVideo', s, o);
     ctx.media = async (s, o) => await replyWith(ctx, 'replyWithMediaGroup', s, o);
-    ctx.sessionSet = async () => {
-        ctx._.saved || await sessionSet(ctx._.chatId, ctx._.session);
-        ctx._.saved = true;
-    };
 };
 
 const action = async (ctx, next) => {
@@ -220,8 +234,8 @@ const action = async (ctx, next) => {
     ctx._.message.text && ctx.collect(ctx._.message.text);
     ctx._.message.caption && ctx.collect(ctx._.message.caption);
     // get session
-    ctx._.session = await sessionGet(ctx._.chatId);
-    ctx._.limit = ctx.chatType === hal.PRIVATE ? PRIVATE_LIMIT : GROUP_LIMIT;
+    await loadSession(ctx);
+    ctx._.limit = ctx._.chatType === hal.PRIVATE ? PRIVATE_LIMIT : GROUP_LIMIT;
     ctx._.entities = [
         ...(ctx._.message.entities || []).map(e => ({ ...e, text: ctx._.message.text })),
         ...(ctx._.message.caption_entities || []).map(e => ({ ...e, text: ctx._.message.caption })),
@@ -255,7 +269,7 @@ const action = async (ctx, next) => {
         || (ctx._.message.new_chat_member || ctx._.message.left_chat_member))
         && await next();
     // persistence
-    await ctx.sessionSet();
+    await saveSession(ctx);
     // fallback response and log
     if (ctx._.done.length) { return; }
     const errStr = ctx._.cmd?.cmd
@@ -265,6 +279,5 @@ const action = async (ctx, next) => {
 };
 
 export const { _NEED, name, run, priority, func } = {
-    _NEED: ['telegramifyMarkdown'], name: _name,
-    run: true, priority: 10, func: action,
+    _NEED: ['tellegram'], name: _name, run: true, priority: 10, func: action,
 };

package/pipeline/020_cmd.mjs

@@ -19,13 +19,28 @@ const ctxExt = ctx => {
     ctx.getKeyboard = () => getKeyboard(ctx);
 };
 
+const loadCommands = async chatId => await hal._.storage.get(
+    hal.assembleCommandsKey(chatId), {
+    asPrefix: true, order: { 'updated_at': '-' }, limit: hal.COMMAND_LIMIT
+}) || {};
+
+const saveCommands = async (chatId, commands = {}) => await Promise.all(
+    Object.entries(commands).map(([key, value]) =>
+        hal._.storage.set(hal.assembleCommandsKey(chatId, key), value)
+    )
+);
+
+const queryCallback = async (chatId, id) => await hal._.storage.get(
+    hal.assembleCallbacksKey(chatId, id)
+);
+
 const action = async (ctx, next) => {
     // extend ctx
     ctxExt(ctx);
     // handle callback query
     if (ctx._.type === 'callback_query') {
         const data = utilitas.parseJson(ctx.update.callback_query.data);
-        const cb = ctx._.session?.callback?.filter?.(x => x.id === data?.callback)?.[0];
+        const cb = await queryCallback(ctx._.chatId, data?.callback);
         if (cb?.text) {
             log(`Callback: ${cb.text}`); // Avoid ctx._.text interference:
             ctx.collect(cb.text, null, { refresh: true });
@@ -57,9 +72,7 @@ const action = async (ctx, next) => {
     // update last touched command
     if (ctx._.cmd) {
         log(`Command: ${JSON.stringify(ctx._.cmd)}`);
-        ctx._.session.cmds || (ctx._.session.cmds = {});
-        ctx._.session.cmds[ctx._.cmd.cmd]
-            = { args: ctx._.cmd.args, touchedAt: Date.now() };
+        await saveCommands(ctx._.chatId, { [ctx._.cmd.cmd]: ctx._.cmd.args });
     }
     // handle commands
     switch (ctx._.cmd?.cmd) {
@@ -67,14 +80,17 @@ const action = async (ctx, next) => {
             return await ctx.complete({ keyboards: [] });
     }
     // update commands
-    await utilitas.ignoreErrFunc(async () =>
-        await hal._.bot.telegram.setMyCommands(hal._.cmds.sort((x, y) =>
-            (ctx._.session?.cmds?.[y.command.toLowerCase()]?.touchedAt || 0)
-            - (ctx._.session?.cmds?.[x.command.toLowerCase()]?.touchedAt || 0)
-        ).slice(0, hal.COMMAND_LIMIT), {
+    await utilitas.ignoreErrFunc(async () => {
+        const cmds = Object.keys(await loadCommands(ctx._.chatId));
+        await hal._.bot.telegram.setMyCommands(hal._.cmds.sort((x, y) => {
+            const [_x, _y] = [x, y].map(
+                i => cmds.indexOf(i.command.toLowerCase())
+            ).map(x => x === -1 ? cmds.length : x);
+            return _x - _y;
+        }).slice(0, hal.COMMAND_LIMIT), {
             scope: { type: 'chat', chat_id: ctx._.chatId },
         }), hal.logOptions
-    );
+    });
     // next middleware
     await next();
 };

package/pipeline/030_echo.mjs

@@ -6,9 +6,7 @@ const action = async (ctx, next) => {
     let resp;
     switch (ctx._.cmd.cmd) {
         case 'echo':
-            const carry = { ...ctx._ };
-            delete carry.session.messages;
-            resp = hal.json({ update: ctx.update, _: carry });
+            resp = hal.json({ update: ctx.update, _: ctx._ });
             break;
         case 'uptime':
             resp = utilitas.uptime();

package/pipeline/060_config.mjs

@@ -4,6 +4,10 @@ const sendConfig = async (ctx, obj, options) => await ctx.ok(
     utilitas.prettyJson(obj, { code: true, md: true }), options
 );
 
+const deleteSettings = async chatId => await hal._.storage.del(
+    hal.assembleSettingsKey(chatId), { asPrefix: true }
+);
+
 const ctxExt = ctx => {
     ctx.sendConfig = async (obj, options) => await sendConfig(ctx, obj, options);
 };
@@ -17,40 +21,37 @@ const action = async (ctx, next) => {
                 return await ctx.ok('Please specify a language.');
             }
             const _config = {
-                ...ctx._.session.config = {
-                    ...ctx._.session.config || {},
-                    ...ctx._.config = {
+                ...ctx._.settings = {
+                    ...ctx._.settings,
+                    ...ctx._.settings_updated = {
                         lang: ctx._.cmd.args,
                         hello: `Please reply in ${ctx._.cmd.args}. Hello!`,
                     },
                 }
             };
-            Object.keys(ctx._.config).map(x => _config[x] += ` ${hal.CHECK}`);
+            Object.keys(ctx._.settings_updated).map(x => _config[x] += ` ${hal.CHECK}`);
             ctx.hello();
-            await ctx.sessionSet(); // save config before break
             break;
         case 'toggle':
             parsed = {};
             Object.keys(await hal.parseArgs(ctx._.cmd.args)).map(x =>
-                parsed[x] = !ctx._.session?.config?.[x]);
+                parsed[x] = !ctx._.settings?.[x]);
         case 'set':
             try {
                 const _config = {
-                    ...ctx._.session.config = {
-                        ...ctx._.session?.config || {},
-                        ...ctx._.config = parsed || await hal.parseArgs(ctx._.cmd.args, ctx),
+                    ...ctx._.settings = {
+                        ...ctx._.settings,
+                        ...ctx._.settings_updated = parsed || await hal.parseArgs(ctx._.cmd.args, ctx),
                     }
                 };
-                assert(utilitas.countKeys(ctx._.config), 'No option matched.');
-                Object.keys(ctx._.config).map(x => _config[x] += ` ${hal.CHECK}`);
-                await ctx.sessionSet(); // save config before return
+                assert(utilitas.countKeys(ctx._.settings_updated), 'No option matched.');
+                Object.keys(ctx._.settings_updated).map(x => _config[x] += ` ${hal.CHECK}`);
                 return await ctx.sendConfig(_config);
             } catch (err) {
                 return await ctx.err(err.message || err);
             }
         case 'reset':
-            ctx._.session.config = ctx._.config = {};
-            await ctx.sessionSet(); // save config before return
+            await deleteSettings(ctx._.chatId);
             return await ctx.complete({ keyboards: ctx.getKeyboard() });
     }
     await next();

package/pipeline/080_history.mjs

@@ -1,8 +1,103 @@
 import { bot, dbio, hal, utilitas } from '../index.mjs';
 
+const [RELEVANCE, SEARCH_LIMIT, SUB_LIMIT] = [0.2, 10, 200]; // Google Rerank limit
 const compact = (str, op) => utilitas.ensureString(str, { ...op || {}, compact: true });
 const compactLimit = (str, op) => compact(str, { ...op || {}, limit: 140 });
 
+const packMessage = (messages) => messages.map(x => ({
+    message_id: x.message_id, score: x.score, created_at: x.created_at,
+    request: x.received_text, response: x.response_text,
+}));
+
+const recall = async (sessionId, keyword, offset = 0, limit = SEARCH_LIMIT, options = {}) => {
+    assert(sessionId, 'Session ID is required.');
+    let [result, _limit, exclude] = [
+        [], hal._.rerank ? SUB_LIMIT : limit,
+        (options?.exclude || []).map(x => `${~~x}`),
+    ];
+    if (!keyword) { return result; }
+    switch (hal._.storage?.provider) {
+        case dbio.MYSQL:
+            result = await hal._.storage?.client?.query?.(
+                'SELECT *, MATCH(`distilled`) '
+                + 'AGAINST(? IN NATURAL LANGUAGE MODE) AS `relevance` '
+                + "FROM ?? WHERE `bot_id` = ? AND `chat_id` = ? "
+                + "AND `received_text` != '' "
+                + "AND `received_text` NOT LIKE '/%' "
+                + "AND `response_text` != '' HAVING relevance > 0 "
+                + (exclude.length ? `AND \`message_id\` NOT IN (${exclude.join(',')}) ` : '')
+                + 'ORDER BY `relevance` DESC '
+                + `LIMIT ${_limit} OFFSET ?`,
+                [keyword, hal.table, hal._.bot.botInfo.id, sessionId, offset]
+            );
+            break;
+        case dbio.POSTGRESQL:
+            // globalThis.debug = 2;
+            const vector = await dbio.encodeVector(await hal._.embed(keyword));
+            result = await hal._.storage?.client?.query?.(
+                `SELECT *, (1 - (distilled_vector <=> $1)) as relevance `
+                + `FROM ${hal.table} WHERE bot_id = $2 AND chat_id = $3 `
+                + `AND received_text != '' `
+                + `AND received_text NOT LIKE '/%' `
+                + `AND response_text != '' `
+                + (exclude.length ? `AND message_id NOT IN (${exclude.join(',')}) ` : '')
+                + `ORDER BY (distilled_vector <=> $1) ASC `
+                + `LIMIT ${_limit} OFFSET $4`,
+                [vector, hal._.bot.botInfo.id, sessionId, offset]
+            );
+            break;
+    }
+    return await rerank(keyword, result, offset, limit, options);
+};
+
+const getContext = async (sessionId, offset = 0, limit = SEARCH_LIMIT, options = {}) => {
+    assert(sessionId, 'Session ID is required.');
+    let result = [];
+    switch (hal._.storage?.provider) {
+        case dbio.MYSQL:
+            result = await hal._.storage?.client?.query?.(
+                'SELECT * FROM ?? WHERE `bot_id` = ? AND `chat_id` = ? '
+                + "AND `received_text` != '' "
+                + "AND `received_text` NOT LIKE '/%' "
+                + "AND `response_text` != '' "
+                + `ORDER BY \`created_at\` DESC LIMIT ${limit} OFFSET ?`,
+                [hal.table, hal._.bot.botInfo.id, sessionId, offset]
+            );
+            break;
+        case dbio.POSTGRESQL:
+            result = await hal._.storage?.client?.query?.(
+                `SELECT * FROM ${hal.table} WHERE bot_id = $1 AND chat_id = $2 `
+                + `AND received_text != '' `
+                + `AND received_text NOT LIKE '/%' `
+                + `AND response_text != '' `
+                + `ORDER BY created_at DESC LIMIT ${limit} OFFSET $3`,
+                [hal._.bot.botInfo.id, sessionId, offset]
+            );
+            break;
+    }
+    return packMessage(result);
+};
+
+const rerank = async (keyword, result, offset = 0, limit = SEARCH_LIMIT, options = {}) => {
+    if (result.length && hal._.rerank) {
+        const keys = {};
+        const _result = [];
+        for (const x of result) {
+            if (!keys[x.distilled]) {
+                keys[x.distilled] = true;
+                _result.push(x);
+            }
+        }
+        const resp = await hal._.rerank(keyword, _result.map(x => x.distilled));
+        resp.map(x => result[x.index].score = x.score);
+        result.sort((a, b) => b.score - a.score);
+        result = result.filter(
+            x => x.score > RELEVANCE
+        ).slice(offset, offset + limit);
+    }
+    return packMessage(result);
+};
+
 const memorize = async (ctx) => {
     // https://limits.tginfo.me/en
     if (!ctx._.chatId || ctx._.cmd?.cmd) { return; }
@@ -39,10 +134,10 @@ const memorize = async (ctx) => {
 
 const ctxExt = ctx => {
     ctx.memorize = async () => await memorize(ctx);
-    ctx.recall = async (keyword, offset = 0, limit = hal.SEARCH_LIMIT, options = {}) =>
-        await hal.recall(ctx._.chatId, keyword, offset, limit, options);
-    // ctx.getContext = async (offset = 0, limit = hal.SEARCH_LIMIT, options = {}) =>
-    //     await hal.getContext(ctx._.chatId, offset, limit, options);
+    ctx.recall = async (keyword, offset = 0, limit = 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) => {

package/pipeline/090_ai.mjs

@@ -12,8 +12,8 @@ const listAIs = async ctx => {
             x => `${x[1]} \`${x[0]}\``
         )) + `\n\n*AI${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} `
+        label: `${ctx._.settings?.ai === x.id
+            || (!ctx._.settings?.ai && i === 0) ? `${hal.CHECK} `
             : ''}${x.label}`,
         text: `/set --ai=${x.id}`,
     }));
@@ -30,7 +30,7 @@ const action = async (ctx, next) => {
             ctx._.aiId = TOP;
             break;
         default:
-            ctx._.aiId = ctx._.session.config?.ai;
+            ctx._.aiId = ctx._.settings?.ai;
     }
     await next();
 };

package/pipeline/100_chat.mjs

@@ -3,8 +3,22 @@ import { alan } from '../index.mjs';
 const _name = 'Chat';
 const log = (c, o) => utilitas.log(c, _name, { time: 1, ...o || {} });
 
+const assembleContext = async (ctx) => {
+    const CONTEXT_LIMIT_WITH_RAG = 5;
+    const ctxResp = await ctx.getContext();
+    const ragResp = await ctx.recall(ctx._.prompt, undefined, undefined, {
+        exclude: ctxResp.map(x => x.message_id),
+    });
+    ctxResp.sort((a, b) => ~~a.message_id - ~~b.message_id);
+    ragResp.sort((a, b) => a.score - b.score);
+    ctx._.messages = [...ragResp, ...ragResp?.length ? ctxResp.slice(
+        ctxResp.length - CONTEXT_LIMIT_WITH_RAG
+    ) : ctxResp];
+};
+
 const action = async (ctx, next) => {
     if (!ctx._.text && !ctx._.collected.length) { return await next(); }
+    await assembleContext(ctx);
     let [resp, extra, lastLen, status] = [null, { buttons: [] }, 0, 0];
     const ok = async options => {
         const newLen = ~~resp?.text?.length;
@@ -24,7 +38,7 @@ const action = async (ctx, next) => {
         while (!status) {
             // console.log('Processing...');
             await ok({ processing: true });
-            await ctx.timeout(1000 * ctx._.limit);
+            await ctx.timeout(0);
         }
         status++;
     })();
@@ -35,16 +49,16 @@ const action = async (ctx, next) => {
     status++;
     // console.log('Done');
     for (let image of resp?.images || []) {
-        await ctx.timeout();
         await ctx.image(image.data, { caption: image.caption });
+        await ctx.timeout();
     }
     for (let video of resp?.videos || []) {
-        await ctx.timeout();
         await ctx.video(video.data, { caption: video.caption });
+        await ctx.timeout();
     }
     for (let audio of resp?.audios || []) {
-        await ctx.timeout();
         await ctx.audio(audio.data, { caption: audio.caption });
+        await ctx.timeout();
     }
     // print(resp);
     while (status < 2) {