@felores/kie-ai-mcp-server 1.7.1 → 1.7.3

package/README.md

@@ -22,6 +22,8 @@ Access the world's best AI models through a single, developer-friendly API. Gene
 - **Nano Banana**: Lightning-fast image generation and editing
 - **ElevenLabs**: Studio-quality text-to-speech and sound effects
 - **ByteDance Seedance**: High-quality video with text-to-video and image-to-video
+- **ByteDance Seedream V4**: Advanced image generation and editing with unified interface
+- **Qwen**: Powerful image generation and editing with acceleration options
 
 ### 💰 **Affordable Pricing**
 Pay-as-you-go credit system means you only pay for what you use. Good for startups and enterprises looking to reduce AI costs.
@@ -515,7 +517,143 @@ Video with specific ending frame:
 
 **Note**: The `callBackUrl` is optional and will use the `KIE_AI_CALLBACK_URL` environment variable if not provided. Video generation typically takes 2-5 minutes depending on quality and complexity.
 
-### 13. `runway_aleph_video`
+### 13. `bytedance_seedream_image`
+Generate and edit images using ByteDance Seedream V4 models (unified tool for both text-to-image and image editing).
+
+**Parameters:**
+- `prompt` (string, required): Text prompt for image generation or editing (max 10000 chars)
+- `image_urls` (array, optional): Array of image URLs for editing mode (1-10 images, if not provided, uses text-to-image)
+- `image_size` (string, optional): Image aspect ratio (default: "1:1")
+  - Options: `1:1`, `4:3`, `3:4`, `16:9`, `9:16`, `21:9`, `9:21`, `3:2`, `2:3`
+- `image_resolution` (string, optional): Image resolution (default: "1K")
+  - `1K`: Standard resolution (1024px on shortest side)
+  - `2K`: High resolution (2048px on shortest side)
+  - `4K`: Ultra high resolution (4096px on shortest side)
+- `max_images` (integer, optional): Number of images to generate (1-6, default: 1)
+- `seed` (integer, optional): Random seed for reproducible results (default: -1 for random)
+- `callBackUrl` (string, optional): URL for task completion notifications
+
+**Examples:**
+
+Text-to-image generation:
+```json
+{
+  "prompt": "A majestic dragon perched atop a crystal mountain at sunset, digital art style",
+  "image_size": "16:9",
+  "image_resolution": "2K",
+  "max_images": 2,
+  "seed": 42
+}
+```
+
+Image editing:
+```json
+{
+  "prompt": "Transform the day scene into a magical night with glowing stars and moonlight",
+  "image_urls": ["https://example.com/day-landscape.jpg"],
+  "image_size": "16:9",
+  "image_resolution": "2K",
+  "max_images": 1
+}
+```
+
+Multiple image editing:
+```json
+{
+  "prompt": "Apply a consistent cyberpunk aesthetic to all images with neon lights and futuristic elements",
+  "image_urls": [
+    "https://example.com/character1.jpg",
+    "https://example.com/character2.jpg",
+    "https://example.com/background.jpg"
+  ],
+  "image_resolution": "4K",
+  "max_images": 3
+}
+```
+
+**Key Features:**
+- **Unified Interface**: Single tool for both text-to-image and image editing
+- **Smart Mode Detection**: Automatically detects mode based on presence of `image_urls`
+- **High Resolution**: Support for 1K, 2K, and 4K output
+- **Multiple Images**: Generate up to 6 images in a single request
+- **Batch Editing**: Edit up to 10 images simultaneously with consistent style
+- **Reproducible Results**: Seed control for consistent output
+
+**Note**: The `callBackUrl` is optional and will use the `KIE_AI_CALLBACK_URL` environment variable if not provided. Image generation typically takes 30-120 seconds depending on resolution and complexity.
+
+### 14. `qwen_image`
+Generate and edit images using Qwen models (unified tool for both text-to-image and image editing).
+
+**Parameters:**
+- `prompt` (string, required): Text prompt for image generation or editing
+- `image_url` (string, optional): URL of image to edit (if not provided, uses text-to-image)
+- `image_size` (string, optional): Image size (default: "square_hd")
+  - Options: `square`, `square_hd`, `portrait_4_3`, `portrait_16_9`, `landscape_4_3`, `landscape_16_9`
+- `num_inference_steps` (integer, optional): Number of inference steps (default: 30 for text-to-image, 25 for edit)
+  - Text-to-image: 2-250, Edit: 2-49
+- `guidance_scale` (number, optional): CFG scale (default: 2.5 for text-to-image, 4 for edit)
+  - Range: 0-20
+- `enable_safety_checker` (boolean, optional): Enable safety checker (default: true)
+- `output_format` (string, optional): Output format (default: "png")
+  - Options: `png`, `jpeg`
+- `negative_prompt` (string, optional): Negative prompt (max 500 chars, default: " ")
+- `acceleration` (string, optional): Acceleration level (default: "none")
+  - Options: `none`, `regular`, `high`
+- `num_images` (string, optional): Number of images (edit mode only)
+  - Options: `1`, `2`, `3`, `4`
+- `sync_mode` (boolean, optional): Sync mode (edit mode only, default: false)
+- `seed` (number, optional): Random seed for reproducible results
+- `callBackUrl` (string, optional): URL for task completion notifications
+
+**Examples:**
+
+Text-to-image generation:
+```json
+{
+  "prompt": "A beautiful landscape with mountains and a lake at sunset",
+  "image_size": "landscape_16_9",
+  "num_inference_steps": 30,
+  "guidance_scale": 2.5,
+  "output_format": "png",
+  "seed": 42
+}
+```
+
+Image editing:
+```json
+{
+  "prompt": "Change the day scene to night with stars and moonlight",
+  "image_url": "https://example.com/day-landscape.jpg",
+  "image_size": "landscape_16_9",
+  "num_inference_steps": 25,
+  "guidance_scale": 4,
+  "num_images": "2",
+  "output_format": "png"
+}
+```
+
+High-acceleration generation:
+```json
+{
+  "prompt": "A futuristic city with flying cars",
+  "image_size": "square_hd",
+  "acceleration": "high",
+  "enable_safety_checker": true,
+  "negative_prompt": "blurry, low quality"
+}
+```
+
+**Key Features:**
+- **Unified Interface**: Single tool for both text-to-image and image editing
+- **Smart Mode Detection**: Automatically detects mode based on presence of `image_url`
+- **Flexible Sizing**: Support for multiple aspect ratios and resolutions
+- **Acceleration Options**: Speed up generation with acceleration levels
+- **Batch Generation**: Generate multiple images in edit mode
+- **Reproducible Results**: Seed control for consistent output
+
+**Note**: The `callBackUrl` is optional and will use the `KIE_AI_CALLBACK_URL` environment variable if not provided. Image generation typically takes 10-60 seconds depending on settings and acceleration level.
+
+### 15. `runway_aleph_video`
 Transform videos using Runway Aleph video-to-video generation with AI-powered editing.
 
 **Parameters:**

