@felores/kie-ai-mcp-server 1.0.2 → 1.1.0

package/README.md

@@ -5,7 +5,8 @@ An MCP (Model Context Protocol) server that provides access to Kie.ai's AI APIs
 ## Features
 
 - **Nano Banana Image Generation**: Text-to-image generation using Google's Gemini 2.5 Flash Image Preview
-- **Nano Banana Image Editing**: Natural language image editing with up to 5 input images
+- **Nano Banana Image Editing**: Natural language image editing with up to 10 input images
+- **Nano Banana Image Upscaling**: Upscale images 1-4x with optional face enhancement
 - **Veo3 Video Generation**: Professional-quality video generation with text-to-video and image-to-video capabilities
 - **1080p Video Upgrade**: Get high-definition versions of Veo3 videos
 - **Task Management**: SQLite-based task tracking with status polling
@@ -22,14 +23,14 @@ An MCP (Model Context Protocol) server that provides access to Kie.ai's AI APIs
 ### From NPM
 
 ```bash
-npm install -g @andrewlwn77/kie-ai-mcp-server
+npm install -g @felores/kie-ai-mcp-server
 ```
 
 ### From Source
 
 ```bash
 # Clone the repository
-git clone https://github.com/andrewlwn77/kie-ai-mcp-server.git
+git clone https://github.com/felores/kie-ai-mcp-server.git
 cd kie-ai-mcp-server
 
 # Install dependencies
@@ -75,7 +76,7 @@ Or if installed globally:
 {
   "kie-ai-mcp-server": {
     "command": "npx",
-    "args": ["-y", "@andrewlwn77/kie-ai-mcp-server"],
+    "args": ["-y", "@felores/kie-ai-mcp-server"],
     "env": {
       "KIE_AI_API_KEY": "your-api-key-here"
     }
@@ -89,12 +90,16 @@ Or if installed globally:
 Generate images using Nano Banana.
 
 **Parameters:**
-- `prompt` (string, required): Text description of the image to generate
+- `prompt` (string, required): Text description of the image to generate (max 5000 chars)
+- `output_format` (string, optional): "png" or "jpeg" (default: "png")
+- `image_size` (string, optional): Aspect ratio - "1:1", "9:16", "16:9", "3:4", "4:3", "3:2", "2:3", "5:4", "4:5", "21:9", "auto" (default: "1:1")
 
 **Example:**
 ```json
 {
-  "prompt": "A surreal painting of a giant banana floating in space"
+  "prompt": "A surreal painting of a giant banana floating in space",
+  "output_format": "png",
+  "image_size": "16:9"
 }
 ```
 
@@ -102,18 +107,39 @@ Generate images using Nano Banana.
 Edit images using natural language prompts.
 
 **Parameters:**
-- `prompt` (string, required): Description of edits to make
-- `image_urls` (array, required): URLs of images to edit (max 5)
+- `prompt` (string, required): Description of edits to make (max 5000 chars)
+- `image_urls` (array, required): URLs of images to edit (max 10)
+- `output_format` (string, optional): "png" or "jpeg" (default: "png")
+- `image_size` (string, optional): Aspect ratio (default: "1:1")
 
 **Example:**
 ```json
 {
   "prompt": "Add a rainbow arching over the mountains",
-  "image_urls": ["https://example.com/image.jpg"]
+  "image_urls": ["https://example.com/image.jpg"],
+  "output_format": "png",
+  "image_size": "16:9"
 }
 ```
 
-### 3. `generate_veo3_video`
+### 3. `upscale_nano_banana`
+Upscale images with optional face enhancement.
+
+**Parameters:**
+- `image` (string, required): URL of image to upscale (max 10MB, jpeg/png/webp)
+- `scale` (integer, optional): Upscale factor 1-4 (default: 2)
+- `face_enhance` (boolean, optional): Enable GFPGAN face enhancement (default: false)
+
+**Example:**
+```json
+{
+  "image": "https://example.com/image.jpg",
+  "scale": 4,
+  "face_enhance": true
+}
+```
+
+### 4. `generate_veo3_video`
 Generate videos using Veo3.
 
 **Parameters:**
@@ -135,20 +161,20 @@ Generate videos using Veo3.
 }
 ```
 
