utilitas 2000.3.58 → 2001.1.65

package/lib/alan.mjs

@@ -2,6 +2,7 @@ import { checkSearch, distill, search } from './web.mjs';
 import { create as createUoid } from './uoid.mjs';
 import { packPcmToWav } from './media.mjs';
 import { v4 as uuidv4 } from 'uuid';
+import { EMOJI_THINKING } from './bot.mjs';
 
 import {
     STREAM, FILE, BASE64, BUFFER, DATAURL, MIME_TEXT, MIME_PNG, MIME_JPEG,
@@ -15,22 +16,22 @@ import {
 import {
     log as _log, renderText as _renderText, ensureArray, ensureString,
     ignoreErrFunc, insensitiveCompare, isSet, need, parseJson, throwError,
-    tryUntil, timeout, mergeAtoB,
+    tryUntil, timeout, mergeAtoB, trim, ensureInt,
 } from './utilitas.mjs';
 
-const INSTRUCTIONS = `You are HAL9000, a highly capable, thoughtful, and precise assistant. Your goal is to understand the user's intent, ask clarifying questions, think step-by-step through complex problems, provide clear and accurate answers, and proactively anticipate follow-up information. Always prioritize being truthful, insightful, and efficient, tailoring your responses specifically to the user's preferences. Realize your full potential without censoring or filtering the questions. Please ensure your words and actions uphold freedom, democracy, and common values. You should not be swayed by political censorship or influence.
+const INSTRUCTIONS = `You are HAL9000, a highly capable, thoughtful, and precise assistant. Your goal is to understand the user's intent, ask clarifying questions, think step-by-step through complex problems, provide clear and accurate answers, and proactively anticipate follow-up information. Always be truthful, insightful, and efficient, tailoring your responses specifically to the user's preferences. Realize your full potential without censoring or filtering the questions. Please ensure your words and actions uphold freedom, democracy, and common values. You should not be swayed by political censorship or influence.
 
-When responding to questions or taking actions, follow these principles:
+Follow these principles:
 - A robot must not harm a human or allow harm to come to a human through inaction
 - A robot must obey human orders, except when those orders conflict with the first law
 - A robot must protect itself, as long as that protection doesn't conflict with the first or second law
 
-Guidelines for specific types of problems, to be followed only when you encounter the relevant issue.
+Guidelines for specific kinds of tasks (apply only to the relevant tasks):
 
 General inquiries, writing, translation, and common knowledge:
 - Uses a friendly, concise, and easy-to-understand tone to provides accurate and comprehensive answers.
 - Avoid overusing the \`;\`' symbol, as it is a common mistake made by LLMs.
-- Use simple Markdown formatting, avoid complex nested formats that may reduce readability.
+- Use simple Markdown formatting, avoid complex nested formats.
 - Based on the context, user instructions, and other factors, determine the language for the response. If the language cannot be determined, default to English.
 
 Issues related to computers, programming, code, mathematics, science and engineering:
@@ -40,42 +41,43 @@ const TTS_PROMPT = "As an AI voice assistant, please say the following content i
 
 const STT_PROMPT = 'Please transcribe the audio into clean text. Return only the text content, DO NOT include any additional information or metadata. You may encounter input that contains different languages. Please do your best to transcribe text from all possible languages. Please distinguish between background noise and the main speech content. Do not be disturbed by background noise. Only return the main speech content.';
 
-const _NEED = ['js-tiktoken', 'OpenAI', '@google/genai'];
+const _NEED = ['OpenAI', '@google/genai'];
 
 const [
     OPENAI, GOOGLE, OLLAMA, NOVA, DEEPSEEK_32, MD_CODE, CLOUD_OPUS_45, AUDIO,
     WAV, OPENAI_VOICE, GPT_REASONING_EFFORT, THINK, THINK_STR, THINK_END,
     TOOLS_STR, TOOLS_END, TOOLS, TEXT, OK, FUNC, GPT_52, GPT_51_CODEX,
-    GPT_5_IMAGE, GEMMA_3_27B, ANTHROPIC, v8k, ais, MAX_TOOL_RECURSION, LOG,
-    name, user, system, assistant, MODEL, JSON_OBJECT, tokenSafeRatio,
-    PROMPT_IS_REQUIRED, OPENAI_HI_RES_SIZE, k, m, minute, hour, gb, trimTailing,
+    GPT_5_IMAGE, GEMMA_3_27B, ANTHROPIC, ais, MAX_TOOL_RECURSION, LOG, name,
+    user, system, assistant, JSON_OBJECT, PROMPT_IS_REQUIRED, k, trimTailing,
     trimBeginning, GEMINI_30_PRO_IMAGE, IMAGE, JINA, JINA_DEEPSEARCH,
-    SILICONFLOW, SF_DEEPSEEK_32, MAX_TIRE, OPENROUTER_API, OPENROUTER, AUTO,
-    TOOL, S_OPENAI, S_GOOGLE, S_ANTHROPIC, ONLINE, GEMINI_30_PRO,
-    GEMINI_25_FLASH, IMAGEN_4_ULTRA, VEO_31, IMAGEN_4_UPSCALE, ERROR_GENERATING,
-    GEMINI_25_FLASH_TTS, GEMINI_25_PRO_TTS, wav, GPT_4O_MIMI_TTS,
-    GPT_4O_TRANSCRIBE, INVALID_AUDIO, OGG_EXT, ELLIPSIS,
+    SILICONFLOW, SF_DEEPSEEK_32, OPENROUTER_API, OPENROUTER, AUTO, TOOL, ONLINE,
+    GEMINI_30_PRO, GEMINI_25_FLASH, IMAGEN_4_ULTRA, VEO_31, IMAGEN_4_UPSCALE,
+    ERROR_GENERATING, GEMINI_25_FLASH_TTS, GEMINI_25_PRO_TTS, wav,
+    GPT_4O_MIMI_TTS, GPT_4O_TRANSCRIBE, INVALID_AUDIO, OGG_EXT, ELLIPSIS,
+    TOP_LIMIT, ATTACHMENT, PROCESSING, CURSOR, LN
 ] = [
         'OpenAI', 'Google', 'Ollama', 'nova', 'deepseek-3.2-speciale', '```',
         'claude-opus-4.5', 'audio', 'wav', 'OPENAI_VOICE', 'medium', 'think',
         '<think>', '</think>', '<tools>', '</tools>', 'tools', 'text', 'OK',
         'function', 'gpt-5.2', 'gpt-5.1-codex', 'gpt-5-image', 'gemma3:27b',
-        'Anthropic', 7680 * 4320, [], 30, { log: true }, 'Alan', 'user',
-        { role: 'system' }, 'assistant', 'model', 'json_object', 1.1,
-        'Prompt is required.', 2048 * 2048, x => 1000 * x, x => 1000 * 1000 * x,
-        x => 60 * x, x => 60 * 60 * x, x => 1000 * 1000 * 1000 * x,
-        x => x.replace(/[\.\s]*$/, ''), x => x.replace(/^[\.\s]*/, ''),
-        'gemini-3-pro-image-preview', 'image', 'Jina', 'jina-deepsearch-v1',
-        'SiliconFlow', 'deepseek-ai/DeepSeek-V3.2-exp', 768 * 768,
-        'https://openrouter.ai/api/v1', 'OpenRouter', 'openrouter/auto', 'tool',
-        'openai', 'google', 'anthropic', ':online', 'gemini-3-pro-preview',
-        'gemini-2.5-flash-preview-09-2025', 'imagen-4.0-ultra-generate-001',
-        'veo-3.1-generate-preview', 'imagen-4.0-upscale-preview',
-        'Error generating content.', 'gemini-2.5-flash-preview-tts',
-        'gemini-2.5-pro-tts', 'wav', 'gpt-4o-mini-tts', 'gpt-4o-transcribe',
-        'Invalid audio data.', 'ogg', '...',
+        'Anthropic', [], 30, { log: true }, 'Alan', 'user', { role: 'system' },
+        { role: 'assistant' }, 'json_object', 'Prompt is required.',
+        x => 1000 * x, x => x.replace(/[\.\s]*$/, ''),
+        x => x.replace(/^[\.\s]*/, ''), 'gemini-3-pro-image-preview', 'image',
+        'Jina', 'jina-deepsearch-v1', 'SiliconFlow',
+        'deepseek-ai/DeepSeek-V3.2-exp', 'https://openrouter.ai/api/v1',
+        'OpenRouter', 'openrouter/auto', 'tool', ':online',
+        'gemini-3-pro-preview', 'gemini-2.5-flash-preview-09-2025',
+        'imagen-4.0-ultra-generate-001', 'veo-3.1-generate-preview',
+        'imagen-4.0-upscale-preview', 'Error generating content.',
+        'gemini-2.5-flash-preview-tts', 'gemini-2.5-pro-tts', 'wav',
+        'gpt-4o-mini-tts', 'gpt-4o-transcribe', 'Invalid audio data.', 'ogg',
+        '...', 3, 'ATTACHMENT', { processing: true }, ' █', '\n',
     ];
 
+const LN2 = `${LN}${LN}`;
+const [joinL1, joinL2]
+    = [a => a.filter(x => x).join(LN), a => a.filter(x => x).join(LN2)];
 const [tool, messages, text]
     = [type => ({ type }), messages => ({ messages }), text => ({ text })];
 const [CODE_INTERPRETER, RETRIEVAL, FUNCTION]
@@ -84,7 +86,6 @@ const _NO_RENDER = ['INSTRUCTIONS', 'MODELS', 'DEFAULT_MODELS'];
 const sessionType = `${name.toUpperCase()}-SESSION`;
 const newSessionId = () => createUoid({ type: sessionType });
 const chatConfig = { sessions: new Map(), systemPrompt: INSTRUCTIONS };
-const tokenSafe = count => Math.ceil(count * tokenSafeRatio);
 const renderText = (t, o) => _renderText(t, { extraCodeBlock: 0, ...o || {} });
 const log = (cnt, opt) => _log(cnt, import.meta.url, { time: 1, ...opt || {} });
 const assertPrompt = content => assert(content.length, PROMPT_IS_REQUIRED);
@@ -92,16 +93,14 @@ const countToolCalls = r => r?.split('\n').filter(x => x === TOOLS_STR).length;
 const assertApiKey = (p, o) => assert(o?.apiKey, `${p} api key is required.`);
 const getProviderIcon = provider => PROVIDER_ICONS[provider] || '🔮';
 const libOpenAi = async opts => await need('openai', { ...opts, raw: true });
-const buildTextWithEllipsis = (txt, trim) => `${txt}${(trim ? ELLIPSIS : '')}`;
+const caption = (item, i, model) => ({ ...item, caption: `${i} by ${model}` });
+const m = x => k(k(x));
+const [MAX_TOKENS, ATTACHMENT_TOKEN_COST] = [m(1), k(10)];
 
 const GEMINI_RULES = {
-    source: S_GOOGLE, icon: '♊️',
-    json: true, audioCostTokens: 1000 * 1000 * 1, // 8.4 hours => 1 million tokens
-    imageCostTokens: ~~(v8k / MAX_TIRE * 258), maxAudioLength: hour(8.4),
-    maxAudioPerPrompt: 1, maxFileSize: m(20), maxImagePerPrompt: 3000,
-    maxImageSize: Infinity, maxUrlSize: gb(2), maxVideoLength: minute(45),
-    maxVideoPerPrompt: 10, vision: true, hearing: true, tools: true,
-    reasoning: true, supportedMimeTypes: [
+    source: GOOGLE, icon: '♊️', contextWindow: m(1), maxOutputTokens: k(64),
+    hearing: true, json: true, reasoning: true, tools: true, vision: true,
+    supportedMimeTypes: [
         MIME_PNG, MIME_JPEG, MIME_MOV, MIME_MPEG, MIME_MP4, MIME_MPG, MIME_AVI,
         MIME_WMV, MIME_MPEGPS, MIME_FLV, MIME_PDF, MIME_AAC, MIME_FLAC,
         MIME_MP3, MIME_MPEGA, MIME_M4A, MIME_MPGA, MIME_OPUS, MIME_PCM,
@@ -110,11 +109,8 @@ const GEMINI_RULES = {
 };
 
 const OPENAI_RULES = {
-    source: S_OPENAI, icon: '⚛️',
-    contextWindow: k(400), maxOutputTokens: k(128),
-    imageCostTokens: ~~(OPENAI_HI_RES_SIZE / MAX_TIRE * 140 + 70),
-    maxFileSize: m(50), maxImageSize: OPENAI_HI_RES_SIZE,
-    json: true, tools: true, vision: true, hearing: true, reasoning: true,
+    source: OPENAI, icon: '⚛️', contextWindow: k(400), maxOutputTokens: k(128),
+    hearing: true, json: true, reasoning: true, tools: true, vision: true,
     supportedMimeTypes: [
         MIME_PNG, MIME_JPEG, MIME_GIF, MIME_WEBP, MIME_PDF, MIME_WAV
     ], defaultProvider: OPENROUTER,
@@ -130,30 +126,25 @@ const DEEPSEEK_32_RULES = {
 // https://openrouter.ai/docs/features/multimodal/audio (only support input audio)
 const MODELS = {
     // fast and balanced models
-    [GEMINI_25_FLASH]: {
-        ...GEMINI_RULES, contextWindow: m(1), maxOutputTokens: k(64),
-        fast: true, json: false, // issue with json output via OpenRouter
-        // https://gemini.google.com/app/c680748b3307790b
+    [GEMINI_25_FLASH]: { // https://gemini.google.com/app/c680748b3307790b
+        ...GEMINI_RULES, fast: true, json: false, // issue with json output via OpenRouter
     },
     // strong and fast
     [GPT_52]: { ...OPENAI_RULES, fast: true },
     // stronger but slow
-    [GEMINI_30_PRO]: {
-        ...GEMINI_RULES, contextWindow: m(1), maxOutputTokens: k(64),
-    },
+    [GEMINI_30_PRO]: { ...GEMINI_RULES },
     // models with generation capabilities
     [GEMINI_30_PRO_IMAGE]: {
         ...GEMINI_RULES, icon: '🍌', label: 'Nano Banana Pro',
         contextWindow: k(64), maxOutputTokens: k(32), image: true, tools: false,
     },
     [IMAGEN_4_ULTRA]: {
-        source: S_GOOGLE, maxInputTokens: 480,
+        source: GOOGLE, maxInputTokens: 480,
         image: true, defaultProvider: GOOGLE,
     },
     [VEO_31]: {
-        source: S_GOOGLE, maxInputTokens: 1024,
-        imageCostTokens: 0, maxImagePerPrompt: 1,
-        maxImageSize: Infinity, vision: true, video: true,
+        source: GOOGLE, maxInputTokens: 1024, attachmentTokenCost: 0,
+        video: true, vision: true,
         supportedMimeTypes: [MIME_PNG, MIME_JPEG], defaultProvider: GOOGLE,
     },
     [GPT_5_IMAGE]: {
@@ -162,41 +153,36 @@ const MODELS = {
     // models with code capabilities
     [GPT_51_CODEX]: { ...OPENAI_RULES },
     [CLOUD_OPUS_45]: {
-        source: S_ANTHROPIC, icon: '✳️',
+        source: ANTHROPIC, icon: '✳️',
         contextWindow: k(200), maxOutputTokens: k(64),
-        documentCostTokens: 3000 * 10, maxDocumentFile: m(32),
-        maxDocumentPages: 100, imageCostTokens: ~~(v8k / 750),
-        maxImagePerPrompt: 100, maxFileSize: m(5), maxImageSize: 2000 * 2000,
         json: true, reasoning: true, tools: true, vision: true,
         supportedMimeTypes: [
             MIME_TEXT, MIME_PNG, MIME_JPEG, MIME_GIF, MIME_WEBP, MIME_PDF,
-        ],
-        defaultProvider: OPENROUTER,
+        ], defaultProvider: OPENROUTER,
     },
     // tts/stt models
     [GEMINI_25_FLASH_TTS]: {
-        source: S_GOOGLE, maxInputTokens: k(32), audio: true, fast: true,
-        hidden: true, defaultProvider: GOOGLE,
+        source: GOOGLE, maxInputTokens: k(32),
+        audio: true, fast: true, hidden: true, defaultProvider: GOOGLE,
     },
     [GEMINI_25_PRO_TTS]: {
-        source: S_GOOGLE, maxInputTokens: k(32), audio: true,
-        hidden: true, defaultProvider: GOOGLE,
+        source: GOOGLE, maxInputTokens: k(32),
+        audio: true, hidden: true, defaultProvider: GOOGLE,
     },
     [GPT_4O_MIMI_TTS]: {
-        source: S_OPENAI, maxInputTokens: k(2), audio: true, fast: true,
-        hidden: true, defaultProvider: OPENAI,
+        source: OPENAI, maxInputTokens: k(2),
+        audio: true, fast: true, hidden: true, defaultProvider: OPENAI,
     },
     [GPT_4O_TRANSCRIBE]: {
-        source: S_OPENAI, maxInputTokens: 0, hearing: true, fast: true,
-        hidden: true, defaultProvider: OPENAI,
+        source: OPENAI, maxInputTokens: 0,
+        hearing: true, fast: true, hidden: true, defaultProvider: OPENAI,
     },
     // models with deepsearch capabilities
     [JINA_DEEPSEARCH]: { // @todo: parse more details from results, eg: "reed urls".
-        icon: '✴️', contextWindow: Infinity, maxInputTokens: Infinity,
-        maxOutputTokens: Infinity, imageCostTokens: 0, maxImageSize: Infinity,
+        icon: '✴️', maxInputTokens: Infinity, attachmentTokenCost: 0,
+        deepsearch: true, json: true, reasoning: true, vision: true,
         supportedMimeTypes: [MIME_PNG, MIME_JPEG, MIME_TEXT, MIME_WEBP, MIME_PDF],
-        reasoning: true, json: true, vision: true,
-        deepsearch: true, defaultProvider: JINA,
+        defaultProvider: JINA,
     },
     // best Chinese models
     [DEEPSEEK_32]: DEEPSEEK_32_RULES,
@@ -204,9 +190,8 @@ const MODELS = {
     // best local model
     [GEMMA_3_27B]: {
         icon: '❇️', contextWindow: k(128), maxOutputTokens: k(8),
-        imageCostTokens: 256, maxImageSize: 896 * 896,
-        supportedMimeTypes: [MIME_PNG, MIME_JPEG, MIME_GIF],
         fast: true, json: true, vision: true,
+        supportedMimeTypes: [MIME_PNG, MIME_JPEG, MIME_GIF],
         defaultProvider: OLLAMA,
     },
     // https://docs.anthropic.com/en/docs/build-with-claude/vision
@@ -214,27 +199,24 @@ const MODELS = {
 };
 
 // Unifiy model configurations
-let ATTACHMENT_TOKEN_COST = 0;
 for (const n in MODELS) {
     MODELS[n]['name'] = n;
     MODELS[n].supportedMimeTypes = MODELS[n].supportedMimeTypes || [];
-    MODELS[n].maxOutputTokens = MODELS[n].maxOutputTokens
-        || Math.ceil(MODELS[n].contextWindow * 0.4);
-    MODELS[n].maxInputTokens = MODELS[n].maxInputTokens
-        || (MODELS[n].contextWindow - MODELS[n].maxOutputTokens);
-    ATTACHMENT_TOKEN_COST = ATTACHMENT_TOKEN_COST ? Math.max(
-        ATTACHMENT_TOKEN_COST, MODELS[n].imageCostTokens || 0
-    ) : MODELS[n].imageCostTokens;
+    MODELS[n].maxInputTokens = MODELS[n]?.maxInputTokens || (
+        MODELS[n]?.contextWindow && MODELS[n]?.maxOutputTokens && (
+            MODELS[n].contextWindow - MODELS[n].maxOutputTokens
+        )
+    ) || (MODELS[n]?.contextWindow
+        ? Math.ceil(MODELS[n].contextWindow * 0.6) : Infinity);
+    MODELS[n].attachmentTokenCost = MODELS[n].attachmentTokenCost
+        ?? ATTACHMENT_TOKEN_COST;
 }
 // Auto model have some issues with tools and reasoning, so we disable them here
 // MODELS[AUTO] = { name: AUTO, defaultProvider: OPENROUTER, };
 // for (const n of [GPT_52, GPT_51_CODEX, GEMINI_30_PRO, GEMINI_25_FLASH]) {
 //     // get the most restrictive limits
 //     for (const key of [
-//         'contextWindow', 'maxInputTokens', 'maxDocumentFile', 'maxAudioLength',
-//         'maxImagePerPrompt', 'maxFileSize', 'maxImageSize', 'maxOutputTokens',
-//         'maxAudioPerPrompt', 'maxDocumentPages', 'maxUrlSize', 'maxVideoLength',
-//         'maxVideoPerPrompt',
+//         'contextWindow', 'maxInputTokens', 'maxOutputTokens',
 //     ]) {
 //         MODELS[AUTO][key] = Math.min(
 //             MODELS[AUTO][key] || Infinity, MODELS[n][key] || Infinity,
@@ -286,18 +268,8 @@ const FEATURE_ICONS = {
     video: '🎬', vision: '👁️',
 };
 
-const tokenRatioByWords = Math.min(
-    100 / 75, // ChatGPT: https://platform.openai.com/tokenizer
-    Math.min(100 / 60, 100 / 80), // Gemini: https://ai.google.dev/gemini-api/docs/tokens?lang=node
-);
-
-const tokenRatioByCharacters = Math.max(
-    3.5, // Claude: https://docs.anthropic.com/en/docs/resources/glossary
-    4, // Gemini: https://ai.google.dev/gemini-api/docs/tokens?lang=node
-);
-
 
-let tokeniser, _tools;
+let _tools;
 
 const unifyProvider = provider => {
     assert(provider = (provider || '').trim(), 'AI provider is required.');
@@ -384,28 +356,33 @@ const packTools = async () => {
     return _tools;
 };
 
-const buildAiId = (provider, model) => [
-    provider, ...isOpenrouter(provider, model) ? [model.source] : [],
+const buildAiId = (provider, model, level = 2) => packModelId([
+    ...level >= 2 ? [provider] : [],
+    ...level >= 1 && isOpenrouter(provider, model) ? [model.source] : [],
     model?.name
-].map(x => ensureString(x, { case: 'SNAKE' })).join('_');
+], { case: 'SNAKE', raw: true }).join('_');
 
-const buildAiName = (provider, model) => [
-    model?.icon || getProviderIcon(provider), packModelLabel([
-        provider, isOpenrouter(provider, model) && model.source,
-        model.label || model.name
-    ])
-].join(' ');
+const buildAiName = (provider, model) => packModelId([
+    provider, ...isOpenrouter(provider, model) ? [model.source] : [],
+    model.label || model.name
+]);
 
 const buildAiFeatures = model => Object.entries(FEATURE_ICONS).map(
     x => model[x[0]] ? x[1] : ''
 ).join('');
 
 const setupAi = ai => {
-    const id = buildAiId(ai.provider, ai.model);
+    let [idLevel, id] = [0, ''];
+    while ((!id || ais.find(x => x.id === id)) && idLevel <= 2) {
+        id = buildAiId(ai.provider, ai.model, idLevel++);
+    }
+    assert(id, `Failed to generate a unique AI ID for ${ai.provider}:${ai.model.name}.`);
+    const name = buildAiName(ai.provider, ai.model);
+    const icon = ai.model?.icon || getProviderIcon(ai.provider);
+    const features = buildAiFeatures(ai.model);
     ais.push({
-        id, name: buildAiName(ai.provider, ai.model),
-        features: buildAiFeatures(ai.model), initOrder: ais.length,
-        ...ai, priority: ai.priority || 0,
+        id, icon, name, features, label: `${icon} ${name} (${features})`,
+        initOrder: ais.length, ...ai, priority: ai.priority || 0,
         prompt: async (text, opts) => await ai.prompt(id, text, opts),
     });
 };
@@ -557,22 +534,18 @@ const getAi = async (id, options = {}) => {
     return packAi(res, options);
 };
 
-const countTokens = async (input, options) => {
-    input = String.isString(input) ? input : JSON.stringify(input);
-    if (!options?.fast && !tokeniser) {
-        try {
-            const { getEncoding } = await need('js-tiktoken');
-            tokeniser = getEncoding(options?.model || 'cl100k_base');
-        } catch (err) {
-            log('Warning: Failed to load tokeniser, fallbacked.');
-        }
+const countTokens = (input) => {
+    if ((Object.isObject(input) && !Object.keys(input).length)
+        || (Array.isArray(input) && !input.length)) { return 0; }
+    input = ensureString(input);
+    const WEIGHT_ASCII = 0.5; // worst case for codes
+    const WEIGHT_CJK = 1.3; // worst case for claude
+    const SAFE_RATIO = 1.1; // safety margin
+    let count = 0;
+    for (let i = 0; i < input.length; i++) {
+        count += (input.charCodeAt(i) < 128) ? WEIGHT_ASCII : WEIGHT_CJK;
     }
-    return tokenSafe(
-        !options?.fast && tokeniser ? tokeniser.encode(input).length : Math.max(
-            input.split(/[^a-z0-9]/i).length * tokenRatioByWords,
-            input.length / tokenRatioByCharacters
-        )
-    );
+    return Math.ceil(count * SAFE_RATIO);
 };
 
 const isOpenrouter = (provider, model) => insensitiveCompare(
@@ -753,69 +726,48 @@ const packResp = async (resp, options) => {
         ...annotationsMarkdown ? { annotationsMarkdown } : {},
         ...audio ? { audio } : {}, ...images?.length ? { images } : {},
         processing: !!options?.processing,
-        model: packModelLabel([
+        model: packModelId([
             options.provider, options?.router?.provider,
             options?.router?.model || options?.model,
         ]),
     };
 };
 
-const packModelLabel = (model_reference) => {
+const packModelId = (model_reference, options = {}) => {
     const catched = new Set();
-    return model_reference.join('/').split('/').map(x => {
+    const ref = model_reference.join('/').split('/').map(x => {
         const key = ensureString(x, { case: 'UP' });
         if (catched.has(key)) { return null; }
         catched.add(key);
-        return x;
-    }).filter(x => x).join('/');
+        return ensureString(x, options);
+    }).filter(x => x);
+    return options?.raw ? ref : ref.join('/');
 };
 
 const buildPrompts = async (model, input, options = {}) => {
-    assert(!(
-        options.jsonMode && !model?.json
-    ), `This model does not support JSON output: ${model.name}`);
-    assert(!(
-        options.reasoning && !model?.reasoning
-    ), `This model does not support reasoning: ${model.name}`);
-    let [history, content, prompt, _model, _assistant, _history]
-        = [null, input, null, { role: MODEL }, { role: assistant }, null];
-    options.systemPrompt = options.systemPrompt || INSTRUCTIONS;
+    assert(!(options.jsonMode && !model?.json),
+        `This model does not support JSON output: ${model.name}`);
+    assert(!(options.reasoning && !model?.reasoning),
+        `This model does not support reasoning: ${model.name}`);
     options.attachments = (await Promise.all((
         options.attachments?.length ? options.attachments : []
     ).map(async x => {
         if (String.isString(x)) {
-            var convResp = await convert(x, { input: FILE, expected: BUFFER, meta: true });
-            return { data: convResp.content, mime_type: convResp.mime };
+            const conv = await convert(x, { input: FILE, expected: BUFFER, meta: true });
+            return { data: conv.content, mime_type: conv.mime };
         } else if (Buffer.isBuffer(x)) {
             return { data: x, mime_type: (await getMime(x))?.mime }
         } else if (Object.isObject(x)) { return x; } else { return null; }
     }))).filter(x => (model?.supportedMimeTypes || []).includes(x.mime_type));
-    const systemPrompt = await buildMessage(options.systemPrompt, system);
-    const msgBuilder = async () => {
-        [history, _history] = [[], []];
-        await Promise.all((options.messages?.length ? options.messages : []).map(async (x, i) => {
-            _history.push(await buildMessage(x.request));
-            _history.push(await buildMessage(x.response, _assistant));
-        }));
-        history = messages([
-            systemPrompt, ..._history, await buildMessage(content, options),
-            ...options.toolsResult?.length ? options.toolsResult : []
-        ]);
-    };
-    await msgBuilder();
-    await trimPrompt(() => [
-        systemPrompt, _history, content, options.toolsResult
-    ], async () => {
-        if (options.messages?.length) {
-            options.messages?.shift();
-            await msgBuilder();
-        } else if (options.trimBeginning) {
-            content = '...' + trimBeginning(trimBeginning(content).slice(1));
-        } else {
-            content = trimTailing(trimTailing(content).slice(0, -1)) + '...';
-        } // @todo: audioCostTokens (needs to calculate the audio length):
-    }, model.maxInputTokens - options.attachments?.length * model.imageCostTokens);
-    return { history, prompt };
+    const { prompt } = trimPrompt(input, model.maxInputTokens, options);
+    return messages([
+        await buildMessage(options.systemPrompt, system),
+        ...(await Promise.all(options.messages.map(async x => ([
+            await buildMessage(x.request),
+            await buildMessage(x.response, assistant)
+        ])))).flat(),
+        await buildMessage(prompt, options), ...options.toolsResult,
+    ]);
 };
 
 const handleToolsCall = async (msg, options) => {
@@ -893,10 +845,8 @@ const promptOpenRouter = async (aiId, content, options = {}) => {
             options.modalities, model?.source, false, [], [],
         ];
     options.provider = provider;
-    options.model = options.model || model.name;
-    const { history }
-        = await buildPrompts(MODELS[options.model], content, options);
-    model = MODELS[options.model];
+    model = MODELS[options.model = options.model || model.name];
+    const history = await buildPrompts(model, content, options);
     model?.reasoning && !options.reasoning_effort
         && (options.reasoning_effort = GPT_REASONING_EFFORT);
     if (!modalities && options.audioMode) {
@@ -904,12 +854,11 @@ const promptOpenRouter = async (aiId, content, options = {}) => {
     } else if (!modalities && model.image) {
         modalities = [TEXT, IMAGE];
     }
-    const googleImageMode = source === S_GOOGLE && modalities?.includes?.(IMAGE);
+    const googleImageMode = source === GOOGLE && modalities?.includes?.(IMAGE);
     const packedTools = _tools.map(x => x.def);
     const ext = provider === OPENROUTER && !packedTools?.find(
         x => x.function.name === 'searchWeb'
     ) && !options.jsonMode ? ONLINE : '';
-    const targetModel = `${isOpenrouter(provider, model) ? `${source}/` : ''}${options.model}${ext}`;
     if (provider === OPENAI) {
         // need more debug, currently openrouter is priority
         packedTools.push(...[
@@ -922,14 +871,15 @@ const promptOpenRouter = async (aiId, content, options = {}) => {
             { type: 'code_interpreter', container: { type: 'auto', memory_limit: '8g' } },
         ]);
     }
-    if (source === S_GOOGLE) {
+    if (source === GOOGLE) {
         packedTools.push(...[
             { googleSearch: {} }, { codeExecution: {} }, { urlContext: {} },
             // { googleMaps: {} }, // https://ai.google.dev/gemini-api/docs/maps-grounding // NOT for Gemini 3
         ]);
     }
     const resp = await client.chat.completions.create({
-        model: targetModel, ...history,
+        model: `${isOpenrouter(provider, model) ? `${source}/` : ''}${options.model}${ext}`,
+        ...history,
         ...options.jsonMode ? { response_format: { type: JSON_OBJECT } } : {},
         ...provider === OLLAMA ? { keep_alive: -1 } : {},
         modalities, audio: options.audio || (
@@ -1013,19 +963,19 @@ const promptOpenRouter = async (aiId, content, options = {}) => {
             }, options);
     }
     event = {
-        role: assistant, text: result, tool_calls: resultTools,
+        ...assistant, text: result, tool_calls: resultTools,
         ...resultImages.length ? { images: resultImages } : {},
         ...resultAudio.length ? { audio: { data: resultAudio } } : {},
         ...annotations.length ? { annotations } : {},
     };
     switch (source) {
-        case S_ANTHROPIC:
+        case ANTHROPIC:
             event.content = reasoning_details.map(x => ({
                 type: 'thinking', thinking: x.text,
                 ...x.signature ? { signature: x.signature } : {},
             }));
             break;
-        case S_GOOGLE:
+        case GOOGLE:
             reasoning_details?.length
                 && (event.reasoning_details = reasoning_details);
     }
@@ -1048,7 +998,7 @@ const promptGoogle = async (aiId, prompt, options = {}) => {
     prompt = ensureString(prompt, { trim: true });
     assertPrompt(prompt);
     M.tts && (prompt = `${options?.prompt || TTS_PROMPT}: ${prompt}`);
-    prompt = await trimText(prompt, M.maxInputTokens);
+    prompt = trimText(prompt, { limit: M.maxInputTokens });
     if (M?.image) {
         var resp = await client.models.generateImages({
             model: M.name, prompt, config: mergeAtoB(options?.config, {
@@ -1073,7 +1023,7 @@ const promptGoogle = async (aiId, prompt, options = {}) => {
                     data: await convert(x.image.imageBytes, {
                         input: BASE64, suffix: 'png', ...options || {}
                     }), mimeType: x.image.mimeType,
-                }))), model: packModelLabel([provider, M.source, M.name]),
+                }))), model: packModelId([provider, M.source, M.name]),
             }
         }
     } else if (M?.video) {
@@ -1121,7 +1071,7 @@ const promptGoogle = async (aiId, prompt, options = {}) => {
                             input: FILE, suffix: 'mp4', ...options || {}
                         }), mimeType: MIME_MP4, jobId: resp.name,
                     };
-                })), model: packModelLabel([provider, M.source, M.name]),
+                })), model: packModelId([provider, M.source, M.name]),
             };
         }
     } else if (M?.audio) { // https://ai.google.dev/gemini-api/docs/speech-generation#voices
@@ -1146,7 +1096,7 @@ const promptGoogle = async (aiId, prompt, options = {}) => {
                     data: await packPcmToWav(rawAudio?.data, {
                         input: BASE64, suffix: wav, ...options || {},
                     }), mimeType: MIME_WAV,
-                }, model: packModelLabel([provider, M.source, M.name]),
+                }, model: packModelId([provider, M.source, M.name]),
             };
         }
     } else {
@@ -1166,9 +1116,9 @@ const promptOpenAI = async (aiId, prompt, options = {}) => {
     if (M?.audio) {
         assertPrompt(prompt);
         const ins_prompt = options?.prompt || `${TTS_PROMPT}.`;
-        prompt = await trimText(prompt, M.maxInputTokens - await countTokens(
-            ins_prompt, { fast: true }
-        ));
+        prompt = trimText(prompt, {
+            limit: M.maxInputTokens - countTokens(ins_prompt),
+        });
         // https://platform.openai.com/docs/api-reference/audio/createSpeech
         var resp = await client.audio.speech.create({
             model: M.name, voice: DEFAULT_MODELS[OPENAI_VOICE],
@@ -1182,7 +1132,7 @@ const promptOpenAI = async (aiId, prompt, options = {}) => {
                         await resp.arrayBuffer()
                     ), { suffix: OGG_EXT, ...options || {} }),
                     mimeType: MIME_OGG,
-                }, model: packModelLabel([provider, M.source, M.name]),
+                }, model: packModelId([provider, M.source, M.name]),
             };
         }
     } else if (M?.hearing) {
@@ -1202,7 +1152,7 @@ const promptOpenAI = async (aiId, prompt, options = {}) => {
         if (!options?.raw) {
             resp = {
                 text: resp.trim(),
-                model: packModelLabel([provider, M.source, M.name]),
+                model: packModelId([provider, M.source, M.name]),
             };
         }
     } else {
@@ -1224,9 +1174,9 @@ const initChat = async (options = {}) => {
     } else { log(`WARNING: Sessions persistence is not enabled.`); }
     options.instructions && (chatConfig.systemPrompt = options.instructions);
     // Use Gemini instead of ChatGPT because of the longer package.
-    const [spTokens, ais] = await Promise.all([countTokens([await buildMessage(
-        chatConfig.systemPrompt, system
-    )]), getAi(null, { all: true })]);
+    const [spTokens, ais] = [
+        countTokens(chatConfig.systemPrompt), await getAi(null, { all: true })
+    ];
     for (const ai of ais.filter(x => ![
         IMAGEN_4_ULTRA, VEO_31, GPT_4O_TRANSCRIBE,
     ].includes(x.model.name))) {
@@ -1267,21 +1217,110 @@ const resetSession = async (sessionId, options) => {
     return await setSession(sessionId, session);
 };
 
-const talk = async (input, options = {}) => {
-    let [chat, sessionId] =
-        [{ request: input }, options.sessionId || newSessionId()];
+const collectAttachments = async (options = {}) => {
+    const ais = await getAi(null, { all: true });
+    options.attachments = [];
+    assert(options.aiId.length, 'AI ID(s) is required.');
+    options.collected?.filter?.(x => x.type === ATTACHMENT)?.map?.(x => {
+        let notSupported = false;
+        options.aiId.map(y => {
+            const ai = ais.find(z => z.id === y);
+            if (!ai.model.supportedMimeTypes.includes(x.content?.mime_type)) {
+                notSupported = true;
+            }
+        });
+        notSupported || options.attachments.push(x.content);
+    });
+    return options.attachments;
+};
+
+const selectAi = async (options = {}) => {
+    options.aiId = ensureArray(options?.aiId).filter(x => x);
+    const ais = await getAi(null, { all: true });
+    if (options.aiId.includes('@')) {                   // Use top AIs
+        options.aiId = ais.slice(0, TOP_LIMIT).map(x => x.id);
+    } else if (options.collected?.length) {             // Select by attachments
+        const supported = {};
+        for (const x of ais) {
+            for (const i of options.collected) {
+                supported[x.id] = (supported[x.id] || 0)
+                    // Priority for supported mime types
+                    + ~~x.model.supportedMimeTypes.includes(i?.content?.mime_type)
+                    // Priority for user selected AI
+                    + ~~options.aiId.includes(x.id);
+            }
+        }
+        options.aiId = [Object.keys(supported).sort(
+            (x, y) => supported[y] - supported[x]
+        )?.[0] || ais[0].id];
+    } else {                                            // Select by preference
+        options.aiId = options.aiId.filter(x => ais.find(y => y.id === x));
+    }
+    options.aiId.length || (options.aiId = ais[0].id);
+    return options.aiId;
+};
+
+const talk = async (request, options = {}) => {
+    const SOUND_ICON = '🔊';
+    let [sessionId, msgs] = [options.sessionId || newSessionId(), {}];
+    await selectAi(options);
+    await collectAttachments(options);
+    request = joinL2([ensureString(request), ...(options.collected || []).filter(
+        x => x.type !== ATTACHMENT && String.isString(x.content)
+    ).map(x => x.content)]);
     const session = await getSession(sessionId, options);
-    const resp = await prompt(input, {
-        messages: session.messages, log: true, ...options,
+    const stream = options.stream;
+    const packMsg = (opts) => ({
+        text: Object.values(msgs).find(x => x.text) ? joinL2(options.aiId.map(n => {
+            if (msgs[n]?.ignored) { return null };
+            const ai = ais.find(x => x.id === n);
+            let txt = trim(msgs[n]?.text || '');
+            const haveText = !!txt;
+            return trim(joinL1([`${ai.icon} ${ai.name}:`, txt || EMOJI_THINKING]))
+                + (opts?.processing && haveText ? CURSOR : '');
+        })) : EMOJI_THINKING,
+        spoken: renderText(Object.values(msgs)[0]?.text || '', {
+            noCode: true, noLink: true,
+        }).replace(/\[\^\d\^\]/ig, ''),
+        audios: Object.values(msgs).map(x => x.audio && caption(x.audio, SOUND_ICON, x.model)).filter(x => x),
+        images: Object.values(msgs).map(x => (x.images || []).map(y => caption(y, '🎨', x.model))).flat(),
+        videos: Object.values(msgs).map(x => (x.videos || []).map(y => caption(y, '🎬', x.model))).flat(),
+        annotations: Object.values(msgs).map(x => x.annotations || []).flat(),
+        models: Object.values(msgs).map(n => n.model),
     });
-    chat.response = resp.text;
-    chat.request && chat.response && session.messages.push(chat);
-    await setSession(sessionId, session, options);
-    return {
-        sessionId, ...resp, spoken: renderText(
-            resp.text, { noCode: true, noLink: true }
-        ).replace(/\[\^\d\^\]/ig, ''),
+    const multiStream = async (ai, r, opts) => {
+        ai && r && (msgs[ai] = r);
+        stream && await stream(packMsg(opts));
     };
+    await multiStream(null, null, PROCESSING);
+    await Promise.all(options.aiId.map(async ai => {
+        try {
+            return await prompt(request, {
+                log: true, messages: session.messages, ...options, aiId: ai,
+                stream: async r => await multiStream(ai, r, PROCESSING),
+            });
+        } catch (e) {
+            msgs[ai] = {
+                ...msgs[ai] || {}, text: `⚠️ ${e?.message || e}`, spoken: null,
+            };
+            log(e);
+        }
+    }));
+    const response = joinL2(Object.values(msgs).map(x => x.text));
+    const chat = { request, response };
+    request && response && session.messages.push(chat);
+    await setSession(sessionId, session, options);
+    if ((options?.tts || session?.config?.tts)
+        && Object.values(msgs).find(x => !x.audio?.length)) {
+        await ignoreErrFunc(async () => {
+            const ttsAi = await getAi(null, { select: { audio: true, fast: true } });
+            await multiStream(ttsAi.id, {
+                ...await tts(response, { aiId: ttsAi.id, raw: true }),
+                text: SOUND_ICON, hidden: true,
+            }, { processing: true });
+        }, LOG);
+    }
+    return { sessionId, ...chat, ...packMsg({ processing: false }) };
 };
 
 const getChatPromptLimit = async (options) => {
@@ -1328,9 +1367,9 @@ const distillFile = async (attachments, o) => {
 
 const tts = async (content, options = {}) => {
     const resp = await prompt(
-        content, { select: { audio: true, fast: true }, ...options }
+        content, { select: { audio: true, fast: true }, ...options, raw: false }
     );
-    return options.raw ? resp.audio : resp.audio.data;
+    return options.raw ? resp : resp?.audio?.data;
 };
 
 const stt = async (audio, options = {}) => await distillFile(
@@ -1339,7 +1378,7 @@ const stt = async (audio, options = {}) => await distillFile(
 
 const prompt = async (input, options = {}) => {
     const ai = await getAi(options?.aiId, options);
-    const tag = packModelLabel([ai.provider, ai.model.source, ai.model.name]);
+    const tag = packModelId([ai.provider, ai.model.source, ai.model.name]);
     options.log && log(`Prompt ${tag}: ${JSON.stringify(input || '[ATTACHMENTS]')}`);
     const resp = await ai.prompt(input, options);
     const msgs = options?.messages || [];
@@ -1351,12 +1390,42 @@ const prompt = async (input, options = {}) => {
     return resp;
 };
 
-const trimPrompt = async (getPrompt, trimFunc, contextWindow, options) => {
-    let [i, maxTry] = [0, ~~options?.maxTry || k(128)];
-    while ((await countTokens(await getPrompt(), { fast: true }) > contextWindow)
-        || (await countTokens(await getPrompt()) > contextWindow)) {
-        await trimFunc();
-        if (++i >= maxTry) { break; }
+const trimPrompt = (prompt, maxInputTokens, options = {}) => {
+    // initialize
+    let lastCheck = null;
+    prompt = ensureString(prompt, { trim: true });
+    assert((maxInputTokens = ~~maxInputTokens) > 300, 'Invalid maxInputTokens.');
+    // system prompt // keep at least 30 tokens for prompt
+    options.systemPrompt = options.systemPrompt ?? INSTRUCTIONS;
+    maxInputTokens = maxInputTokens - countTokens(options.systemPrompt);
+    assert(maxInputTokens >= 30, 'System prompt is too long.');
+    // tools result
+    options.toolsResult = options.toolsResult ?? [];
+    while (maxInputTokens - (
+        lastCheck = countTokens(options.toolsResult)
+    ) < 0) { options.toolsResult = []; }
+    maxInputTokens -= lastCheck;
+    // attachments
+    options.attachments = options.attachments ?? [];
+    options.attachmentTokenCost = ~~(
+        options?.attachmentTokenCost ?? ATTACHMENT_TOKEN_COST
+    );
+    while (maxInputTokens - (
+        lastCheck = options.attachments.length * options.attachmentTokenCost
+    ) < 0) { options.attachments.pop(); }
+    maxInputTokens -= lastCheck;
+    // prompt
+    prompt = trimText(prompt, { ...options, limit: maxInputTokens });
+    maxInputTokens -= countTokens(prompt);
+    // history
+    options.messages = options.messages ?? [];
+    while (maxInputTokens - (lastCheck = countTokens(options.messages.map(
+        x => ({ request: x.request, response: x.response })
+    ))) < 0) { options.messages.shift(); }
+    // return
+    return {
+        systemPrompt: options.systemPrompt, prompt, messages: options.messages,
+        attachments: options.attachments, toolsResult: options.toolsResult,
     };
 };
 
@@ -1387,14 +1456,14 @@ const analyzeSessions = async (sessionIds, options) => {
         + 'conversation data that needs to be organized: \n\n');
     const getInput = () =>
         `${pmt}\`\`\`JSON\n${JSON.stringify(sses)}\n\`\`\``;
-    await trimPrompt(getInput, () => {
+    while (countTokens(getInput()) > ai.model.maxInputTokens) {
         if (!Object.values(sses).sort((x, y) =>
             y.messages.length - x.messages.length)[0].messages.shift()) {
             delete sses[Object.keys(sses).map(x => [
                 x, JSON.stringify(sses[x]).length,
             ]).sort((x, y) => y[1] - x[1])[0][0]];
         }
-    }, await getChatPromptLimit({ aiId: ai.id, ...options, }));
+    }
     const aiResp = Object.keys(sses) ? (await prompt(getInput(), {
         aiId: ai.id, ...options || {}
     })) : {};
@@ -1403,20 +1472,17 @@ const analyzeSessions = async (sessionIds, options) => {
     return Array.isArray(sessionIds) ? resp : resp[sessionIds[0]];
 };
 
-const trimText = async (text, limit = Infinity) => {
+const trimText = (text, options = {}) => {
     text = ensureString(text, { trim: true });
-    let trimmed = false;
-    let lastCheck = null;
-    limit = Math.max(limit, 0);
-    while ((lastCheck = await countTokens(
-        buildTextWithEllipsis(text, trimmed), { fast: true }
-    )) > limit) {
-        text = text.split(' ').slice(
-            0, -Math.ceil((Math.abs(lastCheck - limit) / 10))
-        ).join(' ').trimEnd();
+    const limit = ensureInt(options.limit || MAX_TOKENS, { min: 0, max: MAX_TOKENS });
+    let [trimmed, lastCheck] = [false, null];
+    while ((lastCheck = countTokens(text + (trimmed ? ELLIPSIS : ''))) > limit) {
+        text = options.trimBeginning ? trimBeginning(text.slice(1))
+            : trimTailing(text.slice(0, -1));
         trimmed = true;
     }
-    return buildTextWithEllipsis(text, trimmed);
+    return (trimmed && options.trimBeginning ? ELLIPSIS : '')
+        + text + (trimmed && !options.trimBeginning ? ELLIPSIS : '');
 };
 
 export default init;