utilitas 1999.1.7 → 1999.1.9

package/lib/alan.mjs

@@ -45,36 +45,6 @@ const _NEED = [
     'js-tiktoken', 'OpenAI',
 ];
 
-const [
-    OPENAI, GEMINI, OPENAI_EMBEDDING, GEMINI_EMEDDING, OPENAI_TRAINING, OLLAMA,
-    GPT_4O_MINI, GPT_4O, GPT_O1, GPT_O3_MINI, GEMINI_20_FLASH,
-    GEMINI_20_FLASH_THINKING, GEMINI_20_PRO, NOVA, DEEPSEEK_R1, DEEPSEEK_R1_70B,
-    DEEPSEEK_R1_32B, MD_CODE, TEXT_EMBEDDING_3_SMALL, TEXT_EMBEDDING_3_LARGE,
-    CLOUD_37_SONNET, AUDIO, WAV, ATTACHMENTS, CHAT, OPENAI_VOICE, MEDIUM, LOW,
-    HIGH, GPT_REASONING_EFFORT, THINK, THINK_STR, THINK_END, AZURE, TOOLS_STR,
-    TOOLS_END, TOOLS, TEXT, THINKING, OK, FUNC, GPT_45, REDACTED_THINKING,
-    GEMMA_3_27B, AZURE_OPENAI, ANTHROPIC, VERTEX_ANTHROPIC, GEMMA327B, size8k,
-    ais, MAX_TOOL_RECURSION, LOG, name, user, system, assistant, MODEL,
-    JSON_OBJECT, TOOL, silent, GEMINI_EMBEDDING_M, INVALID_FILE, tokenSafeRatio,
-    GPT_QUERY_LIMIT, minsOfDay, CONTENT_IS_REQUIRED,
-] = [
-        'OpenAI', 'Gemini', 'OPENAI_EMBEDDING', 'GEMINI_EMEDDING',
-        'OPENAI_TRAINING', 'Ollama', 'gpt-4o-mini', 'gpt-4o', 'o1', 'o3-mini',
-        'gemini-2.0-flash', 'gemini-2.0-flash-thinking-exp',
-        'gemini-2.0-pro-exp', 'nova', 'deepseek-r1', 'deepseek-r1:70b',
-        'deepseek-r1:32b', '```', 'text-embedding-3-small',
-        'text-embedding-3-large', 'claude-3-7-sonnet@20250219', 'audio', 'wav',
-        '[ATTACHMENTS]', 'CHAT', 'OPENAI_VOICE', 'medium', 'low', 'high',
-        'medium', 'think', '<think>', '</think>', 'AZURE', '<tools>',
-        '</tools>', 'tools', 'text', 'thinking', 'OK', 'function',
-        'gpt-4.5-preview', 'redacted_thinking', 'gemma-3-27b-it',
-        'Azure Openai', 'Anthropic', 'Vertex Anthropic', 'gemma3:27b',
-        7680 * 4320, [], 10, { log: true }, 'Alan', 'user', 'system',
-        'assistant', 'model', 'json_object', 'tool', true,
-        'gemini-embedding-exp-03-07', 'Invalid file data.', 1.1, 100, 60 * 24,
-        'Content is required.',
-    ];
-
 const [
     png, jpeg, mov, mpeg, mp4, mpg, avi, wmv, mpegps, flv, gif, webp, pdf, aac,
     flac, mp3, m4a, mpga, opus, pcm, wav, webm, tgpp, mimeJson, mimeText, pcm16,
@@ -88,6 +58,39 @@ const [
         'text/plain', 'audio/x-wav', 'audio/ogg',
     ];
 
+const [
+    OPENAI, GEMINI, OPENAI_EMBEDDING, GEMINI_EMEDDING, OPENAI_TRAINING, OLLAMA,
+    GPT_4O_MINI, GPT_4O, GPT_O1, GPT_O3_MINI, GEMINI_20_FLASH,
+    GEMINI_20_FLASH_THINKING, GEMINI_20_PRO, NOVA, DEEPSEEK_R1, MD_CODE,
+    TEXT_EMBEDDING_3_SMALL, TEXT_EMBEDDING_3_LARGE, CLOUD_37_SONNET, AUDIO, WAV,
+    ATTACHMENTS, CHAT, OPENAI_VOICE, MEDIUM, LOW, HIGH, GPT_REASONING_EFFORT,
+    THINK, THINK_STR, THINK_END, AZURE, TOOLS_STR, TOOLS_END, TOOLS, TEXT,
+    THINKING, OK, FUNC, GPT_45, REDACTED_THINKING, GEMMA_3_27B, AZURE_OPENAI,
+    ANTHROPIC, VERTEX_ANTHROPIC, GEMMA327B, v8k, ais, MAX_TOOL_RECURSION, LOG,
+    name, user, system, assistant, MODEL, JSON_OBJECT, TOOL, silent,
+    GEMINI_EMBEDDING_M, INVALID_FILE, tokenSafeRatio, GPT_QUERY_LIMIT,
+    CONTENT_IS_REQUIRED, OPENAI_HI_RES_SIZE, k, kT, m, minute, hour,
+    gb, trimTailing, EBD, GEMINI_20_FLASH_EXP, IMAGE
+] = [
+        'OpenAI', 'Gemini', 'OPENAI_EMBEDDING', 'GEMINI_EMEDDING',
+        'OPENAI_TRAINING', 'Ollama', 'gpt-4o-mini', 'gpt-4o', 'o1', 'o3-mini',
+        'gemini-2.0-flash', 'gemini-2.0-flash-thinking-exp',
+        'gemini-2.0-pro-exp', 'nova', 'deepseek-r1', '```',
+        'text-embedding-3-small', 'text-embedding-3-large',
+        'claude-3-7-sonnet@20250219', 'audio', 'wav', '[ATTACHMENTS]', 'CHAT',
+        'OPENAI_VOICE', 'medium', 'low', 'high', 'medium', 'think', '<think>',
+        '</think>', 'AZURE', '<tools>', '</tools>', 'tools', 'text', 'thinking',
+        'OK', 'function', 'gpt-4.5-preview', 'redacted_thinking',
+        'gemma-3-27b-it', 'Azure Openai', 'Anthropic', 'Vertex Anthropic',
+        'gemma3:27b', 7680 * 4320, [], 10, { log: true }, 'Alan', 'user',
+        'system', 'assistant', 'model', 'json_object', 'tool', true,
+        'gemini-embedding-exp-03-07', 'Invalid file data.', 1.1, 100,
+        'Content is required.', 2000 * 768, x => 1024 * x, x => 1000 * x,
+        x => 1024 * 1024 * x, x => 60 * x, x => 60 * 60 * x,
+        x => 1024 * 1024 * 1024 * x, x => x.replace(/[\.\s]*$/, ''),
+        { embedding: true }, 'gemini-2.0-flash-exp', 'image',
+    ];
+
 const [tool, messages, text]
     = [type => ({ type }), messages => ({ messages }), text => ({ text })];
 const [CODE_INTERPRETER, RETRIEVAL, FUNCTION]
@@ -98,7 +101,6 @@ const [newSessionId, newAiId]
     = [sessionType, aiType].map(type => () => createUoid({ type }));
 const chatConfig = { sessions: new Map(), systemPrompt: INSTRUCTIONS };
 const tokenSafe = count => Math.ceil(count * tokenSafeRatio);
-const trimTailing = text => text.replace(/[\.\s]*$/, '');
 const renderText = (t, o) => _renderText(t, { extraCodeBlock: 0, ...o || {} });
 const log = (cnt, opt) => _log(cnt, import.meta.url, { time: 1, ...opt || {} });
 const assertContent = content => assert(content.length, CONTENT_IS_REQUIRED);
@@ -107,267 +109,129 @@ const assertApiKey = (p, o) => assert(o?.apiKey, `${p} api key is required.`);
 const libOpenAi = async opts => await need('openai', { ...opts, raw: true });
 const OpenAI = async opts => new (await libOpenAi(opts)).OpenAI(opts);
 const AzureOpenAI = async opts => new (await libOpenAi(opts)).AzureOpenAI(opts);
-
-const DEFAULT_MODELS = {
-    [OPENAI]: GPT_4O,
-    [AZURE_OPENAI]: GPT_4O,
-    [GEMINI]: GEMINI_20_FLASH,
-    [ANTHROPIC]: CLOUD_37_SONNET,
-    [VERTEX_ANTHROPIC]: CLOUD_37_SONNET,
-    [OLLAMA]: GEMMA327B,
-    [OPENAI_VOICE]: NOVA,
-    [OPENAI_EMBEDDING]: TEXT_EMBEDDING_3_SMALL,
-    [GEMINI_EMEDDING]: GEMINI_EMBEDDING_M,
-    [OPENAI_TRAINING]: GPT_4O_MINI, // https://platform.openai.com/docs/guides/fine-tuning
+const OPENAI_S1 = { contextWindow: kT(128), maxOutputTokens: k(16) };
+const OPENAI_S2 = { contextWindow: kT(200), maxOutputTokens: kT(100) };
+const OPENAI_EBD = { ...EBD, maxInputTokens: k(8) - 1 };
+const OPENAI_AUDIO_TYPES = { supportedAudioTypes: [wav] };
+const GPT_4O_AUDIO = { ...OPENAI_AUDIO_TYPES, audio: 'gpt-4o-audio-preview' };
+
+const OPENAI_RULES = {
+    imageCostTokens: ~~(OPENAI_HI_RES_SIZE / (512 * 512) * 170 + 85),
+    maxFileSize: m(20), maxImageSize: OPENAI_HI_RES_SIZE,
+    supportedMimeTypes: [png, jpeg, gif, webp],
+    json: true, tools: true, vision: true,
 };
 
-DEFAULT_MODELS[CHAT] = DEFAULT_MODELS[GEMINI];
-
-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
-);
+const GEMINI_RULES = {
+    audioCostTokens: 1000 * 1000 * 1, // 8.4 hours => 1 million tokens
+    imageCostTokens: ~~(v8k / (768 * 768) * 258), maxAudioLength: hour(8.4),
+    maxAudioPerPrompt: 1, maxFileSize: m(20), maxImagePerPrompt: 3000,
+    maxImageSize: Infinity, maxUrlSize: gb(2), maxVideoLength: minute(45),
+    maxVideoPerPrompt: 10, vision: true, supportedMimeTypes: [
+        png, jpeg, mov, mpeg, mp4, mpg, avi, wmv, mpegps, flv, pdf, aac,
+        flac, mp3, m4a, mpga, opus, pcm, wav, webm, tgpp,
+    ],
+};
 
-// https://platform.openai.com/docs/models/continuous-model-upgrades
-// https://platform.openai.com/settings/organization/limits // Tier 3
-// https://cloud.google.com/vertex-ai/docs/generative-ai/model-reference/gemini
+// https://platform.openai.com/docs/models
 // https://cloud.google.com/vertex-ai/docs/generative-ai/learn/models
 const MODELS = {
+    [GPT_4O]: { ...OPENAI_S1, ...OPENAI_RULES, ...GPT_4O_AUDIO },
+    [GPT_45]: { ...OPENAI_S1, ...OPENAI_RULES, ...GPT_4O_AUDIO },
     [GPT_4O_MINI]: {
-        contextWindow: 128000,
-        imageCostTokens: 1105,
-        maxOutputTokens: 16384,
-        requestLimitsRPM: 10000,
-        tokenLimitsTPD: 1000000000,
-        tokenLimitsTPM: 10000000,
-        audio: 'gpt-4o-mini-audio-preview',
-        fast: true,
-        json: true,
-        tools: true,
-        vision: true,
-        supportedMimeTypes: [png, jpeg, gif, webp],
-        supportedAudioTypes: [wav],
-        trainingData: 'Oct 2023',
-    },
-    [GPT_4O]: {
-        contextWindow: 128000,
-        imageCostTokens: 1105,
-        maxOutputTokens: 16384,
-        requestLimitsRPM: 10000,
-        tokenLimitsTPD: 20000000,
-        tokenLimitsTPM: 2000000,
-        audio: 'gpt-4o-audio-preview',
-        json: true,
-        tools: true,
-        vision: true,
-        supportedMimeTypes: [png, jpeg, gif, webp],
-        supportedAudioTypes: [wav],
-        trainingData: 'Oct 2023',
+        ...OPENAI_S1, ...OPENAI_RULES, ...OPENAI_AUDIO_TYPES,
+        audio: 'gpt-4o-mini-audio-preview', fast: true,
     },
     [GPT_O1]: {
-        contextWindow: 200000,
-        imageCostTokens: 1105,
-        maxOutputTokens: 100000,
-        requestLimitsRPM: 10000,
-        tokenLimitsTPD: 200000000,
-        tokenLimitsTPM: 2000000,
-        json: true,
+        ...OPENAI_S2, ...OPENAI_RULES, ...GPT_4O_AUDIO,
         reasoning: true,
-        tools: true,
-        vision: true,
-        supportedMimeTypes: [
-            png, jpeg, gif, webp,
-        ],
-        trainingData: 'Oct 2023',
     },
     [GPT_O3_MINI]: {
-        contextWindow: 200000,
-        imageCostTokens: 1105,
-        maxOutputTokens: 100000,
-        requestLimitsRPM: 10000,
-        tokenLimitsTPD: 1000000000,
-        tokenLimitsTPM: 10000000,
-        fast: true,
-        json: true,
-        reasoning: true,
-        tools: true,
-        vision: true,
-        supportedMimeTypes: [png, jpeg, gif, webp],
-        trainingData: 'Oct 2023',
-    },
-    [GPT_45]: {
-        contextWindow: 128000,
-        imageCostTokens: 1105,
-        maxOutputTokens: 16384,
-        requestLimitsRPM: 10000,
-        tokenLimitsTPD: 100000000,
-        tokenLimitsTPM: 1000000,
-        json: true,
-        tools: true,
-        vision: true,
-        supportedMimeTypes: [png, jpeg, gif, webp],
-        trainingData: 'Oct 2023',
+        ...OPENAI_S2, ...OPENAI_RULES, ...GPT_4O_AUDIO,
+        fast: true, reasoning: true,
     },
     [GEMINI_20_FLASH]: {
-        // https://ai.google.dev/gemini-api/docs/models/gemini
-        // https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/send-multimodal-prompts?hl=en#gemini-send-multimodal-samples-pdf-nodejs
-        // Audio / Video Comming Soon: https://ai.google.dev/gemini-api/docs/models/gemini#gemini-2.0-flash
-        audioCostTokens: 1000000, // 8.4 hours => 1 million tokens
-        contextWindow: 1048576,
-        imageCostTokens: size8k / (768 * 768) * 258,
-        maxAudioLength: 60 * 60 * 8.4, // 9.5 hours
-        maxAudioPerPrompt: 1,
-        maxFileSize: 20 * 1024 * 1024, // 20 MB
-        maxImagePerPrompt: 3000,
-        maxImageSize: Infinity,
-        maxOutputTokens: 1024 * 8,
-        maxUrlSize: 1024 * 1024 * 1024 * 2, // 2 GB
-        maxVideoLength: 60 * 50, // 50 minutes
-        maxVideoLengthWithAudio: 60 * 50, // 50 minutes
-        maxVideoLengthWithoutAudio: 60 * 60, // 1 hour
-        maxVideoPerPrompt: 10,
-        requestLimitsRPD: 1500,
-        requestLimitsRPM: 2000,
-        tokenLimitsTPM: 4 * 1000000,
-        fast: true,
-        json: true,
-        tools: true,
-        vision: true,
-        supportedMimeTypes: [
-            png, jpeg, mov, mpeg, mp4, mpg, avi, wmv, mpegps, flv, pdf, aac,
-            flac, mp3, m4a, mpga, opus, pcm, wav, webm, tgpp,
-        ],
-        trainingData: 'August 2024',
+        ...GEMINI_RULES, contextWindow: m(1), maxOutputTokens: k(8),
+        fast: true, json: true, tools: true,
     },
     [GEMINI_20_FLASH_THINKING]: {
-        // https://cloud.google.com/vertex-ai/generative-ai/docs/thinking-mode?hl=en
-        contextWindow: 1024 * (8 + 32),
-        imageCostTokens: size8k / (768 * 768) * 258,
-        maxFileSize: 20 * 1024 * 1024, // 20 MB
-        maxImagePerPrompt: 3000,
-        maxImageSize: Infinity,
-        maxOutputTokens: 1024 * 8,
-        maxUrlSize: 1024 * 1024 * 1024 * 2, // 2 GB
-        requestLimitsRPM: 1000,
-        requestLimitsRPD: 1500,
-        tokenLimitsTPM: 4 * 1000000,
+        ...GEMINI_RULES, contextWindow: m(1), maxOutputTokens: k(64),
         reasoning: true,
-        vision: true,
-        supportedMimeTypes: [png, jpeg],
-        trainingData: 'August 2024',
     },
     [GEMINI_20_PRO]: {
-        contextWindow: 2097152,
-        imageCostTokens: size8k / (768 * 768) * 258,
-        maxFileSize: 20 * 1024 * 1024, // 20 MB
-        maxImagePerPrompt: 3000,
-        maxImageSize: Infinity,
-        maxOutputTokens: 1024 * 8,
-        maxUrlSize: 1024 * 1024 * 1024 * 2, // 2 GB
-        requestLimitsRPM: 1000,
-        requestLimitsRPD: 1500,
-        tokenLimitsTPM: 4 * 1000000,
+        ...GEMINI_RULES, contextWindow: m(2), maxOutputTokens: k(8),
         json: true,
-        vision: true,
-        supportedMimeTypes: [
-            png, jpeg, mov, mpeg, mp4, mpg, avi, wmv, mpegps, flv, pdf, aac,
-            flac, mp3, m4a, mpga, opus, pcm, wav, webm, tgpp,
-        ],
-        trainingData: 'August 2024',
     },
     [GEMMA_3_27B]: {
-        contextWindow: 128 * 1000,
-        imageCostTokens: 256,
-        maxImageSize: 896 * 896,
-        maxOutputTokens: 1024 * 8,
-        fast: true,
-        json: true,
-        vision: true,
-        supportedMimeTypes: [png, jpeg],
+        contextWindow: kT(128), maxOutputTokens: k(8),
+        imageCostTokens: 256, maxImageSize: 896 * 896,
+        supportedMimeTypes: [png, jpeg, gif],
+        fast: true, json: true, vision: true,
     },
     [DEEPSEEK_R1]: {
-        contextWindow: 128 * 1000,
-        maxOutputTokens: 32768,
-        requestLimitsRPM: Infinity,
-        tokenLimitsTPM: Infinity,
+        contextWindow: kT(128), maxOutputTokens: k(32),
         reasoning: true,
-    },
-    [TEXT_EMBEDDING_3_SMALL]: {
-        contextWindow: 8191,
-        embedding: true,
-        outputDimension: 1536,
-        requestLimitsRPM: 500,
-        tokenLimitsTPM: 1000000,
-        trainingData: 'Sep 2021',
-    },
-    [TEXT_EMBEDDING_3_LARGE]: {
-        contextWindow: 8191,
-        embedding: true,
-        outputDimension: 3072, // ERROR: column cannot have more than 2000 dimensions for hnsw index
-        requestLimitsRPM: 500,
-        tokenLimitsTPM: 1000000,
-        trainingData: 'Sep 2021',
-    },
-    [GEMINI_EMBEDDING_M]: {
-        contextWindow: 1024 * 8,
-        outputDimension: 1024 * 3, // ERROR: column cannot have more than 2000 dimensions for hnsw index
-        embedding: true,
-    },
-    // https://console.cloud.google.com/vertex-ai/publishers/anthropic/model-garden/claude-3-7-sonnet?authuser=5&inv=1&invt=Abqftg&project=backend-alpha-97077
-    [CLOUD_37_SONNET]: {
-        contextWindow: 200 * 1000,
-        maxOutputTokens: 64 * 1000, // Should be 128 * 1000, but Anthropic SDK limits it to 64 * 1000
-        imageCostTokens: size8k / 750,
-        documentCostTokens: 3000 * 100, // 100 pages: https://docs.anthropic.com/en/docs/build-with-claude/pdf-support
-        maxImagePerPrompt: 5, // https://docs.anthropic.com/en/docs/build-with-claude/vision
-        maxImageSize: 1092, // by pixels
-        maxDocumentPages: 100,
-        maxDocumentFile: 1024 * 1024 * 32, // 32MB
-        requestLimitsRPM: 50,
-        tokenLimitsITPM: 40000,
-        tokenLimitsOTPM: 8000,
-        json: true,
-        reasoning: true,
-        tools: true,
-        vision: true,
+    }, // ERROR: column cannot have more than 2000 dimensions for hnsw index
+    [TEXT_EMBEDDING_3_LARGE]: { ...OPENAI_EBD, dimension: k(3) },
+    [TEXT_EMBEDDING_3_SMALL]: { ...OPENAI_EBD, dimension: k(1.5) },
+    [GEMINI_EMBEDDING_M]: { ...EBD, maxInputTokens: k(8), dimension: k(3) },
+    [CLOUD_37_SONNET]: { // 100 pages: https://docs.anthropic.com/en/docs/build-with-claude/pdf-support
+        contextWindow: kT(200), maxOutputTokens: kT(64),
+        documentCostTokens: 3000 * 100, maxDocumentFile: m(32),
+        maxDocumentPages: 100, imageCostTokens: ~~(v8k / 750),
+        maxImagePerPrompt: 100, maxImageSize: 2000 * 2000,
         supportedMimeTypes: [png, jpeg, gif, webp, pdf],
-        trainingData: 'Apr 2024',
-    },
-};
+        json: true, reasoning: true, tools: true, vision: true,
+    }, // https://docs.anthropic.com/en/docs/build-with-claude/vision
 
