@dataclouder/nest-vertex 0.0.3 → 0.0.4

package/controllers/gemini-chat.controller.d.ts

@@ -0,0 +1,12 @@
+import { GeminiChatService } from '../services/gemini-chat.service';
+interface ChatMessageInput {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+}
+export declare class GeminiChatController {
+    private readonly geminiChatService;
+    private readonly logger;
+    constructor(geminiChatService: GeminiChatService);
+    generateText(messages: ChatMessageInput[]): Promise<import("../services/gemini-chat.service").ChatMessageDict>;
+}
+export {};

package/controllers/nest-tts.controller.d.ts

@@ -0,0 +1,11 @@
+import { google } from '@google-cloud/text-to-speech/build/protos/protos';
+import { FastifyReply } from 'fastify';
+import { NestTtsService, SynthesizeSpeechInput } from '../services/nest-tts.service';
+export declare class NestTtsController {
+    private readonly nestTtsService;
+    private readonly logger;
+    constructor(nestTtsService: NestTtsService);
+    ping(): string;
+    synthesizeSpeech(body: SynthesizeSpeechInput, res: FastifyReply): Promise<Buffer>;
+    listVoices(languageCode?: string): Promise<google.cloud.texttospeech.v1.IVoice[]>;
+}

package/controllers/nest-vertex.controller.d.ts

@@ -0,0 +1,14 @@
+import { NestVertexService } from '../services/nest-vertex.service';
+import { GenerateVideoDto } from '../dto/generate-video.dto';
+import { GenerateImageDto } from '../dto/generate-image.dto';
+import { GenerateVideosOperation, GenerateImagesResponse } from '@google/genai';
+export declare class NestVertexController {
+    private readonly nestVertexService;
+    private readonly logger;
+    constructor(nestVertexService: NestVertexService);
+    generateVideo(generateVideoDto: GenerateVideoDto): Promise<{
+        operationName: string;
+    }>;
+    getVideoStatus(operationName: string): Promise<GenerateVideosOperation>;
+    generateImage(generateImageDto: GenerateImageDto): Promise<GenerateImagesResponse>;
+}

package/dto/generate-image.dto.d.ts

@@ -0,0 +1,7 @@
+export declare class GenerateImageDto {
+    prompt: string;
+    numberOfImages?: number;
+    aspectRatio?: string;
+    negativePrompt?: string;
+    seed?: number;
+}

package/dto/generate-video.dto.d.ts

@@ -0,0 +1,18 @@
+declare class ImageInputDto {
+    bytesBase64Encoded?: string;
+    gcsUri?: string;
+    mimeType: string;
+}
+export declare class GenerateVideoDto {
+    prompt?: string;
+    image?: ImageInputDto;
+    durationSeconds: number;
+    aspectRatio?: string;
+    negativePrompt?: string;
+    personGeneration?: string;
+    sampleCount?: number;
+    seed?: number;
+    storageUri?: string;
+    enhancePrompt?: boolean;
+}
+export {};

package/index.d.ts

@@ -0,0 +1,6 @@
+export * from './nest-vertex.module';
+export * from './controllers/nest-tts.controller';
+export * from './services/nest-vertex.service';
+export * from './services/nest-tts.service';
+export * from './services/gemini-chat.service';
+export * from './dto/generate-image.dto';

package/index.js

