@felores/kie-ai-mcp-server 1.0.3 → 1.1.2

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
@@ -51,6 +52,7 @@ export KIE_AI_API_KEY="your-api-key-here"
 export KIE_AI_BASE_URL="https://api.kie.ai/api/v1"  # Default
 export KIE_AI_TIMEOUT="60000"                      # Default: 60 seconds
 export KIE_AI_DB_PATH="./tasks.db"                 # Default: ./tasks.db
+export KIE_AI_CALLBACK_URL="https://your-domain.com/api/callback"  # Default callback URL for video generation
 ```
 
 ### MCP Configuration
@@ -89,12 +91,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,28 +108,51 @@ 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:**
 - `prompt` (string, required): Video description
 - `imageUrls` (array, optional): Image for image-to-video (max 1)
 - `model` (enum, optional): "veo3" or "veo3_fast" (default: "veo3")
-- `aspectRatio` (enum, optional): "16:9" or "9:16" (default: "16:9")
+- `aspectRatio` (enum, optional): "16:9", "9:16", or "Auto" (default: "16:9", only 16:9 supports 1080P)
 - `seeds` (integer, optional): Random seed 10000-99999
 - `watermark` (string, optional): Watermark text
-- `enableFallback` (boolean, optional): Enable fallback mechanism
+- `callBackUrl` (string, optional): Callback URL for completion notifications
+- `enableFallback` (boolean, optional): Enable fallback mechanism (default: false, fallback videos cannot use 1080P endpoint)
+- `enableTranslation` (boolean, optional): Auto-translate prompts to English (default: true)
 
 **Example:**
 ```json
@@ -131,24 +160,25 @@ Generate videos using Veo3.
   "prompt": "A dog playing in a park",
   "model": "veo3",
   "aspectRatio": "16:9",
