utilitas 1999.1.60 → 1999.1.62

package/lib/alan.mjs

@@ -5,7 +5,11 @@ import { end, loop } from './event.mjs';
 import { fileTypeFromBuffer } from 'file-type';
 
 import {
-    BASE64, BUFFER, DATAURL, MIME_BINARY, MIME_JSON, MIME_TEXT, STREAM, convert,
+    BASE64, BUFFER, DATAURL, MIME_BINARY, MIME_JSON, MIME_TEXT, MIME_PNG,
+    MIME_JPEG, MIME_MOV, MIME_MPEG, MIME_MP4, MIME_MPG, MIME_AVI, MIME_WMV,
+    MIME_MPEGPS, MIME_FLV, MIME_GIF, MIME_WEBP, MIME_PDF, MIME_AAC, MIME_FLAC,
+    MIME_MP3, MIME_MPEGA, MIME_M4A, MIME_MPGA, MIME_OPUS, MIME_PCM, MIME_WAV,
+    MIME_WEBM, MIME_TGPP, MIME_PCM16, STREAM, convert,
 } from './storage.mjs';
 
 import {
@@ -43,18 +47,6 @@ const _NEED = [
     'js-tiktoken', 'OpenAI',
 ];
 
-const [
-    png, jpeg, mov, mpeg, mp4, mpg, avi, wmv, mpegps, flv, gif, webp, pdf, aac,
-    flac, mp3, mpega, m4a, mpga, opus, pcm, wav, webm, tgpp, pcm16, ogg,
-] = [
-        'image/png', 'image/jpeg', 'video/mov', 'video/mpeg', 'video/mp4',
-        'video/mpg', 'video/avi', 'video/wmv', 'video/mpegps', 'video/x-flv',
-        'image/gif', 'image/webp', 'application/pdf', 'audio/aac', 'audio/flac',
-        'audio/mp3', 'audio/mpeg', 'audio/m4a', 'audio/mpga', 'audio/opus',
-        'audio/pcm', 'audio/wav', 'audio/webm', 'video/3gpp', 'audio/x-wav',
-        'audio/ogg',
-    ];
-
 const [
     OPENAI, GEMINI, OPENAI_TRAINING, OLLAMA, GPT_4O, GPT_O3, GEMINI_25_FLASH,
     NOVA, DEEPSEEK_R1, MD_CODE, TEXT_EMBEDDING_3_SMALL, TEXT_EMBEDDING_3_LARGE,
@@ -112,8 +104,8 @@ const OPENAI_EBD = { ...EBD, maxInputTokens: k(8) - 1 };
 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],
-    supportedAudioTypes: [wav], audio: 'gpt-4o-audio-preview',
+    supportedMimeTypes: [MIME_PNG, MIME_JPEG, MIME_GIF, MIME_WEBP],
+    supportedAudioTypes: [MIME_WAV], audio: 'gpt-4o-audio-preview',
     json: true, tools: true, vision: true, defaultProvider: OPENAI,
 };
 
@@ -124,8 +116,10 @@ const GEMINI_RULES = {
     maxAudioPerPrompt: 1, maxFileSize: m(20), maxImagePerPrompt: 3000,
     maxImageSize: Infinity, maxUrlSize: gb(2), maxVideoLength: minute(45),
     maxVideoPerPrompt: 10, vision: true, supportedMimeTypes: [
-        png, jpeg, mov, mpeg, mp4, mpg, avi, wmv, mpegps, flv, pdf, aac,
-        flac, mp3, mpega, m4a, mpga, opus, pcm, wav, webm, tgpp,
+        MIME_PNG, MIME_JPEG, MIME_MOV, MIME_MPEG, MIME_MP4, MIME_MPG, MIME_AVI,
+        MIME_WMV, MIME_MPEGPS, MIME_FLV, MIME_PDF, MIME_AAC, MIME_FLAC,
+        MIME_MP3, MIME_MPEGA, MIME_M4A, MIME_MPGA, MIME_OPUS, MIME_PCM,
+        MIME_WAV, MIME_WEBM, MIME_TGPP,
     ], defaultProvider: GEMINI,
 };
 