@@ -0,0 +1,978 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ([
+/* 0 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+__exportStar(__webpack_require__(1), exports);
+__exportStar(__webpack_require__(13), exports);
+__exportStar(__webpack_require__(3), exports);
+__exportStar(__webpack_require__(11), exports);
+__exportStar(__webpack_require__(14), exports);
+__exportStar(__webpack_require__(10), exports);
+
+
+/***/ }),
+/* 1 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+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;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.NestVertexModule = void 0;
+const common_1 = __webpack_require__(2);
+const nest_vertex_service_1 = __webpack_require__(3);
+const nest_vertex_controller_1 = __webpack_require__(5);
+const nest_tts_service_1 = __webpack_require__(11);
+const nest_tts_controller_1 = __webpack_require__(13);
+const gemini_chat_service_1 = __webpack_require__(14);
+const gemini_chat_controller_1 = __webpack_require__(15);
+let NestVertexModule = class NestVertexModule {
+};
+exports.NestVertexModule = NestVertexModule;
+exports.NestVertexModule = NestVertexModule = __decorate([
+    (0, common_1.Module)({
+        providers: [nest_vertex_service_1.NestVertexService, nest_tts_service_1.NestTtsService, gemini_chat_service_1.GeminiChatService],
+        exports: [nest_vertex_service_1.NestVertexService, nest_tts_service_1.NestTtsService, gemini_chat_service_1.GeminiChatService],
+        controllers: [nest_vertex_controller_1.NestVertexController, nest_tts_controller_1.NestTtsController, gemini_chat_controller_1.GeminiChatController],
+    })
+], NestVertexModule);
+
+
+/***/ }),
+/* 2 */
+/***/ ((module) => {
+
+module.exports = require("@nestjs/common");
+
+/***/ }),
+/* 3 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+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 NestVertexService_1;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.NestVertexService = void 0;
+const common_1 = __webpack_require__(2);
+const genai_1 = __webpack_require__(4);
+let NestVertexService = NestVertexService_1 = class NestVertexService {
+    genAi;
+    logger = new common_1.Logger(NestVertexService_1.name);
+    videoModelName = 'veo-2.0-generate-001';
+    imageModelName = 'imagen-3.0-generate-002';
+    onModuleInit() {
+        const apiKey = process.env.GEMINI_API_KEY;
+        if (!apiKey) {
+            this.logger.error('GEMINI_API_KEY environment variable not set. NestVertexService will not function.');
+        }
+        else {
+            console.log('GEMINI_API_KEY environment variable set: ', apiKey);
+            this.genAi = new genai_1.GoogleGenAI({ apiKey });
+            this.logger.log('GoogleGenAI client initialized successfully.');
+        }
+    }
+    async startVideoGeneration(generateVideoDto) {
+        if (!this.genAi) {
+            throw new Error('GoogleGenAI client not initialized. Check GEMINI_API_KEY.');
+        }
+        this.logger.log(`Starting video generation with DTO: ${JSON.stringify(generateVideoDto)}`);
+        const videoRequest = {
+            model: this.videoModelName,
+            prompt: generateVideoDto.prompt,
+            ...(generateVideoDto.image && {
+                image: {
+                    bytesBase64Encoded: generateVideoDto.image.bytesBase64Encoded,
+                    gcsUri: generateVideoDto.image.gcsUri,
+                    mimeType: generateVideoDto.image.mimeType,
+                },
+            }),
+            durationSeconds: generateVideoDto.durationSeconds,
+            aspectRatio: generateVideoDto.aspectRatio,
+            negativePrompt: generateVideoDto.negativePrompt,
+            personGeneration: generateVideoDto.personGeneration,
+            sampleCount: generateVideoDto.sampleCount,
+            seed: generateVideoDto.seed,
+            storageUri: generateVideoDto.storageUri,
+            enhancePrompt: generateVideoDto.enhancePrompt,
+        };
+        Object.keys(videoRequest).forEach((key) => videoRequest[key] === undefined && delete videoRequest[key]);
+        if (videoRequest.image) {
+            if (videoRequest.image.bytesBase64Encoded === undefined)
+                delete videoRequest.image.bytesBase64Encoded;
+            if (videoRequest.image.gcsUri === undefined)
+                delete videoRequest.image.gcsUri;
+            if (Object.keys(videoRequest.image).length === 1 && videoRequest.image.mimeType) {
+                if (!videoRequest.image.bytesBase64Encoded && !videoRequest.image.gcsUri) {
+                    delete videoRequest.image;
+                }
+            }
+            else if (Object.keys(videoRequest.image).length === 0) {
+                delete videoRequest.image;
+            }
+        }
+        try {
+            const operation = await this.genAi.models.generateVideos(videoRequest);
+            this.logger.log(`Video generation operation started: ${operation.name}`);
+            return operation;
+        }
+        catch (error) {
+            this.logger.error('Error starting video generation:', error.message || error);
+            throw error;
+        }
+    }
+    async checkVideoOperationStatus(operationName) {
+        if (!this.genAi) {
+            throw new Error('GoogleGenAI client not initialized. Check GEMINI_API_KEY.');
+        }
+        this.logger.warn(`Attempting to check status for operation: ${operationName}. ` +
+            `Note: This may fail due to SDK requiring the full operation object for getVideosOperation.`);
+        try {
+            const oper = { name: operationName };
+            const operation = await this.genAi.operations.getVideosOperation({
+                operation: oper,
+            });
+            this.logger.log(`Operation ${operationName} status: ${operation.done ? 'Done' : 'Processing'}`);
+            return operation;
+        }
+        catch (error) {
+            this.logger.error(`Error checking status for operation ${operationName}:`, error);
+            throw error;
+        }
+    }
+    async startImageGeneration(generateImageDto) {
+        if (!this.genAi) {
+            throw new Error('GoogleGenAI client not initialized. Check GEMINI_API_KEY/Vertex AI setup.');
+        }
+        this.logger.log(`Starting image generation with DTO: ${JSON.stringify(generateImageDto)}`);
+        const imageRequest = {
+            model: this.imageModelName,
+            prompt: generateImageDto.prompt,
+            config: {
+                numberOfImages: generateImageDto.numberOfImages,
+                aspectRatio: generateImageDto.aspectRatio,
+                negativePrompt: generateImageDto.negativePrompt,
+            },
+        };
+        Object.keys(imageRequest.config).forEach((key) => imageRequest.config[key] === undefined && delete imageRequest.config[key]);
+        try {
+            const response = await this.genAi.models.generateImages(imageRequest);
+            this.logger.log(`Image generation successful for prompt: "${generateImageDto.prompt}"`);
+            return response;
+        }
+        catch (error) {
+            this.logger.error('Error starting image generation:', error.message || error);
+            throw error;
+        }
+    }
+};
+exports.NestVertexService = NestVertexService;
+exports.NestVertexService = NestVertexService = NestVertexService_1 = __decorate([
+    (0, common_1.Injectable)()
+], NestVertexService);
+
+
+/***/ }),
+/* 4 */
+/***/ ((module) => {
+
+module.exports = require("@google/genai");
+
+/***/ }),
+/* 5 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+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 NestVertexController_1;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.NestVertexController = void 0;
+const openapi = __webpack_require__(6);
+const common_1 = __webpack_require__(2);
+const nest_vertex_service_1 = __webpack_require__(3);
+const generate_video_dto_1 = __webpack_require__(7);
+const generate_image_dto_1 = __webpack_require__(10);
+const swagger_1 = __webpack_require__(6);
+let NestVertexController = NestVertexController_1 = class NestVertexController {
+    nestVertexService;
+    logger = new common_1.Logger(NestVertexController_1.name);
+    constructor(nestVertexService) {
+        this.nestVertexService = nestVertexService;
+    }
+    async generateVideo(generateVideoDto) {
+        this.logger.log(`Received request to generate video: ${JSON.stringify(generateVideoDto)}`);
+        try {
+            const operation = await this.nestVertexService.startVideoGeneration(generateVideoDto);
+            return { operationName: operation.name };
+        }
+        catch (error) {
+            this.logger.error('Error in generateVideo endpoint:', error);
+            throw error;
+        }
+    }
+    async getVideoStatus(operationName) {
+        this.logger.log(`Received request to check status for operation: ${operationName}`);
+        try {
+            return await this.nestVertexService.checkVideoOperationStatus(operationName);
+        }
+        catch (error) {
+            this.logger.error(`Error checking status for operation ${operationName}:`, error);
+            throw error;
+        }
+    }
+    async generateImage(generateImageDto) {
+        this.logger.log(`Received request to generate image: ${JSON.stringify(generateImageDto)}`);
+        try {
+            const response = await this.nestVertexService.startImageGeneration(generateImageDto);
+            return response;
+        }
+        catch (error) {
+            this.logger.error('Error in generateImage endpoint:', error);
+            throw error;
+        }
+    }
+};
+exports.NestVertexController = NestVertexController;
+__decorate([
+    (0, common_1.Post)('generate-video'),
+    openapi.ApiResponse({ status: 201 }),
+    __param(0, (0, common_1.Body)(new common_1.ValidationPipe({ transform: true, whitelist: true }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [generate_video_dto_1.GenerateVideoDto]),
+    __metadata("design:returntype", Promise)
+], NestVertexController.prototype, "generateVideo", null);
+__decorate([
+    (0, common_1.Get)('video-status/:operationName'),
+    openapi.ApiResponse({ status: 200, type: Object }),
+    __param(0, (0, common_1.Param)('operationName')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], NestVertexController.prototype, "getVideoStatus", null);
+__decorate([
+    (0, common_1.Post)('generate-image'),
+    openapi.ApiResponse({ status: 201 }),
+    __param(0, (0, common_1.Body)(new common_1.ValidationPipe({ transform: true, whitelist: true }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [generate_image_dto_1.GenerateImageDto]),
+    __metadata("design:returntype", Promise)
+], NestVertexController.prototype, "generateImage", null);
+exports.NestVertexController = NestVertexController = NestVertexController_1 = __decorate([
+    (0, swagger_1.ApiTags)('Vertex Image/video'),
+    (0, common_1.Controller)('api/vertex'),
+    __metadata("design:paramtypes", [nest_vertex_service_1.NestVertexService])
+], NestVertexController);
+
+
+/***/ }),
+/* 6 */
+/***/ ((module) => {
+
+module.exports = require("@nestjs/swagger");
+
+/***/ }),
+/* 7 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+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);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.GenerateVideoDto = void 0;
+const openapi = __webpack_require__(6);
+const class_validator_1 = __webpack_require__(8);
+const class_transformer_1 = __webpack_require__(9);
+class ImageInputDto {
+    bytesBase64Encoded;
+    gcsUri;
+    mimeType;
+    static _OPENAPI_METADATA_FACTORY() {
+        return { bytesBase64Encoded: { required: false, type: () => String, format: "base64" }, gcsUri: { required: false, type: () => String, pattern: "/^gs:\\/\\/.+/" }, mimeType: { required: true, type: () => String } };
+    }
+}
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsBase64)(),
+    (0, class_validator_1.ValidateIf)((o) => !o.gcsUri),
+    (0, class_validator_1.IsNotEmpty)({ message: 'Either bytesBase64Encoded or gcsUri must be provided in image object' }),
+    __metadata("design:type", String)
+], ImageInputDto.prototype, "bytesBase64Encoded", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.Matches)(/^gs:\/\/.+/, { message: 'gcsUri must be a valid Cloud Storage URI (gs://...)' }),
+    (0, class_validator_1.ValidateIf)((o) => !o.bytesBase64Encoded),
+    (0, class_validator_1.IsNotEmpty)({ message: 'Either bytesBase64Encoded or gcsUri must be provided in image object' }),
+    __metadata("design:type", String)
+], ImageInputDto.prototype, "gcsUri", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], ImageInputDto.prototype, "mimeType", void 0);
+class GenerateVideoDto {
+    prompt;
+    image;
+    durationSeconds = 8;
+    aspectRatio = '16:9';
+    negativePrompt;
+    personGeneration = 'allow_adult';
+    sampleCount = 1;
+    seed;
+    storageUri;
+    enhancePrompt = true;
+    static _OPENAPI_METADATA_FACTORY() {
+        return { prompt: { required: false, type: () => String }, image: { required: false, type: () => ImageInputDto }, durationSeconds: { required: true, type: () => Number, default: 8, minimum: 5, maximum: 8 }, aspectRatio: { required: false, type: () => String, default: "16:9" }, negativePrompt: { required: false, type: () => String }, personGeneration: { required: false, type: () => String, default: "allow_adult" }, sampleCount: { required: false, type: () => Number, default: 1, minimum: 1, maximum: 4 }, seed: { required: false, type: () => Number, minimum: 0, maximum: 4294967295 }, storageUri: { required: false, type: () => String, pattern: "/^gs:\\/\\/.+\\/.+/" }, enhancePrompt: { required: false, type: () => Boolean, default: true } };
+    }
+}
+exports.GenerateVideoDto = GenerateVideoDto;
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.ValidateIf)((o) => !o.image),
+    (0, class_validator_1.IsNotEmpty)({ message: 'prompt is required if image is not provided' }),
+    __metadata("design:type", String)
+], GenerateVideoDto.prototype, "prompt", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.ValidateNested)(),
+    (0, class_transformer_1.Type)(() => ImageInputDto),
+    __metadata("design:type", ImageInputDto)
+], GenerateVideoDto.prototype, "image", void 0);
+__decorate([
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.Min)(5),
+    (0, class_validator_1.Max)(8),
+    __metadata("design:type", Number)
+], GenerateVideoDto.prototype, "durationSeconds", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsEnum)(['16:9', '9:16'], { message: 'aspectRatio must be either "16:9" or "9:16"' }),
+    __metadata("design:type", String)
+], GenerateVideoDto.prototype, "aspectRatio", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], GenerateVideoDto.prototype, "negativePrompt", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsEnum)(['allow_adult', 'disallow'], { message: 'personGeneration must be either "allow_adult" or "disallow"' }),
+    __metadata("design:type", String)
+], GenerateVideoDto.prototype, "personGeneration", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.Min)(1),
+    (0, class_validator_1.Max)(4),
+    __metadata("design:type", Number)
+], GenerateVideoDto.prototype, "sampleCount", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.Min)(0),
+    (0, class_validator_1.Max)(4294967295),
+    __metadata("design:type", Number)
+], GenerateVideoDto.prototype, "seed", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.Matches)(/^gs:\/\/.+\/.+/, { message: 'storageUri must be a valid Cloud Storage URI (gs://BUCKET_NAME/SUBDIRECTORY)' }),
+    __metadata("design:type", String)
+], GenerateVideoDto.prototype, "storageUri", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsBoolean)(),
+    __metadata("design:type", Boolean)
+], GenerateVideoDto.prototype, "enhancePrompt", void 0);
+
+
+/***/ }),
+/* 8 */
+/***/ ((module) => {
+
+module.exports = require("class-validator");
+
+/***/ }),
+/* 9 */
+/***/ ((module) => {
+
+module.exports = require("class-transformer");
+
+/***/ }),
+/* 10 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+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);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.GenerateImageDto = void 0;
+const openapi = __webpack_require__(6);
+const class_validator_1 = __webpack_require__(8);
+class GenerateImageDto {
+    prompt;
+    numberOfImages = 1;
+    aspectRatio = '1:1';
+    negativePrompt;
+    seed;
+    static _OPENAPI_METADATA_FACTORY() {
+        return { prompt: { required: true, type: () => String }, numberOfImages: { required: false, type: () => Number, default: 1, minimum: 1, maximum: 8 }, aspectRatio: { required: false, type: () => String, default: "1:1" }, negativePrompt: { required: false, type: () => String }, seed: { required: false, type: () => Number, minimum: 0, maximum: 4294967295 } };
+    }
+}
+exports.GenerateImageDto = GenerateImageDto;
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], GenerateImageDto.prototype, "prompt", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.Min)(1),
+    (0, class_validator_1.Max)(8),
+    __metadata("design:type", Number)
+], GenerateImageDto.prototype, "numberOfImages", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsEnum)(['1:1', '16:9', '9:16', '3:4', '4:3'], { message: 'aspectRatio must be one of "1:1", "16:9", "9:16", "3:4", "4:3"' }),
+    __metadata("design:type", String)
+], GenerateImageDto.prototype, "aspectRatio", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], GenerateImageDto.prototype, "negativePrompt", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.Min)(0),
+    (0, class_validator_1.Max)(4294967295),
+    __metadata("design:type", Number)
+], GenerateImageDto.prototype, "seed", void 0);
+
+
+/***/ }),
+/* 11 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+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);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.NestTtsService = void 0;
+const common_1 = __webpack_require__(2);
+const text_to_speech_1 = __webpack_require__(12);
+let NestTtsService = class NestTtsService {
+    logger = new common_1.Logger('VertexTtsService');
+    client;
+    constructor() {
+        this.client = new text_to_speech_1.TextToSpeechClient();
+        this.logger.log('Google TextToSpeechClient initialized.');
+    }
+    getHello() {
+        return 'Hello from VertexTtsService!';
+    }
+    async synthesizeSpeech(input) {
+        const { text, languageCode, ssmlGender = 'NEUTRAL', voiceName, voice, audioEncoding = 'MP3', speedRate, } = input;
+        const voiceId = voiceName || voice;
+        console.log('Selected voice:', voiceId);
+        const langCode = !languageCode ? voiceId.slice(0, 5) : languageCode;
+        const request = {
+            input: { text: text },
+            voice: voiceId ? { name: voiceId, languageCode: langCode } : { languageCode: langCode, ssmlGender: ssmlGender },
+            audioConfig: {
+                audioEncoding: audioEncoding,
+                speakingRate: speedRate,
+            },
+        };
+        this.logger.log(`Synthesizing speech for text: "${text.substring(0, 50)}..."`);
+        try {
+            console.log('request', request);
+            const [response] = await this.client.synthesizeSpeech(request);
+            if (response.audioContent instanceof Uint8Array) {
+                this.logger.log('Speech synthesis successful.');
+                return Buffer.from(response.audioContent);
+            }
+            else {
+                this.logger.warn('No audio content received from TTS API.');
+                return null;
+            }
+        }
+        catch (error) {
+            this.logger.error('Error synthesizing speech:', error);
+            throw new Error(`Failed to synthesize speech: ${error.message}`);
+        }
+    }
+    async listVoices(languageCode) {
+        const request = {};
+        if (languageCode) {
+            request.languageCode = languageCode;
+            this.logger.log(`Fetching list of available voices for language: ${languageCode}...`);
+        }
+        else {
+            this.logger.log('Fetching list of all available voices...');
+        }
+        try {
+            const [response] = await this.client.listVoices(request);
+            if (response.voices) {
+                const count = response.voices.length;
+                this.logger.log(`Successfully fetched ${count} voice${count === 1 ? '' : 's'}${languageCode ? ` for language ${languageCode}` : ''}.`);
+                return response.voices;
+            }
+            else {
+                this.logger.warn('No voices received from TTS API.');
+                return [];
+            }
+        }
+        catch (error) {
+            this.logger.error('Error listing voices:', error);
+            throw new Error(`Failed to list voices: ${error.message}`);
+        }
+    }
+};
+exports.NestTtsService = NestTtsService;
+exports.NestTtsService = NestTtsService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], NestTtsService);
+
+
+/***/ }),
+/* 12 */
+/***/ ((module) => {
+
+module.exports = require("@google-cloud/text-to-speech");
+
+/***/ }),
+/* 13 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+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); }
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.NestTtsController = void 0;
+const openapi = __webpack_require__(6);
+const common_1 = __webpack_require__(2);
+const swagger_1 = __webpack_require__(6);
+const nest_tts_service_1 = __webpack_require__(11);
+let NestTtsController = class NestTtsController {
+    nestTtsService;
+    logger = new common_1.Logger('VertexTtsController');
+    constructor(nestTtsService) {
+        this.nestTtsService = nestTtsService;
+    }
+    ping() {
+        this.logger.log('Received ping request');
+        return this.nestTtsService.getHello();
+    }
+    async synthesizeSpeech(body, res) {
+        console.log('Received synthesize request', body);
+        this.logger.log(`Received synthesize request for text: "${body.text.substring(0, 50)}..."`);
+        try {
+            const audioBuffer = await this.nestTtsService.synthesizeSpeech(body);
+            if (!audioBuffer) {
+                this.logger.error('Synthesis resulted in null buffer');
+                throw new common_1.NotFoundException('Could not generate audio for the given input.');
+            }
+            res.header('Content-Length', audioBuffer.length.toString());
+            this.logger.log(`Successfully synthesized audio (${audioBuffer.length} bytes)`);
+            return audioBuffer;
+        }
+        catch (error) {
+            this.logger.error(`Synthesis failed: ${error.message}`, error.stack);
+            throw new common_1.InternalServerErrorException(`Speech synthesis failed: ${error.message}`);
+        }
+    }
+    async listVoices(languageCode) {
+        this.logger.log(`Received request to list voices${languageCode ? ` for language ${languageCode}` : ''}`);
+        try {
+            const voices = await this.nestTtsService.listVoices(languageCode);
+            this.logger.log(`Returning ${voices.length} voice${voices.length === 1 ? '' : 's'}.`);
+            return voices;
+        }
+        catch (error) {
+            this.logger.error(`Failed to list voices: ${error.message}`, error.stack);
+            throw new common_1.InternalServerErrorException(`Failed to list voices: ${error.message}`);
+        }
+    }
+};
+exports.NestTtsController = NestTtsController;
+__decorate([
+    (0, common_1.Get)('ping'),
+    (0, swagger_1.ApiOperation)({ summary: 'Ping the TTS service' }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Service is available' }),
+    openapi.ApiResponse({ status: 200, type: String }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", String)
+], NestTtsController.prototype, "ping", null);
+__decorate([
+    (0, common_1.Post)('synthesize'),
+    (0, common_1.HttpCode)(common_1.HttpStatus.OK),
+    (0, swagger_1.ApiOperation)({ summary: 'Synthesize speech from text' }),
+    (0, swagger_1.ApiBody)({
+        description: 'Text and configuration for speech synthesis',
+        schema: {
+            type: 'object',
+            properties: {
+                text: { type: 'string', example: 'Hello world' },
+                languageCode: { type: 'string', example: 'en-US', description: 'Optional language code (default: en-US)' },
+                ssmlGender: { type: 'string', example: 'NEUTRAL', description: 'Optional SSML gender (default: NEUTRAL)' },
+                voiceName: { type: 'string', example: 'en-US-Neural2-F', description: 'Optional specific voice name' },
+                audioEncoding: { type: 'string', example: 'MP3', description: 'Optional audio encoding (default: MP3)' },
+            },
+            required: ['text'],
+        },
+    }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Returns the synthesized audio file (e.g., MP3)' }),
+    (0, swagger_1.ApiResponse)({ status: 500, description: 'Internal server error during synthesis' }),
+    (0, common_1.Header)('Content-Type', 'audio/mpeg'),
+    openapi.ApiResponse({ status: common_1.HttpStatus.OK, type: Object }),
+    __param(0, (0, common_1.Body)()),
+    __param(1, (0, common_1.Res)({ passthrough: true })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], NestTtsController.prototype, "synthesizeSpeech", null);
+__decorate([
+    (0, common_1.Get)('voices'),
+    (0, swagger_1.ApiOperation)({ summary: 'List available TTS voices, optionally filtered by language' }),
+    (0, swagger_1.ApiQuery)({ name: 'languageCode', required: false, type: String, description: 'Optional language code (e.g., en-US) to filter voices' }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Returns a list of available voices', type: [Object] }),
+    (0, swagger_1.ApiResponse)({ status: 500, description: 'Internal server error while fetching voices' }),
+    openapi.ApiResponse({ status: 200, type: [Object] }),
+    __param(0, (0, common_1.Query)('languageCode')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], NestTtsController.prototype, "listVoices", null);
+exports.NestTtsController = NestTtsController = __decorate([
+    (0, swagger_1.ApiTags)('Vertex TTS'),
+    (0, common_1.Controller)('api/vertex/tts'),
+    __metadata("design:paramtypes", [nest_tts_service_1.NestTtsService])
+], NestTtsController);
+
+
+/***/ }),
+/* 14 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+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 GeminiChatService_1;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.GeminiChatService = exports.ChatMessageDict = exports.ChatRole = void 0;
+const common_1 = __webpack_require__(2);
+const genai_1 = __webpack_require__(4);
+var ChatRole;
+(function (ChatRole) {
+    ChatRole["System"] = "system";
+    ChatRole["User"] = "user";
+    ChatRole["Assistant"] = "assistant";
+    ChatRole["AssistantHelper"] = "assistantHelper";
+})(ChatRole || (exports.ChatRole = ChatRole = {}));
+class ChatMessageDict {
+    content;
+    role;
+    metadata;
+}
+exports.ChatMessageDict = ChatMessageDict;
+let GeminiChatService = GeminiChatService_1 = class GeminiChatService {
+    logger = new common_1.Logger(GeminiChatService_1.name);
+    clientGenAi;
+    modelName = 'gemini-1.5-flash';
+    constructor() {
+        const apiKey = process.env.GEMINI_API_KEY;
+        if (!apiKey) {
+            throw new Error('GEMINI_API_KEY environment variable not set.');
+        }
+        this.clientGenAi = new genai_1.GoogleGenAI({ apiKey });
+        this.logger.log(`GeminiChatService initialized with model: ${this.modelName}`);
+    }
+    mapToGeminiRole(role) {
+        switch (role) {
+            case 'assistant':
+                return 'model';
+            case 'system':
+                this.logger.warn('System role encountered, will be extracted, not directly added to Gemini history.');
+                return 'user';
+            case 'user':
+            default:
+                return 'user';
+        }
+    }
+    formatMessagesToContent(messages) {
+        return messages
+            .filter((msg) => msg.role !== 'system' && typeof msg.content === 'string')
+            .map((msg) => ({
+            role: this.mapToGeminiRole(msg.role),
+            parts: [{ text: msg.content }],
+        }));
+    }
+    async chat(messages) {
+        if (!messages || messages.length === 0) {
+            return { content: '', role: ChatRole.Assistant, metadata: { finishReason: 'NO_INPUT' } };
+        }
+        const systemMessage = messages.find((msg) => msg.role === 'system')?.content;
+        if (systemMessage) {
+        }
+        let lastMessage = messages[messages.length - 1];
+        if (lastMessage.role !== 'user' || typeof lastMessage.content !== 'string') {
+            messages.push({ role: 'user', content: 'please say something to start/continue conversation' });
+            lastMessage = messages[messages.length - 1];
+        }
+        const formattedContents = this.formatMessagesToContent(messages);
+        try {
+            this.logger.debug(`Sending request to Gemini model ${this.modelName} with ${formattedContents.length} content parts and system instruction: ${!!systemMessage}`);
+            const response = await this.clientGenAi.models.generateContent({
+                model: this.modelName,
+                contents: formattedContents,
+                config: { systemInstruction: systemMessage },
+            });
+            this.logger.debug(`Received Gemini response text.`);
+            const responseText = response?.text ?? '';
+            return {
+                content: responseText,
+                role: ChatRole.Assistant,
+                metadata: {},
+            };
+        }
+        catch (error) {
+            this.logger.error(`Gemini chat.sendMessage failed: ${error.message}`, error.stack);
+            throw new Error(`Failed to get Gemini chat completion: ${error.message}`);
+        }
+    }
+    async chatStream(messages) {
+        if (!messages || messages.length === 0) {
+            this.logger.warn('Gemini chatStream called with empty messages.');
+            return (async function* () { })();
+        }
+        const systemMessage = messages.find((msg) => msg.role === 'system')?.content;
+        if (systemMessage) {
+            this.logger.log(`System prompt extracted for stream: "${systemMessage}"`);
+        }
+        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.');
+            throw new Error('The last message for streaming must be from the user and contain string content.');
+        }
+        const formattedContents = this.formatMessagesToContent(messages);
+        const processStream = async function* () {
+            try {
+                this.logger.debug(`Sending stream request to Gemini model ${this.modelName} with ${formattedContents.length} content parts and system instruction: ${!!systemMessage}`);
+                const stream = await this.ai.models.generateContentStream({
+                    model: this.modelName,
+                    contents: formattedContents,
+                    config: { systemInstruction: systemMessage },
+                });
+                for await (const chunk of stream) {
+                    const chunkText = chunk?.text ?? '';
+                    if (chunkText) {
+                        this.logger.debug(`Received Gemini stream chunk text.`);
+                        yield {
+                            content: chunkText,
+                            role: ChatRole.Assistant,
+                            metadata: {
+                                isChunk: true,
+                            },
+                        };
+                    }
+                }
+                this.logger.debug(`Gemini stream finished.`);
+            }
+            catch (error) {
+                this.logger.error(`Gemini generateContentStream failed: ${error.message}`, error.stack);
+                throw new Error(`Failed to get Gemini chat stream completion: ${error.message}`);
+            }
+        }.bind(this);
+        return processStream();
+    }
+    async listModels() {
+        return [
+            { id: 'gemini-2.5-flash-preview-04-17' },
+            { id: 'gemini-2.5-pro-preview-03-25' },
+            { id: 'gemini-2.0-flash' },
+            { id: 'gemini-2.0-flash-lite' },
+            { id: 'gemini-2.0-flash-live-001' },
+        ];
+    }
+};
+exports.GeminiChatService = GeminiChatService;
+exports.GeminiChatService = GeminiChatService = GeminiChatService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], GeminiChatService);
+
+
+/***/ }),
+/* 15 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+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 GeminiChatController_1;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.GeminiChatController = void 0;
+const openapi = __webpack_require__(6);
+const common_1 = __webpack_require__(2);
+const gemini_chat_service_1 = __webpack_require__(14);
+const swagger_1 = __webpack_require__(6);
+let GeminiChatController = GeminiChatController_1 = class GeminiChatController {
+    geminiChatService;
+    logger = new common_1.Logger(GeminiChatController_1.name);
+    constructor(geminiChatService) {
+        this.geminiChatService = geminiChatService;
+    }
+    async generateText(messages) {
+        this.logger.log('Received request for text generation');
+        try {
+            const result = await this.geminiChatService.chat(messages);
+            return result;
+        }
+        catch (error) {
+            this.logger.error(`Error generating text: ${error.message}`, error.stack);
+            throw error;
+        }
+    }
+};
+exports.GeminiChatController = GeminiChatController;
+__decorate([
+    (0, common_1.Post)('generate-text'),
+    openapi.ApiResponse({ status: 201, type: (__webpack_require__(14).ChatMessageDict) }),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], GeminiChatController.prototype, "generateText", null);
+exports.GeminiChatController = GeminiChatController = GeminiChatController_1 = __decorate([
+    (0, swagger_1.ApiTags)('Vertex Gemini'),
+    (0, common_1.Controller)('api/vertex/gemini'),
+    __metadata("design:paramtypes", [gemini_chat_service_1.GeminiChatService])
+], GeminiChatController);
+
+
+/***/ })
+/******/ 	]);
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__(0);
+/******/ 	
+/******/ })()
+;