-MODELS[DEEPSEEK_R1_70B] = MODELS[DEEPSEEK_R1];
-MODELS[DEEPSEEK_R1_32B] = MODELS[DEEPSEEK_R1];
-MODELS[GEMMA327B] = MODELS[GEMMA_3_27B];
+};
 
+// Unifiy model configurations
+let ATTACHMENT_TOKEN_COST = 0;
 for (const n in MODELS) {
     MODELS[n]['name'] = n;
-    if (MODELS[n].embedding) {
-        MODELS[n].maxInputTokens = MODELS[n].contextWindow;
-    } else {
+    if (!MODELS[n].embedding) {
         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);
-        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].maxInputTokens,
-            MODELS[n].requestLimitsRPM, MODELS[n].requestLimitsRPD / minsOfDay
-        ));
+        ATTACHMENT_TOKEN_COST = ATTACHMENT_TOKEN_COST ? Math.max(
+            ATTACHMENT_TOKEN_COST, MODELS[n].imageCostTokens || 0
+        ) : MODELS[n].imageCostTokens;
     }
 }
+MODELS[GEMMA327B] = MODELS[GEMMA_3_27B]; // Ollama Alias
+MODELS[GEMINI_20_FLASH].image = GEMINI_20_FLASH_EXP;
+MODELS[GEMINI_20_FLASH_EXP] = {
+    ...MODELS[GEMINI_20_FLASH],
+    name: GEMINI_20_FLASH_EXP, image: true, tools: false,
+};
+
+// Default models for each provider
+const DEFAULT_MODELS = {
+    [OPENAI]: GPT_4O,
+    [AZURE_OPENAI]: GPT_4O,
+    [GEMINI]: GEMINI_20_FLASH,
+    [ANTHROPIC]: CLOUD_37_SONNET,
+    [VERTEX_ANTHROPIC]: CLOUD_37_SONNET,
+    [OLLAMA]: GEMMA327B,
+    [OPENAI_VOICE]: NOVA,
+    [OPENAI_EMBEDDING]: TEXT_EMBEDDING_3_SMALL,
+    [GEMINI_EMEDDING]: GEMINI_EMBEDDING_M,
+    [OPENAI_TRAINING]: GPT_4O_MINI, // https://platform.openai.com/docs/guides/fine-tuning
+};
+DEFAULT_MODELS[CHAT] = DEFAULT_MODELS[GEMINI];
+
+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 MAX_INPUT_TOKENS = MODELS[GPT_4O_MINI].maxInputTokens;
-const ATTACHMENT_TOKEN_COST = Math.max(MODELS[GPT_4O].imageCostTokens, 5000);
-const MAX_TRIM_TRY = MAX_INPUT_TOKENS / 1000;
+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;
@@ -629,7 +493,7 @@ const buildGptMessage = (content, options) => {
     const attachments = (options?.attachments || []).map(x => {
         assert(MODELS[options?.model], 'Model is required.');
         if (MODELS[options.model]?.supportedMimeTypes?.includes?.(x.mime_type)) {
-            return { type: 'image_url', image_url: { url: x.url } };
+            return { type: 'image_url', image_url: { url: x.url, detail: 'high' } };
         } else if (MODELS[options.model]?.supportedAudioTypes?.includes?.(x.mime_type)) {
             alterModel = selectGptAudioModel(options);
             return {
@@ -719,12 +583,15 @@ const getInfoEnd = text => Math.max(...[THINK_END, TOOLS_END].map(x => {
 // @todo: escape ``` in think and tools
 const packResp = async (resp, options) => {
     if (options?.raw) { return resp; }
-    let [txt, audio, references, simpleText, referencesMarkdown, end, json] = [
-        resp.text || '',                                                        // ChatGPT / Claude / Gemini / Ollama
-        resp?.audio?.data,                                                      // ChatGPT audio mode
-        resp?.references,                                                       // Gemini references
-        '', '', '', null,
-    ];
+    let [
+        txt, audio, references, simpleText, referencesMarkdown, end, json,
+        images
+    ] = [
+            resp.text || '',                                                    // ChatGPT / Claude / Gemini / Ollama
+            resp?.audio?.data,                                                  // ChatGPT audio mode
+            resp?.references,                                                   // Gemini references
+            '', '', '', null, resp?.images || [],
+        ];
     simpleText = txt;
     while ((end = getInfoEnd(simpleText))) {
         simpleText = simpleText.slice(end).trim();
@@ -741,9 +608,17 @@ const packResp = async (resp, options) => {
     ])) && (audio = await convert(audio, {
         input: BUFFER, expected: BUFFER, ...options || {},
     }));
+    if (images?.length) {
+        for (let i in images) {
+            images[i].data = await convert(images[i].data, {
+                input: BASE64, expected: BUFFER,
+            });
+        }
+    }
     options?.jsonMode && !options?.delta && (json = parseJson(simpleText, null));
     if (options?.simple && options?.audioMode) { return audio; }
     else if (options?.simple && options?.jsonMode) { return json; }
+    else if (options?.simple && options?.imageMode) { return images; }
     else if (options?.simple) { return simpleText; }
     else if (options?.jsonMode) { txt = `\`\`\`json\n${simpleText}\n\`\`\``; }
     // references debug codes:
@@ -796,6 +671,7 @@ const packResp = async (resp, options) => {
         ...references ? { references } : {},
         ...referencesMarkdown ? { referencesMarkdown } : {},
         ...audio ? { audio, audioMimeType: options?.audioMimeType } : {},
+        ...images?.length ? { images } : {},
         processing: !!options?.processing,
         model: options?.model,
     };
@@ -828,7 +704,10 @@ const buildPrompts = async (model, input, options = {}) => {
             prompt = buildClaudeMessage(content, { ...options, cache_control: true });
             break;
         case GEMINI:
-            const _role = { role: options.model === GEMMA_3_27B ? user : system };
+            const _role = {
+                role: [GEMINI_20_FLASH_EXP, GEMMA_3_27B].includes(options.model)
+                    ? user : system
+            };
             systemPrompt = buildGeminiHistory(options.systemPrompt, _role);
             prompt = options.toolsResult?.[options.toolsResult?.length - 1]?.parts
                 || buildGeminiMessage(content, options)
@@ -884,9 +763,10 @@ const buildPrompts = async (model, input, options = {}) => {
             msgBuilder();
         } else {
             content = trimTailing(trimTailing(content).slice(0, -1)) + '...';
-        }
-    }, model.maxInputTokens - options.attachments?.length * ATTACHMENT_TOKEN_COST);
-    if ([OPENAI].includes(options.flavor) || options.model === GEMMA_3_27B) {
+        } // @todo: audioCostTokens (needs to calculate the audio length):
+    }, model.maxInputTokens - options.attachments?.length * model.imageCostTokens);
+    if ([OPENAI].includes(options.flavor)
+        || [GEMINI_20_FLASH_EXP, GEMMA_3_27B].includes(options.model)) {
         systemPrompt = null;
     }
     return { systemPrompt, history, prompt };
@@ -1073,7 +953,7 @@ const promptAnthropic = async (aiId, content, options = {}) => {
         = await buildPrompts(model, content, { ...options, flavor: ANTHROPIC });
     const resp = await client.beta.messages.create({
         model: options.model, ...history, system, stream: true,
-        max_tokens: options.extendedThinking ? 128000 : model.maxOutputTokens,
+        max_tokens: options.extendedThinking ? kT(128) : model.maxOutputTokens,
         ...(options.reasoning ?? model.reasoning) ? {
             thinking: options.thinking || {
                 type: 'enabled',
@@ -1163,8 +1043,10 @@ const deleteFile = async (aiId, file_id, options) => {
 
 const generationConfig = options => ({
     generationConfig: {
+        responseMimeType: options.jsonMode ? mimeJson : mimeText,
+        responseModalities: options.modalities
+            || (options.imageMode ? [TEXT, IMAGE] : undefined),
         ...options?.generationConfig || {},
-        responseMimeType: options?.jsonMode ? mimeJson : mimeText,
     },
 });
 
@@ -1182,43 +1064,62 @@ const packGeminiReferences = (chunks, supports) => {
 };
 
 const promptGemini = async (aiId, content, options = {}) => {
-    const { client, model } = await getAi(aiId);
-    let [result, references, functionCalls, responded]
-        = [options.result ?? '', null, null, false];
+    let { client, model } = await getAi(aiId);
+    let [result, references, functionCalls, responded, images]
+        = [options.result ?? '', null, null, false, []];
     options.model = options.model || model.name;
+    model.image && (options.imageMode = true);
+    assert(!(options.imageMode && !model.image), 'Image mode is not supported.');
+    if (String.isString(model.image)) {
+        options.model = model.image;
+        options.imageMode = true;
+        model = MODELS[options.model];
+    }
     const { systemPrompt: systemInstruction, history, prompt }
         = await buildPrompts(model, content, { ...options, flavor: GEMINI });
     const _client = client.getGenerativeModel({
         model: options.model, systemInstruction,
-        ...model?.tools && !options.jsonMode ? (options.tools ?? {
-            tools: [
-                // @todo: Gemini will failed when using these tools together.
-                // https://ai.google.dev/gemini-api/docs/function-calling
-                // { codeExecution: {} },
-                // { googleSearch: {} },
-                { functionDeclarations: (await toolsGemini()).map(x => x.def) },
-            ],
-            toolConfig: { functionCallingConfig: { mode: 'AUTO' } },
-        }) : {},
+        ...model?.tools && !options.jsonMode
+            && options.model !== GEMINI_20_FLASH_EXP ? (options.tools ?? {
+                tools: [
+                    // @todo: Gemini will failed when using these tools together.
+                    // https://ai.google.dev/gemini-api/docs/function-calling
+                    // { codeExecution: {} },
+                    // { googleSearch: {} },
+                    {
+                        functionDeclarations: (
+                            await toolsGemini()
+                        ).map(x => x.def)
+                    },
+                ],
+                toolConfig: { functionCallingConfig: { mode: 'AUTO' } },
+            }) : {},
     });
     // https://github.com/google/generative-ai-js/blob/main/samples/node/advanced-chat.js
     // Google's bug: history is not allowed while using inline_data?
     const chat = _client.startChat({ history, ...generationConfig(options) });
     const resp = await chat.sendMessageStream(prompt);
     for await (const chunk of resp.stream) {
-        print(chunk);
+        const deltaImages = [];
+        chunk.candidates[0].content?.parts?.filter(
+            x => x?.inlineData?.mimeType === png
+        )?.map?.(x => {
+            deltaImages.push(x.inlineData);
+            images.push(x.inlineData);
+        });
         functionCalls || (functionCalls = chunk.functionCalls);
         const rfc = packGeminiReferences(
             chunk.candidates[0]?.groundingMetadata?.groundingChunks,
             chunk.candidates[0]?.groundingMetadata?.groundingSupports
         );
         rfc && (references = rfc);
-        let delta = chunk?.text?.() || '';
-        options.result && delta
-            && (responded = responded || (delta = `\n\n${delta}`));
-        result += delta;
-        delta && await streamResp({
-            text: options.delta ? delta : result,
+        let deltaText = chunk?.text?.() || '';
+        options.result && deltaText
+            && (responded = responded || (deltaText = `\n\n${deltaText}`));
+        result += deltaText;
+        (deltaText || deltaImages.length) && await streamResp({
+            text: options.delta ? deltaText : result,
+            images: options.delta ? deltaImages : images,
         }, options);
     }
     const _resp = await resp.response;
@@ -1237,7 +1138,7 @@ const promptGemini = async (aiId, content, options = {}) => {
         });
     }
     return await packResp({
-        text: mergeMsgs(toolsResponse, toolsResult), references,
+        text: mergeMsgs(toolsResponse, toolsResult), images, references,
     }, options);
 };
 
@@ -1411,7 +1312,7 @@ const talk = async (input, options = {}) => {
     };
 };
 
-const getMaxChatPromptLimit = async (options) => {
+const getChatPromptLimit = async (options) => {
     let resp = 0;
     (await getAi(null, { all: true })).map(x => {
         if (options?.aiId && options?.aiId !== x.id) { return; }
@@ -1419,7 +1320,17 @@ const getMaxChatPromptLimit = async (options) => {
         resp = resp ? Math.min(resp, maxInputTokens) : maxInputTokens;
     });
     assert(resp > 0, 'Chat engine has not been initialized.');
-    return options?.raw ? resp : Math.min(resp, MAX_INPUT_TOKENS);
+    return resp;
+};
+
+const getChatAttachmentCost = async (options) => {
+    let resp = 0;
+    (await getAi(null, { all: true })).map(x => {
+        if (options?.aiId && options?.aiId !== x.id) { return; }
+        resp = Math.max(resp, x.model.imageCostTokens || 0);
+    });
+    assert(resp > 0, 'Chat engine has not been initialized.');
+    return resp;
 };
 
 const distillFile = async (attachments, o) => {
@@ -1465,7 +1376,7 @@ const prompt = async (input, options = {}) => {
 };
 
 const trimPrompt = async (getPrompt, trimFunc, contextWindow, options) => {
-    let [i, maxTry] = [0, ~~options?.maxTry || MAX_TRIM_TRY];
+    let [i, maxTry] = [0, ~~options?.maxTry || kT(128)];
     while ((await countTokens(await getPrompt(), { fast: true }) > contextWindow)
         || (await countTokens(await getPrompt()) > contextWindow)) {
         await trimFunc();
@@ -1515,38 +1426,54 @@ const analyzeSessions = async (sessionIds, options) => {
 
 export default init;
 export {
-    ATTACHMENT_TOKEN_COST, CLOUD_37_SONNET, CODE_INTERPRETER, DEEPSEEK_R1,
-    DEEPSEEK_R1_32B, DEEPSEEK_R1_70B, DEFAULT_MODELS,
-    FUNCTION, GEMINI_20_FLASH, GEMINI_20_FLASH_THINKING,
-    GPT_45, GPT_4O, GPT_4O_MINI, GPT_O1, GPT_O3_MINI, INSTRUCTIONS, MODELS,
-    OPENAI_VOICE, RETRIEVAL,
-    TEXT_EMBEDDING_3_SMALL, _NEED, analyzeSessions,
+    _NEED,
+    CLOUD_37_SONNET,
+    CODE_INTERPRETER,
+    DEEPSEEK_R1,
+    DEFAULT_MODELS,
+    FUNCTION,
+    GEMINI_20_FLASH_THINKING,
+    GEMINI_20_FLASH,
+    GPT_45,
+    GPT_4O_MINI,
+    GPT_4O,
+    GPT_O1,
+    GPT_O3_MINI,
+    INSTRUCTIONS,
+    MODELS,
+    OPENAI_VOICE,
+    RETRIEVAL,
+    analyzeSessions,
     buildGptTrainingCase,
     buildGptTrainingCases,
     cancelGptFineTuningJob,
     countTokens,
-    createGeminiEmbedding, createGptFineTuningJob,
+    createGeminiEmbedding,
+    createGptFineTuningJob,
     createOpenAIEmbedding,
     deleteFile,
     distillFile,
+    getAi,
+    getChatAttachmentCost,
+    getChatPromptLimit,
     getGptFineTuningJob,
-    getMaxChatPromptLimit,
     getSession,
     init,
     initChat,
     jpeg,
-    getAi,
     listFiles,
     listGptFineTuningEvents,
     listGptFineTuningJobs,
     listOpenAIModels,
     ogg,
-    prompt, promptOpenAI,
+    prompt,
     promptAnthropic,
     promptGemini,
+    promptOpenAI,
     resetSession,
     tailGptFineTuningEvents,
     talk,
+    TEXT_EMBEDDING_3_SMALL,
     trimPrompt,
     uploadFile,
     uploadFileForFineTuning,