agnes-ai-cli 0.1.2 → 0.1.3

package/README.md

@@ -29,10 +29,11 @@ agnes video text2video --prompt "a cinematic drone shot of waves at dusk"
 agnes video img2video --image ./frame.png --prompt "animate subtle rain and drifting fog"
 agnes video multivideo --image ./frame-a.png --image ./frame-b.png --prompt "blend these references into one motion concept"
 agnes video keyframes --image ./frame-a.png --image ./frame-b.png --prompt "morph between the two scenes"
-agnes video poll <task-id>
+agnes video poll <video-or-task-id>
 ```
 
 Local media inputs are uploaded to a temporary public URL automatically. The default bridge tries x0.at first, then falls back to tmpfiles, Uguu, and Litterbox.
+Video creation is asynchronous. Create commands print both `taskId` and `videoId` when Agnes returns them; use `videoId` with `agnes video poll`. Passing an older `taskId` still works through the legacy polling endpoint.
 
 ## JS API
 

package/dist/cli.js

@@ -224,9 +224,9 @@ Examples:
   agnes video text2video --prompt "A cinematic beach scene at sunset"
   agnes video img2video --image ./frame.png --prompt "Add gentle wind and a soft push-in"
   agnes video keyframes --image ./a.png --image ./b.png --prompt "Transition between the frames"
-  agnes video poll task_123
+  agnes video poll video_123
 
-Use this group for Agnes video task creation and polling. Video creation is asynchronous; poll returns the final result.
+Use this group for Agnes video task creation and polling. Video creation is asynchronous; poll uses the recommended video_id endpoint and keeps task_id inputs compatible with the legacy endpoint.
 `);
     buildVideoGenerateCommand(video, "text2video", "Generate a video from text", async (client, options) => client.video.generate({
         mode: "text2video",
@@ -277,19 +277,19 @@ Use this group for Agnes video task creation and polling. Video creation is asyn
     video
         .command("poll")
         .description("Poll an Agnes video task until it finishes")
-        .argument("<task-id>", "Task id returned by Agnes video creation")
-        .option("--interval <seconds>", "Polling interval seconds", parseInteger, 3)
+        .argument("<video-or-task-id>", "Video id returned by Agnes video creation; task ids are accepted for legacy compatibility")
+        .option("--interval <seconds>", "Polling interval seconds", parseInteger, 5)
         .option("--timeout <seconds>", "Polling timeout seconds", parseInteger, 600)
         .option("--json", "Output JSON")
         .addHelpText("after", `
 Example:
-  agnes video poll task_123 --interval 3 --timeout 600
+  agnes video poll video_123 --interval 5 --timeout 600
 
 Request shape:
-  Polls Agnes /videos/{task_id} until the task completes, fails, or times out. Use this after any asynchronous video creation command.
+  Polls Agnes /agnesapi?video_id={video_id} until the task completes, fails, or times out. If you pass a task_ id, poll uses the legacy /videos/{task_id} endpoint for compatibility. Use this after any asynchronous video creation command.
 `)
-        .action(async (taskId, options) => {
-        const result = await client.video.poll(taskId, {
+        .action(async (id, options) => {
+        const result = await client.video.poll(id, {
             intervalSeconds: options.interval,
             timeoutSeconds: options.timeout,
         });
@@ -344,6 +344,7 @@ function buildVideoGenerateCommand(video, name, description, fn, imageMode = fal
         const task = result;
         printLines([
             `taskId: ${task.taskId}`,
+            task.videoId ? `videoId: ${task.videoId}` : undefined,
             `status: ${task.status}`,
         ]);
     });

package/dist/config.d.ts

@@ -46,6 +46,7 @@ export type AgnesStatus = "queued" | "in_progress" | "completed" | "failed" | "t
 export interface NormalizedVideoTask {
     ok: true;
     taskId: string;
+    videoId?: string;
     status: AgnesStatus;
     rawStatus?: string;
     model: string;
@@ -54,6 +55,7 @@ export interface NormalizedVideoTask {
 export interface NormalizedVideoResult {
     ok: true;
     taskId: string;
+    videoId?: string;
     status: AgnesStatus;
     rawStatus?: string;
     model: string;

package/dist/index.d.ts

@@ -29,6 +29,6 @@ export declare function createAgnesClient(config?: AgnesClientConfig): {
     };
     video: {
         generate: (options: import("./video/normalizeVideoRequest.js").VideoGenerateOptions) => Promise<import("./config.js").NormalizedVideoTask>;
-        poll: (taskId: string, options?: import("./video/pollVideo.js").PollVideoOptions) => Promise<import("./config.js").NormalizedVideoResult>;
+        poll: (id: string, options?: import("./video/pollVideo.js").PollVideoOptions) => Promise<import("./config.js").NormalizedVideoResult>;
     };
 };

package/dist/index.js

@@ -24,7 +24,7 @@ export function createAgnesClient(config = {}) {
         },
         video: {
             generate: (options) => generateVideo(options, config),
-            poll: (taskId, options) => pollVideo(taskId, options, config),
+            poll: (id, options) => pollVideo(id, options, config),
         },
     };
 }

package/dist/video/generateVideo.d.ts

@@ -3,4 +3,5 @@ import { type VideoGenerateOptions } from "./normalizeVideoRequest.js";
 export declare function generateVideo(options: VideoGenerateOptions, config?: AgnesClientConfig): Promise<NormalizedVideoTask>;
 export declare function normalizeVideoTask(raw: unknown): NormalizedVideoTask;
 export declare function extractTaskId(record: Record<string, unknown>): string;
+export declare function extractVideoId(record: Record<string, unknown>): string | undefined;
 export declare function normalizeStatus(rawStatus: string): "queued" | "in_progress" | "completed" | "failed";

package/dist/video/generateVideo.js

@@ -42,10 +42,12 @@ async function resolveMediaInputs(inputs, ttl, config) {
 export function normalizeVideoTask(raw) {
     const record = ensureRecord(raw);
     const taskId = extractTaskId(record);
+    const videoId = extractVideoId(record);
     const rawStatus = typeof record.status === "string" ? record.status : "queued";
     return {
         ok: true,
         taskId,
+        videoId,
         status: normalizeStatus(rawStatus),
         rawStatus,
         model: typeof record.model === "string" ? record.model : "agnes-video-v2.0",
@@ -69,6 +71,13 @@ export function extractTaskId(record) {
     }
     return taskId;
 }
+export function extractVideoId(record) {
+    if (typeof record.video_id === "string")
+        return record.video_id;
+    if (typeof record.id === "string" && record.id.startsWith("video_"))
+        return record.id;
+    return undefined;
+}
 export function normalizeStatus(rawStatus) {
     if (rawStatus === "queued" || rawStatus === "in_progress" || rawStatus === "completed" || rawStatus === "failed") {
         return rawStatus;

package/dist/video/pollVideo.d.ts

@@ -3,5 +3,5 @@ export interface PollVideoOptions {
     intervalSeconds?: number;
     timeoutSeconds?: number;
 }
-export declare function pollVideo(taskId: string, options?: PollVideoOptions, config?: AgnesClientConfig): Promise<NormalizedVideoResult>;
+export declare function pollVideo(id: string, options?: PollVideoOptions, config?: AgnesClientConfig): Promise<NormalizedVideoResult>;
 export declare function normalizeVideoResult(raw: unknown): NormalizedVideoResult;

package/dist/video/pollVideo.js

@@ -1,20 +1,20 @@
 import { resolveConfig } from "../config.js";
 import { AgnesCliError } from "../errors.js";
 import { requestJson } from "../http/requestJson.js";
-import { extractTaskId, normalizeStatus } from "./generateVideo.js";
-export async function pollVideo(taskId, options = {}, config = {}) {
+import { extractTaskId, extractVideoId, normalizeStatus } from "./generateVideo.js";
+export async function pollVideo(id, options = {}, config = {}) {
     const resolved = resolveConfig(config);
     if (!resolved.apiKey) {
         throw new AgnesCliError("AUTH_MISSING", "AGNES_API_KEY is required for Agnes requests.");
     }
-    const intervalMs = (options.intervalSeconds ?? 3) * 1000;
+    const intervalMs = (options.intervalSeconds ?? 5) * 1000;
     const timeoutMs = (options.timeoutSeconds ?? 600) * 1000;
     const started = Date.now();
     while (true) {
         if (Date.now() - started > timeoutMs) {
-            throw new AgnesCliError("POLL_TIMEOUT", "Agnes video polling timed out.", { taskId, status: "timed_out" });
+            throw new AgnesCliError("POLL_TIMEOUT", "Agnes video polling timed out.", { id, status: "timed_out" });
         }
-        const { response, raw } = await requestJson(resolved.fetchImpl, `${resolved.baseUrl}/videos/${taskId}`, {
+        const { response, raw } = await requestJson(resolved.fetchImpl, buildVideoPollUrl(resolved.baseUrl, id), {
             headers: {
                 Authorization: `Bearer ${resolved.apiKey}`,
             },
@@ -22,13 +22,13 @@ export async function pollVideo(taskId, options = {}, config = {}) {
             networkMessage: "Agnes video poll request failed before a response was received.",
         });
         if (response.status === 404) {
-            throw new AgnesCliError("TASK_NOT_FOUND", "Agnes video task was not found.", { taskId, status: "failed", raw });
+            throw new AgnesCliError("TASK_NOT_FOUND", "Agnes video task was not found.", { id, status: "failed", raw });
         }
         if (response.status === 503) {
-            throw new AgnesCliError("SERVICE_BUSY", "Agnes video service is busy.", { taskId, status: "queued", raw });
+            throw new AgnesCliError("SERVICE_BUSY", "Agnes video service is busy.", { id, status: "queued", raw });
         }
         if (!response.ok) {
-            throw new AgnesCliError("AGNES_REQUEST_FAILED", `Agnes video poll failed with HTTP ${response.status}.`, { taskId, status: "failed", raw });
+            throw new AgnesCliError("AGNES_REQUEST_FAILED", `Agnes video poll failed with HTTP ${response.status}.`, { id, status: "failed", raw });
         }
         const result = normalizeVideoResult(raw);
         if (result.status === "completed")
@@ -45,6 +45,7 @@ export function normalizeVideoResult(raw) {
     }
     const record = raw;
     const taskId = extractTaskId(record);
+    const videoId = extractVideoId(record);
     const rawStatus = typeof record.status === "string" ? record.status : "queued";
     const status = normalizeStatus(rawStatus);
     const videoUrl = extractVideoUrl(record);
@@ -54,6 +55,7 @@ export function normalizeVideoResult(raw) {
     return {
         ok: true,
         taskId,
+        videoId,
         status: status,
         rawStatus,
         model: typeof record.model === "string" ? record.model : "agnes-video-v2.0",
@@ -63,6 +65,14 @@ export function normalizeVideoResult(raw) {
         raw,
     };
 }
+function buildVideoPollUrl(baseUrl, id) {
+    if (id.startsWith("task_")) {
+        return `${baseUrl.replace(/\/$/, "")}/videos/${encodeURIComponent(id)}`;
+    }
+    const url = new URL("/agnesapi", new URL(baseUrl));
+    url.searchParams.set("video_id", id);
+    return url.toString();
+}
 function extractVideoUrl(record) {
     const candidates = [
         record.video_url,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agnes-ai-cli",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "CLI and JS API for Agnes text, image, and video workflows.",
   "type": "module",
   "bin": {