@dataclouder/nest-vertex 0.0.54 → 0.0.56

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

@@ -54,7 +54,7 @@ __decorate([
                 },
                 voiceName: {
                     type: 'string',
-                    example: 'Charon',
+                    example: 'en-US-Chirp3-HD-Puck',
                     description: 'Optional specific voice name (default: Charon)',
                 },
                 languageCode: {
@@ -62,6 +62,11 @@ __decorate([
                     example: 'en-US',
                     description: 'Optional language code (default: en-US)',
                 },
+                model_name: {
+                    type: 'string',
+                    example: 'gemini-2.5-flash-tts',
+                    description: 'Optional model name (default: gemini-2.5-flash-tts)',
+                },
             },
             required: ['text'],
         },

package/package.json

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

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

@@ -16,4 +16,5 @@ export declare class KeyBalancerClientService {
     getKeys(): Promise<AvailableKeyResult[]>;
     private getUnavailableServiceResult;
     recordFailedRequest(keyId: string, error: any, modelType: ModelType, model: string, ttlSeconds?: number): Promise<void>;
+    updateUsage(keyUsageId: string, usageCount: number): Promise<any>;
 }

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

@@ -42,7 +42,7 @@ let KeyBalancerClientService = KeyBalancerClientService_1 = class KeyBalancerCli
             token,
             keyRequest,
         };
-        const keyBalancerHost = process.env.KEY_BALANCER_HOST || 'http://localhost:3000';
+        const keyBalancerHost = process.env.KEY_BALANCER_HOST || 'http://localhost:8085';
         const url = `${keyBalancerHost}/api/key-usage/best-key-balanced`;
         const { data } = await (0, rxjs_1.firstValueFrom)(this.httpService.post(url, finalRquest));
         return data;
@@ -51,7 +51,7 @@ let KeyBalancerClientService = KeyBalancerClientService_1 = class KeyBalancerCli
         const appFilter = {
             filters: { provider: 'google', keyType: 'service_account' },
         };
-        const keyBalancerHost = process.env.KEY_BALANCER_HOST || 'http://localhost:3000';
+        const keyBalancerHost = process.env.KEY_BALANCER_HOST || 'http://localhost:8085';
         const url = `${keyBalancerHost}/api/key-balancer/query`;
         const { data } = await (0, rxjs_1.firstValueFrom)(this.httpService.post(url, appFilter));
         return data.rows;
@@ -74,6 +74,19 @@ let KeyBalancerClientService = KeyBalancerClientService_1 = class KeyBalancerCli
         this.logger.warn(`Failed to get LLM key for model ${model} from the external service.`, data);
         return;
     }
