@wavespeed/mcp 1.0.13 → 1.0.15

package/README.md

@@ -25,20 +25,21 @@ Built on the same design as the open-source [`@wavespeed/cli`](https://github.co
 - **No hardcoded models.** The catalog comes from the live API (1h cache); new platform models work the day they ship.
 - **One generation verb.** `run_model` executes anything; `get_model_schema` tells the agent what inputs a model actually accepts, so it reads before it writes.
 - **Inputs are never mutated.** The one explicit transform is the `@path` marker — a `"@./photo.jpg"` value inside `input` uploads the file and substitutes its hosted URL. Bare paths are passed through untouched.
-- **Honest pricing.** `get_price` quotes before you spend and names the inputs the quote was blind to (`unpriced_inputs`) instead of presenting a formula's floor as "the" price.
+- **Quote before you spend.** `get_price` takes the same input as `run_model` and returns an estimate; the amount actually charged for a run is authoritative.
 
 ## Tools
 
 | Tool | What it does |
 |---|---|
 | `list_models` | Search the live catalog by text or modality type |
-| `get_model_schema` | A model's real input schema (required, properties, defaults) |
+| `get_model_schema` | A model's real input schema (required, properties, defaults), with a link to the model's `llms.txt` |
 | `run_model` | Submit + wait; rejects input keys the model doesn't accept; `@path` inputs upload automatically; returns output URLs |
-| `get_price` | Cost estimate with `unpriced_inputs` / `at_base_price` disclosure |
-| `get_balance` | Account credit balance |
+| `get_price` | Cost estimate for the inputs you pass (no charge), with a link to the model's `llms.txt` |
+| `get_balance` | Account credit balance, with the top-up link |
 | `list_predictions` | Run history (default last 24h); filter by model, status, time range |
 | `list_billings` | Itemized charges and refunds (needs a Billing-access key) |
 | `get_usage` | Spend, request counts and per-model breakdown (default last 7 days; needs a Billing-access key) |
+| `delete_predictions` | Delete finished runs from the history (up to 100; needs `confirm: true`, cannot be undone from here) |
 | `upload_file` | Local file → hosted URL (24h content-hash dedupe) |
 | `get_prediction` | Status/outputs of any run by id; optional `wait_seconds` to wait for it |
 

package/dist/lib/api.js

@@ -200,6 +200,10 @@ export async function fetchUsageStats(startTime, endTime, model) {
         body.model_uuid = model;
     return apiPost('/api/v3/user/usage_stats', body, { timeoutMs: GET_TIMEOUT_MS });
 }
+// The model page's markdown summary for agents (inputs, endpoint, examples).
+export function modelLlmsTxtUrl(modelId) {
+    return `https://wavespeed.ai/models/${modelId}/llms.txt`;
+}
 export async function fetchPricing(modelId, inputs) {
     // /model/price is the documented pricing endpoint.
     return apiPost('/api/v3/model/price', { model_id: modelId, inputs });
@@ -256,3 +260,7 @@ export async function waitForPrediction(id, opts = {}) {
         await new Promise((r) => setTimeout(r, interval));
     }
 }
+// Deletes within the key's own organization; the response lists the ids actually deleted.
+export async function deletePredictions(ids) {
+    return apiPost('/api/v3/predictions/delete', { ids }, { timeoutMs: GET_TIMEOUT_MS });
+}

package/dist/lib/delete-predictions.js

@@ -0,0 +1,34 @@
+// delete_predictions: the checks and the report around POST /api/v3/predictions/delete.
+// The API only touches the key's own organization and returns the ids it deleted.
+export const MAX_DELETE_IDS = 100;
+const ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+/** The ids to send: trimmed, unique, valid, and only once the user agreed (confirm). */
+export function prepareDelete(ids, confirm) {
+    const unique = [];
+    for (const raw of ids) {
+        const id = raw.trim();
+        if (!ID_PATTERN.test(id))
+            throw new Error(`Invalid prediction id "${raw}".`);
+        if (!unique.includes(id))
+            unique.push(id);
+    }
+    if (unique.length === 0 || unique.length > MAX_DELETE_IDS) {
+        throw new Error(`Pass between 1 and ${MAX_DELETE_IDS} prediction ids.`);
+    }
+    if (!confirm) {
+        throw new Error(`Nothing was deleted. This removes ${unique.length} prediction(s) from the history and cannot be undone here: ask the user, then call again with confirm: true.`);
+    }
+    return unique;
+}
+export function summarizeDelete(requested, deletedIds) {
+    const deleted = deletedIds ?? [];
+    const notDeleted = requested.filter((id) => !deleted.includes(id));
+    return {
+        deleted,
+        deleted_count: deleted.length,
+        requested: requested.length,
+        ...(notDeleted.length > 0
+            ? { not_deleted: notDeleted, note: "These ids were not deleted: they are not in this account's history, are still running, or were already deleted." }
+            : {}),
+    };
+}

package/dist/server.js

@@ -9,17 +9,19 @@
 // * Inputs are never mutated. The one explicit transform is the `@path`
 //   marker, which uploads the referenced local file and substitutes its
 //   hosted URL. Bare paths pass through untouched.
-// * Price quotes name the inputs they were blind to instead of presenting
-//   the formula's floor as "the" price.
+// * Price quotes are estimates for the inputs given; the model's llms.txt
+//   is linked next to them for what each input means.
 import { createRequire } from 'node:module';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import { Client } from 'wavespeed';
-import { fetchModels, fetchBalance, fetchHistory, fetchBillings, fetchUsageStats, PREDICTION_STATUSES, fetchPricing, submitPrediction, waitForPrediction, MCP_CLIENT_NAME, TERMINAL_FAILURES, } from './lib/api.js';
+import { fetchModels, fetchBalance, fetchHistory, fetchBillings, fetchUsageStats, deletePredictions, PREDICTION_STATUSES, fetchPricing, modelLlmsTxtUrl, submitPrediction, waitForPrediction, MCP_CLIENT_NAME, TERMINAL_FAILURES, } from './lib/api.js';
 import { getApiKey, getBaseUrl } from './lib/config.js';
+import { MAX_DELETE_IDS, prepareDelete, summarizeDelete } from './lib/delete-predictions.js';
+// Where to add credit; handed to the assistant next to the balance.
+const TOP_UP_URL = 'https://wavespeed.ai/top-up';
 import { resolveLocalFiles } from './lib/local-files.js';
 import { uploadWithCache } from './lib/upload-cache.js';
-import { missingPriceVars, isFloorQuote } from './lib/pricing-vars.js';
 import { findUnknownInputs } from './lib/validate-inputs.js';
 const require = createRequire(import.meta.url);
 const { version: PKG_VERSION } = require('../package.json');
@@ -161,6 +163,7 @@ export function createServer() {
             required: schema?.required ?? [],
             properties: schema?.properties ?? {},
             property_order: schema?.['x-order-properties'] ?? [],
+            llms_txt: modelLlmsTxtUrl(meta.model_id),
         });
     });
     server.tool('run_model', 'Run any WaveSpeed model. input keys come from get_model_schema; unknown keys are rejected before submission. Local files: pass "@./path" string values — they are uploaded and replaced with hosted URLs (bare paths are NOT uploaded). Returns the prediction id right away (done=false); call get_prediction with that id and wait_seconds until done=true to get the output URLs. The task keeps running on the server. Pass wait_seconds here to wait for a quick model in the same call.', {
@@ -205,43 +208,23 @@ export function createServer() {
             ...(done ? {} : { next: STILL_RUNNING_HINT }),
         });
     });
