@ronana/mcp 0.1.1 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ronana
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,7 +1,6 @@
 # Ronana CLI and MCP
 
-NOTE: MCP and the command line are in admin preview. At launch they will
-require a paid plan.
+Requires a Ronana paid plan.
 
 WARNING: Generations spend your account credits.
 
@@ -38,6 +37,8 @@ ronana generate cost   google/nano-banana-2-lite/edit --prompt "make it dusk" --
 ronana generate create google/nano-banana-2-lite/edit --prompt "make it dusk" --image ./photo.png --out ./renders
 ronana generate get <id> | wait <id> [--out dir]
 ronana generate list
+ronana upscale <id | file | url> --resolution 4k --out ./renders
+ronana folder list | add <folder> <id…>
 ```
 
 Every field from `model get` is a flag (`--aspect_ratio 16:9`, `--seed 7`).
@@ -81,9 +82,27 @@ add it to the app's MCP settings:
 }
 ```
 
+On Windows, start it through `cmd`, or the app cannot find `npx`:
+
+```json
+{
+  "mcpServers": {
+    "ronana": {
+      "command": "cmd",
+      "args": ["/c", "npx", "-y", "-p", "@ronana/mcp", "ronana-mcp"],
+      "env": { "RONANA_MCP_UPLOAD_ROOT": "C:\\Users\\you\\Pictures\\ronana" }
+    }
+  }
+}
+```
+
+In Claude Code: `claude mcp add ronana -- cmd /c npx -y -p @ronana/mcp ronana-mcp`.
+In PowerShell, quote the separator (`'--'`), or PowerShell drops it.
+
 The local server adds one tool, `upload_local_reference`, which uploads a file
 from inside `RONANA_MCP_UPLOAD_ROOT`. Set it to the folder that holds your
-media, never a home directory or a drive root. Files larger than 3 MB stream
+media. The tool is off until it is set, and it refuses a home directory or a
+drive root. Files larger than 3 MB stream
 straight to storage, and Ronana checks each file before it adds it to your
 library.
 
@@ -95,18 +114,22 @@ library.
 | `get_model` | Get one model's contract: its input schema. |
 | `estimate_cost` | Estimate the credit cost of a generation. Takes the same `model` and `input` as `generate`. |
 | `generate` | Start an image or video generation. |
-| `get_generation` | Get one generation and its download link. |
+| `get_generation` | Get one generation and its download link. Pass `wait_seconds` (up to 45) to wait for the result in one call. |
+| `upscale` | Upscale a video to a higher resolution. |
 | `list_generations` | List recent generations. |
 | `list_references` | List library references. |
 | `upload_reference` | Add a file to the library from a URL (up to 25 MB) or from base64 (under 3 MB). |
 | `create_upload` | Get a private upload link for a larger local file (up to 200 MB). |
 | `finish_upload` | Add a file uploaded with `create_upload` to the library. |
+| `list_folders` | List the folders in the library. |
+| `add_to_folder` | File library items into a folder. |
 | `get_account` | Get the plan and credit balance. |
 
 A generate call takes a `model` and an `input`, exactly as `get_model` shows it
 in `input_schema`. A media field takes a public https URL or a Ronana id
-(`ref_…`, `img_…`, `gen_…`). Generation tools return an id immediately. Poll
-`get_generation` until the status is `completed` or `failed`.
+(`ref_…`, `img_…`, `gen_…`). Generation tools return an id immediately. Call
+`get_generation` with `wait_seconds` until the status is `completed` or
+`failed`. Apps that support MCP Apps show the image or video right in the chat.
 
 ```json
 { "model": "google/nano-banana-2/edit", "input": { "prompt": "a lantern shop at dusk", "images": ["https://example.com/ref.png"] } }

package/dist/cli.js

@@ -12,15 +12,17 @@
 //   ronana generate cost <model> [same flags as create]
 //   ronana generate get | wait <id> [--out dir]
 //   ronana generate list [--limit n]
+//   ronana upscale <id | file | https-url> [--resolution r] [--model m] [--wait] [--out dir]
+//   ronana folder list | add <folder> <id…>
 import { randomUUID } from "node:crypto";
-import { createWriteStream } from "node:fs";
+import { createWriteStream, existsSync, statSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
 import { basename, extname, join, resolve } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { login, logout, readCredentials } from "./oauth.js";
 import { callTool, remoteClient, ToolError, uploadFile } from "./remote.js";
-import { buildInput, flag, has, parseArgs, replaceLocalMedia, typeOf } from "./input.js";
+import { buildInput, flag, has, isRemoteValue, parseArgs, replaceLocalMedia, typeOf } from "./input.js";
 const HELP = `Usage: ronana <command>
 
   auth login                    Sign in with your browser (--base-url, --no-browser)