package/dist/index.js

@@ -5,7 +5,7 @@ import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } f
 import { KieAiClient } from './kie-ai-client.js';
 import { TaskDatabase } from './database.js';
 import { z } from 'zod';
-import { NanoBananaGenerateSchema, NanoBananaEditSchema, NanoBananaUpscaleSchema, Veo3GenerateSchema, SunoGenerateSchema, ElevenLabsTTSSchema, ElevenLabsSoundEffectsSchema, ByteDanceSeedanceVideoSchema, RunwayAlephVideoSchema, WanVideoSchema } from './types.js';
+import { NanoBananaGenerateSchema, NanoBananaEditSchema, NanoBananaUpscaleSchema, Veo3GenerateSchema, SunoGenerateSchema, ElevenLabsTTSSchema, ElevenLabsSoundEffectsSchema, ByteDanceSeedanceVideoSchema, ByteDanceSeedreamImageSchema, QwenImageSchema, RunwayAlephVideoSchema, WanVideoSchema } from './types.js';
 class KieAiMcpServer {
     server;
     client;
@@ -13,7 +13,7 @@ class KieAiMcpServer {
     constructor() {
         this.server = new Server({
             name: 'kie-ai-mcp-server',
-            version: '1.7.1',
+            version: '1.7.3',
         });
         // Initialize client with config from environment
         const config = {
@@ -551,6 +551,143 @@ class KieAiMcpServer {
                             required: ['prompt']
                         }
                     },
+                    {
+                        name: 'bytedance_seedream_image',
+                        description: 'Generate and edit images using ByteDance Seedream V4 models (unified tool for both text-to-image and image editing)',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                prompt: {
+                                    type: 'string',
+                                    description: 'Text prompt for image generation or editing (max 10000 characters)',
+                                    minLength: 1,
+                                    maxLength: 10000
+                                },
+                                image_urls: {
+                                    type: 'array',
+                                    description: 'Array of image URLs for editing mode (optional - if not provided, uses text-to-image)',
+                                    items: {
+                                        type: 'string',
+                                        format: 'uri'
+                                    },
+                                    minItems: 1,
+                                    maxItems: 10
+                                },
+                                image_size: {
+                                    type: 'string',
+                                    description: 'Image aspect ratio',
+                                    enum: ['1:1', '4:3', '3:4', '16:9', '9:16', '21:9', '9:21', '3:2', '2:3'],
+                                    default: '1:1'
+                                },
+                                image_resolution: {
+                                    type: 'string',
+                                    description: 'Image resolution',
+                                    enum: ['1K', '2K', '4K'],
+                                    default: '1K'
+                                },
+                                max_images: {
+                                    type: 'integer',
+                                    description: 'Number of images to generate',
+                                    minimum: 1,
+                                    maximum: 6,
+                                    default: 1
+                                },
+                                seed: {
+                                    type: 'integer',
+                                    description: 'Random seed for reproducible results (use -1 for random)',
+                                    default: -1
+                                },
+                                callBackUrl: {
+                                    type: 'string',
+                                    description: 'Optional: URL for task completion notifications (uses KIE_AI_CALLBACK_URL env var if not provided)',
+                                    format: 'uri'
+                                }
+                            },
+                            required: ['prompt']
+                        }
+                    },
+                    {
+                        name: 'qwen_image',
+                        description: 'Generate and edit images using Qwen models (unified tool for both text-to-image and image editing)',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                prompt: {
+                                    type: 'string',
+                                    description: 'Text prompt for image generation or editing',
+                                    minLength: 1
+                                },
+                                image_url: {
+                                    type: 'string',
+                                    description: 'URL of image to edit (optional - if not provided, uses text-to-image)',
+                                    format: 'uri'
+                                },
+                                image_size: {
+                                    type: 'string',
+                                    description: 'Image size',
+                                    enum: ['square', 'square_hd', 'portrait_4_3', 'portrait_16_9', 'landscape_4_3', 'landscape_16_9'],
+                                    default: 'square_hd'
+                                },
+                                num_inference_steps: {
+                                    type: 'integer',
+                                    description: 'Number of inference steps (2-250 for text-to-image, 2-49 for edit)',
+                                    minimum: 2,
+                                    maximum: 250,
+                                    default: 30
+                                },
+                                guidance_scale: {
+                                    type: 'number',
+                                    description: 'CFG scale (0-20, default: 2.5 for text-to-image, 4 for edit)',
+                                    minimum: 0,
+                                    maximum: 20,
+                                    default: 2.5
+                                },
+                                enable_safety_checker: {
+                                    type: 'boolean',
+                                    description: 'Enable safety checker',
+                                    default: true
+                                },
+                                output_format: {
+                                    type: 'string',
+                                    description: 'Output format',
+                                    enum: ['png', 'jpeg'],
+                                    default: 'png'
+                                },
+                                negative_prompt: {
+                                    type: 'string',
+                                    description: 'Negative prompt (max 500 characters)',
+                                    maxLength: 500,
+                                    default: ' '
+                                },
+                                acceleration: {
+                                    type: 'string',
+                                    description: 'Acceleration level',
+                                    enum: ['none', 'regular', 'high'],
+                                    default: 'none'
+                                },
+                                num_images: {
+                                    type: 'string',
+                                    description: 'Number of images (1-4, edit mode only)',
+                                    enum: ['1', '2', '3', '4']
+                                },
+                                sync_mode: {
+                                    type: 'boolean',
+                                    description: 'Sync mode (edit mode only)',
+                                    default: false
+                                },
+                                seed: {
+                                    type: 'number',
+                                    description: 'Random seed for reproducible results'
+                                },
+                                callBackUrl: {
+                                    type: 'string',
+                                    description: 'Optional: URL for task completion notifications (uses KIE_AI_CALLBACK_URL env var if not provided)',
+                                    format: 'uri'
+                                }
+                            },
+                            required: ['prompt']
+                        }
+                    },
                     {
                         name: 'runway_aleph_video',
                         description: 'Transform videos using Runway Aleph video-to-video generation with AI-powered editing',
@@ -693,6 +830,10 @@ class KieAiMcpServer {
                         return await this.handleElevenLabsSoundEffects(args);
                     case 'bytedance_seedance_video':
                         return await this.handleByteDanceSeedanceVideo(args);
+                    case 'bytedance_seedream_image':
+                        return await this.handleByteDanceSeedreamImage(args);
+                    case 'qwen_image':
+                        return await this.handleQwenImage(args);
                     case 'runway_aleph_video':
                         return await this.handleRunwayAlephVideo(args);
                     case 'wan_video':
@@ -1383,6 +1524,176 @@ class KieAiMcpServer {
             });
         }
     }
