@wavespeed/cli 0.4.4 → 0.4.6

package/dist/commands/history.js

@@ -35,7 +35,7 @@ export function registerHistory(program) {
         .option('--page <n>', 'Page number', '1')
         .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('--status <s>', 'Filter by status (created, processing, completed, failed, cancelled, timeout, deleted)')
         .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: [...]}')

package/dist/commands/run.js

@@ -5,7 +5,8 @@ import fs from 'node:fs';
 import { requireClient } from '../lib/client.js';
 import { parseInputs, withInputSyntaxHint } from '../lib/inputs.js';
 import { resolveLocalFiles } from '../lib/local-files.js';
-import { submitPrediction, waitForPrediction } from '../lib/api.js';
+import { fetchModels, submitPrediction, waitForPrediction } from '../lib/api.js';
+import { findUnknownInputs } from '../lib/validate-inputs.js';
 import { uploadWithCache } from '../lib/upload-cache.js';
 import { downloadOutputs, printOutputs } from '../lib/output.js';
 import { emitJson, emitJsonError, isJsonMode, log, setJsonMode } from '../lib/log.js';
@@ -74,6 +75,7 @@ export function registerRun(program) {
         .option('--input-file <path>', 'JSON file with full input object')
         .option('--download [path]', 'Save outputs locally (optional path template, e.g. "./out/{index}.{ext}")')
         .option('--sync', 'Attempt sync mode; timed-out tasks can still be queried later')
+        .option('--no-validate', 'Skip pre-submit input validation against the model schema')
         .option('--json', 'Emit a single JSON object on stdout (progress goes to stderr)')
         .option('--output-dir <dir>', 'Directory for --download when no path is given')
         .action(async (modelArg, opts) => {
@@ -97,6 +99,50 @@ export function registerRun(program) {
         Object.assign(input, parseInputs(opts.input ?? []));
         if (opts.prompt)
             input.prompt = opts.prompt;
+        // Reject inputs the model's schema does not declare BEFORE anything
+        // costs money. The API's entry whitelist silently drops unknown keys,
+        // so a typo doesn't fail — it bills a generation that ignored the
+        // parameter. Validation fails open (no schema → no check) and, to
+        // avoid stale-cache false positives, re-fetches the catalog once
+        // before rejecting.
+        if (opts.validate !== false) {
+            try {
+                let { models } = await fetchModels();
+                let found = models.find((m) => m.model_id === model);
+                let report = findUnknownInputs(input, found);
+                if (report) {
+                    ({ models } = await fetchModels({ refresh: true }));
+                    found = models.find((m) => m.model_id === model);
+                    report = findUnknownInputs(input, found);
+                }
+                if (report) {
+                    const lines = report.unknown.map((k) => {
+                        const hint = report.suggestions.get(k);
+                        return `  ${k}` + (hint ? `  (did you mean \`${hint}\`?)` : '');
+                    });
+                    const msg = `Model ${model} does not accept: ${report.unknown.join(', ')}. ` +
+                        `The API silently drops unknown inputs, so this would bill a run that ignores them.`;
+                    if (isJsonMode()) {
+                        emitJsonError(msg, { unknown_inputs: report.unknown, accepted_inputs: report.known });
+                    }
+                    else {
+                        console.error(chalk.red('Error: ') + `unknown input${report.unknown.length > 1 ? 's' : ''} for ` + chalk.cyan(model) + ':');
+                        for (const l of lines)
+                            console.error(chalk.yellow(l));
+                        console.error(chalk.gray('  The API silently drops unknown inputs — the run would be billed with them ignored.'));
+                        console.error(chalk.gray('  Accepted inputs: ') + report.known.join(', '));
+                        console.error(chalk.gray('  Full schema:     ') + chalk.cyan(`wavespeed schema ${model}`));
+                        console.error(chalk.gray('  Bypass check:    ') + chalk.cyan('--no-validate'));
+                    }
+                    process.exit(1);
+                }
+            }
+            catch {
+                // Catalog unreachable — validation is best-effort, never a blocker.
+                // (The unknown-input rejection above exits the process directly and
+                // is not routed through here.)
+            }
+        }
         // `@path` inputs become hosted URLs before submission. Only the
         // explicit @ marker uploads — the CLI never guesses that a bare value
         // was meant to be a file.

package/dist/lib/api.js

@@ -153,6 +153,7 @@ export const PREDICTION_STATUSES = [
     'failed',
     'cancelled',
     'timeout',
+    'deleted',
 ];
 /**
  * Submit a prediction WITHOUT waiting for it. Split from polling so the
@@ -176,7 +177,7 @@ export async function waitForPrediction(id, opts = {}) {
         opts.onTick?.(item.status);
         if (item.status === 'completed')
             return item;
-        if (item.status === 'failed' || item.status === 'cancelled' || item.status === 'timeout') {
+        if (item.status === 'failed' || item.status === 'cancelled' || item.status === 'timeout' || item.status === 'deleted') {
             throw new Error(`Prediction ${item.status}${item.error ? `: ${item.error}` : ''} (task_id: ${id})`);
         }
         if (opts.signal?.cancelled)

package/dist/lib/validate-inputs.js

@@ -0,0 +1,62 @@
+// Pre-submit input validation against a model's published request schema.
+//
+// The API's entry whitelist silently DROPS any input key that is not in the
+// model's schema — a typo like `size=2560*1440` against a model whose real
+// knobs are `aspect_ratio`/`resolution` doesn't fail, it just quietly bills a
+// generation with defaults. Catching that before submission is the only
+// moment the mistake is still free.
+//
+// Validation fails OPEN: no schema (brand-new model, catalog lag, offline
+// cache miss) means no check. It must never block a submission the API would
+// have accepted.
+export function requestSchemaProps(model) {
+    const props = model?.api_schema?.api_schemas?.[0]?.request_schema?.properties;
+    if (!props)
+        return null;
+    const keys = Object.keys(props);
+    return keys.length > 0 ? keys : null;
+}
+// Small edit distance for typo hints — inputs are short snake_case tokens, so
+// a full Levenshtein over ≤40 keys is nothing.
+function editDistance(a, b) {
+    const dp = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
+    for (let j = 0; j <= b.length; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= a.length; i++)
+        for (let j = 1; j <= b.length; j++)
+            dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    return dp[a.length][b.length];
+}
+function closest(key, known) {
+    let best;
+    let bestD = Infinity;
+    for (const k of known) {
+        const d = editDistance(key.toLowerCase(), k.toLowerCase());
+        if (d < bestD) {
+            bestD = d;
+            best = k;
+        }
+    }
+    // A hint is only a hint when it's plausibly the same word.
+    return bestD <= Math.max(2, Math.floor(key.length / 3)) ? best : undefined;
+}
+/**
+ * Compare top-level input keys with the schema's properties.
+ * Returns null when everything checks out or no schema is available.
+ */
+export function findUnknownInputs(input, model) {
+    const known = requestSchemaProps(model);
+    if (!known)
+        return null;
+    const knownSet = new Set(known);
+    const unknown = Object.keys(input).filter((k) => !knownSet.has(k));
+    if (unknown.length === 0)
+        return null;
+    const suggestions = new Map();
+    for (const k of unknown) {
+        const hit = closest(k, known);
+        if (hit)
+            suggestions.set(k, hit);
+    }
+    return { unknown, known, suggestions };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wavespeed/cli",
-  "version": "0.4.4",
-  "description": "WaveSpeed CLI — one command to run any WaveSpeed AI model from your terminal.",
+  "version": "0.4.6",
+  "description": "WaveSpeed CLI \u2014 one command to run any WaveSpeed AI model from your terminal.",
   "publishConfig": {
     "access": "public"
   },