@ronana/mcp 0.0.0-stage → 0.1.1

package/dist/input.js

@@ -0,0 +1,166 @@
+// The CLI's input handling, kept free of any network or terminal I/O so it
+// can be tested: argv parsing, and turning flags into a model's provider-native
+// `input` body using the contract `get_model` publishes.
+import { existsSync, statSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+const BOOLEAN_FLAGS = new Set(["json", "wait", "help", "no_browser"]);
+/** CLI options that are meaningless without a value. A model's own fields stay
+ *  lenient, since a bare `--sound` means true. */
+const VALUE_FLAGS = new Set(["out", "input", "idempotency_key", "base_url", "wait_timeout", "wait_interval", "limit", "kind"]);
+export function parseArgs(argv) {
+    const positional = [];
+    const flags = new Map();
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "-h") {
+            flags.set("help", ["true"]);
+            continue;
+        }
+        if (!arg.startsWith("--")) {
+            positional.push(arg);
+            continue;
+        }
+        const eq = arg.indexOf("=");
+        const name = (eq > 0 ? arg.slice(2, eq) : arg.slice(2)).replaceAll("-", "_");
+        let value;
+        if (eq > 0)
+            value = arg.slice(eq + 1);
+        else if (!BOOLEAN_FLAGS.has(name) && i + 1 < argv.length && !argv[i + 1].startsWith("--"))
+            value = argv[++i];
+        else if (VALUE_FLAGS.has(name))
+            throw new Error(`--${name.replaceAll("_", "-")} needs a value.`);
+        else
+            value = "true";
+        flags.set(name, [...(flags.get(name) ?? []), value]);
+    }
+    return { positional, flags };
+}
+export const flag = (args, name) => args.flags.get(name)?.at(-1);
+export const has = (args, name) => args.flags.has(name);
+export const takeFlag = (args, name) => { const v = flag(args, name); args.flags.delete(name); return v; };
+export const typeOf = (schema) => (Array.isArray(schema.type) ? schema.type.find((t) => t !== "null") : schema.type) ?? "string";
+const RESERVED = new Set(["json", "wait", "out", "input", "wait_timeout", "wait_interval", "idempotency_key", "help"]);
+/** A URL (the server says which schemes it accepts) or a Ronana id. */
+export const isRemoteValue = (v) => /^https?:\/\//i.test(v) || /^(ref|img|gen)_[A-Za-z0-9]+$/.test(v);
+const isLocalFile = (path) => existsSync(path) && statSync(path).isFile();
+function coerce(field, raw, schema) {
+    const type = schema ? typeOf(schema) : "string";
+    if (type === "integer" || type === "number") {
+        const n = Number(raw);
+        if (!Number.isFinite(n) || (type === "integer" && !Number.isInteger(n)))
+            throw new Error(`--${field} must be a ${type}.`);
+        return n;
+    }
+    if (type === "boolean") {
+        if (raw !== "true" && raw !== "false")
+            throw new Error(`--${field} must be true or false.`);
+        return raw === "true";
+    }
+    if (type === "object") {
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`--${field} must be JSON.`);
+        }
+    }
+    return raw;
+}
+async function readInputFlag(raw) {
+    if (!raw)
+        return {};
+    const text = raw.startsWith("@") ? await readFile(raw.slice(1), "utf8") : raw;
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new Error("--input must be a JSON object (or @file.json).");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new Error("--input must be a JSON object.");
+    return parsed;
+}
+/** A flag value written as a JSON array (`--images '["a","b"]'`), else null —
+ *  so a plain value that merely starts with "[" stays a plain value. */
+function jsonArray(raw) {
+    if (!raw.startsWith("["))
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Top-level media fields of one kind, for the --image/--video/--audio shorthands. */
+function shorthandTarget(contract, kind) {
+    const fields = contract.media_fields
+        .filter((m) => m.kind === kind && !m.mask)
+        .map((m) => m.field.replace(/\[\]$/, ""))
+        .filter((f) => !f.includes("."));
+    return fields.length ? fields[0] : undefined;
+}
+export async function buildInput(contract, args) {
+    const input = await readInputFlag(takeFlag(args, "input"));
+    const properties = contract.input_schema.properties ?? {};
+    for (const [rawName, values] of args.flags) {
+        if (RESERVED.has(rawName))
+            continue;
+        let name = rawName in properties ? rawName : rawName.replaceAll("_", "-") in properties ? rawName.replaceAll("_", "-") : rawName;
+        if (!(name in properties) && ["image", "video", "audio"].includes(name))
+            name = shorthandTarget(contract, name) ?? name;
+        const schema = properties[name];
+        if (!schema) {
+            throw new Error(`${contract.id} has no field "${rawName}". Fields: ${Object.keys(properties).join(", ")}.`);
+        }
+        if (typeOf(schema) === "array") {
+            const items = values.flatMap((v) => jsonArray(v) ?? [coerce(name, v, schema.items)]);
+            input[name] = [...(Array.isArray(input[name]) ? input[name] : []), ...items];
+        }
+        else {
+            input[name] = coerce(name, values.at(-1), schema);
+        }
+    }
+    return input;
+}
+/** Replace every local file named in a media field with an uploaded ref id.
+ *  Only media fields are looked at, so a prompt that happens to match a file
+ *  name is never uploaded. A file named twice uploads once. */
+export async function replaceLocalMedia(contract, input, upload) {
+    const cache = new Map();
+    const resolveValue = async (value) => {
+        if (typeof value !== "string")
+            return value;
+        // A file on disk wins, so a local file named like an id still uploads.
+        const path = resolve(value);
+        if (!isLocalFile(path)) {
+            if (isRemoteValue(value))
+                return value;
+            throw new Error(`"${value}" is not a file, a URL, or a ref_/img_/gen_ id.`);
+        }
+        if (!cache.has(path))
+            cache.set(path, upload(path));
+        return cache.get(path);
+    };
+    const walk = async (node, segments) => {
+        if (!segments.length)
+            return resolveValue(node);
+        if (!node || typeof node !== "object")
+            return node;
+        const [head, ...rest] = segments;
+        const isList = head.endsWith("[]");
+        const key = isList ? head.slice(0, -2) : head;
+        const target = node;
+        if (!(key in target))
+            return node;
+        target[key] = isList && Array.isArray(target[key])
+            ? await Promise.all(target[key].map((item) => walk(item, rest)))
+            : await walk(target[key], rest);
+        return node;
+    };
+    for (const media of contract.media_fields)
+        await walk(input, media.field.split("."));
+}

package/dist/oauth.d.ts

@@ -0,0 +1,11 @@
+export interface StoredCredentials {
+    baseUrl: string;
+    clientId: string;
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+}
+export declare function readCredentials(): StoredCredentials | null;
+export declare function logout(): Promise<void>;
+export declare function login(baseUrl?: string, openInBrowser?: boolean): Promise<void>;
+export declare function accessToken(): Promise<string>;

package/dist/oauth.js

@@ -0,0 +1,225 @@
+import { createHash, randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { spawn } from "node:child_process";
+import { closeSync, openSync, statSync, unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Entry } from "@napi-rs/keyring";
+const SERVICE = "Ronana MCP";
+const ACCOUNT = "oauth";
+const SCOPES = "mcp:read mcp:upload mcp:generate offline_access";
+/** How long a sign-in may sit in the browser. An AI agent often runs login for
+ *  the user, and a closed tab must end the command rather than hang it. */
+const LOGIN_TIMEOUT_MS = 5 * 60_000;
+const entry = () => new Entry(SERVICE, ACCOUNT);
+export function readCredentials() {
+    const value = entry().getPassword();
+    if (!value)
+        return null;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function writeCredentials(value) {
+    entry().setPassword(JSON.stringify(value));
+}
+export async function logout() {
+    const current = readCredentials();
+    if (current) {
+        await fetch(`${current.baseUrl}/api/auth/oauth2/revoke`, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({ token: current.refreshToken, client_id: current.clientId }),
+        }).catch(() => null);
+    }
+    try {
+        entry().deletePassword();
+    }
+    catch { /* No stored credential. */ }
+}
+function openBrowser(url) {
+    if (process.platform === "win32") {
+        spawn("rundll32", ["url.dll,FileProtocolHandler", url], { detached: true, stdio: "ignore" }).unref();
+    }
+    else if (process.platform === "darwin") {
+        spawn("open", [url], { detached: true, stdio: "ignore" }).unref();
+    }
+    else {
+        spawn("xdg-open", [url], { detached: true, stdio: "ignore" }).unref();
+    }
+}
+async function tokenRequest(baseUrl, fields) {
+    const response = await fetch(`${baseUrl}/api/auth/oauth2/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams(fields),
+    });
+    const body = await response.json();
+    if (!response.ok)
+        throw new Error(String(body.error_description ?? body.error ?? "OAuth token request failed."));
+    return body;
+}
+export async function login(baseUrl = process.env.RONANA_BASE_URL ?? "https://ronana.ai", openInBrowser = true) {
+    baseUrl = baseUrl.replace(/\/$/, "");
+    const verifier = randomBytes(32).toString("base64url");
+    const challenge = createHash("sha256").update(verifier).digest("base64url");
+    const state = randomBytes(24).toString("base64url");
+    const callback = await new Promise((resolve, reject) => {
+        let settle;
+        let fail;
+        const code = new Promise((ok, no) => { settle = ok; fail = no; });
+        const timer = setTimeout(() => fail(new Error("Sign-in timed out. Run `ronana auth login` again.")), LOGIN_TIMEOUT_MS);
+        const close = () => { clearTimeout(timer); server.close(); };
+        const server = createServer((req, res) => {
+            const url = new URL(req.url ?? "/", "http://127.0.0.1");
+            if (url.searchParams.get("state") !== state) {
+                res.writeHead(400).end("Invalid OAuth state.");
+                fail(new Error("OAuth state did not match."));
+            }
+            else if (url.searchParams.get("error")) {
+                res.writeHead(400).end("Authorization was not completed.");
+                fail(new Error(url.searchParams.get("error_description") ?? url.searchParams.get("error")));
+            }
+            else {
+                res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" }).end("Ronana is connected. You can close this window.");
+                settle(url.searchParams.get("code") ?? "");
+            }
+            close();
+        });
+        server.once("error", (error) => { clearTimeout(timer); reject(error); });
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                close();
+                return reject(new Error("Loopback callback failed."));
+            }
+            resolve({ redirectUri: `http://127.0.0.1:${address.port}/callback`, code, close });
+        });
+    });
+    // Every exit below (refused registration, timeout, a refused token) frees the
+    // loopback port and the timer, so the process can end.
+    try {
+        const registration = await fetch(`${baseUrl}/api/auth/oauth2/register`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                client_name: "Ronana CLI",
+                redirect_uris: [callback.redirectUri],
+                token_endpoint_auth_method: "none",
+                grant_types: ["authorization_code", "refresh_token"],
+                response_types: ["code"],
+                scope: SCOPES,
+            }),
+        });
+        const registered = await registration.json();
+        if (!registration.ok || typeof registered.client_id !== "string")
+            throw new Error("OAuth client registration failed.");
+        const authorize = new URL(`${baseUrl}/api/auth/oauth2/authorize`);
+        authorize.search = new URLSearchParams({
+            response_type: "code",
+            client_id: registered.client_id,
+            redirect_uri: callback.redirectUri,
+            scope: SCOPES,
+            resource: `${baseUrl}/mcp`,
+            code_challenge: challenge,
+            code_challenge_method: "S256",
+            state,
+        }).toString();
+        process.stderr.write(`${openInBrowser ? "Opening your browser to sign in. If it does not open, visit" : "Open this link to sign in"}:
+${authorize}
+`);
+        if (openInBrowser)
+            openBrowser(authorize.toString());
+        const code = await callback.code;
+        const tokens = await tokenRequest(baseUrl, {
+            grant_type: "authorization_code",
+            client_id: registered.client_id,
+            redirect_uri: callback.redirectUri,
+            code,
+            code_verifier: verifier,
+            resource: `${baseUrl}/mcp`,
+        });
+        if (typeof tokens.access_token !== "string" || typeof tokens.refresh_token !== "string")
+            throw new Error("OAuth response did not contain tokens.");
+        writeCredentials({
+            baseUrl,
+            clientId: registered.client_id,
+            accessToken: tokens.access_token,
+            refreshToken: tokens.refresh_token,
+            expiresAt: Date.now() + Number(tokens.expires_in ?? 900) * 1000,
+        });
+    }
+    finally {
+        callback.close();
+    }
+}
+const fresh = (c) => c.expiresAt > Date.now() + 60_000;
+/** Several CLI runs (and the MCP bridge) share one stored refresh token, and the
+ *  server rotates it on use: two processes refreshing at once would race, and
+ *  the loser's stale token could sign the user out. A lock file makes the
+ *  refresh one-at-a-time; whoever waits re-reads the winner's new token. */
+async function withRefreshLock(fn) {
+    const lock = join(tmpdir(), "ronana-oauth-refresh.lock");
+    let held = false;
+    for (const deadline = Date.now() + 15_000;;) {
+        try {
+            closeSync(openSync(lock, "wx"));
+            held = true;
+            break;
+        }
+        catch {
+            // A crashed holder leaves the file behind; a refresh never takes 30s.
+            try {
+                if (Date.now() - statSync(lock).mtimeMs > 30_000)
+                    unlinkSync(lock);
+            }
+            catch { /* Gone already. */ }
+            if (Date.now() > deadline)
+                break; // Proceed unlocked rather than hang.
+            await new Promise((r) => setTimeout(r, 100));
+        }
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        if (held)
+            try {
+                unlinkSync(lock);
+            }
+            catch { /* Gone already. */ }
+    }
+}
+export async function accessToken() {
+    const stored = readCredentials();
+    if (!stored)
+        throw new Error("Not signed in. Run `ronana auth login` first.");
+    if (fresh(stored))
+        return stored.accessToken;
+    return withRefreshLock(async () => {
+        const current = readCredentials();
+        if (!current)
+            throw new Error("Not signed in. Run `ronana auth login` first.");
+        if (fresh(current))
+            return current.accessToken; // Another process refreshed.
+        const tokens = await tokenRequest(current.baseUrl, {
+            grant_type: "refresh_token",
+            client_id: current.clientId,
+            refresh_token: current.refreshToken,
+            resource: `${current.baseUrl}/mcp`,
+        });
+        if (typeof tokens.access_token !== "string")
+            throw new Error("OAuth refresh failed.");
+        const next = {
+            ...current,
+            accessToken: tokens.access_token,
+            refreshToken: typeof tokens.refresh_token === "string" ? tokens.refresh_token : current.refreshToken,
+            expiresAt: Date.now() + Number(tokens.expires_in ?? 900) * 1000,
+        };
+        writeCredentials(next);
+        return next.accessToken;
+    });
+}