@@ -35,6 +37,9 @@ const HELP = `Usage: ronana <command>
   generate get <id>             Status and download links
   generate wait <id>            Wait for a generation to finish
   generate list                 Recent generations (--limit n)
+  upscale <id|file|url>         Upscale a video (costs credits; --resolution, --model)
+  folder list                   Your library folders
+  folder add <folder> <id…>     File items into a folder (made if missing)
 
 Generate flags:
   --<field> <value>             Any field from \`model get\`. Repeat for lists.
@@ -65,6 +70,8 @@ function describeField(name, schema, required) {
         parts.push(`default ${JSON.stringify(schema.default)}`);
     return `  --${name.padEnd(22)} ${parts.join("  ")}${required ? "  (required)" : ""}`;
 }
+/** Model ids are lowercase paths; forgive the casing and a trailing slash. */
+const modelId = (raw) => raw.trim().replace(/\/+$/, "").toLowerCase();
 const TERMINAL = new Set(["completed", "failed", "canceled"]);
 function seconds(args, name, fallback) {
     const raw = flag(args, name);
@@ -80,8 +87,12 @@ async function waitFor(remote, id, args) {
     let last = "";
     for (;;) {
         let gen;
+        const asked = Date.now();
         try {
-            gen = await callTool(remote, "get_generation", { id });
+            // The server holds the call until the job settles (up to 25s), so this
+            // loop makes one request per 25s rather than one every few seconds.
+            const wait_seconds = Math.max(0, Math.min(25, Math.floor((deadline - asked) / 1000)));
+            gen = await callTool(remote, "get_generation", { id, wait_seconds });
         }
         catch (error) {
             // A server answer (not found, no access) is final; anything else is the
@@ -99,7 +110,11 @@ ${id} is still running. Resume with \`ronana generate wait ${id}\`.`);
             return gen;
         if (Date.now() > deadline)
             throw new Error(`Still ${gen.status} after ${timeoutMs / 1000}s. Check later with \`ronana generate wait ${id}\`.`);
