utilitas 1999.1.17 → 1999.1.19

package/lib/alan.mjs

@@ -54,49 +54,46 @@ const [
     ];
 
 const [
-    OPENAI, GEMINI, OPENAI_EMBEDDING, GEMINI_EMEDDING, OPENAI_TRAINING, OLLAMA,
-    GPT_4O_MINI, GPT_4O, GPT_O1, GPT_O3_MINI, GEMINI_20_FLASH,
-    GEMINI_20_FLASH_THINKING, GEMINI_20_PRO, NOVA, DEEPSEEK_R1, MD_CODE,
-    TEXT_EMBEDDING_3_SMALL, TEXT_EMBEDDING_3_LARGE, CLOUD_37_SONNET, AUDIO, WAV,
-    ATTACHMENTS, CHAT, OPENAI_VOICE, MEDIUM, LOW, HIGH, GPT_REASONING_EFFORT,
-    THINK, THINK_STR, THINK_END, AZURE, TOOLS_STR, TOOLS_END, TOOLS, TEXT,
-    THINKING, OK, FUNC, GPT_45, REDACTED_THINKING, GEMMA_3_27B, AZURE_OPENAI,
-    ANTHROPIC, VERTEX_ANTHROPIC, GEMMA327B, v8k, ais, MAX_TOOL_RECURSION, LOG,
-    name, user, system, assistant, MODEL, JSON_OBJECT, TOOL, silent,
-    GEMINI_EMBEDDING_M, INVALID_FILE, tokenSafeRatio, GPT_QUERY_LIMIT,
-    CONTENT_IS_REQUIRED, OPENAI_HI_RES_SIZE, k, kT, m, minute, hour,
-    gb, trimTailing, EBD, GEMINI_20_FLASH_EXP, IMAGE, JINA_DEEPSEARCH,
-    JINA_DEEPSEARCH_M, JINA_EMBEDDING, JINA_CLIP,
+    OPENAI, GEMINI, OPENAI_TRAINING, OLLAMA, GPT_4O_MINI, GPT_4O, GPT_O1,
+    GPT_O3_MINI, GEMINI_20_FLASH, GEMINI_20_FLASH_THINKING, GEMINI_20_PRO, NOVA,
+    DEEPSEEK_R1, MD_CODE, TEXT_EMBEDDING_3_SMALL, TEXT_EMBEDDING_3_LARGE,
+    CLOUD_37_SONNET, AUDIO, WAV, ATTACHMENTS, CHAT, OPENAI_VOICE, MEDIUM, LOW,
+    HIGH, GPT_REASONING_EFFORT, THINK, THINK_STR, THINK_END, AZURE, TOOLS_STR,
+    TOOLS_END, TOOLS, TEXT, THINKING, OK, FUNC, GPT_45, REDACTED_THINKING,
+    GEMMA_3_27B, AZURE_OPENAI, ANTHROPIC, VERTEX_ANTHROPIC, GEMMA327B, v8k, ais,
+    MAX_TOOL_RECURSION, LOG, name, user, system, assistant, MODEL, JSON_OBJECT,
+    TOOL, silent, GEMINI_EMBEDDING_M, INVALID_FILE, tokenSafeRatio,
+    GPT_QUERY_LIMIT, CONTENT_IS_REQUIRED, OPENAI_HI_RES_SIZE, k, kT, m, minute,
+    hour, gb, trimTailing, EBD, GEMINI_20_FLASH_EXP, IMAGE, JINA,
+    JINA_DEEPSEARCH, JINA_CLIP,
 ] = [
-        'OpenAI', 'Gemini', 'OPENAI_EMBEDDING', 'GEMINI_EMEDDING',
-        'OPENAI_TRAINING', 'Ollama', 'gpt-4o-mini', 'gpt-4o', 'o1', 'o3-mini',
-        'gemini-2.0-flash', 'gemini-2.0-flash-thinking-exp',
-        'gemini-2.0-pro-exp', 'nova', 'deepseek-r1', '```',
-        'text-embedding-3-small', 'text-embedding-3-large',
-        'claude-3-7-sonnet@20250219', 'audio', 'wav', '[ATTACHMENTS]', 'CHAT',
-        'OPENAI_VOICE', 'medium', 'low', 'high', 'medium', 'think', '<think>',
-        '</think>', 'AZURE', '<tools>', '</tools>', 'tools', 'text', 'thinking',
-        'OK', 'function', 'gpt-4.5-preview', 'redacted_thinking',
-        'gemma-3-27b-it', 'Azure Openai', 'Anthropic', 'Vertex Anthropic',
-        'gemma3:27b', 7680 * 4320, [], 10, { log: true }, 'Alan', 'user',
-        'system', 'assistant', 'model', 'json_object', 'tool', true,
+        'OpenAI', 'Gemini', 'OPENAI_TRAINING', 'Ollama', 'gpt-4o-mini',
+        'gpt-4o', 'o1', 'o3-mini', 'gemini-2.0-flash',
+        'gemini-2.0-flash-thinking-exp', 'gemini-2.0-pro-exp', 'nova',
+        'deepseek-r1', '```', 'text-embedding-3-small',
+        'text-embedding-3-large', 'claude-3-7-sonnet@20250219', 'audio', 'wav',
+        '[ATTACHMENTS]', 'CHAT', 'OPENAI_VOICE', 'medium', 'low', 'high',
+        'medium', 'think', '<think>', '</think>', 'AZURE', '<tools>',
+        '</tools>', 'tools', 'text', 'thinking', 'OK', 'function',
+        'gpt-4.5-preview', 'redacted_thinking', 'gemma-3-27b-it',
+        'Azure Openai', 'Anthropic', 'Vertex Anthropic', 'gemma3:27b',
+        7680 * 4320, [], 10, { log: true }, 'Alan', 'user', 'system',
+        'assistant', 'model', 'json_object', 'tool', true,
         'gemini-embedding-exp-03-07', 'Invalid file data.', 1.1, 100,
         'Content is required.', 2000 * 768, x => 1024 * x, x => 1000 * x,
         x => 1024 * 1024 * x, x => 60 * x, x => 60 * 60 * x,
         x => 1024 * 1024 * 1024 * x, x => x.replace(/[\.\s]*$/, ''),
-        { embedding: true }, 'gemini-2.0-flash-exp', 'image', 'Jina Deepsearch',
-        'jina-deepsearch-v1', 'JINA_EMBEDDING', 'jina-clip-v2',
+        { embedding: true }, 'gemini-2.0-flash-exp', 'image', 'Jina',
+        'jina-deepsearch-v1', 'jina-clip-v2',
     ];
 
 const [tool, messages, text]
     = [type => ({ type }), messages => ({ messages }), text => ({ text })];
 const [CODE_INTERPRETER, RETRIEVAL, FUNCTION]
     = ['code_interpreter', 'retrieval', FUNC].map(tool);
