@dataclouder/nest-vertex 0.0.26 → 0.0.28

package/comfyui/controllers/comfy-ui.controller.d.ts

@@ -17,16 +17,13 @@ export declare class ComfyUiController {
     constructor(comfyImageService: ComfyImageService, comfyVideoService: ComfyVideoService, generatedAssetService: GeneratedAssetService, httpService: HttpService, eventEmitter: EventEmitter2);
     generateImage(generateImageDto: ImageGenRequestAdapter): Promise<ImageGenAdapterResponse>;
     generateVideoFromLocalImage(positivePrompt: string, negativePrompt: string): Promise<{
-        message: string;
-        asset: import("../..").GeneratedAsset;
+        prompt_id: string;
     }>;
     generateVideoFromAsset(id: string): Promise<{
-        message: string;
-        asset: import("../..").GeneratedAsset;
+        prompt_id: string;
     }>;
     generateVideoFromUrl(videoUrlRequestDto: VideoUrlRequestDto): Promise<{
-        message: string;
-        asset: import("../..").GeneratedAsset;
+        prompt_id: string;
     }>;
     sse(): Observable<MessageEvent>;
 }

package/comfyui/controllers/comfy-ui.controller.js

@@ -79,16 +79,7 @@ let ComfyUiController = ComfyUiController_1 = class ComfyUiController {
             if (!asset || !asset.assets?.firstFrame?.url) {
                 throw new common_1.NotFoundException(`Asset with id ${id} not found or does not have a valid image url.`);
             }
-            const imageUrl = asset.assets.firstFrame.url;
-            const response = await this.httpService.axiosRef.get(imageUrl, { responseType: 'arraybuffer' });
-            const imageBuffer = Buffer.from(response.data, 'binary');
-            const videoRequest = {
-                workflowPath: path.resolve('./comfy_workflows/video-15_seconds.json'),
-                inputImage: imageBuffer,
-                positivePrompt: 'Faces are smiling',
-                negativePrompt: 'low quality, blurry, static',
-            };
-            const videoResponse = await this.comfyVideoService.runVideoGenerationFromWorkflow(videoRequest, id);
+            const videoResponse = await this.comfyVideoService.runVideoGenerationForAssetId(id);
             this.logger.log(`ComfyUI video generation started. Response: ${JSON.stringify(videoResponse)}`);
             return videoResponse;
         }
