agnes-ai-cli 0.1.0

package/dist/config.js

@@ -0,0 +1,24 @@
+import { AgnesCliError } from "./errors.js";
+export const DEFAULT_BASE_URL = "https://apihub.agnes-ai.com/v1";
+export const DEFAULT_MEDIA_TTL = "1h";
+export const DEFAULT_VIDEO_DIMENSIONS = {
+    width: 1152,
+    height: 768,
+};
+export const DEFAULT_VIDEO_TEMPORAL = {
+    numFrames: 121,
+    frameRate: 24,
+};
+export function resolveConfig(config = {}) {
+    if (!config.fetchImpl && typeof fetch !== "function") {
+        throw new AgnesCliError("FETCH_UNAVAILABLE", "Global fetch is unavailable in this Node runtime.");
+    }
+    return {
+        apiKey: config.apiKey ?? config.env?.AGNES_API_KEY ?? process.env.AGNES_API_KEY,
+        baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+        fetchImpl: config.fetchImpl ?? fetch,
+        defaultMediaTtl: config.defaultMediaTtl ?? DEFAULT_MEDIA_TTL,
+        mediaProvider: config.mediaProvider,
+        env: config.env ?? process.env,
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,7 @@
+export declare class AgnesCliError extends Error {
+    code: string;
+    details?: unknown;
+    exitCode: number;
+    constructor(code: string, message: string, details?: unknown, exitCode?: number);
+}
+export declare function isAgnesCliError(error: unknown): error is AgnesCliError;

package/dist/errors.js

@@ -0,0 +1,15 @@
+export class AgnesCliError extends Error {
+    code;
+    details;
+    exitCode;
+    constructor(code, message, details, exitCode = 1) {
+        super(message);
+        this.name = "AgnesCliError";
+        this.code = code;
+        this.details = details;
+        this.exitCode = exitCode;
+    }
+}
+export function isAgnesCliError(error) {
+    return error instanceof AgnesCliError;
+}

package/dist/http/requestJson.d.ts

@@ -0,0 +1,8 @@
+export declare function requestJson(fetchImpl: typeof fetch, url: string, init: RequestInit, options?: {
+    retries?: number;
+    retryDelayMs?: number;
+    networkMessage?: string;
+}): Promise<{
+    response: Response;
+    raw: unknown;
+}>;

package/dist/http/requestJson.js

@@ -0,0 +1,26 @@
+import { AgnesCliError } from "../errors.js";
+export async function requestJson(fetchImpl, url, init, options = {}) {
+    const retries = options.retries ?? 2;
+    const retryDelayMs = options.retryDelayMs ?? 500;
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt += 1) {
+        try {
+            const response = await fetchImpl(url, init);
+            const raw = await response.json();
+            return { response, raw };
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === retries) {
+                throw new AgnesCliError("NETWORK_ERROR", options.networkMessage ?? "Network request failed.", { cause: error instanceof Error ? error.message : String(error) });
+            }
+            await sleep(retryDelayMs);
+        }
+    }
+    throw new AgnesCliError("NETWORK_ERROR", options.networkMessage ?? "Network request failed.", {
+        cause: lastError instanceof Error ? lastError.message : String(lastError),
+    });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/image/generateImage.d.ts

@@ -0,0 +1,3 @@
+import type { AgnesClientConfig, ImageGenerationResult } from "../config.js";
+import { type ImageGenerateOptions } from "./normalizeImageRequest.js";
+export declare function generateImage(options: ImageGenerateOptions, config?: AgnesClientConfig): Promise<ImageGenerationResult>;

package/dist/image/generateImage.js

@@ -0,0 +1,62 @@
+import { resolveConfig } from "../config.js";
+import { AgnesCliError } from "../errors.js";
+import { requestJson } from "../http/requestJson.js";
+import { toPublicUrl } from "../media/toPublicUrl.js";
+import { collectImageInputs, imageGenerateSchema, normalizeImageRequest } from "./normalizeImageRequest.js";
+export async function generateImage(options, config = {}) {
+    const parsed = imageGenerateSchema.parse(options);
+    const resolved = resolveConfig(config);
+    if (!resolved.apiKey) {
+        throw new AgnesCliError("AUTH_MISSING", "AGNES_API_KEY is required for Agnes requests.");
+    }
+    const { inputs, ttl } = collectImageInputs(parsed);
+    const resolvedImages = await resolveMediaInputs(inputs, ttl, config);
+    const payload = normalizeImageRequest(parsed, resolvedImages);
+    const { response, raw } = await requestJson(resolved.fetchImpl, `${resolved.baseUrl}/images/generations`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${resolved.apiKey}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(payload),
+    }, {
+        networkMessage: "Agnes image request failed before a response was received.",
+    });
+    if (!response.ok) {
+        throw new AgnesCliError("AGNES_REQUEST_FAILED", `Agnes image request failed with HTTP ${response.status}.`, raw);
+    }
+    const url = extractImageUrl(raw);
+    if (!url) {
+        throw new AgnesCliError("IMAGE_URL_MISSING", "Agnes image response did not include a URL.", raw);
+    }
+    return {
+        ok: true,
+        model: String(payload.model),
+        url,
+        raw,
+    };
+}
+async function resolveMediaInputs(inputs, ttl, config) {
+    const cache = new Map();
+    const resolved = [];
+    for (const input of inputs) {
+        if (!cache.has(input)) {
+            const value = await toPublicUrl(input, ttl ? { ttl: ttl } : {}, config);
+            cache.set(input, value.url);
+        }
+        resolved.push(cache.get(input));
+    }
+    return resolved;
+}
+function extractImageUrl(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const record = raw;
+    const data = Array.isArray(record.data) ? record.data[0] : undefined;
+    if (data && typeof data === "object" && typeof data.url === "string") {
+        return data.url;
+    }
+    if (typeof record.url === "string")
+        return record.url;
+    return undefined;
+}