-const [sessionType, aiType]
-    = [`${name.toUpperCase()}-SESSION`, `${name.toUpperCase()}-AI`];
-const [newSessionId, newAiId]
-    = [sessionType, aiType].map(type => () => createUoid({ type }));
 const _NO_RENDER = ['INSTRUCTIONS', 'MODELS', 'DEFAULT_MODELS'];
+const sessionType = `${name.toUpperCase()}-SESSION`;
+const newSessionId = () => createUoid({ type: sessionType });
 const chatConfig = { sessions: new Map(), systemPrompt: INSTRUCTIONS };
 const tokenSafe = count => Math.ceil(count * tokenSafeRatio);
 const renderText = (t, o) => _renderText(t, { extraCodeBlock: 0, ...o || {} });
@@ -117,7 +114,7 @@ const OPENAI_RULES = {
     imageCostTokens: ~~(OPENAI_HI_RES_SIZE / (512 * 512) * 170 + 85),
     maxFileSize: m(20), maxImageSize: OPENAI_HI_RES_SIZE,
     supportedMimeTypes: [png, jpeg, gif, webp],
-    json: true, tools: true, vision: true,
+    json: true, tools: true, vision: true, defaultProvider: OPENAI,
 };
 
 const GEMINI_RULES = {
@@ -128,7 +125,7 @@ const GEMINI_RULES = {
     maxVideoPerPrompt: 10, vision: true, supportedMimeTypes: [
         png, jpeg, mov, mpeg, mp4, mpg, avi, wmv, mpegps, flv, pdf, aac,
         flac, mp3, m4a, mpga, opus, pcm, wav, webm, tgpp,
-    ],
+    ], defaultProvider: GEMINI,
 };
 
 // https://platform.openai.com/docs/models