@@ -98,13 +89,13 @@ let ComfyUiController = ComfyUiController_1 = class ComfyUiController {
         }
     }
     async generateVideoFromUrl(videoUrlRequestDto) {
-        const { url, positivePrompt, negativePrompt } = videoUrlRequestDto;
+        const { url } = videoUrlRequestDto;
         this.logger.log(`Received request to generate video from url: ${url}`);
         try {
             const newAsset = await this.generatedAssetService.save({
                 assets: { firstFrame: { url } },
             });
-            const videoResponse = await this.comfyVideoService.runVideoGenerationForAssetId(newAsset.id, positivePrompt, negativePrompt);
+            const videoResponse = await this.comfyVideoService.runVideoGenerationForAssetId(newAsset.id);
             this.logger.log(`ComfyUI video generation started. Response: ${JSON.stringify(videoResponse)}`);
             return videoResponse;
         }

package/comfyui/dto/video-generation.dto.d.ts

@@ -0,0 +1,6 @@
+export declare class RunVideoGenerationForAssetIdDto {
+    assetId: string;
+    positivePrompt?: string;
+    negativePrompt?: string;
+    metadata?: any;
+}

package/comfyui/dto/video-generation.dto.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunVideoGenerationForAssetIdDto = void 0;
+class RunVideoGenerationForAssetIdDto {
+    assetId;
+    positivePrompt;
+    negativePrompt;
+    metadata;
+}
+exports.RunVideoGenerationForAssetIdDto = RunVideoGenerationForAssetIdDto;
+//# sourceMappingURL=video-generation.dto.js.map

package/comfyui/models/comfy.models.d.ts

@@ -16,4 +16,7 @@ export interface VideoGenRequest {
     positivePrompt: string;
     negativePrompt: string;
     outputFilenamePrefix?: string;
+    width?: number;
+    height?: number;
+    seconds?: number;
 }

package/comfyui/providers/comfy-services.providers.js

@@ -32,11 +32,11 @@ exports.comfyServicesProviders = [
     },
     {
         provide: comfy_video_service_1.ComfyVideoService,
-        useFactory: (connectionService, httpService, generatedAssetService, cloudStorageService) => {
+        useFactory: (connectionService, httpService, generatedAssetService) => {
             if (!connectionService) {
                 return null;
             }
-            return new comfy_video_service_1.ComfyVideoService(connectionService, httpService, generatedAssetService, cloudStorageService);
+            return new comfy_video_service_1.ComfyVideoService(connectionService, generatedAssetService, httpService);
         },
         inject: [comfy_connection_service_1.ComfyConnectionService, axios_1.HttpService, generated_asset_service_1.GeneratedAssetService, nest_storage_1.CloudStorageService],
     },

package/comfyui/services/comfy-connection.service.d.ts

@@ -29,6 +29,7 @@ export declare class ComfyConnectionService implements OnModuleInit, OnModuleDes
     queuePrompt(workflow: any): Promise<{
         prompt_id: string;
     }>;
+    uploadImage(imageBuffer: Buffer, filename: string): Promise<any>;
     queuePromptAndWait(workflow: any, timeoutMs?: number): Promise<any>;
     getAssetData(filename: string, subfolder: string, type: string): Promise<Buffer>;
 }

package/comfyui/services/comfy-connection.service.js

@@ -23,6 +23,7 @@ const rxjs_1 = require("rxjs");
 const generated_asset_service_1 = require("../../services/generated-asset.service");
 const nest_storage_1 = require("@dataclouder/nest-storage");
 const event_emitter_1 = require("@nestjs/event-emitter");
+const FormData = require("form-data");
 let ComfyConnectionService = ComfyConnectionService_1 = class ComfyConnectionService {
     configService;
     httpService;
@@ -122,8 +123,8 @@ let ComfyConnectionService = ComfyConnectionService_1 = class ComfyConnectionSer
             this.logger.log(`Resolved pending promise for prompt ${prompt_id}.`);
             return;
         }
-        const asset = await this.generatedAssetService.findOneByOperationId(prompt_id);
-        if (!asset) {
+        const generatedAsset = await this.generatedAssetService.findOneByOperationId(prompt_id);
+        if (!generatedAsset) {
             this.logger.warn(`No asset found for prompt_id: ${prompt_id}`);
             return;
         }
@@ -136,26 +137,26 @@ let ComfyConnectionService = ComfyConnectionService_1 = class ComfyConnectionSer
             videoFilename = video.filename;
             this.logger.log(`Found video output: ${videoFilename}`);
             if (videoBuffer) {
-                const uploadResult = await this.cloudStorageService.uploadFileAndMakePublic(process.env.STORAGE_BUCKET, `generated-videos/${asset.id}.mp4`, videoBuffer, 'video/mp4');
+                const uploadResult = await this.cloudStorageService.uploadFileAndMakePublic(process.env.STORAGE_BUCKET, `generated-videos/${generatedAsset.id}.mp4`, videoBuffer, 'video/mp4');
                 this.logger.log(`Successfully uploaded video to: ${uploadResult.url}`);
-                asset.url = uploadResult.url;
-                asset.result = uploadResult;
-                asset.status = 'completed';
-                await this.generatedAssetService.update(asset.id, asset);
-                this.eventEmitter.emit('asset.updated', asset);
+                generatedAsset.url = uploadResult.url;
+                generatedAsset.result = uploadResult;
+                generatedAsset.status = 'completed';
+                await this.generatedAssetService.update(generatedAsset.id, generatedAsset);
+                this.eventEmitter.emit('asset.updated', generatedAsset);
             }
             else {
                 this.logger.error(`No video found in the output for prompt ${prompt_id}.`);
-                asset.status = 'failed';
-                await this.generatedAssetService.update(asset.id, asset);
-                this.eventEmitter.emit('asset.updated', asset);
+                generatedAsset.status = 'failed';
+                await this.generatedAssetService.update(generatedAsset.id, generatedAsset);
+                this.eventEmitter.emit('asset.updated', generatedAsset);
             }
         }
         catch (error) {
             this.logger.error(`Failed to process output for prompt ${prompt_id}:`, error);
-            asset.status = 'failed';
-            await this.generatedAssetService.update(asset.id, asset);
-            this.eventEmitter.emit('asset.updated', asset);
+            generatedAsset.status = 'failed';
+            await this.generatedAssetService.update(generatedAsset.id, generatedAsset);
+            this.eventEmitter.emit('asset.updated', generatedAsset);
         }
     }
     getClient() {
@@ -178,6 +179,16 @@ let ComfyConnectionService = ComfyConnectionService_1 = class ComfyConnectionSer
         };
         return (0, rxjs_1.firstValueFrom)(this.httpService.post(url, payload)).then((res) => res.data);
     }
