@dataclouder/nest-vertex 0.0.37 → 0.0.39

package/controllers/groq-stt.controller.d.ts

@@ -0,0 +1,8 @@
+import { type MulterFile } from '@webundsoehne/nest-fastify-file-upload';
+import { GroqService } from '../services/whisper/groq.service';
+export declare class GroqSttController {
+    private readonly groqService;
+    private readonly logger;
+    constructor(groqService: GroqService);
+    processAudio(file: MulterFile): Promise<any>;
+}

package/controllers/groq-stt.controller.js

@@ -0,0 +1,60 @@
+"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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var GroqSttController_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroqSttController = void 0;
+const common_1 = require("@nestjs/common");
+const nest_fastify_file_upload_1 = require("@webundsoehne/nest-fastify-file-upload");
+const swagger_1 = require("@nestjs/swagger");
+const groq_service_1 = require("../services/whisper/groq.service");
+let GroqSttController = GroqSttController_1 = class GroqSttController {
+    groqService;
+    logger = new common_1.Logger(GroqSttController_1.name);
+    constructor(groqService) {
+        this.groqService = groqService;
+    }
+    async processAudio(file) {
+        console.log('Receive requests');
+        if (!file || !file.buffer) {
+            console.error('No file buffer received.');
+            return { error: 'No file uploaded or file buffer is missing.' };
+        }
+        console.log(`Received file: ${file.originalname}, mimetype: ${file.mimetype}, size: ${file.size}`);
+        try {
+            const result = await this.groqService.transcribeAudio(file.buffer, file.originalname, file.mimetype);
+            return result;
+        }
+        catch (error) {
+            console.error('Error during transcription process:', error);
+            return { error: 'Failed to transcribe audio.', details: error.message };
+        }
+    }
+};
+exports.GroqSttController = GroqSttController;
+__decorate([
+    (0, common_1.Post)('transcribe-bytes'),
+    (0, common_1.UseInterceptors)((0, nest_fastify_file_upload_1.FileInterceptor)('file')),
+    (0, swagger_1.ApiConsumes)('multipart/form-data'),
+    (0, nest_fastify_file_upload_1.ApiFileBody)('file'),
+    __param(0, (0, common_1.UploadedFile)('file')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GroqSttController.prototype, "processAudio", null);
+exports.GroqSttController = GroqSttController = GroqSttController_1 = __decorate([
+    (0, swagger_1.ApiTags)('Speech-to-Text'),
+    (0, common_1.Controller)('api/groq-stt'),
+    __metadata("design:paramtypes", [groq_service_1.GroqService])
+], GroqSttController);
+//# sourceMappingURL=groq-stt.controller.js.map

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

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

package/models/key-balancer.models.js

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

package/nest-vertex.module.js

@@ -35,6 +35,8 @@ 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");
+const groq_stt_controller_1 = require("./controllers/groq-stt.controller");
+const groq_service_1 = require("./services/whisper/groq.service");
 let NestVertexModule = class NestVertexModule {
 };
 exports.NestVertexModule = NestVertexModule;
@@ -61,6 +63,7 @@ exports.NestVertexModule = NestVertexModule = __decorate([
             key_balancer_api_service_1.KeyBalancerApiService,
             vertex_veo_genai_service_1.VertexVeoGenaiService,
             google_genai_service_1.GoogleGenaiService,
+            groq_service_1.GroqService,
         ],
         exports: [
             vertex_image_video_service_1.VertexImageVideoService,
@@ -76,6 +79,7 @@ exports.NestVertexModule = NestVertexModule = __decorate([
             key_balancer_api_service_1.KeyBalancerApiService,
             vertex_veo_genai_service_1.VertexVeoGenaiService,
             google_genai_service_1.GoogleGenaiService,
+            groq_service_1.GroqService,
             comfyui_module_1.ComfyUIModule,
         ],
         controllers: [
@@ -87,6 +91,7 @@ exports.NestVertexModule = NestVertexModule = __decorate([
             generated_assets_controller_1.GeneratedAssetsController,
             vertex_comfy_controller_1.VertexComfyController,
             vertex_veo_video_controller_1.VertexVeoGenerationController,
+            groq_stt_controller_1.GroqSttController,
         ],
     })
 ], NestVertexModule);

package/package.json

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

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

@@ -6,7 +6,7 @@ export declare class GoogleGenaiService {
     private readonly logger;
     private readonly defaultApiKey;
     constructor(keyBalancer: KeyBalancerApiService);
-    getGoogleGenAIClient(modelName: string, keyTierType?: TierType, modelType?: ModelType): Promise<{
+    getGoogleGenAIClient(modelName: string, keyTierType?: TierType, aiType?: ModelType): Promise<{
         client: GoogleGenAI;
         balancedKey?: AvailableKeyResult;
     }>;

package/services/google-genai.service.js

@@ -26,10 +26,15 @@ let GoogleGenaiService = GoogleGenaiService_1 = class GoogleGenaiService {
             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) {
+    async getGoogleGenAIClient(modelName, keyTierType, aiType) {
         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 (process.env.KEY_BALANCER_HOST && aiType) {
+            const balancedKey = await this.keyBalancer.postQueryKey({
+                provider: 'google',
+                model: modelName,
+                tier: keyTierType,
+                aiType: aiType,
+            });
             if (balancedKey?.apiKey) {
                 this.logger.debug(`Using balanced key: ${balancedKey.name} ${balancedKey.id}`);
                 return { client: new genai_1.GoogleGenAI({ apiKey: balancedKey.apiKey }), balancedKey };

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

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

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

@@ -20,20 +20,20 @@ let KeyBalancerApiService = KeyBalancerApiService_1 = class KeyBalancerApiServic
     constructor(httpService) {
         this.httpService = httpService;
     }
-    async getKey(modelType, model, tier) {
+    async postQueryKey(request) {
         const keyBalancerHost = process.env.KEY_BALANCER_HOST;
         if (!keyBalancerHost) {
             this.logger.error('KEY_BALANCER_HOST environment variable not set.');
             return this.getUnavailableServiceResult();
         }
         try {
-            const url = `${keyBalancerHost}/api/key-balancer/redis/key/${modelType.toLowerCase()}?model=${model}&tier=${tier || ''}`;
+            const url = `${keyBalancerHost}/api/key-balancer/redis/key`;
             this.logger.warn(`Request to: ${url}`);
-            const { data } = await (0, rxjs_1.firstValueFrom)(this.httpService.get(url));
+            const { data } = await (0, rxjs_1.firstValueFrom)(this.httpService.post(url, request));
             return data;
         }
         catch (error) {
-            this.logger.error(`Failed to get ${modelType} key for model ${model} from the external service.`, error.stack);
+            this.logger.error(`Failed to get ${request.aiType} key for model ${request.model} from the external service.`, error.stack);
             return this.getUnavailableServiceResult();
         }
     }

package/services/vertex-image.service.js

@@ -43,7 +43,12 @@ let ImageVertexService = ImageVertexService_1 = class ImageVertexService {
             keyId = 'local';
         }
         else {
-            availableKey = (await this.keyBalancerApiService.getKey(key_balancer_models_1.ModelType.IMAGE, model, key_balancer_models_1.TierType.TIER_1));
+            availableKey = (await this.keyBalancerApiService.postQueryKey({
+                provider: 'google',
+                model: model,
+                tier: key_balancer_models_1.TierType.TIER_1,
+                aiType: key_balancer_models_1.ModelType.IMAGE,
+            }));
             if (availableKey === null) {
                 this.logger.error('KEY BALANCER IS DOWN: :::: No available API key from key balancer.');
             }

package/services/whisper/groq.service.d.ts

@@ -0,0 +1,11 @@
+import Groq from 'groq-sdk';
+import { KeyBalancerApiService } from '../key-balancer-api.service';
+export declare class GroqService {
+    private readonly keyBalancer;
+    private readonly logger;
+    private groq;
+    constructor(keyBalancer: KeyBalancerApiService);
+    private getClientWithKey;
+    private getExtensionFromMimeType;
+    transcribeAudio(fileBuffer: Buffer, originalFileName: string, mimeType: string): Promise<Groq.Audio.Transcriptions.Transcription>;
+}

package/services/whisper/groq.service.js

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var GroqService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroqService = void 0;
+const common_1 = require("@nestjs/common");
+const groq_sdk_1 = __importStar(require("groq-sdk"));
+const path = __importStar(require("path"));
+const key_balancer_api_service_1 = require("../key-balancer-api.service");
+const key_balancer_models_1 = require("dataclouder/nest-vertex/models/key-balancer.models");
+let GroqService = GroqService_1 = class GroqService {
+    keyBalancer;
+    logger = new common_1.Logger(GroqService_1.name);
+    groq;
+    constructor(keyBalancer) {
+        this.keyBalancer = keyBalancer;
+    }
+    getClientWithKey(key) {
+        return new groq_sdk_1.default({ apiKey: key });
+    }
+    getExtensionFromMimeType(mimeType) {
+        switch (mimeType?.toLowerCase()) {
+            case 'audio/wav':
+            case 'audio/x-wav':
+                return '.wav';
+            case 'audio/mpeg':
+                return '.mp3';
+            case 'audio/mp4':
+            case 'video/mp4':
+                return '.mp4';
+            case 'audio/flac':
+                return '.flac';
+            case 'audio/ogg':
+                return '.ogg';
+            case 'audio/opus':
+                return '.opus';
+            case 'audio/webm':
+            case 'video/webm':
+                return '.webm';
+            case 'audio/mpga':
+                return '.mpga';
+            case 'audio/m4a':
+                return '.m4a';
+            default:
+                this.logger.warn(`Unsupported or unknown mime type provided: ${mimeType}`);
+                return null;
+        }
+    }
+    async transcribeAudio(fileBuffer, originalFileName, mimeType) {
+        this.logger.log(`Attempting to transcribe file: ${originalFileName} (${mimeType})`);
+        const extension = this.getExtensionFromMimeType(mimeType);
+        let effectiveFileName = originalFileName;
+        if (extension) {
+            const currentExt = path.extname(originalFileName).toLowerCase();
+            if (currentExt !== extension) {
+                const baseName = path.basename(originalFileName, currentExt);
+                effectiveFileName = `${baseName}${extension}`;
+                this.logger.log(`Adjusted filename to: ${effectiveFileName} based on mime type: ${mimeType}`);
+            }
+            else {
+                this.logger.log(`Filename ${originalFileName} already has correct extension ${extension}`);
+            }
+        }
+        else {
+            this.logger.warn(`Could not determine valid extension for mime type ${mimeType}. Using original filename: ${originalFileName}. Transcription may fail if the filename lacks a supported extension.`);
+        }
+        try {
+            const file = await (0, groq_sdk_1.toFile)(fileBuffer, effectiveFileName, { type: mimeType });
+            const keyResult = await this.keyBalancer.postQueryKey({
+                provider: 'groq',
+                model: 'whisper-large-v3-turbo',
+                tier: key_balancer_models_1.TierType.FREE_TIER,
+                aiType: key_balancer_models_1.ModelType.AUDIO,
+            });
+            const transcription = await this.getClientWithKey(keyResult.apiKey).audio.transcriptions.create({
+                file: file,
+                model: 'whisper-large-v3-turbo',
+                response_format: 'verbose_json',
+                timestamp_granularities: ['word'],
+            });
+            this.logger.log(`Transcription successful for file: ${effectiveFileName}`);
+            return transcription;
+        }
+        catch (error) {
+            this.logger.error(`Error during transcription for file ${effectiveFileName}:`, error?.error || error);
+            const errorMessage = error?.error?.message || (error instanceof Error ? error.message : 'Unknown error during transcription');
+            throw new Error(`Failed to transcribe audio: ${errorMessage}`);
+        }
+    }
+};
+exports.GroqService = GroqService;
+exports.GroqService = GroqService = GroqService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [key_balancer_api_service_1.KeyBalancerApiService])
+], GroqService);
+//# sourceMappingURL=groq.service.js.map