-### 4. `get_task_status`
+### 5. `get_task_status`
 Check the status of a generation task.
 
 **Parameters:**
 - `task_id` (string, required): Task ID to check
 
-### 5. `list_tasks`
+### 6. `list_tasks`
 List recent tasks with their status.
 
 **Parameters:**
 - `limit` (integer, optional): Max tasks to return (default: 20, max: 100)
 - `status` (string, optional): Filter by status ("pending", "processing", "completed", "failed")
 
-### 6. `get_veo3_1080p_video`
+### 7. `get_veo3_1080p_video`
 Get 1080P high-definition version of a Veo3 video.
 
 **Parameters:**
@@ -164,10 +190,12 @@ The server interfaces with these Kie.ai API endpoints:
 - **Veo3 Video Generation**: `POST /api/v1/veo/generate` ✅ **VALIDATED**
 - **Veo3 Video Status**: `GET /api/v1/veo/record-info` ✅ **VALIDATED**  
 - **Veo3 1080p Upgrade**: `GET /api/v1/veo/get-1080p-video` ✅ **VALIDATED**
-- **Nano Banana Generation**: `POST /api/v1/playground/createTask` ✅ **VALIDATED**
-- **Nano Banana Status**: `GET /api/v1/playground/recordInfo` ✅ **VALIDATED**
+- **Nano Banana Generation**: `POST /api/v1/jobs/createTask` 
+- **Nano Banana Edit**: `POST /api/v1/jobs/createTask`
+- **Nano Banana Upscale**: `POST /api/v1/jobs/createTask`
+- **Nano Banana Status**: `GET /api/v1/jobs/recordInfo`
 
-All endpoints have been tested and validated with live API responses.
+All endpoints follow official Kie.ai API documentation.
 
 ## Database Schema
 
@@ -285,7 +313,7 @@ See https://kie.ai/billing for detailed pricing.
 ## Support
 
 For issues related to:
-- **MCP Server**: Open an issue at https://github.com/andrewlwn77/kie-ai-mcp-server/issues
+- **MCP Server**: Open an issue at https://github.com/felores/kie-ai-mcp-server/issues
 - **Kie.ai API**: Contact support@kie.ai or check https://docs.kie.ai/
 - **API Keys**: Visit https://kie.ai/api-key
 
@@ -303,7 +331,31 @@ MIT License - see LICENSE file for details.
 
 ## Changelog
 
-### v1.0.0
+### v1.1.0 (2025-01-14)
+
+**Breaking Changes:**
+- Migrated from `/playground/*` to official `/jobs/*` API endpoints for all Nano Banana operations
+- Updated status check endpoint from `/playground/recordInfo` to `/jobs/recordInfo`
+
+**New Features:**
+- Added `upscale_nano_banana` tool for image upscaling (1-4x) with optional GFPGAN face enhancement
+- Added `output_format` parameter (png/jpeg) to `generate_nano_banana` and `edit_nano_banana`
+- Added `image_size` parameter (11 aspect ratios) to `generate_nano_banana` and `edit_nano_banana`
+
+**Improvements:**
+- Increased prompt max length from 1,000 to 5,000 characters for Nano Banana tools
+- Increased max input images from 5 to 10 for `edit_nano_banana`
+- Enhanced `get_task_status` to properly parse `resultJson` and extract result URLs
+- Improved task status mapping: `waiting` → `processing`, `success` → `completed`, `fail` → `failed`
+- Task status now automatically updates local database with API responses
+- Better error message handling from API responses
+
+**Documentation:**
+- Updated README with all new parameters and tools
+- Corrected API endpoints to match official Kie.ai documentation
+- Added comprehensive examples for all tools
+
+### v1.0.0 (2024-12-XX)
 - Initial release
 - Nano Banana image generation and editing
 - Veo3 video generation

package/dist/index.js

@@ -4,7 +4,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
 import { KieAiClient } from './kie-ai-client.js';
 import { TaskDatabase } from './database.js';
