utilitas 1998.2.64 → 1998.2.66

package/lib/alan.mjs

@@ -46,32 +46,31 @@ const _NEED = [
 ];
 
 const [
-    OPENAI, GEMINI, CHATGPT, OPENAI_EMBEDDING, GEMINI_EMEDDING, OPENAI_TRAINING,
-    OLLAMA, CLAUDE, GPT_4O_MINI, GPT_4O, GPT_O1, GPT_O3_MINI, GEMINI_20_FLASH,
+    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, EMBEDDING_001, DEEPSEEK_R1,
-    DEEPSEEK_R1_70B, DEEPSEEK_R1_32B, MD_CODE, CHATGPT_REASONING,
-    TEXT_EMBEDDING_3_SMALL, TEXT_EMBEDDING_3_LARGE, CLOUD_37_SONNET, AUDIO, WAV,
-    CHATGPT_MINI, 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, NOT_INIT, INVALID_FILE, tokenSafeRatio,
-    GPT_QUERY_LIMIT, minsOfDay, CONTENT_IS_REQUIRED,
+    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, NOT_INIT,
+    INVALID_FILE, tokenSafeRatio, GPT_QUERY_LIMIT, minsOfDay,
+    CONTENT_IS_REQUIRED,
 ] = [
-        'OPENAI', 'GEMINI', 'CHATGPT', 'OPENAI_EMBEDDING', 'GEMINI_EMEDDING',
-        'OPENAI_TRAINING', 'OLLAMA', 'CLAUDE', 'gpt-4o-mini', 'gpt-4o', 'o1',
-        'o3-mini', 'gemini-2.0-flash', 'gemini-2.0-flash-thinking-exp',
+        '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', 'embedding-001', 'deepseek-r1',
-        'deepseek-r1:70b', 'deepseek-r1:32b', '```', 'CHATGPT_REASONING',
-        'text-embedding-3-small', 'text-embedding-3-large',
-        'claude-3-7-sonnet@20250219', 'audio', 'wav', 'CHATGPT_MINI',
+        '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',
+        7680 * 4320, [], 10, { log: true }, 'Alan', 'user', 'system',
         'assistant', 'model', 'json_object', 'tool', true,
         'AI engine has not been initialized.', 'Invalid file data.', 1.1, 100,
         60 * 24, 'Content is required.',
@@ -90,23 +89,16 @@ const [
         'text/plain', 'audio/x-wav', 'audio/ogg',
     ];
 
-const [tool, provider, messages, text] = [
-    type => ({ type }), provider => ({ provider }),
-    messages => ({ messages }), text => ({ text }),
-];
-
+const [tool, messages, text]
+    = [type => ({ type }), messages => ({ messages }), text => ({ text })];
 const [CODE_INTERPRETER, RETRIEVAL, FUNCTION]
     = ['code_interpreter', 'retrieval', FUNC].map(tool);
-const chatConfig
-    = { sessions: new Map(), engines: {}, systemPrompt: INSTRUCTIONS };
 const [sessionType, aiType]
     = [`${name.toUpperCase()}-SESSION`, `${name.toUpperCase()}-AI`];
 const [newSessionId, newAiId]
     = [sessionType, aiType].map(type => () => createUoid({ type }));
+const chatConfig = { sessions: new Map(), systemPrompt: INSTRUCTIONS };
 const tokenSafe = count => Math.ceil(count * tokenSafeRatio);
-const clients = {};
-const unifyProvider = options => unifyType(options?.provider, 'AI provider');
-const unifyEngine = options => unifyType(options?.engine, 'AI engine');
 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 || {} });
@@ -128,18 +120,8 @@ const DEFAULT_MODELS = {
     [OPENAI_EMBEDDING]: TEXT_EMBEDDING_3_SMALL,
     [GEMINI_EMEDDING]: EMBEDDING_001,
     [OPENAI_TRAINING]: GPT_4O_MINI, // https://platform.openai.com/docs/guides/fine-tuning
-
-
-    [CHATGPT_MINI]: GPT_4O_MINI,
-    [CHATGPT_REASONING]: GPT_O3_MINI,
 };
 