@@ -164,13 +161,13 @@ const MODELS = {
         contextWindow: kT(128), maxOutputTokens: k(8),
         imageCostTokens: 256, maxImageSize: 896 * 896,
         supportedMimeTypes: [png, jpeg, gif],
-        fast: true, json: true, vision: true,
+        fast: true, json: true, vision: true, defaultProvider: GEMINI,
     },
-    [JINA_DEEPSEARCH_M]: {
+    [JINA_DEEPSEARCH]: {
         contextWindow: Infinity, maxInputTokens: Infinity,
         maxOutputTokens: Infinity, imageCostTokens: 0, maxImageSize: Infinity,
         supportedMimeTypes: [png, jpeg, MIME_TEXT, webp, pdf],
-        reasoning: true, json: true, vision: true,
+        reasoning: true, json: true, vision: true, defaultProvider: JINA,
     },
     [DEEPSEEK_R1]: {
         contextWindow: kT(128), maxOutputTokens: k(32),
@@ -189,6 +186,7 @@ const MODELS = {
         maxImagePerPrompt: 100, maxImageSize: 2000 * 2000,
         supportedMimeTypes: [png, jpeg, gif, webp, pdf],
         json: true, reasoning: true, tools: true, vision: true,
+        defaultProvider: ANTHROPIC,
     }, // https://docs.anthropic.com/en/docs/build-with-claude/vision
 };
 
@@ -207,12 +205,15 @@ for (const n in MODELS) {
         ) : MODELS[n].imageCostTokens;
     }
 }
-MODELS[GEMMA327B] = MODELS[GEMMA_3_27B]; // Ollama Alias
+
 MODELS[GEMINI_20_FLASH].image = GEMINI_20_FLASH_EXP;
 MODELS[GEMINI_20_FLASH_EXP] = {
     ...MODELS[GEMINI_20_FLASH],
     name: GEMINI_20_FLASH_EXP, image: true, tools: false,
 };
+MODELS[GEMMA327B] = { // Ollama Alias
+    ...MODELS[GEMMA_3_27B], name: GEMMA327B, defaultProvider: OLLAMA
+};
 
 // Default models for each provider
 const DEFAULT_MODELS = {
@@ -221,15 +222,17 @@ const DEFAULT_MODELS = {
     [GEMINI]: GEMINI_20_FLASH,
     [ANTHROPIC]: CLOUD_37_SONNET,
     [VERTEX_ANTHROPIC]: CLOUD_37_SONNET,
-    [JINA_DEEPSEARCH]: JINA_DEEPSEARCH_M,
+    [JINA]: JINA_DEEPSEARCH,
     [OLLAMA]: GEMMA327B,
     [OPENAI_VOICE]: NOVA,
-    [OPENAI_EMBEDDING]: TEXT_EMBEDDING_3_SMALL,
-    [GEMINI_EMEDDING]: GEMINI_EMBEDDING_M,
-    [JINA_EMBEDDING]: JINA_CLIP,
     [OPENAI_TRAINING]: GPT_4O_MINI, // https://platform.openai.com/docs/guides/fine-tuning
 };
-DEFAULT_MODELS[CHAT] = DEFAULT_MODELS[GEMINI];
+
+const DEFAULT_EMBEDDING = {
+    [OPENAI]: TEXT_EMBEDDING_3_SMALL,
+    [GEMINI]: GEMINI_EMBEDDING_M,
+    [JINA]: JINA_CLIP,
+};
 
 const tokenRatioByWords = Math.min(
     100 / 75, // ChatGPT: https://platform.openai.com/tokenizer
@@ -247,7 +250,7 @@ let tokeniser;
 const unifyProvider = provider => {
     assert(provider = (provider || '').trim(), 'AI provider is required.');
     for (let type of [OPENAI, AZURE_OPENAI, AZURE, GEMINI, ANTHROPIC,
-        VERTEX_ANTHROPIC, JINA_DEEPSEARCH, OLLAMA]) {
+        VERTEX_ANTHROPIC, JINA, OLLAMA]) {
         if (insensitiveCompare(provider, type)) { return type; }
     }
     throwError(`Invalid AI provider: ${provider}.`);
@@ -347,112 +350,139 @@ const toolsGemini = async () => (await toolsOpenAI()).map(x => ({
     }
 }));
 
+const buildAiId = (provider, model) => [provider, model].map(
+    x => ensureString(x, { case: 'SNAKE' })
+).join('_');
+
+const setupAi = ai => {
+    const id = buildAiId(ai.provider, ai.model.name);
+    ais.push({
+        id, 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)),
+    });
+};
+
 const init = async (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];
