utilitas 1998.2.58 → 1998.2.60

package/lib/alan.mjs

@@ -49,25 +49,30 @@ 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,
     GEMINI_20_FLASH_THINKING, GEMINI_20_PRO, NOVA, EMBEDDING_001, DEEPSEEK_R1,
-    DEEPSEEK_R1_32B, DEEPSEEK_R1_70B, MD_CODE, CHATGPT_REASONING,
-    TEXT_EMBEDDING_3_SMALL, TEXT_EMBEDDING_3_LARGE, CLAUDE_35_SONNET,
-    CLAUDE_35_HAIKU, 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,
+    DEEPSEEK_R1_70B, 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,
 ] = [
         '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',
         'gemini-2.0-pro-exp', 'nova', 'embedding-001', 'deepseek-r1',
-        'deepseek-r1:32b', 'deepseek-r1:70b', '```', 'CHATGPT_REASONING',
-        'text-embedding-3-small', 'text-embedding-3-large',
-        'claude-3-5-sonnet-latest', 'claude-3-5-haiku-latest',
-        'claude-3-7-sonnet@20250219', 'audio', 'wav', 'CHATGPT_MINI',
-        '[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',
+        'deepseek-r1:70b', '```', 'CHATGPT_REASONING', 'text-embedding-3-small',
+        'text-embedding-3-large', 'claude-3-7-sonnet@20250219', 'audio', 'wav',
+        'CHATGPT_MINI', '[ATTACHMENTS]', 'CHAT', 'OPENAI_VOICE', 'medium',
+        'low', 'high', 'medium', 'think', '<think>', '</think>', 'AZURE',
+        '<tools>', '</tools>', 'tools', 'text', 'thinking', 'OK', 'function',
+        'gpt-4.5-preview', 'redacted_thinking', 'gemma-3-27b-it',
+        'AZURE OPENAI', 'ANTHROPIC', 'VERTEX ANTHROPIC', 'gemma3:27b',
+        7680 * 4320, {}, 10, { log: true }, 'Alan', 'user', 'system',
+        'assistant', 'model', 'json_object', 'tool', true,
+        'AI engine has not been initialized.', 'Invalid file data.', 1.1, 100,
+        60 * 24,
     ];
 
 const [
@@ -88,45 +93,52 @@ const [tool, provider, messages, text] = [
     messages => ({ messages }), text => ({ text }),
 ];
 
-const [name, user, system, assistant, MODEL, JSON_OBJECT, TOOL, silent]
-    = ['Alan', 'user', 'system', 'assistant', 'model', 'json_object', 'tool', true];
 const [CODE_INTERPRETER, RETRIEVAL, FUNCTION]
     = ['code_interpreter', 'retrieval', FUNC].map(tool);
-const [NOT_INIT, INVALID_FILE]
-    = ['AI engine has not been initialized.', 'Invalid file data.'];
 const chatConfig
     = { sessions: new Map(), engines: {}, systemPrompt: INSTRUCTIONS };
-const [tokenSafeRatio, GPT_QUERY_LIMIT, minsOfDay] = [1.1, 100, 60 * 24];
+const [sessionType, aiType]
+    = [`${name.toUpperCase()}-SESSION`, `${name.toUpperCase()}-AI`];
+const [newSessionId, newAiId]
+    = [sessionType, aiType].map(type => () => createUoid({ type }));
 const tokenSafe = count => Math.ceil(count * tokenSafeRatio);
 const clients = {};
-const size8k = 7680 * 4320;
-const MAX_TOOL_RECURSION = 10;
-const LOG = { log: true };
-const sessionType = `${name.toUpperCase()}-SESSION`;
 const unifyProvider = options => unifyType(options?.provider, 'AI provider');
 const unifyEngine = options => unifyType(options?.engine, 'AI engine');
 const trimTailing = text => text.replace(/[\.\s]*$/, '');
-const newSessionId = () => createUoid({ type: sessionType });
 const renderText = (t, o) => _renderText(t, { extraCodeBlock: 0, ...o || {} });
 const log = (cnt, opt) => _log(cnt, import.meta.url, { time: 1, ...opt || {} });
 const CONTENT_IS_REQUIRED = 'Content is required.';
 const assertContent = content => assert(content.length, CONTENT_IS_REQUIRED);
 const countToolCalls = r => r?.split('\n').filter(x => x === TOOLS_STR).length;
+const assertApiKey = (p, o) => assert(o?.apiKey, `${p} api key is required.`);
+const libOpenAi = async opts => await need('openai', { ...opts, raw: true });
+const OpenAI = async opts => new (await libOpenAi(opts)).OpenAI(opts);
+const AzureOpenAI = async opts => new (await libOpenAi(opts)).AzureOpenAI(opts);
 
 const DEFAULT_MODELS = {
-    [CHATGPT_MINI]: GPT_4O_MINI,
-    [CHATGPT_REASONING]: GPT_O3_MINI,
-    [CHATGPT]: GPT_4O,
-    [CLAUDE]: CLOUD_37_SONNET,
-    [GEMINI_EMEDDING]: EMBEDDING_001,
+    [OPENAI]: GPT_4O,
+    [AZURE_OPENAI]: GPT_4O,
     [GEMINI]: GEMINI_20_FLASH,
-    [OLLAMA]: DEEPSEEK_R1,
-    [AZURE]: DEEPSEEK_R1,
+    [ANTHROPIC]: CLOUD_37_SONNET,
+    [VERTEX_ANTHROPIC]: CLOUD_37_SONNET,
+    [OLLAMA]: GEMMA327B,
+    [OPENAI_VOICE]: NOVA,
     [OPENAI_EMBEDDING]: TEXT_EMBEDDING_3_SMALL,
+    [GEMINI_EMEDDING]: EMBEDDING_001,
     [OPENAI_TRAINING]: GPT_4O_MINI, // https://platform.openai.com/docs/guides/fine-tuning
-    [OPENAI_VOICE]: NOVA,
+
+
+    [CHATGPT_MINI]: GPT_4O_MINI,
+    [CHATGPT_REASONING]: GPT_O3_MINI,
 };
 
+
+
+
+
+
+
 DEFAULT_MODELS[CHAT] = DEFAULT_MODELS[GEMINI];
 
 const tokenRatioByWords = Math.min(
@@ -194,13 +206,9 @@ const MODELS = {
         reasoning: true,
         vision: true,
         tools: true,
-        // audio: 'gpt-4o-audio-preview', // fallback to GPT-4O to support audio
         supportedMimeTypes: [
             png, jpeg, gif, webp,
         ],
-        // supportedAudioTypes: [ // fallback to GPT-4O to support audio
-        //     wav,
-        // ],
     },
     [GPT_O3_MINI]: {
         contextWindow: 200000,
@@ -214,13 +222,9 @@ const MODELS = {
         reasoning: true,
         vision: true,
         tools: true,
-        // audio: 'gpt-4o-mini-audio-preview', // fallback to GPT-4O-MINI to support audio
         supportedMimeTypes: [
             png, jpeg, gif, webp,
         ],
-        // supportedAudioTypes: [ // fallback to GPT-4O-MINI to support audio
-        //     wav,
-        // ],
     },
     [GPT_45]: {
         contextWindow: 128000,
@@ -305,6 +309,15 @@ const MODELS = {
             flac, mp3, m4a, mpga, opus, pcm, wav, webm, tgpp,
         ],
     },
+    [GEMMA_3_27B]: {
+        contextWindow: 128 * 1000,
+        imageCostTokens: 256,
+        maxImageSize: 896 * 896,
+        maxOutputTokens: 1024 * 8,
+        vision: true,
+        json: true,
+        supportedMimeTypes: [png, jpeg],
+    },
     [DEEPSEEK_R1]: {
         contextWindow: 128 * 1000,
         maxOutputTokens: 32768,
@@ -333,24 +346,6 @@ const MODELS = {
         embedding: true,
         requestLimitsRPM: 1500,
     },
-    [CLAUDE_35_SONNET]: { // https://docs.anthropic.com/en/docs/about-claude/models
-        contextWindow: 200 * 1000,
-        maxOutputTokens: 8192,
-        imageCostTokens: size8k / 750,
-        documentCostTokens: 3000 * 100, // 100 pages: https://docs.anthropic.com/en/docs/build-with-claude/pdf-support
-        maxImagePerPrompt: 5, // https://docs.anthropic.com/en/docs/build-with-claude/vision
-        maxImageSize: 1092, // by pixels
-        maxDocumentPages: 100,
-        maxDocumentFile: 1024 * 1024 * 32, // 32MB
-        requestLimitsRPM: 50,
-        tokenLimitsITPM: 40000,
-        tokenLimitsOTPM: 8000,
-        trainingData: 'Apr 2024',
-        tools: true,
-        supportedMimeTypes: [
-            png, jpeg, gif, webp, pdf,
-        ],
-    },
     // https://console.cloud.google.com/vertex-ai/publishers/anthropic/model-garden/claude-3-7-sonnet?authuser=5&inv=1&invt=Abqftg&project=backend-alpha-97077
     [CLOUD_37_SONNET]: {
         contextWindow: 200 * 1000,
@@ -373,9 +368,8 @@ const MODELS = {
     },
 };
 
-MODELS[CLAUDE_35_HAIKU] = MODELS[CLAUDE_35_SONNET];
-MODELS[DEEPSEEK_R1_32B] = MODELS[DEEPSEEK_R1];
 MODELS[DEEPSEEK_R1_70B] = MODELS[DEEPSEEK_R1];
+MODELS[GEMMA327B] = MODELS[GEMMA_3_27B];
 
 for (const n in MODELS) {
     MODELS[n]['name'] = n;
@@ -505,56 +499,90 @@ const toolsGemini = async () => (await toolsOpenAI()).map(x => ({
     }
 }));
 
-const init = async (options) => {
+const init = async (options = {}) => {
+    const id = newAiId();
     const provider = unifyProvider(options);
+    const modelName = options.model || DEFAULT_MODELS[provider];
+    assert(modelName, `Model is required for provider: ${provider}.`);
+    let model = options.modelConfig || MODELS[modelName];
+    assert(model, `The model has not been configured yet: ${modelName}.`);
+    model = { name: modelName, ...model };
     switch (provider) {
-        case OPENAI: case AZURE:
-            if (options?.apiKey) {
-                provider === AZURE && assert(
-                    options?.baseURL, 'Azure api endpoint is required.'
-                );
-                const libOpenAI = await need('openai', { raw: true });
-                const openai = new (options?.endpoint && options?.deployment
-                    ? libOpenAI.AzureOpenAI : libOpenAI.OpenAI)(options);
-                clients[provider] = { client: openai, clientBeta: openai.beta };
-            }
+        case OPENAI:
+            assertApiKey(provider, options);
+            ais[id] = {
+                id, provider, model, client: await OpenAI(options),
+                prompt: async (cnt, opts) => await promptOpenAI(id, cnt, opts),
+            };
+            break;
+        case AZURE_OPENAI:
+            assertApiKey(provider, options);
+            assert(options.endpoint,
+                `{provider} api endpoint and deployment are required.`);
+            ais[id] = {
+                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] = {
+                id, provider, model, client: await OpenAI(options),
+                prompt: async (cnt, opts) => await promptOpenAI(id, cnt, opts),
+            };
             break;
         case GEMINI:
-            if (options?.apiKey) {
-                const { GoogleGenerativeAI } = await need('@google/generative-ai');
-                const genAi = new GoogleGenerativeAI(options.apiKey);
-                clients[provider] = { client: genAi };
-            }
+            assertApiKey(provider, options);
+            const { GoogleGenerativeAI } = await need('@google/generative-ai');
+            ais[id] = {
+                id, provider, model,
+                client: new GoogleGenerativeAI(options.apiKey),
+                prompt: async (cnt, opts) => await promptGemini(id, cnt, opts),
+            };
             break;
-        case CLAUDE:
-            if (options?.apiKey || (options?.credentials && options?.projectId)) {
-                // https://github.com/anthropics/anthropic-sdk-typescript/tree/main/packages/vertex-sdk
-                const Anthropic = (await need(options?.credentials
-                    ? '@anthropic-ai/vertex-sdk' : '@anthropic-ai/sdk', { raw: true }))[
-                    options?.credentials ? 'AnthropicVertex' : 'Anthropic'
-                ];
-                if (options?.credentials) {
-                    process.env['GOOGLE_APPLICATION_CREDENTIALS'] = options.credentials;
-                    process.env['ANTHROPIC_VERTEX_PROJECT_ID'] = options.projectId;
-                }
-                const anthropic = new Anthropic({
-                    ...options?.apiKey ? { apiKey: options.apiKey } : {},
-                    ...options?.credentials ? { region: options?.region || 'us-east5' } : {},
-                });
-                clients[provider] = { client: anthropic };
-            }
+        case ANTHROPIC:
+            assertApiKey(provider, options);
+            const Anthropic = (await need('@anthropic-ai/sdk')).Anthropic;
+            ais[id] = {
+                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
+            assert(options?.credentials, `${provider} api credentials are required.`);
+            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] = {
+                id, provider, model,
+                client: new AnthropicVertex({ region: options?.region || 'us-east5' }),
+                prompt: async (cnt, opts) => await promptAnthropic(id, cnt, opts),
+            };
             break;
         case OLLAMA:
-            clients[provider] || (clients[provider] = {
+            ais[id] = {
+                id, provider, model,
                 client: new (await need('ollama', { raw: true })).Ollama(options),
-                model: options?.model || DEFAULT_MODELS[OLLAMA],
-            });
+                prompt: async (cnt, opts) => await promptOllama(id, cnt, opts),
+            };
             break;
         default:
-            throwError(`Invalid AI provider: ${options?.provider || 'null'}`);
+            throwError(`Invalid AI provider: ${options.provider || 'null'}.`);
     }
-    assert(clients[provider], NOT_INIT);
-    return clients[provider];
+    return ais[id];
+};
+
+const getAi = async (id, options) => {
+    if (id) {
+        if (ais[id]) { return options?.client ? ais[id]?.client : ais[id]; }
+        else { throwError(`AI not found: ${id}.`); }
+    }
+    return ais;
 };
 
 const countTokens = async (input, options) => {
@@ -806,7 +834,8 @@ const buildPrompts = async (model, input, options = {}) => {
             prompt = buildOllamaMessage(content, options);
             break;
         case GEMINI:
-            systemPrompt = buildGeminiHistory(options.systemPrompt, _system);
+            const _role = { role: options.model === GEMMA_3_27B ? user : system };
+            systemPrompt = buildGeminiHistory(options.systemPrompt, _role);
             prompt = options.toolsResult?.[options.toolsResult?.length - 1]?.parts
                 || buildGeminiMessage(content, options)
             break;
@@ -844,6 +873,7 @@ const buildPrompts = async (model, input, options = {}) => {
                 break;
             case GEMINI:
                 history.push(
+                    ...options.model === GEMMA_3_27B ? [systemPrompt] : [],
                     ...options.toolsResult?.length ? [
                         buildGeminiHistory(content, { ...options, role: user }),
                         ...options.toolsResult.slice(0, options.toolsResult.length - 1)
@@ -861,6 +891,10 @@ const buildPrompts = async (model, input, options = {}) => {
             content = trimTailing(trimTailing(content).slice(0, -1)) + '...';
         }
     }, model.maxInputTokens - options.attachments?.length * ATTACHMENT_TOKEN_COST);
+    if ([CHATGPT, OLLAMA].includes(options.flavor)
+        || options.model === GEMMA_3_27B) {
+        systemPrompt = null;
+    }
     return { systemPrompt, history, prompt };
 };
 
@@ -957,36 +991,32 @@ const mergeMsgs = (resp, calls) => [resp, ...calls.length ? [
     `⚠️ Tools recursion limit reached: ${MAX_TOOL_RECURSION}`
 ] : []].map(x => x.trim()).join('\n\n');
 
-const promptChatGPT = async (content, options = {}) => {
-    if (options.model) { } else if (options.provider === AZURE) {
-        options.model = DEFAULT_MODELS[AZURE];
-    } else if (options.reasoning) {
-        options.model = DEFAULT_MODELS[CHATGPT_REASONING];
-    } else {
-        options.model = DEFAULT_MODELS[CHATGPT];
-    }
-    let [_MODEL, result, resultAudio, event, resultTools, responded] = [
-        MODELS[options.model], options?.result ?? '', Buffer.alloc(0), null, [],
-        false
+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.reasoning && !options.reasoning_effort
-        && (options.reasoning_effort = GPT_REASONING_EFFORT);
-    const { client } = await getOpenAIClient(options);
+    options.flavor = CHATGPT;
+    options.model = options.model || model.name;
     const { history }
-        = await buildPrompts(_MODEL, content, { ...options, flavor: CHATGPT });
+        = await buildPrompts(MODELS[options.model], content, options);
+    model = MODELS[options.model];
+    model.reasoning && !azure && !options.reasoning_effort
+        && (options.reasoning_effort = GPT_REASONING_EFFORT);
     const modalities = options.modalities
         || (options.audioMode ? [TEXT, AUDIO] : undefined);
     [options.audioMimeType, options.suffix] = [pcm16, 'pcm.wav'];
     const resp = await client.chat.completions.create({
+        model: azure ? undefined : options.model, ...history,
+        ...options.jsonMode ? { response_format: { type: JSON_OBJECT } } : {},
         modalities, audio: options.audio || (
             modalities?.find?.(x => x === AUDIO)
             && { voice: DEFAULT_MODELS[OPENAI_VOICE], format: 'pcm16' }
-        ), ...history, ..._MODEL?.tools ? {
+        ), ...model.tools && !azure ? {
             tools: options.tools ?? (await toolsOpenAI()).map(x => x.def),
-        } : {}, ...options.jsonMode ? {
-            response_format: { type: JSON_OBJECT }
-        } : {}, model: options.model, stream: true,
-        store: true, tool_choice: 'auto',
+            tool_choice: 'auto',
+        } : {}, ...azure ? {} : { store: true }, stream: true,
     });
     for await (event of resp) {
         event = event?.choices?.[0] || {};
@@ -1001,9 +1031,11 @@ const promptChatGPT = async (content, options = {}) => {
             isSet(x.index, true) && (curFunc.index = x.index);
             x.id && (curFunc.id = x.id);
             x.type && (curFunc.type = x.type);
-            curFunc.function || (curFunc.function = { name: '', arguments: '' });
+            curFunc.function
+                || (curFunc.function = { name: '', arguments: '' });
             x?.function?.name && (curFunc.function.name += x.function.name);
-            x?.function?.arguments && (curFunc.function.arguments += x.function.arguments);
+            x?.function?.arguments
+                && (curFunc.function.arguments += x.function.arguments);
         }
         options.result && deltaText
             && (responded = responded || (deltaText = `\n\n${deltaText}`));
@@ -1021,25 +1053,27 @@ const promptChatGPT = async (content, options = {}) => {
     };
     const { toolsResult, toolsResponse }
         = await handleToolsCall(event, { ...options, result });
-    if (toolsResult.length && countToolCalls(toolsResponse) < MAX_TOOL_RECURSION) {
-        return promptChatGPT(content, { ...options, toolsResult, result: toolsResponse });
+    if (toolsResult.length
+        && countToolCalls(toolsResponse) < MAX_TOOL_RECURSION) {
+        return promptOpenAI(aiId, content, {
+            ...options, toolsResult, result: toolsResponse,
+        });
     }
     event.text = mergeMsgs(toolsResponse, toolsResult);
     return await packResp(event, options);
 };
 
-const promptAzure = async (content, options = {}) =>
-    await promptChatGPT(content, { ...options, provider: AZURE });
-
-const promptOllama = async (content, options = {}) => {
-    const { client, model } = await getOllamaClient(options);
+const promptOllama = async (aiId, content, options = {}) => {
+    const { client, model } = await getAi(aiId);
     // https://github.com/ollama/ollama-js
     // https://github.com/jmorganca/ollama/blob/main/examples/typescript-simplechat/client.ts
-    options.model = options?.model || model;
-    let [_MODEL, chunk, result] = [MODELS[options.model], null, ''];
-    const { history: h }
-        = await buildPrompts(_MODEL, content, { ...options, flavor: OLLAMA });
-    const resp = await client.chat({ model: options.model, stream: true, ...h });
+    options.model = options?.model || model.name;
+    let [chunk, result] = [null, ''];
+    const { history }
+        = await buildPrompts(model, content, { ...options, flavor: OLLAMA });
+    const resp = await client.chat({
+        model: options.model, stream: true, ...history,
+    });
     for await (chunk of resp) {
         const delta = chunk.message.content || '';
         result += delta;
@@ -1050,33 +1084,28 @@ const promptOllama = async (content, options = {}) => {
     return await packResp({ text: result }, options);
 };
 
-const promptClaude = async (content, options = {}) => {
-    options.model = options.model || DEFAULT_MODELS[CLAUDE];
+const promptAnthropic = async (aiId, content, options = {}) => {
+    const { client, model } = await getAi(aiId);
     let [
-        _MODEL, event, text, thinking, signature, result, thinkEnd, tool_use,
-        responded, redacted_thinking,
-    ] = [
-            MODELS[options.model], null, '', '', '', options.result ?? '', '',
-            [], false, [],
-        ];
-    // https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking
-    options?.test_redacted_thinking && !options?.result && (
+        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'
-    );
-    const { client } = await getClaudeClient(options);
+    ); // 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: CLAUDE });
     const resp = await client.beta.messages.create({
-        model: options.model,
-        max_tokens: options?.extendedThinking ? 128000 : _MODEL.maxOutputTokens,
-        ...history, system, stream: true,
-        ...options.reasoning ?? _MODEL?.reasoning ? {
+        model: options.model, ...history, system, stream: true,
+        max_tokens: options.extendedThinking ? 128000 : model.maxOutputTokens,
+        ...(options.reasoning ?? model.reasoning) ? {
             thinking: options.thinking || {
                 type: 'enabled',
                 budget_tokens: options?.extendedThinking ? 16000 : 1024,
             },
-        } : {}, ..._MODEL?.tools ? {
+        } : {}, ...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
@@ -1121,7 +1150,7 @@ const promptClaude = async (content, options = {}) => {
         event, { ...options, result, flavor: CLAUDE },
     );
     if (tool_use.length && countToolCalls(toolsResponse) < MAX_TOOL_RECURSION) {
-        return await promptClaude(content, {
+        return await promptAnthropic(aiId, content, {
             ...options, toolsResult: [...options.toolsResult || [],
             ...toolsResult], result: toolsResponse,
         });
@@ -1178,31 +1207,29 @@ const packGeminiReferences = (chunks, supports) => {
     return references;
 };
 
-const promptGemini = async (content, options = {}) => {
-    options.model || (options.model = DEFAULT_MODELS[GEMINI]);
-    let [result, references, functionCalls, responded, _MODEL]
-        = [options.result ?? '', null, null, false, MODELS[options.model]];
-    const { client: _client } = await getGeminiClient(options);
+const promptGemini = async (aiId, content, options = {}) => {
+    const { client, model } = await getAi(aiId);
+    let [result, references, functionCalls, responded]
+        = [options.result ?? '', null, null, false];
+    options.model = options.model || model.name;
     const { systemPrompt: systemInstruction, history, prompt }
-        = await buildPrompts(_MODEL, content, { ...options, flavor: GEMINI });
-    const client = _client.getGenerativeModel({
+        = await buildPrompts(model, content, { ...options, flavor: GEMINI });
+    const _client = client.getGenerativeModel({
         model: options.model, systemInstruction,
-        ...MODELS[options.model]?.tools && !options.jsonMode ? (
-            options.tools ?? {
-                tools: [
-                    // @todo: Gemini will failed when using these tools together.
-                    // https://ai.google.dev/gemini-api/docs/function-calling
-                    // { codeExecution: {} },
-                    // { googleSearch: {} },
-                    { functionDeclarations: (await toolsGemini()).map(x => x.def) },
-                ],
-                toolConfig: { functionCallingConfig: { mode: 'AUTO' } },
-            }
-        ) : {},
+        ...model?.tools && !options.jsonMode ? (options.tools ?? {
+            tools: [
+                // @todo: Gemini will failed when using these tools together.
+                // https://ai.google.dev/gemini-api/docs/function-calling
+                // { codeExecution: {} },
+                // { googleSearch: {} },
+                { functionDeclarations: (await toolsGemini()).map(x => x.def) },
+            ],
+            toolConfig: { functionCallingConfig: { mode: 'AUTO' } },
+        }) : {},
     });
     // https://github.com/google/generative-ai-js/blob/main/samples/node/advanced-chat.js
     // Google's bug: history is not allowed while using inline_data?
-    const chat = client.startChat({ history, ...generationConfig(options) });
+    const chat = _client.startChat({ history, ...generationConfig(options) });
     const resp = await chat.sendMessageStream(prompt);
     for await (const chunk of resp.stream) {
         functionCalls || (functionCalls = chunk.functionCalls);
@@ -1227,10 +1254,11 @@ const promptGemini = async (content, options = {}) => {
         { role: MODEL, parts: functionCalls },
         { ...options, result, flavor: GEMINI }
     );
-    if (toolsResult.length && countToolCalls(toolsResponse) < MAX_TOOL_RECURSION) {
-        return promptGemini(content, {
-            ...options || {}, toolsResult: [...options?.toolsResult || [],
-            ...toolsResult], result: toolsResponse,
+    if (toolsResult.length
+        && countToolCalls(toolsResponse) < MAX_TOOL_RECURSION) {
+        return promptGemini(aiId, content, {
+            ...options || {}, result: toolsResponse,
+            toolsResult: [...options?.toolsResult || [], ...toolsResult],
         });
     }
     return await packResp({
@@ -1427,9 +1455,9 @@ const talk = async (input, options) => {
         ...options,
     };
     switch (engine) {
-        case CHATGPT: resp = await promptChatGPT(input, pmtOptions); break;
+        case CHATGPT: resp = await promptOpenAI(input, pmtOptions); break;
         case GEMINI: resp = await promptGemini(input, pmtOptions); break;
-        case CLAUDE: resp = await promptClaude(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}'.`);
@@ -1553,17 +1581,17 @@ const analyzeSessions = async (sessionIds, options) => {
 };
 
 const PREFERRED_ENGINES = [
-    { client: OPENAI, func: promptChatGPT, multimodal: 0 },
+    { client: OPENAI, func: promptOpenAI, multimodal: 0 },
     { client: GEMINI, func: promptGemini, multimodal: 1 },
-    { client: CLAUDE, func: promptClaude, multimodal: 2 },
-    { client: AZURE, func: promptAzure, multimodal: 3 },
+    { 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,
-    DEEPSEEK_R1_32B, DEEPSEEK_R1_70B, DEFAULT_MODELS,
+    DEEPSEEK_R1_70B, DEFAULT_MODELS,
     EMBEDDING_001,
     FUNCTION, GEMINI_20_FLASH, GEMINI_20_FLASH_THINKING, GPT_45, GPT_4O, GPT_4O_MINI, GPT_O1, GPT_O3_MINI, INSTRUCTIONS, MODELS,
     OPENAI_VOICE, RETRIEVAL,
@@ -1582,13 +1610,14 @@ export {
     init,
     initChat,
     jpeg,
+    getAi,
     listFiles,
     listGptFineTuningEvents,
     listGptFineTuningJobs,
     listOpenAIModels,
     ogg,
-    prompt, promptAzure, promptChatGPT,
-    promptClaude,
+    prompt, promptOpenAI,
+    promptAnthropic,
     promptGemini,
     promptOllama,
     resetSession,

package/lib/manifest.mjs

@@ -1,7 +1,7 @@
 const manifest = {
     "name": "utilitas",
     "description": "Just another common utility for JavaScript.",
-    "version": "1998.2.58",
+    "version": "1998.2.60",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "utilitas",
     "description": "Just another common utility for JavaScript.",
-    "version": "1998.2.58",
+    "version": "1998.2.60",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",