+    async updateUsage(keyUsageId, usageCount) {
+        const keyBalancerHost = process.env.KEY_BALANCER_HOST || 'http://localhost:8085';
+        const url = `${keyBalancerHost}/api/key-usage/update-usage`;
+        try {
+            const { data } = await (0, rxjs_1.firstValueFrom)(this.httpService.post(url, { keyUsageId, usageCount }));
+            this.logger.verbose(`Usage updated for keyUsageId: ${keyUsageId} with usageCount: ${usageCount}`);
+            return data;
+        }
+        catch (error) {
+            this.logger.error(`Failed to update usage for keyUsageId: ${keyUsageId}`, error.stack);
+            throw error;
+        }
+    }
 };
 exports.KeyBalancerClientService = KeyBalancerClientService;
 exports.KeyBalancerClientService = KeyBalancerClientService = KeyBalancerClientService_1 = __decorate([

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

@@ -1,6 +1,10 @@
 import { BaseTtsService } from './base-tts.service';
-import { SynthesizeSpeechInput } from './vertex-tts.service';
+import { SynthesizeSpeechInput, VertextTtsService } from './vertex-tts.service';
+import { KeyBalancerClientService } from './key-balancer-api.service';
 export declare class VertexGeminiTtsService extends BaseTtsService {
-    constructor();
+    private readonly keyBalancerClientService;
+    private readonly vertexTtsService;
+    constructor(keyBalancerClientService: KeyBalancerClientService, vertexTtsService: VertextTtsService);
     synthesizeSpeech(input: SynthesizeSpeechInput): Promise<Buffer | null>;
+    synthesizeSpeechTest(input: SynthesizeSpeechInput): Promise<Buffer | null>;
 }

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

@@ -12,13 +12,36 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VertexGeminiTtsService = void 0;
 const common_1 = require("@nestjs/common");
 const base_tts_service_1 = require("./base-tts.service");
+const vertex_tts_service_1 = require("./vertex-tts.service");
 const gemini_config_1 = require("../config/gemini.config");
+const key_balancer_api_service_1 = require("./key-balancer-api.service");
 let VertexGeminiTtsService = class VertexGeminiTtsService extends base_tts_service_1.BaseTtsService {
-    constructor() {
+    keyBalancerClientService;
+    vertexTtsService;
+    constructor(keyBalancerClientService, vertexTtsService) {
         const credentials = JSON.parse(gemini_config_1.GEMINI_API_KEY);
         super('VertexGeminiTtsService', { credentials });
+        this.keyBalancerClientService = keyBalancerClientService;
+        this.vertexTtsService = vertexTtsService;
     }
     async synthesizeSpeech(input) {
+        const { text, voice: voiceName = 'Charon', languageCode = 'en-US' } = input;
+        this.logger.log(`Synthesizing speech for text: "${input.text.substring(0, 50)}..." with voice: ${input.voiceName}`);
+        const request = {
+            text: input.text,
+            voice: input.voiceName,
+            languageCode: input.languageCode,
+            modelName: input.modelName || undefined,
+        };
+        return this.vertexTtsService.synthesizeSpeech(request);
+    }
+    async synthesizeSpeechTest(input) {
+        const { text, voice: voiceName = 'Charon', languageCode = 'en-US' } = input;
+        const geminiKey = await this.keyBalancerClientService.getBestKey({
+            service: 'chirp-3-hd',
+            provider: 'google',
+        }, null);
+        console.log(geminiKey);
         this.logger.log(`Synthesizing speech for text: "${input.text.substring(0, 50)}..." with voice: ${input.voiceName}`);
         const request = {
             input: { text: input.text, prompt: input.prompt },
@@ -37,6 +60,7 @@ let VertexGeminiTtsService = class VertexGeminiTtsService extends base_tts_servi
 exports.VertexGeminiTtsService = VertexGeminiTtsService;
 exports.VertexGeminiTtsService = VertexGeminiTtsService = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [])
+    __metadata("design:paramtypes", [key_balancer_api_service_1.KeyBalancerClientService,
+        vertex_tts_service_1.VertextTtsService])
 ], VertexGeminiTtsService);
 //# sourceMappingURL=vertex-gemini-tts.service.js.map

package/services/vertex-tts.service.d.ts

@@ -3,11 +3,11 @@ import { AudioSpeed } from '../models/audio.settings';
 import { BaseTtsService } from './base-tts.service';
 import { AppToken } from '@dataclouder/nest-auth';
 import { KeyBalancerClientService } from './key-balancer-api.service';
-import { MetricAIService } from './metric-ai.service';
 export interface SynthesizeSpeechInput {
     text: string;
     prompt?: string;
     languageCode?: string;
+    modelName?: string;
     ssmlGender?: google.cloud.texttospeech.v1.SsmlVoiceGender;
     voice?: string;
     voiceName?: string;
@@ -19,8 +19,7 @@ export interface SynthesizeSpeechInput {
 }
 export declare class VertextTtsService extends BaseTtsService {
     private readonly keyBalancerClient;
-    private readonly metricAIService;
-    constructor(keyBalancerClient: KeyBalancerClientService, metricAIService: MetricAIService);
+    constructor(keyBalancerClient: KeyBalancerClientService);
     synthesizeSpeech(input: SynthesizeSpeechInput, token?: AppToken): Promise<Buffer | null>;
     private handleSynthesisWithClient;
     private _resolveVoice;

package/services/vertex-tts.service.js

@@ -16,46 +16,43 @@ const google_voices_1 = require("../models/google-voices");
 const base_tts_service_1 = require("./base-tts.service");
 const key_balancer_api_service_1 = require("./key-balancer-api.service");
 const text_to_speech_1 = require("@google-cloud/text-to-speech");
-const metric_ai_service_1 = require("./metric-ai.service");
 const gemini_models_1 = require("../models/gemini-models");
 let VertextTtsService = class VertextTtsService extends base_tts_service_1.BaseTtsService {
     keyBalancerClient;
-    metricAIService;
-    constructor(keyBalancerClient, metricAIService) {
+    constructor(keyBalancerClient) {
         super('VertexTtsService');
         this.keyBalancerClient = keyBalancerClient;
-        this.metricAIService = metricAIService;
     }
     async synthesizeSpeech(input, token) {
         let client;
-        if (token) {
-            this.logger.log(`Synthesizing speech for user: ${token.email}`);
-            const selectedKey = await this.keyBalancerClient.getBestKey({
-                provider: 'google',
-                service: gemini_models_1.GoogleTTSModels.Chirp3HD,
-                keyType: 'service_account',
-            }, token);
-            if (selectedKey.key) {
-                this.logger.debug(` 🎤 📣 Using balanced key Service Account : ${selectedKey.name} ${selectedKey.id}`);
-                try {
-                    const credentials = JSON.parse(selectedKey.key);
-                    client = new text_to_speech_1.TextToSpeechClient({ credentials });
-                }
-                catch (error) {
-                    this.logger.error('Failed to parse key credentials', error);
-                }
+        this.logger.log(`Synthesizing speech for user: ${token?.email}`);
+        const selectedKey = await this.keyBalancerClient.getBestKey({
+            provider: 'google',
+            service: gemini_models_1.GoogleTTSModels.Chirp3HD,
+            keyType: 'service_account',
+        }, token);
+        if (selectedKey.key) {
+            this.keyBalancerClient.updateUsage(selectedKey.id, input.text.length);
+            this.logger.verbose(` Balanced key Found : ${selectedKey.name} ${selectedKey.id}`);
+            try {
+                const credentials = JSON.parse(selectedKey.key);
+                client = new text_to_speech_1.TextToSpeechClient({ credentials });
             }
-            else {
-                this.logger.warn(' CHECK ! ❗️ No balanced key found, USING service account');
+            catch (error) {
+                this.logger.error('Failed to parse key credentials', error);
             }
         }
         const voiceId = this._resolveVoice(input.voice, input.languageCode);
         const request = this._buildSynthesizeSpeechRequest(input, voiceId);
         this.logger.log(`Synthesizing speech for text: "${input.text.substring(0, 50)}..." with voice: ${voiceId}`);
         if (client) {
+            this.logger.debug(` 🍷AUDIO TTS🎤 📣 Using balanced key Service Account : ${selectedKey.name} ${selectedKey.id}`);
             return this.handleSynthesisWithClient(request, client);
         }
-        return this.handleSynthesis(request);
+        else {
+            this.logger.warn(' CHECK ! ❗️ 🍷AUDIO TTS🎤 USING DEFAULT KEY');
+            return this.handleSynthesis(request);
+        }
     }
     async handleSynthesisWithClient(request, client) {
         try {
@@ -70,7 +67,7 @@ let VertextTtsService = class VertextTtsService extends base_tts_service_1.BaseT
             }
         }
         catch (error) {
-            this.logger.error('Error synthesizing speech:', error);
+            this.logger.error('Error synthesizing speech:', error.message);
             throw new Error(`Failed to synthesize speech: ${error.message}`);
         }
     }
@@ -113,7 +110,6 @@ let VertextTtsService = class VertextTtsService extends base_tts_service_1.BaseT
 exports.VertextTtsService = VertextTtsService;
 exports.VertextTtsService = VertextTtsService = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [key_balancer_api_service_1.KeyBalancerClientService,
-        metric_ai_service_1.MetricAIService])
+    __metadata("design:paramtypes", [key_balancer_api_service_1.KeyBalancerClientService])
 ], VertextTtsService);
 //# sourceMappingURL=vertex-tts.service.js.map