utilitas 1999.1.93 → 1999.1.95

package/lib/alan.mjs

@@ -1,16 +1,15 @@
 import { checkSearch, distill, search } from './web.mjs';
 import { create as createUoid } from './uoid.mjs';
-import { end, loop } from './event.mjs';
 import { fileTypeFromBuffer } from 'file-type';
 import { packPcmToWav } from './media.mjs';
 import { v4 as uuidv4 } from 'uuid';
 
 import {
-    BASE64, BUFFER, DATAURL, MIME_BINARY, MIME_JSON, MIME_TEXT, MIME_PNG,
-    MIME_JPEG, MIME_MOV, MIME_MPEG, MIME_MP4, MIME_MPG, MIME_AVI, MIME_WMV,
-    MIME_MPEGPS, MIME_FLV, MIME_GIF, MIME_WEBP, MIME_PDF, MIME_AAC, MIME_FLAC,
-    MIME_MP3, MIME_MPEGA, MIME_M4A, MIME_MPGA, MIME_OPUS, MIME_PCM, MIME_WAV,
-    MIME_WEBM, MIME_TGPP, MIME_PCM16, MIME_OGG, STREAM, convert, formatDataURL
+    BASE64, BUFFER, DATAURL, MIME_BINARY, MIME_TEXT, MIME_PNG, MIME_JPEG,
+    MIME_MOV, MIME_MPEG, MIME_MP4, MIME_MPG, MIME_AVI, MIME_WMV, MIME_MPEGPS,
+    MIME_FLV, MIME_GIF, MIME_WEBP, MIME_PDF, MIME_AAC, MIME_FLAC, MIME_MP3,
+    MIME_MPEGA, MIME_M4A, MIME_MPGA, MIME_OPUS, MIME_PCM, MIME_WAV, MIME_WEBM,
+    MIME_TGPP, MIME_PCM16, MIME_OGG, convert, formatDataURL, decodeBase64DataURL,
 } from './storage.mjs';
 
 import {
@@ -43,42 +42,32 @@ You may be provided with some tools(functions) to help you gather information an
 - When the tools are not suitable and you have to answer questions based on your understanding, please do not mention any tool-related information in your response.
 - Unless otherwise specified to require the original result, in most cases, you may reorganize the information obtained after using the tool to solve the problem as needed.`;
 
-const _NEED = [
-    '@anthropic-ai/sdk', '@anthropic-ai/vertex-sdk', '@google/genai',
-    'js-tiktoken', 'OpenAI',
-];
+const _NEED = ['js-tiktoken', 'OpenAI'];
 
 const [
-    OPENAI, GEMINI, OPENAI_TRAINING, OLLAMA, GEMINI_25_FLASH, NOVA,
-    DEEPSEEK_R1, MD_CODE, TEXT_EMBEDDING_3_SMALL, TEXT_EMBEDDING_3_LARGE,
-    CLOUD_SONNET_45, 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_5, GPT_5_MINI,
-    REDACTED_THINKING, GEMMA_3_27B, AZURE_OPENAI, ANTHROPIC, VERTEX_ANTHROPIC,
-    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_25_FLASH_IMAGE, IMAGE, JINA,
-    JINA_DEEPSEARCH, JINA_CLIP, VERTEX, GEMINI_25_PRO, SILICONFLOW,
-    SF_DEEPSEEK_R1, MAX_TIRE,
+    OPENAI, GEMINI, OLLAMA, GEMINI_25_FLASH, NOVA, DEEPSEEK_R1, MD_CODE,
+    CLOUD_SONNET_45, AUDIO, WAV, ATTACHMENTS, OPENAI_VOICE,
+    GPT_REASONING_EFFORT, THINK, THINK_STR, THINK_END, TOOLS_STR, TOOLS_END,
+    TOOLS, TEXT, OK, FUNC, GPT_51, GPT_51_CODEX, GEMMA_3_27B, ANTHROPIC, v8k, ais,
+    MAX_TOOL_RECURSION, LOG, name, user, system, assistant, MODEL, JSON_OBJECT,
+    tokenSafeRatio, CONTENT_IS_REQUIRED, OPENAI_HI_RES_SIZE, k, kT, m, minute,
+    hour, gb, trimTailing, GEMINI_25_FLASH_IMAGE, IMAGE, JINA, JINA_DEEPSEARCH,
+    GEMINI_25_PRO, SILICONFLOW, SF_DEEPSEEK_R1, MAX_TIRE, OPENROUTER_API,
+    OPENROUTER, AUTO, TOOL,
 ] = [
-        'OpenAI', 'Gemini', 'OPENAI_TRAINING', 'Ollama',
-        'gemini-2.5-flash-preview-09-2025', 'nova', 'deepseek-r1', '```',
-        'text-embedding-3-small', 'text-embedding-3-large',
-        'claude-sonnet-4-5@20250929', 'audio', 'wav', '[ATTACHMENTS]', 'CHAT',
-        'OPENAI_VOICE', 'medium', 'low', 'high', 'medium', 'think', '<think>',
-        '</think>', 'AZURE', '<tools>', '</tools>', 'tools', 'text', 'thinking',
-        'OK', 'function', 'gpt-5', 'gpt-5-mini', 'redacted_thinking',
-        'gemma3:27b', 'Azure Openai', 'Anthropic', 'Vertex Anthropic',
-        7680 * 4320, [], 30, { log: true }, 'Alan', 'user', 'system',
-        'assistant', 'model', 'json_object', 'tool', true,
-        'gemini-embedding-001', 'Invalid file data.', 1.1, 100,
-        'Content is required.', 2048 * 2048, 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.5-flash-image', 'image', 'Jina',
-        'jina-deepsearch-v1', 'jina-clip-v2', 'Vertex', 'gemini-2.5-pro',
-        'SiliconFlow', 'Pro/deepseek-ai/DeepSeek-R1', 768 * 768,
+        'OpenAI', 'Gemini', 'Ollama', 'gemini-2.5-flash-preview-09-2025',
+        'nova', 'deepseek-r1', '```', 'anthropic/claude-sonnet-4.5', 'audio',
+        'wav', '[ATTACHMENTS]', 'OPENAI_VOICE', 'medium', 'think', '<think>',
+        '</think>', '<tools>', '</tools>', 'tools', 'text', 'OK', 'function',
+        'gpt-5.1', 'gpt-5.1-codex', 'gemma3:27b', 'Anthropic', 7680 * 4320, [],
+        30, { log: true }, 'Alan', 'user', { role: 'system' }, 'assistant',
+        'model', 'json_object', 1.1, 'Content is required.', 2048 * 2048,
+        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]*$/, ''), 'gemini-2.5-flash-image', 'image',
+        'Jina', 'jina-deepsearch-v1', 'gemini-2.5-pro', 'SiliconFlow',
+        'Pro/deepseek-ai/DeepSeek-R1', 768 * 768,
+        'https://openrouter.ai/api/v1', 'OpenRouter', 'openrouter/auto', 'tool',
     ];
 
 const [tool, messages, text]