package/dist/remote.d.ts

@@ -0,0 +1,20 @@
+import { Client } from "@modelcontextprotocol/client";
+export declare function remoteClient(): Promise<Client>;
+/** A tool failure, carrying the server's structured error (code, message, and
+ *  whatever context the gate attached: a billing url, the offending field). */
+export declare class ToolError extends Error {
+    readonly error: Record<string, unknown>;
+    constructor(error: Record<string, unknown>);
+}
+type Remote = Awaited<ReturnType<typeof remoteClient>>;
+/** Call one tool and unwrap the `{ ok, data | error }` envelope every Ronana
+ *  tool answers with. */
+export declare function callTool<T = unknown>(remote: Remote, name: string, args?: Record<string, unknown>): Promise<T>;
+/** Add a local file to the library and return its ref. Small files go inline
+ *  as base64; larger ones stream straight to storage through a signed PUT. */
+export declare function uploadFile(remote: Remote, path: string): Promise<{
+    id: string;
+    kind: string;
+    reused: boolean;
+}>;
+export {};

package/dist/remote.js

@@ -0,0 +1,86 @@
+// The one connection to Ronana's remote MCP endpoint, shared by the stdio
+// bridge (server.ts) and the CLI (cli.ts). Both sign in once, with the same
+// stored OAuth credential, and every call runs the server's own gates.
+import { createReadStream, statSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { basename, extname } from "node:path";
+import { Readable } from "node:stream";
+import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+import { accessToken, readCredentials } from "./oauth.js";
+export async function remoteClient() {
+    const credentials = readCredentials();
+    if (!credentials)
+        throw new Error("Not signed in. Run `ronana auth login` first.");
+    const client = new Client({ name: "ronana-local", version: "1.0.0" });
+    const transport = new StreamableHTTPClientTransport(new URL(`${credentials.baseUrl}/mcp`), {
+        authProvider: { token: accessToken },
+        onInsufficientScope: "throw",
+    });
+    try {
+        await client.connect(transport);
+    }
+    catch (error) {
+        // A 404 means either an account outside the MCP rollout or a server with no
+        // MCP at all (a wrong --base-url). Only a server that advertises the MCP
+        // resource can be refusing the account.
+        if (error instanceof Error && /not found/i.test(error.message)) {
+            const advertised = await fetch(`${credentials.baseUrl}/.well-known/oauth-protected-resource/mcp`)
+                .then((r) => r.ok, () => false);
+            throw new Error(advertised
+                ? "This account does not have access to Ronana's CLI and MCP yet."
+                : `No Ronana MCP endpoint at ${credentials.baseUrl}. Sign in again with the right --base-url.`);
+        }
+        throw error;
+    }
+    return client;
+}
+/** A tool failure, carrying the server's structured error (code, message, and
+ *  whatever context the gate attached: a billing url, the offending field). */
+export class ToolError extends Error {
+    error;
+    constructor(error) {
+        super(typeof error.message === "string" ? error.message : "The request failed.");
+        this.error = error;
+    }
+}
+/** Call one tool and unwrap the `{ ok, data | error }` envelope every Ronana
+ *  tool answers with. */
+export async function callTool(remote, name, args = {}) {
+    const response = await remote.callTool({ name, arguments: args });
+    const body = response.structuredContent;
+    if (body?.ok)
+        return body.data;
+    if (body?.error)
+        throw new ToolError(body.error);
+    const text = Array.isArray(response.content) ? response.content.map((c) => ("text" in c ? c.text : "")).join(" ") : "";
+    throw new ToolError({ code: "TOOL_FAILED", message: text || `${name} failed.` });
+}
+/* Must match upload_reference's `data` cap (3 MB of bytes ≈ 4.2 MB of base64,
+   the most Vercel's 4.5 MB body cap lets through). */
+const INLINE_LIMIT = 3 * 1024 * 1024;
+const CONTENT_TYPES = {
+    ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png", ".webp": "image/webp",
+    ".heic": "image/heic", ".avif": "image/avif", ".gif": "image/gif", ".mp4": "video/mp4",
+    ".mov": "video/quicktime", ".webm": "video/webm", ".mp3": "audio/mpeg", ".wav": "audio/wav", ".m4a": "audio/mp4",
+};
+/** Add a local file to the library and return its ref. Small files go inline
+ *  as base64; larger ones stream straight to storage through a signed PUT. */
+export async function uploadFile(remote, path) {
+    const filename = basename(path);
+    const { size } = statSync(path);
+    if (size <= INLINE_LIMIT) {
+        const data = (await readFile(path)).toString("base64");
+        return callTool(remote, "upload_reference", { data, filename });
+    }
+    const contentType = CONTENT_TYPES[extname(path).toLowerCase()];
+    if (!contentType)
+        throw new Error(`Unsupported file type: ${filename}`);
+    const ticket = await callTool(remote, "create_upload", { filename, content_type: contentType, size });
+    const put = await fetch(ticket.upload_url, {
+        method: "PUT", headers: ticket.headers,
+        body: Readable.toWeb(createReadStream(path)), duplex: "half",
+    });
+    if (!put.ok)
+        throw new Error(`The upload failed (storage answered ${put.status}).`);
+    return callTool(remote, "finish_upload", { upload_id: ticket.upload_id, filename });
+}

package/dist/schemas.d.ts

@@ -0,0 +1,101 @@
+import { z } from "zod";
+/** MCP request schemas mirror the public HTTP schemas.
+ * Contract tests compare their fields and boundaries with those schemas. */
+export declare const estimateCostInputSchema: {
+    readonly modelId: z.ZodString;
+    readonly resolution: z.ZodOptional<z.ZodString>;
+    readonly aspectRatio: z.ZodOptional<z.ZodString>;
+    readonly durationSeconds: z.ZodOptional<z.ZodNumber>;
+    readonly quality: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    readonly hasVideoRefs: z.ZodOptional<z.ZodBoolean>;
+    readonly generateAudio: z.ZodOptional<z.ZodBoolean>;
+    readonly params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean]>>>;
+};
+export declare const generateInputSchema: {
+    readonly model: z.ZodString;
+    readonly prompt: z.ZodOptional<z.ZodString>;
+    readonly negativePrompt: z.ZodOptional<z.ZodString>;
+    readonly aspectRatio: z.ZodOptional<z.ZodString>;
+    readonly resolution: z.ZodOptional<z.ZodString>;
+    readonly attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        source: z.ZodEnum<["ref", "video_generation", "image_generation", "media_asset"]>;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        source: "ref" | "video_generation" | "image_generation" | "media_asset";
+    }, {
+        id: string;
+        source: "ref" | "video_generation" | "image_generation" | "media_asset";
+    }>, "many">>;
+    readonly seed: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    readonly params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean]>>>;
+    readonly idempotencyKey: z.ZodOptional<z.ZodString>;
+    readonly wait: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const videoGenerationInputSchema: {
+    readonly slotBindings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    readonly keyframes: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodNumber>, Record<string, number>, Record<string, number>>>;
+    readonly duration: z.ZodOptional<z.ZodNumber>;
+    readonly generateAudio: z.ZodOptional<z.ZodBoolean>;
+    readonly movementAmplitude: z.ZodOptional<z.ZodEnum<["auto", "small", "medium", "large"]>>;
+    readonly shotType: z.ZodOptional<z.ZodEnum<["intelligence", "customize"]>>;
+    readonly multiPrompt: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        prompt: z.ZodString;
+        duration: z.ZodNumber;
+        shotSize: z.ZodOptional<z.ZodEnum<["auto", "wide", "medium", "closeup", "macro", "pov"]>>;
+        cameraMove: z.ZodOptional<z.ZodEnum<["auto", "static", "pan", "tracking", "dollyIn", "dollyOut", "zoom"]>>;
+    }, "strip", z.ZodTypeAny, {
+        prompt: string;
+        duration: number;
+        shotSize?: "medium" | "auto" | "wide" | "closeup" | "macro" | "pov" | undefined;
+        cameraMove?: "auto" | "static" | "pan" | "tracking" | "dollyIn" | "dollyOut" | "zoom" | undefined;
+    }, {
+        prompt: string;
+        duration: number;
+        shotSize?: "medium" | "auto" | "wide" | "closeup" | "macro" | "pov" | undefined;
+        cameraMove?: "auto" | "static" | "pan" | "tracking" | "dollyIn" | "dollyOut" | "zoom" | undefined;
+    }>, "many">>;
+    readonly model: z.ZodString;
+    readonly prompt: z.ZodOptional<z.ZodString>;
+    readonly negativePrompt: z.ZodOptional<z.ZodString>;
+    readonly aspectRatio: z.ZodOptional<z.ZodString>;
+    readonly resolution: z.ZodOptional<z.ZodString>;
+    readonly attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        source: z.ZodEnum<["ref", "video_generation", "image_generation", "media_asset"]>;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        source: "ref" | "video_generation" | "image_generation" | "media_asset";
+    }, {
+        id: string;
+        source: "ref" | "video_generation" | "image_generation" | "media_asset";
+    }>, "many">>;
+    readonly seed: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    readonly params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean]>>>;
+    readonly idempotencyKey: z.ZodOptional<z.ZodString>;
+    readonly wait: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const imageGenerationInputSchema: {
+    readonly quality: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    readonly webSearch: z.ZodOptional<z.ZodBoolean>;
+    readonly maskDataUrl: z.ZodOptional<z.ZodString>;
+    readonly model: z.ZodString;
+    readonly prompt: z.ZodOptional<z.ZodString>;
+    readonly negativePrompt: z.ZodOptional<z.ZodString>;
+    readonly aspectRatio: z.ZodOptional<z.ZodString>;
+    readonly resolution: z.ZodOptional<z.ZodString>;
+    readonly attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        source: z.ZodEnum<["ref", "video_generation", "image_generation", "media_asset"]>;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        source: "ref" | "video_generation" | "image_generation" | "media_asset";
+    }, {
+        id: string;
+        source: "ref" | "video_generation" | "image_generation" | "media_asset";
+    }>, "many">>;
+    readonly seed: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    readonly params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodBoolean]>>>;
+    readonly idempotencyKey: z.ZodOptional<z.ZodString>;
+    readonly wait: z.ZodOptional<z.ZodBoolean>;
+};

