@felores/kie-ai-mcp-server 1.7.2 → 1.7.4

package/README.md

@@ -23,6 +23,7 @@ Access the world's best AI models through a single, developer-friendly API. Gene
 - **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.
@@ -580,7 +581,79 @@ Multiple image editing:
 
 **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. `runway_aleph_video`
+### 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:**
@@ -636,7 +709,125 @@ Vertical video for social media:
 
 **Note**: The `callBackUrl` is optional and will use the `KIE_AI_CALLBACK_URL` environment variable if not provided. Video-to-video transformation typically takes 3-8 minutes depending on complexity and length.
 
-### 14. `wan_video`
+### 16. `midjourney_generate`
+Generate images and videos using Midjourney AI models (unified tool for text-to-image, image-to-image, style reference, omni reference, and video generation).
+
+**Parameters:**
+- `prompt` (string, required): Text prompt describing the desired image or video (max 2000 chars)
+- `taskType` (string, optional): Task type for generation mode (auto-detected if not provided)
+  - Options: `mj_txt2img`, `mj_img2img`, `mj_style_reference`, `mj_omni_reference`, `mj_video`, `mj_video_hd`
+- `fileUrl` (string, optional): Single image URL for image-to-image or video generation (legacy - use fileUrls instead)
+- `fileUrls` (array, optional): Array of image URLs for image-to-image or video generation (recommended, max 10)
+- `speed` (string, optional): Generation speed (not required for video/omni tasks)
+  - Options: `relaxed`, `fast`, `turbo`
+- `aspectRatio` (string, optional): Output aspect ratio (default: "16:9")
+  - Options: `1:2`, `9:16`, `2:3`, `3:4`, `5:6`, `6:5`, `4:3`, `3:2`, `1:1`, `16:9`, `2:1`
+- `version` (string, optional): Midjourney model version (default: "7")
+  - Options: `7`, `6.1`, `6`, `5.2`, `5.1`, `niji6`
+- `variety` (integer, optional): Controls diversity of generated results (0-100, increment by 5)
+- `stylization` (integer, optional): Artistic style intensity (0-1000, suggested multiple of 50)
+- `weirdness` (integer, optional): Creativity and uniqueness level (0-3000, suggested multiple of 100)
+- `ow` (integer, optional): Omni intensity parameter for omni reference tasks (1-1000)
+- `waterMark` (string, optional): Watermark identifier (max 100 chars)
+- `enableTranslation` (boolean, optional): Auto-translate non-English prompts to English (default: false)
+- `videoBatchSize` (string, optional): Number of videos to generate (video mode only, default: "1")
+  - Options: `1`, `2`, `4`
+- `motion` (string, optional): Motion level for video generation (required for video mode, default: "high")
+  - Options: `high`, `low`
+- `high_definition_video` (boolean, optional): Use HD video generation instead of standard definition (default: false)
+- `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",
+  "aspectRatio": "16:9",
+  "version": "7",
+  "speed": "fast",
+  "stylization": 500
+}
+```
+
+Image-to-image generation:
+```json
+{
+  "prompt": "Transform this portrait into a cyberpunk style with neon lights",
+  "fileUrls": ["https://example.com/portrait.jpg"],
+  "aspectRatio": "1:1",
+  "version": "7",
+  "variety": 10
+}
+```
+
+Standard definition video generation (default):
+```json
+{
+  "prompt": "Add gentle movement and atmospheric effects",
+  "fileUrls": ["https://example.com/landscape.jpg"],
+  "motion": "high",
+  "videoBatchSize": "1",
+  "aspectRatio": "16:9"
+}
+```
+
+High definition video generation (explicit):
+```json
+{
+  "prompt": "Create cinematic video with dramatic motion",
+  "fileUrls": ["https://example.com/cityscape.jpg"],
+  "motion": "high",
+  "high_definition_video": true,
+  "videoBatchSize": "2",
+  "aspectRatio": "16:9"
+}
+```
+
+Omni reference generation:
+```json
+{
+  "prompt": "Place this character in a fantasy forest setting",
+  "fileUrls": ["https://example.com/character.jpg"],
+  "ow": 500,
+  "aspectRatio": "16:9",
+  "version": "7"
+}
+```
+
+Style reference generation:
+```json
+{
+  "prompt": "Apply this artistic style to a new landscape",
+  "fileUrls": ["https://example.com/artistic-style.jpg"],
+  "taskType": "mj_style_reference",
+  "aspectRatio": "16:9",
+  "stylization": 700
+}
+```
+
+**Key Features:**
+- **Unified Interface**: Single tool for all Midjourney generation modes
+- **Smart Mode Detection**: Automatically detects task type based on parameters
+- **Video Default**: Uses standard definition video by default, HD only when explicitly requested
+- **Multiple Aspect Ratios**: Support for vertical, horizontal, square, and ultra-wide formats
+- **Style Control**: Fine-tune artistic style with stylization, variety, and weirdness parameters
+- **Speed Options**: Choose generation speed based on urgency (relaxed/fast/turbo)
+- **Model Versions**: Access different Midjourney models including niji for anime/illustration
+- **Reference Modes**: Advanced omni and style reference for character and style transfer
+- **Batch Generation**: Generate multiple videos in a single request
+
+**Smart Detection Logic:**
+- If `high_definition_video` is true → `mj_video_hd`
+- If `motion` or `videoBatchSize` present → `mj_video` (standard) or `mj_video_hd` (explicit)
+- If `ow` present → `mj_omni_reference`
+- If `taskType` is `mj_style_reference` → `mj_style_reference`
+- If `fileUrl`/`fileUrls` present → `mj_img2img`
+- Otherwise → `mj_txt2img`
+
+**Note**: The `callBackUrl` is optional and will use the `KIE_AI_CALLBACK_URL` environment variable if not provided. Generation times vary: text-to-image (1-3 minutes), image-to-image (2-4 minutes), video generation (3-8 minutes), reference modes (2-5 minutes).
+
+### 17. `wan_video`
 Generate videos using Alibaba Wan 2.5 models (unified tool for both text-to-video and image-to-video).
 
 **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, ByteDanceSeedreamImageSchema, RunwayAlephVideoSchema, WanVideoSchema } from './types.js';