package/nest-vertex.module.d.ts

@@ -0,0 +1,2 @@
+export declare class NestVertexModule {
+}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@dataclouder/nest-vertex",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "NestJS Vertex AI library for Dataclouder",
   "author": "dataclouder",
   "license": "MIT",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "index.js",
+  "types": "index.d.ts",
   "files": [
-    "dist",
-    "src"
+    "**/*.js",
+    "**/*.d.ts"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.lib.json",

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

@@ -0,0 +1,23 @@
+import { ChatCompletionMessageParam } from 'groq-sdk/resources/chat/completions';
+export declare enum ChatRole {
+    System = "system",
+    User = "user",
+    Assistant = "assistant",
+    AssistantHelper = "assistantHelper"
+}
+export declare class ChatMessageDict {
+    content: string;
+    role: ChatRole;
+    metadata?: any;
+}
+export declare class GeminiChatService {
+    private readonly logger;
+    private readonly clientGenAi;
+    private readonly modelName;
+    constructor();
+    private mapToGeminiRole;
+    private formatMessagesToContent;
+    chat(messages: ChatCompletionMessageParam[]): Promise<ChatMessageDict>;
+    chatStream(messages: ChatCompletionMessageParam[]): Promise<AsyncIterable<ChatMessageDict>>;
+    listModels(): Promise<Record<string, string>[]>;
+}

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

@@ -0,0 +1,20 @@
+import { google } from '@google-cloud/text-to-speech/build/protos/protos';
+export interface SynthesizeSpeechInput {
+    text: string;
+    languageCode?: string;
+    ssmlGender?: google.cloud.texttospeech.v1.SsmlVoiceGender;
+    voiceName?: string;
+    voice?: string;
+    audioEncoding?: google.cloud.texttospeech.v1.AudioEncoding;
+    generateTranscription?: boolean;
+    speed?: string;
+    speedRate?: number;
+}
+export declare class NestTtsService {
+    private readonly logger;
+    private client;
+    constructor();
+    getHello(): string;
+    synthesizeSpeech(input: SynthesizeSpeechInput): Promise<Buffer | null>;
+    listVoices(languageCode?: string): Promise<google.cloud.texttospeech.v1.IVoice[]>;
+}

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

@@ -0,0 +1,14 @@
+import { OnModuleInit } from '@nestjs/common';
+import { GenerateVideosOperation, GenerateImagesResponse } from '@google/genai';
+import { GenerateVideoDto } from '../dto/generate-video.dto';
+import { GenerateImageDto } from '../dto/generate-image.dto';
+export declare class NestVertexService implements OnModuleInit {
+    private genAi;
+    private readonly logger;
+    private readonly videoModelName;
+    private readonly imageModelName;
+    onModuleInit(): void;
+    startVideoGeneration(generateVideoDto: GenerateVideoDto): Promise<GenerateVideosOperation>;
+    checkVideoOperationStatus(operationName: string): Promise<GenerateVideosOperation>;
+    startImageGeneration(generateImageDto: GenerateImageDto): Promise<GenerateImagesResponse>;
+}