utilitas 1995.2.37 → 1995.2.39

package/index.mjs

@@ -13,7 +13,6 @@ import * as dbio from './lib/dbio.mjs';
 import * as email from './lib/email.mjs';
 import * as encryption from './lib/encryption.mjs';
 import * as event from './lib/event.mjs';
-import * as hal from './lib/hal.mjs';
 import * as image from './lib/image.mjs';
 import * as media from './lib/media.mjs';
 import * as memory from './lib/memory.mjs';
@@ -41,8 +40,8 @@ export {
     fileType, math, uuid,
     // features
     alan, bot, boxes, cache, callosum, color, dbio, email, encryption, event,
-    hal, image, manifest, media, memory, network, sentinel, shekel, shell, shot,
-    sms, speech, ssl, storage, tape, uoid, utilitas, vision, web
+    image, manifest, media, memory, network, sentinel, shekel, shell, shot, sms,
+    speech, ssl, storage, tape, uoid, utilitas, vision, web
 };
 
 if (utilitas.inBrowser() && !globalThis.utilitas) {

package/lib/alan.mjs

@@ -1,8 +1,12 @@
 import { convert } from './storage.mjs';
 import { create as createUoid } from './uoid.mjs';
-import { ensureString, ignoreErrFunc, need, throwError } from './utilitas.mjs';
 import { loop, end } from './event.mjs';
 
+import {
+    ensureString, ignoreErrFunc, log as _log, need, renderText as _renderText,
+    throwError,
+} from './utilitas.mjs';
+
 const _NEED = [
     '@google-cloud/aiplatform', '@google-cloud/vertexai',
     '@google/generative-ai', 'js-tiktoken', 'OpenAI',
@@ -24,7 +28,7 @@ const [tool, provider, messages, text] = [
     messages => ({ messages }), text => ({ text }),
 ];
 
-const [name, user, system, assistant, model]
+const [name, user, system, assistant, MODEL]
     = ['Alan', 'user', 'system', 'assistant', 'model'];
 const [CODE_INTERPRETER, RETRIEVAL, FUNCTION]
     = ['code_interpreter', 'retrieval', 'function'].map(tool);
@@ -33,15 +37,19 @@ const [NOT_INIT, INVALID_FILE]
 const [silent, STREAM, instructions]
     = [true, 'STREAM', 'You are a helpful assistant.'];
 const GOOGLE_APPLICATION_CREDENTIALS = 'GOOGLE_APPLICATION_CREDENTIALS';
-const [tokenRatio, tokenSafeRatio, GPT_QUERY_LIMIT] = [100 / 75, 1.1, 100];     // https://platform.openai.com/tokenizer
+const [tokenRatio, tokenSafeRatio, GPT_QUERY_LIMIT, minsOfDay]
+    = [100 / 75, 1.1, 100, 60 * 24]; // https://platform.openai.com/tokenizer
 const tokenSafe = count => Math.ceil(count * tokenSafeRatio);
-const countTokens = t => tokenSafe(t.split(/[^a-z0-9]/i).length * tokenRatio);
 const clients = {};
-const _log = { log: true };
+const LOG = { log: true };
 const sessionType = `${name.toUpperCase()}-SESSION`;
 const unifyProvider = options => unifyType(options?.provider, 'AI provider');
 const unifyEngine = options => unifyType(options?.engine, 'AI engine');
 const packResp = _text => [text(_text)];
+const trimTailing = text => text.replace(/[\.\s]*$/, '');
+const newSessionId = () => createUoid({ type: sessionType });
+const renderText = (t, o) => _renderText(t, { extraCodeBlock: 0, ...o || {} });
+const log = (cnt, opt) => _log(cnt, import.meta.url, { time: 1, ...opt || {} });
 
 const [
     OPENAI, VERTEX, GEMINI, CHATGPT, ASSISTANT, OPENAI_EMBEDDING,
@@ -70,6 +78,8 @@ const chatConfig = {
 
 // https://platform.openai.com/docs/models/continuous-model-upgrades
 // https://platform.openai.com/account/limits // Tier 2
+// https://cloud.google.com/vertex-ai/docs/generative-ai/model-reference/gemini
+// https://cloud.google.com/vertex-ai/docs/generative-ai/learn/models
 const MODELS = {
     [GPT_35_TURBO]: {
         contextWindow: 4096,
@@ -79,7 +89,7 @@ const MODELS = {
     },
     [GPT_35_TURBO_1106]: {
         contextWindow: 16385,
-        maximumOutputTokens: 4096,
+        maxOutputTokens: 4096,
         tokenLimitsTPM: 160000,
         requestLimitsRPM: 5000,
         trainingData: 'Sep 2021',
@@ -92,7 +102,7 @@ const MODELS = {
     },
     [GPT_4_1106]: {
         contextWindow: 128000,
-        maximumOutputTokens: 4096,
+        maxOutputTokens: 4096,
         tokenLimitsTPM: 300000,
         tokenLimitsTPD: 5000000,
         requestLimitsRPM: 5000,
@@ -100,12 +110,30 @@ const MODELS = {
     },
     [GPT_4_VISION]: {
         contextWindow: 128000,
-        maximumOutputTokens: 4096,
+        maxOutputTokens: 4096,
         tokenLimitsTPM: 40000,
         requestLimitsRPM: 120,
         requestLimitsRPD: 1500,
         trainingData: 'Apr 2023',
     },
+    [GEMINI_PRO]: {
+        contextWindow: 32760,
+        maxOutputTokens: 8192,
+        trainingData: 'Feb 2023',
+    },
+    [GEMINI_PRO_VISION]: {
+        contextWindow: 16384,
+        maxOutputTokens: 2048,
+        maxImageSize: Infinity,
+        maxFileSize: 20 * 1024 * 1024, // 20 MB
+        maxImagePerPrompt: 16,
+        maxVideoLength: 60 * 2,
+        trainingData: 'Feb 2023',
+        supportedMimeTypes: [
+            'image/png', 'image/jpeg', 'video/mov', 'video/mpeg', 'video/mp4',
+            'video/mpg', 'video/avi', 'video/wmv', 'video/mpegps', 'video/flv',
+        ],
+    },
     [TEXT_EMBEDDING_ADA_002]: {
         contextWindow: 5000000,
         requestLimitsRPM: 5000,
@@ -116,19 +144,17 @@ const MODELS = {
 for (const n in MODELS) {
     MODELS[n]['name'] = n;
     if ([TEXT_EMBEDDING_ADA_002].includes(n)) { continue; }
-    MODELS[n].maximumOutputTokens
-        = MODELS[n].maximumOutputTokens
+    MODELS[n].maxOutputTokens = MODELS[n].maxOutputTokens
         || Math.ceil(MODELS[n].contextWindow * 0.4);
-    MODELS[n].maximumInputTokens
-        = MODELS[n].maximumInputTokens
-        || (MODELS[n].contextWindow - MODELS[n].maximumOutputTokens);
-    MODELS[n].tokenLimitsTPD
-        = MODELS[n].tokenLimitsTPD || (MODELS[n].tokenLimitsTPM * 60 * 24);
-    MODELS[n].requestLimitsRPD
-        = MODELS[n].requestLimitsRPD || (MODELS[n].requestLimitsRPM * 60 * 24);
+    MODELS[n].maxInputTokens = MODELS[n].maxInputTokens
+        || (MODELS[n].contextWindow - MODELS[n].maxOutputTokens);
+    MODELS[n].tokenLimitsTPD = MODELS[n].tokenLimitsTPD
+        || (MODELS[n].tokenLimitsTPM * minsOfDay);
+    MODELS[n].requestLimitsRPD = MODELS[n].requestLimitsRPD
+        || (MODELS[n].requestLimitsRPM * minsOfDay);
     MODELS[n].requestCapacityRPM = Math.ceil(Math.min(
-        MODELS[n].tokenLimitsTPM / MODELS[n].maximumInputTokens,
-        MODELS[n].requestLimitsRPM, MODELS[n].requestLimitsRPD / 60 / 24
+        MODELS[n].tokenLimitsTPM / MODELS[n].maxInputTokens,
+        MODELS[n].requestLimitsRPM, MODELS[n].requestLimitsRPD / minsOfDay
     ));
 }
 
@@ -144,14 +170,14 @@ const init = async (options) => {
         case OPENAI:
             if (options?.apiKey) {
                 const OpenAI = await need('openai');
-                const { getEncoding } = await need('js-tiktoken');
+                // const { getEncoding } = await need('js-tiktoken');
                 const openai = new OpenAI(options);
                 clients[provider] = {
                     client: openai, clientBeta: openai.beta,
-                    tokeniser: getEncoding(options?.tokenModel || 'cl100k_base'),
-                    countTokens: text => tokenSafe(
-                        clients[provider].tokeniser.encode(text).length
-                    ),
+                    // tokeniser: getEncoding(options?.tokenModel || 'cl100k_base'),
+                    // countTokens: text => tokenSafe(
+                    //     clients[provider].tokeniser.encode(text).length
+                    // ),
                 };
             }
             break;
@@ -160,17 +186,21 @@ const init = async (options) => {
                 process.env[GOOGLE_APPLICATION_CREDENTIALS] = options.credentials;
                 const { VertexAI } = await need('@google-cloud/vertexai');
                 const aiplatform = await need('@google-cloud/aiplatform');
-                const [project, location]
-                    = [options?.project, options?.location || 'us-east4'];
+                const [project, location] = [
+                    options?.project,
+                    options?.location || 'northamerica-northeast1', // 'us-east4'
+                ];
                 clients[provider] = {
-                    project, location, helpers: aiplatform.helpers, countTokens,
+                    project, location, helpers: aiplatform.helpers, // countTokens,
                     generative: (new VertexAI({
                         project, location,
                     })).preview.getGenerativeModel({
                         model: options?.model || DEFAULT_MODELS[VERTEX],
                         generation_config: {
-                            max_output_tokens: 2048, temperature: 0.4, top_p: 1,
-                            top_k: 32, ...options?.generation_config || {},
+                            // https://cloud.google.com/vertex-ai/docs/generative-ai/model-reference/gemini
+                            // max_output_tokens: 2048, temperature: 0.4,
+                            // top_p: 1, top_k: 32,
+                            ...options?.generation_config || {},
                         },
                     }),
                     prediction: new aiplatform.v1.PredictionServiceClient({
@@ -190,7 +220,7 @@ const init = async (options) => {
                     embedding: genAi.getGenerativeModel({
                         model: DEFAULT_MODELS[GEMINI_EMEDDING],
                     }),
-                    countTokens,
+                    // countTokens,
                 };
             }
             break;
@@ -201,6 +231,10 @@ const init = async (options) => {
     return clients[provider];
 };
 
+const countTokens = input => tokenSafe((
+    String.isString(input) ? input : JSON.stringify(input)
+).split(/[^a-z0-9]/i).length * tokenRatio);
+
 const buildGptMessage = (content, options) => {
     assert(content, 'Content is required.');
     return String.isString(content) ? {
@@ -250,7 +284,7 @@ const promptChatGPT = async (content, options) => {
         };
         await ignoreErrFunc(async () => await options?.stream?.(
             packGptResp(chunk, options)
-        ), _log);
+        ), LOG);
     }
     return { response: packGptResp(chunk, options) };
 };
@@ -360,7 +394,7 @@ const promptAssistant = async (content, options) => {
             const resp = await getRun(thread.id, objRun.id);
             await ignoreErrFunc(async () => await options?.stream?.(
                 options?.raw ? resp : packResp('')
-            ), _log);
+            ), LOG);
             if (resp?.status !== 'completed') { return; }
             resolve(resp);
         } catch (err) {
@@ -454,7 +488,7 @@ const handleGeminiResponse = async (resp, options) => {
         for await (const chunk of _resp.stream) {
             await ignoreErrFunc(async () => await options.stream(
                 options?.raw ? chunk : chunk.candidates[0].content.parts
-            ), _log);
+            ), LOG);
         }
     }
     const result = await _resp.response;
@@ -616,6 +650,8 @@ const initChat = async (options) => {
         assert(model, `Invalid chat model: '${i}'.`);
         chatConfig.engines[key] = options.engines[i];
         chatConfig.engines[key].model = chatConfig.engines[key].model || model;
+        const mxPmpt = MODELS[chatConfig.engines[key].model].maxInputTokens / 2;
+        let pmptTokens = 0;
         switch (key) {
             case ASSISTANT:
                 chatConfig.engines[key].assistantId
@@ -628,62 +664,108 @@ const initChat = async (options) => {
                         }
                     })).id;
                 break;
+            case CHATGPT: case GEMINI: case VERTEX:
+                pmptTokens = countTokens([buildVertexMessage(
+                    chatConfig.systemPrompt, { role: system }
+                )]); // Use vertex instead of chatgpt because of the longer pack
+                assert(
+                    pmptTokens < mxPmpt,
+                    `System prompt is too long: ${pmptTokens} / ${mxPmpt} tokens.`
+                );
+                break;
         }
     }
     return chatConfig;
 };
 
+const defaultSession = session => ({
+    messages: [], systemPrompt: chatConfig.systemPrompt,
+    threadId: null, ...session || {},
+});
+
+const assertSessionId = sessionId => {
+    sessionId = ensureString(sessionId, { case: 'UP' });
+    assert(sessionId, 'Session ID is required.');
+    return sessionId;
+};
+
 const getSession = async (sessionId, options) => {
-    const [session, messages] = [{
-        messages: [], systemPrompt: chatConfig.systemPrompt, threadId: null,
-        ...(await chatConfig.sessions.get(
-            sessionId, options?.prompt, options
-        )) || {},
-    }, []];
-    switch (options?.engine) {
-        case CHATGPT:
-            session.messages.map(x => {
-                messages.push(buildGptMessage(x.request, { role: user }));
-                messages.push(buildGptMessage(x.response, { role: assistant }));
-            });
-            break;
-        case GEMINI:
-        case VERTEX:
-            session.messages.map(x => {
-                messages.push(buildVertexMessage(x.request, { role: user }));
-                messages.push(buildVertexMessage(x.response, { role: model }));
-            });
-            break;
-    }
-    messages.length && (session.messages = messages);
-    return session;
+    sessionId = assertSessionId(sessionId);
+    return defaultSession(await chatConfig.sessions.get(
+        sessionId, options?.prompt, options
+    ));
 };
 
-const setSessions = async (sessionId, session, options) => {
+const setSession = async (sessionId, session, options) => {
+    sessionId = assertSessionId(sessionId);
     return await chatConfig.sessions.set(sessionId, session, options);
 };
 
+const resetSession = async (sessionId, options) => {
+    const session = {
+        ...defaultSession(),
+        ...options?.systemPrompt ? { systemPrompt: options.systemPrompt } : {},
+    };
+    return await setSession(sessionId, session);
+};
+
 const talk = async (input, options) => {
     const engine = unifyEngine({ engine: CHATGPT, ...options });
     assert(chatConfig.engines[engine], NOT_INIT);
-    const sessionId = options?.sessionId || createUoid({ type: sessionType });
-    const session = await getSession(sessionId, options);
-    const chat = { request: input };
-    let [_provider, _model, resp] = [engine, null, null];
+    const model = MODELS[chatConfig.engines[engine].model];
+    const sessionId = options?.sessionId || newSessionId();
+    const session = await getSession(sessionId, { engine, ...options });
+    let [_provider, _model, resp, sys, messages, msgBuilder] =
+        [engine, null, null, [], [], null];
     switch (engine) {
         case CHATGPT:
-            _provider = OPENAI; _model = DEFAULT_MODELS[CHATGPT]; break;
+            _provider = OPENAI;
+            _model = DEFAULT_MODELS[CHATGPT];
+            sys.push(buildGptMessage(session.systemPrompt, { role: system }));
+            msgBuilder = () => {
+                messages = [];
+                session.messages.map(x => {
+                    messages.push(buildGptMessage(x.request, { role: user }));
+                    messages.push(buildGptMessage(x.response, { role: assistant }));
+                });
+            };
+            msgBuilder()
+            break;
         case ASSISTANT:
-            _provider = OPENAI; _model = DEFAULT_MODELS[ASSISTANT]; break;
+            _provider = OPENAI;
+            _model = DEFAULT_MODELS[ASSISTANT];
+            break;
         case GEMINI: case VERTEX:
-            _model = DEFAULT_MODELS[engine]; break;
+            _model = DEFAULT_MODELS[engine];
+            sys.push(buildVertexMessage(session.systemPrompt, { role: user }));
+            msgBuilder = () => {
+                messages = [];
+                session.messages.map(x => {
+                    messages.push(buildVertexMessage(x.request, { role: user }));
+                    messages.push(buildVertexMessage(x.response, { role: MODEL }));
+                });
+            };
+            msgBuilder()
+            break;
         default:
             throwError(`Invalid AI engine: '${engine}'.`);
     }
+    while (countTokens([
+        ...sys, ...messages, buildVertexMessage(input, { role: user })
+    ]) >= model.maxInputTokens) {
+        if (messages.length) {
+            session.messages.shift();
+            msgBuilder && msgBuilder();
+        } else {
+            input = trimTailing(trimTailing(input).slice(0, -1)) + '...';
+        }
+    }
+    const chat = { request: input };
+    log(`Prompt: ${JSON.stringify(input)}`);
     switch (engine) {
         case CHATGPT:
             resp = await promptChatGPT(input, {
-                messages: session.messages, model: _model, ...options,
+                messages, model: _model, ...options,
             });
             break;
         case ASSISTANT:
@@ -694,14 +776,10 @@ const talk = async (input, options) => {
             session.threadId = resp.thread.id;
             break;
         case GEMINI:
-            resp = await promptGemini(input, {
-                messages: session.messages, ...options,
-            });
+            resp = await promptGemini(input, { messages, ...options });
             break;
         case VERTEX:
-            resp = await promptVertex(input, {
-                messages: session.messages, ...options,
-            });
+            resp = await promptVertex(input, { messages, ...options });
             break;
     }
     for (const _resp of resp.response) {
@@ -711,8 +789,24 @@ const talk = async (input, options) => {
         }
     }
     session.messages.push(chat);
-    await setSessions(sessionId, session, options);
-    return { sessionId, response: resp.response };
+    await setSession(sessionId, session, options);
+    const text = resp.response.filter(x => x.text).map(x => x.text).join('\n\n');
+    log(`Response: ${JSON.stringify(resp.response)}`);
+    return {
+        sessionId, response: resp.response, text, rendered: renderText(text),
+        spoken: renderText(text, { noCode: true }).replace(/\[\^\d\^\]/ig, ''),
+    };
+};
+
+const getMaxChatPromptLimit = (options) => {
+    let resp = 0;
+    for (const i in chatConfig.engines) {
+        if (options?.engine && i !== options.engine) { continue; }
+        const maxInputTokens = MODELS[chatConfig.engines[i].model].maxInputTokens;
+        resp = resp ? Math.min(resp, maxInputTokens) : maxInputTokens;
+    }
+    assert(resp > 0, 'Chat engine has not been initialized.');
+    return resp;
 };
 
 export default init;
@@ -738,11 +832,11 @@ export {
     buildGptTrainingCase,
     buildGptTrainingCases,
     cancelGptFineTuningJob,
+    countTokens,
     createAssistant,
     createGeminiEmbedding,
     createGptFineTuningJob,
     createMessage,
-    initChat,
     createOpenAIEmbedding,
     createVertexEmbedding,
     deleteAllFilesFromAssistant,
@@ -756,9 +850,11 @@ export {
     getAssistant,
     getGptFineTuningJob,
     getLatestMessage,
+    getMaxChatPromptLimit,
     getRun,
     getThread,
     init,
+    initChat,
     listAssistant,
     listAssistantFiles,
     listFiles,
@@ -771,6 +867,7 @@ export {
     promptChatGPT,
     promptGemini,
     promptVertex,
+    resetSession,
     run,
     tailGptFineTuningEvents,
     talk,

package/lib/manifest.mjs

@@ -1,7 +1,7 @@
 const manifest = {
     "name": "utilitas",
     "description": "Just another common utility for JavaScript.",
-    "version": "1995.2.37",
+    "version": "1995.2.39",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",
@@ -36,7 +36,6 @@ const manifest = {
         "@mozilla/readability": "^0.4.4",
         "@ngrok/ngrok": "^0.9.1",
         "@sentry/node": "^7.88.0",
-        "@waylaidwanderer/chatgpt-api": "^1.37.3",
         "acme-client": "^5.0.0",
         "browserify-fs": "^1.0.0",
         "buffer": "^6.0.3",

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "utilitas",
     "description": "Just another common utility for JavaScript.",
-    "version": "1995.2.37",
+    "version": "1995.2.39",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",
@@ -47,7 +47,6 @@
         "@mozilla/readability": "^0.4.4",
         "@ngrok/ngrok": "^0.9.1",
         "@sentry/node": "^7.88.0",
-        "@waylaidwanderer/chatgpt-api": "^1.37.3",
         "acme-client": "^5.0.0",
         "browserify-fs": "^1.0.0",
         "buffer": "^6.0.3",

package/lib/hal.mjs

@@ -1,139 +0,0 @@
-import {
-    ensureString, insensitiveCompare, log as _log, need,
-    renderText as _renderText, throwError, verifyUrl,
-} from './utilitas.mjs';
-
-const _NEED = ['@waylaidwanderer/chatgpt-api'];
-const [BING, CHATGPT] = ['BING', 'CHATGPT'];
-const renderText = (t, o) => _renderText(t, { extraCodeBlock: 1, ...o || {} });
-const log = content => _log(content, import.meta.url);
-const iCmp = (strA, strB) => insensitiveCompare(strA, strB, { w: true });
-const link = (text, url) => `[${text}](${url})`;
-const li = (id, text, url) => `\n${id}. ` + (url ? link(text, url) : text);
-const cardReg = /^\[\d*\]:\ ([^\ ]*)\ "(.*)"$/ig;
-// https://help.openai.com/en/articles/4936856-what-are-tokens-and-how-to-count-them
-// Adding 10% to the token count to account for the model's error margin.
-const countTokens = t => Math.ceil(t.split(/[^a-z0-9]/i).length * 100 / 75 * 1.1);
-// Keep this for GPT4 {
-// const MAX_CONTEXT_TOKENS = 8192;
-// }
-const MAX_CONTEXT_TOKENS = 4096;
-const MAX_PROMPT_TOKENS = Math.floor(MAX_CONTEXT_TOKENS * 0.6);
-const MAX_RESPONSE_TOKENS = MAX_CONTEXT_TOKENS - MAX_PROMPT_TOKENS;
-
-const init = async options => {
-    const clear = key => key ? (delete sessions[key]) : (sessions = {});
-    const get = (k, s) => k ? (s ? sessions[k]?.[s] : sessions[k]) : sessions;
-    const set = (k, s, v) => sessions[k][s] = v;
-    let [sessions, provider, engine, client] = [{}];
-    switch ((provider = ensureString(options?.provider, { case: 'UP' }))) {
-        case BING:
-            // https://github.com/waylaidwanderer/node-chatgpt-api/blob/main/demos/use-bing-client.js
-            engine = (await need('@waylaidwanderer/chatgpt-api')).BingAIClient;
-            client = new engine(options?.clientOptions);
-            break;
-        case CHATGPT:
-            // https://github.com/waylaidwanderer/node-chatgpt-api/blob/main/demos/use-client.js
-            // Throttled: Request is throttled.
-            // https://github.com/waylaidwanderer/node-chatgpt-api/issues/96
-            engine = (await need('@waylaidwanderer/chatgpt-api')).ChatGPTClient;
-            client = new engine(options?.clientOptions?.apiKey, {
-                keepNecessaryMessagesOnly: true,
-                // Keep this for GPT4 {
-                // maxContextTokens: MAX_CONTEXT_TOKENS,
-                // }
-                modelOptions: {
-                    model: options?.model || 'gpt-3.5-turbo',
-                    // Keep this for GPT4 {
-                    // model: options?.model || 'gpt-4',
-                    // max_tokens: MAX_RESPONSE_TOKENS,
-                    // }
-                    ...options?.clientOptions?.modelOptions || {}
-                }, ...options?.clientOptions || {},
-            }, options?.cacheOptions);
-            break;
-        default: throwError('Invalid AI provider.', 500);
-    }
-    client.provider = provider;
-    const send = async (message, options, onProgress) => {
-        const [sessionId, cur, upd, apd] = [
-            options?.sessionId || '_',
-            key => get(sessionId, key),
-            (key, val) => set(sessionId, key, val),
-            (key, val) => set(sessionId, key, cur(key) + val),
-        ];
-        options?.session && (sessions[sessionId] = options.session);
-        const objSession = { parentMessageId: cur('messageId') };
-        switch (client.provider) {
-            case BING:
-                Object.assign(objSession, {
-                    toneStyle: options?.toneStyle || 'balanced', // or creative, precise
-                    jailbreakConversationId: cur('jailbreakConversationId') || true,
-                });
-                break;
-            case CHATGPT:
-                Object.assign(objSession, { conversationId: cur('conversationId') });
-                break;
-        }
-        log(`Prompt: ${message}`);
-        try {
-            sessions[sessionId] = await client.sendMessage(
-                message, { ...objSession, ...options || {}, onProgress }
-            );
-        } catch (err) {
-            // @todo: when this happens, just reset hal? not all the project?
-            log(err);
-            clear(sessionId);
-            throwError(err?.message || err, 500);
-        }
-        upd('responseRendered', renderText(cur('response')));
-        // We should use `cur('details')?.spokenText` but it's too short and infoless for now.
-        upd('spokenText', renderText(cur('response'), { noCode: true }).replace(/\[\^\d\^\]/ig, ''));
-        const sources = cur('details')?.sourceAttributions || [];
-        if (sources.length) {
-            apd('responseRendered', '\n\nSource:');
-            for (let i in sources) {
-                const idx = ~~i + 1;
-                upd('responseRendered', cur('responseRendered').replaceAll(
-                    `[^${idx}^]`, link(`(${idx})`, sources[i].seeMoreUrl)
-                ) + li(idx, sources[i].providerDisplayName, sources[i].seeMoreUrl));
-            }
-        }
-        const cards = (
-            cur('details')?.adaptiveCards || []
-        )[0]?.body[0].text.split('\n\n')[0].split('\n').map(line => ({
-            providerDisplayName: line.replace(cardReg, '$2'),
-            seeMoreUrl: line.replace(cardReg, '$1'),
-        })).filter(card => {
-            for (let src of sources) {
-                if (iCmp(src.seeMoreUrl, card.seeMoreUrl)) { return false; }
-            }
-            return card.providerDisplayName && verifyUrl(card.seeMoreUrl);
-        });
-        if (cards?.length) {
-            apd('responseRendered', '\n\nLearn more:');
-            for (let i in cards) {
-                apd('responseRendered', li(
-                    ~~i + 1, cards[i].providerDisplayName, cards[i].seeMoreUrl
-                ));
-            }
-        }
-        upd(
-            'suggestedResponses',
-            cur('details')?.suggestedResponses?.map?.(s => s.text) || []
-        );
-        // console.log(JSON.stringify(cur()));
-        return cur();
-    };
-    return { clear, client, engine, get, send };
-};
-
-export default init;
-export {
-    _NEED,
-    MAX_CONTEXT_TOKENS,
-    MAX_PROMPT_TOKENS,
-    MAX_RESPONSE_TOKENS,
-    countTokens,
-    init,
-};