package/dist/schemas.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+const MAX_ATTACHMENTS_PER_SUBMIT = 50;
+/** MCP request schemas mirror the public HTTP schemas.
+ * Contract tests compare their fields and boundaries with those schemas. */
+export const estimateCostInputSchema = {
+    modelId: z.string().min(1).max(300).describe("A model id from list_models."),
+    resolution: z.string().max(40).optional(),
+    aspectRatio: z.string().max(20).optional(),
+    durationSeconds: z.number().min(-1).max(600).optional(),
+    quality: z.enum(["low", "medium", "high"]).optional(),
+    hasVideoRefs: z.boolean().optional(),
+    generateAudio: z.boolean().optional(),
+    params: z.record(z.string().max(64), z.union([
+        z.number(), z.string().max(64), z.boolean(),
+    ])).optional(),
+};
+const attachment = z.object({
+    source: z.enum(["ref", "video_generation", "image_generation", "media_asset"]),
+    id: z.string().min(1).max(128),
+});
+export const generateInputSchema = {
+    model: z.string().min(1).max(120).describe("A model id from list_models."),
+    prompt: z.string().min(1).max(25_000).optional(),
+    negativePrompt: z.string().max(1000).optional(),
+    aspectRatio: z.string().min(1).max(16).optional(),
+    resolution: z.string().min(1).max(16).optional(),
+    attachments: z.array(attachment).max(MAX_ATTACHMENTS_PER_SUBMIT).optional(),
+    seed: z.number().int().min(0).max(4294967295).nullable().optional(),
+    params: z.record(z.string().max(64), z.union([
+        z.number(), z.string().max(64), z.boolean(),
+    ])).optional(),
+    idempotencyKey: z.string().max(64).optional(),
+    wait: z.boolean().optional(),
+};
+export const videoGenerationInputSchema = {
+    ...generateInputSchema,
+    slotBindings: z.record(z.string().max(32), z.string().max(128)).optional(),
+    keyframes: z.record(z.string().max(128), z.number().min(0).max(3600)).refine((value) => Object.keys(value).length <= 20, "Maximum 20 keyframes.").optional(),
+    duration: z.number().int().min(-1).max(60).optional(),
+    generateAudio: z.boolean().optional(),
+    movementAmplitude: z.enum(["auto", "small", "medium", "large"]).optional(),
+    shotType: z.enum(["intelligence", "customize"]).optional(),
+    multiPrompt: z.array(z.object({
+        prompt: z.string().min(1).max(2500),
+        duration: z.number().int().min(1).max(15),
+        shotSize: z.enum(["auto", "wide", "medium", "closeup", "macro", "pov"]).optional(),
+        cameraMove: z.enum(["auto", "static", "pan", "tracking", "dollyIn", "dollyOut", "zoom"]).optional(),
+    })).max(6).optional(),
+};
+export const imageGenerationInputSchema = {
+    ...generateInputSchema,
+    quality: z.enum(["low", "medium", "high"]).optional(),
+    webSearch: z.boolean().optional(),
+    maskDataUrl: z.string().max(7_000_000).optional(),
+};

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};