agnes-ai-cli 0.1.0

package/dist/video/normalizeVideoRequest.d.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { type Ttl } from "../config.js";
+export declare const videoGenerateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    prompt: z.ZodString;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    numFrames: z.ZodOptional<z.ZodNumber>;
+    frameRate: z.ZodOptional<z.ZodNumber>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    negativePrompt: z.ZodOptional<z.ZodString>;
+    mode: z.ZodLiteral<"text2video">;
+}, z.core.$strip>, z.ZodObject<{
+    prompt: z.ZodString;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    numFrames: z.ZodOptional<z.ZodNumber>;
+    frameRate: z.ZodOptional<z.ZodNumber>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    negativePrompt: z.ZodOptional<z.ZodString>;
+    mode: z.ZodLiteral<"img2video">;
+    image: z.ZodString;
+    ttl: z.ZodOptional<z.ZodEnum<{
+        "1h": "1h";
+        "12h": "12h";
+        "24h": "24h";
+        "72h": "72h";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    prompt: z.ZodString;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    numFrames: z.ZodOptional<z.ZodNumber>;
+    frameRate: z.ZodOptional<z.ZodNumber>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    negativePrompt: z.ZodOptional<z.ZodString>;
+    mode: z.ZodLiteral<"multivideo">;
+    images: z.ZodArray<z.ZodString>;
+    ttl: z.ZodOptional<z.ZodEnum<{
+        "1h": "1h";
+        "12h": "12h";
+        "24h": "24h";
+        "72h": "72h";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    prompt: z.ZodString;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    numFrames: z.ZodOptional<z.ZodNumber>;
+    frameRate: z.ZodOptional<z.ZodNumber>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    negativePrompt: z.ZodOptional<z.ZodString>;
+    mode: z.ZodLiteral<"keyframes">;
+    images: z.ZodArray<z.ZodString>;
+    ttl: z.ZodOptional<z.ZodEnum<{
+        "1h": "1h";
+        "12h": "12h";
+        "24h": "24h";
+        "72h": "72h";
+    }>>;
+}, z.core.$strip>], "mode">;
+export type VideoGenerateOptions = z.infer<typeof videoGenerateSchema>;
+export declare function collectVideoInputs(options: VideoGenerateOptions): {
+    inputs: string[];
+    ttl?: Ttl;
+};
+export declare function normalizeVideoRequest(options: VideoGenerateOptions, resolvedImages: string[]): Record<string, unknown>;
+export declare function validateVideoSettings({ numFrames, frameRate, mode, imageCount, }: {
+    numFrames: number;
+    frameRate: number;
+    mode: VideoGenerateOptions["mode"];
+    imageCount: number;
+}): void;

package/dist/video/normalizeVideoRequest.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { DEFAULT_VIDEO_DIMENSIONS, DEFAULT_VIDEO_TEMPORAL } from "../config.js";
+import { AgnesCliError } from "../errors.js";
+const shared = {
+    prompt: z.string().min(1),
+    width: z.number().int().positive().optional(),
+    height: z.number().int().positive().optional(),
+    numFrames: z.number().int().positive().optional(),
+    frameRate: z.number().int().positive().optional(),
+    seed: z.number().int().optional(),
+    negativePrompt: z.string().min(1).optional(),
+};
+export const videoGenerateSchema = z.discriminatedUnion("mode", [
+    z.object({ mode: z.literal("text2video"), ...shared }),
+    z.object({ mode: z.literal("img2video"), image: z.string().min(1), ttl: z.enum(["1h", "12h", "24h", "72h"]).optional(), ...shared }),
+    z.object({ mode: z.literal("multivideo"), images: z.array(z.string().min(1)).min(2), ttl: z.enum(["1h", "12h", "24h", "72h"]).optional(), ...shared }),
+    z.object({ mode: z.literal("keyframes"), images: z.array(z.string().min(1)).min(2), ttl: z.enum(["1h", "12h", "24h", "72h"]).optional(), ...shared }),
+]);
+export function collectVideoInputs(options) {
+    switch (options.mode) {
+        case "text2video":
+            return { inputs: [] };
+        case "img2video":
+            return { inputs: [options.image], ttl: options.ttl };
+        case "multivideo":
+        case "keyframes":
+            return { inputs: options.images, ttl: options.ttl };
+        default:
+            throw new AgnesCliError("INVALID_VIDEO_MODE", "Unsupported video generation mode.");
+    }
+}
+export function normalizeVideoRequest(options, resolvedImages) {
+    const width = options.width ?? DEFAULT_VIDEO_DIMENSIONS.width;
+    const height = options.height ?? DEFAULT_VIDEO_DIMENSIONS.height;
+    const numFrames = options.numFrames ?? DEFAULT_VIDEO_TEMPORAL.numFrames;
+    const frameRate = options.frameRate ?? DEFAULT_VIDEO_TEMPORAL.frameRate;
+    validateVideoSettings({ numFrames, frameRate, mode: options.mode, imageCount: resolvedImages.length });
+    const payload = {
+        model: "agnes-video-v2.0",
+        prompt: options.prompt,
+        width,
+        height,
+        num_frames: numFrames,
+        frame_rate: frameRate,
+    };
+    if (options.seed !== undefined)
+        payload.seed = options.seed;
+    if (options.negativePrompt)
+        payload.negative_prompt = options.negativePrompt;
+    switch (options.mode) {
+        case "text2video":
+            break;
+        case "img2video":
+            payload.image = resolvedImages[0];
+            break;
+        case "multivideo":
+            payload.extra_body = { image: resolvedImages };
+            break;
+        case "keyframes":
+            payload.extra_body = { image: resolvedImages, mode: "keyframes" };
+            break;
+        default:
+            throw new AgnesCliError("INVALID_VIDEO_MODE", "Unsupported video generation mode.");
+    }
+    return payload;
+}
+export function validateVideoSettings({ numFrames, frameRate, mode, imageCount, }) {
+    if (numFrames > 441) {
+        throw new AgnesCliError("INVALID_VIDEO_SETTINGS", "numFrames must be <= 441.");
+    }
+    if ((numFrames - 1) % 8 !== 0) {
+        throw new AgnesCliError("INVALID_VIDEO_SETTINGS", "numFrames must satisfy 8n + 1.");
+    }
+    if (frameRate < 1 || frameRate > 60) {
+        throw new AgnesCliError("INVALID_VIDEO_SETTINGS", "frameRate must be between 1 and 60.");
+    }
+    if (mode === "img2video" && imageCount !== 1) {
+        throw new AgnesCliError("INVALID_VIDEO_SETTINGS", "img2video requires exactly one image.");
+    }
+    if ((mode === "multivideo" || mode === "keyframes") && imageCount < 2) {
+        throw new AgnesCliError("INVALID_VIDEO_SETTINGS", `${mode} requires at least two images.`);
+    }
+}

package/dist/video/pollVideo.d.ts

@@ -0,0 +1,7 @@
+import type { AgnesClientConfig, NormalizedVideoResult } from "../config.js";
+export interface PollVideoOptions {
+    intervalSeconds?: number;
+    timeoutSeconds?: number;
+}
+export declare function pollVideo(taskId: string, options?: PollVideoOptions, config?: AgnesClientConfig): Promise<NormalizedVideoResult>;
+export declare function normalizeVideoResult(raw: unknown): NormalizedVideoResult;

package/dist/video/pollVideo.js

@@ -0,0 +1,83 @@
+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 = {}) {
+    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 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" });
+        }
+        const { response, raw } = await requestJson(resolved.fetchImpl, `${resolved.baseUrl}/videos/${taskId}`, {
+            headers: {
+                Authorization: `Bearer ${resolved.apiKey}`,
+            },
+        }, {
+            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 });
+        }
+        if (response.status === 503) {
+            throw new AgnesCliError("SERVICE_BUSY", "Agnes video service is busy.", { taskId, status: "queued", raw });
+        }
+        if (!response.ok) {
+            throw new AgnesCliError("AGNES_REQUEST_FAILED", `Agnes video poll failed with HTTP ${response.status}.`, { taskId, status: "failed", raw });
+        }
+        const result = normalizeVideoResult(raw);
+        if (result.status === "completed")
+            return result;
+        if (result.status === "failed") {
+            throw new AgnesCliError("TASK_FAILED", "Agnes video task failed.", result);
+        }
+        await sleep(intervalMs);
+    }
+}
+export function normalizeVideoResult(raw) {
+    if (!raw || typeof raw !== "object") {
+        throw new AgnesCliError("INVALID_RESPONSE", "Agnes video poll response was not an object.", raw);
+    }
+    const record = raw;
+    const taskId = extractTaskId(record);
+    const rawStatus = typeof record.status === "string" ? record.status : "queued";
+    const status = normalizeStatus(rawStatus);
+    const videoUrl = extractVideoUrl(record);
+    if (status === "completed" && !videoUrl) {
+        throw new AgnesCliError("VIDEO_URL_MISSING", "Completed Agnes video task did not include a video URL.", raw);
+    }
+    return {
+        ok: true,
+        taskId,
+        status: status,
+        rawStatus,
+        model: typeof record.model === "string" ? record.model : "agnes-video-v2.0",
+        videoUrl: videoUrl ?? "",
+        seconds: typeof record.seconds === "number" ? record.seconds : undefined,
+        size: typeof record.size === "string" ? record.size : undefined,
+        raw,
+    };
+}
+function extractVideoUrl(record) {
+    const candidates = [
+        record.video_url,
+        record.url,
+        record.output_url,
+        record.remixed_from_video_id,
+        typeof record.result === "object" && record.result ? record.result.video_url : undefined,
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === "string" && /^https?:\/\//.test(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "agnes-ai-cli",
+  "version": "0.1.0",
+  "description": "CLI and JS API for Agnes text, image, and video workflows.",
+  "type": "module",
+  "bin": {
+    "agnes": "bin/agnes.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "bin",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepare": "npm run build",
+    "test": "npm run build && node --test",
+    "lint": "npm run build",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": [
+    "agnes",
+    "ai",
+    "cli",
+    "image-generation",
+    "video-generation"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^15.0.0",
+    "zod": "^4.1.12"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "typescript": "^5.9.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jomeswang/agnes-ai-cli.git"
+  },
+  "homepage": "https://github.com/jomeswang/agnes-ai-cli#readme",
+  "bugs": {
+    "url": "https://github.com/jomeswang/agnes-ai-cli/issues"
+  },
+  "author": "jomeswang"
+}