-    assert(model, `The model has not been configured yet: ${modelName}.`);
-    model = { name: modelName, ...model };
+    let models;
+    if (options.model === '*') { // All models
+        models = Object.values(MODELS).filter(x => x.defaultProvider === provider);
+    } else if (options.model) { // Specific model
+        models = Object.values(MODELS).filter(x => ensureArray(options.model).includes(x.name));
+    } else if (DEFAULT_MODELS[provider]) { // Default model
+        models = [MODELS[DEFAULT_MODELS[provider]]];
+    } else if (options.modelConfig) {
+        models = ensureArray(options.modelConfig);
+    }
+    assert(models.length,
+        `Model name or description is required for provider: ${provider}.`);
     switch (provider) {
         case OPENAI:
             assertApiKey(provider, options);
-            ais.push({
-                id, provider, model, priority: 0, initOrder: ais.length,
-                client: await OpenAI(options),
-                prompt: async (cnt, opts) => await promptOpenAI(id, cnt, opts),
-                embedding: async (i, o) => await createOpenAIEmbedding(id, i, o),
-            });
+            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.`);
-            ais.push({
-                id, provider, model, priority: 0, initOrder: ais.length,
-                client: await AzureOpenAI({
-                    apiVersion: '2025-01-01-preview',
-                    deployment: model.name, ...options,
-                }),
-                prompt: async (cnt, opts) => await promptOpenAI(id, cnt, opts),
+            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.`);
-            ais.push({
-                id, provider, model, priority: 0, initOrder: ais.length,
-                client: await OpenAI(options),
-                prompt: async (cnt, opts) => await promptOpenAI(id, cnt, opts),
-            });
+            var model = models[0];
+            var client = await OpenAI(options);
+            setupAi({ provider, model, client, prompt: promptOpenAI });
             break;
         case GEMINI:
             assertApiKey(provider, options);
             const { GoogleGenerativeAI } = await need('@google/generative-ai');
-            ais.push({
-                id, provider, model, priority: 0, initOrder: ais.length,
-                client: new GoogleGenerativeAI(options.apiKey),
-                prompt: async (cnt, opts) => await promptGemini(id, cnt, opts),
-                embedding: async (i, o) => await createGeminiEmbedding(id, i, o),
-            });
+            var client = new GoogleGenerativeAI(options.apiKey);
+            for (let model of models) {
+                setupAi({
+                    provider, model, client,
+                    prompt: promptGemini, embedding: createGeminiEmbedding,
+                });
+            }
             break;
         case ANTHROPIC:
             assertApiKey(provider, options);