+import { NanoBananaGenerateSchema, NanoBananaEditSchema, NanoBananaUpscaleSchema, Veo3GenerateSchema, SunoGenerateSchema, ElevenLabsTTSSchema, ElevenLabsSoundEffectsSchema, ByteDanceSeedanceVideoSchema, ByteDanceSeedreamImageSchema, QwenImageSchema, RunwayAlephVideoSchema, WanVideoSchema, MidjourneyGenerateSchema } 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.2',
+            version: '1.7.4',
         });
         // Initialize client with config from environment
         const config = {
@@ -606,6 +606,196 @@ class KieAiMcpServer {
                             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: 'midjourney_generate',
+                        description: 'Generate images and videos using Midjourney AI models (unified tool for text-to-image, image-to-image, style reference, omni reference, and video generation)',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                prompt: {
+                                    type: 'string',
+                                    description: 'Text prompt describing the desired image or video (max 2000 characters)',
+                                    minLength: 1,
+                                    maxLength: 2000
+                                },
+                                taskType: {
+                                    type: 'string',
+                                    description: 'Task type for generation mode (auto-detected if not provided)',
+                                    enum: ['mj_txt2img', 'mj_img2img', 'mj_style_reference', 'mj_omni_reference', 'mj_video', 'mj_video_hd']
+                                },
+                                fileUrl: {
+                                    type: 'string',
+                                    description: 'Single image URL for image-to-image or video generation (legacy - use fileUrls instead)',
+                                    format: 'uri'
+                                },
+                                fileUrls: {
+                                    type: 'array',
+                                    description: 'Array of image URLs for image-to-image or video generation (recommended)',
+                                    items: {
+                                        type: 'string',
+                                        format: 'uri'
+                                    },
+                                    maxItems: 10
+                                },
+                                speed: {
+                                    type: 'string',
+                                    description: 'Generation speed (not required for video/omni tasks)',
+                                    enum: ['relaxed', 'fast', 'turbo']
+                                },
+                                aspectRatio: {
+                                    type: 'string',
+                                    description: 'Output aspect ratio',
+                                    enum: ['1:2', '9:16', '2:3', '3:4', '5:6', '6:5', '4:3', '3:2', '1:1', '16:9', '2:1'],
+                                    default: '16:9'
+                                },
+                                version: {
+                                    type: 'string',
+                                    description: 'Midjourney model version',
+                                    enum: ['7', '6.1', '6', '5.2', '5.1', 'niji6'],
+                                    default: '7'
+                                },
+                                variety: {
+                                    type: 'integer',
+                                    description: 'Controls diversity of generated results (0-100, increment by 5)',
+                                    minimum: 0,
+                                    maximum: 100
+                                },
+                                stylization: {
+                                    type: 'integer',
+                                    description: 'Artistic style intensity (0-1000, suggested multiple of 50)',
+                                    minimum: 0,
+                                    maximum: 1000
+                                },
+                                weirdness: {
+                                    type: 'integer',
+                                    description: 'Creativity and uniqueness level (0-3000, suggested multiple of 100)',
+                                    minimum: 0,
+                                    maximum: 3000
+                                },
+                                ow: {
+                                    type: 'integer',
+                                    description: 'Omni intensity parameter for omni reference tasks (1-1000)',
+                                    minimum: 1,
+                                    maximum: 1000
+                                },
+                                waterMark: {
+                                    type: 'string',
+                                    description: 'Watermark identifier',
+                                    maxLength: 100
+                                },
+                                enableTranslation: {
+                                    type: 'boolean',
+                                    description: 'Auto-translate non-English prompts to English',
+                                    default: false
+                                },
+                                videoBatchSize: {
+                                    type: 'string',
+                                    description: 'Number of videos to generate (video mode only)',
+                                    enum: ['1', '2', '4'],
+                                    default: '1'
+                                },
+                                motion: {
+                                    type: 'string',
+                                    description: 'Motion level for video generation (required for video mode)',
+                                    enum: ['high', 'low'],
+                                    default: 'high'
+                                },
+                                high_definition_video: {
+                                    type: 'boolean',
+                                    description: 'Use high definition video generation instead of standard definition',
+                                    default: false
+                                },
+                                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',
@@ -750,6 +940,10 @@ class KieAiMcpServer {
                         return await this.handleByteDanceSeedanceVideo(args);
                     case 'bytedance_seedream_image':
                         return await this.handleByteDanceSeedreamImage(args);
+                    case 'qwen_image':
+                        return await this.handleQwenImage(args);
+                    case 'midjourney_generate':
+                        return await this.handleMidjourneyGenerate(args);
                     case 'runway_aleph_video':
                         return await this.handleRunwayAlephVideo(args);
                     case 'wan_video':
@@ -1515,6 +1709,225 @@ class KieAiMcpServer {
             });
         }
     }