-  "seeds": 12345
+  "seeds": 12345,
+  "enableTranslation": true
 }
 ```
 
-### 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 +194,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
 
@@ -303,7 +335,40 @@ MIT License - see LICENSE file for details.
 
 ## Changelog
 
-### v1.0.0
+### v1.1.1 (2025-01-14)
+
+**Improvements:**
+- Added `KIE_AI_CALLBACK_URL` environment variable for default callback URL
+- Added `enableTranslation` parameter to Veo3 (auto-translate prompts to English)
+- Added `Auto` option to Veo3 `aspectRatio`
+- Exposed `callBackUrl` parameter in Veo3 tool schema
+- Veo3 tool now fully aligned with official Kie.ai API documentation
+
+### 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.2',
         });
         // Initialize client with config from environment
         const config = {
@@ -27,6 +27,40 @@ class KieAiMcpServer {
         this.db = new TaskDatabase(process.env.KIE_AI_DB_PATH);
         this.setupHandlers();
     }
+    formatError(toolName, error, paramDescriptions) {
+        let errorMessage = 'Unknown error';
+        let errorDetails = '';
+        if (error instanceof Error) {
+            errorMessage = error.message;
+            // Check for Zod validation errors
+            if (errorMessage.includes('ZodError')) {
+                const lines = errorMessage.split('\n');
+                const validationErrors = lines.filter(line => line.includes('Expected') || line.includes('Required') || line.includes('Invalid'));
+                if (validationErrors.length > 0) {
+                    errorDetails = `Validation errors:\n${validationErrors.map(err => `- ${err.trim()}`).join('\n')}`;
+                }
+            }
+        }
+        // Build parameter guidance
+        const paramGuidance = Object.entries(paramDescriptions)
+            .map(([param, desc]) => `- ${param}: ${desc}`)
+            .join('\n');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: false,
+                        tool: toolName,
+                        error: errorMessage,
+                        details: errorDetails,
+                        parameter_guidance: paramGuidance,
+                        message: `Failed to execute ${toolName}. Check parameters and try again.`
+                    }, null, 2)
+                }
+            ]
+        };
+    }
     setupHandlers() {
         this.server.setRequestHandler(ListToolsRequestSchema, async () => {
             return {
@@ -41,7 +75,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 +103,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',
@@ -101,8 +186,8 @@ class KieAiMcpServer {
                                 },
                                 aspectRatio: {
                                     type: 'string',
-                                    enum: ['16:9', '9:16'],
-                                    description: 'Video aspect ratio',
+                                    enum: ['16:9', '9:16', 'Auto'],
+                                    description: 'Video aspect ratio (16:9 supports 1080P)',
                                     default: '16:9'
                                 },
                                 seeds: {
@@ -111,10 +196,20 @@ class KieAiMcpServer {
                                     minimum: 10000,
                                     maximum: 99999
                                 },
+                                callBackUrl: {
+                                    type: 'string',
+                                    format: 'uri',
+                                    description: 'Callback URL for task completion notifications'
+                                },
                                 enableFallback: {
                                     type: 'boolean',
-                                    description: 'Enable fallback mechanism for content policy failures',
+                                    description: 'Enable fallback mechanism for content policy failures (Note: fallback videos cannot use 1080P endpoint)',
                                     default: false
+                                },
+                                enableTranslation: {
+                                    type: 'boolean',
+                                    description: 'Auto-translate prompts to English for better results',
+                                    default: true
                                 }
                             },
                             required: ['prompt']
@@ -184,6 +279,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':
@@ -206,8 +303,8 @@ class KieAiMcpServer {
         });
     }
     async handleGenerateNanoBanana(args) {
-        const request = NanoBananaGenerateSchema.parse(args);
         try {
+            const request = NanoBananaGenerateSchema.parse(args);
             const response = await this.client.generateNanoBanana(request);
             if (response.data?.taskId) {
                 await this.db.createTask({
@@ -231,23 +328,16 @@ class KieAiMcpServer {
             };
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : 'Generation failed';
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: message
-                        }, null, 2)
-                    }
-                ]
-            };
+            return this.formatError('generate_nano_banana', error, {
+                prompt: 'Required: text description of image to generate (max 5000 chars)',
+                output_format: 'Optional: "png" or "jpeg"',
+                image_size: 'Optional: aspect ratio like "16:9", "1:1", etc.'
+            });
         }
     }
     async handleEditNanoBanana(args) {
-        const request = NanoBananaEditSchema.parse(args);
         try {
+            const request = NanoBananaEditSchema.parse(args);
             const response = await this.client.editNanoBanana(request);
             if (response.data?.taskId) {
                 await this.db.createTask({
@@ -271,23 +361,54 @@ class KieAiMcpServer {
             };
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : 'Editing failed';
+            return this.formatError('edit_nano_banana', error, {
+                prompt: 'Required: editing instructions (max 5000 chars)',
+                image_urls: 'Required: array of 1-10 image URLs to edit',
+                output_format: 'Optional: "png" or "jpeg"',
+                image_size: 'Optional: aspect ratio like "16:9", "1:1", etc.'
+            });
+        }
+    }
+    async handleUpscaleNanoBanana(args) {
+        try {
+            const request = NanoBananaUpscaleSchema.parse(args);
+            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: false,
-                            error: message
+                            success: true,
+                            response: response,
+                            message: 'Nano Banana upscale initiated'
                         }, null, 2)
                     }
                 ]
             };
         }
+        catch (error) {
+            return this.formatError('upscale_nano_banana', error, {
+                image: 'Required: URL of image to upscale (jpeg/png/webp, max 10MB)',
+                scale: 'Optional: upscale factor 1-4 (default: 2)',
+                face_enhance: 'Optional: enable face enhancement (default: false)'
+            });
+        }
     }
     async handleGenerateVeo3Video(args) {
-        const request = Veo3GenerateSchema.parse(args);
         try {
+            const request = Veo3GenerateSchema.parse(args);
+            // Use environment variable as fallback if callBackUrl not provided
+            if (!request.callBackUrl && process.env.KIE_AI_CALLBACK_URL) {
+                request.callBackUrl = process.env.KIE_AI_CALLBACK_URL;
+            }
             const response = await this.client.generateVeo3Video(request);
             if (response.data?.taskId) {
                 await this.db.createTask({
@@ -311,67 +432,90 @@ class KieAiMcpServer {
             };
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : 'Video generation failed';
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: message
-                        }, null, 2)
-                    }
-                ]
-            };
+            return this.formatError('generate_veo3_video', error, {
+                prompt: 'Required: video description (max 2000 chars)',
+                imageUrls: 'Optional: array with 1 image URL for image-to-video',
+                model: 'Optional: "veo3" (quality) or "veo3_fast" (cost-efficient)',
+                watermark: 'Optional: watermark text (max 100 chars)',
+                aspectRatio: 'Optional: "16:9", "9:16", or "Auto"',
+                seeds: 'Optional: random seed (10000-99999)',
+                callBackUrl: 'Optional: callback URL for notifications',
+                enableFallback: 'Optional: enable fallback for content policy failures',
+                enableTranslation: 'Optional: auto-translate prompts to English'
+            });
         }
     }
     async handleGetTaskStatus(args) {
-        const { task_id } = args;
-        if (!task_id || typeof task_id !== 'string') {
-            throw new McpError(ErrorCode.InvalidParams, 'task_id is required and must be a string');
-        }
         try {
+            const { task_id } = args;
+            if (!task_id || typeof task_id !== 'string') {
+                throw new McpError(ErrorCode.InvalidParams, 'task_id is required and must be a string');
+            }
             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)
                     }
                 ]
             };
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : 'Failed to get task status';
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: message
-                        }, null, 2)
-                    }
-                ]
-            };
+            return this.formatError('get_task_status', error, {
+                task_id: 'Required: task ID to check status for'
+            });
         }
     }
     async handleListTasks(args) {
-        const { limit = 20, status } = args;
         try {
+            const { limit = 20, status } = args;
             let tasks;
             if (status) {
                 tasks = await this.db.getTasksByStatus(status, limit);
@@ -394,26 +538,18 @@ class KieAiMcpServer {
             };
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : 'Failed to list tasks';
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: message
-                        }, null, 2)
-                    }
-                ]
-            };
+            return this.formatError('list_tasks', error, {
+                limit: 'Optional: max tasks to return (1-100, default: 20)',
+                status: 'Optional: filter by status (pending, processing, completed, failed)'
+            });
         }
     }
     async handleGetVeo1080pVideo(args) {
-        const { task_id, index } = args;
-        if (!task_id || typeof task_id !== 'string') {
-            throw new McpError(ErrorCode.InvalidParams, 'task_id is required and must be a string');
-        }
         try {
+            const { task_id, index } = args;
+            if (!task_id || typeof task_id !== 'string') {
+                throw new McpError(ErrorCode.InvalidParams, 'task_id is required and must be a string');
+            }
             const response = await this.client.getVeo1080pVideo(task_id, index);
             return {
                 content: [
@@ -431,18 +567,10 @@ class KieAiMcpServer {
             };
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : 'Failed to get 1080p video';
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: message
-                        }, null, 2)
-                    }
-                ]
-            };
+            return this.formatError('get_veo3_1080p_video', error, {
+                task_id: 'Required: Veo3 task ID to get 1080p video for',
+                index: 'Optional: video index (for multiple video results)'
+            });
         }
     }
     async run() {

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,51 +1,80 @@
 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;
     imageUrls: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     model: z.ZodDefault<z.ZodEnum<["veo3", "veo3_fast"]>>;
     watermark: z.ZodOptional<z.ZodString>;
-    aspectRatio: z.ZodDefault<z.ZodEnum<["16:9", "9:16"]>>;
+    aspectRatio: z.ZodDefault<z.ZodEnum<["16:9", "9:16", "Auto"]>>;
     seeds: z.ZodOptional<z.ZodNumber>;
     callBackUrl: z.ZodOptional<z.ZodString>;
     enableFallback: z.ZodDefault<z.ZodBoolean>;
+    enableTranslation: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
 }, "strip", z.ZodTypeAny, {
     prompt: string;
     model: "veo3" | "veo3_fast";
-    aspectRatio: "16:9" | "9:16";
+    aspectRatio: "9:16" | "16:9" | "Auto";
     enableFallback: boolean;
     imageUrls?: string[] | undefined;
     watermark?: string | undefined;
     seeds?: number | undefined;
     callBackUrl?: string | undefined;
+    enableTranslation?: boolean | undefined;
 }, {
     prompt: string;
     imageUrls?: string[] | undefined;
     model?: "veo3" | "veo3_fast" | undefined;
     watermark?: string | undefined;
-    aspectRatio?: "16:9" | "9:16" | undefined;
+    aspectRatio?: "9:16" | "16:9" | "Auto" | undefined;
     seeds?: number | undefined;
     callBackUrl?: string | undefined;
     enableFallback?: boolean | undefined;
+    enableTranslation?: 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 +91,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,19 +1,29 @@
 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),
     imageUrls: z.array(z.string().url()).max(1).optional(),
     model: z.enum(['veo3', 'veo3_fast']).default('veo3'),
     watermark: z.string().max(100).optional(),
-    aspectRatio: z.enum(['16:9', '9:16']).default('16:9'),
+    aspectRatio: z.enum(['16:9', '9:16', 'Auto']).default('16:9'),
     seeds: z.number().int().min(10000).max(99999).optional(),
     callBackUrl: z.string().url().optional(),
-    enableFallback: z.boolean().default(false)
+    enableFallback: z.boolean().default(false),
+    enableTranslation: z.boolean().default(true).optional()
 });

package/package.json

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