+    async handleByteDanceSeedreamImage(args) {
+        try {
+            const request = ByteDanceSeedreamImageSchema.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.generateByteDanceSeedreamImage(request);
+            if (response.code === 200 && response.data?.taskId) {
+                // Determine mode for user feedback
+                const isEdit = !!request.image_urls && request.image_urls.length > 0;
+                const mode = isEdit ? 'Image Editing' : 'Text-to-Image';
+                // Store task in database
+                await this.db.createTask({
+                    task_id: response.data.taskId,
+                    api_type: 'bytedance-seedream-image',
+                    status: 'pending'
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                task_id: response.data.taskId,
+                                message: `ByteDance Seedream V4 ${mode} task created successfully`,
+                                parameters: {
+                                    mode: mode,
+                                    prompt: request.prompt.substring(0, 100) + (request.prompt.length > 100 ? '...' : ''),
+                                    image_size: request.image_size || '1:1',
+                                    image_resolution: request.image_resolution || '1K',
+                                    max_images: request.max_images || 1,
+                                    seed: request.seed !== undefined ? request.seed : -1,
+                                    ...(isEdit && { image_urls_count: request.image_urls?.length || 0 })
+                                },
+                                next_steps: [
+                                    `Use get_task_status with task_id: ${response.data.taskId} to check progress`,
+                                    'Generated images will be available when status is "completed"'
+                                ],
+                                usage_examples: [
+                                    `get_task_status: {"task_id": "${response.data.taskId}"}`,
+                                    `list_tasks: {"limit": 10}`
+                                ]
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            else {
+                throw new Error(response.msg || 'Failed to create ByteDance Seedream V4 image task');
+            }
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                return this.formatError('bytedance_seedream_image', error, {
+                    prompt: 'Required: Text prompt for image generation or editing (max 10000 characters)',
+                    image_urls: 'Optional: Array of image URLs for editing mode (1-10 images)',
+                    image_size: 'Optional: Image aspect ratio (default: 1:1)',
+                    image_resolution: 'Optional: Image resolution - 1K/2K/4K (default: 1K)',
+                    max_images: 'Optional: Number of images to generate (1-6, default: 1)',
+                    seed: 'Optional: Random seed for reproducible results (default: -1 for random)',
+                    callBackUrl: 'Optional: URL for task completion notifications (uses KIE_AI_CALLBACK_URL env var if not provided)'
+                });
+            }
+            return this.formatError('bytedance_seedream_image', error, {
+                prompt: 'Required: Text prompt for image generation or editing (max 10000 characters)',
+                image_urls: 'Optional: Array of image URLs for editing mode (1-10 images)',
+                image_size: 'Optional: Image aspect ratio (default: 1:1)',
+                image_resolution: 'Optional: Image resolution - 1K/2K/4K (default: 1K)',
+                max_images: 'Optional: Number of images to generate (1-6, default: 1)',
+                seed: 'Optional: Random seed for reproducible results (default: -1 for random)',
+                callBackUrl: 'Optional: URL for task completion notifications (uses KIE_AI_CALLBACK_URL env var if not provided)'
+            });
+        }
+    }
+    async handleQwenImage(args) {
+        try {
+            const request = QwenImageSchema.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.generateQwenImage(request);
+            if (response.code === 200 && response.data?.taskId) {
+                // Determine mode for user feedback
+                const isEdit = !!request.image_url;
+                const mode = isEdit ? 'Image Editing' : 'Text-to-Image';
+                // Store task in database
+                await this.db.createTask({
+                    task_id: response.data.taskId,
+                    api_type: 'qwen-image',
+                    status: 'pending'
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                task_id: response.data.taskId,
+                                message: `Qwen ${mode} task created successfully`,
+                                parameters: {
+                                    mode: mode,
+                                    prompt: request.prompt.substring(0, 100) + (request.prompt.length > 100 ? '...' : ''),
+                                    image_size: request.image_size || 'square_hd',
+                                    num_inference_steps: request.num_inference_steps || (isEdit ? 25 : 30),
+                                    guidance_scale: request.guidance_scale || (isEdit ? 4 : 2.5),
+                                    enable_safety_checker: request.enable_safety_checker !== false,
+                                    output_format: request.output_format || 'png',
+                                    negative_prompt: request.negative_prompt || (isEdit ? 'blurry, ugly' : ' '),
+                                    acceleration: request.acceleration || 'none',
+                                    seed: request.seed,
+                                    ...(isEdit && {
+                                        image_url: request.image_url,
+                                        num_images: request.num_images,
+                                        sync_mode: request.sync_mode
+                                    })
+                                },
+                                next_steps: [
+                                    `Use get_task_status with task_id: ${response.data.taskId} to check progress`,
+                                    'Generated images will be available when status is "completed"'
+                                ],
+                                usage_examples: [
+                                    `get_task_status: {"task_id": "${response.data.taskId}"}`,
+                                    `list_tasks: {"limit": 10}`
+                                ]
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            else {
+                throw new Error(response.msg || 'Failed to create Qwen image task');
+            }
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                return this.formatError('qwen_image', error, {
+                    prompt: 'Required: Text prompt for image generation or editing',
+                    image_url: 'Optional: URL of image to edit (required for edit mode)',
+                    image_size: 'Optional: Image size (square, square_hd, portrait_4_3, portrait_16_9, landscape_4_3, landscape_16_9)',
+                    num_inference_steps: 'Optional: Number of inference steps (2-250 for text-to-image, 2-49 for edit)',
+                    guidance_scale: 'Optional: CFG scale (0-20, default: 2.5 for text-to-image, 4 for edit)',
+                    enable_safety_checker: 'Optional: Enable safety checker (default: true)',
+                    output_format: 'Optional: Output format (png/jpeg, default: png)',
+                    negative_prompt: 'Optional: Negative prompt (max 500 chars)',
+                    acceleration: 'Optional: Acceleration level (none/regular/high, default: none)',
+                    num_images: 'Optional: Number of images (1-4, edit mode only)',
+                    sync_mode: 'Optional: Sync mode (edit mode only)',
+                    seed: 'Optional: Random seed for reproducible results',
+                    callBackUrl: 'Optional: URL for task completion notifications (uses KIE_AI_CALLBACK_URL env var if not provided)'
+                });
+            }
+            return this.formatError('qwen_image', error, {
+                prompt: 'Required: Text prompt for image generation or editing',
+                image_url: 'Optional: URL of image to edit (required for edit mode)',
+                image_size: 'Optional: Image size (square, square_hd, portrait_4_3, portrait_16_9, landscape_4_3, landscape_16_9)',
+                num_inference_steps: 'Optional: Number of inference steps (2-250 for text-to-image, 2-49 for edit)',
+                guidance_scale: 'Optional: CFG scale (0-20, default: 2.5 for text-to-image, 4 for edit)',
+                enable_safety_checker: 'Optional: Enable safety checker (default: true)',
+                output_format: 'Optional: Output format (png/jpeg, default: png)',
+                negative_prompt: 'Optional: Negative prompt (max 500 chars)',
+                acceleration: 'Optional: Acceleration level (none/regular/high, default: none)',
+                num_images: 'Optional: Number of images (1-4, edit mode only)',
+                sync_mode: 'Optional: Sync mode (edit mode only)',
+                seed: 'Optional: Random seed for reproducible results',
+                callBackUrl: 'Optional: URL for task completion notifications (uses KIE_AI_CALLBACK_URL env var if not provided)'
+            });
+        }
+    }
     async handleRunwayAlephVideo(args) {
         try {
             const request = RunwayAlephVideoSchema.parse(args);

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

@@ -1,4 +1,4 @@
-import { KieAiConfig, KieAiResponse, NanoBananaGenerateRequest, NanaBananaEditRequest, NanoBananaUpscaleRequest, Veo3GenerateRequest, SunoGenerateRequest, ElevenLabsTTSRequest, ElevenLabsSoundEffectsRequest, ByteDanceSeedanceVideoRequest, RunwayAlephVideoRequest, WanVideoRequest, ImageResponse, TaskResponse } from './types.js';
+import { KieAiConfig, KieAiResponse, NanoBananaGenerateRequest, NanaBananaEditRequest, NanoBananaUpscaleRequest, Veo3GenerateRequest, SunoGenerateRequest, ElevenLabsTTSRequest, ElevenLabsSoundEffectsRequest, ByteDanceSeedanceVideoRequest, RunwayAlephVideoRequest, WanVideoRequest, ByteDanceSeedreamImageRequest, QwenImageRequest, ImageResponse, TaskResponse } from './types.js';
 export declare class KieAiClient {
     private config;
     constructor(config: KieAiConfig);
@@ -14,5 +14,7 @@ export declare class KieAiClient {
     generateByteDanceSeedanceVideo(request: ByteDanceSeedanceVideoRequest): Promise<KieAiResponse<TaskResponse>>;
     generateRunwayAlephVideo(request: RunwayAlephVideoRequest): Promise<KieAiResponse<TaskResponse>>;
     generateWanVideo(request: WanVideoRequest): Promise<KieAiResponse<TaskResponse>>;
+    generateByteDanceSeedreamImage(request: ByteDanceSeedreamImageRequest): Promise<KieAiResponse<TaskResponse>>;
+    generateQwenImage(request: QwenImageRequest): Promise<KieAiResponse<TaskResponse>>;
     getVeo1080pVideo(taskId: string, index?: number): Promise<KieAiResponse<any>>;
 }

package/dist/kie-ai-client.js

@@ -80,7 +80,7 @@ export class KieAiClient {
         else if (apiType === 'suno') {
             return this.makeRequest(`/generate/record-info?taskId=${taskId}`, 'GET');
         }
-        else if (apiType === 'elevenlabs-tts' || apiType === 'elevenlabs-sound-effects' || apiType === 'bytedance-seedance-video' || apiType === 'wan-video') {
+        else if (apiType === 'elevenlabs-tts' || apiType === 'elevenlabs-sound-effects' || apiType === 'bytedance-seedance-video' || apiType === 'bytedance-seedream-image' || apiType === 'qwen-image' || apiType === 'wan-video') {
             return this.makeRequest(`/jobs/recordInfo?taskId=${taskId}`, 'GET');
         }
         else if (apiType === 'runway-aleph-video') {
@@ -232,6 +232,60 @@ export class KieAiClient {
         };
         return this.makeRequest('/jobs/createTask', 'POST', jobRequest);
     }
+    async generateByteDanceSeedreamImage(request) {
+        // Determine mode based on presence of image_urls
+        const isEdit = !!request.image_urls && request.image_urls.length > 0;
+        const model = isEdit ? 'bytedance/seedream-v4-edit' : 'bytedance/seedream-v4-text-to-image';
+        const input = {
+            prompt: request.prompt,
+            image_size: request.image_size || '1:1',
+            image_resolution: request.image_resolution || '1K',
+            max_images: request.max_images || 1,
+            seed: request.seed !== undefined ? request.seed : -1
+        };
+        // Add edit-specific parameters
+        if (isEdit) {
+            input.image_urls = request.image_urls;
+        }
+        const jobRequest = {
+            model,
+            input,
+            callBackUrl: request.callBackUrl || process.env.KIE_AI_CALLBACK_URL
+        };
+        return this.makeRequest('/jobs/createTask', 'POST', jobRequest);
+    }
+    async generateQwenImage(request) {
+        // Determine mode based on presence of image_url
+        const isEdit = !!request.image_url;
+        const model = isEdit ? 'qwen/image-edit' : 'qwen/text-to-image';
+        const input = {
+            prompt: request.prompt,
+            image_size: request.image_size || 'square_hd',
+            num_inference_steps: request.num_inference_steps || (isEdit ? 25 : 30),
+            seed: request.seed,
+            guidance_scale: request.guidance_scale || (isEdit ? 4 : 2.5),
+            enable_safety_checker: request.enable_safety_checker !== false,
+            output_format: request.output_format || 'png',
+            negative_prompt: request.negative_prompt || (isEdit ? 'blurry, ugly' : ' '),
+            acceleration: request.acceleration || 'none'
+        };
+        // Add edit-specific parameters
+        if (isEdit) {
+            input.image_url = request.image_url;
+            if (request.num_images) {
+                input.num_images = request.num_images;
+            }
+            if (request.sync_mode !== undefined) {
+                input.sync_mode = request.sync_mode;
+            }
+        }
+        const jobRequest = {
+            model,
+            input,
+            callBackUrl: request.callBackUrl || process.env.KIE_AI_CALLBACK_URL
+        };
+        return this.makeRequest('/jobs/createTask', 'POST', jobRequest);
+    }
     async getVeo1080pVideo(taskId, index) {
         const params = new URLSearchParams({ taskId });
         if (index !== undefined) {

package/dist/types.d.ts

@@ -402,6 +402,146 @@ export declare const WanVideoSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
     negative_prompt?: string | undefined;
     enable_prompt_expansion?: boolean | undefined;
 }>;
+export declare const ByteDanceSeedreamImageSchema: z.ZodEffects<z.ZodObject<{
+    prompt: z.ZodString;
+    image_urls: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    image_size: z.ZodOptional<z.ZodDefault<z.ZodEnum<["square", "square_hd", "portrait_4_3", "portrait_3_2", "portrait_16_9", "landscape_4_3", "landscape_3_2", "landscape_16_9", "landscape_21_9"]>>>;
+    image_resolution: z.ZodOptional<z.ZodDefault<z.ZodEnum<["1K", "2K", "4K"]>>>;
+    max_images: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    callBackUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    image_size?: "square" | "square_hd" | "portrait_4_3" | "portrait_3_2" | "portrait_16_9" | "landscape_4_3" | "landscape_3_2" | "landscape_16_9" | "landscape_21_9" | undefined;
+    image_urls?: string[] | undefined;
+    callBackUrl?: string | undefined;
+    seed?: number | undefined;
+    image_resolution?: "1K" | "2K" | "4K" | undefined;
+    max_images?: number | undefined;
+}, {
+    prompt: string;
+    image_size?: "square" | "square_hd" | "portrait_4_3" | "portrait_3_2" | "portrait_16_9" | "landscape_4_3" | "landscape_3_2" | "landscape_16_9" | "landscape_21_9" | undefined;
+    image_urls?: string[] | undefined;
+    callBackUrl?: string | undefined;
+    seed?: number | undefined;
+    image_resolution?: "1K" | "2K" | "4K" | undefined;
+    max_images?: number | undefined;
+}>, {
+    prompt: string;
+    image_size?: "square" | "square_hd" | "portrait_4_3" | "portrait_3_2" | "portrait_16_9" | "landscape_4_3" | "landscape_3_2" | "landscape_16_9" | "landscape_21_9" | undefined;
+    image_urls?: string[] | undefined;
+    callBackUrl?: string | undefined;
+    seed?: number | undefined;
+    image_resolution?: "1K" | "2K" | "4K" | undefined;
+    max_images?: number | undefined;
+}, {
+    prompt: string;
+    image_size?: "square" | "square_hd" | "portrait_4_3" | "portrait_3_2" | "portrait_16_9" | "landscape_4_3" | "landscape_3_2" | "landscape_16_9" | "landscape_21_9" | undefined;
+    image_urls?: string[] | undefined;
+    callBackUrl?: string | undefined;
+    seed?: number | undefined;
+    image_resolution?: "1K" | "2K" | "4K" | undefined;
+    max_images?: number | undefined;
+}>;
+export declare const QwenImageSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    prompt: z.ZodString;
+    image_url: z.ZodOptional<z.ZodString>;
+    image_size: z.ZodOptional<z.ZodDefault<z.ZodEnum<["square", "square_hd", "portrait_4_3", "portrait_16_9", "landscape_4_3", "landscape_16_9"]>>>;
+    num_inference_steps: z.ZodOptional<z.ZodNumber>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    guidance_scale: z.ZodOptional<z.ZodNumber>;
+    enable_safety_checker: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    output_format: z.ZodOptional<z.ZodDefault<z.ZodEnum<["png", "jpeg"]>>>;
+    negative_prompt: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    acceleration: z.ZodOptional<z.ZodDefault<z.ZodEnum<["none", "regular", "high"]>>>;
+    num_images: z.ZodOptional<z.ZodEnum<["1", "2", "3", "4"]>>;
+    sync_mode: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    callBackUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    output_format?: "png" | "jpeg" | undefined;
+    image_size?: "square" | "square_hd" | "portrait_4_3" | "portrait_16_9" | "landscape_4_3" | "landscape_16_9" | undefined;
+    callBackUrl?: string | undefined;
+    image_url?: string | undefined;
+    seed?: number | undefined;
+    enable_safety_checker?: boolean | undefined;
+    negative_prompt?: string | undefined;
+    num_inference_steps?: number | undefined;
+    guidance_scale?: number | undefined;
+    acceleration?: "none" | "regular" | "high" | undefined;
+    num_images?: "1" | "2" | "3" | "4" | undefined;
+    sync_mode?: boolean | undefined;
+}, {
+    prompt: string;
+    output_format?: "png" | "jpeg" | undefined;
+    image_size?: "square" | "square_hd" | "portrait_4_3" | "portrait_16_9" | "landscape_4_3" | "landscape_16_9" | undefined;
+    callBackUrl?: string | undefined;
+    image_url?: string | undefined;
+    seed?: number | undefined;
+    enable_safety_checker?: boolean | undefined;
+    negative_prompt?: string | undefined;
+    num_inference_steps?: number | undefined;
+    guidance_scale?: number | undefined;
+    acceleration?: "none" | "regular" | "high" | undefined;
+    num_images?: "1" | "2" | "3" | "4" | undefined;
+    sync_mode?: boolean | undefined;
+}>, {
+    prompt: string;
+    output_format?: "png" | "jpeg" | undefined;
+    image_size?: "square" | "square_hd" | "portrait_4_3" | "portrait_16_9" | "landscape_4_3" | "landscape_16_9" | undefined;
+    callBackUrl?: string | undefined;
+    image_url?: string | undefined;
+    seed?: number | undefined;
+    enable_safety_checker?: boolean | undefined;
+    negative_prompt?: string | undefined;
+    num_inference_steps?: number | undefined;
+    guidance_scale?: number | undefined;
+    acceleration?: "none" | "regular" | "high" | undefined;
+    num_images?: "1" | "2" | "3" | "4" | undefined;
+    sync_mode?: boolean | undefined;
+}, {
+    prompt: string;
+    output_format?: "png" | "jpeg" | undefined;
+    image_size?: "square" | "square_hd" | "portrait_4_3" | "portrait_16_9" | "landscape_4_3" | "landscape_16_9" | undefined;
+    callBackUrl?: string | undefined;
+    image_url?: string | undefined;
+    seed?: number | undefined;
+    enable_safety_checker?: boolean | undefined;
+    negative_prompt?: string | undefined;
+    num_inference_steps?: number | undefined;
+    guidance_scale?: number | undefined;
+    acceleration?: "none" | "regular" | "high" | undefined;
+    num_images?: "1" | "2" | "3" | "4" | undefined;
+    sync_mode?: boolean | undefined;
+}>, {
+    prompt: string;
+    output_format?: "png" | "jpeg" | undefined;
+    image_size?: "square" | "square_hd" | "portrait_4_3" | "portrait_16_9" | "landscape_4_3" | "landscape_16_9" | undefined;
+    callBackUrl?: string | undefined;
+    image_url?: string | undefined;
+    seed?: number | undefined;
+    enable_safety_checker?: boolean | undefined;
+    negative_prompt?: string | undefined;
+    num_inference_steps?: number | undefined;
+    guidance_scale?: number | undefined;
+    acceleration?: "none" | "regular" | "high" | undefined;
+    num_images?: "1" | "2" | "3" | "4" | undefined;
+    sync_mode?: boolean | undefined;
+}, {
+    prompt: string;
+    output_format?: "png" | "jpeg" | undefined;
+    image_size?: "square" | "square_hd" | "portrait_4_3" | "portrait_16_9" | "landscape_4_3" | "landscape_16_9" | undefined;
+    callBackUrl?: string | undefined;
+    image_url?: string | undefined;
+    seed?: number | undefined;
+    enable_safety_checker?: boolean | undefined;
+    negative_prompt?: string | undefined;
+    num_inference_steps?: number | undefined;
+    guidance_scale?: number | undefined;
+    acceleration?: "none" | "regular" | "high" | undefined;
+    num_images?: "1" | "2" | "3" | "4" | undefined;
+    sync_mode?: boolean | undefined;
+}>;
 export type NanoBananaGenerateRequest = z.infer<typeof NanoBananaGenerateSchema>;
 export type NanaBananaEditRequest = z.infer<typeof NanoBananaEditSchema>;
 export type NanoBananaUpscaleRequest = z.infer<typeof NanoBananaUpscaleSchema>;
@@ -412,6 +552,8 @@ export type ElevenLabsSoundEffectsRequest = z.infer<typeof ElevenLabsSoundEffect
 export type ByteDanceSeedanceVideoRequest = z.infer<typeof ByteDanceSeedanceVideoSchema>;
 export type RunwayAlephVideoRequest = z.infer<typeof RunwayAlephVideoSchema>;
 export type WanVideoRequest = z.infer<typeof WanVideoSchema>;
+export type ByteDanceSeedreamImageRequest = z.infer<typeof ByteDanceSeedreamImageSchema>;
+export type QwenImageRequest = z.infer<typeof QwenImageSchema>;
 export interface KieAiResponse<T = any> {
     code: number;
     msg: string;
@@ -427,7 +569,7 @@ export interface TaskResponse {
 export interface TaskRecord {
     id?: number;
     task_id: string;
-    api_type: 'nano-banana' | 'nano-banana-edit' | 'nano-banana-upscale' | 'veo3' | 'suno' | 'elevenlabs-tts' | 'elevenlabs-sound-effects' | 'bytedance-seedance-video' | 'runway-aleph-video' | 'wan-video';
+    api_type: 'nano-banana' | 'nano-banana-edit' | 'nano-banana-upscale' | 'veo3' | 'suno' | 'elevenlabs-tts' | 'elevenlabs-sound-effects' | 'bytedance-seedance-video' | 'runway-aleph-video' | 'wan-video' | 'bytedance-seedream-image' | 'qwen-image';
     status: 'pending' | 'processing' | 'completed' | 'failed';
     created_at: string;
     updated_at: string;

package/dist/types.js

@@ -180,3 +180,76 @@ export const WanVideoSchema = z.object({
     message: "Invalid aspect_ratio for image-to-video mode. Valid options: 16:9, 9:16, 1:1",
     path: ["aspect_ratio"]
 });
+export const ByteDanceSeedreamImageSchema = z.object({
+    prompt: z.string().min(1).max(5000),
+    image_urls: z.array(z.string().url()).min(1).max(10).optional(),
+    image_size: z.enum([
+        'square', 'square_hd', 'portrait_4_3', 'portrait_3_2', 'portrait_16_9',
+        'landscape_4_3', 'landscape_3_2', 'landscape_16_9', 'landscape_21_9'
+    ]).default('square_hd').optional(),
+    image_resolution: z.enum(['1K', '2K', '4K']).default('1K').optional(),
+    max_images: z.number().int().min(1).max(6).default(1).optional(),
+    seed: z.number().optional(),
+    callBackUrl: z.string().url().optional()
+}).refine((data) => {
+    // Check if callBackUrl is provided directly or via environment variable
+    const hasCallBackUrl = data.callBackUrl || process.env.KIE_AI_CALLBACK_URL;
+    if (!hasCallBackUrl) {
+        return false;
+    }
+    return true;
+}, {
+    message: "callBackUrl is required (either directly or via KIE_AI_CALLBACK_URL environment variable)",
+    path: ["callBackUrl"]
+});
+export const QwenImageSchema = z.object({
+    prompt: z.string().min(1),
+    image_url: z.string().url().optional(), // Required for edit mode, optional for text-to-image
+    image_size: z.enum([
+        'square', 'square_hd', 'portrait_4_3', 'portrait_16_9',
+        'landscape_4_3', 'landscape_16_9'
+    ]).default('square_hd').optional(),
+    num_inference_steps: z.number().int().min(2).max(250).optional(),
+    seed: z.number().optional(),
+    guidance_scale: z.number().min(0).max(20).optional(),
+    enable_safety_checker: z.boolean().default(true).optional(),
+    output_format: z.enum(['png', 'jpeg']).default('png').optional(),
+    negative_prompt: z.string().max(500).default(' ').optional(),
+    acceleration: z.enum(['none', 'regular', 'high']).default('none').optional(),
+    // Edit-specific parameters
+    num_images: z.enum(['1', '2', '3', '4']).optional(),
+    sync_mode: z.boolean().default(false).optional(),
+    callBackUrl: z.string().url().optional()
+}).refine((data) => {
+    // Check if callBackUrl is provided directly or via environment variable
+    const hasCallBackUrl = data.callBackUrl || process.env.KIE_AI_CALLBACK_URL;
+    if (!hasCallBackUrl) {
+        return false;
+    }
+    return true;
+}, {
+    message: "callBackUrl is required (either directly or via KIE_AI_CALLBACK_URL environment variable)",
+    path: ["callBackUrl"]
+}).refine((data) => {
+    // Validate edit mode requirements
+    const isEditMode = !!data.image_url;
+    if (isEditMode) {
+        // Edit mode specific validations
+        if (data.num_inference_steps && (data.num_inference_steps < 2 || data.num_inference_steps > 49)) {
+            return false;
+        }
+        if (data.prompt && data.prompt.length > 2000) {
+            return false;
+        }
+    }
+    else {
+        // Text-to-image mode specific validations
+        if (data.prompt && data.prompt.length > 5000) {
+            return false;
+        }
+    }
+    return true;
+}, {
+    message: "Invalid parameters for detected mode",
+    path: []
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@felores/kie-ai-mcp-server",
-  "version": "1.7.1",
-  "description": "MCP server for Kie.ai APIs (Nano Banana image generation/editing, Veo3 video generation, Suno music generation, and ElevenLabs text-to-speech)",
+  "version": "1.7.3",
+  "description": "MCP server for Kie.ai APIs (Nano Banana image generation/editing, ByteDance Seedream V4 image generation/editing, Veo3 video generation, Suno music generation, and ElevenLabs text-to-speech)",
   "main": "dist/index.js",
   "bin": {
     "kie-ai-mcp-server": "dist/index.js"