@tstdl/base 0.92.35 → 0.92.36

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

@@ -1,5 +1,5 @@
 import '../polyfills.js';
-import { Resolvable, type resolveArgumentType } from '../injector/interfaces.js';
+import { afterResolve, Resolvable, type resolveArgumentType } from '../injector/interfaces.js';
 import { AiServiceOptions } from './ai.service.js';
 import { FileContentPart, FileInput } from './types.js';
 export type AiFileServiceOptions = Pick<AiServiceOptions, 'apiKey' | 'vertex'>;
@@ -13,6 +13,7 @@ type File = {
 export declare class AiFileService implements Resolvable<AiFileServiceArgument> {
     #private;
     readonly [resolveArgumentType]: AiFileServiceArgument;
+    [afterResolve](): Promise<void>;
     processFile(fileInput: FileInput): Promise<FileContentPart>;
     processFiles(fileInputs: FileInput[]): Promise<FileContentPart[]>;
     getFileById(id: string): File | undefined;

package/ai/ai-file.service.js

@@ -60,24 +60,45 @@ 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';
 import { Singleton } from '../injector/decorators.js';
 import { inject, injectArgument } from '../injector/inject.js';
+import { afterResolve } from '../injector/interfaces.js';
 import { Logger } from '../logger/logger.js';
 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({ apiKey: this.#options.apiKey }) : undefined;
     #fileMap = new Map();
     #fileUriMap = new Map();
     #logger = inject(Logger, 'AiFileService');
+    #bucket;
+    async [afterResolve]() {
+        if (isDefined(this.#options.vertex)) {
+            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, {
+                    lifecycle: {
+                        rule: [{
+                                action: { type: 'Delete' },
+                                condition: { age: 1 }
+                            }]
+                    }
+                });
+                this.#bucket = bucket;
+            }
+        }
+    }
     async processFile(fileInput) {
         const file = await this.getFile(fileInput);
         this.#fileMap.set(file.id, file);
@@ -100,27 +121,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 +146,22 @@ 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.#bucket)) {
+                const [file] = await this.#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 +173,23 @@ let AiFileService = class AiFileService {
                 await result_1;
         }
     }
-    async waitForFileActive(fileMetadata) {
-        let file = await this.#fileManager.getFile(fileMetadata.name);
-        while (file.state == FileState.PROCESSING) {
+    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.36",
   "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",