agnes-ai-cli 0.1.1 → 0.1.3

package/README.md

@@ -29,9 +29,12 @@ 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
 
 ```js

package/dist/cli.js

@@ -72,7 +72,7 @@ Use this group when Agnes requires a public image URL and your source asset is a
         .command("url")
         .description("Return a public URL for a local file or pass through an existing URL")
         .argument("<file-or-url>", "Local file path or http(s) URL")
-        .option("--ttl <ttl>", "Litterbox TTL (1h, 12h, 24h, 72h)", "1h")
+        .option("--ttl <ttl>", "Temporary upload TTL (1h, 12h, 24h, 72h)", "1h")
         .option("--json", "Output JSON")
         .action(async (input, options) => {
         const result = await client.media.toPublicUrl(input, { ttl: ttlSchema.parse(options.ttl) });
@@ -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

@@ -40,12 +40,13 @@ export interface AuthCheckResult {
 export interface PublicUrlResult {
     ok: true;
     url: string;
-    source: "passthrough" | "litterbox" | "provider";
+    source: "passthrough" | "litterbox" | "temporary" | "provider";
 }
 export type AgnesStatus = "queued" | "in_progress" | "completed" | "failed" | "timed_out";
 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

@@ -2,6 +2,7 @@ import type { AgnesClientConfig } from "./config.js";
 export { checkAuth } from "./auth/check.js";
 export { toPublicUrl } from "./media/toPublicUrl.js";
 export { LitterboxMediaUrlProvider } from "./media/litterbox.js";
+export { TemporaryMediaUrlProvider, TmpfilesMediaUrlProvider, UguuMediaUrlProvider, X0MediaUrlProvider } from "./media/temporary-upload.js";
 export type { AgnesClientConfig, AuthCheckResult, PublicUrlResult, ImageGenerationResult, NormalizedVideoTask, NormalizedVideoResult, Ttl, } from "./config.js";
 export type { ImageGenerateOptions } from "./image/normalizeImageRequest.js";
 export type { TextCompleteOptions, TextCompletionResult } from "./text/complete.js";
@@ -28,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

@@ -7,6 +7,7 @@ import { pollVideo } from "./video/pollVideo.js";
 export { checkAuth } from "./auth/check.js";
 export { toPublicUrl } from "./media/toPublicUrl.js";
 export { LitterboxMediaUrlProvider } from "./media/litterbox.js";
+export { TemporaryMediaUrlProvider, TmpfilesMediaUrlProvider, UguuMediaUrlProvider, X0MediaUrlProvider } from "./media/temporary-upload.js";
 export function createAgnesClient(config = {}) {
     return {
         auth: {
@@ -23,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/media/litterbox.d.ts

@@ -1,9 +1,15 @@
 import type { FetchLike, Ttl } from "../config.js";
+type LitterboxMediaUrlProviderOptions = {
+    maxAttempts?: number;
+    retryDelayMs?: number;
+};
 export declare class LitterboxMediaUrlProvider {
     private readonly fetchImpl;
-    constructor(fetchImpl?: FetchLike);
+    private readonly options;
+    constructor(fetchImpl?: FetchLike, options?: LitterboxMediaUrlProviderOptions);
     upload(localPath: string, options?: {
         ttl?: Ttl;
     }): Promise<string>;
     private postFormWithRetry;
 }
+export {};

package/dist/media/litterbox.js

@@ -14,8 +14,10 @@ const MIME_TYPES = {
 };
 export class LitterboxMediaUrlProvider {
     fetchImpl;
-    constructor(fetchImpl = fetch) {
+    options;
+    constructor(fetchImpl = fetch, options = {}) {
         this.fetchImpl = fetchImpl;
+        this.options = options;
     }
     async upload(localPath, options = {}) {
         const ttl = options.ttl ?? "1h";
@@ -40,7 +42,9 @@ export class LitterboxMediaUrlProvider {
     }
     async postFormWithRetry(form) {
         let lastError;
-        for (let attempt = 0; attempt <= 2; attempt += 1) {
+        const maxAttempts = this.options.maxAttempts ?? 3;
+        const retryDelayMs = this.options.retryDelayMs ?? 500;
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
             try {
                 const response = await this.fetchImpl(LITTERBOX_ENDPOINT, {
                     method: "POST",
@@ -51,12 +55,12 @@ export class LitterboxMediaUrlProvider {
             }
             catch (error) {
                 lastError = error;
-                if (attempt === 2) {
+                if (attempt === maxAttempts) {
                     throw new AgnesCliError("UPLOAD_FAILED", "Litterbox upload failed before a response was received.", {
                         cause: error instanceof Error ? error.message : String(error),
                     });
                 }
-                await sleep(500);
+                await sleep(retryDelayMs);
             }
         }
         throw new AgnesCliError("UPLOAD_FAILED", "Litterbox upload failed before a response was received.", {

package/dist/media/temporary-upload.d.ts

@@ -0,0 +1,25 @@
+import type { FetchLike, MediaUrlProvider, Ttl } from "../config.js";
+export declare class TemporaryMediaUrlProvider implements MediaUrlProvider {
+    private readonly providers;
+    constructor(fetchImpl?: FetchLike);
+    upload(localPath: string, options?: {
+        ttl?: Ttl;
+    }): Promise<string>;
+}
+export declare class X0MediaUrlProvider implements MediaUrlProvider {
+    private readonly fetchImpl;
+    constructor(fetchImpl?: FetchLike);
+    upload(localPath: string): Promise<string>;
+}
+export declare class UguuMediaUrlProvider implements MediaUrlProvider {
+    private readonly fetchImpl;
+    constructor(fetchImpl?: FetchLike);
+    upload(localPath: string): Promise<string>;
+}
+export declare class TmpfilesMediaUrlProvider implements MediaUrlProvider {
+    private readonly fetchImpl;
+    constructor(fetchImpl?: FetchLike);
+    upload(localPath: string, options?: {
+        ttl?: Ttl;
+    }): Promise<string>;
+}

package/dist/media/temporary-upload.js

@@ -0,0 +1,176 @@
+import { promises as fs } from "node:fs";
+import { basename, extname } from "node:path";
+import { AgnesCliError } from "../errors.js";
+import { LitterboxMediaUrlProvider } from "./litterbox.js";
+const X0_ENDPOINT = "https://x0.at/";
+const UGUU_ENDPOINT = "https://uguu.se/upload";
+const TMPFILES_ENDPOINT = "https://tmpfiles.org/api/v1/upload";
+const MIME_TYPES = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+    ".webm": "video/webm",
+};
+const TTL_SECONDS = {
+    "1h": "3600",
+    "12h": "43200",
+    "24h": "86400",
+    "72h": "259200",
+};
+export class TemporaryMediaUrlProvider {
+    providers;
+    constructor(fetchImpl = fetch) {
+        this.providers = [
+            { name: "x0.at", provider: new X0MediaUrlProvider(fetchImpl) },
+            { name: "tmpfiles", provider: new TmpfilesMediaUrlProvider(fetchImpl) },
+            { name: "Uguu", provider: new UguuMediaUrlProvider(fetchImpl) },
+            { name: "Litterbox", provider: new LitterboxMediaUrlProvider(fetchImpl, { maxAttempts: 1 }) },
+        ];
+    }
+    async upload(localPath, options = {}) {
+        const failures = [];
+        for (const { name, provider } of this.providers) {
+            try {
+                return await provider.upload(localPath, options);
+            }
+            catch (error) {
+                failures.push(`${name}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        throw new AgnesCliError("UPLOAD_FAILED", "Temporary upload failed after trying x0.at, tmpfiles, Uguu, and Litterbox.", {
+            failures,
+        });
+    }
+}
+export class X0MediaUrlProvider {
+    fetchImpl;
+    constructor(fetchImpl = fetch) {
+        this.fetchImpl = fetchImpl;
+    }
+    async upload(localPath) {
+        const form = await createFileForm(localPath, "file");
+        const { response, text } = await postForm(this.fetchImpl, X0_ENDPOINT, form);
+        if (!response.ok) {
+            throw new AgnesCliError("UPLOAD_FAILED", `x0.at upload failed with HTTP ${response.status}.`, {
+                status: response.status,
+                body: text,
+            });
+        }
+        const url = extractPlainTextUrl(text);
+        if (!url) {
+            throw new AgnesCliError("UPLOAD_FAILED", `x0.at did not return a public URL: ${text}`);
+        }
+        return url;
+    }
+}
+export class UguuMediaUrlProvider {
+    fetchImpl;
+    constructor(fetchImpl = fetch) {
+        this.fetchImpl = fetchImpl;
+    }
+    async upload(localPath) {
+        const form = await createFileForm(localPath, "files[]");
+        const { response, text } = await postForm(this.fetchImpl, UGUU_ENDPOINT, form);
+        if (!response.ok) {
+            throw new AgnesCliError("UPLOAD_FAILED", `Uguu upload failed with HTTP ${response.status}.`, {
+                status: response.status,
+                body: text,
+            });
+        }
+        const raw = parseUploadJson(text, "Uguu");
+        const url = extractUguuUrl(raw);
+        if (!url) {
+            throw new AgnesCliError("UPLOAD_FAILED", `Uguu did not return a public URL: ${text}`);
+        }
+        return url;
+    }
+}
+export class TmpfilesMediaUrlProvider {
+    fetchImpl;
+    constructor(fetchImpl = fetch) {
+        this.fetchImpl = fetchImpl;
+    }
+    async upload(localPath, options = {}) {
+        const form = await createFileForm(localPath, "file");
+        form.set("expire", TTL_SECONDS[options.ttl ?? "1h"]);
+        const { response, text } = await postForm(this.fetchImpl, TMPFILES_ENDPOINT, form);
+        if (!response.ok) {
+            throw new AgnesCliError("UPLOAD_FAILED", `tmpfiles upload failed with HTTP ${response.status}.`, {
+                status: response.status,
+                body: text,
+            });
+        }
+        const raw = parseUploadJson(text, "tmpfiles");
+        const url = extractTmpfilesUrl(raw);
+        if (!url) {
+            throw new AgnesCliError("UPLOAD_FAILED", `tmpfiles did not return a public URL: ${text}`);
+        }
+        return toTmpfilesDirectUrl(url);
+    }
+}
+async function createFileForm(localPath, fieldName) {
+    const file = await fs.readFile(localPath);
+    const form = new FormData();
+    const mimeType = MIME_TYPES[extname(localPath).toLowerCase()] ?? "application/octet-stream";
+    form.set(fieldName, new Blob([file], { type: mimeType }), basename(localPath));
+    return form;
+}
+async function postForm(fetchImpl, endpoint, form) {
+    try {
+        const response = await fetchImpl(endpoint, {
+            method: "POST",
+            body: form,
+        });
+        return { response, text: (await response.text()).trim() };
+    }
+    catch (error) {
+        throw new AgnesCliError("UPLOAD_FAILED", `${new URL(endpoint).hostname} upload failed before a response was received.`, {
+            cause: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+function parseUploadJson(text, providerName) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new AgnesCliError("UPLOAD_FAILED", `${providerName} did not return JSON: ${text}`);
+    }
+}
+function extractPlainTextUrl(text) {
+    const url = text.match(/https?:\/\/[^\s"'<>]+/)?.[0];
+    return url && /^https?:\/\//.test(url) ? url : undefined;
+}
+function extractUguuUrl(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const files = raw.files;
+    if (!Array.isArray(files))
+        return undefined;
+    const first = files[0];
+    if (!first || typeof first !== "object")
+        return undefined;
+    const url = first.url;
+    return typeof url === "string" && /^https?:\/\//.test(url) ? url : undefined;
+}
+function extractTmpfilesUrl(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const data = raw.data;
+    if (!data || typeof data !== "object")
+        return undefined;
+    const url = data.url;
+    return typeof url === "string" && /^https?:\/\//.test(url) ? url : undefined;
+}
+function toTmpfilesDirectUrl(url) {
+    const parsed = new URL(url);
+    if (parsed.hostname !== "tmpfiles.org" || parsed.pathname.startsWith("/dl/")) {
+        return url;
+    }
+    parsed.pathname = `/dl${parsed.pathname}`;
+    return parsed.toString();
+}

package/dist/media/toPublicUrl.js

@@ -2,7 +2,7 @@ import { access, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { constants } from "node:fs";
 import { tmpdir } from "node:os";
 import { extname, join } from "node:path";
-import { LitterboxMediaUrlProvider } from "./litterbox.js";
+import { TemporaryMediaUrlProvider } from "./temporary-upload.js";
 import { resolveConfig } from "../config.js";
 import { AgnesCliError } from "../errors.js";
 const MIME_EXTENSIONS = {
@@ -20,11 +20,11 @@ export async function toPublicUrl(input, options = {}, config = {}) {
     }
     const resolved = resolveConfig(config);
     const provider = resolved.mediaProvider ??
-        new LitterboxMediaUrlProvider(resolved.fetchImpl);
+        new TemporaryMediaUrlProvider(resolved.fetchImpl);
     const materialized = await materializeUploadInput(input, resolved.fetchImpl);
     try {
         const url = await provider.upload(materialized.path, { ttl: options.ttl ?? resolved.defaultMediaTtl });
-        return { ok: true, url, source: resolved.mediaProvider ? "provider" : "litterbox" };
+        return { ok: true, url, source: resolved.mediaProvider ? "provider" : "temporary" };
     }
     finally {
         if (materialized.cleanupDir) {

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.1",
+  "version": "0.1.3",
   "description": "CLI and JS API for Agnes text, image, and video workflows.",
   "type": "module",
   "bin": {