@@ -150,15 +144,16 @@ const MODELS = {
     [GEMMA_3_27B]: {
         contextWindow: kT(128), maxOutputTokens: k(8),
         imageCostTokens: 256, maxImageSize: 896 * 896,
-        supportedMimeTypes: [png, jpeg, gif],
+        supportedMimeTypes: [MIME_PNG, MIME_JPEG, MIME_GIF],
         fast: true, json: true, vision: true,
         defaultProvider: OLLAMA,
     },
     [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, deepsearch: true, defaultProvider: JINA,
+        supportedMimeTypes: [MIME_PNG, MIME_JPEG, MIME_TEXT, MIME_WEBP, MIME_PDF],
+        reasoning: true, json: true, vision: true,
+        deepsearch: true, defaultProvider: JINA,
     },
     [DEEPSEEK_R1]: {
         contextWindow: kT(128), maxOutputTokens: k(8),
@@ -180,7 +175,7 @@ const MODELS = {
         maxDocumentPages: 100, imageCostTokens: ~~(v8k / 750),
         maxImagePerPrompt: Math.min(/*Anthropic:*/100, /*Vertex:*/20),
         maxFileSize: /*Vertex*/m(5), maxImageSize: 2000 * 2000,
-        supportedMimeTypes: [png, jpeg, gif, webp, pdf],
+        supportedMimeTypes: [MIME_PNG, MIME_JPEG, MIME_GIF, MIME_WEBP, MIME_PDF],
         json: true, reasoning: true, tools: true, vision: true,
         defaultProvider: [ANTHROPIC, VERTEX_ANTHROPIC],
     }, // https://docs.anthropic.com/en/docs/build-with-claude/vision
@@ -623,9 +618,9 @@ const buildClaudeMessage = (text, options) => {
     assert(text, 'Text is required.');
     const attachments = (options?.attachments?.length ? options?.attachments : []).map(x => {
         let type = '';
-        if ([pdf].includes(x.mime_type)) {
+        if ([MIME_PDF].includes(x.mime_type)) {
             type = 'document';
-        } else if ([png, jpeg, gif, webp].includes(x.mime_type)) {
+        } else if ([MIME_PNG, MIME_JPEG, MIME_GIF, MIME_WEBP].includes(x.mime_type)) {
             type = 'image';
         } else { throwError(`Unsupported mime type: ${x.mime_type}`); }
         return {
@@ -785,10 +780,13 @@ const buildPrompts = async (model, input, options = {}) => {
     assert(!(
         options.reasoning && !model?.reasoning
     ), `This model does not support reasoning: ${options.model}`);
-    let [systemPrompt, history, content, prompt, _system, _user, _assistant] = [
-        null, null, input || ATTACHMENTS, null, // length hack: ATTACHMENTS
-        { role: system }, { role: user }, { role: assistant },
-    ];
+    let [
+        systemPrompt, history, content, prompt, _system, _model, _assistant,
+        _history,
+    ] = [
+            null, null, input || ATTACHMENTS, null, // length hack: ATTACHMENTS
+            { role: system }, { role: MODEL }, { role: assistant }, null,
+        ];
     options.systemPrompt = options.systemPrompt || INSTRUCTIONS;
     options.attachments = (
         options.attachments?.length ? options.attachments : []
@@ -798,68 +796,71 @@ const buildPrompts = async (model, input, options = {}) => {
     switch (options.flavor) {
         case OPENAI:
             systemPrompt = buildGptMessage(options.systemPrompt, _system);
-            prompt = buildGptMessage(content, options);
             break;
         case ANTHROPIC:
             systemPrompt = options.systemPrompt;
-            prompt = buildClaudeMessage(content, { ...options, cache_control: true });
             break;
         case GEMINI:
             const _role = {
-                role: [GEMINI_20_FLASH].includes(options.model)
-                    ? user : system
+                role: [GEMINI_20_FLASH].includes(options.model) ? user : system
             };
             systemPrompt = buildGeminiHistory(options.systemPrompt, _role);
-            prompt = options.toolsResult?.[options.toolsResult?.length - 1]?.parts
-                || buildGeminiMessage(content, options)
             break;
     }
     const msgBuilder = () => {
-        history = [];
+        [history, _history] = [[], []];
         (options.messages?.length ? options.messages : []).map((x, i) => {
             switch (options.flavor) {
                 case OPENAI:
-                    history.push(buildGptMessage(x.request, _user));
-                    history.push(buildGptMessage(x.response, _assistant));
+                    _history.push(buildGptMessage(x.request));
+                    _history.push(buildGptMessage(x.response, _assistant));
                     break;
                 case ANTHROPIC:
-                    history.push(buildClaudeMessage(x.request, _user));
-                    history.push(buildClaudeMessage(x.response, _assistant));
+                    _history.push(buildClaudeMessage(x.request));
+                    _history.push(buildClaudeMessage(x.response, _assistant));
                     break;
                 case GEMINI:
                     // https://github.com/google/generative-ai-js/blob/main/samples/node/advanced-chat.js
                     // Google's bug: history is not allowed while using inline_data?
                     if (options.attachments?.length) { return; }
-                    history.push(buildGeminiHistory(x.request, _user));
-                    history.push(buildGeminiHistory(x.response, { role: MODEL }));
+                    _history.push(buildGeminiHistory(x.request));
+                    _history.push(buildGeminiHistory(x.response, _model));
                     break;
             }
         });
         switch (options.flavor) {
             case OPENAI:
                 history = messages([
-                    systemPrompt, ...history, prompt,
+                    systemPrompt, ..._history, buildGptMessage(content, options),
                     ...options.toolsResult?.length ? options.toolsResult : []
                 ]);
                 break;
             case ANTHROPIC:
                 history = messages([
-                    ...history, prompt,
-                    ...options.toolsResult?.length ? options.toolsResult : []
+                    ..._history, buildClaudeMessage(content, {
+                        ...options, cache_control: true
+                    }), ...options.toolsResult?.length ? options.toolsResult : []
                 ]);
                 break;
             case GEMINI:
-                history.push(
-                    ...options.toolsResult?.length ? [
-                        buildGeminiHistory(content, { ...options, role: user }),
-                        ...options.toolsResult.slice(0, options.toolsResult.length - 1)
-                    ] : []
-                );
+                [history, prompt] = options.toolsResult?.length ? [
+                    [
+                        ..._history,
+                        buildGeminiHistory(content, options),
+                        ...options.toolsResult.slice(0, options.toolsResult.length - 1),
+                    ],
+                    options.toolsResult[options.toolsResult?.length - 1].parts,
+                ] : [
+                    [..._history],
+                    buildGeminiMessage(content, options),
+                ];
                 break;
         }
     };
     msgBuilder();
-    await trimPrompt(() => [systemPrompt, history, content], () => {
+    await trimPrompt(() => [
+        systemPrompt, _history, content, options.toolsResult
+    ], () => {
         if (options.messages?.length) {
             options.messages?.shift();
             msgBuilder();
@@ -978,11 +979,11 @@ const promptOpenAI = async (aiId, content, options = {}) => {
     const { history }
         = await buildPrompts(MODELS[options.model], content, options);
     model = MODELS[options.model];
-    model.reasoning && !azure && !options.reasoning_effort
+    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'];
+    [options.audioMimeType, options.suffix] = [MIME_PCM16, 'pcm.wav'];
     const resp = await client.chat.completions.create({
         model: azure ? undefined : options.model, ...history,
         ...options.jsonMode ? { response_format: { type: JSON_OBJECT } } : {},
@@ -990,7 +991,7 @@ const promptOpenAI = async (aiId, content, options = {}) => {
         modalities, audio: options.audio || (
             modalities?.find?.(x => x === AUDIO)
             && { voice: DEFAULT_MODELS[OPENAI_VOICE], format: 'pcm16' }
-        ), ...model.tools && !azure ? {
+        ), ...model?.tools && !azure ? {
             tools: options.tools ?? (await toolsOpenAI()).map(x => x.def),
             tool_choice: 'auto',
         } : {}, ...azure ? {} : { store: true }, stream: true,
@@ -1198,7 +1199,7 @@ const promptGemini = async (aiId, content, options = {}) => {
         event?.content?.parts?.map(x => {
             if (x.text) { deltaText = x.text; }
             else if (x.functionCall) { functionCalls.push(x); }
-            else if (x.inlineData?.mimeType === png) {
+            else if (x.inlineData?.mimeType === MIME_PNG) {
                 deltaImages.push(x.inlineData);
                 images.push(x.inlineData);
             }
@@ -1536,6 +1537,7 @@ export {
     MODELS,
     OPENAI_VOICE,
     RETRIEVAL,
+    TEXT_EMBEDDING_3_SMALL,
     analyzeSessions,
     buildGptTrainingCase,
     buildGptTrainingCases,
@@ -1553,18 +1555,10 @@ export {
     getSession,
     init,
     initChat,
-    jpeg,
     listFiles,
     listGptFineTuningEvents,
     listGptFineTuningJobs,
     listOpenAIModels,
-    m4a,
-    mp3,
-    mp4,
-    mpeg,
-    mpega,
-    mpga,
-    ogg,
     prompt,
     promptAnthropic,
     promptGemini,
@@ -1572,10 +1566,7 @@ export {
     resetSession,
     tailGptFineTuningEvents,
     talk,
-    TEXT_EMBEDDING_3_SMALL,
     trimPrompt,
     uploadFile,
     uploadFileForFineTuning,
-    wav,
-    webm,
 };

package/lib/manifest.mjs

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

package/lib/storage.mjs

@@ -27,10 +27,19 @@ const sanitizeFilename = (s, r) => s.replace(/[\/?<>\\:*|"]/g, r || '_').trim();
 const [
     NULL, BASE64, BUFFER, FILE, STREAM, TEXT, _JSON, encoding, BINARY, BLOB,
     DATAURL, mode, dirMode, MIME_TEXT, MIME_BINARY, MIME_JSON, MIME_PNG,
+    MIME_JPEG, MIME_MOV, MIME_MPEG, MIME_MP4, MIME_MPG, MIME_AVI, MIME_WMV,
+    MIME_MPEGPS, MIME_FLV, MIME_GIF, MIME_WEBP, MIME_PDF, MIME_AAC, MIME_FLAC,
+    MIME_MP3, MIME_MPEGA, MIME_M4A, MIME_MPGA, MIME_OPUS, MIME_PCM, MIME_WAV,
+    MIME_WEBM, MIME_TGPP, MIME_PCM16, MIME_OGG,
 ] = [
         'NULL', 'BASE64', 'BUFFER', 'FILE', 'STREAM', 'TEXT', 'JSON', 'utf8',
         'binary', 'BLOB', 'DATAURL', '0644', '0755', 'text/plain',
         'application/octet-stream', 'application/json', 'image/png',
+        'image/jpeg', 'video/mov', 'video/mpeg', 'video/mp4', 'video/mpg',
+        'video/avi', 'video/wmv', 'video/mpegps', 'video/x-flv', 'image/gif',
+        'image/webp', 'application/pdf', 'audio/aac', 'audio/flac', 'audio/mp3',
+        'audio/mpeg', 'audio/m4a', 'audio/mpga', 'audio/opus', 'audio/pcm',
+        'audio/wav', 'audio/webm', 'video/3gpp', 'audio/x-wav', 'audio/ogg',
     ];
 
 const [encodeBase64, encodeBinary, encodeNull]
@@ -473,10 +482,35 @@ export {
     BUFFER,
     DATAURL,
     FILE,
+    MIME_AAC,
+    MIME_AVI,
     MIME_BINARY,
+    MIME_FLAC,
+    MIME_FLV,
+    MIME_GIF,
+    MIME_JPEG,
     MIME_JSON,
+    MIME_M4A,
+    MIME_MOV,
+    MIME_MP3,
+    MIME_MP4,
+    MIME_MPEG,
+    MIME_MPEGA,
+    MIME_MPEGPS,
+    MIME_MPG,
+    MIME_MPGA,
+    MIME_OGG,
+    MIME_OPUS,
+    MIME_PCM,
+    MIME_PCM16,
+    MIME_PDF,
     MIME_PNG,
     MIME_TEXT,
+    MIME_TGPP,
+    MIME_WAV,
+    MIME_WEBM,
+    MIME_WEBP,
+    MIME_WMV,
     STREAM,
     analyzeFile,
     assertPath,

package/package.json

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