@@ -98,21 +87,21 @@ 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 OpenAI = async opts => new (await libOpenAi(opts)).OpenAI(opts);
-const AzureOpenAI = async opts => new (await libOpenAi(opts)).AzureOpenAI(opts);
-const OPENAI_EBD = { ...EBD, maxInputTokens: k(8) - 1 };
-
 const OPENAI_RULES = {
+    source: 'openai',
     contextWindow: kT(400), maxOutputTokens: k(128),
     imageCostTokens: ~~(OPENAI_HI_RES_SIZE / MAX_TIRE * 140 + 70),
     maxFileSize: m(50), maxImageSize: OPENAI_HI_RES_SIZE,
     supportedMimeTypes: [MIME_PNG, MIME_JPEG, MIME_GIF, MIME_WEBP],
     supportedDocTypes: [MIME_PDF],
-    supportedAudioTypes: [MIME_WAV], audio: 'gpt-4o-audio-preview',
+    supportedAudioTypes: [MIME_WAV],
+    // audio: 'gpt-4o-audio-preview',
     json: true, tools: true, vision: true,
-    reasoning: true, defaultProvider: OPENAI,
+    reasoning: true, defaultProvider: OPENROUTER,
 };
 
 const GEMINI_RULES = {
+    source: 'google',
     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,
@@ -125,7 +114,7 @@ const GEMINI_RULES = {
     ], supportedAudioTypes: [MIME_WAV, MIME_OGG, MIME_OPUS],
     // audio: 'gemini-2.5-flash-exp-native-audio-thinking-dialog',
     // gemini-2.5-flash-preview-native-audio-dialog
-    defaultProvider: GEMINI,
+    defaultProvider: OPENROUTER,
 };
 
 const DEEPSEEK_R1_RULES = {
@@ -135,9 +124,10 @@ const DEEPSEEK_R1_RULES = {
 
 // https://platform.openai.com/docs/models
 // https://cloud.google.com/vertex-ai/docs/generative-ai/learn/models
+// https://openrouter.ai/docs/features/multimodal/audio (only support input audio)
 const MODELS = {
-    [GPT_5]: { ...OPENAI_RULES, },
-    [GPT_5_MINI]: { ...OPENAI_RULES, fast: true },
+    [GPT_51]: { ...OPENAI_RULES, fast: true },
+    [GPT_51_CODEX]: { ...OPENAI_RULES },
     [GEMINI_25_FLASH_IMAGE]: {
         ...GEMINI_RULES, contextWindow: k(64), maxOutputTokens: k(32),
         fast: true, image: true,
@@ -166,12 +156,6 @@ const MODELS = {
     },
     [DEEPSEEK_R1]: DEEPSEEK_R1_RULES,
     [SF_DEEPSEEK_R1]: { ...DEEPSEEK_R1_RULES, defaultProvider: SILICONFLOW },
-    [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) },
-    [JINA_CLIP]: {
-        maxInputTokens: k(8), maxImageSize: 512 * 512, dimension: k(1),
-    },
     [CLOUD_SONNET_45]: {
         contextWindow: kT(200), maxOutputTokens: kT(64),
         documentCostTokens: 3000 * 10, maxDocumentFile: m(32),
@@ -179,7 +163,7 @@ const MODELS = {
         maxImagePerPrompt: 100, maxFileSize: m(5), maxImageSize: 2000 * 2000,
         supportedMimeTypes: [MIME_TEXT, MIME_PNG, MIME_JPEG, MIME_GIF, MIME_WEBP, MIME_PDF],
         json: true, reasoning: true, tools: true, vision: true,
-        defaultProvider: [ANTHROPIC, VERTEX_ANTHROPIC],
+        defaultProvider: OPENROUTER,
     },
     // https://docs.anthropic.com/en/docs/build-with-claude/vision
     // https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/claude/sonnet-4-5
@@ -189,43 +173,70 @@ const MODELS = {
 let ATTACHMENT_TOKEN_COST = 0;
 for (const n in MODELS) {
     MODELS[n]['name'] = n;
-    if (!MODELS[n].embedding) {
-        MODELS[n].supportedMimeTypes = MODELS[n].supportedMimeTypes || [];
-        MODELS[n].supportedDocTypes = MODELS[n].supportedDocTypes || [];
-        MODELS[n].supportedAudioTypes = MODELS[n].supportedAudioTypes || [];
-        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].supportedMimeTypes = MODELS[n].supportedMimeTypes || [];
+    MODELS[n].supportedDocTypes = MODELS[n].supportedDocTypes || [];
+    MODELS[n].supportedAudioTypes = MODELS[n].supportedAudioTypes || [];
+    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[AUTO] = { name: AUTO, defaultProvider: OPENROUTER, };
+for (const n of [GPT_51, GPT_51_CODEX, GEMINI_25_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',
+    ]) {
+        MODELS[AUTO][key] = Math.min(
+            MODELS[AUTO][key] || Infinity, MODELS[n][key] || Infinity,
+        );
+    }
+    // get the most permissive costs
+    for (const key of [
+        'documentCostTokens', 'imageCostTokens', 'audioCostTokens',
+    ]) {
+        MODELS[AUTO][key] = Math.max(
+            MODELS[AUTO][key] || 0, MODELS[n][key] || 0,
+        );
+    }
+    // combine supported types
+    for (const key of [
+        'supportedAudioTypes', 'supportedDocTypes', 'supportedMimeTypes',
+    ]) {
+        MODELS[AUTO][key] = [...new Set(
+            [...MODELS[AUTO][key] || [], ...MODELS[n][key] || []]
+        )];
+    }
+    // for other features, if any model supports it, then AUTO supports it
+    for (const key of [
+        'json', 'reasoning', 'tools', 'vision', 'fast', 'deepsearch', 'image',
+    ]) {
+        MODELS[AUTO][key] = MODELS[AUTO][key] || MODELS[n][key];
+    }
+    // catch first possible support
+    for (const key of ['audio']) {
+        MODELS[AUTO][key] = MODELS[AUTO][key] || MODELS[n][key];
+    }
+};
 
 // Default models for each provider
 const DEFAULT_MODELS = {
-    [OPENAI]: GPT_5,
+    [OPENROUTER]: AUTO,
     [SILICONFLOW]: SF_DEEPSEEK_R1,
-    [GEMINI]: GEMINI_25_PRO,
-    [ANTHROPIC]: CLOUD_SONNET_45,
-    [VERTEX_ANTHROPIC]: CLOUD_SONNET_45,
     [JINA]: JINA_DEEPSEARCH,
     [OLLAMA]: GEMMA_3_27B,
     [OPENAI_VOICE]: NOVA,
-    [OPENAI_TRAINING]: null, // https://platform.openai.com/docs/guides/fine-tuning
-};
-
-const DEFAULT_EMBEDDING = {
-    [OPENAI]: TEXT_EMBEDDING_3_SMALL,
-    [GEMINI]: GEMINI_EMBEDDING_M,
-    [JINA]: JINA_CLIP,
 };
 
 const PROVIDER_ICONS = {
-    [OPENAI]: '⚛️', [AZURE_OPENAI]: '⚛️', [AZURE]: '☁️', [JINA]: '✴️',
-    [GEMINI]: '♊️', [VERTEX]: '📖', [OLLAMA]: '🦙',
-    [ANTHROPIC]: '✳️', [VERTEX_ANTHROPIC]: '✳️', [SILICONFLOW]: '🧬',
+    [OPENROUTER]: '🔀', [OPENAI]: '⚛️', [JINA]: '✴️', [GEMINI]: '♊️',
+    [OLLAMA]: '🦙', [ANTHROPIC]: '✳️', [SILICONFLOW]: '🧬',
 };
 
 const FEATURE_ICONS = {
@@ -248,8 +259,7 @@ let tokeniser;
 
 const unifyProvider = provider => {
     assert(provider = (provider || '').trim(), 'AI provider is required.');
-    for (let type of [OPENAI, AZURE_OPENAI, AZURE, GEMINI, VERTEX, ANTHROPIC,
-        VERTEX_ANTHROPIC, JINA, OLLAMA, SILICONFLOW]) {
+    for (let type of [OPENROUTER, JINA, OLLAMA, SILICONFLOW]) {
         if (insensitiveCompare(provider, type)) { return type; }
     }
     throwError(`Invalid AI provider: ${provider}.`);
@@ -326,51 +336,37 @@ const toolsOpenAI = async () => {
     return _tools;
 };
 
-const toolsClaude = async () => (await toolsOpenAI()).map(x => ({
-    ...x, def: {
-        name: x.def.function.name,
-        description: x.def.function.description,
-        input_schema: x.def.function.parameters,
-    }
-}));
+const buildAiId = (provider, model) => [
+    provider, ...isOpenrouter(provider, model) ? [model.source] : [],
+    model?.name
+].map(x => ensureString(x, { case: 'SNAKE' })).join('_');
 
-const toolsGemini = async (options) => (await toolsOpenAI()).map(x => ({
-    ...x, def: {
-        name: x.def.function.name, description: x.def.function.description,
-        parameters: {
-            type: 'object',
-            properties: x.def.function.parameters.properties,
-            required: x.def.function.parameters.required,
-        }, ...options?.provider === 'VERTEX' ? {
-            response: x.def.function?.response ?? {
-                type: 'string', description: 'It could be a string or JSON',
-            }
-        } : {},
-    }
-}));
+const buildAiName = (provider, model) => [
+    getProviderIcon(provider), provider,
+    `(${isOpenrouter(provider, model) ? `${model.source}/` : ''}${model.name})`
+].join(' ');
 
-const buildAiId = (provider, model) => [provider, model].map(
-    x => ensureString(x, { case: 'SNAKE' })
-).join('_');
+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.name);
-    const icon = getProviderIcon(ai.provider);
-    const features = Object.entries(FEATURE_ICONS).map(
-        x => ai.model[x[0]] ? x[1] : ''
-    ).join('');
+    const id = buildAiId(ai.provider, ai.model);
     ais.push({
-        id, name: `${icon} ${ai.provider} (${ai.model.name})`,
-        features, initOrder: ais.length,
+        id, name: buildAiName(ai.provider, ai.model),
+        features: buildAiFeatures(ai.model), initOrder: ais.length,
         priority: DEFAULT_MODELS[ai.provider] === ai.model.name ? -1 : 0,
-        modelEmbedding: MODELS[DEFAULT_EMBEDDING[ai.provider]], ...ai,
-        prompt: ai.prompt && (async (c, o) => await ai.prompt(id, c, o)),
-        embedding: ai.embedding && (async (c, o) => await ai.embedding(id, c, o)),
+        ...ai, prompt: async (text, opts) => await ai.prompt(id, text, opts),
     });
 };
 
 const init = async (options = {}) => {
-    const provider = unifyProvider(options?.provider);
+    if (options?.debug) {
+        (await need('node:util')).inspect.defaultOptions.depth = null;
+        options.logLevel = 'debug';
+    }
+    options.provider = options.provider || OPENROUTER;
+    const provider = unifyProvider(options.provider);
     let models;
     if (options.model === '*') { // All models
         models = Object.values(MODELS).filter(
@@ -388,106 +384,22 @@ const init = async (options = {}) => {
     assert(models.length,
         `Model name or description is required for provider: ${provider}.`);
     switch (provider) {
-        case OPENAI:
-            assertApiKey(provider, options);
-            var client = await OpenAI(options);
-            for (let model of models) {
-                setupAi({
-                    provider, model, client,
-                    prompt: promptOpenAI, embedding: createOpenAIEmbedding,
-                });
-            }
-            break;
-        case AZURE_OPENAI:
-            assertApiKey(provider, options);
-            assert(options.endpoint,
-                `${provider} api endpoint and deployment are required.`);
-            var model = models[0];
-            var client = await AzureOpenAI({
-                apiVersion: '2025-01-01-preview',
-                deployment: model.name, ...options,
-            });
-            setupAi({ provider, model, client, prompt: promptOpenAI });
-            break;
-        case AZURE:
-            assertApiKey(provider, options);
-            assert(options.baseURL, `${provider} api endpoint is required.`);
-            var model = models[0];
-            var client = await OpenAI(options);
-            setupAi({ provider, model, client, prompt: promptOpenAI });
-            break;
-        case SILICONFLOW:
-            assertApiKey(provider, options);
-            var client = await OpenAI({ baseURL: 'https://api.siliconflow.cn/v1', ...options });
-            var model = models[0];
-            setupAi({ provider, model, client, prompt: promptOpenAI });
-            break;
-        case GEMINI:
-            assert(options.apiKey, `${provider} api key is required.`);
-            var { GoogleGenAI } = await need('@google/genai');
-            var client = new GoogleGenAI(options);
-            for (let model of models) {
-                setupAi({
-                    provider, model, client,
-                    prompt: promptGemini, embedding: createGeminiEmbedding,
-                });
-            }
-            break;
-        case VERTEX:
-            assert(options.credentials && options.project,
-                `${provider} credentials and project id are required.`);
-            process.env['GOOGLE_APPLICATION_CREDENTIALS'] = options.credentials;
-            var { GoogleGenAI } = await need('@google/genai');
-            var client = new GoogleGenAI({
-                vertexai: true, location: 'global', ...options
-            });
-            for (let model of models) {
-                setupAi({
-                    provider, model, client,
-                    prompt: promptGemini, embedding: createGeminiEmbedding,
-                });
-            }
-            break;
-        case ANTHROPIC:
-            assertApiKey(provider, options);
-            var client = new ((
-                await need('@anthropic-ai/sdk')
-            ).Anthropic)(options)
-            for (let model of models) {
-                setupAi({ provider, model, client, prompt: promptAnthropic });
-            }
-            break;
-        case VERTEX_ANTHROPIC:
-            // https://github.com/anthropics/anthropic-sdk-typescript/tree/main/packages/vertex-sdk
-            assert(options.credentials && options.projectId,
-                `${provider} credentials and project id are required.`);
-            process.env['GOOGLE_APPLICATION_CREDENTIALS'] = options.credentials;
-            process.env['ANTHROPIC_VERTEX_PROJECT_ID'] = options.projectId;
-            var model = models[0];
-            var client = new ((
-                await need('@anthropic-ai/vertex-sdk', { raw: true })
-            ).AnthropicVertex)({ region: options?.region || 'global' });
-            setupAi({ provider, model, client, prompt: promptAnthropic });
-            break;
         case JINA:
             assertApiKey(provider, options);
-            var [client, clientEmbedding] = [await OpenAI({
+            var client = await OpenAI({
                 baseURL: 'https://deepsearch.jina.ai/v1/', ...options,
-            }), await OpenAI({
-                baseURL: 'https://api.jina.ai/v1/', ...options,
-            })];
+            });
             for (let model of models) {
-                setupAi({
-                    provider, model, client, clientEmbedding,
-                    prompt: promptOpenAI, embedding: createOpenAIEmbedding,
-                });
+                setupAi({ provider, model, client, prompt: promptOpenAI });
             }
             break;
         case OLLAMA:
             // https://github.com/ollama/ollama/blob/main/docs/openai.md
             const baseURL = 'http://localhost:11434/v1/';
             const phLog = m => log(`Ollama preheat: ${m?.message || m}`);
-            var client = await OpenAI({ baseURL, apiKey: 'ollama', ...options });
+            var client = await OpenAI({
+                baseURL, apiKey: 'ollama', ...options,
+            });
             for (let model of models) {
                 setupAi({ provider, model, client, prompt: promptOpenAI });
                 ignoreErrFunc(async () => {
@@ -499,8 +411,24 @@ const init = async (options = {}) => {
                 }, { log: phLog });
             }
             break;
+        case SILICONFLOW:
+            assertApiKey(provider, options);
+            var client = await OpenAI({
+                baseURL: 'https://api.siliconflow.cn/v1', ...options,
+            });
+            for (let model of models) {
+                setupAi({ provider, model, client, prompt: promptOpenAI });
+            }
+            break;
         default:
-            throwError(`Invalid AI provider: ${options.provider || 'null'}.`);
+            assertApiKey(provider, options);
+            var client = await OpenAI({ baseURL: OPENROUTER_API, ...options || {} });
+            for (let model of models) {
+                setupAi({
+                    provider: OPENROUTER || provider, model, client,
+                    prompt: promptOpenAI,
+                });
+            }
     }
     ais.sort((a, b) => a.priority - b.priority || a.initOrder - b.initOrder);
     return ais;
@@ -510,8 +438,7 @@ const packAi = (ais, options = {}) => {
     const res = options.basic ? ais.map(x => ({
         id: x.id, name: x.name, features: x.features,
         initOrder: x.initOrder, priority: x.priority,
-        provider: x.provider, model: x.model, modelEmbedding: x.modelEmbedding,
-        prompt: !!x.prompt, embedding: !!x.embedding,
+        provider: x.provider, model: x.model,
     })) : ais;
     return options.all ? res : res[0];
 };
@@ -561,6 +488,10 @@ const countTokens = async (input, options) => {
     );
 };
 
+const isOpenrouter = (provider, model) => insensitiveCompare(
+    provider, OPENROUTER
+) && (model ? model?.source : true);
+
 const selectVisionModel = options => {
     assert(
         MODELS[options.model]?.vision,
@@ -579,7 +510,7 @@ const selectAudioModel = options => {
         ? MODELS[options.model]?.audio : null;
 };
 
-const buildGptMessage = (content, options) => {
+const buildMessage = (content, options) => {
     content = content || '';
     let alterModel = options?.audioMode && selectAudioModel(options);
     const attachments = (options?.attachments || []).map(x => {
@@ -620,70 +551,6 @@ const buildGptMessage = (content, options) => {
     return message;
 };
 
-const buildGeminiParts = (text, attachments) => {
-    // Gemini API does not allow empty text, even you prompt with attachments.
-    const message = [...text?.length || attachments?.length ? [{
-        text: text?.length ? text : ' '
-    }] : [], ...attachments || []];
-    assertContent(message);
-    return message;
-};
-
-const buildGeminiMessage = (content, options) => {
-    content = content || '';
-    // @todo: for future audio mode support
-    // let alterModel = options?.audioMode && selectAudioModel(options);
-    const attachments = (
-        options?.attachments?.length ? options.attachments : []
-    ).map(x => {
-        // assert(MODELS[options?.model], 'Model is required.');
-        // if (MODELS[options.model]?.supportedAudioTypes?.includes?.(x.mime_type)
-        //     && !options.imageMode) {
-        //     alterModel = selectAudioModel(options);
-        // }
-        return {
-            inlineData: { mimeType: x.mime_type, data: x.data }
-        };
-    });
-    // if (alterModel) {
-    //     options.model = alterModel;
-    //     options.audioMode = true;
-    // }
-    return String.isString(content) ? (options?.history ? {
-        role: options?.role || user,
-        parts: buildGeminiParts(content, attachments),
-    } : buildGeminiParts(content, attachments)) : content;
-};
-
-const buildClaudeMessage = (text, options) => {
-    assert(text, 'Text is required.');
-    const attachments = (options?.attachments?.length ? options?.attachments : []).map(x => {
-        let type = '';
-        if ([MIME_PDF].includes(x.mime_type)) {
-            type = 'document';
-        } else if ([MIME_PNG, MIME_JPEG, MIME_GIF, MIME_WEBP].includes(x.mime_type)) {
-            type = 'image';
-        } else { throwError(`Unsupported mime type: ${x.mime_type}`); }
-        return {
-            type, source: {
-                type: BASE64.toLowerCase(),
-                media_type: x.mime_type, data: x.data,
-            },
-        }
-    });
-    return String.isString(text) ? {
-        role: options?.role || user, content: [...attachments, {
-            type: TEXT, text, ...options?.cache_control ? {
-                cache_control: { type: 'ephemeral' },
-            } : {},
-        }],
-    } : text;
-};
-
-const buildGeminiHistory = (text, options) => buildGeminiMessage(
-    text, { ...options || {}, history: true }
-);
-
 const listOpenAIModels = async (aiId, options) => {
     const { client } = await getAi(aiId);
     const resp = await client.models.list();
@@ -692,7 +559,8 @@ const listOpenAIModels = async (aiId, options) => {
 
 const streamResp = async (resp, options) => {
     const msg = await packResp(resp, { ...options, processing: true });
-    return options?.stream && (msg?.text || msg?.audio?.length)
+    return options?.stream
+        && (msg?.text || msg?.audio?.length || msg?.images?.length)
         && await ignoreErrFunc(async () => await options.stream(msg), LOG);
 };
 
@@ -705,13 +573,14 @@ const getInfoEnd = text => Math.max(...[THINK_END, TOOLS_END].map(x => {
 const packResp = async (resp, options) => {
     if (options?.raw) { return resp; }
     let [
-        txt, audio, references, simpleText, referencesMarkdown, end, json,
-        images
+        txt, audio, images, references, simpleText, referencesMarkdown, end,
+        json, audioMimeType,
     ] = [
             resp.text || '',                                                    // ChatGPT / Claude / Gemini / Ollama
             resp?.audio?.data,                                                  // ChatGPT audio mode
+            resp?.images || [],                                                 // Gemini images via Openrouter
             resp?.references,                                                   // Gemini references
-            '', '', '', null, resp?.images || [],
+            '', '', '', null, MIME_PCM16
         ];
     simpleText = txt;
     while ((end = getInfoEnd(simpleText))) {
@@ -722,16 +591,18 @@ const packResp = async (resp, options) => {
         const str = simpleText.indexOf(x);
         str >= 0 && (simpleText = simpleText.slice(0, str).trim());
     });
-    audio = await ignoreErrFunc(async () => await packPcmToWav(audio, {
-        input: Buffer.isBuffer(audio) ? BUFFER : BASE64, expected: BUFFER,
+    audio = await ignoreErrFunc(async () => ({
+        data: await packPcmToWav(audio, {
+            input: BUFFER, expected: BUFFER, suffix: 'pcm.wav', ...options
+        }), mime: audioMimeType,
     }));
-    if (images?.length) {
-        for (let i in images) {
-            images[i].data = await convert(images[i].data, {
-                input: BASE64, expected: BUFFER,
-            });
-        }
-    }
+    images = await Promise.all(
+        images.map(async x => ({
+            data: await convert(x.buffer, {
+                input: BUFFER, expected: BUFFER, ...options
+            }), mime: x.mime,
+        }))
+    );
     options?.jsonMode && !options?.delta && (json = parseJson(simpleText, null));
     if (options?.simple && options?.audioMode) { return audio; }
     else if (options?.simple && options?.jsonMode) { return json; }
@@ -803,8 +674,7 @@ const packResp = async (resp, options) => {
         ...text(txt), ...options?.jsonMode ? { json } : {},
         ...references ? { references } : {},
         ...referencesMarkdown ? { referencesMarkdown } : {},
-        ...audio ? { audio, audioMimeType: options?.audioMimeType } : {},
-        ...images?.length ? { images } : {},
+        ...audio ? { audio } : {}, ...images?.length ? { images } : {},
         processing: !!options?.processing,
         model: options?.model,
     };
@@ -817,13 +687,8 @@ const buildPrompts = async (model, input, options = {}) => {
     assert(!(
         options.reasoning && !model?.reasoning
     ), `This model does not support reasoning: ${options.model}`);
-    let [
-        systemPrompt, history, content, prompt, _system, _model, _assistant,
-        _history,
-    ] = [
-            null, null, input, null, { role: system }, { role: MODEL },
-            { role: assistant }, null,
-        ];
+    let [history, content, prompt, _model, _assistant, _history]
+        = [null, input, null, { role: MODEL }, { role: assistant }, null];
     options.systemPrompt = options.systemPrompt || INSTRUCTIONS;
     options.attachments = (
         options.attachments?.length ? options.attachments : []
@@ -832,70 +697,17 @@ const buildPrompts = async (model, input, options = {}) => {
         ...model?.supportedDocTypes,
         ...model?.supportedAudioTypes,
     ].includes(x.mime_type));
-    switch (options.flavor) {
-        case OPENAI:
-            systemPrompt = buildGptMessage(options.systemPrompt, _system);
-            break;
-        case ANTHROPIC:
-            systemPrompt = options.systemPrompt;
-            break;
-        case GEMINI:
-            const _role = {
-                role: [GEMINI_25_FLASH_IMAGE].includes(options.model)
-                    ? user : system
-            };
-            systemPrompt = buildGeminiHistory(options.systemPrompt, _role);
-            break;
-    }
+    const systemPrompt = buildMessage(options.systemPrompt, system);
     const msgBuilder = () => {
         [history, _history] = [[], []];
         (options.messages?.length ? options.messages : []).map((x, i) => {
-            switch (options.flavor) {
-                case OPENAI:
-                    _history.push(buildGptMessage(x.request));
-                    _history.push(buildGptMessage(x.response, _assistant));
-                    break;
-                case ANTHROPIC:
-                    _history.push(buildClaudeMessage(x.request));
-                    _history.push(buildClaudeMessage(x.response, _assistant));
-                    break;
-                case GEMINI:
-                    // 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?
-                    if (options.attachments?.length) { return; }
-                    _history.push(buildGeminiHistory(x.request));
-                    _history.push(buildGeminiHistory(x.response, _model));
-                    break;
-            }
+            _history.push(buildMessage(x.request));
+            _history.push(buildMessage(x.response, _assistant));
         });
-        switch (options.flavor) {
-            case OPENAI:
-                history = messages([
-                    systemPrompt, ..._history, buildGptMessage(content, options),
-                    ...options.toolsResult?.length ? options.toolsResult : []
-                ]);
-                break;
-            case ANTHROPIC:
-                history = messages([
-                    ..._history, buildClaudeMessage(content, {
-                        ...options, cache_control: true
-                    }), ...options.toolsResult?.length ? options.toolsResult : []
-                ]);
-                break;
-            case GEMINI:
-                [history, prompt] = options.toolsResult?.length ? [
-                    [
-                        ..._history,
-                        buildGeminiHistory(content, options),
-                        ...options.toolsResult.slice(0, options.toolsResult.length - 1),
-                    ],
-                    options.toolsResult[options.toolsResult?.length - 1].parts,
-                ] : [
-                    [..._history],
-                    buildGeminiMessage(content, options),
-                ];
-                break;
-        }
+        history = messages([
+            systemPrompt, ..._history, buildMessage(content, options),
+            ...options.toolsResult?.length ? options.toolsResult : []
+        ]);
     };
     msgBuilder();
     await trimPrompt(() => [
@@ -908,11 +720,7 @@ const buildPrompts = async (model, input, options = {}) => {
             content = trimTailing(trimTailing(content).slice(0, -1)) + '...';
         } // @todo: audioCostTokens (needs to calculate the audio length):
     }, model.maxInputTokens - options.attachments?.length * model.imageCostTokens);
-    if ([OPENAI].includes(options.flavor)
-        || [GEMINI_25_FLASH_IMAGE].includes(options.model)) {
-        systemPrompt = null;
-    }
-    return { systemPrompt, history, prompt };
+    return { history, prompt };
 };
 
 const handleToolsCall = async (msg, options) => {
@@ -932,34 +740,12 @@ const handleToolsCall = async (msg, options) => {
     if (calls.length) {
         preRes.push(msg);
         for (const fn of calls) {
-            switch (options?.flavor) {
-                case ANTHROPIC:
-                    input = fn.input = String.isString(fn?.input)
-                        ? parseJson(fn.input) : fn?.input;
-                    packMsg = (content, is_error) => ({
-                        type: 'tool_result', tool_use_id: fn.id,
-                        content, is_error,
-                    });
-                    break;
-                case GEMINI:
-                    input = fn?.functionCall?.args;
-                    packMsg = (t, e) => ({
-                        functionResponse: {
-                            name: fn?.functionCall?.name, response: {
-                                name: fn?.functionCall?.name,
-                                content: e ? `[Error] ${t}` : t,
-                            }
-                        }
-                    });
-                    break;
-                case OPENAI: default:
-                    input = parseJson(fn?.function?.arguments);
-                    packMsg = (content = '', e = false) => ({
-                        role: TOOL, tool_call_id: fn.id,
-                        ...e ? { error: content, content: '' } : { content }
-                    });
-                    break;
-            }
+            input = fn?.functionCall?.args;
+            packMsg = (t, e) => ({
+                role: 'tool',
+                tool_call_id: fn.id,
+                content: e ? `[Error] ${t}` : t
+            });
             const name = (fn?.function || fn?.functionCall || fn)?.name;
             if (!name) { continue; }
             await resp(`${callIdx++ ? '\n' : ''}Name: ${name}`);
@@ -987,12 +773,7 @@ const handleToolsCall = async (msg, options) => {
                 log(rt);
             }
         }
-        if (content.length) {
-            switch (options?.flavor) {
-                case ANTHROPIC: content = [{ role: user, content }]; break;
-                case GEMINI: content = [{ role: user, parts: content }]; break;
-            }
-        }
+        content = content.map(x => ({ role: TOOL, ...x }));
         responded && await resp(TOOLS_END);
     }
     return {
@@ -1007,37 +788,51 @@ const mergeMsgs = (resp, calls) => [resp, ...calls.length ? [
 
 const promptOpenAI = async (aiId, content, options = {}) => {
     let { provider, client, model } = await getAi(aiId);
-    let [result, resultAudio, event, resultTools, responded, azure] = [
-        options.result ?? '', Buffer.alloc(0), null, [], false,
-        provider === AZURE
-    ];
-    options.flavor = OPENAI;
+    let [
+        result, resultAudio, resultImages, resultReasoning, event, resultTools,
+        responded, modalities, source, reasoningEnd
+    ] = [
+            options.result ?? '', Buffer.alloc(0), [], '', null, [], false,
+            options.modalities, model?.source, false
+        ];
     options.model = options.model || model.name;
     const { history }
         = await buildPrompts(MODELS[options.model], content, options);
     model = MODELS[options.model];
-    model?.reasoning && !azure && !options.reasoning_effort
+    model?.reasoning && !options.reasoning_effort
         && (options.reasoning_effort = GPT_REASONING_EFFORT);
-    const modalities = options.modalities
-        || (options.audioMode ? [TEXT, AUDIO] : undefined);
-    [options.audioMimeType, options.suffix] = [MIME_PCM16, 'pcm.wav'];
+    if (!modalities && options.audioMode) {
+        modalities = [TEXT, AUDIO];
+    } else if (!modalities && model.image) {
+        modalities = [TEXT, IMAGE];
+    }
+    const googleImageMode = source === 'google' && modalities?.has?.(IMAGE);
+    const targetModel = `${isOpenrouter(provider, model) ? `${source}/` : ''}${options.model}`;
     const resp = await client.chat.completions.create({
-        model: azure ? undefined : options.model, ...history,
+        model: targetModel, ...history,
         ...options.jsonMode ? { response_format: { type: JSON_OBJECT } } : {},
         ...provider === OLLAMA ? { keep_alive: -1 } : {},
         modalities, audio: options.audio || (
             modalities?.find?.(x => x === AUDIO)
             && { voice: DEFAULT_MODELS[OPENAI_VOICE], format: 'pcm16' }
-        ), ...model?.tools && !azure ? {
+        ), ...model?.tools && !googleImageMode ? {
             tools: options.tools ?? (await toolsOpenAI()).map(x => x.def),
             tool_choice: 'auto',
-        } : {}, ...azure ? {} : { store: true }, stream: true,
+        } : {},
+        store: true, stream: true,
         reasoning_effort: options.reasoning_effort,
     });
     for await (event of resp) {
+        print(JSON.stringify(event, null, 2));
         event = event?.choices?.[0] || {};
         const delta = event.delta || {};
-        let deltaText = delta.content || delta.audio?.transcript || '';
+        let [delteReasoning, deltaText] = [
+            delta.reasoning || '',
+            delta.content || delta.audio?.transcript || ''
+        ];
+        const deltaImages = (delta?.images || []).map(
+            x => decodeBase64DataURL(x.image_url.url)
+        );
         const deltaAudio = delta.audio?.data ? await convert(
             delta.audio.data, { input: BASE64, expected: BUFFER }
         ) : Buffer.alloc(0);
@@ -1055,16 +850,28 @@ const promptOpenAI = async (aiId, content, options = {}) => {
         }
         options.result && deltaText
             && (responded = responded || (deltaText = `\n\n${deltaText}`));
+        resultReasoning += delteReasoning;
+        delteReasoning && delteReasoning === resultReasoning
+            && (delteReasoning = `${THINK_STR}\n${delteReasoning}`);
+        resultReasoning && deltaText && !reasoningEnd && (
+            reasoningEnd = delteReasoning = `${delteReasoning}${THINK_END}\n\n`
+        );
+        deltaText = delteReasoning + deltaText;
         result += deltaText;
+        resultImages.push(...deltaImages);
         resultAudio = Buffer.concat([resultAudio, deltaAudio]);
+        const respImages = options.delta ? deltaImages : resultImages;
         const respAudio = options.delta ? deltaAudio : resultAudio;
-        (deltaText || deltaAudio?.length) && await streamResp({
-            text: options.delta ? deltaText : result,
-            ...respAudio.length ? { audio: { data: respAudio } } : {},
-        }, options);
+        (deltaText || deltaAudio?.length || deltaImages.length)
+            && await streamResp({
+                text: options.delta ? deltaText : result,
+                ...respAudio.length ? { audio: { data: respAudio } } : {},
+                ...respImages.length ? { images: respImages } : {},
+            }, options);
     }
     event = {
         role: assistant, text: result, tool_calls: resultTools,
+        ...resultImages.length ? { images: resultImages } : {},
         ...resultAudio.length ? { audio: { data: resultAudio } } : {},
     };
     const { toolsResult, toolsResponse }
@@ -1079,329 +886,122 @@ const promptOpenAI = async (aiId, content, options = {}) => {
     return await packResp(event, options);
 };
 
-const promptAnthropic = async (aiId, content, options = {}) => {
-    const { client, model } = await getAi(aiId);
-    let [
-        event, text, thinking, signature, result, thinkEnd, tool_use,
-        responded, redacted_thinking
-    ] = [null, '', '', '', options.result ?? '', '', [], false, []];
-    options.model = options.model || model.name;
-    options.test_redacted_thinking && !result && (
-        content += '\n\nANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_'
-        + '46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB'
-    ); // https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking
-    const { systemPrompt: system, history }
-        = 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 ? kT(128) : model.maxOutputTokens,
-        ...(options.reasoning ?? model.reasoning) ? {
-            thinking: options.thinking || {
-                type: 'enabled',
-                budget_tokens: options?.extendedThinking ? 16000 : 1024,
-            },
-        } : {}, ...model?.tools ? {
-            tools: options.tools ?? (await toolsClaude()).map(x => x.def),
-            tool_choice: { type: 'auto' }, betas: [
-                // https://docs.anthropic.com/en/docs/build-with-claude/tool-use/token-efficient-tool-use
-                'token-efficient-tools-2025-02-19',
-                'interleaved-thinking-2025-05-14',
-                // https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking
-                ...options?.extendedThinking ? ['output-128k-2025-02-19'] : [],
-            ],
-        } : {},
-    });
-    for await (const chunk of resp) {
-        event = chunk?.content_block || chunk?.delta || {};
-        let [deltaThink, deltaText] = [event.thinking || '', event.text || ''];
-        text += deltaText;
-        thinking += deltaThink;
-        signature = signature || event?.signature || '';
-        deltaThink && deltaThink === thinking
-            && (deltaThink = `${THINK_STR}\n${deltaThink}`);
-        thinking && deltaText && !thinkEnd
-            && (thinkEnd = deltaThink = `${deltaThink}\n${THINK_END}\n\n`);
-        event?.type === REDACTED_THINKING && redacted_thinking.push(event);
-        if (event?.type === 'tool_use') {
-            tool_use.push({ ...event, input: '' });
-        } else if (event.partial_json) {
-            tool_use[tool_use.length - 1].input += event.partial_json;
-        }
-        deltaText = deltaThink + deltaText;
-        options.result && deltaText
-            && (responded = responded || (deltaText = `\n\n${deltaText}`));
-        result += deltaText;
-        deltaText && await streamResp({
-            text: options.delta ? deltaText : result,
-        }, options);
-    }
-    event = {
-        role: assistant, content: [
-            ...thinking ? [{ type: THINKING, thinking, signature }] : [],
-            ...redacted_thinking,
-            ...text ? [{ type: TEXT, text }] : [], ...tool_use,
-        ]
-    };
-    const { toolsResult, toolsResponse } = await handleToolsCall(
-        event, { ...options, result, flavor: ANTHROPIC },
-    );
-    if (tool_use.length && countToolCalls(toolsResponse) < MAX_TOOL_RECURSION) {
-        return await promptAnthropic(aiId, content, {
-            ...options, toolsResult: [...options.toolsResult || [],
-            ...toolsResult], result: toolsResponse,
-        });
-    }
-    return packResp({ text: mergeMsgs(toolsResponse, tool_use) }, options);
-};
-
-const uploadFile = async (aiId, input, options) => {
-    const { client } = await getAi(aiId);
-    const { content: file, cleanup } = await convert(input, {
-        input: options?.input, ...options || {}, expected: STREAM,
-        errorMessage: INVALID_FILE, suffix: options?.suffix,
-        withCleanupFunc: true,
-    });
-    const resp = await client.files.create({ file, ...options?.params || {} });
-    await cleanup();
-    return resp;
-};
-
-const uploadFileForFineTuning = async (aiId, content, options) => await uploadFile(
-    aiId, content, { suffix: 'jsonl', ...options, params: { purpose: 'fine-tune' } }
-);
-
-const listFiles = async (aiId, options) => {
-    const { client } = await getAi(aiId);
-    const files = [];
-    const list = await client.files.list(options?.params || {});
-    for await (const file of list) { files.push(file); }
-    return files;
-};
-
-const deleteFile = async (aiId, file_id, options) => {
-    const { client } = await getAi(aiId);
-    return await client.files.del(file_id);
-};
-
-const packGeminiReferences = (chunks, supports) => {
-    let references = null;
-    if (chunks?.length && supports?.length) {
-        references = { segments: [], links: [] };
-        supports.map(s => references.segments.push({
-            ...s.segment, indices: s.groundingChunkIndices,
-            confidence: s.confidenceScores,
-        }));
-        chunks.map(c => references.links.push(c.web));
-    }
-    return references;
-};
-
-const promptGemini = async (aiId, content, options = {}) => {
-    let { provider, client, model } = await getAi(aiId);
-    let [
-        event, result, text, thinking, references, functionCalls, responded,
-        images, thinkEnd,
-    ] = [null, options.result ?? '', '', '', null, [], false, [], false];
-    options.model = options.model || model.name;
-    model?.image === true && (options.imageMode = true);
-    assert(!(options.imageMode && !model.image), 'Image mode is not supported.');
-    if (options.imageMode && String.isString(model.image)) {
-        options.model = model.image;
-        options.imageMode = true;
-        model = MODELS[options.model];
-    }
-    options.flavor = GEMINI;
-    const { systemPrompt: systemInstruction, history, prompt }
-        = await buildPrompts(model, content, options);
-    const responseModalities = options.modalities
-        || (options.imageMode ? [TEXT, IMAGE] : undefined)
-        || (options.audioMode ? [TEXT, AUDIO] : undefined);
-    const chat = client.chats.create({
-        model: options.model, history, config: {
-            responseMimeType: options.jsonMode ? MIME_JSON : MIME_TEXT,
-            ...model.reasoning ? {
-                thinkingConfig: { includeThoughts: true },
-            } : {}, systemInstruction, responseModalities,
-            ...options?.config || {}, ...model?.tools && !options.jsonMode
-                && ![GEMINI_25_FLASH_IMAGE].includes(options.model)
-                ? (options.tools ?? {
-                    tools: [
-                        // @todo: Gemini will failed when using these tools together.
-                        // https://ai.google.dev/gemini-api/docs/function-calling
-                        // { codeExecution: {} },
-                        // { googleSearch: {} },
-                        // { urlContext: {} },
-                        // @todo: test these tools in next version 👆
-                        {
-                            functionDeclarations: (
-                                await toolsGemini({ provider })
-                            ).map(x => x.def)
-                        },
-                    ], toolConfig: { functionCallingConfig: { mode: 'AUTO' } },
-                }) : {},
-        },
-    });
-    const resp = await chat.sendMessageStream({ message: prompt });
-    for await (const chunk of resp) {
-        assert(
-            !chunk?.promptFeedback?.blockReason,
-            chunk?.promptFeedback?.blockReason
-        );
-        event = chunk?.candidates?.[0];
-        let [deltaText, deltaThink, deltaImages] = ['', '', []];
-        event?.content?.parts?.map(x => {
-            if (x.text && x.thought) { deltaThink = x.text; }
-            else if (x.text) { deltaText = x.text; }
-            else if (x.functionCall) { functionCalls.push(x); }
-            else if (x.inlineData?.mimeType === MIME_PNG) {
-                deltaImages.push(x.inlineData);
-                images.push(x.inlineData);
-            }
-        });
-        text += deltaText;
-        thinking += deltaThink;
-        deltaThink && deltaThink === thinking
-            && (deltaThink = `${THINK_STR}\n${deltaThink}`);
-        thinking && deltaText && !thinkEnd
-            && (thinkEnd = deltaThink = `${deltaThink}${THINK_END}\n\n`);
-        deltaText = deltaThink + deltaText;
-        const rfc = packGeminiReferences(
-            event?.groundingMetadata?.groundingChunks,
-            event?.groundingMetadata?.groundingSupports
-        );
-        rfc && (references = rfc);
-        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);
-    }
-    event = {
-        role: MODEL, parts: [
-            ...thinking ? [{ thought: true, text: thinking }] : [],
-            ...text ? [{ text }] : [],
-            ...functionCalls,
-        ],
-    };
-    const { toolsResult, toolsResponse } = await handleToolsCall(
-        event, { ...options, result, flavor: GEMINI }
-    );
-    if (toolsResult.length
-        && countToolCalls(toolsResponse) < MAX_TOOL_RECURSION) {
-        return promptGemini(aiId, content, {
-            ...options || {}, result: toolsResponse,
-            toolsResult: [...options?.toolsResult || [], ...toolsResult],
-        });
-    }
-    return await packResp({
-        text: mergeMsgs(toolsResponse, toolsResult), images, references,
-    }, options);
-};
-
-const checkEmbeddingInput = async (input, model) => {
-    assert(input, 'Text is required.', 400);
-    const arrInput = input.split(' ');
-    const getInput = () => arrInput.join(' ');
-    const _model = MODELS[model];
-    assert(_model, `Invalid model: '${model}'.`);
-    await trimPrompt(getInput, arrInput.pop, _model.contextWindow);
-    return getInput();
-};
-
-const createOpenAIEmbedding = async (aiId, input, options) => {
-    // args from vertex embedding may be useful uere
-    // https://cloud.google.com/vertex-ai/docs/generative-ai/embeddings/get-text-embeddings
-    // task_type	Description
-    // RETRIEVAL_QUERY	Specifies the given text is a query in a search/ retrieval setting.
-    // RETRIEVAL_DOCUMENT	Specifies the given text is a document in a search / retrieval setting.
-    // SEMANTIC_SIMILARITY	Specifies the given text will be used for Semantic Textual Similarity(STS).
-    // CLASSIFICATION	Specifies that the embeddings will be used for classification.
-    // CLUSTERING	Specifies that the embeddings will be used for clustering.
-    let { client, modelEmbedding, clientEmbedding } = await getAi(aiId);
-    const model = options?.model || modelEmbedding.name;
-    const resp = await (clientEmbedding || client).embeddings.create({
-        model, input: await checkEmbeddingInput(input, model),
-    });
-    return options?.raw ? resp : resp?.data[0].embedding;
-};
-
-const createGeminiEmbedding = async (aiId, input, options) => {
-    const { client, modelEmbedding, clientEmbedding } = await getAi(aiId);
-    const model = options?.model || modelEmbedding.name;
-    const resp = await (
-        clientEmbedding || client
-    ).getGenerativeModel({ model }).embedContent(
-        await checkEmbeddingInput(input, model)
-    );
-    return options?.raw ? resp : resp?.embedding.values;
-};
-
-const buildGptTrainingCase = (prompt, response, options) => messages([
-    ...options?.systemPrompt ? [
-        buildGptMessage(options.systemPrompt, { role: system })
-    ] : [], buildGptMessage(prompt),
-    buildGptMessage(response, { role: assistant }),
-]);
-
-const buildGptTrainingCases = (cases, opts) => cases.map(x => JSON.stringify(
-    buildGptTrainingCase(x.prompt, x.response, { ...x.options, ...opts })
-)).join('\n');
-
-const createGptFineTuningJob = async (aiId, training_file, options) => {
-    const { client } = await getAi(aiId);
-    return await client.fineTuning.jobs.create({
-        training_file, model: options?.model || DEFAULT_MODELS[OPENAI_TRAINING],
-    })
-};
-
-const getGptFineTuningJob = async (aiId, job_id, options) => {
-    const { client } = await getAi(aiId);
-    // https://platform.openai.com/finetune/[job_id]?filter=all
-    return await client.fineTuning.jobs.retrieve(job_id);
-};
-
-const cancelGptFineTuningJob = async (aiId, job_id, options) => {
-    const { client } = await getAi(aiId);
-    return await client.fineTuning.jobs.cancel(job_id);
-};
-
-const listGptFineTuningJobs = async (aiId, options) => {
-    const { client } = await getAi(aiId);
-    const resp = await client.fineTuning.jobs.list({
-        limit: GPT_QUERY_LIMIT, ...options?.params
-    });
-    return options?.raw ? resp : resp.data;
-};
-
-const listGptFineTuningEvents = async (aiId, job_id, options) => {
-    const { client } = await getAi(aiId);
-    const resp = await client.fineTuning.jobs.listEvents(job_id, {
-        limit: GPT_QUERY_LIMIT, ...options?.params,
-    });
-    return options?.raw ? resp : resp.data;
-};
-
-const tailGptFineTuningEvents = async (aiId, job_id, options) => {
-    assert(job_id, 'Job ID is required.');
-    const [loopName, listOpts] = [`GPT-${job_id}`, {
-        ...options, params: { ...options?.params, order: 'ascending' }
-    }];
-    let lastEvent;
-    return await loop(async () => {
-        const resp = await listGptFineTuningEvents(aiId, job_id, {
-            ...listOpts, params: {
-                ...listOpts?.params,
-                ...(lastEvent ? { after: lastEvent.id } : {}),
-            },
-        });
-        for (lastEvent of resp) {
-            lastEvent.message.includes('completed') && await end(loopName);
-            await options?.stream(lastEvent);
-        }
-    }, 3, 2, 1, loopName, { silent, ...options });
-};
+// const packGeminiReferences = (chunks, supports) => {
+//     let references = null;
+//     if (chunks?.length && supports?.length) {
+//         references = { segments: [], links: [] };
+//         supports.map(s => references.segments.push({
+//             ...s.segment, indices: s.groundingChunkIndices,
+//             confidence: s.confidenceScores,
+//         }));
+//         chunks.map(c => references.links.push(c.web));
+//     }
+//     return references;
+// };
+
+// const promptGemini = async (aiId, content, options = {}) => {
+//     let { provider, client, model } = await getAi(aiId);
+//     let [
+//         event, result, text, thinking, references, functionCalls, responded,
+//         images, thinkEnd,
+//     ] = [null, options.result ?? '', '', '', null, [], false, [], false];
+//     options.model = options.model || model.name;
+//     model?.image === true && (options.imageMode = true);
+//     assert(!(options.imageMode && !model.image), 'Image mode is not supported.');
+//     if (options.imageMode && String.isString(model.image)) {
+//         options.model = model.image;
+//         options.imageMode = true;
+//         model = MODELS[options.model];
+//     }
+//     options.flavor = GEMINI;
+//     const { systemPrompt: systemInstruction, history, prompt }
+//         = await buildPrompts(model, content, options);
+//     const responseModalities = options.modalities
+//         || (options.imageMode ? [TEXT, IMAGE] : undefined)
+//         || (options.audioMode ? [TEXT, AUDIO] : undefined);
+//     const chat = client.chats.create({
+//         model: options.model, history, config: {
+//             responseMimeType: options.jsonMode ? MIME_JSON : MIME_TEXT,
+//             ...model.reasoning ? {
+//                 thinkingConfig: { includeThoughts: true },
+//             } : {}, systemInstruction, responseModalities,
+//             ...options?.config || {}, ...model?.tools && !options.jsonMode
+//                 && ![GEMINI_25_FLASH_IMAGE].includes(options.model)
+//                 ? (options.tools ?? {
+//                     tools: [
+//                         // @todo: Gemini will failed when using these tools together.
+//                         // https://ai.google.dev/gemini-api/docs/function-calling
+//                         // { codeExecution: {} },
+//                         // { googleSearch: {} },
+//                         // { urlContext: {} },
+//                         // @todo: test these tools in next version 👆
+//                         {
+//                             functionDeclarations: (
+//                                 await toolsGemini({ provider })
+//                             ).map(x => x.def)
+//                         },
+//                     ], toolConfig: { functionCallingConfig: { mode: 'AUTO' } },
+//                 }) : {},
+//         },
+//     });
+//     const resp = await chat.sendMessageStream({ message: prompt });
+//     for await (const chunk of resp) {
+//         assert(
+//             !chunk?.promptFeedback?.blockReason,
+//             chunk?.promptFeedback?.blockReason
+//         );
+//         event = chunk?.candidates?.[0];
+//         let [deltaText, deltaThink, deltaImages] = ['', '', []];
+//         event?.content?.parts?.map(x => {
+//             if (x.text && x.thought) { deltaThink = x.text; }
+//             else if (x.text) { deltaText = x.text; }
+//             else if (x.functionCall) { functionCalls.push(x); }
+//             else if (x.inlineData?.mimeType === MIME_PNG) {
+//                 deltaImages.push(x.inlineData);
+//                 images.push(x.inlineData);
+//             }
+//         });
+//         text += deltaText;
+//         thinking += deltaThink;
+//         deltaThink && deltaThink === thinking
+//             && (deltaThink = `${THINK_STR}\n${deltaThink}`);
+//         thinking && deltaText && !thinkEnd
+//             && (thinkEnd = deltaThink = `${deltaThink}${THINK_END}\n\n`);
+//         deltaText = deltaThink + deltaText;
+//         const rfc = packGeminiReferences(
+//             event?.groundingMetadata?.groundingChunks,
+//             event?.groundingMetadata?.groundingSupports
+//         );
+//         rfc && (references = rfc);
+//         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);
+//     }
+//     event = {
+//         role: MODEL, parts: [
+//             ...thinking ? [{ thought: true, text: thinking }] : [],
+//             ...text ? [{ text }] : [],
+//             ...functionCalls,
+//         ],
+//     };
+//     const { toolsResult, toolsResponse } = await handleToolsCall(
+//         event, { ...options, result, flavor: GEMINI }
+//     );
+//     if (toolsResult.length
+//         && countToolCalls(toolsResponse) < MAX_TOOL_RECURSION) {
+//         return promptGemini(aiId, content, {
+//             ...options || {}, result: toolsResponse,
+//             toolsResult: [...options?.toolsResult || [], ...toolsResult],
+//         });
+//     }
+//     return await packResp({
+//         text: mergeMsgs(toolsResponse, toolsResult), images, references,
+//     }, options);
+// };
 
 const initChat = async (options = {}) => {
     if (options.sessions) {
@@ -1413,8 +1013,8 @@ const initChat = async (options = {}) => {
     }
     options.instructions && (chatConfig.systemPrompt = options.instructions);
     // Use Gemini instead of ChatGPT because of the longer package.
-    const [spTokens, ais] = await Promise.all([countTokens([buildGeminiHistory(
-        chatConfig.systemPrompt, { role: system }
+    const [spTokens, ais] = await Promise.all([countTokens([buildMessage(
+        options.systemPrompt, system
     )]), getAi(null, { all: true })]);
     for (const ai of ais) {
         const mxPmpt = ai.model.maxInputTokens / 2;
@@ -1597,42 +1197,25 @@ export {
     FUNCTION,
     GEMINI_25_FLASH,
     GEMINI_25_FLASH_IMAGE,
-    GPT_5,
+    GPT_51,
     INSTRUCTIONS,
     MODELS,
     OPENAI_VOICE,
     RETRIEVAL,
-    TEXT_EMBEDDING_3_SMALL,
     analyzeSessions,
-    buildGptTrainingCase,
-    buildGptTrainingCases,
-    cancelGptFineTuningJob,
     countTokens,
-    createGeminiEmbedding,
-    createGptFineTuningJob,
-    createOpenAIEmbedding,
-    deleteFile,
     distillFile,
     getAi,
     getChatAttachmentCost,
     getChatPromptLimit,
-    getGptFineTuningJob,
     getSession,
     init,
     initChat,
     k,
-    listFiles,
-    listGptFineTuningEvents,
-    listGptFineTuningJobs,
     listOpenAIModels,
     prompt,
-    promptAnthropic,
-    promptGemini,
     promptOpenAI,
     resetSession,
-    tailGptFineTuningEvents,
     talk,
     trimPrompt,
-    uploadFile,
-    uploadFileForFineTuning,
 };