-import { NanoBananaGenerateSchema, NanoBananaEditSchema, Veo3GenerateSchema } from './types.js';
+import { NanoBananaGenerateSchema, NanoBananaEditSchema, NanoBananaUpscaleSchema, Veo3GenerateSchema } from './types.js';
 class KieAiMcpServer {
     server;
     client;
@@ -12,7 +12,7 @@ class KieAiMcpServer {
     constructor() {
         this.server = new Server({
             name: 'kie-ai-mcp-server',
-            version: '1.0.0',
+            version: '1.1.0',
         });
         // Initialize client with config from environment
         const config = {
@@ -41,7 +41,19 @@ class KieAiMcpServer {
                                     type: 'string',
                                     description: 'Text prompt for image generation',
                                     minLength: 1,
-                                    maxLength: 1000
+                                    maxLength: 5000
+                                },
+                                output_format: {
+                                    type: 'string',
+                                    enum: ['png', 'jpeg'],
+                                    description: 'Output format for the images',
+                                    default: 'png'
+                                },
+                                image_size: {
+                                    type: 'string',
+                                    enum: ['1:1', '9:16', '16:9', '3:4', '4:3', '3:2', '2:3', '5:4', '4:5', '21:9', 'auto'],
+                                    description: 'Aspect ratio for the output image',
+                                    default: '1:1'
                                 }
                             },
                             required: ['prompt']
@@ -57,19 +69,58 @@ class KieAiMcpServer {
                                     type: 'string',
                                     description: 'Text prompt for image editing',
                                     minLength: 1,
-                                    maxLength: 1000
+                                    maxLength: 5000
                                 },
                                 image_urls: {
                                     type: 'array',
-                                    description: 'URLs of input images for editing (max 5)',
+                                    description: 'URLs of input images for editing (max 10)',
                                     items: { type: 'string', format: 'uri' },
                                     minItems: 1,
-                                    maxItems: 5
+                                    maxItems: 10
+                                },
+                                output_format: {
+                                    type: 'string',
+                                    enum: ['png', 'jpeg'],
+                                    description: 'Output format for the images',
+                                    default: 'png'
+                                },
+                                image_size: {
+                                    type: 'string',
+                                    enum: ['1:1', '9:16', '16:9', '3:4', '4:3', '3:2', '2:3', '5:4', '4:5', '21:9', 'auto'],
+                                    description: 'Aspect ratio for the output image',
+                                    default: '1:1'
                                 }
                             },
                             required: ['prompt', 'image_urls']
                         }
                     },
+                    {
+                        name: 'upscale_nano_banana',
+                        description: 'Upscale images using Nano Banana Upscale with optional face enhancement',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                image: {
+                                    type: 'string',
+                                    format: 'uri',
+                                    description: 'URL of the image to upscale (max 10MB, jpeg/png/webp)'
+                                },
+                                scale: {
+                                    type: 'integer',
+                                    description: 'Upscale factor (1-4)',
+                                    minimum: 1,
+                                    maximum: 4,
+                                    default: 2
+                                },
+                                face_enhance: {
+                                    type: 'boolean',
+                                    description: 'Enable GFPGAN face enhancement',
+                                    default: false
+                                }
+                            },
+                            required: ['image']
+                        }
+                    },
                     {
                         name: 'generate_veo3_video',
                         description: 'Generate professional-quality videos using Google\'s Veo3 API',
@@ -184,6 +235,8 @@ class KieAiMcpServer {
                         return await this.handleGenerateNanoBanana(args);
                     case 'edit_nano_banana':
                         return await this.handleEditNanoBanana(args);
+                    case 'upscale_nano_banana':
+                        return await this.handleUpscaleNanoBanana(args);
                     case 'generate_veo3_video':
                         return await this.handleGenerateVeo3Video(args);
                     case 'get_task_status':
@@ -285,6 +338,46 @@ class KieAiMcpServer {
             };
         }
     }
