@dataclouder/nest-vertex 0.0.2

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@dataclouder/nest-vertex",
+  "version": "0.0.2",
+  "description": "NestJS Vertex AI library for Dataclouder",
+  "author": "dataclouder",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.lib.json",
+    "publish:npm": "npm run build && npm version patch && npm publish"
+  },
+  "keywords": [
+    "nestjs",
+    "library",
+    "vertex",
+    "ai"
+  ],
+  "peerDependencies": {
+    "@nestjs/common": ">=10.0.0",
+    "@nestjs/core": ">=10.0.0",
+    "rxjs": ">=7.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

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

@@ -0,0 +1,29 @@
+import { Controller, Post, Body, Logger } from '@nestjs/common';
+import { GeminiChatService } from '../services/gemini-chat.service';
+import { ApiTags } from '@nestjs/swagger';
+
+// Basic interface for input messages, similar to ChatCompletionMessageParam
+interface ChatMessageInput {
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+}
+
+@ApiTags('Vertex Gemini') // Keeping tag as 'tts' for now
+@Controller('api/vertex/gemini')
+export class GeminiChatController {
+  private readonly logger = new Logger(GeminiChatController.name);
+
+  constructor(private readonly geminiChatService: GeminiChatService) {}
+
+  @Post('generate-text')
+  async generateText(@Body() messages: ChatMessageInput[]) {
+    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; // Re-throw the error for NestJS to handle
+    }
+  }
+}

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

@@ -0,0 +1,120 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  Res,
+  HttpCode,
+  HttpStatus,
+  Header,
+  Logger,
+  InternalServerErrorException,
+  NotFoundException,
+  Query, // Import Query decorator
+} from '@nestjs/common';
+import { google } from '@google-cloud/text-to-speech/build/protos/protos'; // Import google types
+import { ApiTags, ApiOperation, ApiBody, ApiResponse, ApiQuery } from '@nestjs/swagger'; // Import ApiQuery
+import { FastifyReply } from 'fastify'; // Import FastifyReply type
+import { NestTtsService, SynthesizeSpeechInput } from '../services/nest-tts.service';
+@ApiTags('Vertex TTS') // Keeping tag as 'tts' for now
+@Controller('api/vertex/tts') // Updated route prefix to 'vertex/tts'
+export class NestTtsController {
+  // Keeping class name for now
+  private readonly logger = new Logger('VertexTtsController'); // Updated logger context
+
+  constructor(private readonly nestTtsService: NestTtsService) {}
+
+  @Get('ping') // Renamed from 'generate'/'hello'
+  @ApiOperation({ summary: 'Ping the TTS service' })
+  @ApiResponse({ status: 200, description: 'Service is available' })
+  ping(): string {
+    this.logger.log('Received ping request');
+    return this.nestTtsService.getHello(); // Keep using the simple service method for ping
+  }
+
+  @Post('synthesize')
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: 'Synthesize speech from text' })
+  @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'], // Only 'text' is required
+    },
+  })
+  @ApiResponse({ status: 200, description: 'Returns the synthesized audio file (e.g., MP3)' })
+  @ApiResponse({ status: 500, description: 'Internal server error during synthesis' })
+  @Header('Content-Type', 'audio/mpeg') // Set default, assuming MP3
+  async synthesizeSpeech(
+    @Body() body: SynthesizeSpeechInput,
+    @Res({ passthrough: true }) res: FastifyReply, // Use FastifyReply type
+  ) {
+    console.log('Received synthesize request', body);
+
+    // Removed Promise<Buffer> return type annotation
+    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');
+        // Use NotFoundException or a more specific error if appropriate
+        throw new NotFoundException('Could not generate audio for the given input.');
+      }
+
+      // For testing porpuse
+
+      // // --- Save audio locally as mp3 ---
+      // const audioDir = path.join(process.cwd(), 'public', 'tts-audio'); // Save in project_root/public/tts-audio
+      // const filename = `tts_${Date.now()}.mp3`;
+      // const filePath = path.join(audioDir, filename);
+
+      // try {
+      //   await fs.mkdir(audioDir, { recursive: true }); // Ensure directory exists
+      //   await fs.writeFile(filePath, audioBuffer);
+      //   this.logger.log(`Audio saved successfully to ${filePath}`);
+      // } catch (saveError) {
+      //   // Log the error but don't stop the response from being sent
+      //   this.logger.error(`Failed to save audio file to ${filePath}: ${saveError.message}`, saveError.stack);
+      //   // Optionally, you could throw an error here if saving is critical
+      //   // throw new InternalServerErrorException(`Failed to save audio file: ${saveError.message}`);
+      // }
+      // // --- End save audio ---
+
+      // Set content type based on actual encoding if needed, otherwise default is fine
+      // Example: if (body.audioEncoding === 'OGG_OPUS') res.header('Content-Type', 'audio/ogg');
+      res.header('Content-Length', audioBuffer.length.toString()); // Use res.header for Fastify
+
+      this.logger.log(`Successfully synthesized audio (${audioBuffer.length} bytes)`);
+      return audioBuffer; // NestJS handles sending the buffer
+    } catch (error) {
+      this.logger.error(`Synthesis failed: ${error.message}`, error.stack);
+      // Re-throw as a NestJS exception for proper handling
+      throw new InternalServerErrorException(`Speech synthesis failed: ${error.message}`);
+    }
+  }
+
+  @Get('voices')
+  @ApiOperation({ summary: 'List available TTS voices, optionally filtered by language' })
+  @ApiQuery({ name: 'languageCode', required: false, type: String, description: 'Optional language code (e.g., en-US) to filter voices' })
+  @ApiResponse({ status: 200, description: 'Returns a list of available voices', type: [Object] }) // Using Object as a placeholder for Swagger type
+  @ApiResponse({ status: 500, description: 'Internal server error while fetching voices' })
+  async listVoices(@Query('languageCode') languageCode?: string): Promise<google.cloud.texttospeech.v1.IVoice[]> {
+    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 InternalServerErrorException(`Failed to list voices: ${error.message}`);
+    }
+  }
+}

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

