@dataclouder/nest-vertex 0.0.35 → 0.0.37

package/controllers/vertex-gemini-chat.controller.js

@@ -27,7 +27,7 @@ let GeminiChatController = GeminiChatController_1 = class GeminiChatController {
     async generateText(generateTextDto) {
         this.logger.log(`Received request for text generation with keyType: ${generateTextDto.keyType}`);
         try {
-            const result = await this.geminiChatService.chat(generateTextDto.messages, undefined, generateTextDto.keyType);
+            const result = await this.geminiChatService.chat(generateTextDto.messages, undefined, generateTextDto?.keyType);
             return result;
         }
         catch (error) {

package/models/adapter.models.d.ts

@@ -1,4 +1,5 @@
 import { SynthesizeSpeechInput } from '../services/vertex-tts.service';
+import { TierType } from './key-balancer.models';
 export interface IModelAdapterMethods {
     listModels(): Promise<Record<string, string>[]>;
     generate(imageDto: any): Promise<any>;
@@ -18,7 +19,7 @@ export interface ChatLLMRequestAdapter {
     provider?: string;
     model?: IAIModel;
     returnJson?: boolean;
-    keyType?: string;
+    keyType?: TierType;
 }
 export declare class ChatMessageDict {
     content: string;

package/models/key-balancer.models.d.ts

@@ -5,7 +5,8 @@ export declare enum TierType {
 }
 export declare enum ModelType {
     LLM = "llm",
-    IMAGE = "image"
+    IMAGE = "image",
+    VIDEO = "video"
 }
 export interface IKeyBalancer {
     _id?: string;

package/models/key-balancer.models.js

@@ -10,5 +10,6 @@ var ModelType;
 (function (ModelType) {
     ModelType["LLM"] = "llm";
     ModelType["IMAGE"] = "image";
+    ModelType["VIDEO"] = "video";
 })(ModelType || (exports.ModelType = ModelType = {}));
 //# sourceMappingURL=key-balancer.models.js.map

package/nest-vertex.module.js

@@ -34,6 +34,7 @@ const key_balancer_api_service_1 = require("./services/key-balancer-api.service"
 const comfyui_module_1 = require("./comfyui/comfyui.module");
 const vertex_veo_genai_service_1 = require("./services/vertex-veo-genai.service");
 const vertex_veo_video_controller_1 = require("./controllers/vertex-veo-video.controller");
+const google_genai_service_1 = require("./services/google-genai.service");
 let NestVertexModule = class NestVertexModule {
 };
 exports.NestVertexModule = NestVertexModule;
@@ -59,6 +60,7 @@ exports.NestVertexModule = NestVertexModule = __decorate([
             generated_asset_service_1.GeneratedAssetService,
             key_balancer_api_service_1.KeyBalancerApiService,
             vertex_veo_genai_service_1.VertexVeoGenaiService,
+            google_genai_service_1.GoogleGenaiService,
         ],
         exports: [
             vertex_image_video_service_1.VertexImageVideoService,
@@ -73,6 +75,7 @@ exports.NestVertexModule = NestVertexModule = __decorate([
             generated_asset_service_1.GeneratedAssetService,
             key_balancer_api_service_1.KeyBalancerApiService,
             vertex_veo_genai_service_1.VertexVeoGenaiService,
+            google_genai_service_1.GoogleGenaiService,
             comfyui_module_1.ComfyUIModule,
         ],
         controllers: [

package/package.json

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

package/services/google-genai.service.d.ts

@@ -0,0 +1,13 @@
+import { GoogleGenAI } from '@google/genai';
+import { AvailableKeyResult, ModelType, TierType } from '../models/key-balancer.models';
+import { KeyBalancerApiService } from './key-balancer-api.service';
+export declare class GoogleGenaiService {
+    private readonly keyBalancer;
+    private readonly logger;
+    private readonly defaultApiKey;
+    constructor(keyBalancer: KeyBalancerApiService);
+    getGoogleGenAIClient(modelName: string, keyTierType?: TierType, modelType?: ModelType): Promise<{
+        client: GoogleGenAI;
+        balancedKey?: AvailableKeyResult;
+    }>;
+}

package/services/google-genai.service.js

@@ -0,0 +1,53 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var GoogleGenaiService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleGenaiService = void 0;
+const common_1 = require("@nestjs/common");
+const genai_1 = require("@google/genai");
+const nest_core_1 = require("@dataclouder/nest-core");
+const key_balancer_api_service_1 = require("./key-balancer-api.service");
+let GoogleGenaiService = GoogleGenaiService_1 = class GoogleGenaiService {
+    keyBalancer;
+    logger = new common_1.Logger(GoogleGenaiService_1.name);
+    defaultApiKey;
+    constructor(keyBalancer) {
+        this.keyBalancer = keyBalancer;
+        this.defaultApiKey = process.env.GEMINI_API_KEY || '';
+        if (!this.defaultApiKey) {
+            this.logger.warn('GEMINI_API_KEY environment variable not set. This service will not work without available keys in the balancer.');
+        }
+    }
+    async getGoogleGenAIClient(modelName, keyTierType, modelType) {
+        this.logger.warn('getGoogleGenAIClient() Getting key from redis');
+        if (process.env.KEY_BALANCER_HOST && modelType) {
+            const balancedKey = await this.keyBalancer.getKey(modelType, modelName, keyTierType);
+            if (balancedKey?.apiKey) {
+                this.logger.debug(`Using balanced key: ${balancedKey.name} ${balancedKey.id}`);
+                return { client: new genai_1.GoogleGenAI({ apiKey: balancedKey.apiKey }), balancedKey };
+            }
+        }
+        if (!this.defaultApiKey) {
+            throw new nest_core_1.AppException({
+                error_message: 'No API keys available',
+                explanation: 'All balanced keys are rate-limited or failing, and no default GEMINI_API_KEY is configured.',
+            });
+        }
+        this.logger.warn('No balanced keys available. Falling back to default API key.');
+        return { client: new genai_1.GoogleGenAI({ apiKey: this.defaultApiKey }), balancedKey: null };
+    }
+};
+exports.GoogleGenaiService = GoogleGenaiService;
+exports.GoogleGenaiService = GoogleGenaiService = GoogleGenaiService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [key_balancer_api_service_1.KeyBalancerApiService])
+], GoogleGenaiService);
+//# sourceMappingURL=google-genai.service.js.map

package/services/key-balancer-api.service.d.ts

@@ -1,10 +1,10 @@
 import { HttpService } from '@nestjs/axios';
-import { AvailableKeyResult, ModelType } from '../models/key-balancer.models';
+import { AvailableKeyResult, ModelType, TierType } from '../models/key-balancer.models';
 export declare class KeyBalancerApiService {
     private readonly httpService;
     private readonly logger;
     constructor(httpService: HttpService);
-    getLlmKey(model: string, tier?: string): Promise<AvailableKeyResult>;
-    getImageKey(model: string, tier?: string): Promise<AvailableKeyResult>;
+    getKey(modelType: ModelType, model: string, tier?: TierType): Promise<AvailableKeyResult>;
+    private getUnavailableServiceResult;
     recordFailedRequest(keyId: string, error: any, modelType: ModelType, model: string, ttlSeconds?: number): Promise<void>;
 }

package/services/key-balancer-api.service.js

@@ -20,46 +20,33 @@ let KeyBalancerApiService = KeyBalancerApiService_1 = class KeyBalancerApiServic
     constructor(httpService) {
         this.httpService = httpService;
     }
-    async getLlmKey(model, tier) {
-        try {
-            const keyBalancerHost = process.env.KEY_BALANCER_HOST;
-            const url = `${keyBalancerHost}/api/key-balancer/redis/key/llm?model=${model}&tier=${tier || ''}`;
-            this.logger.warn(`Request to: ${url}`);
-            const { data } = await (0, rxjs_1.firstValueFrom)(this.httpService.get(url));
-            return data;
-        }
-        catch (error) {
-            this.logger.error(`Failed to get LLM key for model ${model} from the external service.`, error.stack);
-            return {
-                id: '',
-                apiKey: '',
-                name: '',
-                type: '',
-                error: 'ServiceUnavailable',
-                errorDescription: 'Failed to fetch key from key-balancer API.',
-            };
+    async getKey(modelType, model, tier) {
+        const keyBalancerHost = process.env.KEY_BALANCER_HOST;
+        if (!keyBalancerHost) {
+            this.logger.error('KEY_BALANCER_HOST environment variable not set.');
+            return this.getUnavailableServiceResult();
         }
-    }
-    async getImageKey(model, tier) {
         try {
-            const keyBalancerHost = process.env.KEY_BALANCER_HOST;
-            const url = `${keyBalancerHost}/api/key-balancer/redis/key/image?model=${model}&tier=${tier || ''}`;
+            const url = `${keyBalancerHost}/api/key-balancer/redis/key/${modelType.toLowerCase()}?model=${model}&tier=${tier || ''}`;
             this.logger.warn(`Request to: ${url}`);
             const { data } = await (0, rxjs_1.firstValueFrom)(this.httpService.get(url));
             return data;
         }
         catch (error) {
-            this.logger.error(`Failed to get IMAGE key for model ${model} from the external service.`, error.stack);
-            return {
-                id: '',
-                apiKey: '',
-                name: '',
-                type: '',
-                error: 'ServiceUnavailable',
-                errorDescription: 'Failed to fetch key from key-balancer API.',
-            };
+            this.logger.error(`Failed to get ${modelType} key for model ${model} from the external service.`, error.stack);
+            return this.getUnavailableServiceResult();
         }
     }
+    getUnavailableServiceResult() {
+        return {
+            id: '',
+            apiKey: '',
+            name: '',
+            type: '',
+            error: 'ServiceUnavailable',
+            errorDescription: 'Failed to fetch key from key-balancer API.',
+        };
+    }
     async recordFailedRequest(keyId, error, modelType, model, ttlSeconds) {
         const keyBalancerHost = process.env.KEY_BALANCER_HOST;
         const url = `${keyBalancerHost}/api/key-balancer/redis/key/failed`;

package/services/vertex-gemini-chat.service.d.ts

@@ -1,19 +1,20 @@
 import { ChatMessageDict, MessageLLM, EModelQuality, DescribeImageRequestAdapter } from '../models/adapter.models';
+import { TierType } from '../models/key-balancer.models';
 import { KeyBalancerApiService } from './key-balancer-api.service';
+import { GoogleGenaiService } from './google-genai.service';
 export declare class GeminiChatService {
     private readonly keyBalancer;
+    private readonly googleGenaiService;
     private readonly logger;
     private readonly defaultModel;
-    private readonly defaultApiKey;
-    constructor(keyBalancer: KeyBalancerApiService);
-    private _getGoogleGenAIClient;
+    constructor(keyBalancer: KeyBalancerApiService, googleGenaiService: GoogleGenaiService);
     private mapToGeminiRole;
     private formatMessagesToContent;
-    chat(messages: MessageLLM[], model?: string, keyType?: string): Promise<ChatMessageDict>;
-    chatStream(messages: MessageLLM[], model?: string, keyType?: string): Promise<AsyncIterable<ChatMessageDict>>;
+    chat(messages: MessageLLM[], model?: string, keyType?: TierType): Promise<ChatMessageDict>;
+    chatStream(messages: MessageLLM[], model?: string, keyType?: TierType): Promise<AsyncIterable<ChatMessageDict>>;
     listModels(): Promise<Record<string, string>[]>;
     getDefaultQualityModel(quality: EModelQuality): string;
     private _extractJsonWithRecovery;
-    chatAndExtractJson(messages: MessageLLM[], model?: string, keyType?: string): Promise<any>;
+    chatAndExtractJson(messages: MessageLLM[], model?: string, keyType?: TierType): Promise<any>;
     describeImageByUrl(dto: DescribeImageRequestAdapter): Promise<any>;
 }

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

@@ -12,44 +12,23 @@ var GeminiChatService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GeminiChatService = void 0;
 const common_1 = require("@nestjs/common");
-const genai_1 = require("@google/genai");
 const nest_core_1 = require("@dataclouder/nest-core");
 const gemini_models_1 = require("../models/gemini-models");
 const adapter_models_1 = require("../models/adapter.models");
 const llm_models_1 = require("../models/llm.models");
 const key_balancer_models_1 = require("../models/key-balancer.models");
 const key_balancer_api_service_1 = require("./key-balancer-api.service");
+const google_genai_service_1 = require("./google-genai.service");
 let GeminiChatService = GeminiChatService_1 = class GeminiChatService {
     keyBalancer;
+    googleGenaiService;
     logger = new common_1.Logger(GeminiChatService_1.name);
-    defaultModel = 'gemini-2.5-flash-lite';
-    defaultApiKey;
-    constructor(keyBalancer) {
+    defaultModel = 'gemini-1.5-flash-latest';
+    constructor(keyBalancer, googleGenaiService) {
         this.keyBalancer = keyBalancer;
-        this.defaultApiKey = process.env.GEMINI_API_KEY || '';
-        if (!this.defaultApiKey) {
-            this.logger.warn('GEMINI_API_KEY environment variable not set. This service will not work without available keys in the balancer.');
-        }
+        this.googleGenaiService = googleGenaiService;
         this.logger.log(`GeminiChatService initialized with model: ${this.defaultModel}`);
     }
-    async _getGoogleGenAIClient(model, keyType) {
-        this.logger.warn('_getGoogleGenAIClient() Getting key from redis');
-        if (process.env.KEY_BALANCER_HOST) {
-            const balancedKey = await this.keyBalancer.getLlmKey(model, keyType);
-            if (balancedKey?.apiKey) {
-                this.logger.debug(`Using balanced key: ${balancedKey.name} ${balancedKey.id}`);
-                return { client: new genai_1.GoogleGenAI({ apiKey: balancedKey.apiKey }), balancedKey };
-            }
-        }
-        if (!this.defaultApiKey) {
-            throw new nest_core_1.AppException({
-                error_message: 'No API keys available',
-                explanation: 'All balanced keys are rate-limited or failing, and no default GEMINI_API_KEY is configured.',
-            });
-        }
-        this.logger.warn('No balanced keys available. Falling back to default API key.');
-        return { client: new genai_1.GoogleGenAI({ apiKey: this.defaultApiKey }), balancedKey: null };
-    }
     mapToGeminiRole(role) {
         switch (role) {
             case 'assistant':
@@ -64,8 +43,8 @@ let GeminiChatService = GeminiChatService_1 = class GeminiChatService {
     }
     formatMessagesToContent(messages) {
         return messages
-            .filter((msg) => msg.role !== 'system' && typeof msg.content === 'string')
-            .map((msg) => ({
+            .filter(msg => msg.role !== 'system' && typeof msg.content === 'string')
+            .map(msg => ({
             role: this.mapToGeminiRole(msg.role),
             parts: [{ text: msg.content }],
         }));
@@ -78,11 +57,11 @@ let GeminiChatService = GeminiChatService_1 = class GeminiChatService {
         if (!messages || messages.length === 0) {
             return { content: '', role: adapter_models_1.ChatRole.Assistant, metadata: { finishReason: 'NO_INPUT' } };
         }
-        const { client, balancedKey } = await this._getGoogleGenAIClient(model, keyType);
+        const { client, balancedKey } = await this.googleGenaiService.getGoogleGenAIClient(model, keyType);
         try {
             const systemMessage = messages
-                .filter((msg) => msg.role === 'system')
-                .map((msg) => msg.content)
+                .filter(msg => msg.role === 'system')
+                .map(msg => msg.content)
                 .join('\n');
             let lastMessage = messages[messages.length - 1];
             if (lastMessage.role !== 'user' || typeof lastMessage.content !== 'string') {
@@ -153,7 +132,7 @@ let GeminiChatService = GeminiChatService_1 = class GeminiChatService {
             this.logger.warn('Gemini chatStream called with empty messages.');
             return (async function* () { })();
         }
-        const systemMessage = messages.find((msg) => msg.role === 'system')?.content;
+        const systemMessage = messages.find(msg => msg.role === 'system')?.content;
         const lastMessage = messages[messages.length - 1];
         if (lastMessage.role !== 'user' || typeof lastMessage.content !== 'string') {
             this.logger.error('The last message for streaming must be from the user and contain string content.');
@@ -161,7 +140,7 @@ let GeminiChatService = GeminiChatService_1 = class GeminiChatService {
         }
         const formattedContents = this.formatMessagesToContent(messages);
         const processStream = async function* () {
-            const { client, balancedKey } = await this._getGoogleGenAIClient(model, keyType);
+            const { client, balancedKey } = await this.googleGenaiService.getGoogleGenAIClient(model, keyType);
             try {
                 this.logger.debug(`Sending stream request to Gemini model ${model} with ${formattedContents.length} content parts and system instruction: ${!!systemMessage}`);
                 const stream = await client.models.generateContentStream({
@@ -250,7 +229,7 @@ let GeminiChatService = GeminiChatService_1 = class GeminiChatService {
         const textModelForFix = gemini_models_1.GeminiModels.Gemini2_5Lite;
         const prompt = dto.prompt ||
             'Describe this image, return a json with {"description": "description of image in 1 paragraph", "video": "idea of video in 1 paragraph, describe movements and camera movements, animation, actions or anything that can fit in 6 seconds video "}';
-        const { client, balancedKey } = await this._getGoogleGenAIClient(visionModelLLM, key_balancer_models_1.ModelType.LLM);
+        const { client, balancedKey } = await this.googleGenaiService.getGoogleGenAIClient(visionModelLLM, key_balancer_models_1.TierType.TIER_1);
         this.logger.log(`Fetching image from URL: ${dto.url}`);
         const imageResponse = await fetch(dto.url);
         if (!imageResponse.ok) {
@@ -286,12 +265,13 @@ let GeminiChatService = GeminiChatService_1 = class GeminiChatService {
             this.logger.error(`Error in describeImageByUrl vision call: ${error.message}`, error.stack);
             throw new Error(`Failed to get Gemini vision completion: ${error.message}`);
         }
-        return this._extractJsonWithRecovery(visionResponseText, textModelForFix, key_balancer_models_1.ModelType.LLM);
+        return this._extractJsonWithRecovery(visionResponseText, textModelForFix);
     }
 };
 exports.GeminiChatService = GeminiChatService;
 exports.GeminiChatService = GeminiChatService = GeminiChatService_1 = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [key_balancer_api_service_1.KeyBalancerApiService])
+    __metadata("design:paramtypes", [key_balancer_api_service_1.KeyBalancerApiService,
+        google_genai_service_1.GoogleGenaiService])
 ], GeminiChatService);
 //# sourceMappingURL=vertex-gemini-chat.service.js.map

package/services/vertex-image.service.js

@@ -43,7 +43,7 @@ let ImageVertexService = ImageVertexService_1 = class ImageVertexService {
             keyId = 'local';
         }
         else {
-            availableKey = await this.keyBalancerApiService.getImageKey(model, tierType || 'tier 1');
+            availableKey = (await this.keyBalancerApiService.getKey(key_balancer_models_1.ModelType.IMAGE, model, key_balancer_models_1.TierType.TIER_1));
             if (availableKey === null) {
                 this.logger.error('KEY BALANCER IS DOWN: :::: No available API key from key balancer.');
             }
@@ -83,10 +83,10 @@ let ImageVertexService = ImageVertexService_1 = class ImageVertexService {
                 safetySettings: [{ threshold: genai_1.HarmBlockThreshold.BLOCK_NONE }],
             },
         };
-        Object.keys(imageRequest.config).forEach((key) => imageRequest.config[key] === undefined && delete imageRequest.config[key]);
+        Object.keys(imageRequest.config).forEach(key => imageRequest.config[key] === undefined && delete imageRequest.config[key]);
         try {
             const response = await client.models.generateImages(imageRequest);
-            const generatedImages = response?.generatedImages?.map((generatedImage) => {
+            const generatedImages = response?.generatedImages?.map(generatedImage => {
                 return generatedImage.image;
             });
             console.warn(' _____ Creo que este no regresa el tipo  ImageGenAdapterResponse ');
@@ -122,7 +122,7 @@ let ImageVertexService = ImageVertexService_1 = class ImageVertexService {
                 personGeneration: genai_1.PersonGeneration.ALLOW_ALL,
             },
         };
-        Object.keys(imageVertexRequest.config || {}).forEach((key) => imageVertexRequest?.config?.[key] === undefined && delete imageVertexRequest?.config?.[key]);
+        Object.keys(imageVertexRequest.config || {}).forEach(key => imageVertexRequest?.config?.[key] === undefined && delete imageVertexRequest?.config?.[key]);
         try {
             const slicedPrompt = imageRequest.prompt.slice(0, 50);
             this.logger.log(`Sending request... -> startImageGenerationAdapter() MODEL 🎆${imageVertexRequest.model} for prompt: ${slicedPrompt}...`);

package/services/vertex-veo-genai.service.d.ts

@@ -3,14 +3,15 @@ import { GeneratedAsset } from '../models/generated-asset.entity';
 import { CloudStorageService } from '@dataclouder/nest-storage';
 import { GeneratedAssetService } from './generated-asset.service';
 import { HttpService } from '@nestjs/axios';
+import { GoogleGenaiService } from './google-genai.service';
 export declare class VertexVeoGenaiService {
     private readonly generatedAssetModel;
     private readonly cloudStorageService;
     private readonly httpService;
     private readonly generatedAssetService;
+    private readonly googleGenaiService;
     private readonly logger;
-    private genAI;
-    constructor(generatedAssetModel: Model<GeneratedAsset>, cloudStorageService: CloudStorageService, httpService: HttpService, generatedAssetService: GeneratedAssetService);
+    constructor(generatedAssetModel: Model<GeneratedAsset>, cloudStorageService: CloudStorageService, httpService: HttpService, generatedAssetService: GeneratedAssetService, googleGenaiService: GoogleGenaiService);
     generateVideo(): Promise<any>;
     generateVideoFromAssetId(assetId: string, metadata?: any): Promise<{
         url: string | undefined;

package/services/vertex-veo-genai.service.js

@@ -51,39 +51,39 @@ const mongoose_1 = require("@nestjs/mongoose");
 const mongoose_2 = require("mongoose");
 const generated_asset_entity_1 = require("../models/generated-asset.entity");
 const nest_storage_1 = require("@dataclouder/nest-storage");
-const genai_1 = require("@google/genai");
 const generated_asset_service_1 = require("./generated-asset.service");
 const axios_1 = require("@nestjs/axios");
 const uuid_1 = require("uuid");
 const fs = __importStar(require("fs/promises"));
-const VeoModels = {
-    Veo3: 'veo-3.0-fast-generate-001',
-    Veo3Fast: 'veo-3.0-fast-generate-001',
-};
+const google_genai_service_1 = require("./google-genai.service");
+const gemini_models_1 = require("../models/gemini-models");
+const key_balancer_models_1 = require("../models/key-balancer.models");
 let VertexVeoGenaiService = class VertexVeoGenaiService {
     generatedAssetModel;
     cloudStorageService;
     httpService;
     generatedAssetService;
+    googleGenaiService;
     logger = new common_1.Logger('VertexVeoGenaiService');
-    genAI;
-    constructor(generatedAssetModel, cloudStorageService, httpService, generatedAssetService) {
+    constructor(generatedAssetModel, cloudStorageService, httpService, generatedAssetService, googleGenaiService) {
         this.generatedAssetModel = generatedAssetModel;
         this.cloudStorageService = cloudStorageService;
         this.httpService = httpService;
         this.generatedAssetService = generatedAssetService;
-        this.genAI = new genai_1.GoogleGenAI({ apiKey: 'AIzaSyApFzJHWqD0Yh_0WyJNIS0c9w6LA0rzOBM' });
+        this.googleGenaiService = googleGenaiService;
         this.logger.log('VertexVeoGenaiService initialized. This service may be temporal, since VEO is only available in GCP vía REST API.');
     }
     async generateVideo() {
         const prompt = 'Panning wide shot of a calico kitten sleeping in the sunshine';
-        const imagenResponse = await this.genAI.models.generateImages({
+        const { client, balancedKey } = await this.googleGenaiService.getGoogleGenAIClient(gemini_models_1.GeminiVideoModels.Veo3Fast, key_balancer_models_1.TierType.TIER_1, key_balancer_models_1.ModelType.VIDEO);
+        console.log('the balance key for video is ', balancedKey);
+        const imagenResponse = await client.models.generateImages({
             model: 'imagen-3.0-generate-002',
             prompt: prompt,
         });
         this.logger.log(imagenResponse);
         const videoRequest = {
-            model: VeoModels.Veo3Fast,
+            model: gemini_models_1.GeminiVideoModels.Veo3Fast,
             prompt: prompt,
             image: {
                 imageBytes: imagenResponse.generatedImages[0].image.imageBytes,
@@ -98,11 +98,12 @@ let VertexVeoGenaiService = class VertexVeoGenaiService {
             this.logger.log('Updating asset metadata for future retrieval:', metadata);
             await this.generatedAssetService.partialUpdate(assetId, metadata);
         }
+        console.log('Donwloading image for first frame....', genAsset.assets.firstFrame.url);
         const imageUrl = genAsset.assets.firstFrame.url;
         const response = await this.httpService.axiosRef.get(imageUrl, { responseType: 'arraybuffer' });
         const imageBufferBytes = Buffer.from(response.data, 'binary');
         const videoRequest = {
-            model: VeoModels.Veo3,
+            model: gemini_models_1.GeminiVideoModels.Veo3Fast,
             prompt: genAsset.prompt || genAsset?.description || 'Random movement for video',
             config: {
                 aspectRatio: '9:16',
@@ -117,27 +118,32 @@ let VertexVeoGenaiService = class VertexVeoGenaiService {
         genAsset.url = videoRequestResult.url;
         console.log(videoRequestResult);
         await this.generatedAssetService.save(genAsset);
+        this.logger.log(`Generated video saved to DB: ${genAsset._id}`);
         return videoRequestResult;
     }
     async _generateVideo(videoRequest) {
-        let operation = await this.genAI.models.generateVideos(videoRequest);
+        console.log('Generating video...', videoRequest);
+        const { client, balancedKey } = await this.googleGenaiService.getGoogleGenAIClient(gemini_models_1.GeminiVideoModels.Veo3Fast, key_balancer_models_1.TierType.TIER_1, key_balancer_models_1.ModelType.VIDEO);
+        console.log('the balance key for video is ', balancedKey);
+        let operation = await client.models.generateVideos(videoRequest);
         const filename = `veo_video_${(0, uuid_1.v4)()}.mp4`;
         let seconds = 0;
         while (!operation.done) {
             seconds += 5;
             this.logger.log(`Waiting for video generation to complete... (${seconds}s)`);
             await new Promise(resolve => setTimeout(resolve, 5000));
-            operation = await this.genAI.operations.getVideosOperation({
+            operation = await client.operations.getVideosOperation({
                 operation: operation,
             });
             console.log('result', JSON.stringify(operation));
         }
-        await this.genAI.files.download({
+        console.log('Operations is Done...', JSON.stringify(operation));
+        await client.files.download({
             file: operation.response?.generatedVideos?.[0].video || '',
             downloadPath: `${filename}`,
         });
-        this.logger.log(` ❗️ La api tiene un error, no me avisa cunado descarga el video. esperando 3 segundos.....`);
-        await new Promise(resolve => setTimeout(resolve, 3000));
+        this.logger.log(` ❗️ Bug de GEN AI API, No FUNCIONA ASYNC para descargar video, esperando 3.5 segundos a que descarge.....`);
+        await new Promise(resolve => setTimeout(resolve, 3500));
         const videoBuffer = await fs.readFile(filename);
         console.log('Subiendo video a storage', filename, process.env.STORAGE_BUCKET);
         const uploadResult = await this.cloudStorageService.uploadFileAndMakePublic(process.env.STORAGE_BUCKET, `generated-videos/${filename}`, videoBuffer, 'video/mp4');
@@ -155,6 +161,7 @@ exports.VertexVeoGenaiService = VertexVeoGenaiService = __decorate([
     __metadata("design:paramtypes", [mongoose_2.Model,
         nest_storage_1.CloudStorageService,
         axios_1.HttpService,
-        generated_asset_service_1.GeneratedAssetService])
+        generated_asset_service_1.GeneratedAssetService,
+        google_genai_service_1.GoogleGenaiService])
 ], VertexVeoGenaiService);
 //# sourceMappingURL=vertex-veo-genai.service.js.map