-        await new Promise((r) => setTimeout(r, intervalMs));
+        // A server that answered at once (an older one, or a short wait) still gets
+        // the local pause, so the loop never spins.
+        const left = intervalMs - (Date.now() - asked);
+        if (left > 0)
+            await new Promise((r) => setTimeout(r, left));
     }
 }
 const EXT_BY_TYPE = {
@@ -107,6 +122,8 @@ const EXT_BY_TYPE = {
     "video/mp4": ".mp4", "video/webm": ".webm", "video/quicktime": ".mov",
 };
 async function download(gen, dir) {
+    if (existsSync(dir) && !statSync(dir).isDirectory())
+        throw new Error(`--out must be a folder; ${dir} is a file.`);
     await mkdir(dir, { recursive: true });
     const saved = [];
     for (const output of gen.outputs) {
@@ -160,6 +177,8 @@ async function generateCommand(sub, args) {
     const [target] = args.positional;
     if (sub === "list") {
         const limit = Number(flag(args, "limit") ?? 25);
+        if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+            throw new Error("--limit must be a whole number from 1 to 100.");
         const rows = await withRemote((r) => callTool(r, "list_generations", { limit }));
         return emit(rows, () => rows.forEach((g) => print(`${g.id.padEnd(28)} ${g.status.padEnd(11)} ${g.created_at}`)));
     }
@@ -174,7 +193,7 @@ async function generateCommand(sub, args) {
     if (sub !== "create" && sub !== "cost")
         throw new Error("Use generate create | cost | get | wait | list.");
     await withRemote(async (remote) => {
-        const contract = await callTool(remote, "get_model", { id: target });
+        const contract = await callTool(remote, "get_model", { id: modelId(target) });
         const input = await buildInput(contract, args);
         await replaceLocalMedia(contract, input, async (path) => {
             note(`Uploading ${basename(path)}…`);
@@ -199,17 +218,23 @@ async function generateCommand(sub, args) {
 async function modelCommand(sub, args) {
     if (sub === "list" || sub === undefined) {
         const kind = flag(args, "kind");
+        if (kind !== undefined && kind !== "image" && kind !== "video")
+            throw new Error("--kind must be image or video.");
         const filter = args.positional[0]?.toLowerCase();
         const models = (await withRemote((r) => callTool(r, "list_models", kind ? { kind } : {})))
             .filter((m) => !filter || m.id.toLowerCase().includes(filter) || m.name.toLowerCase().includes(filter));
-        return emit(models, () => models.forEach((m) => print(`${m.id.padEnd(52)} ${m.kind.padEnd(6)} ${m.name}`)));
+        return emit(models, () => {
+            if (!models.length)
+                note(filter ? `No models match "${args.positional[0]}".` : "No models are available on your plan.");
+            models.forEach((m) => print(`${m.id.padEnd(52)} ${m.kind.padEnd(6)} ${m.name}${m.best_for ? `  ${m.best_for}` : ""}`));
+        });
     }
     if (sub !== "get")
         throw new Error("Use model list | get.");
     const id = args.positional[0];
     if (!id)
         throw new Error("Usage: ronana model get <model>");
-    const contract = await withRemote((r) => callTool(r, "get_model", { id }));
+    const contract = await withRemote((r) => callTool(r, "get_model", { id: modelId(id) }));
     emit(contract, () => {
         print(`${contract.name}  (${contract.kind})`);
         print(contract.id);
@@ -225,10 +250,54 @@ async function modelCommand(sub, args) {
             print(`Priced by: ${contract.priced_fields.join(", ")}`);
     });
 }
+async function upscaleCommand(args) {
+    const [source] = args.positional;
+    if (!source)
+        throw new Error("Usage: ronana upscale <gen_…|ref_… id | file | https-url> [--resolution 4k] [--out dir]");
+    await withRemote(async (remote) => {
+        // A local file uploads first; an id or a URL goes as-is.
+        const resolved = isRemoteValue(source) ? source : (note(`Uploading ${basename(source)}…`), (await uploadFile(remote, resolve(source))).id);
+        const queued = await callTool(remote, "upscale", {
+            source: resolved,
+            ...(flag(args, "model") ? { model: flag(args, "model") } : {}),
+            ...(flag(args, "resolution") ? { resolution: flag(args, "resolution") } : {}),
+            idempotency_key: flag(args, "idempotency_key") ?? randomUUID(),
+        });
+        if (!has(args, "wait") && !has(args, "out")) {
+            return emit(queued, () => { print(queued.id); note(`Check it with \`ronana generate wait ${queued.id}\`.`); });
+        }
+        note(`Queued ${queued.id}.`);
+        await finish(await waitFor(remote, queued.id, args), args);
+    });
+}
+async function folderCommand(sub, args) {
+    if (sub === "list" || sub === undefined) {
+        const folders = await withRemote((r) => callTool(r, "list_folders"));
+        return emit(folders, () => folders.forEach((f) => print(`${f.id.padEnd(28)} ${String(f.count).padStart(5)}  ${f.name}`)));
+    }
+    if (sub !== "add")
+        throw new Error("Use folder list | add.");
+    const [folder, ...ids] = args.positional;
+    if (!folder?.trim() || ids.length === 0)
+        throw new Error("Usage: ronana folder add <folder> <id…>");
+    if (folder.trim().length > 60)
+        throw new Error("Folder names are at most 60 characters.");
+    const filed = await withRemote((r) => callTool(r, "add_to_folder", { ids, folder, create: true }));
+    emit(filed, () => {
+        print(`Filed ${filed.filed.length} in "${filed.folder.name}".`);
+        if (filed.not_found?.length)
+            note(`Not found: ${filed.not_found.join(", ")}`);
+    });
+    if (filed.not_found?.length)
+        process.exitCode = 1;
+}
 async function main() {
-    const [command, sub, ...rest] = process.argv.slice(2);
-    const takesSub = command === "auth" || command === "model" || command === "generate";
-    const args = parseArgs(takesSub ? rest : [sub, ...rest].filter((v) => v !== undefined));
+    const [command, ...rest] = process.argv.slice(2);
+    const takesSub = command === "auth" || command === "model" || command === "generate" || command === "folder";
+    const args = parseArgs(rest);
+    // The subcommand is the first word that is not a flag, wherever the flags
+    // sit (`ronana generate --json list`, `ronana generate --help`).
+    const sub = takesSub ? args.positional.shift() : undefined;
     JSON_OUT = has(args, "json");
     if (!command || ["help", "--help", "-h"].includes(command) || has(args, "help"))
         return void process.stdout.write(HELP);
@@ -262,18 +331,29 @@ async function main() {
             const source = args.positional[0];
             if (!source)
                 throw new Error("Usage: ronana upload <file | https-url>");
+            if (/^http:\/\//i.test(source))
+                throw new Error("Use an https:// link; plain http is not accepted.");
             const ref = await withRemote((r) => /^https:\/\//i.test(source)
                 ? callTool(r, "upload_reference", { url: source, filename: basename(new URL(source).pathname) || "upload" })
                 : uploadFile(r, resolve(source)));
             return emit(ref, () => print(ref.id));
         }
         case "generate": return generateCommand(sub, args);
+        case "upscale": return upscaleCommand(args);
+        case "folder":
+        case "folders": return folderCommand(command === "folders" ? "list" : sub, args);
         default: throw new Error(`Unknown command "${command}". Run \`ronana --help\`.`);
     }
 }
 main().catch((error) => {
     if (error instanceof ToolError) {
-        const { code, message, url, billing } = error.error;
+        const { code, url, billing, field } = error.error;
+        let message = String(error.error.message ?? "The request failed.");
+        if (code === "MODEL_UNKNOWN")
+            message = "This model is not available. Run `ronana model list` for the current ids.";
+        // Name the field the server refused, unless the message already does.
+        else if (typeof field === "string" && !message.includes(field))
+            message = `${field}: ${message}`;
         if (JSON_OUT)
             process.stdout.write(`${JSON.stringify({ ok: false, error: error.error }, null, 2)}\n`);
         else

package/dist/input.js

@@ -49,7 +49,7 @@ function coerce(field, raw, schema) {
     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}.`);
+            throw new Error(`--${field} must be ${type === "integer" ? "a whole number" : "a number"}.`);
         return n;
     }
     if (type === "boolean") {
@@ -70,7 +70,9 @@ function coerce(field, raw, schema) {
 async function readInputFlag(raw) {
     if (!raw)
         return {};
-    const text = raw.startsWith("@") ? await readFile(raw.slice(1), "utf8") : raw;
+    const text = raw.startsWith("@")
+        ? await readFile(raw.slice(1), "utf8").catch(() => { throw new Error(`--input: cannot read ${raw.slice(1)}.`); })
+        : raw;
     let parsed;
     try {
         parsed = JSON.parse(text);

package/dist/oauth.js

@@ -64,6 +64,14 @@ async function tokenRequest(baseUrl, fields) {
 }
 export async function login(baseUrl = process.env.RONANA_BASE_URL ?? "https://ronana.ai", openInBrowser = true) {
     baseUrl = baseUrl.replace(/\/$/, "");
+    const parsed = (() => { try {
+        return new URL(baseUrl);
+    }
+    catch {
+        return null;
+    } })();
+    if (!parsed || !/^https?:$/.test(parsed.protocol))
+        throw new Error("--base-url must be a web address, like https://ronana.ai.");
     const verifier = randomBytes(32).toString("base64url");
     const challenge = createHash("sha256").update(verifier).digest("base64url");
     const state = randomBytes(24).toString("base64url");
@@ -113,8 +121,10 @@ export async function login(baseUrl = process.env.RONANA_BASE_URL ?? "https://ro
                 response_types: ["code"],
                 scope: SCOPES,
             }),
+        }).catch(() => { throw new Error(`Could not reach ${baseUrl}. Check --base-url and your connection.`); });
+        const registered = await registration.json().catch(() => {
+            throw new Error(`No Ronana sign-in at ${baseUrl}. Check --base-url.`);
         });
-        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`);

package/dist/remote.js

@@ -1,7 +1,7 @@
 // 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 { createReadStream, existsSync, statSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { basename, extname } from "node:path";
 import { Readable } from "node:stream";
@@ -27,7 +27,7 @@ export async function remoteClient() {
             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."
+                ? `Ronana's CLI and MCP need a paid plan: ${credentials.baseUrl}/pricing`
                 : `No Ronana MCP endpoint at ${credentials.baseUrl}. Sign in again with the right --base-url.`);
         }
         throw error;
@@ -53,6 +53,11 @@ export async function callTool(remote, name, args = {}) {
     if (body?.error)
         throw new ToolError(body.error);
     const text = Array.isArray(response.content) ? response.content.map((c) => ("text" in c ? c.text : "")).join(" ") : "";
+    // The SDK's own argument check answers in prose ("Input validation error:
+    // Invalid arguments for tool x: limit: Invalid input"); keep only the field.
+    const invalid = /Invalid arguments for tool \S+: ([\w.[\]-]+):/.exec(text);
+    if (invalid)
+        throw new ToolError({ code: "INVALID_REQUEST", message: `The value for "${invalid[1]}" is not valid.`, field: invalid[1] });
     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,
@@ -67,7 +72,14 @@ const CONTENT_TYPES = {
  *  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 (!existsSync(path))
+        throw new Error(`No file at ${path}.`);
+    const stat = statSync(path);
+    if (!stat.isFile())
+        throw new Error(`${path} is a folder, not a file.`);
+    const { size } = stat;
+    if (size === 0)
+        throw new Error(`${filename} is empty.`);
     if (size <= INLINE_LIMIT) {
         const data = (await readFile(path)).toString("base64");
         return callTool(remote, "upload_reference", { data, filename });

package/dist/server.js

@@ -1,15 +1,33 @@
 #!/usr/bin/env node
 import { realpath, stat } from "node:fs/promises";
-import { isAbsolute, relative, resolve, sep } from "node:path";
+import { homedir } from "node:os";
+import { isAbsolute, parse, relative, resolve, sep } from "node:path";
 import { fromJsonSchema, McpServer } from "@modelcontextprotocol/server";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
 import { z } from "zod4";
 import { login, logout, readCredentials } from "./oauth.js";
 import { remoteClient, ToolError, uploadFile } from "./remote.js";
-const UPLOAD_ROOT = resolve(process.env.RONANA_MCP_UPLOAD_ROOT ?? process.cwd());
+/* Uploads are off until the user names a folder: defaulting to the working
+   directory handed an AI app whatever folder it happened to start in, often
+   the home folder. A home folder or a drive root is refused for the same
+   reason. */
+const UPLOAD_ROOT = process.env.RONANA_MCP_UPLOAD_ROOT ? resolve(process.env.RONANA_MCP_UPLOAD_ROOT) : null;
 async function resolveInsideRoot(inputPath) {
-    const root = await realpath(UPLOAD_ROOT);
-    const candidate = await realpath(isAbsolute(inputPath) ? inputPath : resolve(root, inputPath));
+    if (!UPLOAD_ROOT)
+        throw new Error("Local uploads are off. Set RONANA_MCP_UPLOAD_ROOT to the folder that holds your media.");
+    const root = await realpath(UPLOAD_ROOT).catch(() => {
+        throw new Error(`RONANA_MCP_UPLOAD_ROOT (${UPLOAD_ROOT}) does not exist.`);
+    });
+    // A root that holds the home folder (the home folder itself, C:\Users, /home
+    // or a drive root) would expose every file in it.
+    const home = await realpath(homedir()).catch(() => homedir());
+    const homeFromRoot = relative(root, home);
+    if (root === parse(root).root || homeFromRoot === "" || !(homeFromRoot.startsWith("..") || isAbsolute(homeFromRoot))) {
+        throw new Error("RONANA_MCP_UPLOAD_ROOT must be a media folder, not a home folder, a folder that contains one, or a drive root.");
+    }
+    const candidate = await realpath(isAbsolute(inputPath) ? inputPath : resolve(root, inputPath)).catch(() => {
+        throw new Error(`No file at ${inputPath} in RONANA_MCP_UPLOAD_ROOT.`);
+    });
     const rel = relative(root, candidate);
     if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel))
         throw new Error("The path is outside RONANA_MCP_UPLOAD_ROOT.");
@@ -18,8 +36,18 @@ async function resolveInsideRoot(inputPath) {
 async function serve() {
     const remote = await remoteClient();
     const { tools } = await remote.listTools();
+    // Present as Ronana itself: the remote server's own title, logo and website,
+    // so an app lists this bridge with the Ronana mark rather than a bare name.
+    const remoteInfo = remote.getServerVersion();
+    const icons = remoteInfo?.icons;
     serveStdio(() => {
-        const server = new McpServer({ name: "Ronana local bridge", version: "1.0.0" });
+        const server = new McpServer({
+            name: "ronana",
+            title: remoteInfo?.title ?? "Ronana",
+            version: "1.0.0",
+            ...(remoteInfo?.websiteUrl ? { websiteUrl: remoteInfo.websiteUrl } : {}),
+            ...(icons ? { icons } : {}),
+        });
         for (const tool of tools) {
             server.registerTool(tool.name, {
                 title: tool.title,
@@ -27,15 +55,19 @@ async function serve() {
                 inputSchema: fromJsonSchema(tool.inputSchema),
                 outputSchema: tool.outputSchema ? fromJsonSchema(tool.outputSchema) : undefined,
                 annotations: tool.annotations,
+                ...(tool.icons ? { icons: tool.icons } : {}),
             }, async (args) => remote.callTool({
                 name: tool.name,
                 arguments: args,
             }));
         }
         server.registerTool("upload_local_reference", {
-            description: `Upload a local file below ${UPLOAD_ROOT} to the account library.`,
+            description: UPLOAD_ROOT
+                ? `Upload a local file below ${UPLOAD_ROOT} to the account library.`
+                : "Upload a local file to the account library. Off until RONANA_MCP_UPLOAD_ROOT names a media folder.",
             inputSchema: z.object({ path: z.string() }),
             annotations: { readOnlyHint: false, destructiveHint: false },
+            ...(icons ? { icons } : {}),
         }, async ({ path }) => {
             try {
                 const safePath = await resolveInsideRoot(path);

package/package.json

@@ -1,14 +1,36 @@
 {
   "name": "@ronana/mcp",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Ronana command line and local MCP bridge.",
-  "license": "UNLICENSED",
+  "license": "MIT",
   "homepage": "https://ronana.ai",
-  "keywords": ["ronana", "mcp", "cli", "image generation", "video generation"],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ronana-ai/cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ronana-ai/cli/issues"
+  },
+  "keywords": [
+    "ronana",
+    "mcp",
+    "cli",
+    "image generation",
+    "video generation"
+  ],
   "type": "module",
-  "bin": { "ronana": "dist/cli.js", "ronana-mcp": "dist/server.js" },
-  "files": ["dist", "README.md"],
-  "publishConfig": { "access": "public" },
+  "bin": {
+    "ronana": "dist/cli.js",
+    "ronana-mcp": "dist/server.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "prepublishOnly": "npm run build",
@@ -21,8 +43,11 @@
     "zod4": "npm:zod@4.4.3"
   },
   "devDependencies": {
+    "@types/node": "^22.10.5",
     "typescript": "^5",
     "tsx": "^4"
   },
-  "engines": { "node": ">=20" }
+  "engines": {
+    "node": ">=20"
+  }
 }

package/dist/client.d.ts

@@ -1,61 +0,0 @@
-import type { ApiErrorBody, ApiPublicModel, GenerationState } from "./types.js";
-export declare class RonanaApiError extends Error {
-    readonly code: string;
-    readonly status: number;
-    readonly body: ApiErrorBody["error"] | null;
-    constructor(code: string, message: string, status: number, body: ApiErrorBody["error"] | null);
-    /** A sentence a person or an agent can act on. The `action` field is the
-     *  server's own decision about which door to open, so this never guesses. */
-    get guidance(): string;
-}
-export interface ClientOptions {
-    apiKey: string;
-    baseUrl: string;
-}
-/** Read the configuration from the environment. Throws with a clear message
- *  when the key is missing, because that is the one mistake every new user
- *  makes. */
-export declare function clientOptionsFromEnv(env?: NodeJS.ProcessEnv): ClientOptions;
-export declare class RonanaClient {
-    private readonly options;
-    constructor(options: ClientOptions);
-    private request;
-    listModels(): Promise<{
-        models: ApiPublicModel[];
-        tier: string;
-    }>;
-    account(): Promise<unknown>;
-    quote(input: Record<string, unknown>): Promise<{
-        available: boolean;
-        credits: number;
-    }>;
-    submitVideo(body: Record<string, unknown>): Promise<{
-        id: string;
-        status: string;
-    }>;
-    submitImage(body: Record<string, unknown>): Promise<{
-        id: string;
-        status: string;
-    }>;
-    generation(id: string): Promise<GenerationState>;
-    /** Upload a file inline. Use this up to 4 MB; larger files need the presigned
-     *  flow below, because a serverless function body cannot exceed 4.5 MB. */
-    uploadInline(bytes: Uint8Array, filename: string): Promise<{
-        ref: {
-            id: string;
-        };
-        reused?: boolean;
-    }>;
-    /** Upload a file larger than 4 MB: sign, PUT straight to storage, finalize.
-     *
-     *  CAUTION: The PUT must send exactly the content type and the content length
-     *  that were signed. Any other value fails the storage signature check. */
-    uploadPresigned(bytes: Uint8Array, filename: string, contentType: string): Promise<{
-        ref: {
-            id: string;
-        };
-        reused?: boolean;
-    }>;
-}
-/** The most bytes an inline upload may carry. Above this, use the signed flow. */
-export declare const INLINE_UPLOAD_MAX_BYTES: number;

package/dist/client.js

@@ -1,128 +0,0 @@
-// The HTTP client for the RonanaLive public API.
-//
-// THE LOAD-BEARING RULE OF THIS PACKAGE: it is a thin HTTP client of
-// `/api/v1/*`. It imports no database, no credit module, and no ORM. If it ever
-// imported the application's database layer, somebody would eventually run this
-// package against production.
-//
-// Everything it needs is two environment variables:
-//   RONANA_API_KEY   the key, `rk_…`, minted at /developers/keys
-//   RONANA_BASE_URL  the origin, default https://ronana.ai
-export class RonanaApiError extends Error {
-    code;
-    status;
-    body;
-    constructor(code, message, status, body) {
-        super(message);
-        this.code = code;
-        this.status = status;
-        this.body = body;
-        this.name = "RonanaApiError";
-    }
-    /** A sentence a person or an agent can act on. The `action` field is the
-     *  server's own decision about which door to open, so this never guesses. */
-    get guidance() {
-        const billing = this.body?.billing;
-        if (!billing)
-            return this.message;
-        switch (billing.action) {
-            case "buy_credits": return `${this.message} Buy more credits at ${billing.url}.`;
-            case "upgrade_plan": return `${this.message} Move to a larger plan at ${billing.url}.`;
-            case "either": return `${this.message} Buy credits or move to a larger plan at ${billing.url}.`;
-            case "verify_email": return `${this.message} Verify the account email at ${billing.url}.`;
-            case "wait": return `${this.message} Wait, then try again.`;
-            case "contact_support": return `${this.message} Contact support.`;
-            default: return this.message;
-        }
-    }
-}
-/** Read the configuration from the environment. Throws with a clear message
- *  when the key is missing, because that is the one mistake every new user
- *  makes. */
-export function clientOptionsFromEnv(env = process.env) {
-    const apiKey = env.RONANA_API_KEY?.trim();
-    if (!apiKey) {
-        throw new Error("RONANA_API_KEY is not set. Create a key at https://ronana.ai/developers/keys, " +
-            "then put it in your MCP client configuration as RONANA_API_KEY.");
-    }
-    const baseUrl = (env.RONANA_BASE_URL?.trim() || "https://ronana.ai").replace(/\/+$/, "");
-    return { apiKey, baseUrl };
-}
-export class RonanaClient {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    async request(method, path, body) {
-        const res = await fetch(`${this.options.baseUrl}${path}`, {
-            method,
-            headers: {
-                authorization: `Bearer ${this.options.apiKey}`,
-                ...(body === undefined ? {} : { "content-type": "application/json" }),
-            },
-            ...(body === undefined ? {} : { body: JSON.stringify(body) }),
-        });
-        const text = await res.text();
-        const parsed = text ? JSON.parse(text) : null;
-        if (!res.ok) {
-            const envelope = parsed?.error ?? null;
-            throw new RonanaApiError(envelope?.code ?? "UNKNOWN", envelope?.message ?? `Request failed with status ${res.status}.`, res.status, envelope);
-        }
-        return parsed;
-    }
-    listModels() {
-        return this.request("GET", "/api/v1/models");
-    }
-    account() {
-        return this.request("GET", "/api/v1/me");
-    }
-    quote(input) {
-        return this.request("POST", "/api/v1/pricing/quote", input);
-    }
-    submitVideo(body) {
-        return this.request("POST", "/api/v1/generations", body);
-    }
-    submitImage(body) {
-        return this.request("POST", "/api/v1/images", body);
-    }
-    generation(id) {
-        return this.request("GET", `/api/v1/generations/${encodeURIComponent(id)}`);
-    }
-    /** Upload a file inline. Use this up to 4 MB; larger files need the presigned
-     *  flow below, because a serverless function body cannot exceed 4.5 MB. */
-    async uploadInline(bytes, filename) {
-        const res = await fetch(`${this.options.baseUrl}/api/v1/refs`, {
-            method: "POST",
-            headers: {
-                authorization: `Bearer ${this.options.apiKey}`,
-                "content-type": "application/octet-stream",
-                "x-filename": encodeURIComponent(filename),
-            },
-            body: bytes,
-        });
-        const text = await res.text();
-        const parsed = text ? JSON.parse(text) : null;
-        if (!res.ok) {
-            const envelope = parsed?.error ?? null;
-            throw new RonanaApiError(envelope?.code ?? "UNKNOWN", envelope?.message ?? "Upload failed.", res.status, envelope);
-        }
-        return parsed;
-    }
-    /** Upload a file larger than 4 MB: sign, PUT straight to storage, finalize.
-     *
-     *  CAUTION: The PUT must send exactly the content type and the content length
-     *  that were signed. Any other value fails the storage signature check. */
-    async uploadPresigned(bytes, filename, contentType) {
-        const signed = await this.request("POST", "/api/v1/refs/upload-url", { filename, contentType, size: bytes.byteLength });
-        const put = await fetch(signed.uploadUrl, {
-            method: "PUT",
-            headers: { "content-type": signed.contentType, "content-length": String(bytes.byteLength) },
-            body: bytes,
-        });
-        if (!put.ok)
-            throw new Error(`The upload to storage failed with status ${put.status}.`);
-        return this.request("POST", "/api/v1/refs", { tmpKey: signed.tmpKey, filename });
-    }
-}
-/** The most bytes an inline upload may carry. Above this, use the signed flow. */
-export const INLINE_UPLOAD_MAX_BYTES = 4 * 1024 * 1024;

package/dist/schemas.d.ts

@@ -1,101 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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/types.d.ts

@@ -1,173 +0,0 @@
-export type RefKind = "image" | "video" | "audio";
-export interface ApiSlotSpec {
-    id: string;
-    kind: RefKind;
-    required: boolean;
-}
-export interface ApiRefSpec {
-    kinds: readonly RefKind[];
-    max: {
-        images?: number;
-        videos?: number;
-        audio?: number;
-        total?: number;
-        videosTotalSec?: number;
-        audioTotalSec?: number;
-        videoMaxBytes?: number;
-        audioMaxBytes?: number;
-        videoMinSec?: number;
-        videoMinWidthPx?: number;
-        videoMaxWidthPx?: number;
-        imageMinPx?: number;
-        imageMaxPx?: number;
-        imageMaxBytes?: number;
-        imageMaxPixels?: number;
-        imageMinAspect?: number;
-        imageMaxAspect?: number;
-        videoMaxSec?: number;
-    };
-    inline: boolean;
-    slots: readonly ApiSlotSpec[];
-    attachmentGroups: {
-        tokenPrefix?: string;
-        maxGroups: number;
-        kinds: Array<"image" | "video" | "audio">;
-        minPerGroup: number;
-        maxPerGroup: number;
-        primaryFirst?: boolean;
-    } | null;
-}
-export type ApiParamSpec = {
-    id: string;
-    kind: "number";
-    min: number;
-    max: number;
-    step: number;
-} | {
-    id: string;
-    kind: "select";
-    options: readonly string[];
-} | {
-    id: string;
-    kind: "toggle";
-};
-export interface ApiInputConditionedRule {
-    mode: "t2v" | "i2v" | "r2v";
-    aspect?: string[];
-    resolution?: string[];
-    duration?: number[];
-    when: readonly {
-        imageRefs: "0" | "1" | "2+" | "any";
-        audioRefs: "0" | "1+" | "any";
-    }[];
-}
-export interface ApiModelSpec {
-    id: string;
-    kind: "video" | "image";
-    name: string;
-    prompt: {
-        required: boolean;
-        maxChars?: number;
-    };
-    aspect: readonly string[];
-    aspectWithImage: readonly string[];
-    resolution: readonly string[];
-    duration: readonly number[];
-    quality: readonly ("low" | "medium" | "high")[];
-    dimensionsFromReference: boolean;
-    refs: ApiRefSpec;
-    params: readonly ApiParamSpec[];
-    variants: readonly ApiInputConditionedRule[];
-    multiShot: boolean;
-    seed: boolean;
-    negativePrompt: boolean;
-    generateAudio: boolean;
-    movementAmplitude: boolean;
-    webSearch: boolean;
-    mask: {
-        format: "png-data-url";
-        dimensions: "match-first-image";
-        polarity: "alpha-punch" | "white-on-black";
-    } | null;
-}
-/**
- * What the server actually SENDS for a model.
- *
- * `ApiModelSpec` above is the total shape. The wire is smaller, twice over: it
- * drops every field carrying no information (`false`, `null`, an empty list),
- * and it drops the fields only the studio uses (`category`, `preset`, and the
- * `group`/`label` split, which arrives as one `name`). A capability the model
- * does not have is ABSENT rather than sent as a "no", so read presence as
- * support:
- *
- *     if (model.seed) { ... }          // correct, whether absent or true
- *     for (const s of model.refs?.slots ?? []) { ... }
- *
- * Derived from `ApiModelSpec`, never hand-written, so a new field on the server
- * reaches this type with no second edit here.
- */
-type Loosen<T> = {
-    [K in keyof T]?: T[K];
-};
-export type InternalModelField = never;
-export type ApiPublicModel = Loosen<Omit<ApiModelSpec, "refs" | "prompt" | InternalModelField>> & {
-    /** The model's display name, in one piece. */
-    name?: string;
-    refs?: Loosen<ApiRefSpec>;
-    prompt?: Loosen<ApiModelSpec["prompt"]>;
-};
-/** The error envelope every v1 endpoint returns on a failure. */
-export interface ApiErrorBody {
-    error: {
-        code: "AUTH_REQUIRED" | "AUTH_INVALID" | "AUTH_EXPIRED" | "SCOPE_INSUFFICIENT" | "ACCOUNT_SUSPENDED" | "ACCOUNT_PENDING_DELETION" | "EMAIL_UNVERIFIED" | "PLAN_UPGRADE_REQUIRED" | "CREDITS_INSUFFICIENT" | "SPEND_LOCKED" | "DAILY_CREDIT_CAP" | "KEY_DAILY_CREDIT_CAP" | "DAILY_GENERATION_CAP" | "STORAGE_FULL" | "RATE_LIMITED" | "CONCURRENCY_LIMIT" | "INVALID_REQUEST" | "MODEL_UNKNOWN" | "MODEL_DISABLED" | "NOT_FOUND" | "PROMPT_TOO_LONG" | "UNSUPPORTED_OPTION" | "LAUNCH_CLOSED" | "SERVICE_UNAVAILABLE" | "INTERNAL";
-        message: string;
-        requestId: string;
-        retryAfterMs?: number;
-        resetAt?: string;
-        field?: string;
-        billing?: {
-            balance?: number;
-            needed?: number;
-            currentTier?: string;
-            requiredTier?: string;
-            nextTier?: {
-                id: string;
-                creditsMonthly: number;
-            } | null;
-            purchasesEnabled?: boolean;
-            atMaxTier?: boolean;
-            action: "buy_credits" | "upgrade_plan" | "either" | "verify_email" | "wait" | "contact_support";
-            url: string;
-        };
-    };
-}
-export interface GenerationState {
-    id: string;
-    kind: "video" | "image";
-    status: "queued" | "processing" | "completed" | "failed" | "canceled";
-    model: string;
-    prompt: string;
-    aspectRatio: string;
-    resolution: string;
-    durationS?: number;
-    quality?: "low" | "medium" | "high" | null;
-    source: "api";
-    output: {
-        url: string | null;
-        expiresAt: string | null;
-        bytes: number | null;
-        width: number | null;
-        height: number | null;
-        durationS?: number | null;
-        retentionExpiresAt: string | null;
-    };
-    failure: {
-        reason: string;
-        title: string;
-        detail: string;
-        detailKey?: string;
-    } | null;
-    createdAt: string;
-    completedAt: string | null;
-}
-export {};

package/dist/types.js

@@ -1,11 +0,0 @@
-// The public shapes this package reads, declared with NO runtime import.
-//
-// They are a copy of the types the server publishes at `GET /api/v1/models`
-// (lib/api/modelSchema.ts). The copy is deliberate: this package must run from
-// npm with nothing but `RONANA_API_KEY` and `RONANA_BASE_URL`, so it can hold no
-// path into the application repository.
-//
-// tests/mcpPublicTypes.test.ts asserts the two definitions stay compatible, in
-// both directions. If somebody adds a field to `ApiModelSpec` and forgets this
-// file, that test fails.
-export {};