@wavespeed/cli 0.4.0 → 0.4.2

package/README.md

@@ -133,11 +133,13 @@ wavespeed models [query]                 Browse the live catalog (cached 1h)
 wavespeed aliases                        List aliases from wavespeed.json + user config
 
 # files
-wavespeed upload <file...>               Upload local file(s) → CDN URLs
+wavespeed upload <file...>               Upload local file(s) → CDN URLs (24h dedup cache)
 wavespeed download <url...>              Save URLs to disk
 
 # account & history
 wavespeed balance                        Show your current credit balance
+wavespeed usage [--since --until]        Spend + request counts, per-model (last 7d)
+wavespeed billings [--type --since …]    Itemized charges and refunds
 wavespeed price <model> -i k=v           Estimate the cost of a run (no charge)
 wavespeed top-up                         Open https://wavespeed.ai/top-up
 wavespeed history [--limit --status …]   List recent predictions (last 24h)
@@ -150,6 +152,16 @@ wavespeed init                           Create a wavespeed.json with defaults +
 wavespeed skill install                  Drop SKILL.md for coding agents
 ```
 
+**Pricing is an estimate.** `wavespeed price` quotes from the model's pricing
+formula, and many models bill from an input — audio/video duration, frame count,
+text length. Those inputs are optional in the quote: ask for a price without
+them and the formula collapses to the model's **base price**, which is the floor
+of its range, not a typical run. `wavespeed price wavespeed-ai/infinitetalk`
+says `$0.15`; a 60s audio actually bills `$1.80`. The command names the inputs it
+was blind to (`unpriced_inputs` / `at_base_price` in `--json`) — supply them for
+a real quote. Whatever it says, the amount actually charged for a run is
+authoritative.
+
 ## Auth
 
 | | Use when |

package/dist/commands/billings.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import { fetchBillings } from '../lib/api.js';
+import { toIso } from '../lib/time.js';
 function money(v) {
     if (v === undefined)
         return '';
@@ -35,8 +36,8 @@ export function registerBillings(program) {
                 type: opts.type,
                 model: opts.model,
                 accessKey: opts.key,
-                startTime: opts.since,
-                endTime: opts.until,
+                startTime: opts.since ? toIso(opts.since) : undefined,
+                endTime: opts.until ? toIso(opts.until, true) : undefined,
             });
             spinner?.stop();
             if (opts.json) {

package/dist/commands/delete.js

@@ -7,7 +7,7 @@ export function registerDelete(program) {
         .command('delete')
         .description('Delete one or more predictions from your history')
         .argument('<id...>', 'Prediction ID(s) to delete')
-        .option('-y, --yes', 'Skip the confirmation prompt')
+        .option('-y, --yes', 'Skip the confirmation prompt (required in scripts / non-interactive use)')
         .option('--json', 'Emit JSON: {deleted: [...ids]}')
         .action(async (ids, opts) => {
         // --json controls output format only; it must never stand in for

package/dist/commands/history.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import { fetchHistory, PREDICTION_STATUSES } from '../lib/api.js';
+import { toIso } from '../lib/time.js';
 function statusBadge(status) {
     const map = {
         completed: chalk.bgGreen.black,
@@ -35,8 +36,8 @@ export function registerHistory(program) {
         .option('--limit <n>', 'Page size (1-100)', '20')
         .option('--model <id>', 'Filter by model ID')
         .option('--status <s>', 'Filter by status (created, processing, completed, failed, cancelled, timeout)')
-        .option('--since <iso>', 'Show predictions created after this ISO timestamp')
-        .option('--until <iso>', 'Show predictions created before this ISO timestamp')
+        .option('--since <time>', 'Predictions created after this time (ISO or YYYY-MM-DD)')
+        .option('--until <time>', 'Predictions created before this time (ISO or YYYY-MM-DD)')
         .option('--json', 'Emit JSON: {page, items: [...]}')
         .action(async (opts) => {
         if (opts.status && !PREDICTION_STATUSES.includes(opts.status)) {
@@ -54,8 +55,8 @@ export function registerHistory(program) {
                 pageSize: parseInt(opts.limit, 10),
                 model: opts.model,
                 status: opts.status,
-                createdAfter: opts.since,
-                createdBefore: opts.until,
+                createdAfter: opts.since ? toIso(opts.since) : undefined,
+                createdBefore: opts.until ? toIso(opts.until, true) : undefined,
             });
             spinner?.stop();
             if (opts.json) {

package/dist/commands/price.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import ora from 'ora';
-import { fetchPricing } from '../lib/api.js';
+import { fetchPricing, fetchModels } from '../lib/api.js';
+import { missingPriceVars, isFloorQuote } from '../lib/pricing-vars.js';
 import { parseInputs } from '../lib/inputs.js';
 import { resolveModelToken } from '../lib/config.js';
 import { collectLocalFiles, resolveLocalFiles } from '../lib/local-files.js';
@@ -13,7 +14,7 @@ export function registerPrice(program) {
         .argument('<model>', 'Model ID or alias')
         .option('-i, --input <pair...>', 'Inputs as key=value (same syntax as `wavespeed run`)', [])
         .option('-p, --prompt <text>', 'Shorthand for --input prompt=<text>')
-        .option('--upload', 'Upload local file inputs first so media-based pricing is exact (quota applies; content-hash cached 24h)')
+        .option('--upload', 'Upload @file inputs first so media-based pricing is exact (quota applies; identical bytes cached 24h)')
         .option('--json', 'Emit JSON')
         .action(async (modelArg, opts) => {
         const resolved = resolveModelToken(modelArg);
@@ -73,9 +74,35 @@ export function registerPrice(program) {
         const spinner = !opts.json ? ora('Calculating price…').start() : null;
         try {
             const data = await fetchPricing(resolved.model, inputs);
+            // /model/price evaluates the model's formula against whatever inputs we
+            // send and never complains about the ones we left out — a formula with
+            // every variable missing collapses to base_price. That is the floor of
+            // the model's range, not a representative charge, so name the inputs
+            // this quote could not see rather than presenting the floor as "the"
+            // price. Catalog is cached 1h; a lookup failure only costs the detail.
+            let unpriced = [];
+            let atFloor = false;
+            try {
+                const { models } = await fetchModels();
+                const meta = models.find((m) => m.model_id === resolved.model);
+                const props = meta?.api_schema?.api_schemas?.[0]?.request_schema?.properties;
+                unpriced = missingPriceVars(meta?.formula, inputs, props);
+                atFloor = isFloorQuote(meta?.formula, inputs);
+            }
+            catch {
+                /* no catalog — fall back to the generic disclaimer below */
+            }
             spinner?.stop();
+            const disclaimer = 'Estimate only, for reference — the amount actually charged for a run is authoritative.';
             if (opts.json) {
-                process.stdout.write(JSON.stringify({ ...data, uploaded: uploadedUrls }, null, 2) + '\n');
+                process.stdout.write(JSON.stringify({
+                    ...data,
+                    estimate: true,
+                    unpriced_inputs: unpriced,
+                    at_base_price: atFloor,
+                    disclaimer,
+                    uploaded: uploadedUrls,
+                }, null, 2) + '\n');
                 return;
             }
             console.log();
@@ -86,6 +113,19 @@ export function registerPrice(program) {
                 (data.discounted_price > 0 && data.discounted_price !== data.price
                     ? chalk.gray(`  (list $${data.price})`)
                     : ''));
+            if (unpriced.length > 0) {
+                console.log('  ' +
+                    chalk.yellow('note:    ') +
+                    chalk.yellow(`this model is priced from ${unpriced.join(', ')}, which ${unpriced.length === 1 ? 'was' : 'were'} not supplied.`));
+                console.log('           ' +
+                    chalk.gray(atFloor
+                        ? 'The figure above is the base price — the floor of this model’s range, not a typical run.'
+                        : 'The figure above prices the rest at their defaults and can move once these are set.'));
+                console.log('           ' +
+                    chalk.gray('Pass ') +
+                    chalk.cyan(unpriced.map((v) => `-i ${v}=…`).join(' ')) +
+                    chalk.gray(' for a representative quote.'));
+            }
             console.log();
             for (const [file, url] of Object.entries(uploadedUrls)) {
                 console.log('  ' + chalk.gray('uploaded: ') + chalk.gray(file + ' → ') + chalk.cyan(url));
@@ -95,6 +135,7 @@ export function registerPrice(program) {
             }
             console.log();
             console.log(chalk.gray('Run it: ') + chalk.cyan(`wavespeed run ${modelArg}` + (opts.prompt ? ` -p "${opts.prompt}"` : '')));
+            console.log(chalk.gray(disclaimer));
             console.log();
         }
         catch (err) {

package/dist/commands/upload.js

@@ -6,7 +6,7 @@ import { uploadWithCache } from '../lib/upload-cache.js';
 export function registerUpload(program) {
     program
         .command('upload')
-        .description('Upload one or more local files to Wavespeed and print their CDN URLs')
+        .description('Upload one or more local files to Wavespeed and print their CDN URLs (identical bytes reuse the same upload for 24h)')
         .argument('<file...>', 'Path(s) to file(s)')
         .option('--json', 'Emit a JSON object on stdout')
         .action(async (files, opts) => {

package/dist/commands/usage.js

@@ -1,16 +1,7 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import { fetchUsageStats } from '../lib/api.js';
-/** Accepts ISO or YYYY-MM-DD; returns full RFC3339 the API requires. */
-function toIso(value, endOfDay = false) {
-    if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
-        return value + (endOfDay ? 'T23:59:59Z' : 'T00:00:00Z');
-    }
-    const d = new Date(value);
-    if (isNaN(d.getTime()))
-        throw new Error(`Invalid time "${value}". Use ISO 8601 or YYYY-MM-DD.`);
-    return d.toISOString();
-}
+import { toIso } from '../lib/time.js';
 export function registerUsage(program) {
     program
         .command('usage')

package/dist/lib/pricing-vars.js

@@ -0,0 +1,75 @@
+// Pricing formulas are JSONata expressions returned by /api/v3/models, e.g.
+//   {"total_price": $max([5, $min([$ceil(get_duration_v3(audio)), 600])]) / 5 * base_price}
+//   {"total_price": base_price * duration / 5}
+//
+// The pricing endpoint evaluates them server-side and happily accepts a partial
+// (or empty) `inputs` object — a formula whose variables are all missing
+// collapses to `base_price`, which is the floor of the model's price range, not
+// a typical charge. `wavespeed price wavespeed-ai/infinitetalk` with no inputs
+// quotes $0.15 while a 60s audio actually costs $1.80. So we parse the formula
+// to find which inputs move the price, and say which ones the quote is blind to.
+const RESERVED = new Set(['base_price', 'total_price', 'true', 'false', 'null']);
+/**
+ * Variable names a pricing formula reads from the model's inputs, in first-seen
+ * order. Excludes JSONata builtins (`$max`), helper calls (`get_duration_v3`),
+ * string literals, and `base_price`/`total_price`.
+ *
+ * Returns [] for a flat-priced model (`base_price * 1`) or an unparseable
+ * formula — callers should treat [] as "nothing input-dependent to warn about".
+ */
+export function extractPriceVars(formula) {
+    if (!formula)
+        return [];
+    // Drop string literals first so "720p" / "total_price" keys never register.
+    const stripped = formula.replace(/"(?:[^"\\]|\\.)*"/g, '""').replace(/'(?:[^'\\]|\\.)*'/g, "''");
+    const vars = [];
+    const seen = new Set();
+    const re = /(\$?)([A-Za-z_][A-Za-z0-9_]*)\s*(\()?/g;
+    let m;
+    while ((m = re.exec(stripped)) !== null) {
+        const [, dollar, name, call] = m;
+        if (dollar)
+            continue; // $max, $ceil, $length — JSONata builtin
+        if (call)
+            continue; // get_duration_v3(...) — server-side helper
+        if (RESERVED.has(name))
+            continue;
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        vars.push(name);
+    }
+    return vars;
+}
+/**
+ * Price-driving variables the quote is genuinely blind to.
+ *
+ * A driver the caller omitted but that carries a schema default is NOT blind —
+ * the server priced it at that default, which is exactly what a run would use.
+ * Only drivers with no default (infinitetalk's `audio`, seedance's
+ * `reference_videos`) leave the quote uninformed, and those are the ones that
+ * silently collapse the formula toward base_price.
+ */
+export function missingPriceVars(formula, inputs, schemaProps) {
+    return extractPriceVars(formula).filter((v) => {
+        const val = inputs[v];
+        if (val !== undefined && val !== null && val !== '')
+            return false;
+        const prop = schemaProps?.[v];
+        return !(prop && 'default' in prop);
+    });
+}
+/**
+ * True when every price driver is unsupplied — the case where the formula
+ * degenerates to `base_price` and the quote is the floor of the model's range
+ * rather than a representative charge.
+ */
+export function isFloorQuote(formula, inputs) {
+    const vars = extractPriceVars(formula);
+    if (vars.length === 0)
+        return false;
+    return vars.every((v) => {
+        const val = inputs[v];
+        return val === undefined || val === null || val === '';
+    });
+}

package/dist/lib/time.js

@@ -0,0 +1,16 @@
+// The predictions-search API is strict RFC3339, so bare dates the CLI's own
+// hints suggest ("--since 2026-01-01") must be widened here, not rejected
+// there. Shared by history, billings, and usage so every time flag accepts
+// the same two forms: full ISO 8601 or YYYY-MM-DD.
+/** Accepts ISO 8601 or YYYY-MM-DD; returns RFC3339. Day-only values span the
+ * whole day: start-of-day normally, end-of-day when `endOfDay` is set. */
+export function toIso(value, endOfDay = false) {
+    if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+        return value + (endOfDay ? 'T23:59:59Z' : 'T00:00:00Z');
+    }
+    const d = new Date(value);
+    if (isNaN(d.getTime())) {
+        throw new Error(`Invalid time "${value}". Use ISO 8601 or YYYY-MM-DD.`);
+    }
+    return d.toISOString();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wavespeed/cli",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "WaveSpeed CLI — one command to run any WaveSpeed AI model from your terminal.",
   "publishConfig": {
     "access": "public"

package/skills/SKILL.md

@@ -23,7 +23,7 @@ wavespeed run google/nano-banana-2/text-to-image \
   -i aspect_ratio="16:9" -i resolution="2k" --json
 ```
 
