@wavespeed/cli 0.4.28 → 0.4.30

package/README.md

@@ -137,7 +137,7 @@ The skill teaches the agent the shortcuts for images and videos (`generate`, `ed
 
 **OpenCode** loads the same file with no extra steps — `.claude/skills/` is on its skill search path. For the MCP tools as well, add the plugin to your OpenCode config — `"plugin": ["@wavespeed/opencode"]` — and run `opencode mcp auth wavespeed` ([WaveSpeedAI/wavespeed-opencode](https://github.com/WaveSpeedAI/wavespeed-opencode)).
 
-**Codex** reads `.agents/skills/`, which the same command writes. For a one-line install that also wires up the MCP server: `codex plugin marketplace add WaveSpeedAI/codex-plugin-wavespeed-cli` ([WaveSpeedAI/codex-plugin-wavespeed-cli](https://github.com/WaveSpeedAI/codex-plugin-wavespeed-cli)).
+**Codex** reads `.agents/skills/`, which the same command writes. For a one-line install that also wires up the MCP server: `codex plugin marketplace add WaveSpeedAI/codex-plugins` ([WaveSpeedAI/codex-plugins](https://github.com/WaveSpeedAI/codex-plugins)).
 
 **DeepSeek Harness (dsh)**: the same skill is packaged for dsh's `.dsh/skills` layout at [WaveSpeedAI/wavespeed-dsh-skill](https://github.com/WaveSpeedAI/wavespeed-dsh-skill).
 
@@ -190,7 +190,8 @@ wavespeed skill install                  Drop SKILL.md for coding agents
 models bill from an input — audio/video duration, frame count, text length. Pass
 the same inputs you would pass to `wavespeed run`: a quote made without them can
 be lower than the real charge. The amount actually charged for a run is
-authoritative.
+authoritative. Like `run`, `price` refuses an input the model does not accept (a typo would
+otherwise be ignored by the quote); `--no-validate` skips the check.
 
 ## Auth
 

package/dist/commands/price.js

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { fetchPricing, modelPlaygroundUrl } from '../lib/api.js';
 import { parseInputs } from '../lib/inputs.js';
-import { modelInputProps } from '../lib/validate-inputs.js';
+import { modelInputProps, unknownInputsFor } from '../lib/validate-inputs.js';
 import { resolveModelToken } from '../lib/config.js';
 import { collectLocalFiles, resolveLocalFiles } from '../lib/local-files.js';
 import { uploadWithCache } from '../lib/upload-cache.js';
@@ -15,6 +15,7 @@ export function registerPrice(program) {
         .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 @file inputs first so media-based pricing is exact (quota applies; identical bytes cached 24h)')
+        .option('--no-validate', 'Skip checking the inputs against the model schema')
         .option('--json', 'Emit JSON')
         .action(async (modelArg, opts) => {
         const resolved = resolveModelToken(modelArg);
@@ -30,6 +31,27 @@ export function registerPrice(program) {
         Object.assign(inputs, parseInputs(opts.input ?? []));
         if (opts.prompt)
             inputs.prompt = opts.prompt;
+        // A key the model does not declare is dropped by the pricer, so a typo would quote a price that ignores it.
+        if (opts.validate !== false) {
+            const report = await unknownInputsFor(resolved.model, inputs);
+            if (report) {
+                const msg = `Model ${resolved.model} does not accept: ${report.unknown.join(', ')}. ` +
+                    `Unknown inputs are ignored, so this quote would not account for them.`;
+                if (opts.json) {
+                    process.stdout.write(JSON.stringify({ error: msg, unknown_inputs: report.unknown, accepted_inputs: report.known }, null, 2) + '\n');
+                }
+                else {
+                    console.error(chalk.red('Error: ') + `unknown input${report.unknown.length > 1 ? 's' : ''} for ` + chalk.cyan(resolved.model) + ':');
+                    for (const k of report.unknown) {
+                        const hint = report.suggestions.get(k);
+                        console.error(chalk.yellow(`  ${k}` + (hint ? `  (did you mean \`${hint}\`?)` : '')));
+                    }
+                    console.error(chalk.gray('  Accepted inputs: ') + report.known.join(', '));
+                    console.error(chalk.gray('  Bypass check:    ') + chalk.cyan('--no-validate'));
+                }
+                process.exit(1);
+            }
+        }
         // Pricing that depends on media (e.g. per-second video upscaling) is
         // measured server-side from the URL, so a local path is useless to the
         // pricing engine. Uploading is slow and quota-limited, so it is opt-in:

package/dist/commands/run.js

@@ -5,8 +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 { fetchModels, submitPrediction, waitForPrediction } from '../lib/api.js';
-import { findUnknownInputs, modelInputProps } from '../lib/validate-inputs.js';
+import { submitPrediction, waitForPrediction } from '../lib/api.js';
+import { modelInputProps, unknownInputsFor } 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';
@@ -106,41 +106,27 @@ export function registerRun(program) {
         // 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);
+            const report = await unknownInputsFor(model, input);
+            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 });
                 }
-                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);
+                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'));
                 }
-            }
-            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.)
+                process.exit(1);
             }
         }
         // `@path` inputs become hosted URLs before submission. Only the

package/dist/lib/api.js

@@ -150,7 +150,7 @@ export function modelPlaygroundUrl(modelId) {
 export async function fetchPricing(modelId, inputs) {
     // /model/price is the documented pricing endpoint; /model/pricing is a
     // legacy contract kept for old clients and absent from the public docs.
-    return apiPost('/api/v3/model/price', { model_id: modelId, inputs });
+    return apiPost('/api/v3/model/price', { model_id: modelId, input: inputs });
 }
 /** The run time in ms the API reports (`timings.inference`), or undefined when absent or zero. */
 export function inferenceMs(item) {

package/dist/lib/validate-inputs.js

@@ -109,3 +109,22 @@ export function findUnknownInputs(input, model) {
     }
     return { unknown, known, suggestions };
 }
+/**
+ * Inputs the model's schema does not declare, checked against the live catalog. The API silently drops unknown
+ * keys, so a typo bills a run (or quotes a price) that ignores it. Fails open: null when the catalog has no schema
+ * or cannot be reached; re-fetches once before reporting, so a stale cache cannot block a valid input.
+ */
+export async function unknownInputsFor(model, input) {
+    try {
+        let { models } = await fetchModels();
+        let report = findUnknownInputs(input, models.find((m) => m.model_id === model));
+        if (report) {
+            ({ models } = await fetchModels({ refresh: true }));
+            report = findUnknownInputs(input, models.find((m) => m.model_id === model));
+        }
+        return report;
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

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