package/dist/image/normalizeImageRequest.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import type { Ttl } from "../config.js";
+export declare const imageGenerateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"text2img">;
+    model: z.ZodOptional<z.ZodEnum<{
+        "agnes-image-2.1-flash": "agnes-image-2.1-flash";
+        "agnes-image-2.0-flash": "agnes-image-2.0-flash";
+    }>>;
+    prompt: z.ZodString;
+    size: z.ZodOptional<z.ZodString>;
+    responseFormat: z.ZodOptional<z.ZodLiteral<"url">>;
+    seed: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"img2img">;
+    model: z.ZodOptional<z.ZodEnum<{
+        "agnes-image-2.1-flash": "agnes-image-2.1-flash";
+        "agnes-image-2.0-flash": "agnes-image-2.0-flash";
+    }>>;
+    image: z.ZodString;
+    prompt: z.ZodString;
+    size: z.ZodOptional<z.ZodString>;
+    responseFormat: z.ZodOptional<z.ZodLiteral<"url">>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    ttl: z.ZodOptional<z.ZodEnum<{
+        "1h": "1h";
+        "12h": "12h";
+        "24h": "24h";
+        "72h": "72h";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"compose">;
+    model: z.ZodOptional<z.ZodEnum<{
+        "agnes-image-2.1-flash": "agnes-image-2.1-flash";
+        "agnes-image-2.0-flash": "agnes-image-2.0-flash";
+    }>>;
+    images: z.ZodArray<z.ZodString>;
+    prompt: z.ZodString;
+    size: z.ZodOptional<z.ZodString>;
+    responseFormat: z.ZodOptional<z.ZodLiteral<"url">>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    ttl: z.ZodOptional<z.ZodEnum<{
+        "1h": "1h";
+        "12h": "12h";
+        "24h": "24h";
+        "72h": "72h";
+    }>>;
+}, z.core.$strip>], "mode">;
+export type ImageGenerateOptions = z.infer<typeof imageGenerateSchema>;
+export declare function normalizeImageRequest(options: ImageGenerateOptions, resolvedImages: string[]): Record<string, unknown>;
+export declare function collectImageInputs(options: ImageGenerateOptions): {
+    inputs: string[];
+    ttl?: Ttl;
+};