-`run --json` returns `{ model, prompt, outputs: [url, ...], saved: [path, ...], elapsed_ms, raw }`. Use the URL when the user wants a link. Add `--download` if they need bytes on disk.
+`run --json` returns `{ id, model, prompt, outputs: [url, ...], saved: [path, ...], elapsed_ms, raw }`. Keep `id` — it is the handle for `wavespeed show <id>` if anything is interrupted. Use the URL when the user wants a link. Add `--download` if they need bytes on disk.
 
 ## Recommended defaults
 
@@ -39,17 +39,18 @@ These are good starting points. Browse alternatives with `wavespeed models <quer
 ## Common recipes
 
 ```bash
-# Edit an existing image — upload first, then pass the URL
-URL=$(wavespeed upload ./input.jpg --json | jq -r .url)
+# Edit an existing image — @path uploads the file and passes its URL (one step)
 wavespeed run google/nano-banana-2/edit \
   -p "replace the background with a sunlit kitchen" \
-  -i images="[\"$URL\"]" --json
+  -i images='["@./input.jpg"]' --json
 
-# Image-to-video — same pattern
-URL=$(wavespeed upload ./hero.jpg --json | jq -r .url)
+# Image-to-video — same @ marker for single-URL fields
 wavespeed run bytedance/seedance-2.0/image-to-video \
   -p "subtle parallax, gentle wind" \