+    async uploadImage(imageBuffer, filename) {
+        const url = `http://${this.comfyApiHost}/upload/image`;
+        const form = new FormData();
+        form.append('image', imageBuffer, { filename });
+        form.append('overwrite', 'true');
+        const response = await (0, rxjs_1.firstValueFrom)(this.httpService.post(url, form, {
+            headers: form.getHeaders(),
+        }));
+        return response.data;
+    }
     async queuePromptAndWait(workflow, timeoutMs = 300000) {
         const { prompt_id } = await this.queuePrompt(workflow);
         this.logger.log(`Queued prompt with ID: ${prompt_id}. Waiting for execution...`);

package/comfyui/services/comfy-video.service.d.ts

@@ -1,22 +1,18 @@
 import { ComfyConnectionService } from './comfy-connection.service';
-import { VideoGenRequest } from '../models/comfy.models';
-import { HttpService } from '@nestjs/axios';
 import { GeneratedAssetService } from '../../services/generated-asset.service';
-import { CloudStorageService } from '@dataclouder/nest-storage';
-import { GeneratedAsset } from '../../models/generated-asset.entity';
+import { HttpService } from '@nestjs/axios';
+import { VideoGenRequest } from '../models/comfy.models';
 export declare class ComfyVideoService {
-    private readonly connectionService;
-    private readonly httpService;
+    private readonly comfyConnectionService;
     private readonly generatedAssetService;
-    private readonly cloudStorageService;
+    private readonly httpService;
     private readonly logger;
-    constructor(connectionService: ComfyConnectionService, httpService: HttpService, generatedAssetService: GeneratedAssetService, cloudStorageService: CloudStorageService);
-    runVideoGenerationFromWorkflow(request: VideoGenRequest, generatedAssetId?: string): Promise<{
-        message: string;
-        asset: GeneratedAsset;
+    constructor(comfyConnectionService: ComfyConnectionService, generatedAssetService: GeneratedAssetService, httpService: HttpService);
+    updateWorkflow(width: number, height: number, seconds: number): Promise<any>;
+    runVideoGenerationFromWorkflow(videoRequest: VideoGenRequest, assetId?: string): Promise<{
+        prompt_id: string;
     }>;
-    runVideoGenerationForAssetId(assetId: string, positivePrompt: string, negativePrompt: string): Promise<{
-        message: string;
-        asset: GeneratedAsset;
+    runVideoGenerationForAssetId(assetId: string): Promise<{
+        prompt_id: string;
     }>;
 }

package/comfyui/services/comfy-video.service.js

@@ -15,86 +15,64 @@ const common_1 = require("@nestjs/common");
 const fs = require("fs/promises");
 const path = require("path");
 const comfy_connection_service_1 = require("./comfy-connection.service");
-const axios_1 = require("@nestjs/axios");
 const generated_asset_service_1 = require("../../services/generated-asset.service");
-const nest_storage_1 = require("@dataclouder/nest-storage");
+const axios_1 = require("@nestjs/axios");
 let ComfyVideoService = ComfyVideoService_1 = class ComfyVideoService {
-    connectionService;
-    httpService;
+    comfyConnectionService;
     generatedAssetService;
-    cloudStorageService;
+    httpService;
     logger = new common_1.Logger(ComfyVideoService_1.name);
-    constructor(connectionService, httpService, generatedAssetService, cloudStorageService) {
-        this.connectionService = connectionService;
-        this.httpService = httpService;
+    constructor(comfyConnectionService, generatedAssetService, httpService) {
+        this.comfyConnectionService = comfyConnectionService;
         this.generatedAssetService = generatedAssetService;
-        this.cloudStorageService = cloudStorageService;
-        if (!connectionService) {
-            this.logger.warn('ComfyConnectionService not available. ComfyVideoService will not be initialized.');
+        this.httpService = httpService;
+    }
+    async updateWorkflow(width, height, seconds) {
+        const workflowPath = path.join(process.cwd(), 'comfy_workflows', 'video-15_seconds.json');
+        const workflowData = await fs.readFile(workflowPath, 'utf-8');
+        const workflow = JSON.parse(workflowData);
+        if (workflow['84']) {
+            workflow['84'].inputs.width = width;
+            workflow['84'].inputs.height = height;
+        }
+        if (workflow['63']) {
+            const lengthInFrames = seconds * 16 + 1;
+            workflow['63'].inputs.length = lengthInFrames;
         }
+        return workflow;
     }
-    async runVideoGenerationFromWorkflow(request, generatedAssetId = null) {
-        this.logger.log(`Starting video generation with workflow: ${request.workflowPath} for asset ${generatedAssetId}`);
-        let asset;
-        try {
-            asset = await this.generatedAssetService.findOne(generatedAssetId);
-            if (!asset) {
-                throw new Error('GeneratedAsset not found');
-            }
-            const host = this.connectionService.getComfyApiHost();
-            const formData = new FormData();
-            const uniqueFilename = `input_${Date.now()}.png`;
-            formData.append('image', new Blob([request.inputImage]), uniqueFilename);
-            formData.append('overwrite', 'true');
-            const uploadResponse = await fetch(`http://${host}/upload/image`, {
-                method: 'POST',
-                body: formData,
-            });
-            if (!uploadResponse.ok) {
-                throw new Error(`Failed to upload image: ${await uploadResponse.text()}`);
-            }
-            const uploadedImage = await uploadResponse.json();
-            this.logger.log(`Successfully uploaded image: ${uploadedImage.name}`);
-            const workflowJson = await fs.readFile(request.workflowPath, 'utf-8');
-            const workflow = JSON.parse(workflowJson);
-            workflow['6'].inputs.text = request.positivePrompt;
-            workflow['7'].inputs.text = request.negativePrompt;
-            workflow['62'].inputs.image = uploadedImage.name;
-            if (request.outputFilenamePrefix) {
-                workflow['90'].inputs.filename_prefix = request.outputFilenamePrefix;
-            }
-            const response = await this.connectionService.queuePrompt(workflow);
-            this.logger.log(`Workflow queued, received prompt id: ${response.prompt_id}`);
-            asset.operationId = response.prompt_id;
-            await this.generatedAssetService.partialUpdate(asset.id, { operationId: response.prompt_id });
-            return {
-                message: 'Video generation workflow has been queued successfully.',
-                asset,
-            };
+    async runVideoGenerationFromWorkflow(videoRequest, assetId) {
+        const { inputImage, positivePrompt, negativePrompt } = videoRequest;
+        const workflow = await this.updateWorkflow(videoRequest.width, videoRequest.height, videoRequest.seconds);
+        workflow['6'].inputs.text = positivePrompt;
+        workflow['7'].inputs.text = negativePrompt;
+        const uploadResponse = await this.comfyConnectionService.uploadImage(inputImage, 'input_image.jpg');
+        const imageName = uploadResponse.name;
+        if (workflow['62']) {
+            workflow['62'].inputs.image = imageName;
         }
-        catch (error) {
-            this.logger.error('Error during video generation from workflow:', error.message || error, error.stack);
-            if (asset) {
-                asset.status = 'failed';
-                await this.generatedAssetService.partialUpdate(asset.id, { status: 'failed' });
-            }
-            throw new common_1.InternalServerErrorException(`Failed to run video generation workflow: ${error.message}`);
+        const response = await this.comfyConnectionService.queuePrompt(workflow);
+        if (assetId) {
+            await this.generatedAssetService.update(assetId, { operationId: response.prompt_id });
         }
+        return response;
     }
-    async runVideoGenerationForAssetId(assetId, positivePrompt, negativePrompt) {
-        this.logger.log(`Starting video generation for asset id: ${assetId}`);
-        const asset = await this.generatedAssetService.findOne(assetId);
-        if (!asset || !asset.assets?.firstFrame?.url) {
+    async runVideoGenerationForAssetId(assetId) {
+        const genAsset = await this.generatedAssetService.findOne(assetId);
+        if (!genAsset || !genAsset.assets?.firstFrame?.url) {
             throw new common_1.NotFoundException(`Asset with id ${assetId} not found or does not have a valid image url.`);
         }
-        const imageUrl = asset.assets.firstFrame.url;
+        const imageUrl = genAsset.assets.firstFrame.url;
         const response = await this.httpService.axiosRef.get(imageUrl, { responseType: 'arraybuffer' });
         const imageBuffer = Buffer.from(response.data, 'binary');
         const videoRequest = {
-            workflowPath: path.resolve('./comfy_workflows/video-15_seconds.json'),
+            workflowPath: path.join(process.cwd(), 'comfy_workflows', 'video-15_seconds.json'),
             inputImage: imageBuffer,
-            positivePrompt: positivePrompt || 'Faces are smiling',
-            negativePrompt: negativePrompt || 'low quality, blurry, static',
+            positivePrompt: genAsset.prompt || genAsset?.description || 'Random movement for video',
+            negativePrompt: 'low quality, blurry, static',
+            width: genAsset.request?.width || null,
+            height: genAsset.request?.height || null,
+            seconds: genAsset.request?.seconds || null,
         };
         return this.runVideoGenerationFromWorkflow(videoRequest, assetId);
     }
@@ -103,8 +81,7 @@ exports.ComfyVideoService = ComfyVideoService;
 exports.ComfyVideoService = ComfyVideoService = ComfyVideoService_1 = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [comfy_connection_service_1.ComfyConnectionService,
-        axios_1.HttpService,
         generated_asset_service_1.GeneratedAssetService,
-        nest_storage_1.CloudStorageService])
+        axios_1.HttpService])
 ], ComfyVideoService);
 //# sourceMappingURL=comfy-video.service.js.map

package/models/generated-asset.entity.d.ts

@@ -19,6 +19,7 @@ export declare class GeneratedAsset implements IGeneratedAsset {
     result: CloudFileStorage;
     name: string;
     description: string;
+    metadata: any;
 }
 export declare const GeneratedAssetSchema: import("mongoose").Schema<GeneratedAsset, import("mongoose").Model<GeneratedAsset, any, any, any, Document<unknown, any, GeneratedAsset, any> & GeneratedAsset & Required<{
     _id: string;

package/models/generated-asset.entity.js

@@ -29,6 +29,7 @@ let GeneratedAsset = class GeneratedAsset {
     result;
     name;
     description;
+    metadata;
 };
 exports.GeneratedAsset = GeneratedAsset;
 __decorate([
@@ -91,6 +92,10 @@ __decorate([
     (0, mongoose_1.Prop)({ required: false }),
     __metadata("design:type", String)
 ], GeneratedAsset.prototype, "description", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ required: false, type: Object }),
+    __metadata("design:type", Object)
+], GeneratedAsset.prototype, "metadata", void 0);
 exports.GeneratedAsset = GeneratedAsset = __decorate([
     (0, mongoose_1.Schema)({ collection: 'generated_assets' })
 ], GeneratedAsset);

package/models/generated-asset.model.d.ts

@@ -24,4 +24,5 @@ export interface IGeneratedAsset {
     status: 'pending' | 'completed' | 'failed';
     assets: IAssetsGeneration;
     result: CloudFileStorage;
+    metadata: any;
 }

package/models/google-voices.js

@@ -90,10 +90,6 @@ exports.DefaultBestVoice = {
         female: 'es-US-Neural2-A',
         male: 'es-US-Studio-B',
     },
-    it: {
-        female: 'it-IT-Standard-E',
-        male: 'it-IT-Neural2-F',
-    },
     pt: {
         female: 'pt-BR-Neural2-C',
         male: 'pt-BR-Chirp3-HD-Fenrir',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dataclouder/nest-vertex",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "description": "NestJS Vertex AI library for Dataclouder",
   "author": "dataclouder",
   "license": "MIT",

package/services/adapter-audio-gen.service.d.ts

@@ -1,10 +1,8 @@
 import { NestTtsService } from './vertex-tts.service';
-import { AudioGenRequestAdapter, AudioGenAdapterResponse } from '../models/adapter.models';
 import { google } from '@google-cloud/text-to-speech/build/protos/protos';
 export declare class AudioGenAdapterService {
     private nestTtsService;
     private readonly logger;
     constructor(nestTtsService: NestTtsService);
     listVoices(provider?: string, languageCode?: string): Promise<google.cloud.texttospeech.v1.IVoice[]>;
-    generateAudio(audioDto: AudioGenRequestAdapter): Promise<AudioGenAdapterResponse>;
 }

package/services/adapter-audio-gen.service.js

@@ -28,20 +28,6 @@ let AudioGenAdapterService = AudioGenAdapterService_1 = class AudioGenAdapterSer
             return [];
         }
     }
-    async generateAudio(audioDto) {
-        if (audioDto.provider === 'google' || !audioDto.provider) {
-            const audioBuffer = await this.nestTtsService.synthesizeSpeech(audioDto);
-            return {
-                audio: audioBuffer,
-                mimeType: 'audio/mpeg',
-                provider: 'google',
-            };
-        }
-        else {
-            this.logger.error(`Provider ${audioDto.provider} not supported for audio generation.`);
-            throw new Error(`Provider ${audioDto.provider} not supported for audio generation.`);
-        }
-    }
 };
 exports.AudioGenAdapterService = AudioGenAdapterService;
 exports.AudioGenAdapterService = AudioGenAdapterService = AudioGenAdapterService_1 = __decorate([

package/services/vertex-gemini-chat.service.js

@@ -138,7 +138,7 @@ let GeminiChatService = GeminiChatService_1 = class GeminiChatService {
                     this.logger.error(`Gemini chat.sendMessage failed: Service Unavailable ${model} - ${balancedKey?.name} con clave ${balancedKey?.apiKey}`);
                     await this.keyBalancer.recordFailedRequest(balancedKey.id, error, key_balancer_models_1.ModelType.LLM, model, 40);
                     throw new nest_core_1.AppException({
-                        error_message: `Parece que fue demasiado con la misma clave, invalidar ${balancedKey?.name} clave ${balancedKey?.apiKey} por unos minutos.`,
+                        error_message: `Problema de Google, No puede procesar la solicitud, invalidar ${balancedKey?.name} clave ${balancedKey?.apiKey} por unos segundos.`,
                         explanation: error.message,
                     });
                 }

package/services/vertex-image.service.js

@@ -37,27 +37,32 @@ let ImageVertexService = ImageVertexService_1 = class ImageVertexService {
     async _getGenAiClient(model, tierType = null) {
         let apiKey;
         let keyId;
+        let availableKey = null;
         if (this.gemini_key) {
             apiKey = this.gemini_key;
             keyId = 'local';
         }
         else {
-            const key = await this.keyBalancerApiService.getImageKey(model, tierType || 'tier 1');
-            if (key?.error === 'RateLimited') {
+            availableKey = await this.keyBalancerApiService.getImageKey(model, tierType || 'tier 1');
+            if (availableKey === null) {
+                this.logger.error('KEY BALANCER IS DOWN: :::: No available API key from key balancer.');
+            }
+            if (availableKey?.error === 'RateLimited') {
                 this.logger.error('No available API key from key balancer.');
                 throw new Error('RateLimited');
             }
-            if (!key || key?.error) {
+            if (!availableKey || availableKey?.error) {
                 this.logger.error('No available API key from key balancer.');
                 throw new Error('Not available API key');
             }
-            apiKey = key.apiKey;
-            keyId = key.id;
+            apiKey = availableKey.apiKey;
+            keyId = availableKey.id;
         }
         return {
             client: new genai_1.GoogleGenAI({ apiKey }),
             keyId,
             model,
+            availableKey,
         };
     }
     async startImageGeneration(generateImageDto) {
@@ -150,8 +155,23 @@ let ImageVertexService = ImageVertexService_1 = class ImageVertexService {
             if (error instanceof nest_core_1.AppException) {
                 throw error;
             }
-            this.logger.error(`startImageGenerationAdapter() Model: ${genAiClient.model} 🔑 KeyId: ${genAiClient.keyId} Error:`, error.message || error);
-            throw error + ' 📝 ' + genAiClient.model + '🔑' + genAiClient.keyId;
+            if (error.name === 'ApiError') {
+                console.log(error);
+                error = JSON.parse(error.message);
+                console.log(error.error);
+                throw new nest_core_1.AppException({
+                    error_message: `Error ${error?.error?.code} De Google ${error?.error?.message} con  Model: ${genAiClient.model} 🔑 KeyId: ${genAiClient.availableKey.apiKey} Alias: ${genAiClient.availableKey.name} `,
+                    explanation: JSON.stringify(error?.error?.details),
+                });
+            }
+            if (error.status === 400) {
+                throw new nest_core_1.AppException({
+                    error_message: `Error 400, la llave probablemente no tiene permisos o saldo.  Model: ${genAiClient.model} 🔑 KeyId: ${genAiClient.availableKey.apiKey} ${genAiClient.availableKey.name}`,
+                    explanation: error.message,
+                });
+            }
+            this.logger.error(`startImageGenerationAdapter() Model: ${genAiClient.model} 🔑 KeyId: ${genAiClient.availableKey.apiKey} ${genAiClient.availableKey.name} Error:`, error.message || error);
+            throw error + ' 📝 ' + genAiClient.model + '🔑' + genAiClient.availableKey.apiKey + ' ' + genAiClient.availableKey.name;
         }
     }
 };