package/dist/image/normalizeImageRequest.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { AgnesCliError } from "../errors.js";
+export const imageGenerateSchema = z.discriminatedUnion("mode", [
+    z.object({
+        mode: z.literal("text2img"),
+        model: z.enum(["agnes-image-2.1-flash", "agnes-image-2.0-flash"]).optional(),
+        prompt: z.string().min(1),
+        size: z.string().optional(),
+        responseFormat: z.literal("url").optional(),
+        seed: z.number().int().optional(),
+    }),
+    z.object({
+        mode: z.literal("img2img"),
+        model: z.enum(["agnes-image-2.1-flash", "agnes-image-2.0-flash"]).optional(),
+        image: z.string().min(1),
+        prompt: z.string().min(1),
+        size: z.string().optional(),
+        responseFormat: z.literal("url").optional(),
+        seed: z.number().int().optional(),
+        ttl: z.enum(["1h", "12h", "24h", "72h"]).optional(),
+    }),
+    z.object({
+        mode: z.literal("compose"),
+        model: z.enum(["agnes-image-2.1-flash", "agnes-image-2.0-flash"]).optional(),
+        images: z.array(z.string().min(1)).min(2),
+        prompt: z.string().min(1),
+        size: z.string().optional(),
+        responseFormat: z.literal("url").optional(),
+        seed: z.number().int().optional(),
+        ttl: z.enum(["1h", "12h", "24h", "72h"]).optional(),
+    }),
+]);
+export function normalizeImageRequest(options, resolvedImages) {
+    const model = options.model ?? "agnes-image-2.1-flash";
+    const payload = {
+        model,
+        prompt: options.prompt,
+    };
+    if (options.size)
+        payload.size = options.size;
+    if (options.seed !== undefined)
+        payload.seed = options.seed;
+    if (options.mode === "text2img") {
+        return payload;
+    }
+    const imageValue = options.mode === "img2img" ? resolvedImages[0] : resolvedImages;
+    payload.extra_body = {
+        image: imageValue,
+        ...(options.responseFormat ? { response_format: options.responseFormat } : {}),
+    };
+    if (model === "agnes-image-2.0-flash") {
+        payload.tags = ["img2img"];
+    }
+    return payload;
+}
+export function collectImageInputs(options) {
+    switch (options.mode) {
+        case "text2img":
+            return { inputs: [] };
+        case "img2img":
+            return { inputs: [options.image], ttl: options.ttl };
+        case "compose":
+            return { inputs: options.images, ttl: options.ttl };
+        default:
+            throw new AgnesCliError("INVALID_IMAGE_MODE", "Unsupported image generation mode.");
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+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 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";
+export type { VideoGenerateOptions } from "./video/normalizeVideoRequest.js";
+export type { PollVideoOptions } from "./video/pollVideo.js";
+export declare function createAgnesClient(config?: AgnesClientConfig): {
+    auth: {
+        check: () => {
+            readonly ok: boolean;
+            readonly configured: boolean;
+            readonly source: "env" | "missing";
+        };
+    };
+    media: {
+        toPublicUrl: (input: string, options?: {
+            ttl?: import("./config.js").Ttl;
+        }) => Promise<import("./config.js").PublicUrlResult>;
+    };
+    text: {
+        complete: (options: import("./text/complete.js").TextCompleteOptions) => Promise<import("./text/complete.js").TextCompletionResult>;
+    };
+    image: {
+        generate: (options: import("./image/normalizeImageRequest.js").ImageGenerateOptions) => Promise<import("./config.js").ImageGenerationResult>;
+    };
+    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>;
+    };
+};

package/dist/index.js

@@ -0,0 +1,29 @@
+import { checkAuth } from "./auth/check.js";
+import { toPublicUrl } from "./media/toPublicUrl.js";
+import { generateImage } from "./image/generateImage.js";
+import { completeText } from "./text/complete.js";
+import { generateVideo } from "./video/generateVideo.js";
+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 function createAgnesClient(config = {}) {
+    return {
+        auth: {
+            check: () => checkAuth({ env: config.env }),
+        },
+        media: {
+            toPublicUrl: (input, options) => toPublicUrl(input, options, config),
+        },
+        text: {
+            complete: (options) => completeText(options, config),
+        },
+        image: {
+            generate: (options) => generateImage(options, config),
+        },
+        video: {
+            generate: (options) => generateVideo(options, config),
+            poll: (taskId, options) => pollVideo(taskId, options, config),
+        },
+    };
+}

package/dist/media/litterbox.d.ts

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

package/dist/media/litterbox.js

@@ -0,0 +1,69 @@
+import { basename, extname } from "node:path";
+import { promises as fs } from "node:fs";
+import { AgnesCliError } from "../errors.js";
+const LITTERBOX_ENDPOINT = "https://litterbox.catbox.moe/resources/internals/api.php";
+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",
+};
+export class LitterboxMediaUrlProvider {
+    fetchImpl;
+    constructor(fetchImpl = fetch) {
+        this.fetchImpl = fetchImpl;
+    }
+    async upload(localPath, options = {}) {
+        const ttl = options.ttl ?? "1h";
+        const file = await fs.readFile(localPath);
+        const form = new FormData();
+        const mimeType = MIME_TYPES[extname(localPath).toLowerCase()] ?? "application/octet-stream";
+        const blob = new Blob([file], { type: mimeType });
+        form.set("reqtype", "fileupload");
+        form.set("time", ttl);
+        form.set("fileToUpload", blob, basename(localPath));
+        const { response, text } = await this.postFormWithRetry(form);
+        if (!response.ok) {
+            throw new AgnesCliError("UPLOAD_FAILED", `Litterbox upload failed with HTTP ${response.status}.`, {
+                status: response.status,
+                body: text,
+            });
+        }
+        if (!/^https?:\/\//.test(text)) {
+            throw new AgnesCliError("UPLOAD_FAILED", `Litterbox did not return a public URL: ${text}`);
+        }
+        return text;
+    }
+    async postFormWithRetry(form) {
+        let lastError;
+        for (let attempt = 0; attempt <= 2; attempt += 1) {
+            try {
+                const response = await this.fetchImpl(LITTERBOX_ENDPOINT, {
+                    method: "POST",
+                    body: form,
+                });
+                const text = (await response.text()).trim();
+                return { response, text };
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt === 2) {
+                    throw new AgnesCliError("UPLOAD_FAILED", "Litterbox upload failed before a response was received.", {
+                        cause: error instanceof Error ? error.message : String(error),
+                    });
+                }
+                await sleep(500);
+            }
+        }
+        throw new AgnesCliError("UPLOAD_FAILED", "Litterbox upload failed before a response was received.", {
+            cause: lastError instanceof Error ? lastError.message : String(lastError),
+        });
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/media/toPublicUrl.d.ts

@@ -0,0 +1,4 @@
+import type { AgnesClientConfig, PublicUrlResult, Ttl } from "../config.js";
+export declare function toPublicUrl(input: string, options?: {
+    ttl?: Ttl;
+}, config?: AgnesClientConfig): Promise<PublicUrlResult>;

package/dist/media/toPublicUrl.js

@@ -0,0 +1,21 @@
+import { access } from "node:fs/promises";
+import { constants } from "node:fs";
+import { LitterboxMediaUrlProvider } from "./litterbox.js";
+import { resolveConfig } from "../config.js";
+import { AgnesCliError } from "../errors.js";
+export async function toPublicUrl(input, options = {}, config = {}) {
+    if (/^https?:\/\//.test(input)) {
+        return { ok: true, url: input, source: "passthrough" };
+    }
+    try {
+        await access(input, constants.R_OK);
+    }
+    catch {
+        throw new AgnesCliError("INPUT_NOT_FOUND", `Input must be an existing file path or an http(s) URL: ${input}`);
+    }
+    const resolved = resolveConfig(config);
+    const provider = resolved.mediaProvider ??
+        new LitterboxMediaUrlProvider(resolved.fetchImpl);
+    const url = await provider.upload(input, { ttl: options.ttl ?? resolved.defaultMediaTtl });
+    return { ok: true, url, source: resolved.mediaProvider ? "provider" : "litterbox" };
+}

package/dist/output.d.ts

@@ -0,0 +1,2 @@
+export declare function printJson(value: unknown): void;
+export declare function printLines(lines: Array<string | undefined>): void;

package/dist/output.js

@@ -0,0 +1,9 @@
+export function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+export function printLines(lines) {
+    for (const line of lines) {
+        if (line)
+            console.log(line);
+    }
+}

package/dist/text/complete.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import type { AgnesClientConfig } from "../config.js";
+declare const textCompleteSchema: z.ZodObject<{
+    model: z.ZodDefault<z.ZodString>;
+    prompt: z.ZodString;
+    stream: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type TextCompleteOptions = z.infer<typeof textCompleteSchema>;
+export interface TextCompletionResult {
+    ok: true;
+    model: string;
+    text: string;
+    raw: unknown;
+}
+export declare function completeText(options: TextCompleteOptions, config?: AgnesClientConfig): Promise<TextCompletionResult>;
+export {};

package/dist/text/complete.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { resolveConfig } from "../config.js";
+import { AgnesCliError } from "../errors.js";
+import { requestJson } from "../http/requestJson.js";
+const textCompleteSchema = z.object({
+    model: z.string().default("agnes-2.0-flash"),
+    prompt: z.string().min(1),
+    stream: z.boolean().optional(),
+});
+export async function completeText(options, config = {}) {
+    const parsed = textCompleteSchema.parse(options);
+    const resolved = resolveConfig(config);
+    if (!resolved.apiKey) {
+        throw new AgnesCliError("AUTH_MISSING", "AGNES_API_KEY is required for Agnes requests.");
+    }
+    const payload = {
+        model: parsed.model,
+        messages: [{ role: "user", content: parsed.prompt }],
+        ...(parsed.stream ? { stream: true } : {}),
+    };
+    const { response, raw } = await requestJson(resolved.fetchImpl, `${resolved.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${resolved.apiKey}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(payload),
+    }, {
+        networkMessage: "Agnes text request failed before a response was received.",
+    });
+    if (!response.ok) {
+        throw new AgnesCliError("AGNES_REQUEST_FAILED", `Agnes text request failed with HTTP ${response.status}.`, raw);
+    }
+    const text = extractText(raw);
+    if (!text) {
+        throw new AgnesCliError("TEXT_MISSING", "Agnes text response did not include assistant content.", raw);
+    }
+    return {
+        ok: true,
+        model: parsed.model,
+        text,
+        raw,
+    };
+}
+function extractText(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const record = raw;
+    const choices = Array.isArray(record.choices) ? record.choices : [];
+    const first = choices[0];
+    if (!first || typeof first !== "object")
+        return undefined;
+    const message = first.message;
+    if (!message || typeof message !== "object")
+        return undefined;
+    const content = message.content;
+    return typeof content === "string" ? content : undefined;
+}

package/dist/video/generateVideo.d.ts

@@ -0,0 +1,6 @@
+import type { AgnesClientConfig, NormalizedVideoTask } from "../config.js";
+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 normalizeStatus(rawStatus: string): "queued" | "in_progress" | "completed" | "failed";

package/dist/video/generateVideo.js

@@ -0,0 +1,77 @@
+import { resolveConfig } from "../config.js";
+import { AgnesCliError } from "../errors.js";
+import { requestJson } from "../http/requestJson.js";
+import { toPublicUrl } from "../media/toPublicUrl.js";
+import { collectVideoInputs, normalizeVideoRequest, videoGenerateSchema } from "./normalizeVideoRequest.js";
+export async function generateVideo(options, config = {}) {
+    const parsed = videoGenerateSchema.parse(options);
+    const resolved = resolveConfig(config);
+    if (!resolved.apiKey) {
+        throw new AgnesCliError("AUTH_MISSING", "AGNES_API_KEY is required for Agnes requests.");
+    }
+    const { inputs, ttl } = collectVideoInputs(parsed);
+    const resolvedImages = await resolveMediaInputs(inputs, ttl, config);
+    const payload = normalizeVideoRequest(parsed, resolvedImages);
+    const { response, raw } = await requestJson(resolved.fetchImpl, `${resolved.baseUrl}/videos`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${resolved.apiKey}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(payload),
+    }, {
+        networkMessage: "Agnes video request failed before a response was received.",
+    });
+    if (!response.ok) {
+        throw new AgnesCliError("AGNES_REQUEST_FAILED", `Agnes video request failed with HTTP ${response.status}.`, raw);
+    }
+    return normalizeVideoTask(raw);
+}
+async function resolveMediaInputs(inputs, ttl, config) {
+    const cache = new Map();
+    const resolved = [];
+    for (const input of inputs) {
+        if (!cache.has(input)) {
+            const value = await toPublicUrl(input, ttl ? { ttl: ttl } : {}, config);
+            cache.set(input, value.url);
+        }
+        resolved.push(cache.get(input));
+    }
+    return resolved;
+}
+export function normalizeVideoTask(raw) {
+    const record = ensureRecord(raw);
+    const taskId = extractTaskId(record);
+    const rawStatus = typeof record.status === "string" ? record.status : "queued";
+    return {
+        ok: true,
+        taskId,
+        status: normalizeStatus(rawStatus),
+        rawStatus,
+        model: typeof record.model === "string" ? record.model : "agnes-video-v2.0",
+        raw,
+    };
+}
+function ensureRecord(raw) {
+    if (!raw || typeof raw !== "object") {
+        throw new AgnesCliError("INVALID_RESPONSE", "Agnes video response was not an object.", raw);
+    }
+    return raw;
+}
+export function extractTaskId(record) {
+    const taskId = typeof record.task_id === "string"
+        ? record.task_id
+        : typeof record.id === "string"
+            ? record.id
+            : undefined;
+    if (!taskId) {
+        throw new AgnesCliError("TASK_ID_MISSING", "Agnes video response did not include task_id or id.", record);
+    }
+    return taskId;
+}
+export function normalizeStatus(rawStatus) {
+    if (rawStatus === "queued" || rawStatus === "in_progress" || rawStatus === "completed" || rawStatus === "failed") {
+        return rawStatus;
+    }
+    return "queued";
+}