@@ -0,0 +1,53 @@
+import { Controller, Post, Body, ValidationPipe, Logger, Param, Get } from '@nestjs/common';
+import { NestVertexService } from '../services/nest-vertex.service';
+import { GenerateVideoDto } from '../dto/generate-video.dto'; // Updated import path
+import { GenerateImageDto } from '../dto/generate-image.dto'; // Updated import path
+import { GenerateVideosOperation, GenerateImagesResponse } from '@google/genai';
+import { ApiTags } from '@nestjs/swagger';
+
+@ApiTags('Vertex Image/video') // Keeping tag as 'tts' for now
+@Controller('api/vertex')
+export class NestVertexController {
+  private readonly logger = new Logger(NestVertexController.name);
+
+  constructor(private readonly nestVertexService: NestVertexService) {}
+
+  @Post('generate-video')
+  async generateVideo(
+    @Body(new ValidationPipe({ transform: true, whitelist: true })) generateVideoDto: GenerateVideoDto,
+  ): Promise<{ operationName: string }> {
+    this.logger.log(`Received request to generate video: ${JSON.stringify(generateVideoDto)}`);
+    try {
+      const operation: GenerateVideosOperation = await this.nestVertexService.startVideoGeneration(generateVideoDto);
+      return { operationName: operation.name };
+    } catch (error) {
+      this.logger.error('Error in generateVideo endpoint:', error);
+      throw error;
+    }
+  }
+
+  @Get('video-status/:operationName')
+  async getVideoStatus(@Param('operationName') operationName: string): Promise<GenerateVideosOperation> {
+    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;
+    }
+  }
+
+  @Post('generate-image')
+  async generateImage(
+    @Body(new ValidationPipe({ transform: true, whitelist: true })) generateImageDto: GenerateImageDto,
+  ): Promise<GenerateImagesResponse> {
+    this.logger.log(`Received request to generate image: ${JSON.stringify(generateImageDto)}`);
+    try {
+      const response: GenerateImagesResponse = await this.nestVertexService.startImageGeneration(generateImageDto);
+      return response;
+    } catch (error) {
+      this.logger.error('Error in generateImage endpoint:', error);
+      throw error;
+    }
+  }
+}

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