-
-
-
-
-
-
 DEFAULT_MODELS[CHAT] = DEFAULT_MODELS[GEMINI];
 
 const tokenRatioByWords = Math.min(
@@ -164,17 +146,14 @@ const MODELS = {
         requestLimitsRPM: 10000,
         tokenLimitsTPD: 1000000000,
         tokenLimitsTPM: 10000000,
-        trainingData: 'Oct 2023',
+        audio: 'gpt-4o-mini-audio-preview',
+        fast: true,
         json: true,
-        vision: true,
         tools: true,
-        audio: 'gpt-4o-mini-audio-preview',
-        supportedMimeTypes: [
-            png, jpeg, gif, webp,
-        ],
-        supportedAudioTypes: [
-            wav,
-        ],
+        vision: true,
+        supportedMimeTypes: [png, jpeg, gif, webp],
+        supportedAudioTypes: [wav],
+        trainingData: 'Oct 2023',
     },
     [GPT_4O]: {
         contextWindow: 128000,
@@ -183,17 +162,13 @@ const MODELS = {
         requestLimitsRPM: 10000,
         tokenLimitsTPD: 20000000,
         tokenLimitsTPM: 2000000,
-        trainingData: 'Oct 2023',
+        audio: 'gpt-4o-audio-preview',
         json: true,
-        vision: true,
         tools: true,
-        audio: 'gpt-4o-audio-preview',
-        supportedMimeTypes: [
-            png, jpeg, gif, webp,
-        ],
-        supportedAudioTypes: [
-            wav,
-        ],
+        vision: true,
+        supportedMimeTypes: [png, jpeg, gif, webp],
+        supportedAudioTypes: [wav],
+        trainingData: 'Oct 2023',
     },
     [GPT_O1]: {
         contextWindow: 200000,
@@ -202,14 +177,14 @@ const MODELS = {
         requestLimitsRPM: 10000,
         tokenLimitsTPD: 200000000,
         tokenLimitsTPM: 2000000,
-        trainingData: 'Oct 2023',
         json: true,
         reasoning: true,
-        vision: true,
         tools: true,
+        vision: true,
         supportedMimeTypes: [
             png, jpeg, gif, webp,
         ],
+        trainingData: 'Oct 2023',
     },
     [GPT_O3_MINI]: {
         contextWindow: 200000,
@@ -218,14 +193,13 @@ const MODELS = {
         requestLimitsRPM: 10000,
         tokenLimitsTPD: 1000000000,
         tokenLimitsTPM: 10000000,
-        trainingData: 'Oct 2023',
+        fast: true,
         json: true,
         reasoning: true,
-        vision: true,
         tools: true,
-        supportedMimeTypes: [
-            png, jpeg, gif, webp,
-        ],
+        vision: true,
+        supportedMimeTypes: [png, jpeg, gif, webp],
+        trainingData: 'Oct 2023',
     },
     [GPT_45]: {
         contextWindow: 128000,
@@ -235,20 +209,18 @@ const MODELS = {
         tokenLimitsTPD: 100000000,
         tokenLimitsTPM: 1000000,
         json: true,
-        vision: true,
         tools: true,
-        supportedMimeTypes: [
-            png, jpeg, gif, webp,
-        ],
+        vision: true,
+        supportedMimeTypes: [png, jpeg, gif, webp],
         trainingData: 'Oct 2023',
     },
     [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,
-        audioCostTokens: 1000000, // 8.4 hours => 1 million tokens
         maxAudioLength: 60 * 60 * 8.4, // 9.5 hours
         maxAudioPerPrompt: 1,
         maxFileSize: 20 * 1024 * 1024, // 20 MB
@@ -260,17 +232,18 @@ const MODELS = {
         maxVideoLengthWithAudio: 60 * 50, // 50 minutes
         maxVideoLengthWithoutAudio: 60 * 60, // 1 hour
         maxVideoPerPrompt: 10,
-        requestLimitsRPM: 2000,
         requestLimitsRPD: 1500,
+        requestLimitsRPM: 2000,
         tokenLimitsTPM: 4 * 1000000,
-        trainingData: 'August 2024',
-        vision: true,
+        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_20_FLASH_THINKING]: {
         // https://cloud.google.com/vertex-ai/generative-ai/docs/thinking-mode?hl=en
@@ -284,12 +257,10 @@ const MODELS = {
         requestLimitsRPM: 1000,
         requestLimitsRPD: 1500,
         tokenLimitsTPM: 4 * 1000000,
-        trainingData: 'August 2024',
-        vision: true,
         reasoning: true,
-        supportedMimeTypes: [
-            png, jpeg,
-        ],
+        vision: true,
+        supportedMimeTypes: [png, jpeg],
+        trainingData: 'August 2024',
     },
     [GEMINI_20_PRO]: {
         contextWindow: 2097152,
@@ -302,21 +273,22 @@ const MODELS = {
         requestLimitsRPM: 1000,
         requestLimitsRPD: 1500,
         tokenLimitsTPM: 4 * 1000000,
-        trainingData: 'August 2024',
-        vision: true,
         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,
-        vision: true,
+        fast: true,
         json: true,
+        vision: true,
         supportedMimeTypes: [png, jpeg],
     },
     [DEEPSEEK_R1]: {
@@ -360,12 +332,12 @@ const MODELS = {
         requestLimitsRPM: 50,
         tokenLimitsITPM: 40000,
         tokenLimitsOTPM: 8000,
-        trainingData: 'Apr 2024', // ?
+        json: true,
         reasoning: true,
         tools: true,
-        supportedMimeTypes: [
-            png, jpeg, gif, webp, pdf,
-        ],
+        vision: true,
+        supportedMimeTypes: [png, jpeg, gif, webp, pdf],
+        trainingData: 'Apr 2024',
     },
 };
 
@@ -401,10 +373,13 @@ const MAX_TRIM_TRY = MAX_INPUT_TOKENS / 1000;
 
 let tokeniser;
 
-const unifyType = (type, name) => {
-    const TYPE = ensureString(type, { case: 'UP' });
-    assert(TYPE, `${name} is required.`);
-    return TYPE;
+const unifyProvider = provider => {
+    assert(provider = (provider || '').trim(), 'AI provider is required.');
+    for (let type of [OPENAI, AZURE_OPENAI, AZURE, GEMINI, ANTHROPIC,
+        VERTEX_ANTHROPIC, OLLAMA]) {
+        if (insensitiveCompare(provider, type)) { return type; }
+    }
+    throwError(`Invalid AI provider: ${provider}.`);
 };
 
 const tools = [
@@ -502,8 +477,8 @@ const toolsGemini = async () => (await toolsOpenAI()).map(x => ({
 }));
 
 const init = async (options = {}) => {
-    const id = newAiId();
-    const provider = unifyProvider(options);
+    const id = options.id || newAiId();
+    const provider = unifyProvider(options?.provider);
     const modelName = options.model || DEFAULT_MODELS[provider];
     assert(modelName, `Model is required for provider: ${provider}.`);
     let model = options.modelConfig || MODELS[modelName];
@@ -512,49 +487,49 @@ const init = async (options = {}) => {
     switch (provider) {
         case OPENAI:
             assertApiKey(provider, options);
-            ais[id] = {
+            ais.push({
                 id, provider, model, client: await OpenAI(options),
                 prompt: async (cnt, opts) => await promptOpenAI(id, cnt, opts),
                 embedding: async (i, o) => await createOpenAIEmbedding(id, i, o),
-            };
+            });
             break;
         case AZURE_OPENAI:
             assertApiKey(provider, options);
             assert(options.endpoint,
-                `{provider} api endpoint and deployment are required.`);
-            ais[id] = {
+                `${provider} api endpoint and deployment are required.`);
+            ais.push({
                 id, provider, model, client: await AzureOpenAI({
                     apiVersion: '2025-01-01-preview',
                     deployment: model.name, ...options,
                 }),
                 prompt: async (cnt, opts) => await promptOpenAI(id, cnt, opts),
-            };
+            });
             break;
         case AZURE:
             assertApiKey(provider, options);
             assert(options.baseURL, `${provider} api endpoint is required.`);
-            ais[id] = {
+            ais.push({
                 id, provider, model, client: await OpenAI(options),
                 prompt: async (cnt, opts) => await promptOpenAI(id, cnt, opts),
-            };
+            });
             break;
         case GEMINI:
             assertApiKey(provider, options);
             const { GoogleGenerativeAI } = await need('@google/generative-ai');
-            ais[id] = {
+            ais.push({
                 id, provider, model,
                 client: new GoogleGenerativeAI(options.apiKey),
                 prompt: async (cnt, opts) => await promptGemini(id, cnt, opts),
                 embedding: async (i, o) => await createGeminiEmbedding(id, i, o),
-            };
+            });
             break;
         case ANTHROPIC:
             assertApiKey(provider, options);
             const Anthropic = (await need('@anthropic-ai/sdk')).Anthropic;
-            ais[id] = {
+            ais.push({
                 id, provider, model, client: new Anthropic(options),
                 prompt: async (cnt, opts) => await promptAnthropic(id, cnt, opts),
-            };
+            });
             break;
         case VERTEX_ANTHROPIC:
             // https://github.com/anthropics/anthropic-sdk-typescript/tree/main/packages/vertex-sdk
@@ -562,21 +537,21 @@ const init = async (options = {}) => {
             const AnthropicVertex = (await need('@anthropic-ai/vertex-sdk')).AnthropicVertex;
             process.env['GOOGLE_APPLICATION_CREDENTIALS'] = options.credentials;
             process.env['ANTHROPIC_VERTEX_PROJECT_ID'] = options.projectId;
-            ais[id] = {
+            ais.push({
                 id, provider, model,
                 client: new AnthropicVertex({ region: options?.region || 'us-east5' }),
                 prompt: async (cnt, opts) => await promptAnthropic(id, cnt, opts),
-            };
+            });
             break;
         case OLLAMA:
             // https://github.com/ollama/ollama/blob/main/docs/openai.md
             const baseURL = 'http://localhost:11434/v1/';
-            ais[id] = {
+            ais.push({
                 id, provider, model, client: await OpenAI({
                     baseURL, apiKey: 'ollama', ...options
                 }),
                 prompt: async (cnt, opts) => await promptOpenAI(id, cnt, opts),
-            };
+            });
             const phLog = m => log(`Ollama preheat: ${m?.message || m}`);
             ignoreErrFunc(async () => {
                 phLog(await (await fetch(`${baseURL}completions`, {
@@ -589,15 +564,32 @@ const init = async (options = {}) => {
         default:
             throwError(`Invalid AI provider: ${options.provider || 'null'}.`);
     }
-    return ais[id];
+    return ais.find(x => x.id === id);
 };
 
-const getAi = async (id, options) => {
+const getAi = async (id, options = {}) => {
     if (id) {
-        if (ais[id]) { return options?.client ? ais[id]?.client : ais[id]; }
-        else { throwError(`AI not found: ${id}.`); }
+        const ai = ais.find(x => x.id === id);
+        assert(ais, `AI not found: ${id}.`);
+        return options?.client ? ai?.client : ai;
+    } else if (options?.select) {
+        const res = [];
+        for (let x of ais) {
+            let select = true;
+            for (let i in options.select) {
+                if (options.select[i] && i !== 'fast' && !x.model[i]) {
+                    select = false; break;
+                }
+            }
+            select && (res.push(x));
+        }
+        const best = options.select?.fast ? res.filter(x => x.model.fast) : res;
+        if (best.length) { return options.all ? best : best[0]; }
+        assert(res.length, 'AI not found.');
+        log(`Best match AI not found, fallbacked: ${JSON.stringify(options.select)}.`);
+        return options.all ? res : res[0];
     }
-    return ais;
+    return options.all ? ais : ais[0];
 };
 
 const countTokens = async (input, options) => {
@@ -702,12 +694,8 @@ const buildGeminiHistory = (text, options) => buildGeminiMessage(
     text, { ...options || {}, history: true }
 );
 
-const [getOpenAIClient] = [OPENAI].map(
-    x => async options => await init({ ...provider(x), ...options })
-);
-
-const listOpenAIModels = async (options) => {
-    const { client } = await getOpenAIClient(options);
+const listOpenAIModels = async (aiId, options) => {
+    const { client } = await getAi(aiId);
     const resp = await client.models.list();
     return options?.raw ? resp : resp.data;
 };
@@ -826,11 +814,11 @@ const buildPrompts = async (model, input, options = {}) => {
         ...model?.supportedMimeTypes || [], ...model.supportedAudioTypes || []
     ].includes(x.mime_type));
     switch (options.flavor) {
-        case CHATGPT:
+        case OPENAI:
             systemPrompt = buildGptMessage(options.systemPrompt, _system);
             prompt = buildGptMessage(content, options);
             break;
-        case CLAUDE:
+        case ANTHROPIC:
             systemPrompt = options.systemPrompt;
             prompt = buildClaudeMessage(content, { ...options, cache_control: true });
             break;
@@ -845,11 +833,11 @@ const buildPrompts = async (model, input, options = {}) => {
         history = [];
         (options.messages?.length ? options.messages : []).map((x, i) => {
             switch (options.flavor) {
-                case CHATGPT:
+                case OPENAI:
                     history.push(buildGptMessage(x.request, _user));
                     history.push(buildGptMessage(x.response, _assistant));
                     break;
-                case CLAUDE:
+                case ANTHROPIC:
                     history.push(buildClaudeMessage(x.request, _user));
                     history.push(buildClaudeMessage(x.response, _assistant));
                     break;
@@ -861,13 +849,13 @@ const buildPrompts = async (model, input, options = {}) => {
             }
         });
         switch (options.flavor) {
-            case CHATGPT:
+            case OPENAI:
                 history = messages([
                     systemPrompt, ...history, prompt,
                     ...options.toolsResult?.length ? options.toolsResult : []
                 ]);
                 break;
-            case CLAUDE:
+            case ANTHROPIC:
                 history = messages([
                     ...history, prompt,
                     ...options.toolsResult?.length ? options.toolsResult : []
@@ -893,7 +881,7 @@ const buildPrompts = async (model, input, options = {}) => {
             content = trimTailing(trimTailing(content).slice(0, -1)) + '...';
         }
     }, model.maxInputTokens - options.attachments?.length * ATTACHMENT_TOKEN_COST);
-    if ([CHATGPT].includes(options.flavor) || options.model === GEMMA_3_27B) {
+    if ([OPENAI].includes(options.flavor) || options.model === GEMMA_3_27B) {
         systemPrompt = null;
     }
     return { systemPrompt, history, prompt };
@@ -914,13 +902,13 @@ const handleToolsCall = async (msg, options) => {
     const calls = msg.tool_calls || msg.content || msg.parts || [];
     if (calls.length) {
         switch (options?.flavor) {
-            case CLAUDE: preRes.push(msg); break;
+            case ANTHROPIC: preRes.push(msg); break;
             case GEMINI: preRes.push(msg); break;
-            case CHATGPT: default: preRes.push(msg); break;
+            case OPENAI: default: preRes.push(msg); break;
         }
         for (const fn of calls) {
             switch (options?.flavor) {
-                case CLAUDE:
+                case ANTHROPIC:
                     input = fn.input = String.isString(fn?.input)
                         ? parseJson(fn.input) : fn?.input;
                     packMsg = (content, is_error) => ({
@@ -939,7 +927,7 @@ const handleToolsCall = async (msg, options) => {
                         }
                     });
                     break;
-                case CHATGPT: default:
+                case OPENAI: default:
                     input = parseJson(fn?.function?.arguments);
                     packMsg = (content = '', e = false) => ({
                         role: TOOL, tool_call_id: fn.id,
@@ -976,7 +964,7 @@ const handleToolsCall = async (msg, options) => {
         }
         if (content.length) {
             switch (options?.flavor) {
-                case CLAUDE: content = [{ role: user, content }]; break;
+                case ANTHROPIC: content = [{ role: user, content }]; break;
                 case GEMINI: content = [{ role: FUNC, parts: content }]; break;
             }
         }
@@ -998,7 +986,7 @@ const promptOpenAI = async (aiId, content, options = {}) => {
         options.result ?? '', Buffer.alloc(0), null, [], false,
         provider === AZURE
     ];
-    options.flavor = CHATGPT;
+    options.flavor = OPENAI;
     options.model = options.model || model.name;
     const { history }
         = await buildPrompts(MODELS[options.model], content, options);
@@ -1077,7 +1065,7 @@ const promptAnthropic = async (aiId, content, options = {}) => {
         + '46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB'
     ); // https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking
     const { systemPrompt: system, history }
-        = await buildPrompts(model, content, { ...options, flavor: CLAUDE });
+        = 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,
@@ -1128,7 +1116,7 @@ const promptAnthropic = async (aiId, content, options = {}) => {
         ]
     };
     const { toolsResult, toolsResponse } = await handleToolsCall(
-        event, { ...options, result, flavor: CLAUDE },
+        event, { ...options, result, flavor: ANTHROPIC },
     );
     if (tool_use.length && countToolCalls(toolsResponse) < MAX_TOOL_RECURSION) {
         return await promptAnthropic(aiId, content, {
@@ -1139,8 +1127,8 @@ const promptAnthropic = async (aiId, content, options = {}) => {
     return packResp({ text: mergeMsgs(toolsResponse, tool_use) }, options);
 };
 
-const uploadFile = async (input, options) => {
-    const { client } = await getOpenAIClient(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,
@@ -1151,20 +1139,20 @@ const uploadFile = async (input, options) => {
     return resp;
 };
 
-const uploadFileForFineTuning = async (content, options) => await uploadFile(
-    content, { suffix: 'jsonl', ...options, params: { purpose: 'fine-tune' } }
+const uploadFileForFineTuning = async (aiId, content, options) => await uploadFile(
+    aiId, content, { suffix: 'jsonl', ...options, params: { purpose: 'fine-tune' } }
 );
 
-const listFiles = async (options) => {
-    const { client } = await getOpenAIClient(options);
+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 (file_id, options) => {
-    const { client } = await getOpenAIClient(options);
+const deleteFile = async (aiId, file_id, options) => {
+    const { client } = await getAi(aiId);
     return await client.files.del(file_id);
 };
 
@@ -1294,48 +1282,48 @@ const buildGptTrainingCases = (cases, opts) => cases.map(x => JSON.stringify(
     buildGptTrainingCase(x.prompt, x.response, { ...x.options, ...opts })
 )).join('\n');
 
-const createGptFineTuningJob = async (training_file, options) => {
-    const { client } = await getOpenAIClient(options);
+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 (job_id, options) => {
-    const { client } = await getOpenAIClient(options);
+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 (job_id, options) => {
-    const { client } = await getOpenAIClient(options);
+const cancelGptFineTuningJob = async (aiId, job_id, options) => {
+    const { client } = await getAi(aiId);
     return await client.fineTuning.jobs.cancel(job_id);
 };
 
-const listGptFineTuningJobs = async (options) => {
-    const { client } = await getOpenAIClient(options);
+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 (job_id, options) => {
-    const { client } = await getOpenAIClient(options);
+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 (job_id, options) => {
+const tailGptFineTuningEvents = async (aiId, job_id, options) => {
     assert(job_id, 'Job ID is required.');
-    const [loopName, listOpts] = [`GPT - ${job_id} `, {
+    const [loopName, listOpts] = [`GPT-${job_id}`, {
         ...options, params: { ...options?.params, order: 'ascending' }
     }];
     let lastEvent;
     return await loop(async () => {
-        const resp = await listGptFineTuningEvents(job_id, {
+        const resp = await listGptFineTuningEvents(aiId, job_id, {
             ...listOpts, params: {
                 ...listOpts?.params,
                 ...(lastEvent ? { after: lastEvent.id } : {}),
@@ -1348,33 +1336,23 @@ const tailGptFineTuningEvents = async (job_id, options) => {
     }, 3, 2, 1, loopName, { silent, ...options });
 };
 
-const initChat = async (options) => {
-    options = {
-        engines: options?.engines || { [DEFAULT_MODELS[CHAT]]: {} },
-        ...options || {},
-    };
-    if (options?.sessions) {
+const initChat = async (options = {}) => {
+    if (options.sessions) {
         assert(
             options.sessions?.get && options.sessions?.set,
             'Invalid session storage provider.'
         );
         chatConfig.sessions = options.sessions;
     }
-    options?.instructions && (chatConfig.systemPrompt = options.instructions);
-    for (const i in options.engines) {
-        const key = ensureString(i, { case: 'UP' });
-        const model = DEFAULT_MODELS[key];
-        assert(model, `Invalid chat model: '${i}'.`);
-        chatConfig.engines[key] = options.engines[i];
-        chatConfig.engines[key].model = chatConfig.engines[key].model || model;
-        const mxPmpt = MODELS[chatConfig.engines[key].model].maxInputTokens / 2;
-        const pmptTokens = await countTokens([buildGeminiHistory(
-            chatConfig.systemPrompt, { role: system }
-        )]); // Use Gemini instead of ChatGPT because of the longer pack
-        assert(
-            pmptTokens < mxPmpt,
-            `System prompt is too long: ${pmptTokens} / ${mxPmpt} tokens.`
-        );
+    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 }
+    )]), getAi(null, { all: true })]);
+    for (const ai of ais) {
+        const mxPmpt = ai.model.maxInputTokens / 2;
+        assert(spTokens < mxPmpt,
+            `System prompt is too long: ${spTokens} / ${mxPmpt} tokens.`);
     }
     return chatConfig;
 };
@@ -1410,53 +1388,30 @@ const resetSession = async (sessionId, options) => {
     return await setSession(sessionId, session);
 };
 
-const packResult = resp => {
-    const result = {
-        ...resp, spoken: renderText(
-            resp.text, { noCode: true, noLink: true }
-        ).replace(/\[\^\d\^\]/ig, ''),
-    };
-    log(`Response (${result.model}): ${JSON.stringify(result.text)}`);
-    // log(result);
-    return result;
-};
-
-const talk = async (input, options) => {
-    let [engine, chat, resp, sessionId] = [
-        unifyEngine({
-            engine: Object.keys(chatConfig.engines)?.[0] || DEFAULT_MODELS[CHAT],
-            ...options,
-        }), { request: input || ATTACHMENTS }, null,
-        options?.sessionId || newSessionId(),
-    ];
-    assert(chatConfig.engines[engine], NOT_INIT);
-    const session = await getSession(sessionId, { engine, ...options });
-    log(`Prompt (${engine}): ${JSON.stringify(input)}`);
-    const pmtOptions = {
-        messages: session.messages, model: chatConfig.engines[engine].model,
-        ...options,
-    };
-    switch (engine) {
-        case CHATGPT: resp = await promptOpenAI(input, pmtOptions); break;
-        case GEMINI: resp = await promptGemini(input, pmtOptions); break;
-        case CLAUDE: resp = await promptAnthropic(input, pmtOptions); break;
-        // case OLLAMA: resp = await promptOllama(input, pmtOptions); break;
-        case AZURE: resp = await promptAzure(input, pmtOptions); break;
-        default: throwError(`Invalid AI engine: '${engine}'.`);
-    }
+const talk = async (input, options = {}) => {
+    let [chat, sessionId] =
+        [{ request: input || ATTACHMENTS }, options.sessionId || newSessionId()];
+    const session = await getSession(sessionId, options);
+    const resp = await prompt(input, {
+        messages: session.messages, log: true, ...options,
+    });
     chat.response = resp.text;
     chat.request && chat.response && session.messages.push(chat);
     await setSession(sessionId, session, options);
-    return { sessionId, ...packResult(resp) };
+    return {
+        sessionId, ...resp, spoken: renderText(
+            resp.text, { noCode: true, noLink: true }
+        ).replace(/\[\^\d\^\]/ig, ''),
+    };
 };
 
-const getMaxChatPromptLimit = (options) => {
+const getMaxChatPromptLimit = async (options) => {
     let resp = 0;
-    for (const i in chatConfig.engines) {
-        if (options?.engine && i !== options.engine) { continue; }
-        const maxInputTokens = MODELS[chatConfig.engines[i].model].maxInputTokens;
+    (await getAi(null, { all: true })).map(x => {
+        if (options?.aiId && options?.aiId !== x.id) { return; }
+        const maxInputTokens = x.model.maxInputTokens;
         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);
 };
@@ -1490,28 +1445,17 @@ const distillFile = async (attachments, o) => {
     attachments = await Promise.all(attachments);
     // print(attachments);
     return await prompt(strPmt, {
-        fast: true, multimodal: true, simple: true, ...o, attachments,
+        simple: true, select: { vision: true, fast: true }, ...o, attachments,
     });
 };
 
-const prompt = async (input, options) => {
-    let egn = options?.engine && unifyEngine(options);
-    const engines = PREFERRED_ENGINES.slice();
-    options?.multimodal && engines.sort((x, y) => x.multimodal - y.multimodal);
-    for (const engine of engines) {
-        if ((egn ? engine.client === egn : true) && clients[engine.client]) {
-            const extra = {};
-            if (engine.client === OPENAI) {
-                if (options?.fast) {
-                    extra.model = DEFAULT_MODELS[CHATGPT_MINI];
-                } else if (options?.reasoning) {
-                    extra.model = DEFAULT_MODELS[CHATGPT_REASONING];
-                }
-            }
-            return await engine.func(input, { ...extra, ...options || {} });
-        }
-    }
-    throwError('No AI provider is available.');
+const prompt = async (input, options = {}) => {
+    const ai = await getAi(options?.aiId, options);
+    const tag = `${ai.provider} (${ai.model.name})`;
+    options.log && log(`Prompt ${tag}: ${JSON.stringify(input)}`);
+    const resp = await ai.prompt(input, options);
+    options.log && log(`Response ${tag}: ${JSON.stringify(resp.text)}`);
+    return resp;
 };
 
 const trimPrompt = async (getPrompt, trimFunc, contextWindow, options) => {
@@ -1553,23 +1497,16 @@ const analyzeSessions = async (sessionIds, options) => {
                 x, JSON.stringify(sses[x]).length,
             ]).sort((x, y) => y[1] - x[1])[0][0]];
         }
-    }, getMaxChatPromptLimit(options));
+    }, await getMaxChatPromptLimit(options));
     const aiResp = Object.keys(sses) ? (await prompt(getInput(), {
-        jsonMode: true, fast: true, simple: true, ...options || {}
+        jsonMode: true, simple: true, select: { json: true, fase: true },
+        ...options || {}
     })) : {};
     assert(aiResp, 'Unable to analyze sessions.');
     ids.map(x => resp[x] = aiResp[x] || null);
     return Array.isArray(sessionIds) ? resp : resp[sessionIds[0]];
 };
 
-const PREFERRED_ENGINES = [
-    { client: OPENAI, func: promptOpenAI, multimodal: 0 },
-    { client: GEMINI, func: promptGemini, multimodal: 1 },
-    { client: CLAUDE, func: promptAnthropic, multimodal: 2 },
-    // { client: AZURE, func: promptAzure, multimodal: 3 },
-    // { client: OLLAMA, func: promptOllama, multimodal: 99 },
-]; // keep gpt first to avoid gemini grounding by default
-
 export default init;
 export {
     ATTACHMENT_TOKEN_COST, CLOUD_37_SONNET, CODE_INTERPRETER, DEEPSEEK_R1,