@wavespeed/mcp 1.0.8 → 1.0.10

package/dist/lib/api.js

@@ -64,9 +64,11 @@ async function httpError(res, method, apiPath) {
     catch {
         /* non-JSON body — fall back below */
     }
-    if (detail)
-        return new Error(detail);
-    return new Error(`${method} ${apiPath} failed: ${res.status} ${res.statusText}`);
+    const err = detail
+        ? new Error(detail)
+        : new Error(`${method} ${apiPath} failed: ${res.status} ${res.statusText}`);
+    err.status = res.status;
+    return err;
 }
 function authHeaders() {
     const apiKey = getApiKey();
@@ -75,8 +77,17 @@ function authHeaders() {
     }
     return { Authorization: `Bearer ${apiKey}`, ...clientAttributionHeaders() };
 }
-async function apiGet(apiPath) {
-    const res = await fetch(`${getBaseUrl()}${apiPath}`, { headers: authHeaders() });
+// Per-request timeouts (no overall cap). A hung socket would otherwise stall
+// the tool call. Read-only GETs are far below 30s in practice (result p99.9
+// < 1s); the async submit gets more headroom because a timeout there is an
+// ambiguous outcome, not a clean failure.
+export const GET_TIMEOUT_MS = 30_000;
+export const SUBMIT_TIMEOUT_MS = 60_000;
+async function apiGetOnce(apiPath) {
+    const res = await fetch(`${getBaseUrl()}${apiPath}`, {
+        headers: authHeaders(),
+        signal: AbortSignal.timeout(GET_TIMEOUT_MS),
+    });
     if (!res.ok)
         throw await httpError(res, 'GET', apiPath);
     const json = (await res.json());
@@ -84,11 +95,39 @@ async function apiGet(apiPath) {
         throw new Error(json.message || `API returned code ${json.code}`);
     return json.data;
 }
-async function apiPost(apiPath, body) {
+// Same set as wavespeed-python. An error with no HTTP status is a network
+// failure or timeout; envelope/JSON errors are not transient.
+const RETRYABLE_STATUS = new Set([429, 500, 502, 503, 504]);
+const MAX_GET_RETRIES = 5;
+function isTransient(err) {
+    if (typeof err?.status === 'number')
+        return RETRYABLE_STATUS.has(err.status);
+    return err instanceof TypeError || err?.name === 'TimeoutError' || err?.name === 'AbortError';
+}
+// Read-only GETs only — submit (POST) is deliberately never retried.
+async function apiGet(apiPath, opts = {}) {
+    const delay = opts.retryDelayMs ?? 1000;
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await apiGetOnce(apiPath);
+        }
+        catch (err) {
+            const reason = err?.message ?? String(err);
+            if (!isTransient(err) && !opts.describe)
+                throw err;
+            if (!isTransient(err) || attempt >= MAX_GET_RETRIES) {
+                throw new Error(opts.describe ? opts.describe(reason, attempt + 1) : reason);
+            }
+            await new Promise((r) => setTimeout(r, delay * (attempt + 1)));
+        }
+    }
+}
+async function apiPost(apiPath, body, opts = {}) {
     const res = await fetch(`${getBaseUrl()}${apiPath}`, {
         method: 'POST',
         headers: { ...authHeaders(), 'Content-Type': 'application/json' },
         body: JSON.stringify(body),
+        signal: opts.timeoutMs ? AbortSignal.timeout(opts.timeoutMs) : undefined,
     });
     if (!res.ok)
         throw await httpError(res, 'POST', apiPath);
@@ -133,10 +172,26 @@ export async function fetchPricing(modelId, inputs) {
  * mid-generation must never orphan a paid task.
  */
 export async function submitPrediction(model, input) {
-    return apiPost(`/api/v3/${model}`, { ...input });
+    try {
+        return await apiPost(`/api/v3/${model}`, { ...input }, { timeoutMs: SUBMIT_TIMEOUT_MS });
+    }
+    catch (err) {
+        // Never retried: the server may already have created (and billed) the task.
+        if (err?.name === 'TimeoutError') {
+            throw new Error(`Submission outcome unknown: no response within ${SUBMIT_TIMEOUT_MS / 1000}s. The task may have been created and billed — do not resubmit blindly; if you have a prediction id, check it with get_prediction.`);
+        }
+        throw err;
+    }
 }
-export async function fetchPrediction(id) {
-    return apiGet(`/api/v3/predictions/${id}/result`);
+// The message always carries the task id and says the task was not declared
+// failed — a status read that dies after submit must not look like a lost
+// (or failed) paid task.
+export async function fetchPrediction(id, opts = {}) {
+    return apiGet(`/api/v3/predictions/${id}/result`, {
+        retryDelayMs: opts.retryDelayMs,
+        describe: (reason, attempts) => `Could not read the status of task ${id} after ${attempts} attempt${attempts > 1 ? 's' : ''}: ${reason}. ` +
+            `The task was created and may still be running — call get_prediction with id "${id}" to check it (task_id: ${id}).`,
+    });
 }
 export const TERMINAL_FAILURES = ['failed', 'cancelled', 'timeout', 'deleted'];
 /**
@@ -145,13 +200,13 @@ export const TERMINAL_FAILURES = ['failed', 'cancelled', 'timeout', 'deleted'];
  * budget runs out. Running out is NOT an error: generations can take hours,
  * so the caller gets the still-running prediction back (done=false) and
  * reports its id instead of losing it in a thrown message. `onTick` fires
- * after every non-terminal poll.
+ * after every non-terminal poll. Transient status-read failures are retried.
  */
 export async function waitForPrediction(id, opts = {}) {
     const interval = opts.intervalMs ?? 1000;
     const deadline = opts.timeoutMs !== undefined ? Date.now() + opts.timeoutMs : undefined;
     for (;;) {
-        const item = await fetchPrediction(id);
+        const item = await fetchPrediction(id, { retryDelayMs: opts.retryDelayMs });
         if (item.status === 'completed' || TERMINAL_FAILURES.includes(item.status)) {
             return { item, done: true };
         }

package/dist/lib/validate-inputs.js

@@ -16,6 +16,31 @@ export function requestSchemaProps(model) {
     const keys = Object.keys(props);
     return keys.length > 0 ? keys : null;
 }
+/**
+ * Legacy field names a model still accepts, as `legacy -> canonical`.
+ *
+ * The API renames public fields without breaking old callers by declaring the
+ * old name in the property's `x-aliases` (e.g. `last_image` carries
+ * `["end_image"]`) and folding it into the canonical name before validation.
+ * A legacy name is therefore a valid input, not a typo — it just is not listed
+ * as an accepted input, so schema-driven UIs show only the current name.
+ */
+export function requestSchemaAliases(model) {
+    const aliases = new Map();
+    const props = model?.api_schema?.api_schemas?.[0]?.request_schema?.properties;
+    if (!props)
+        return aliases;
+    for (const [name, def] of Object.entries(props)) {
+        const declared = def?.['x-aliases'];
+        if (!Array.isArray(declared))
+            continue;
+        for (const alias of declared) {
+            if (typeof alias === 'string' && alias !== name)
+                aliases.set(alias, name);
+        }
+    }
+    return aliases;
+}
 // 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) {
@@ -49,7 +74,8 @@ export function findUnknownInputs(input, model) {
     if (!known)
         return null;
     const knownSet = new Set(known);
-    const unknown = Object.keys(input).filter((k) => !knownSet.has(k));
+    const aliases = requestSchemaAliases(model);
+    const unknown = Object.keys(input).filter((k) => !knownSet.has(k) && !aliases.has(k));
     if (unknown.length === 0)
         return null;
     const suggestions = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wavespeed/mcp",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "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": {
@@ -39,7 +39,7 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
-    "wavespeed": "^0.3.2",
+    "wavespeed": "^0.3.4",
     "zod": "^3.24.0"
   },
   "devDependencies": {