utilitas 1999.1.63 → 1999.1.65

package/lib/alan.mjs

@@ -3,13 +3,14 @@ import { create as createUoid } from './uoid.mjs';
 import { createWavHeader } from './media.mjs';
 import { end, loop } from './event.mjs';
 import { fileTypeFromBuffer } from 'file-type';
+import { v4 as uuidv4 } from 'uuid';
 
 import {
     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,
+    MIME_WEBM, MIME_TGPP, MIME_PCM16, STREAM, convert, formatDataURL
 } from './storage.mjs';
 
 import {
@@ -105,6 +106,7 @@ const OPENAI_RULES = {
     imageCostTokens: ~~(OPENAI_HI_RES_SIZE / (512 * 512) * 170 + 85),
     maxFileSize: m(20), maxImageSize: OPENAI_HI_RES_SIZE,
     supportedMimeTypes: [MIME_PNG, MIME_JPEG, MIME_GIF, MIME_WEBP],
+    supportedDocTypes: [MIME_PDF],
     supportedAudioTypes: [MIME_WAV], audio: 'gpt-4o-audio-preview',
     json: true, tools: true, vision: true, defaultProvider: OPENAI,
 };
@@ -187,6 +189,8 @@ for (const n in MODELS) {
     MODELS[n]['name'] = n;
     if (!MODELS[n].embedding) {
         MODELS[n].supportedMimeTypes = MODELS[n].supportedMimeTypes || [];
+        MODELS[n].supportedDocTypes = MODELS[n].supportedDocTypes || [];
+        MODELS[n].supportedAudioTypes = MODELS[n].supportedAudioTypes || [];
         MODELS[n].maxOutputTokens = MODELS[n].maxOutputTokens
             || Math.ceil(MODELS[n].contextWindow * 0.4);
         MODELS[n].maxInputTokens = MODELS[n].maxInputTokens
@@ -556,12 +560,22 @@ const countTokens = async (input, options) => {
     );
 };
 
+const selectGptVisionModel = options => {
+    assert(
+        MODELS[options.model]?.vision,
+        `Vision modality is not supported by model: ${options.model}`
+    );
+    return String.isString(MODELS[options.model].vision)
+        ? MODELS[options.model].vision : null;
+};
+
 const selectGptAudioModel = options => {
     assert(
         MODELS[options.model]?.audio,
         `Audio modality is not supported by model: ${options.model}`
     );
-    return MODELS[options.model]?.audio;
+    return String.isString(MODELS[options.model]?.audio)
+        ? MODELS[options.model]?.audio : null;
 };
 
 const buildGptMessage = (content, options) => {
@@ -570,10 +584,22 @@ const buildGptMessage = (content, options) => {
     const attachments = (options?.attachments || []).map(x => {
         assert(MODELS[options?.model], 'Model is required.');
         if (MODELS[options.model]?.supportedMimeTypes?.includes?.(x.mime_type)) {
-            if (String.isString(MODELS[options.model]?.vision)) {
-                alterModel = MODELS[options.model]?.vision;
-            }
-            return { type: 'image_url', image_url: { url: x.url, detail: 'high' } };
+            alterModel = selectGptVisionModel(options); // URL or Base64URL
+            return {
+                type: 'image_url',
+                image_url: { url: x.url, detail: 'high' },
+            };
+        } else if (MODELS[options.model]?.supportedDocTypes?.includes?.(x.mime_type)) {
+            alterModel = selectGptVisionModel(options);
+            print(formatDataURL(x.mime_type, x.data));
+            return {
+                type: 'file',
+                file: {
+                    file_data: formatDataURL(x.mime_type, x.data),
+                    filename: x.file_name
+                        || `${uuidv4()}.${x.mime_type.split('/')[1]}`,
+                },
+            };
         } else if (MODELS[options.model]?.supportedAudioTypes?.includes?.(x.mime_type)) {
             alterModel = selectGptAudioModel(options);
             return {
@@ -791,7 +817,9 @@ const buildPrompts = async (model, input, options = {}) => {
     options.attachments = (
         options.attachments?.length ? options.attachments : []
     ).filter(x => [
-        ...model?.supportedMimeTypes || [], ...model.supportedAudioTypes || []
+        ...model?.supportedMimeTypes,
+        ...model?.supportedDocTypes,
+        ...model?.supportedAudioTypes,
     ].includes(x.mime_type));
     switch (options.flavor) {
         case OPENAI:

package/lib/gen.mjs

@@ -1,8 +1,9 @@
 import {
-    ensureArray, ensureString, log as _log, need, throwError, tryUntil,
+    ensureArray, ensureString, ignoreErrFunc, log as _log, need, throwError,
+    tryUntil,
 } from './utilitas.mjs';
 
-import { assertCommand, exec } from './shell.mjs';
+import { assertExist, exec } from './shell.mjs';
 import { convert, MIME_PNG } from './storage.mjs';
 import { createReadStream } from 'fs';
 
@@ -180,12 +181,13 @@ const image = async (prompt, options) => {
 };
 
 const getGeminiAccessToken = async (credentials) => {
-    await assertCommand('gcloud');
-    const actResp = await exec(
-        `gcloud auth activate-service-account --key-file=${credentials}`,
+    const bin = 'gcloud';
+    await assertExist(bin);
+    const actResp = await ignoreErrFunc(async () => await exec(
+        `${bin} auth activate-service-account --key-file=${credentials}`,
         { acceptError: true }
-    );
-    assert(actResp.includes('Activated service account credentials'),
+    ), { log: true });
+    assert(actResp?.includes?.('Activated service account credentials'),
         'Failed to activate service account credentials.', 500);
     const tokResp = (await exec(`gcloud auth print-access-token`)).trim();
     assert(tokResp, 'Failed to get access token.', 500);

package/lib/manifest.mjs

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

package/lib/shell.mjs

@@ -30,4 +30,4 @@ const assertExist = async (bin, er, code = 500) => {
 };
 
 export default exec;
-export { assertCommand, assertExist, exec, exist, which };
+export { assertExist, exec, exist, which };

package/lib/storage.mjs

@@ -23,6 +23,7 @@ const mapFilename = name => join(name.substr(0, 2), name.substr(2, 2));
 const [_zip, _unzip] = [__zip, __unzip].map(promisify);
 const log = content => _log(content, import.meta.url);
 const sanitizeFilename = (s, r) => s.replace(/[\/?<>\\:*|"]/g, r || '_').trim();
+const formatDataURL = (mt, b64) => `data:${mt};${BASE64.toLowerCase()},${b64}`;
 
 const [
     NULL, BASE64, BUFFER, FILE, STREAM, TEXT, _JSON, encoding, BINARY, BLOB,
@@ -175,7 +176,7 @@ const encodeBase64DataURL = async (mime, buffer) => {
     ) || MIME_BINARY;
     assert(mime, 'MIME type is required.', 400);
     assert(Buffer.isBuffer(buffer), 'Data buffer is required.', 400);
-    return `data:${mime};${BASE64},${base64Encode(buffer, true)}`;
+    return formatDataURL(mime, base64Encode(buffer, true));
 };
 
 const decodeBase64DataURL = dataUrl => {
@@ -524,6 +525,7 @@ export {
     encodeBase64DataURL,
     exists,
     existsOnCloud,
+    formatDataURL,
     getConfig,
     getConfigFilename,
     getGcUrlByBucket,
@@ -548,5 +550,5 @@ export {
     writeFile,
     writeJson,
     writeTempFile,
-    zip
+    zip,
 };

package/package.json

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