@@ -0,0 +1,53 @@
+// src/vertex/dto/generate-image.dto.ts
+import { IsString, IsNotEmpty, IsOptional, IsInt, Min, Max, IsEnum } from 'class-validator';
+
+export class GenerateImageDto {
+  /**
+   * The text prompt describing the image(s) to generate.
+   * Example: "A futuristic cityscape at sunset"
+   */
+  @IsString()
+  @IsNotEmpty()
+  prompt: string;
+
+  /**
+   * The number of images to generate.
+   * @default 1
+   */
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Max(8) // Assuming a reasonable max, adjust if needed based on API limits
+  numberOfImages?: number = 1;
+
+  /**
+   * Defines the aspect ratio of the generated image(s).
+   * Common values: '1:1', '16:9', '9:16'. Check API docs for exact supported values.
+   * @default '1:1'
+   */
+  @IsOptional()
+  @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"' })
+  aspectRatio?: string = '1:1';
+
+  /**
+   * A text string describing elements to avoid in the generated image(s).
+   * Example: "text, watermark, blurry"
+   */
+  @IsOptional()
+  @IsString()
+  negativePrompt?: string;
+
+  /**
+   * A seed value for deterministic image generation.
+   * Using the same seed and prompt should yield the same result.
+   * Range: 0 - 4,294,967,295
+   */
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  @Max(4294967295)
+  seed?: number;
+
+  // Add other relevant parameters if known from SDK/API docs, e.g.,
+  // style_preset, output_format, quality, etc.
+}

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