-  -i image="$URL" -i duration=5 --json
+  -i image=@./hero.jpg -i duration=5 --json
+
+# Or upload separately when you need the URL itself
+URL=$(wavespeed upload ./hero.jpg --json | jq -r .url)
 
 # Save outputs locally with a template
 wavespeed run ... -p "..." --download "./out/{index}.{ext}"
@@ -62,7 +63,7 @@ If `wavespeed.json` exists (created by `wavespeed init`):
 - **`defaultModel`** — lets `wavespeed run -p "…"` (no model arg) work.
 - **Aliases** — named shortcuts that bundle model + default inputs. Run `wavespeed aliases` to see what's defined. `wavespeed run <alias> -h` shows the resolved schema. CLI `-i k=v` overrides alias defaults.
 
-The CLI never modifies the user's prompt or inputs. What you typed is what hits the API.
+The CLI never modifies the user's prompt or inputs. The single exception is explicit: an `@path` value uploads that file and substitutes its hosted URL. Bare paths are never uploaded.
 
 ## Auth
 
@@ -70,6 +71,8 @@ The CLI never modifies the user's prompt or inputs. What you typed is what hits
 
 ## Pitfalls
 
-- Local file paths don't auto-upload — call `wavespeed upload` first to get a CDN URL.
+- Local files: use `@./file.jpg` in `-i` values. Bare paths are NOT uploaded and the model will reject them.
 - Don't invent model IDs. Always confirm via `wavespeed models` or `wavespeed schema <id>` before running.
 - Use `--json` on every `run` so you can read `outputs[0]` programmatically.
+- `wavespeed delete` requires `--yes` when run non-interactively (that includes you).
+- Spend questions: `wavespeed usage` (totals, per-model) and `wavespeed billings` (per-charge records).