+    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 handleMidjourneyGenerate(args) {
+        try {
+            const request = MidjourneyGenerateSchema.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.generateMidjourney(request);
+            if (response.code === 200 && response.data?.taskId) {
+                // Determine task type for user feedback
+                const hasImage = request.fileUrl || (request.fileUrls && request.fileUrls.length > 0);
+                const isVideoMode = request.motion || request.videoBatchSize || request.high_definition_video;
+                const isOmniMode = request.ow || request.taskType === 'mj_omni_reference';
+                const isStyleMode = request.taskType === 'mj_style_reference';
+                let taskTypeDisplay = 'Text-to-Image';
+                if (isOmniMode) {
+                    taskTypeDisplay = 'Omni Reference';
+                }
+                else if (isStyleMode) {
+                    taskTypeDisplay = 'Style Reference';
+                }
+                else if (isVideoMode) {
+                    taskTypeDisplay = request.high_definition_video ? 'Image-to-HD-Video' : 'Image-to-Video';
+                }
+                else if (hasImage) {
+                    taskTypeDisplay = 'Image-to-Image';
+                }
+                // Store task in database
+                await this.db.createTask({
+                    task_id: response.data.taskId,
+                    api_type: 'midjourney',
+                    status: 'pending'
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                task_id: response.data.taskId,
+                                message: `Midjourney ${taskTypeDisplay} task created successfully`,
+                                parameters: {
+                                    task_type: taskTypeDisplay,
+                                    prompt: request.prompt.substring(0, 100) + (request.prompt.length > 100 ? '...' : ''),
+                                    aspect_ratio: request.aspectRatio || '16:9',
+                                    version: request.version || '7',
+                                    speed: request.speed,
+                                    variety: request.variety,
+                                    stylization: request.stylization,
+                                    weirdness: request.weirdness,
+                                    enable_translation: request.enableTranslation || false,
+                                    waterMark: request.waterMark,
+                                    ...(hasImage && {
+                                        file_urls: request.fileUrls || [request.fileUrl]
+                                    }),
+                                    ...(isVideoMode && {
+                                        motion: request.motion || 'high',
+                                        video_batch_size: request.videoBatchSize || '1',
+                                        high_definition_video: request.high_definition_video || false
+                                    }),
+                                    ...(isOmniMode && {
+                                        ow: request.ow
+                                    })
+                                },
+                                next_steps: [
+                                    `Use get_task_status with task_id: ${response.data.taskId} to check progress`,
+                                    'Generated content 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 Midjourney task');
+            }
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                return this.formatError('midjourney_generate', error, {
+                    prompt: 'Required: Text prompt describing the desired image (max 2000 chars)',
+                    taskType: 'Optional: Task type (mj_txt2img, mj_img2img, mj_style_reference, mj_omni_reference, mj_video, mj_video_hd) - auto-detected if not provided',
+                    fileUrl: 'Optional: Single image URL for image-to-image or video generation (legacy)',
+                    fileUrls: 'Optional: Array of image URLs for image-to-image or video generation (recommended)',
+                    speed: 'Optional: Generation speed (relaxed/fast/turbo) - not required for video/omni tasks',
+                    aspectRatio: 'Optional: Output aspect ratio (1:2, 9:16, 2:3, 3:4, 5:6, 6:5, 4:3, 3:2, 1:1, 16:9, 2:1, default: 16:9)',
+                    version: 'Optional: Midjourney model version (7, 6.1, 6, 5.2, 5.1, niji6, default: 7)',
+                    variety: 'Optional: Diversity control (0-100, increment by 5)',
+                    stylization: 'Optional: Artistic style intensity (0-1000, suggested multiple of 50)',
+                    weirdness: 'Optional: Creativity level (0-3000, suggested multiple of 100)',
+                    ow: 'Optional: Omni intensity for omni reference tasks (1-1000)',
+                    waterMark: 'Optional: Watermark identifier (max 100 chars)',
+                    enableTranslation: 'Optional: Auto-translate non-English prompts (default: false)',
+                    videoBatchSize: 'Optional: Number of videos to generate (1/2/4, default: 1, video mode only)',
+                    motion: 'Optional: Video motion level (high/low, default: high, required for video)',
+                    high_definition_video: 'Optional: Use HD video generation (default: false, uses standard definition)',
+                    callBackUrl: 'Optional: URL for task completion notifications (uses KIE_AI_CALLBACK_URL env var if not provided)'
+                });
+            }
+            return this.formatError('midjourney_generate', error, {
+                prompt: 'Required: Text prompt describing the desired image (max 2000 chars)',
+                taskType: 'Optional: Task type (mj_txt2img, mj_img2img, mj_style_reference, mj_omni_reference, mj_video, mj_video_hd) - auto-detected if not provided',
+                fileUrl: 'Optional: Single image URL for image-to-image or video generation (legacy)',
+                fileUrls: 'Optional: Array of image URLs for image-to-image or video generation (recommended)',
+                speed: 'Optional: Generation speed (relaxed/fast/turbo) - not required for video/omni tasks',
+                aspectRatio: 'Optional: Output aspect ratio (1:2, 9:16, 2:3, 3:4, 5:6, 6:5, 4:3, 3:2, 1:1, 16:9, 2:1, default: 16:9)',
+                version: 'Optional: Midjourney model version (7, 6.1, 6, 5.2, 5.1, niji6, default: 7)',
+                variety: 'Optional: Diversity control (0-100, increment by 5)',
+                stylization: 'Optional: Artistic style intensity (0-1000, suggested multiple of 50)',
+                weirdness: 'Optional: Creativity level (0-3000, suggested multiple of 100)',
+                ow: 'Optional: Omni intensity for omni reference tasks (1-1000)',
+                waterMark: 'Optional: Watermark identifier (max 100 chars)',
+                enableTranslation: 'Optional: Auto-translate non-English prompts (default: false)',
+                videoBatchSize: 'Optional: Number of videos to generate (1/2/4, default: 1, video mode only)',
+                motion: 'Optional: Video motion level (high/low, default: high, required for video)',
+                high_definition_video: 'Optional: Use HD video generation (default: false, uses standard definition)',
+                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, ByteDanceSeedreamImageRequest, ImageResponse, TaskResponse } from './types.js';
+import { KieAiConfig, KieAiResponse, NanoBananaGenerateRequest, NanaBananaEditRequest, NanoBananaUpscaleRequest, Veo3GenerateRequest, SunoGenerateRequest, ElevenLabsTTSRequest, ElevenLabsSoundEffectsRequest, ByteDanceSeedanceVideoRequest, RunwayAlephVideoRequest, WanVideoRequest, ByteDanceSeedreamImageRequest, QwenImageRequest, MidjourneyGenerateRequest, ImageResponse, TaskResponse } from './types.js';
 export declare class KieAiClient {
     private config;
     constructor(config: KieAiConfig);
@@ -15,5 +15,7 @@ export declare class KieAiClient {
     generateRunwayAlephVideo(request: RunwayAlephVideoRequest): Promise<KieAiResponse<TaskResponse>>;
     generateWanVideo(request: WanVideoRequest): Promise<KieAiResponse<TaskResponse>>;
     generateByteDanceSeedreamImage(request: ByteDanceSeedreamImageRequest): Promise<KieAiResponse<TaskResponse>>;
+    generateQwenImage(request: QwenImageRequest): Promise<KieAiResponse<TaskResponse>>;
+    generateMidjourney(request: MidjourneyGenerateRequest): Promise<KieAiResponse<TaskResponse>>;
     getVeo1080pVideo(taskId: string, index?: number): Promise<KieAiResponse<any>>;
 }

package/dist/kie-ai-client.js

@@ -80,13 +80,16 @@ 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 === 'bytedance-seedream-image' || 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') {
             return this.makeRequest(`/api/v1/aleph/record-info?taskId=${taskId}`, 'GET');
         }
-        // Fallback: try jobs first, then veo, then generate (for tasks not in database)
+        else if (apiType === 'midjourney') {
+            return this.makeRequest(`/mj/record-info?taskId=${taskId}`, 'GET');
+        }
+        // Fallback: try jobs first, then veo, then generate, then mj (for tasks not in database)
         try {
             return await this.makeRequest(`/jobs/recordInfo?taskId=${taskId}`, 'GET');
         }
@@ -99,7 +102,12 @@ export class KieAiClient {
                     return await this.makeRequest(`/generate/record-info?taskId=${taskId}`, 'GET');
                 }
                 catch (sunoError) {
-                    throw error;
+                    try {
+                        return await this.makeRequest(`/mj/record-info?taskId=${taskId}`, 'GET');
+                    }
+                    catch (mjError) {
+                        throw error;
+                    }
                 }
             }
         }
@@ -254,6 +262,107 @@ export class KieAiClient {
         };
         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 generateMidjourney(request) {
+        // Smart task type detection
+        let taskType = request.taskType;
+        const hasImage = request.fileUrl || (request.fileUrls && request.fileUrls.length > 0);
+        const isVideoMode = request.motion || request.videoBatchSize || request.high_definition_video;
+        const isOmniMode = request.ow || request.taskType === 'mj_omni_reference';
+        const isStyleMode = request.taskType === 'mj_style_reference';
+        // Auto-detect task type if not provided
+        if (!taskType) {
+            if (isOmniMode) {
+                taskType = 'mj_omni_reference';
+            }
+            else if (isStyleMode) {
+                taskType = 'mj_style_reference';
+            }
+            else if (isVideoMode) {
+                taskType = request.high_definition_video ? 'mj_video_hd' : 'mj_video';
+            }
+            else if (hasImage) {
+                taskType = 'mj_img2img';
+            }
+            else {
+                taskType = 'mj_txt2img';
+            }
+        }
+        // Build request payload
+        const payload = {
+            taskType,
+            prompt: request.prompt,
+            aspectRatio: request.aspectRatio || '16:9',
+            version: request.version || '7',
+            enableTranslation: request.enableTranslation || false,
+            callBackUrl: request.callBackUrl || process.env.KIE_AI_CALLBACK_URL
+        };
+        // Add image URLs (prefer fileUrls array over fileUrl)
+        if (request.fileUrls && request.fileUrls.length > 0) {
+            payload.fileUrls = request.fileUrls;
+        }
+        else if (request.fileUrl) {
+            payload.fileUrls = [request.fileUrl];
+        }
+        // Add optional parameters based on task type
+        if (request.speed && !['mj_video', 'mj_video_hd', 'mj_omni_reference'].includes(taskType)) {
+            payload.speed = request.speed;
+        }
+        if (request.variety !== undefined) {
+            payload.variety = request.variety;
+        }
+        if (request.stylization !== undefined) {
+            payload.stylization = request.stylization;
+        }
+        if (request.weirdness !== undefined) {
+            payload.weirdness = request.weirdness;
+        }
+        if (request.waterMark !== undefined) {
+            payload.waterMark = request.waterMark;
+        }
+        // Task-specific parameters
+        if (taskType === 'mj_omni_reference' && request.ow) {
+            payload.ow = request.ow;
+        }
+        if ((taskType === 'mj_video' || taskType === 'mj_video_hd')) {
+            payload.motion = request.motion || 'high';
+            if (request.videoBatchSize) {
+                payload.videoBatchSize = parseInt(request.videoBatchSize.toString());
+            }
+        }
+        return this.makeRequest('/mj/generate', 'POST', payload);
+    }
     async getVeo1080pVideo(taskId, index) {
         const params = new URLSearchParams({ taskId });
         if (index !== undefined) {

package/dist/types.d.ts

@@ -443,6 +443,232 @@ export declare const ByteDanceSeedreamImageSchema: z.ZodEffects<z.ZodObject<{
     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 declare const MidjourneyGenerateSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    prompt: z.ZodString;
+    taskType: z.ZodOptional<z.ZodEnum<["mj_txt2img", "mj_img2img", "mj_style_reference", "mj_omni_reference", "mj_video", "mj_video_hd"]>>;
+    fileUrl: z.ZodOptional<z.ZodString>;
+    fileUrls: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    speed: z.ZodOptional<z.ZodEnum<["relaxed", "fast", "turbo"]>>;
+    aspectRatio: z.ZodOptional<z.ZodDefault<z.ZodEnum<["1:2", "9:16", "2:3", "3:4", "5:6", "6:5", "4:3", "3:2", "1:1", "16:9", "2:1"]>>>;
+    version: z.ZodOptional<z.ZodDefault<z.ZodEnum<["7", "6.1", "6", "5.2", "5.1", "niji6"]>>>;
+    variety: z.ZodOptional<z.ZodNumber>;
+    stylization: z.ZodOptional<z.ZodNumber>;
+    weirdness: z.ZodOptional<z.ZodNumber>;
+    ow: z.ZodOptional<z.ZodNumber>;
+    waterMark: z.ZodOptional<z.ZodString>;
+    enableTranslation: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    callBackUrl: z.ZodOptional<z.ZodString>;
+    videoBatchSize: z.ZodOptional<z.ZodDefault<z.ZodEnum<["1", "2", "4"]>>>;
+    motion: z.ZodOptional<z.ZodDefault<z.ZodEnum<["high", "low"]>>>;
+    high_definition_video: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    aspectRatio?: "1:1" | "9:16" | "16:9" | "3:4" | "4:3" | "3:2" | "2:3" | "1:2" | "5:6" | "6:5" | "2:1" | undefined;
+    callBackUrl?: string | undefined;
+    enableTranslation?: boolean | undefined;
+    speed?: "turbo" | "relaxed" | "fast" | undefined;
+    waterMark?: string | undefined;
+    taskType?: "mj_txt2img" | "mj_img2img" | "mj_style_reference" | "mj_omni_reference" | "mj_video" | "mj_video_hd" | undefined;
+    fileUrl?: string | undefined;
+    fileUrls?: string[] | undefined;
+    version?: "6" | "7" | "6.1" | "5.2" | "5.1" | "niji6" | undefined;
+    variety?: number | undefined;
+    stylization?: number | undefined;
+    weirdness?: number | undefined;
+    ow?: number | undefined;
+    videoBatchSize?: "1" | "2" | "4" | undefined;
+    motion?: "high" | "low" | undefined;
+    high_definition_video?: boolean | undefined;
+}, {
+    prompt: string;
+    aspectRatio?: "1:1" | "9:16" | "16:9" | "3:4" | "4:3" | "3:2" | "2:3" | "1:2" | "5:6" | "6:5" | "2:1" | undefined;
+    callBackUrl?: string | undefined;
+    enableTranslation?: boolean | undefined;
+    speed?: "turbo" | "relaxed" | "fast" | undefined;
+    waterMark?: string | undefined;
+    taskType?: "mj_txt2img" | "mj_img2img" | "mj_style_reference" | "mj_omni_reference" | "mj_video" | "mj_video_hd" | undefined;
+    fileUrl?: string | undefined;
+    fileUrls?: string[] | undefined;
+    version?: "6" | "7" | "6.1" | "5.2" | "5.1" | "niji6" | undefined;
+    variety?: number | undefined;
+    stylization?: number | undefined;
+    weirdness?: number | undefined;
+    ow?: number | undefined;
+    videoBatchSize?: "1" | "2" | "4" | undefined;
+    motion?: "high" | "low" | undefined;
+    high_definition_video?: boolean | undefined;
+}>, {
+    prompt: string;
+    aspectRatio?: "1:1" | "9:16" | "16:9" | "3:4" | "4:3" | "3:2" | "2:3" | "1:2" | "5:6" | "6:5" | "2:1" | undefined;
+    callBackUrl?: string | undefined;
+    enableTranslation?: boolean | undefined;
+    speed?: "turbo" | "relaxed" | "fast" | undefined;
+    waterMark?: string | undefined;
+    taskType?: "mj_txt2img" | "mj_img2img" | "mj_style_reference" | "mj_omni_reference" | "mj_video" | "mj_video_hd" | undefined;
+    fileUrl?: string | undefined;
+    fileUrls?: string[] | undefined;
+    version?: "6" | "7" | "6.1" | "5.2" | "5.1" | "niji6" | undefined;
+    variety?: number | undefined;
+    stylization?: number | undefined;
+    weirdness?: number | undefined;
+    ow?: number | undefined;
+    videoBatchSize?: "1" | "2" | "4" | undefined;
+    motion?: "high" | "low" | undefined;
+    high_definition_video?: boolean | undefined;
+}, {
+    prompt: string;
+    aspectRatio?: "1:1" | "9:16" | "16:9" | "3:4" | "4:3" | "3:2" | "2:3" | "1:2" | "5:6" | "6:5" | "2:1" | undefined;
+    callBackUrl?: string | undefined;
+    enableTranslation?: boolean | undefined;
+    speed?: "turbo" | "relaxed" | "fast" | undefined;
+    waterMark?: string | undefined;
+    taskType?: "mj_txt2img" | "mj_img2img" | "mj_style_reference" | "mj_omni_reference" | "mj_video" | "mj_video_hd" | undefined;
+    fileUrl?: string | undefined;
+    fileUrls?: string[] | undefined;
+    version?: "6" | "7" | "6.1" | "5.2" | "5.1" | "niji6" | undefined;
+    variety?: number | undefined;
+    stylization?: number | undefined;
+    weirdness?: number | undefined;
+    ow?: number | undefined;
+    videoBatchSize?: "1" | "2" | "4" | undefined;
+    motion?: "high" | "low" | undefined;
+    high_definition_video?: boolean | undefined;
+}>, {
+    prompt: string;
+    aspectRatio?: "1:1" | "9:16" | "16:9" | "3:4" | "4:3" | "3:2" | "2:3" | "1:2" | "5:6" | "6:5" | "2:1" | undefined;
+    callBackUrl?: string | undefined;
+    enableTranslation?: boolean | undefined;
+    speed?: "turbo" | "relaxed" | "fast" | undefined;
+    waterMark?: string | undefined;
+    taskType?: "mj_txt2img" | "mj_img2img" | "mj_style_reference" | "mj_omni_reference" | "mj_video" | "mj_video_hd" | undefined;
+    fileUrl?: string | undefined;
+    fileUrls?: string[] | undefined;
+    version?: "6" | "7" | "6.1" | "5.2" | "5.1" | "niji6" | undefined;
+    variety?: number | undefined;
+    stylization?: number | undefined;
+    weirdness?: number | undefined;
+    ow?: number | undefined;
+    videoBatchSize?: "1" | "2" | "4" | undefined;
+    motion?: "high" | "low" | undefined;
+    high_definition_video?: boolean | undefined;
+}, {
+    prompt: string;
+    aspectRatio?: "1:1" | "9:16" | "16:9" | "3:4" | "4:3" | "3:2" | "2:3" | "1:2" | "5:6" | "6:5" | "2:1" | undefined;
+    callBackUrl?: string | undefined;
+    enableTranslation?: boolean | undefined;
+    speed?: "turbo" | "relaxed" | "fast" | undefined;
+    waterMark?: string | undefined;
+    taskType?: "mj_txt2img" | "mj_img2img" | "mj_style_reference" | "mj_omni_reference" | "mj_video" | "mj_video_hd" | undefined;
+    fileUrl?: string | undefined;
+    fileUrls?: string[] | undefined;
+    version?: "6" | "7" | "6.1" | "5.2" | "5.1" | "niji6" | undefined;
+    variety?: number | undefined;
+    stylization?: number | undefined;
+    weirdness?: number | undefined;
+    ow?: number | undefined;
+    videoBatchSize?: "1" | "2" | "4" | undefined;
+    motion?: "high" | "low" | undefined;
+    high_definition_video?: boolean | undefined;
+}>;
 export type NanoBananaGenerateRequest = z.infer<typeof NanoBananaGenerateSchema>;
 export type NanaBananaEditRequest = z.infer<typeof NanoBananaEditSchema>;
 export type NanoBananaUpscaleRequest = z.infer<typeof NanoBananaUpscaleSchema>;
@@ -454,6 +680,8 @@ export type ByteDanceSeedanceVideoRequest = z.infer<typeof ByteDanceSeedanceVide
 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 type MidjourneyGenerateRequest = z.infer<typeof MidjourneyGenerateSchema>;
 export interface KieAiResponse<T = any> {
     code: number;
     msg: string;
@@ -469,7 +697,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' | 'bytedance-seedream-image';
+    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' | 'midjourney';
     status: 'pending' | 'processing' | 'completed' | 'failed';
     created_at: string;
     updated_at: string;

package/dist/types.js

@@ -202,3 +202,122 @@ export const ByteDanceSeedreamImageSchema = z.object({
     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: []
+});
+export const MidjourneyGenerateSchema = z.object({
+    prompt: z.string().min(1).max(2000),
+    taskType: z.enum([
+        'mj_txt2img', 'mj_img2img', 'mj_style_reference', 'mj_omni_reference',
+        'mj_video', 'mj_video_hd'
+    ]).optional(), // Auto-detected if not provided
+    fileUrl: z.string().url().optional(), // Single image URL (legacy)
+    fileUrls: z.array(z.string().url()).max(10).optional(), // Array of image URLs (recommended)
+    speed: z.enum(['relaxed', 'fast', 'turbo']).optional(), // Not required for video/omni tasks
+    aspectRatio: z.enum([
+        '1:2', '9:16', '2:3', '3:4', '5:6', '6:5', '4:3', '3:2', '1:1', '16:9', '2:1'
+    ]).default('16:9').optional(),
+    version: z.enum(['7', '6.1', '6', '5.2', '5.1', 'niji6']).default('7').optional(),
+    variety: z.number().int().min(0).max(100).optional(), // Increment by 5
+    stylization: z.number().int().min(0).max(1000).optional(), // Suggested multiple of 50
+    weirdness: z.number().int().min(0).max(3000).optional(), // Suggested multiple of 100
+    ow: z.number().int().min(1).max(1000).optional(), // Omni intensity (only for mj_omni_reference)
+    waterMark: z.string().max(100).optional(),
+    enableTranslation: z.boolean().default(false).optional(),
+    callBackUrl: z.string().url().optional(),
+    // Video-specific parameters
+    videoBatchSize: z.enum(['1', '2', '4']).default('1').optional(), // Only for mj_video/mj_video_hd
+    motion: z.enum(['high', 'low']).default('high').optional(), // Required for video generation
+    high_definition_video: z.boolean().default(false).optional() // If true, use mj_video_hd instead of mj_video
+}).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) => {
+    // Auto-detect and validate task type based on parameters
+    const hasImage = data.fileUrl || (data.fileUrls && data.fileUrls.length > 0);
+    const isVideoMode = data.motion || data.videoBatchSize || data.high_definition_video;
+    const isOmniMode = data.taskType === 'mj_omni_reference' || data.ow;
+    const isStyleMode = data.taskType === 'mj_style_reference';
+    // If taskType is explicitly provided, validate it
+    if (data.taskType) {
+        // Video tasks require motion parameter
+        if ((data.taskType === 'mj_video' || data.taskType === 'mj_video_hd') && !data.motion) {
+            return false;
+        }
+        // Omni tasks require ow parameter
+        if (data.taskType === 'mj_omni_reference' && !data.ow) {
+            return false;
+        }
+        // Image tasks require image URL
+        if ((data.taskType === 'mj_img2img' || data.taskType === 'mj_style_reference' || data.taskType === 'mj_omni_reference') && !hasImage) {
+            return false;
+        }
+        // Video tasks require image URL
+        if ((data.taskType === 'mj_video' || data.taskType === 'mj_video_hd') && !hasImage) {
+            return false;
+        }
+        // Text-to-image should not have image URL
+        if (data.taskType === 'mj_txt2img' && hasImage) {
+            return false;
+        }
+    }
+    return true;
+}, {
+    message: "Invalid combination of parameters for the detected task type",
+    path: []
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@felores/kie-ai-mcp-server",
-  "version": "1.7.2",
-  "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)",
+  "version": "1.7.4",
+  "description": "MCP server for Kie.ai APIs (Nano Banana image generation/editing, ByteDance Seedream V4 image generation/editing, Veo3 video generation, Suno music generation, ElevenLabs text-to-speech, and Midjourney AI generation)",
   "main": "dist/index.js",
   "bin": {
     "kie-ai-mcp-server": "dist/index.js"