utilitas 1999.1.59 → 1999.1.61

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 {
@@ -982,7 +977,7 @@ const promptOpenAI = async (aiId, content, options = {}) => {
         && (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 } } : {},
@@ -1198,7 +1193,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 +1531,7 @@ export {
     MODELS,
     OPENAI_VOICE,
     RETRIEVAL,
+    TEXT_EMBEDDING_3_SMALL,
     analyzeSessions,
     buildGptTrainingCase,
     buildGptTrainingCases,
@@ -1553,18 +1549,10 @@ export {
     getSession,
     init,
     initChat,
-    jpeg,
     listFiles,
     listGptFineTuningEvents,
     listGptFineTuningJobs,
     listOpenAIModels,
-    m4a,
-    mp3,
-    mp4,
-    mpeg,
-    mpega,
-    mpga,
-    ogg,
     prompt,
     promptAnthropic,
     promptGemini,
@@ -1572,10 +1560,7 @@ export {
     resetSession,
     tailGptFineTuningEvents,
     talk,
-    TEXT_EMBEDDING_3_SMALL,
     trimPrompt,
     uploadFile,
     uploadFileForFineTuning,
-    wav,
-    webm,
 };

package/lib/gen.mjs

@@ -1,9 +1,10 @@
 import {
-    ensureString, log as _log, need, throwError, tryUntil,
+    ensureArray, ensureString, log as _log, need, throwError, tryUntil,
 } from './utilitas.mjs';
 
-import { convert, MIME_PNG } from './storage.mjs';
 import { assertCommand, exec } from './shell.mjs';
+import { convert, MIME_PNG } from './storage.mjs';
+import { createReadStream } from 'fs';
 
 const _NEED = ['OpenAI'];
 const log = (cnt, opt) => _log(cnt, import.meta.url, { time: 1, ...opt || {} });
@@ -25,7 +26,10 @@ const init = async (options) => {
         case OPENAI:
             const OpenAI = await need('openai');
             const openai = new OpenAI(options);
-            clients[provider] = openai.images;
+            clients[provider] = {
+                image: openai.images,
+                toFile: OpenAI.toFile,
+            };
             break;
         case GEMINI:
             clients[provider] = {
@@ -48,6 +52,19 @@ const extractVideo = async (data, options) => await convert(
     data, { input: BASE64, suffix: 'mp4', ...options || {} }
 );
 
+const prepareImage = async (files, repack, options) => {
+    if (!files) { return }
+    const multiple = Array.isArray(files);
+    files = ensureArray(files);
+    const resp = await Promise.all(files.map(async x => await repack(
+        createReadStream(await convert(
+            x, { expected: 'FILE', ...options || {} }
+        )), null, { type: MIME_PNG } // don't need to be right MIME type
+    )));
+    return multiple ? resp : resp[0];
+};
+
+
 const image = async (prompt, options) => {
     let provider = ensureString(options?.provider, { case: 'UP' });
     if (!provider && clients?.[GEMINI]?.apiKey) { provider = GEMINI; }
@@ -64,19 +81,29 @@ const image = async (prompt, options) => {
     };
     switch (provider) {
         case OPENAI:
+            let [func, extraOptions] = ['generate', {}];
+            if (options?.reference || options?.mask) {
+                func = 'edit';
+                extraOptions = {
+                    image: await prepareImage(options?.reference, client.toFile, options),
+                    mask: await prepareImage(options?.mask, client.toFile, options),
+                };
+            }
             try { // https://platform.openai.com/docs/guides/image-generation?image-generation-model=gpt-image-1
-                var resp = await client.generate({
+                var resp = await client.image[func]({
                     prompt, model: OPENAI_MODEL, n, quality: 'high',
                     size: '1536x1024', moderation: 'low',
                     // 1024x1024 (square), 1536x1024 (landscape), 1024x1536 (portrait), auto (default)
                     // background: 'transparent',
-                    ...options?.params || {},
+                    ...extraOptions, ...options?.params || {},
                 });
             } catch (err) { throwError(err?.message || ERROR_GENERATING); }
             if (!options?.raw) {
                 resp.data = await Promise.all(resp.data.map(async x => ({
                     caption: `🎨 by ${OPENAI_MODEL}`,
-                    data: await extractImage(x.b64_json, options),
+                    data: await extractImage(x.b64_json, {
+                        ...options || {}, input: BASE64,
+                    }),
                     mimeType: MIME_PNG,
                 })));
             }

package/lib/manifest.mjs

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