utilitas 1999.1.17 → 1999.1.18

package/lib/alan.mjs

@@ -65,8 +65,8 @@ const [
     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,
+    gb, trimTailing, EBD, GEMINI_20_FLASH_EXP, IMAGE, JINA, JINA_DEEPSEARCH,
+    JINA_EMBEDDING, JINA_CLIP,
 ] = [
         'OpenAI', 'Gemini', 'OPENAI_EMBEDDING', 'GEMINI_EMEDDING',
         'OPENAI_TRAINING', 'Ollama', 'gpt-4o-mini', 'gpt-4o', 'o1', 'o3-mini',
@@ -84,7 +84,7 @@ const [
         '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',
+        { embedding: true }, 'gemini-2.0-flash-exp', 'image', 'Jina',
         'jina-deepsearch-v1', 'JINA_EMBEDDING', 'jina-clip-v2',
     ];
 
@@ -92,11 +92,9 @@ 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 +115,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 +126,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 +162,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 +187,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 +206,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,7 +223,7 @@ 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,
@@ -247,7 +249,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 +349,153 @@ const toolsGemini = async () => (await toolsOpenAI()).map(x => ({
     }
 }));
 
+const buildAiId = (provider, model) => [provider, model].map(
+    x => ensureString(x, { case: 'SNAKE' })
+).join('_');
+
 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) {
+                var id = buildAiId(provider, model.name);
+                ais.push({
+                    id, provider, model, priority: 0, initOrder: ais.length, client,
+                    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.`);
+            var model = models[0];
+            var client = await AzureOpenAI({
+                apiVersion: '2025-01-01-preview',
+                deployment: model.name, ...options,
+            });
+            var id = buildAiId(provider, model.name);
             ais.push({
-                id, provider, model, priority: 0, initOrder: ais.length,
-                client: await AzureOpenAI({
-                    apiVersion: '2025-01-01-preview',
-                    deployment: model.name, ...options,
-                }),
+                id, provider, model, priority: 0, initOrder: ais.length, client,
                 prompt: async (cnt, opts) => await promptOpenAI(id, cnt, opts),
             });
             break;
         case AZURE:
             assertApiKey(provider, options);
             assert(options.baseURL, `${provider} api endpoint is required.`);
+            var model = models[0];
+            var client = await OpenAI(options);
+            var id = buildAiId(provider, model.name);
             ais.push({
-                id, provider, model, priority: 0, initOrder: ais.length,
-                client: await OpenAI(options),
+                id, provider, model, priority: 0, initOrder: ais.length, client,
                 prompt: async (cnt, opts) => await promptOpenAI(id, cnt, opts),
             });
             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) {
+                var id = buildAiId(provider, model.name);
+                ais.push({
+                    id, provider, model, priority: 0, initOrder: ais.length, client,
+                    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.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) {
+                var id = buildAiId(provider, model.name);
+                ais.push({
+                    id, provider, model, priority: 0, initOrder: ais.length, client,
+                    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;
+            var model = models[0];
+            var client = new ((
+                await need('@anthropic-ai/vertex-sdk')
+            ).AnthropicVertex)({ region: options?.region || 'us-east5' });
+            var id = buildAiId(provider, model.name);
             ais.push({
-                id, provider, model, priority: 0, initOrder: ais.length,
-                client: new AnthropicVertex({ region: options?.region || 'us-east5' }),
+                id, provider, model, priority: 0, initOrder: ais.length, client: client,
                 prompt: async (cnt, opts) => await promptAnthropic(id, cnt, opts),
             });
             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, ebd] = [await OpenAI({
+                baseURL: 'https://deepsearch.jina.ai/v1/', ...options,
+            }), await OpenAI({
+                baseURL: 'https://api.jina.ai/v1/', ...options,
+            })];
+            for (let model of models) {
+                var id = buildAiId(provider, model.name);
+                ais.push({
+                    id, provider, model, priority: 0, initOrder: ais.length, client,
+                    prompt: async (cnt, opts) => await promptOpenAI(id, cnt, opts),
+                    embedding: async (i, o) => await createJinaEmbedding(ebd, i, o),
+                });
+            }
             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) {
+                var id = buildAiId(provider, model.name);
+                ais.push({
+                    id, provider, model, priority: 0, initOrder: ais.length, client,
+                    prompt: async (cnt, opts) => await promptOpenAI(id, cnt, opts),
+                });
+                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, provider: x.provider, model: x.model, priority: x.priority,
+        initOrder: x.initOrder, prompt: !!x.prompt, embedding: !!x.embedding,
+    })) : ais;
+    return options.all ? res : res[0];
 };
 
 const getAi = async (id, options = {}) => {
@@ -472,12 +515,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;
 };

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.18",
     "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.18",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",