+    async handleUpscaleNanoBanana(args) {
+        const request = NanoBananaUpscaleSchema.parse(args);
+        try {
+            const response = await this.client.upscaleNanaBanana(request);
+            if (response.data?.taskId) {
+                await this.db.createTask({
+                    task_id: response.data.taskId,
+                    api_type: 'nano-banana-upscale',
+                    status: 'pending',
+                    result_url: response.data.imageUrl
+                });
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            response: response,
+                            message: 'Nano Banana upscale initiated'
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Upscale failed';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: false,
+                            error: message
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+    }
     async handleGenerateVeo3Video(args) {
         const request = Veo3GenerateSchema.parse(args);
         try {
@@ -334,21 +427,54 @@ class KieAiMcpServer {
             const localTask = await this.db.getTask(task_id);
             // Always try to get updated status from API, passing api_type if available
             let apiResponse = null;
+            let parsedResult = null;
             try {
                 apiResponse = await this.client.getTaskStatus(task_id, localTask?.api_type);
+                // Update local database with API response
+                if (apiResponse?.data) {
+                    const { state, resultJson, failCode, failMsg } = apiResponse.data;
+                    // Map API state to our status
+                    let status = 'pending';
+                    if (state === 'success')
+                        status = 'completed';
+                    else if (state === 'fail')
+                        status = 'failed';
+                    else if (state === 'waiting')
+                        status = 'processing';
+                    // Parse resultJson if available
+                    if (resultJson) {
+                        try {
+                            parsedResult = JSON.parse(resultJson);
+                        }
+                        catch (e) {
+                            // Invalid JSON in resultJson
+                        }
+                    }
+                    // Update database
+                    await this.db.updateTask(task_id, {
+                        status,
+                        result_url: parsedResult?.resultUrls?.[0] || undefined,
+                        error_message: failMsg || undefined
+                    });
+                }
             }
             catch (error) {
                 // API call failed, use local data if available
             }
+            // Fetch updated local task
+            const updatedTask = await this.db.getTask(task_id);
             return {
                 content: [
                     {
                         type: 'text',
                         text: JSON.stringify({
                             success: true,
-                            local_task: localTask,
+                            task_id: task_id,
+                            status: apiResponse?.data?.state || updatedTask?.status,
+                            result_urls: parsedResult?.resultUrls || (updatedTask?.result_url ? [updatedTask.result_url] : []),
+                            error: apiResponse?.data?.failMsg || updatedTask?.error_message,
                             api_response: apiResponse,
-                            message: localTask ? 'Task found' : 'Task not found in local database'
+                            message: updatedTask ? 'Task found' : 'Task not found in local database'
                         }, null, 2)
                     }
                 ]

package/dist/kie-ai-client.d.ts

@@ -1,10 +1,11 @@
-import { KieAiConfig, KieAiResponse, NanoBananaGenerateRequest, NanaBananaEditRequest, Veo3GenerateRequest, ImageResponse, TaskResponse } from './types.js';
+import { KieAiConfig, KieAiResponse, NanoBananaGenerateRequest, NanaBananaEditRequest, NanoBananaUpscaleRequest, Veo3GenerateRequest, ImageResponse, TaskResponse } from './types.js';
 export declare class KieAiClient {
     private config;
     constructor(config: KieAiConfig);
     private makeRequest;
     generateNanoBanana(request: NanoBananaGenerateRequest): Promise<KieAiResponse<ImageResponse>>;
     editNanoBanana(request: NanaBananaEditRequest): Promise<KieAiResponse<ImageResponse>>;
+    upscaleNanaBanana(request: NanoBananaUpscaleRequest): Promise<KieAiResponse<ImageResponse>>;
     generateVeo3Video(request: Veo3GenerateRequest): Promise<KieAiResponse<TaskResponse>>;
     getTaskStatus(taskId: string, apiType?: string): Promise<KieAiResponse<any>>;
     getVeo1080pVideo(taskId: string, index?: number): Promise<KieAiResponse<any>>;

package/dist/kie-ai-client.js

@@ -33,23 +33,38 @@ export class KieAiClient {
         }
     }
     async generateNanoBanana(request) {
-        const playgroundRequest = {
+        const jobRequest = {
             model: 'google/nano-banana',
             input: {
-                prompt: request.prompt
+                prompt: request.prompt,
+                ...(request.output_format && { output_format: request.output_format }),
+                ...(request.image_size && { image_size: request.image_size })
             }
         };
-        return this.makeRequest('/playground/createTask', 'POST', playgroundRequest);
+        return this.makeRequest('/jobs/createTask', 'POST', jobRequest);
     }
     async editNanoBanana(request) {
-        const playgroundRequest = {
+        const jobRequest = {
             model: 'google/nano-banana-edit',
             input: {
                 prompt: request.prompt,
-                image_urls: request.image_urls
+                image_urls: request.image_urls,
+                ...(request.output_format && { output_format: request.output_format }),
+                ...(request.image_size && { image_size: request.image_size })
+            }
+        };
+        return this.makeRequest('/jobs/createTask', 'POST', jobRequest);
+    }
+    async upscaleNanaBanana(request) {
+        const jobRequest = {
+            model: 'nano-banana-upscale',
+            input: {
+                image: request.image,
+                ...(request.scale !== undefined && { scale: request.scale }),
+                ...(request.face_enhance !== undefined && { face_enhance: request.face_enhance })
             }
         };
-        return this.makeRequest('/playground/createTask', 'POST', playgroundRequest);
+        return this.makeRequest('/jobs/createTask', 'POST', jobRequest);
     }
     async generateVeo3Video(request) {
         return this.makeRequest('/veo/generate', 'POST', request);
@@ -59,12 +74,12 @@ export class KieAiClient {
         if (apiType === 'veo3') {
             return this.makeRequest(`/veo/record-info?taskId=${taskId}`, 'GET');
         }
-        else if (apiType === 'nano-banana' || apiType === 'nano-banana-edit') {
-            return this.makeRequest(`/playground/recordInfo?taskId=${taskId}`, 'GET');
+        else if (apiType === 'nano-banana' || apiType === 'nano-banana-edit' || apiType === 'nano-banana-upscale') {
+            return this.makeRequest(`/jobs/recordInfo?taskId=${taskId}`, 'GET');
         }
-        // Fallback: try playground first, then veo (for tasks not in database)
+        // Fallback: try jobs first, then veo (for tasks not in database)
         try {
-            return await this.makeRequest(`/playground/recordInfo?taskId=${taskId}`, 'GET');
+            return await this.makeRequest(`/jobs/recordInfo?taskId=${taskId}`, 'GET');
         }
         catch (error) {
             try {

package/dist/types.d.ts

@@ -1,20 +1,45 @@
 import { z } from 'zod';
 export declare const NanoBananaGenerateSchema: z.ZodObject<{
     prompt: z.ZodString;
+    output_format: z.ZodOptional<z.ZodDefault<z.ZodEnum<["png", "jpeg"]>>>;
+    image_size: z.ZodOptional<z.ZodDefault<z.ZodEnum<["1:1", "9:16", "16:9", "3:4", "4:3", "3:2", "2:3", "5:4", "4:5", "21:9", "auto"]>>>;
 }, "strip", z.ZodTypeAny, {
     prompt: string;
+    output_format?: "png" | "jpeg" | undefined;
+    image_size?: "1:1" | "9:16" | "16:9" | "3:4" | "4:3" | "3:2" | "2:3" | "5:4" | "4:5" | "21:9" | "auto" | undefined;
 }, {
     prompt: string;
+    output_format?: "png" | "jpeg" | undefined;
+    image_size?: "1:1" | "9:16" | "16:9" | "3:4" | "4:3" | "3:2" | "2:3" | "5:4" | "4:5" | "21:9" | "auto" | undefined;
 }>;
 export declare const NanoBananaEditSchema: z.ZodObject<{
     prompt: z.ZodString;
     image_urls: z.ZodArray<z.ZodString, "many">;
+    output_format: z.ZodOptional<z.ZodDefault<z.ZodEnum<["png", "jpeg"]>>>;
+    image_size: z.ZodOptional<z.ZodDefault<z.ZodEnum<["1:1", "9:16", "16:9", "3:4", "4:3", "3:2", "2:3", "5:4", "4:5", "21:9", "auto"]>>>;
 }, "strip", z.ZodTypeAny, {
     prompt: string;
     image_urls: string[];
+    output_format?: "png" | "jpeg" | undefined;
+    image_size?: "1:1" | "9:16" | "16:9" | "3:4" | "4:3" | "3:2" | "2:3" | "5:4" | "4:5" | "21:9" | "auto" | undefined;
 }, {
     prompt: string;
     image_urls: string[];
+    output_format?: "png" | "jpeg" | undefined;
+    image_size?: "1:1" | "9:16" | "16:9" | "3:4" | "4:3" | "3:2" | "2:3" | "5:4" | "4:5" | "21:9" | "auto" | undefined;
+}>;
+export declare const NanoBananaUpscaleSchema: z.ZodObject<{
+    image: z.ZodString;
+    scale: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    face_enhance: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    image: string;
+    scale?: number | undefined;
+    face_enhance?: boolean | undefined;
+}, {
+    image: string;
+    scale?: number | undefined;
+    face_enhance?: boolean | undefined;
 }>;
 export declare const Veo3GenerateSchema: z.ZodObject<{
     prompt: z.ZodString;
@@ -28,7 +53,7 @@ export declare const Veo3GenerateSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     prompt: string;
     model: "veo3" | "veo3_fast";
-    aspectRatio: "16:9" | "9:16";
+    aspectRatio: "9:16" | "16:9";
     enableFallback: boolean;
     imageUrls?: string[] | undefined;
     watermark?: string | undefined;
@@ -39,13 +64,14 @@ export declare const Veo3GenerateSchema: z.ZodObject<{
     imageUrls?: string[] | undefined;
     model?: "veo3" | "veo3_fast" | undefined;
     watermark?: string | undefined;
-    aspectRatio?: "16:9" | "9:16" | undefined;
+    aspectRatio?: "9:16" | "16:9" | undefined;
     seeds?: number | undefined;
     callBackUrl?: string | undefined;
     enableFallback?: boolean | undefined;
 }>;
 export type NanoBananaGenerateRequest = z.infer<typeof NanoBananaGenerateSchema>;
 export type NanaBananaEditRequest = z.infer<typeof NanoBananaEditSchema>;
+export type NanoBananaUpscaleRequest = z.infer<typeof NanoBananaUpscaleSchema>;
 export type Veo3GenerateRequest = z.infer<typeof Veo3GenerateSchema>;
 export interface KieAiResponse<T = any> {
     code: number;
@@ -62,7 +88,7 @@ export interface TaskResponse {
 export interface TaskRecord {
     id?: number;
     task_id: string;
-    api_type: 'nano-banana' | 'nano-banana-edit' | 'veo3';
+    api_type: 'nano-banana' | 'nano-banana-edit' | 'nano-banana-upscale' | 'veo3';
     status: 'pending' | 'processing' | 'completed' | 'failed';
     created_at: string;
     updated_at: string;

package/dist/types.js

@@ -1,11 +1,20 @@
 import { z } from 'zod';
 // Zod schemas for request validation
 export const NanoBananaGenerateSchema = z.object({
-    prompt: z.string().min(1).max(1000)
+    prompt: z.string().min(1).max(5000),
+    output_format: z.enum(['png', 'jpeg']).default('png').optional(),
+    image_size: z.enum(['1:1', '9:16', '16:9', '3:4', '4:3', '3:2', '2:3', '5:4', '4:5', '21:9', 'auto']).default('1:1').optional()
 });
 export const NanoBananaEditSchema = z.object({
-    prompt: z.string().min(1).max(1000),
-    image_urls: z.array(z.string().url()).min(1).max(5)
+    prompt: z.string().min(1).max(5000),
+    image_urls: z.array(z.string().url()).min(1).max(10),
+    output_format: z.enum(['png', 'jpeg']).default('png').optional(),
+    image_size: z.enum(['1:1', '9:16', '16:9', '3:4', '4:3', '3:2', '2:3', '5:4', '4:5', '21:9', 'auto']).default('1:1').optional()
+});
+export const NanoBananaUpscaleSchema = z.object({
+    image: z.string().url(),
+    scale: z.number().int().min(1).max(4).default(2).optional(),
+    face_enhance: z.boolean().default(false).optional()
 });
 export const Veo3GenerateSchema = z.object({
     prompt: z.string().min(1).max(2000),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@felores/kie-ai-mcp-server",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "MCP server for Kie.ai APIs (Nano Banana image generation/editing and Veo3 video generation)",
   "main": "dist/index.js",
   "bin": {