@@ -0,0 +1,148 @@
+import {
+  IsString,
+  IsOptional,
+  IsInt,
+  Min,
+  Max,
+  IsBoolean,
+  IsEnum,
+  ValidateNested,
+  IsBase64,
+  Matches,
+  IsNotEmpty,
+  ValidateIf,
+} from 'class-validator';
+import { Type } from 'class-transformer';
+
+/**
+ * Represents the image input for guiding video generation.
+ * Can be either bytesBase64Encoded or gcsUri.
+ */
+class ImageInputDto {
+  /**
+   * Base64-encoded image byte string.
+   * Mutually exclusive with gcsUri.
+   */
+  @IsOptional()
+  @IsBase64()
+  @ValidateIf((o) => !o.gcsUri) // Validate only if gcsUri is not present
+  @IsNotEmpty({ message: 'Either bytesBase64Encoded or gcsUri must be provided in image object' })
+  bytesBase64Encoded?: string;
+
+  /**
+   * Cloud Storage bucket URI (e.g., gs://bucket-name/image.png).
+   * Mutually exclusive with bytesBase64Encoded.
+   */
+  @IsOptional()
+  @IsString()
+  @Matches(/^gs:\/\/.+/, { message: 'gcsUri must be a valid Cloud Storage URI (gs://...)' })
+  @ValidateIf((o) => !o.bytesBase64Encoded) // Validate only if bytesBase64Encoded is not present
+  @IsNotEmpty({ message: 'Either bytesBase64Encoded or gcsUri must be provided in image object' })
+  gcsUri?: string;
+
+  /**
+   * The mime type of the image. Required if image object is provided.
+   * Example: "image/png", "image/jpeg"
+   */
+  @IsString()
+  @IsNotEmpty()
+  mimeType: string;
+}
+
+export class GenerateVideoDto {
+  /**
+   * A text string to guide the first eight seconds in the video.
+   * Mandatory if 'image' is not provided.
+   * Example: "A fast-tracking shot through a bustling dystopian sprawl..."
+   */
+  @IsOptional()
+  @IsString()
+  @ValidateIf((o) => !o.image) // Validate only if image is not present
+  @IsNotEmpty({ message: 'prompt is required if image is not provided' })
+  prompt?: string;
+
+  /**
+   * Image input for guiding video generation.
+   * Optional if 'prompt' is provided.
+   * Recommended: 1280x720 or 720x1280 pixels.
+   */
+  @IsOptional()
+  @ValidateNested()
+  @Type(() => ImageInputDto)
+  image?: ImageInputDto;
+
+  /**
+   * The length of video files that you want to generate.
+   * @default 8
+   */
+  @IsInt()
+  @Min(5)
+  @Max(8)
+  durationSeconds: number = 8; // Default value set
+
+  /**
+   * Defines the aspect ratio of the generated video.
+   * @default '16:9'
+   */
+  @IsOptional()
+  @IsEnum(['16:9', '9:16'], { message: 'aspectRatio must be either "16:9" or "9:16"' })
+  aspectRatio?: string = '16:9'; // Default value set
+
+  /**
+   * A text string that describes anything you want to discourage the model from generating.
+   * Example: "overhead lighting, bright colors"
+   */
+  @IsOptional()
+  @IsString()
+  negativePrompt?: string;
+
+  /**
+   * The safety setting that controls whether people or face generation is allowed.
+   * 'allow_adult': allow generation of adults only.
+   * 'disallow': disallows inclusion of people/faces.
+   * @default 'allow_adult'
+   */
+  @IsOptional()
+  @IsEnum(['allow_adult', 'disallow'], { message: 'personGeneration must be either "allow_adult" or "disallow"' })
+  personGeneration?: string = 'allow_adult'; // Default value set
+
+  /**
+   * The number of output videos requested.
+   * @default 1
+   */
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Max(4)
+  sampleCount?: number = 1; // Default value set
+
+  /**
+   * A number to request to make generated videos deterministic.
+   * Adding a seed number with your request without changing other parameters
+   * will cause the model to produce the same videos.
+   * Range: 0 - 4,294,967,295
+   */
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  @Max(4294967295)
+  seed?: number;
+
+  /**
+   * A Cloud Storage bucket URI to store the output video(s).
+   * If not provided, base64-encoded video bytes are returned in the response.
+   * Pattern: gs://BUCKET_NAME/SUBDIRECTORY
+   */
+  @IsOptional()
+  @IsString()
+  @Matches(/^gs:\/\/.+\/.+/, { message: 'storageUri must be a valid Cloud Storage URI (gs://BUCKET_NAME/SUBDIRECTORY)' })
+  storageUri?: string;
+
+  /**
+   * Use Gemini to enhance your prompts.
+   * @default true
+   */
+  @IsOptional()
+  @IsBoolean()
+  enhancePrompt?: boolean = true; // Default value set
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from './nest-vertex.module';
+// Controller
+export * from './controllers/nest-tts.controller'; // Export TTS controller
+// Services
+export * from './services/nest-vertex.service';
+export * from './services/nest-tts.service'; // Export TTS service and interface
+export * from './services/gemini-chat.service'; // Export GeminiChatService
+// Models
+export * from './dto/generate-image.dto'; // Export GenerateImageDto

package/src/nest-vertex.module.ts

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { NestVertexService } from './services/nest-vertex.service';
+import { NestVertexController } from './controllers/nest-vertex.controller';
+import { NestTtsService } from './services/nest-tts.service'; // Import the TTS service
+import { NestTtsController } from './controllers/nest-tts.controller'; // Import the TTS controller
+import { GeminiChatService } from './services/gemini-chat.service';
+import { GeminiChatController } from './controllers/gemini-chat.controller';
+
+@Module({
+  providers: [NestVertexService, NestTtsService, GeminiChatService], // Add NestTtsService and GeminiChatService to providers
+  exports: [NestVertexService, NestTtsService, GeminiChatService], // Export NestTtsService and GeminiChatService
+  controllers: [NestVertexController, NestTtsController, GeminiChatController], // Add NestTtsController and GeminiChatController to controllers
+})
+export class NestVertexModule {}

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

@@ -0,0 +1,190 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { GoogleGenAI, Content, Model } from '@google/genai'; // Use @google/genai - Removed ListModelsResponse
+import { ChatCompletionMessageParam } from 'groq-sdk/resources/chat/completions'; // Keep for input consistency for now
+
+import { ChatMessageDict, ChatRole } from '@dataclouder/nest-agent-cards/models/agents.models'; // Use existing output format
+
+@Injectable()
+export class GeminiChatService {
+  private readonly logger = new Logger(GeminiChatService.name);
+  private readonly clientGenAi: GoogleGenAI;
+  private readonly modelName = 'gemini-1.5-flash'; // Updated model name
+
+  constructor() {
+    const apiKey = process.env.GEMINI_API_KEY; // Using GEMINI_API_KEY as per example
+    if (!apiKey) {
+      throw new Error('GEMINI_API_KEY environment variable not set.');
+    }
+    // Pass apiKey within an options object
+    this.clientGenAi = new GoogleGenAI({ apiKey });
+    this.logger.log(`GeminiChatService initialized with model: ${this.modelName}`);
+  }
+
+  // Maps incoming roles (Groq/OpenAI style) to Gemini roles for history
+  private mapToGeminiRole(role: ChatCompletionMessageParam['role']): 'user' | 'model' {
+    // Return string literal type
+    switch (role) {
+      case 'assistant':
+        return 'model';
+      case 'system':
+        // System messages aren't directly part of Gemini chat history in the same way.
+        // We extract it separately. Treat as 'user' if forced into history.
+        this.logger.warn('System role encountered, will be extracted, not directly added to Gemini history.');
+        return 'user'; // Fallback if needed, but ideally handled separately
+      case 'user':
+      default:
+        return 'user';
+    }
+  }
+
+  // Formats messages for the @google/genai Content structure (used by generateContent)
+  private formatMessagesToContent(messages: ChatCompletionMessageParam[]): Content[] {
+    return messages
+      .filter((msg) => msg.role !== 'system' && typeof msg.content === 'string') // Exclude system messages and ensure content is string
+      .map((msg) => ({
+        role: this.mapToGeminiRole(msg.role),
+        parts: [{ text: msg.content as string }],
+      }));
+  }
+
+  async chat(messages: ChatCompletionMessageParam[]): Promise<ChatMessageDict> {
+    if (!messages || messages.length === 0) {
+      // this.logger.warn('Gemini chat called with empty messages.');
+      return { content: '', role: ChatRole.Assistant, metadata: { finishReason: 'NO_INPUT' } };
+    }
+
+    // 1. Extract System Prompt
+    const systemMessage = messages.find((msg) => msg.role === 'system')?.content as string | undefined;
+    if (systemMessage) {
+      // this.logger.log(`System prompt extracted: "${systemMessage}"`);
+    }
+
+    // 2. Ensure last message is from user (or add one)
+    let lastMessage = messages[messages.length - 1];
+    if (lastMessage.role !== 'user' || typeof lastMessage.content !== 'string') {
+      // this.logger.warn('Last message was not from user or content invalid, adding default message.');
+      messages.push({ role: 'user', content: 'please say something to start/continue conversation' });
+      lastMessage = messages[messages.length - 1];
+    }
+
+    // 3. Format all non-system messages for the 'contents' parameter
+    const formattedContents = this.formatMessagesToContent(messages); // Pass all valid messages
+
+    // 4. Call generateContent (stateless)
+    try {
+      this.logger.debug(
+        `Sending request to Gemini model ${this.modelName} with ${
+          formattedContents.length
+        } content parts and system instruction: ${!!systemMessage}`,
+      );
+      // Reverted: Call generateContent directly on this.ai.models
+      const response = await this.clientGenAi.models.generateContent({
+        model: this.modelName,
+        contents: formattedContents,
+        config: { systemInstruction: systemMessage },
+      });
+
+      this.logger.debug(`Received Gemini response text.`);
+
+      // Assuming response structure provides text directly based on example
+      // Check the actual type definition of GenerateContentResponse if needed
+      const responseText = response?.text ?? ''; // Safely access text, default to empty string
+
+      return {
+        content: responseText,
+        role: ChatRole.Assistant,
+        metadata: {
+          // Try to access finishReason if available in this response structure
+          // finishReason: response?.candidates?.[0]?.finishReason,
+        },
+      };
+    } catch (error) {
+      this.logger.error(`Gemini chat.sendMessage failed: ${error.message}`, error.stack);
+      // Handle specific errors if possible (e.g., API key, rate limits, safety blocks)
+      throw new Error(`Failed to get Gemini chat completion: ${error.message}`);
+    }
+  }
+
+  async chatStream(messages: ChatCompletionMessageParam[]): Promise<AsyncIterable<ChatMessageDict>> {
+    if (!messages || messages.length === 0) {
+      this.logger.warn('Gemini chatStream called with empty messages.');
+      return (async function* () {})(); // Return an empty async iterable
+    }
+
+    // 1. Extract System Prompt
+    const systemMessage = messages.find((msg) => msg.role === 'system')?.content as string | undefined;
+    if (systemMessage) {
+      this.logger.log(`System prompt extracted for stream: "${systemMessage}"`);
+    }
+
+    // 2. Ensure last message is from user
+    const lastMessage = messages[messages.length - 1];
+    if (lastMessage.role !== 'user' || typeof lastMessage.content !== 'string') {
+      // Unlike non-streaming, we probably shouldn't add a message here.
+      // Streaming usually implies a direct user interaction initiated the stream.
+      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.');
+    }
+
+    // 3. Format all non-system messages for the 'contents' parameter
+    const formattedContents = this.formatMessagesToContent(messages); // Pass all valid messages
+
+    // 4. Call generateContentStream (stateless)
+
+    // Define the async generator using an arrow function to capture 'this' context
+    const processStream = async function* (): AsyncIterable<ChatMessageDict> {
+      try {
+        this.logger.debug(
+          `Sending stream request to Gemini model ${this.modelName} with ${
+            formattedContents.length
+          } content parts and system instruction: ${!!systemMessage}`,
+        );
+        // Reverted: Call generateContentStream directly on this.ai.models
+        const stream = await this.ai.models.generateContentStream({
+          model: this.modelName,
+          contents: formattedContents,
+          config: { systemInstruction: systemMessage },
+        });
+
+        for await (const chunk of stream) {
+          // Assuming chunk structure provides text directly based on generateContent response
+          // Check the actual type definition of GenerateContentResponseStream if needed
+          const chunkText = chunk?.text ?? ''; // Safely access text
+          if (chunkText) {
+            // Only yield if there's text content
+            this.logger.debug(`Received Gemini stream chunk text.`);
+            yield {
+              content: chunkText,
+              role: ChatRole.Assistant,
+              metadata: {
+                isChunk: true,
+                // Try to access finishReason if available in this chunk structure
+                // finishReason: chunk?.candidates?.[0]?.finishReason,
+              },
+            };
+          }
+        }
+        this.logger.debug(`Gemini stream finished.`);
+      } catch (error) {
+        this.logger.error(`Gemini generateContentStream failed: ${error.message}`, error.stack);
+        // Re-throw or yield an error message chunk if preferred
+        throw new Error(`Failed to get Gemini chat stream completion: ${error.message}`);
+      }
+    }.bind(this); // Bind 'this' explicitly for safety, although arrow functions usually handle it
+
+    // Return the invoked generator
+    return processStream();
+  }
+
+  // New method to list available models
+  async listModels(): Promise<Record<string, string>[]> {
+    // Last reserach there is no method to return availible models, so i had to hard coded
+    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' },
+    ];
+  }
+}

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

