@tstdl/base 0.92.35 → 0.92.37

package/ai/ai-file.service.d.ts

@@ -20,6 +20,7 @@ export declare class AiFileService implements Resolvable<AiFileServiceArgument>
     private getFile;
     private getFiles;
     private uploadFile;
+    private getBucket;
     private waitForFileActive;
     private waitForFilesActive;
 }

package/ai/ai-file.service.js

@@ -60,6 +60,7 @@ import '../polyfills.js';
 import { stat, unlink, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { Storage } from '@google-cloud/storage';
 import { FileState, GoogleAIFileManager } from '@google/generative-ai/server';
 import { AsyncEnumerable } from '../enumerable/async-enumerable.js';
 import { DetailsError } from '../errors/details.error.js';
@@ -70,14 +71,16 @@ import { createArray } from '../utils/array/array.js';
 import { formatBytes } from '../utils/format.js';
 import { timeout } from '../utils/timing.js';
 import { tryIgnoreAsync } from '../utils/try-ignore.js';
-import { isBlob } from '../utils/type-guards.js';
+import { assertDefinedPass, isBlob, isDefined, isUndefined } from '../utils/type-guards.js';
 import { millisecondsPerSecond } from '../utils/units.js';
 let AiFileService = class AiFileService {
     #options = injectArgument(this);
-    #fileManager = new GoogleAIFileManager(this.#options.apiKey);
+    #fileManager = isUndefined(this.#options.vertex) ? new GoogleAIFileManager(this.#options.apiKey) : undefined;
+    #storage = isDefined(this.#options.vertex) ? new Storage({ projectId: this.#options.vertex.project, apiKey: this.#options.apiKey }) : undefined;
     #fileMap = new Map();
     #fileUriMap = new Map();
     #logger = inject(Logger, 'AiFileService');
+    #bucket;
     async processFile(fileInput) {
         const file = await this.getFile(fileInput);
         this.#fileMap.set(file.id, file);
@@ -100,27 +103,17 @@ let AiFileService = class AiFileService {
     }
     async getFile(fileInput) {
         const id = crypto.randomUUID();
-        const uploadResponse = await this.uploadFile(fileInput, id);
+        const file = await this.uploadFile(fileInput, id);
         this.#logger.verbose(`Processing file "${id}"...`);
-        const response = await this.waitForFileActive(uploadResponse);
-        return {
-            id,
-            name: response.name,
-            uri: response.uri,
-            mimeType: response.mimeType
-        };
+        await this.waitForFileActive(file);
+        return file;
     }
-    async getFiles(files) {
-        const ids = createArray(files.length, () => crypto.randomUUID());
-        const uploadResponses = await AsyncEnumerable.from(files).parallelMap(5, true, async (file, index) => this.uploadFile(file, ids[index])).toArray();
-        this.#logger.verbose(`Processing ${files.length} files...`);
-        const responses = await this.waitForFilesActive(uploadResponses);
-        return responses.map((response, index) => ({
-            id: ids[index],
-            name: response.name,
-            uri: response.uri,
-            mimeType: response.mimeType
-        }));
+    async getFiles(fileInputs) {
+        const ids = createArray(fileInputs.length, () => crypto.randomUUID());
+        const files = await AsyncEnumerable.from(fileInputs).parallelMap(5, true, async (file, index) => this.uploadFile(file, ids[index])).toArray();
+        this.#logger.verbose(`Processing ${fileInputs.length} files...`);
+        await this.waitForFilesActive(files);
+        return files;
     }
     async uploadFile(fileInput, id) {
         const env_1 = { stack: [], error: void 0, hasError: false };
@@ -135,8 +128,23 @@ let AiFileService = class AiFileService {
             }
             const fileSize = isBlob(fileInput) ? fileInput.size : (await stat(path)).size;
             this.#logger.verbose(`Uploading file "${id}" (${formatBytes(fileSize)})...`);
+            if (isDefined(this.#storage)) {
+                const bucket = await this.getBucket();
+                const [file] = await bucket.upload(path, { destination: id, contentType: mimeType });
+                return {
+                    id,
+                    name: id,
+                    uri: file.cloudStorageURI.toString(),
+                    mimeType
+                };
+            }
             const response = await this.#fileManager.uploadFile(path, { mimeType });
-            return response.file;
+            return {
+                id,
+                name: response.file.name,
+                uri: response.file.uri,
+                mimeType: response.file.mimeType
+            };
         }
         catch (e_1) {
             env_1.error = e_1;
@@ -148,24 +156,46 @@ let AiFileService = class AiFileService {
                 await result_1;
         }
     }
-    async waitForFileActive(fileMetadata) {
-        let file = await this.#fileManager.getFile(fileMetadata.name);
-        while (file.state == FileState.PROCESSING) {
+    async getBucket() {
+        if (isUndefined(this.#options.vertex)) {
+            throw new Error('Not using Vertex');
+        }
+        if (isDefined(this.#bucket)) {
+            return this.#bucket;
+        }
+        const bucketName = assertDefinedPass(this.#options.vertex.bucket, 'Bucket not specified');
+        const [exists] = await this.#storage.bucket(bucketName).exists();
+        if (!exists) {
+            const [bucket] = await this.#storage.createBucket(bucketName, {
+                location: this.#options.vertex.location,
+                lifecycle: {
+                    rule: [{
+                            action: { type: 'Delete' },
+                            condition: { age: 1 }
+                        }]
+                }
+            });
+            this.#bucket = bucket;
+        }
+        return this.#bucket;
+    }
+    async waitForFileActive(file) {
+        if (isUndefined(this.#fileManager)) {
+            return;
+        }
+        let state = await this.#fileManager.getFile(file.name);
+        while (state.state == FileState.PROCESSING) {
             await timeout(millisecondsPerSecond);
-            file = await this.#fileManager.getFile(fileMetadata.name);
+            state = await this.#fileManager.getFile(file.name);
         }
-        if (file.state == FileState.FAILED) {
-            throw new DetailsError(file.error?.message ?? `Failed to process file ${file.name}`, file.error?.details);
+        if (state.state == FileState.FAILED) {
+            throw new DetailsError(state.error?.message ?? `Failed to process file ${state.name}`, state.error?.details);
         }
-        return file;
     }
     async waitForFilesActive(files) {
-        const responses = [];
         for (const file of files) {
-            const respones = await this.waitForFileActive(file);
-            responses.push(respones);
+            await this.waitForFileActive(file);
         }
-        return responses;
     }
 };
 AiFileService = __decorate([

package/ai/ai.service.d.ts

@@ -15,6 +15,7 @@ export declare class AiServiceOptions {
     vertex?: {
         project: string;
         location: string;
+        bucket?: string;
     };
     defaultModel?: AiModel;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.35",
+  "version": "0.92.37",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -118,6 +118,7 @@
     "./utils/string": "./utils/string/index.js"
   },
   "dependencies": {
+    "@google-cloud/storage": "^7.15.0",
     "@google-cloud/vertexai": "^1.9.2",
     "disposablestack": "1.1",
     "luxon": "^3.5",