@felores/kie-cli 0.1.2 → 0.2.0

package/dist/index.js

@@ -624,6 +624,12 @@ var ListTasksSchema = z.object({
   limit: z.number().int().max(100).default(20).describe("Maximum number of tasks to return"),
   status: z.enum(["pending", "processing", "completed", "failed"]).optional().describe("Filter by status")
 });
+var WaitForTaskSchema = z.object({
+  task_id: z.string().min(1).describe("Task ID returned by a generation tool to wait for"),
+  timeout_seconds: z.number().int().min(5).max(600).default(180).describe("Max seconds to wait before giving up"),
+  interval_seconds: z.number().int().min(1).max(60).default(5).describe("Seconds between status checks while waiting"),
+  rendezvous_url: z.string().url().optional().describe("Optional callback rendezvous result base URL (e.g. https://felo-workers.felo.workers.dev/kie/result). Omit to poll the Kie API directly (the default). When set, or when KIE_AI_RESULT_URL / a KIE_AI_CALLBACK_URL ending in /kie/callback is configured, it waits on the rendezvous instead")
+});
 var Veo3Get1080pVideoSchema = z.object({
   task_id: z.string().min(1).describe("Veo3 task ID to get 1080p video for"),
   index: z.number().int().min(0).optional().describe("Video index (optional, for multiple video results)")
@@ -3433,6 +3439,170 @@ var veo3Get1080pVideoTool = {
   }
 };
 
+// ../core/dist/tools/wait_for_task.js
+function resolveResultBase(explicit, ctx) {
+  const strip = (u) => u.replace(/\/+$/, "");
+  if (explicit)
+    return strip(explicit);
+  if (process.env.KIE_AI_RESULT_URL)
+    return strip(process.env.KIE_AI_RESULT_URL);
+  const callback = ctx.getCallbackUrl();
+  if (callback.endsWith("/kie/callback")) {
+    return callback.slice(0, -"/kie/callback".length) + "/kie/result";
+  }
+  return null;
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function pollOnce(ctx, task_id) {
+  try {
+    const res = await getTaskStatusTool.run({ task_id }, ctx);
+    return JSON.parse(res.content[0].text);
+  } catch {
+    return null;
+  }
+}
+var waitForTaskTool = {
+  name: "wait_for_task",
+  description: "Wait for a generation task to complete in a single call, so you don't have to poll get_task_status repeatedly. Pass the task_id returned by any generation tool: it blocks until the result is ready (or the timeout) and returns the final URLs, streaming progress meanwhile. By default it polls the Kie API directly (no setup); if a callback rendezvous is configured (KIE_AI_RESULT_URL, rendezvous_url, or a KIE_AI_CALLBACK_URL ending in /kie/callback) it waits on that instead. Tip for long jobs: clients should enable resetTimeoutOnProgress with a generous maxTotalTimeout.",
+  category: "utility",
+  schema: WaitForTaskSchema,
+  async run(args, ctx) {
+    try {
+      const { task_id, timeout_seconds = 180, interval_seconds = 5, rendezvous_url } = WaitForTaskSchema.parse(args);
+      const base = resolveResultBase(rendezvous_url, ctx);
+      const start = Date.now();
+      const deadline = start + timeout_seconds * 1e3;
+      const totalTicks = Math.max(1, Math.ceil(timeout_seconds / interval_seconds));
+      let tick = 0;
+      const elapsed = () => Math.round((Date.now() - start) / 1e3);
+      if (base) {
+        const url = `${base}/${encodeURIComponent(task_id)}`;
+        while (Date.now() < deadline) {
+          tick++;
+          try {
+            const res = await fetch(url);
+            if (res.status === 200) {
+              const data = await res.json();
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: JSON.stringify({
+                      success: true,
+                      task_id,
+                      status: data.status ?? "completed",
+                      elapsed_seconds: elapsed(),
+                      result_urls: data.urls ?? [],
+                      model: data.model ?? null,
+                      message: "Result received from rendezvous"
+                    }, null, 2)
+                  }
+                ]
+              };
+            }
+          } catch {
+          }
+          await ctx.onProgress?.({
+            progress: tick,
+            total: totalTicks,
+            message: `Waiting on rendezvous\u2026 ${elapsed()}s elapsed`
+          });
+          await sleep(interval_seconds * 1e3);
+        }
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                task_id,
+                status: "timed_out",
+                error: "timeout",
+                elapsed_seconds: elapsed(),
+                message: `No result after ${timeout_seconds}s. The task may still be running; retry wait_for_task or check get_task_status.`
+              }, null, 2)
+            }
+          ]
+        };
+      }
+      while (Date.now() < deadline) {
+        tick++;
+        const details = await pollOnce(ctx, task_id);
+        const task = await ctx.db.getTask(task_id);
+        if (task?.status === "completed") {
+          const fromDetails = details?.result_urls;
+          const result_urls = fromDetails && fromDetails.length > 0 ? fromDetails : task.result_url ? [task.result_url] : [];
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: true,
+                  task_id,
+                  status: "completed",
+                  elapsed_seconds: elapsed(),
+                  result_urls,
+                  details,
+                  message: "Generation completed"
+                }, null, 2)
+              }
+            ]
+          };
+        }
+        if (task?.status === "failed") {
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: false,
+                  task_id,
+                  status: "failed",
+                  elapsed_seconds: elapsed(),
+                  error: task.error_message ?? "Generation failed",
+                  details,
+                  message: "Generation failed"
+                }, null, 2)
+              }
+            ]
+          };
+        }
+        await ctx.onProgress?.({
+          progress: tick,
+          total: totalTicks,
+          message: `Generating\u2026 ${elapsed()}s elapsed (status: ${task?.status ?? "pending"})`
+        });
+        await sleep(interval_seconds * 1e3);
+      }
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              success: false,
+              task_id,
+              status: "timed_out",
+              error: "timeout",
+              elapsed_seconds: elapsed(),
+              message: `Still running after ${timeout_seconds}s. Call wait_for_task again with the same task_id, or check get_task_status.`
+            }, null, 2)
+          }
+        ]
+      };
+    } catch (error) {
+      return ctx.formatError("wait_for_task", error, {
+        task_id: "Required: task ID returned by a generation tool",
+        timeout_seconds: "Optional: max seconds to wait (5-600, default: 180)",
+        interval_seconds: "Optional: seconds between status checks (1-60, default: 5)",
+        rendezvous_url: "Optional: rendezvous result base URL (e.g. https://host/kie/result); omit to poll the Kie API directly"
+      });
+    }
+  }
+};
+
 // ../core/dist/tools/wan_animate.js
 import { z as z21 } from "zod";
 var wanAnimateTool = {
@@ -3651,6 +3821,7 @@ var TOOL_REGISTRY = [
   topazUpscaleImageTool,
   veo3GenerateVideoTool,
   veo3Get1080pVideoTool,
+  waitForTaskTool,
   wanAnimateTool,
   wanVideoTool,
   zImageTool

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@felores/kie-cli",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Standalone CLI for Kie.ai APIs: generate images, video, music and speech from the terminal. Same models as the Kie.ai MCP server, no MCP client required.",
   "main": "dist/index.js",
   "bin": {