@@ -0,0 +1,119 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { TextToSpeechClient } from '@google-cloud/text-to-speech';
+import { google } from '@google-cloud/text-to-speech/build/protos/protos'; // For types
+
+// Define interfaces for better type safety
+export interface SynthesizeSpeechInput {
+  text: string;
+  languageCode?: string;
+  ssmlGender?: google.cloud.texttospeech.v1.SsmlVoiceGender;
+  voiceName?: string; // temporary select onlt one voice or voice name
+  voice?: string; // optional voice name
+  audioEncoding?: google.cloud.texttospeech.v1.AudioEncoding;
+  generateTranscription?: boolean;
+  speed?: string;
+  speedRate?: number;
+}
+
+@Injectable()
+export class NestTtsService {
+  // Keeping class name for now
+  private readonly logger = new Logger('VertexTtsService'); // Updated logger context
+  private client: TextToSpeechClient;
+
+  constructor() {
+    // Instantiates a client. Needs GOOGLE_APPLICATION_CREDENTIALS env var set.
+    // See: https://cloud.google.com/docs/authentication/provide-credentials-adc#local-dev
+    this.client = new TextToSpeechClient();
+    this.logger.log('Google TextToSpeechClient initialized.');
+  }
+
+  getHello(): string {
+    return 'Hello from VertexTtsService!'; // Updated message
+  }
+
+  /**
+   * Synthesizes speech from text using Google Cloud TTS.
+   * @param input - The text and configuration for speech synthesis.
+   * @returns A Buffer containing the audio data (e.g., MP3).
+   * @throws Error if synthesis fails.
+   */
+  async synthesizeSpeech(input: SynthesizeSpeechInput): Promise<Buffer | null> {
+    const {
+      text,
+      languageCode, // Default language
+      ssmlGender = 'NEUTRAL', // Default gender
+      voiceName, // Optional specific voice name
+      voice,
+      audioEncoding = 'MP3', // Default audio encoding
+      speedRate,
+    } = input;
+    const voiceId = voiceName || voice;
+    console.log('Selected voice:', voiceId);
+
+    // Seems langcode is required take from voice name
+    const langCode = !languageCode ? voiceId.slice(0, 5) : languageCode;
+
+    const request: google.cloud.texttospeech.v1.ISynthesizeSpeechRequest = {
+      input: { text: text },
+      // Select the language and SSML voice gender (optional)
+      voice: voiceId ? { name: voiceId, languageCode: langCode } : { languageCode: langCode, ssmlGender: ssmlGender },
+      // Select the type of audio encoding and speaking rate
+      audioConfig: {
+        audioEncoding: audioEncoding,
+        speakingRate: speedRate, // Add the speaking rate here
+      },
+    };
+
+    this.logger.log(`Synthesizing speech for text: "${text.substring(0, 50)}..."`);
+
+    try {
+      console.log('request', request);
+      // Performs the text-to-speech 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}`);
+    }
+  }
+
+  /**
+   * Lists available voices from Google Cloud TTS.
+   * Lists available voices from Google Cloud TTS, optionally filtered by language code.
+   * @param languageCode - Optional language code (e.g., 'en-US') to filter voices.
+   * @returns A list of available voices.
+   * @throws Error if listing voices fails.
+   */
+  async listVoices(languageCode?: string): Promise<google.cloud.texttospeech.v1.IVoice[]> {
+    const request: google.cloud.texttospeech.v1.IListVoicesRequest = {};
+    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}`);
+    }
+  }
+}

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

@@ -0,0 +1,184 @@
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
+// Assuming GenerateImagesResponse might be the type, add if available, otherwise use any/unknown
+import { GoogleGenAI, GenerateVideosOperation, GenerateImagesResponse } from '@google/genai';
+import { GenerateVideoDto } from '../dto/generate-video.dto'; // Updated import path
+import { GenerateImageDto } from '../dto/generate-image.dto'; // Updated import path
+
+@Injectable()
+export class NestVertexService implements OnModuleInit {
+  // Renamed class
+  private genAi: GoogleGenAI;
+  private readonly logger = new Logger(NestVertexService.name); // Updated logger name
+  private readonly videoModelName = 'veo-2.0-generate-001';
+  private readonly imageModelName = 'imagen-3.0-generate-002'; // Added image model name
+
+  onModuleInit() {
+    const apiKey = process.env.GEMINI_API_KEY;
+    if (!apiKey) {
+      this.logger.error('GEMINI_API_KEY environment variable not set. NestVertexService will not function.'); // Updated log message
+      // Optionally throw an error to prevent the application from starting
+      // throw new Error('GEMINI_API_KEY environment variable not set.');
+    } else {
+      console.log('GEMINI_API_KEY environment variable set: ', apiKey);
+      this.genAi = new GoogleGenAI({ apiKey });
+      this.logger.log('GoogleGenAI client initialized successfully.');
+    }
+  }
+
+  /**
+   * Starts the video generation process using Google Gen AI.
+   * Starts the video generation process using Google Gen AI based on the provided DTO.
+   * @param generateVideoDto The DTO containing all parameters for video generation.
+   * @returns A Promise resolving to the video generation operation object.
+   */
+  async startVideoGeneration(generateVideoDto: GenerateVideoDto): Promise<GenerateVideosOperation> {
+    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)}`);
+
+    // Construct the request object based on DTO, likely structure for the SDK
+    // Note: The exact structure might need verification against SDK docs/examples if this fails
+    const videoRequest = {
+      model: this.videoModelName,
+      prompt: generateVideoDto.prompt,
+      // Image handling - assuming it's a top-level param or within config
+      ...(generateVideoDto.image && {
+        image: {
+          // Assuming image structure is nested like this
+          bytesBase64Encoded: generateVideoDto.image.bytesBase64Encoded,
+          gcsUri: generateVideoDto.image.gcsUri,
+          mimeType: generateVideoDto.image.mimeType,
+        },
+      }),
+      // Configuration parameters - place them where the SDK expects (e.g., top-level or config object)
+      // Trying top-level first based on common patterns
+      durationSeconds: generateVideoDto.durationSeconds,
+      aspectRatio: generateVideoDto.aspectRatio,
+      negativePrompt: generateVideoDto.negativePrompt,
+      personGeneration: generateVideoDto.personGeneration,
+      sampleCount: generateVideoDto.sampleCount,
+      seed: generateVideoDto.seed,
+      storageUri: generateVideoDto.storageUri,
+      enhancePrompt: generateVideoDto.enhancePrompt,
+      // config: { // Alternative: place parameters inside a 'config' object if needed
+      //   numberOfVideos: generateVideoDto.sampleCount, // Example if sampleCount maps here
+      //   ... other config params
+      // }
+    };
+
+    // Remove undefined optional parameters to avoid sending empty values
+    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 both are undefined after cleanup, remove the image object itself
+      if (Object.keys(videoRequest.image).length === 1 && videoRequest.image.mimeType) {
+        // If only mimeType remains, it's likely an invalid state unless mimeType alone is useful
+        // For safety, let's remove image if both content fields are missing
+        if (!videoRequest.image.bytesBase64Encoded && !videoRequest.image.gcsUri) {
+          delete videoRequest.image;
+        }
+      } else if (Object.keys(videoRequest.image).length === 0) {
+        delete videoRequest.image; // Remove empty image object
+      }
+    }
+
+    try {
+      // Pass the constructed request object
+      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);
+      // Re-throw or handle the error appropriately
+      throw error;
+    }
+  }
+
+  /**
+   * Checks the status of a video generation operation.
+   * IMPORTANT SDK Limitation: The `@google/genai` SDK's `getVideosOperation` method
+   * requires the full operation object, not just the name string, to be passed
+   * in its `operation` parameter (based on TypeScript errors and official examples).
+   * Therefore, this method cannot be directly called from a simple GET endpoint
+   * that only provides the operation name string.
+   *
+   * To implement polling, the client would typically need to store the initial
+   * operation object returned by `startVideoGeneration` and pass it back, or
+   * the server would need to manage operation state differently (e.g., store
+   * operations in a database and poll internally).
+   *
+   * This method is left here as a placeholder demonstrating the intended SDK call,
+   * but it will likely fail if called with just the name string due to the SDK design.
+   *
+   * @param operationName The name of the operation (e.g., "operations/...")
+   * @returns A Promise resolving to the updated operation object.
+   */
+  async checkVideoOperationStatus(operationName: string): Promise<GenerateVideosOperation> {
+    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 {
+      // This call expects the full operation object, not just the name.
+      // Passing only the name string will likely cause a runtime or type error.
+      const oper: GenerateVideosOperation = { name: operationName };
+      const operation = await this.genAi.operations.getVideosOperation({
+        operation: oper, // This line is problematic based on SDK behavior
+      });
+
+      this.logger.log(`Operation ${operationName} status: ${operation.done ? 'Done' : 'Processing'}`);
+      return operation;
+    } catch (error) {
+      this.logger.error(`Error checking status for operation ${operationName}:`, error);
+      // The error might be a TypeError due to the incorrect parameter type.
+      throw error;
+    }
+  }
+
+  /**
+   * Starts the image generation process using Google Gen AI.
+   * @param generateImageDto The DTO containing parameters for image generation.
+   * @returns A Promise resolving to the image generation response.
+   */
+  async startImageGeneration(generateImageDto: GenerateImageDto): Promise<GenerateImagesResponse> {
+    // Use GenerateImagesResponse or adjust type as needed
+    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)}`);
+
+    // Construct the request object for the SDK based on the example
+    const imageRequest = {
+      model: this.imageModelName,
+      prompt: generateImageDto.prompt,
+      config: {
+        numberOfImages: generateImageDto.numberOfImages,
+        aspectRatio: generateImageDto.aspectRatio,
+        negativePrompt: generateImageDto.negativePrompt,
+        // includeRaiReason: true, // Optional, based on example
+        // Add other config parameters from DTO if applicable
+      },
+    };
+
+    // Remove undefined optional parameters from config
+    Object.keys(imageRequest.config).forEach((key) => imageRequest.config[key] === undefined && delete imageRequest.config[key]);
+
+    try {
+      // Pass the constructed request object
+      const response = await this.genAi.models.generateImages(imageRequest);
+      this.logger.log(`Image generation successful for prompt: "${generateImageDto.prompt}"`);
+      // Consider what part of the response to return, e.g., response.generatedImages
+      return response;
+    } catch (error) {
+      this.logger.error('Error starting image generation:', error.message || error);
+      throw error;
+    }
+  }
+}