pixi-board-plugin-mivo 0.1.2 → 0.1.4

package/dist/index.js

@@ -9,6 +9,10 @@ var DEFAULT_API_BASE = "https://aigc.xindong.com/api/v1";
 var URL_KEYS = ["signUrl", "sign_url", "url", "uri", "displayUrl", "fileUrl", "downloadUrl", "src", "image"];
 var ID_KEYS = ["fileId", "file_id", "object_id", "_id"];
 var TOKEN_REFRESH_SKEW_MS = 6e4;
+var MEDIA_ROUTE_BY_KIND = {
+  image: "image",
+  video: "video"
+};
 function createMivoApiClient(options = {}) {
   const env = options.env ?? process.env;
   const fetchImpl = options.fetchImpl ?? fetch;
@@ -129,11 +133,11 @@ function createMivoApiClient(options = {}) {
       const value = await readJsonResponse(response, "Mivo result request");
       return readMessageResult(value);
     },
-    fileUrl(fileId) {
-      return mivoFileUrl(fileId, apiBase);
+    fileUrl(fileId, kind = "image") {
+      return mivoFileUrl(fileId, kind, apiBase);
     },
-    async downloadFile(fileId, savePath) {
-      await this.downloadUrl(this.fileUrl(fileId), savePath);
+    async downloadFile(fileId, savePath, kind = "image") {
+      await this.downloadUrl(this.fileUrl(fileId, kind), savePath);
     },
     async downloadUrl(url, savePath) {
       await mkdir(path.dirname(savePath), { recursive: true });
@@ -151,22 +155,29 @@ function createMivoApiClient(options = {}) {
   }
 }
 function extractImageArtifact(message) {
-  const images = message.content?.images ?? message.images;
-  const image = images?.[0];
-  if (image === void 0 || image === null) return null;
-  if (typeof image === "string") {
-    if (/^https?:\/\//i.test(image)) return { url: image };
-    if (image.startsWith("/file/image/")) return { fileId: image.slice("/file/image/".length) };
-    return { fileId: image };
-  }
-  if (!isRecord(image)) return null;
-  const url = readStringFromAny(image, URL_KEYS);
-  const fileId = readStringFromAny(image, ID_KEYS);
+  return extractMediaArtifact(message, "image");
+}
+function extractVideoArtifact(message) {
+  return extractMediaArtifact(message, "video");
+}
+function extractMediaArtifact(message, kind) {
+  const values = kind === "image" ? message.content?.images ?? message.images : message.content?.videos ?? message.videos;
+  const media = values?.[0];
+  if (media === void 0 || media === null) return null;
+  if (typeof media === "string") {
+    if (/^https?:\/\//i.test(media)) return { url: media };
+    const routePrefix = `/file/${MEDIA_ROUTE_BY_KIND[kind]}/`;
+    if (media.startsWith(routePrefix)) return { fileId: media.slice(routePrefix.length) };
+    return { fileId: media };
+  }
+  if (!isRecord(media)) return null;
+  const url = readStringFromAny(media, URL_KEYS);
+  const fileId = readStringFromAny(media, ID_KEYS);
   if (!url && !fileId) return null;
   return { fileId, url };
 }
-function mivoFileUrl(fileId, apiBase = DEFAULT_API_BASE) {
-  return `${trimTrailingSlash(apiBase)}/file/image/${encodeURIComponent(fileId)}`;
+function mivoFileUrl(fileId, kind = "image", apiBase = DEFAULT_API_BASE) {
+  return `${trimTrailingSlash(apiBase)}/file/${MEDIA_ROUTE_BY_KIND[kind]}/${encodeURIComponent(fileId)}`;
 }
 function readMessageResultFromSse(text) {
   const direct = parseMaybeJson(text);
@@ -258,7 +269,16 @@ function isRecord(value) {
 }
 
 // src/index.ts
-var RATIOS = ["1:1", "2:3", "3:2", "9:16", "16:9"];
+var GPT_IMAGE_RATIOS = ["1:1", "2:3", "3:2", "9:16", "16:9"];
+var NANO_IMAGE_RATIOS = ["1:1", "2:3", "3:2", "3:4", "4:3", "9:16", "16:9", "21:9", "5:4", "4:5"];
+var SEEDANCE_VIDEO_RATIOS = ["1:1", "3:4", "4:3", "9:16", "16:9", "21:9"];
+var KLING_VIDEO_RATIOS = ["1:1", "9:16", "16:9"];
+var IMAGE_COUNTS = [1, 2, 4];
+var IMAGE_RESOLUTIONS = ["1K", "2K", "4K"];
+var SEEDANCE_RESOLUTIONS = ["480P", "720P", "1080P"];
+var KLING_DURATIONS = [5, 10];
+var KLING_MODES = ["std", "pro"];
+var KLING_SOUNDS = ["off", "on"];
 var DEFAULT_RATIO = "1:1";
 var DEFAULT_TIMEOUT_MS = 3e5;
 var DEFAULT_POLL_INTERVAL_MS = 2e3;
@@ -268,7 +288,7 @@ var anyOutputSchema = {
 };
 var mivoPlugin = {
   name: "pixi-board-plugin-mivo",
-  version: "0.1.2",
+  version: "0.1.4",
   environmentVariables: [
     {
       name: "MIVO_API_KEY",
@@ -287,6 +307,9 @@ var mivoPlugin = {
   },
   register(api) {
     api.registerTool(createMivoCreateGptImageTool());
+    api.registerTool(createMivoCreateNanoImageTool());
+    api.registerTool(createMivoCreateKlingVideoTool());
+    api.registerTool(createMivoCreateSeedanceVideoTool());
   }
 };
 var plugin = mivoPlugin;
@@ -300,56 +323,22 @@ function createMivoCreateGptImageTool(deps = {}) {
     inputSchema: createGptImageInputSchema,
     outputSchema: createGptImageOutputSchema,
     async run(input, ctx) {
-      const args = readInput(input);
-      const projectInfo = await ctx.tools.call("canvas.read_project_info", {
-        projectRoot: args.projectRoot
+      const args = readGptImageInput(input);
+      return runMivoGeneration(ctx, client, sleep, {
+        projectRoot: args.projectRoot,
+        prompt: args.prompt,
+        name: args.name ?? defaultNodeName("GPT image", args.prompt),
+        toolName: "mivo.create_gpt_image",
+        chatType: "freeform",
+        mediaKind: "image",
+        extension: "png",
+        timeoutMs: args.timeoutMs,
+        pollIntervalMs: args.pollIntervalMs,
+        metadata: {
+          ratio: args.ratio
+        },
+        buildPayload: (chatSessionId) => buildGptImageSubmitPayload(args, chatSessionId)
       });
-      const projectRoot = projectInfo.projectRoot;
-      let nodeId = null;
-      let messageId = null;
-      try {
-        const createResult = await ctx.tools.call("canvas.create_nodes", {
-          projectRoot,
-          nodes: [
-            {
-              kind: "generating",
-              name: args.name ?? defaultNodeName(args.prompt),
-              options: {
-                mivo: {
-                  status: "generating",
-                  provider: "mivo",
-                  tool: "mivo.create_gpt_image",
-                  prompt: args.prompt,
-                  ratio: args.ratio
-                }
-              }
-            }
-          ]
-        });
-        nodeId = readCreatedNodeId(createResult);
-        const chatSessionId = await client.getChatSessionId("freeform");
-        messageId = await client.submitMessage(buildSubmitPayload(args, chatSessionId));
-        const artifact = await pollForImage(client, messageId, args.timeoutMs, args.pollIntervalMs, sleep);
-        const imagePath = await materializeArtifact(client, artifact, projectRoot, messageId);
-        const installResult = await ctx.tools.call("canvas.generating_node_install", {
-          projectRoot,
-          nodeId,
-          path: imagePath
-        });
-        return {
-          nodeId,
-          messageId,
-          imagePath,
-          imageUrl: artifact.url ?? (artifact.fileId ? client.fileUrl(artifact.fileId) : void 0),
-          nodes: installResult.nodes,
-          assets: installResult.assets ?? []
-        };
-      } catch (error) {
-        if (nodeId) {
-          await markNodeFailed(ctx, projectRoot, nodeId, error, messageId);
-        }
-        throw error;
-      }
     }
   };
 }
@@ -358,9 +347,41 @@ var createGptImageInputSchema = objectSchema({
   prompt: stringSchema("Prompt for GPT Image 2"),
   ratio: {
     type: "string",
-    enum: RATIOS,
+    enum: GPT_IMAGE_RATIOS,
+    description: "Generated image aspect ratio"
+  },
+  name: stringSchema("Optional display name for the generating node"),
+  referenceFileIds: {
+    type: "array",
+    items: { type: "string" },
+    description: "Optional Mivo file ids to use as image references"
+  },
+  timeoutMs: {
+    type: "number",
+    description: "Maximum time to wait for the Mivo message result"
+  },
+  pollIntervalMs: {
+    type: "number",
+    description: "Delay between Mivo result polling attempts"
+  }
+}, ["projectRoot", "prompt"]);
+var createNanoImageInputSchema = objectSchema({
+  projectRoot: stringSchema('Canvas project root absolute path, or "active" for the current canvas'),
+  prompt: stringSchema("Prompt for Nano image generation"),
+  ratio: {
+    type: "string",
+    enum: NANO_IMAGE_RATIOS,
     description: "Generated image aspect ratio"
   },
+  resolution: {
+    type: "string",
+    enum: IMAGE_RESOLUTIONS,
+    description: "Nano image resolution"
+  },
+  n: {
+    type: "number",
+    description: "Number of images to request. The first returned image is installed on the board."
+  },
   name: stringSchema("Optional display name for the generating node"),
   referenceFileIds: {
     type: "array",
@@ -376,11 +397,103 @@ var createGptImageInputSchema = objectSchema({
     description: "Delay between Mivo result polling attempts"
   }
 }, ["projectRoot", "prompt"]);
-var createGptImageOutputSchema = objectSchema({
+var createKlingVideoInputSchema = objectSchema({
+  projectRoot: stringSchema('Canvas project root absolute path, or "active" for the current canvas'),
+  prompt: stringSchema("Prompt for Kling video generation"),
+  ratio: {
+    type: "string",
+    enum: KLING_VIDEO_RATIOS,
+    description: "Generated video aspect ratio"
+  },
+  duration: {
+    type: "number",
+    description: "Generated video duration in seconds"
+  },
+  mode: {
+    type: "string",
+    enum: KLING_MODES,
+    description: "Kling generation mode"
+  },
+  sound: {
+    type: "string",
+    enum: KLING_SOUNDS,
+    description: "Kling sound toggle"
+  },
+  name: stringSchema("Optional display name for the generating node"),
+  referenceImageFileIds: {
+    type: "array",
+    items: { type: "string" },
+    description: "Optional Mivo image file ids to use as references"
+  },
+  referenceVideoFileIds: {
+    type: "array",
+    items: { type: "string" },
+    description: "Optional Mivo video file ids to use as references"
+  },
+  timeoutMs: {
+    type: "number",
+    description: "Maximum time to wait for the Mivo message result"
+  },
+  pollIntervalMs: {
+    type: "number",
+    description: "Delay between Mivo result polling attempts"
+  }
+}, ["projectRoot", "prompt"]);
+var createSeedanceVideoInputSchema = objectSchema({
+  projectRoot: stringSchema('Canvas project root absolute path, or "active" for the current canvas'),
+  prompt: stringSchema("Prompt for Seedance video generation"),
+  ratio: {
+    type: "string",
+    enum: SEEDANCE_VIDEO_RATIOS,
+    description: "Generated video aspect ratio"
+  },
+  duration: {
+    type: "number",
+    description: "Generated video duration in seconds, from 2 to 15"
+  },
+  resolution: {
+    type: "string",
+    enum: SEEDANCE_RESOLUTIONS,
+    description: "Seedance video resolution"
+  },
+  audio: {
+    type: "boolean",
+    description: "Whether to generate audio"
+  },
+  name: stringSchema("Optional display name for the generating node"),
+  referenceImageFileIds: {
+    type: "array",
+    items: { type: "string" },
+    description: "Optional Mivo image file ids to use as references"
+  },
+  referenceVideoFileIds: {
+    type: "array",
+    items: { type: "string" },
+    description: "Optional Mivo video file ids to use as references"
+  },
+  referenceAudioFileIds: {
+    type: "array",
+    items: { type: "string" },
+    description: "Optional Mivo audio file ids to use as references"
+  },
+  timeoutMs: {
+    type: "number",
+    description: "Maximum time to wait for the Mivo message result"
+  },
+  pollIntervalMs: {
+    type: "number",
+    description: "Delay between Mivo result polling attempts"
+  }
+}, ["projectRoot", "prompt"]);
+var createMediaOutputSchema = objectSchema({
   nodeId: { type: "string" },
   messageId: { type: "string" },
+  mediaPath: { type: "string" },
+  mediaUrl: { type: "string" },
   imagePath: { type: "string" },
   imageUrl: { type: "string" },
+  videoPath: { type: "string" },
+  videoUrl: { type: "string" },
   nodes: {
     type: "array",
     items: anyOutputSchema
@@ -389,8 +502,104 @@ var createGptImageOutputSchema = objectSchema({
     type: "array",
     items: anyOutputSchema
   }
-}, ["nodeId", "messageId", "imagePath", "nodes", "assets"]);
-function buildSubmitPayload(input, chatSessionId) {
+}, ["nodeId", "messageId", "mediaPath", "nodes", "assets"]);
+var createGptImageOutputSchema = createMediaOutputSchema;
+var createNanoImageOutputSchema = createMediaOutputSchema;
+var createVideoOutputSchema = createMediaOutputSchema;
+function createMivoCreateNanoImageTool(deps = {}) {
+  const client = deps.client ?? createMivoApiClient();
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  return {
+    name: "mivo.create_nano_image",
+    description: "Create a generating canvas node, submit a Nano image task to Mivo, poll until the image is ready, then replace the generating node with the downloaded media asset.",
+    kind: "plugin",
+    inputSchema: createNanoImageInputSchema,
+    outputSchema: createNanoImageOutputSchema,
+    async run(input, ctx) {
+      const args = readNanoImageInput(input);
+      return runMivoGeneration(ctx, client, sleep, {
+        projectRoot: args.projectRoot,
+        prompt: args.prompt,
+        name: args.name ?? defaultNodeName("Nano image", args.prompt),
+        toolName: "mivo.create_nano_image",
+        chatType: "freeform",
+        mediaKind: "image",
+        extension: "png",
+        timeoutMs: args.timeoutMs,
+        pollIntervalMs: args.pollIntervalMs,
+        metadata: {
+          ratio: args.ratio,
+          resolution: args.resolution
+        },
+        buildPayload: (chatSessionId) => buildNanoImageSubmitPayload(args, chatSessionId)
+      });
+    }
+  };
+}
+function createMivoCreateKlingVideoTool(deps = {}) {
+  const client = deps.client ?? createMivoApiClient();
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  return {
+    name: "mivo.create_kling_video",
+    description: "Create a generating canvas node, submit a Kling video task to Mivo, poll until the video is ready, then replace the generating node with the downloaded media asset.",
+    kind: "plugin",
+    inputSchema: createKlingVideoInputSchema,
+    outputSchema: createVideoOutputSchema,
+    async run(input, ctx) {
+      const args = readKlingVideoInput(input);
+      return runMivoGeneration(ctx, client, sleep, {
+        projectRoot: args.projectRoot,
+        prompt: args.prompt,
+        name: args.name ?? defaultNodeName("Kling video", args.prompt),
+        toolName: "mivo.create_kling_video",
+        chatType: "video",
+        mediaKind: "video",
+        extension: "mp4",
+        timeoutMs: args.timeoutMs,
+        pollIntervalMs: args.pollIntervalMs,
+        metadata: {
+          ratio: args.ratio,
+          duration: args.duration,
+          mode: args.mode,
+          sound: args.sound
+        },
+        buildPayload: (chatSessionId) => buildKlingVideoSubmitPayload(args, chatSessionId)
+      });
+    }
+  };
+}
+function createMivoCreateSeedanceVideoTool(deps = {}) {
+  const client = deps.client ?? createMivoApiClient();
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  return {
+    name: "mivo.create_seedance_video",
+    description: "Create a generating canvas node, submit a Seedance video task to Mivo, poll until the video is ready, then replace the generating node with the downloaded media asset.",
+    kind: "plugin",
+    inputSchema: createSeedanceVideoInputSchema,
+    outputSchema: createVideoOutputSchema,
+    async run(input, ctx) {
+      const args = readSeedanceVideoInput(input);
+      return runMivoGeneration(ctx, client, sleep, {
+        projectRoot: args.projectRoot,
+        prompt: args.prompt,
+        name: args.name ?? defaultNodeName("Seedance video", args.prompt),
+        toolName: "mivo.create_seedance_video",
+        chatType: "video",
+        mediaKind: "video",
+        extension: "mp4",
+        timeoutMs: args.timeoutMs,
+        pollIntervalMs: args.pollIntervalMs,
+        metadata: {
+          ratio: args.ratio,
+          duration: args.duration,
+          resolution: args.resolution
+        },
+        buildPayload: (chatSessionId) => buildSeedanceVideoSubmitPayload(args, chatSessionId)
+      });
+    }
+  };
+}
+function buildGptImageSubmitPayload(input, chatSessionId) {
   const images = input.referenceFileIds ?? [];
   return {
     chatSessionId,
@@ -410,42 +619,167 @@ function buildSubmitPayload(input, chatSessionId) {
     }
   };
 }
-async function pollForImage(client, messageId, timeoutMs, pollIntervalMs, sleep) {
+function buildNanoImageSubmitPayload(input, chatSessionId) {
+  const images = input.referenceFileIds ?? [];
+  return {
+    chatSessionId,
+    title: "\u4F5C\u56FE",
+    modelType: "NANOBANANA",
+    action: images.length > 0 ? "modal" : "imagine",
+    messageType: "image",
+    modelFormat: {
+      version: "GEMINI_3_PRO_IMAGE_PREVIEW"
+    },
+    payload: {
+      prompt: input.prompt,
+      images,
+      n: input.n,
+      imgRatio: input.ratio,
+      resolution: input.resolution
+    }
+  };
+}
+function buildKlingVideoSubmitPayload(input, chatSessionId) {
+  return {
+    chatSessionId,
+    title: "\u4F5C\u89C6\u9891",
+    modelType: "KLING",
+    action: "generate_video",
+    messageType: "video",
+    modelFormat: {
+      version: "kling-v3-omni"
+    },
+    payload: {
+      prompt: input.prompt,
+      images: input.referenceImageFileIds ?? [],
+      video_clips: input.referenceVideoFileIds ?? [],
+      videoRatio: input.ratio,
+      duration: input.duration,
+      mode: input.mode,
+      multi_shot: false,
+      sound: input.sound
+    }
+  };
+}
+function buildSeedanceVideoSubmitPayload(input, chatSessionId) {
+  return {
+    chatSessionId,
+    title: "\u4F5C\u89C6\u9891",
+    modelType: "ARK",
+    action: "generate_video",
+    messageType: "video",
+    modelFormat: {
+      version: "Seedance_2_0"
+    },
+    payload: {
+      prompt: input.prompt,
+      images: input.referenceImageFileIds ?? [],
+      video_clips: input.referenceVideoFileIds ?? [],
+      audio_clips: input.referenceAudioFileIds ?? [],
+      videoRatio: input.ratio,
+      duration: input.duration,
+      resolution: input.resolution,
+      audio: input.audio
+    }
+  };
+}
+async function runMivoGeneration(ctx, client, sleep, options) {
+  const projectInfo = await ctx.tools.call("canvas.read_project_info", {
+    projectRoot: options.projectRoot
+  });
+  const projectRoot = projectInfo.projectRoot;
+  let nodeId = null;
+  let messageId = null;
+  try {
+    const createResult = await ctx.tools.call("canvas.create_nodes", {
+      projectRoot,
+      nodes: [
+        {
+          kind: "generating",
+          name: options.name,
+          options: {
+            mivo: {
+              status: "generating",
+              provider: "mivo",
+              tool: options.toolName,
+              prompt: options.prompt,
+              ...options.metadata
+            }
+          }
+        }
+      ]
+    });
+    nodeId = readCreatedNodeId(createResult);
+    const chatSessionId = await client.getChatSessionId(options.chatType);
+    messageId = await client.submitMessage(options.buildPayload(chatSessionId));
+    const artifact = await pollForMedia(
+      client,
+      messageId,
+      options.mediaKind,
+      options.timeoutMs,
+      options.pollIntervalMs,
+      sleep
+    );
+    const mediaPath = await materializeArtifact(client, artifact, projectRoot, messageId, options.mediaKind, options.extension);
+    const installResult = await ctx.tools.call("canvas.generating_node_install", {
+      projectRoot,
+      nodeId,
+      path: mediaPath
+    });
+    const mediaUrl = artifact.url ?? (artifact.fileId ? client.fileUrl(artifact.fileId, options.mediaKind) : void 0);
+    return {
+      nodeId,
+      messageId,
+      mediaPath,
+      mediaUrl,
+      ...options.mediaKind === "image" ? { imagePath: mediaPath, imageUrl: mediaUrl } : {},
+      ...options.mediaKind === "video" ? { videoPath: mediaPath, videoUrl: mediaUrl } : {},
+      nodes: installResult.nodes,
+      assets: installResult.assets ?? []
+    };
+  } catch (error) {
+    if (nodeId) {
+      await markNodeFailed(ctx, projectRoot, nodeId, options.name, error, messageId);
+    }
+    throw error;
+  }
+}
+async function pollForMedia(client, messageId, mediaKind, timeoutMs, pollIntervalMs, sleep) {
   const start = Date.now();
   let trySse = true;
   while (Date.now() - start <= timeoutMs) {
     const remainingMs = Math.max(1, timeoutMs - (Date.now() - start));
     const message = trySse ? await readSseOrFallback(client, messageId, remainingMs) : await client.getMessageResult(messageId);
     trySse = false;
-    const artifact = extractImageArtifact(message);
+    const artifact = mediaKind === "image" ? extractImageArtifact(message) : extractVideoArtifact(message);
     if (artifact) {
       return artifact;
     }
     const status = normalizeStatus(message.content?.status ?? message.status);
     const error = message.content?.error ?? message.error;
     if (error || isFailedStatus(status)) {
-      throw new Error(`Mivo GPT image generation failed for ${messageId}: ${error ?? status}`);
+      throw new Error(`Mivo ${mediaKind} generation failed for ${messageId}: ${error ?? status}`);
     }
     if (isCompletedStatus(status)) {
-      throw new Error(`Mivo GPT image generation completed for ${messageId} but returned no image`);
+      throw new Error(`Mivo ${mediaKind} generation completed for ${messageId} but returned no ${mediaKind}`);
     }
     await sleep(pollIntervalMs);
   }
-  throw new Error(`Mivo GPT image generation timed out for ${messageId} after ${timeoutMs}ms`);
+  throw new Error(`Mivo ${mediaKind} generation timed out for ${messageId} after ${timeoutMs}ms`);
 }
-async function materializeArtifact(client, artifact, projectRoot, messageId) {
+async function materializeArtifact(client, artifact, projectRoot, messageId, mediaKind, extension) {
   const outputDir = path2.join(projectRoot, ".canvas-mcp", "mivo");
   await mkdir2(outputDir, { recursive: true });
-  const imagePath = path2.join(outputDir, `${safeFileName(messageId)}.png`);
+  const mediaPath = path2.join(outputDir, `${safeFileName(messageId)}.${extension}`);
   if (artifact.fileId) {
-    await client.downloadFile(artifact.fileId, imagePath);
-    return imagePath;
+    await client.downloadFile(artifact.fileId, mediaPath, mediaKind);
+    return mediaPath;
   }
   if (artifact.url) {
-    await client.downloadUrl(artifact.url, imagePath);
-    return imagePath;
+    await client.downloadUrl(artifact.url, mediaPath);
+    return mediaPath;
   }
-  throw new Error(`Mivo GPT image generation returned an image artifact without file id or URL for ${messageId}`);
+  throw new Error(`Mivo ${mediaKind} generation returned an artifact without file id or URL for ${messageId}`);
 }
 async function readSseOrFallback(client, messageId, timeoutMs) {
   try {
@@ -454,14 +788,14 @@ async function readSseOrFallback(client, messageId, timeoutMs) {
     return client.getMessageResult(messageId);
   }
 }
-async function markNodeFailed(ctx, projectRoot, nodeId, error, messageId) {
+async function markNodeFailed(ctx, projectRoot, nodeId, name, error, messageId) {
   try {
     await ctx.tools.call("canvas.update_nodes", {
       projectRoot,
       updates: [
         {
           id: nodeId,
-          name: "Failed: GPT image",
+          name: `Failed: ${name}`,
           options: {
             mivo: {
               status: "failed",
@@ -491,28 +825,81 @@ function readCreatedNodeId(result) {
   }
   return nodeId;
 }
-function readInput(input) {
+function readGptImageInput(input) {
   const record = asRecord2(input);
   const projectRoot = readString(record, "projectRoot");
   const prompt = readString(record, "prompt");
-  const ratio = readOptionalRatio(record.ratio);
+  const ratio = readOptionalEnum(record.ratio, GPT_IMAGE_RATIOS, "ratio") ?? DEFAULT_RATIO;
   const referenceFileIds = readOptionalStringArray(record.referenceFileIds, "referenceFileIds");
-  const timeoutMs = readOptionalPositiveNumber(record.timeoutMs, "timeoutMs") ?? DEFAULT_TIMEOUT_MS;
-  const pollIntervalMs = readOptionalPositiveNumber(record.pollIntervalMs, "pollIntervalMs") ?? DEFAULT_POLL_INTERVAL_MS;
   return {
     projectRoot,
     prompt,
     ratio,
     name: readOptionalString(record.name, "name"),
     referenceFileIds,
-    timeoutMs,
-    pollIntervalMs
+    ...readTiming(record)
+  };
+}
+function readNanoImageInput(input) {
+  const record = asRecord2(input);
+  const projectRoot = readString(record, "projectRoot");
+  const prompt = readString(record, "prompt");
+  return {
+    projectRoot,
+    prompt,
+    ratio: readOptionalEnum(record.ratio, NANO_IMAGE_RATIOS, "ratio") ?? DEFAULT_RATIO,
+    resolution: readOptionalEnum(record.resolution, IMAGE_RESOLUTIONS, "resolution") ?? "2K",
+    n: readOptionalEnum(record.n, IMAGE_COUNTS, "n") ?? 1,
+    name: readOptionalString(record.name, "name"),
+    referenceFileIds: readOptionalStringArray(record.referenceFileIds, "referenceFileIds"),
+    ...readTiming(record)
   };
 }
-function readOptionalRatio(value) {
-  if (value === void 0) return DEFAULT_RATIO;
-  if (typeof value !== "string" || !RATIOS.includes(value)) {
-    throw new Error(`ratio must be one of ${RATIOS.join(", ")}`);
+function readKlingVideoInput(input) {
+  const record = asRecord2(input);
+  const projectRoot = readString(record, "projectRoot");
+  const prompt = readString(record, "prompt");
+  return {
+    projectRoot,
+    prompt,
+    ratio: readOptionalEnum(record.ratio, KLING_VIDEO_RATIOS, "ratio") ?? "16:9",
+    duration: readOptionalEnum(record.duration, KLING_DURATIONS, "duration") ?? 5,
+    mode: readOptionalEnum(record.mode, KLING_MODES, "mode") ?? "std",
+    sound: readOptionalEnum(record.sound, KLING_SOUNDS, "sound") ?? "on",
+    name: readOptionalString(record.name, "name"),
+    referenceImageFileIds: readOptionalStringArray(record.referenceImageFileIds, "referenceImageFileIds"),
+    referenceVideoFileIds: readOptionalStringArray(record.referenceVideoFileIds, "referenceVideoFileIds"),
+    ...readTiming(record)
+  };
+}
+function readSeedanceVideoInput(input) {
+  const record = asRecord2(input);
+  const projectRoot = readString(record, "projectRoot");
+  const prompt = readString(record, "prompt");
+  return {
+    projectRoot,
+    prompt,
+    ratio: readOptionalEnum(record.ratio, SEEDANCE_VIDEO_RATIOS, "ratio") ?? "16:9",
+    duration: readOptionalIntegerInRange(record.duration, "duration", 2, 15) ?? 5,
+    resolution: readOptionalEnum(record.resolution, SEEDANCE_RESOLUTIONS, "resolution") ?? "720P",
+    audio: readOptionalBoolean(record.audio, "audio") ?? true,
+    name: readOptionalString(record.name, "name"),
+    referenceImageFileIds: readOptionalStringArray(record.referenceImageFileIds, "referenceImageFileIds"),
+    referenceVideoFileIds: readOptionalStringArray(record.referenceVideoFileIds, "referenceVideoFileIds"),
+    referenceAudioFileIds: readOptionalStringArray(record.referenceAudioFileIds, "referenceAudioFileIds"),
+    ...readTiming(record)
+  };
+}
+function readTiming(record) {
+  return {
+    timeoutMs: readOptionalPositiveNumber(record.timeoutMs, "timeoutMs") ?? DEFAULT_TIMEOUT_MS,
+    pollIntervalMs: readOptionalPositiveNumber(record.pollIntervalMs, "pollIntervalMs") ?? DEFAULT_POLL_INTERVAL_MS
+  };
+}
+function readOptionalEnum(value, values, label) {
+  if (value === void 0) return void 0;
+  if (!values.includes(value)) {
+    throw new Error(`${label} must be one of ${values.join(", ")}`);
   }
   return value;
 }
@@ -535,6 +922,20 @@ function readOptionalPositiveNumber(value, label) {
   }
   return value;
 }
+function readOptionalIntegerInRange(value, label, min, max) {
+  if (value === void 0) return void 0;
+  if (!Number.isInteger(value) || value < min || value > max) {
+    throw new Error(`${label} must be an integer from ${min} to ${max}`);
+  }
+  return value;
+}
+function readOptionalBoolean(value, label) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "boolean") {
+    throw new Error(`${label} must be a boolean`);
+  }
+  return value;
+}
 function readOptionalString(value, label) {
   if (value === void 0) return void 0;
   if (typeof value !== "string" || value.trim() === "") {
@@ -549,10 +950,10 @@ function readString(record, key) {
   }
   return value;
 }
-function defaultNodeName(prompt) {
+function defaultNodeName(prefix, prompt) {
   const normalized = prompt.replace(/\s+/g, " ").trim();
   const suffix = normalized.length > 48 ? `${normalized.slice(0, 48)}...` : normalized;
-  return `GPT image: ${suffix}`;
+  return `${prefix}: ${suffix}`;
 }
 function safeFileName(value) {
   return value.replace(/[^a-zA-Z0-9._-]/g, "_") || `mivo-${Date.now()}`;
@@ -579,6 +980,9 @@ function errorMessage(error) {
 }
 export {
   createMivoCreateGptImageTool,
+  createMivoCreateKlingVideoTool,
+  createMivoCreateNanoImageTool,
+  createMivoCreateSeedanceVideoTool,
   mivoPlugin,
   plugin
 };