-    server.tool('get_price', 'Estimate the cost of a run before executing it (no charge). Provide the same input you would pass to run_model — pricing often depends on inputs like duration or resolution.', {
+    server.tool('get_price', 'Estimate the cost of a run before executing it (no charge). Provide the same input you would pass to run_model — pricing often depends on inputs like duration or resolution, and a quote made without them can be lower than the real charge.', {
         model: z.string().describe('Model ID from list_models'),
         input: z.record(z.unknown()).default({}).describe('Inputs the quote should account for'),
     }, { readOnlyHint: false, destructiveHint: false, openWorldHint: true }, async ({ model, input }) => {
-        // Resolve @path markers exactly like run_model: pricing formulas often
-        // read the file itself (get_duration_v3(audio)), so quoting with the
-        // literal "@./a.mp3" string would silently collapse to the floor. The
-        // 24h content-hash cache means the later run reuses this upload.
+        // Resolve @path markers exactly like run_model: some prices are measured
+        // from the file itself, so quoting with the literal "@./a.mp3" string
+        // would be wrong. The 24h content-hash cache means the later run reuses
+        // this upload.
         const resolved = await resolveLocalFiles(input, {
             upload: async (p) => (await uploadFile(p)).url,
         });
         const priceInput = resolved.input;
         const data = await fetchPricing(model, priceInput);
-        // The pricing endpoint accepts partial inputs without complaint — a
-        // formula whose variables are all missing collapses to base_price, the
-        // floor of the model's range. Name what the quote could not see.
-        let unpriced = [];
-        let atFloor = false;
-        try {
-            const models = await fetchModels();
-            const meta = models.find((m) => m.model_id === model);
-            unpriced = missingPriceVars(meta?.formula, priceInput, requestSchema(meta ?? {})?.properties);
-            atFloor = isFloorQuote(meta?.formula, priceInput);
-        }
-        catch {
-            /* no catalog — the generic disclaimer still applies */
-        }
-        return ok({
-            ...data,
-            estimate: true,
-            unpriced_inputs: unpriced,
-            at_base_price: atFloor,
-            disclaimer: PRICE_DISCLAIMER,
-        });
+        return ok({ ...data, estimate: true, disclaimer: PRICE_DISCLAIMER, llms_txt: modelLlmsTxtUrl(model) });
     });
-    server.tool('get_balance', 'Show the WaveSpeed account credit balance.', {}, { readOnlyHint: true, openWorldHint: true }, async () => {
-        return ok(await fetchBalance());
+    server.tool('get_balance', 'Show the WaveSpeed account credit balance, with the link to top up.', {}, { readOnlyHint: true, openWorldHint: true }, async () => {
+        return ok({ ...(await fetchBalance()), top_up_url: TOP_UP_URL });
     });
     server.tool('list_predictions', 'List past predictions (run history), newest window first. Defaults to the last 24 hours; pass since/until (ISO or YYYY-MM-DD) for other ranges. Use get_prediction with an id for one task in full.', {
         page: z.number().int().min(1).default(1),
@@ -288,6 +271,14 @@ export function createServer() {
         const start = toIso(since, 'since') ?? new Date(Date.parse(end) - 7 * 24 * 60 * 60 * 1000).toISOString();
         return ok(await fetchUsageStats(start, end, model));
     });
+    server.tool('delete_predictions', `Delete finished predictions from this account's run history, up to ${MAX_DELETE_IDS} at a time. They stop appearing in list_predictions and get_prediction, and this tool cannot bring them back. Runs that are still going are left alone, and only the key's own organization's records are deleted. Ask the user first, and pass confirm: true only after they agreed to delete these ids.`, {
+        ids: z.array(z.string()).min(1).max(MAX_DELETE_IDS).describe('Prediction ids to delete'),
+        confirm: z.boolean().describe('Must be true: the user has agreed to delete these predictions'),
+    }, { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false }, async ({ ids, confirm }) => {
+        const toDelete = prepareDelete(ids, confirm);
+        const res = await deletePredictions(toDelete);
+        return ok(summarizeDelete(toDelete, res.deleted_ids));
+    });
     server.tool('upload_file', 'Upload a local file to WaveSpeed and get its hosted URL (identical bytes reuse the same upload for 24h). Usually unnecessary — run_model handles "@./path" inputs itself.', { path: z.string().describe('Local file path') }, { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }, async ({ path: filePath }) => {
         return ok(await uploadFile(filePath));
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wavespeed/mcp",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "WaveSpeed MCP server — run any model on the live WaveSpeed catalog (image, video, audio, 3D) with schema introspection, local-file upload, and price quotes.",
   "type": "module",
   "bin": {

package/dist/lib/pricing-vars.js

@@ -1,75 +0,0 @@
-// 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 === '';
-    });
-}