-            const Anthropic = (await need('@anthropic-ai/sdk')).Anthropic;
-            ais.push({
-                id, provider, model, priority: 0, initOrder: ais.length,
-                client: new Anthropic(options),
-                prompt: async (cnt, opts) => await promptAnthropic(id, cnt, opts),
-            });
+            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, `${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.push({
-                id, provider, model, priority: 0, initOrder: ais.length,
-                client: new AnthropicVertex({ region: options?.region || 'us-east5' }),
-                prompt: async (cnt, opts) => await promptAnthropic(id, cnt, opts),
-            });
+            var model = models[0];
+            var client = new ((
+                await need('@anthropic-ai/vertex-sdk')
+            ).AnthropicVertex)({ region: options?.region || 'us-east5' });
+            setupAi({ provider, model, client, prompt: promptAnthropic });
             break;
-        case JINA_DEEPSEARCH:
+        case JINA:
             assertApiKey(provider, options);
-            ais.push({
-                id, provider, model, priority: 0, initOrder: ais.length,
-                client: await OpenAI({
-                    baseURL: 'https://deepsearch.jina.ai/v1/', ...options,
-                }),
-                prompt: async (cnt, opts) => await promptOpenAI(id, cnt, opts),
-                embedding: async (i, o) => await createJinaEmbedding(await OpenAI({
-                    baseURL: 'https://api.jina.ai/v1/', ...options,
-                }), i, o),
-            });
+            var [client, clientEmbedding] = [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,
+                });
+            }
             break;
         case OLLAMA:
             // https://github.com/ollama/ollama/blob/main/docs/openai.md
             const baseURL = 'http://localhost:11434/v1/';
-            ais.push({
-                id, provider, model, priority: 0, initOrder: ais.length,
-                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`, {
-                    method: 'POST', body: JSON.stringify({
-                        model: model.name, prompt: '', keep_alive: -1
-                    })
-                })).text());
-            }, { log: phLog });
+            var client = await OpenAI({ baseURL, apiKey: 'ollama', ...options });
+            for (let model of models) {
+                setupAi({ provider, model, client, prompt: promptOpenAI });
+                ignoreErrFunc(async () => {
+                    phLog(await (await fetch(`${baseURL}completions`, {
+                        method: 'POST', body: JSON.stringify({
+                            model: model.name, prompt: '', keep_alive: -1
+                        })
+                    })).text());
+                }, { log: phLog });
+            }
             break;
         default:
             throwError(`Invalid AI provider: ${options.provider || 'null'}.`);
     }
     ais.sort((a, b) => a.priority - b.priority || a.initOrder - b.initOrder);
-    return ais.find(x => x.id === id);
+    return ais;
+};
+
+const packAi = (ais, options = {}) => {
+    const res = options.basic ? ais.map(x => ({
+        id: x.id, initOrder: x.initOrder, priority: x.priority,
+        provider: x.provider, model: x.model, modelEmbedding: x.modelEmbedding,
+        prompt: !!x.prompt, embedding: !!x.embedding,
+    })) : ais;
+    return options.all ? res : res[0];
 };
 
 const getAi = async (id, options = {}) => {
@@ -472,12 +502,12 @@ const getAi = async (id, options = {}) => {
             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]; }
+        if (best.length) { return packAi(best, options); }
         assert(res.length, 'AI not found.');
         log(`Best match AI not found, fallbacked: ${JSON.stringify(options.select)}.`);
-        return options.all ? res : res[0];
+        return packAi(res, options);
     }
-    const result = options.all ? ais : ais[0];
+    const result = packAi(ais, options);
     assert(result?.length || result?.id, 'AI not found.');
     return result;
 };
@@ -1173,7 +1203,7 @@ const checkEmbeddingInput = async (input, model) => {
     return getInput();
 };
 
-const createOpenAIEmbedding = async (client, input, options) => {
+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
@@ -1182,23 +1212,20 @@ const createOpenAIEmbedding = async (client, input, options) => {
     // 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.
-    String.isString(client) && (client = (await getAi(client)).client);
-    const model = options?.model || DEFAULT_MODELS[OPENAI_EMBEDDING];
-    const resp = await client.embeddings.create({
+    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 createJinaEmbedding = async (client, input, options) =>
-    await createOpenAIEmbedding(client, input, {
-        model: DEFAULT_MODELS[JINA_EMBEDDING], ...options || {}
-    });
-
 const createGeminiEmbedding = async (aiId, input, options) => {
-    const { client } = await getAi(aiId);
-    const model = options?.model || DEFAULT_MODELS[GEMINI_EMEDDING];
-    const resp = await client.getGenerativeModel({ model }).embedContent(
+    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;

package/lib/manifest.mjs

@@ -1,7 +1,7 @@
 const manifest = {
     "name": "utilitas",
     "description": "Just another common utility for JavaScript.",
-    "version": "1999.1.17",
+    "version": "1999.1.19",
     "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": "1999.1.17",
+    "version": "1999.1.19",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",