@wavespeed/cli 0.4.9 → 0.4.10

package/dist/lib/api.js

@@ -88,12 +88,17 @@ async function httpError(res, method, path) {
     catch {
         /* non-JSON body (gateway error page, empty response) — fall back below */
     }
-    if (detail)
-        return new Error(detail);
-    return new Error(`${method} ${path} failed: ${res.status} ${res.statusText}`);
+    const err = detail
+        ? new Error(detail)
+        : new Error(`${method} ${path} failed: ${res.status} ${res.statusText}`);
+    err.status = res.status;
+    return err;
 }
-async function apiGet(path) {
-    const res = await fetch(`${getBaseUrl()}${path}`, { headers: authHeaders() });
+async function apiGet(path, opts = {}) {
+    const res = await fetch(`${getBaseUrl()}${path}`, {
+        headers: authHeaders(),
+        signal: opts.timeoutMs ? AbortSignal.timeout(opts.timeoutMs) : undefined,
+    });
     if (!res.ok)
         throw await httpError(res, 'GET', path);
     const json = (await res.json());
@@ -137,8 +142,39 @@ export async function fetchHistory(query = {}) {
         body.status = query.status;
     return apiPost('/api/v3/predictions', body);
 }
+// A hung socket would otherwise stall the CLI forever. 30s is far above a
+// healthy status read, so it only trips on a dead connection.
+const POLL_REQUEST_TIMEOUT_MS = 30_000;
 export async function fetchPrediction(id) {
-    return apiGet(`/api/v3/predictions/${id}/result`);
+    return apiGet(`/api/v3/predictions/${id}/result`, {
+        timeoutMs: POLL_REQUEST_TIMEOUT_MS,
+    });
+}
+// Same set as wavespeed-python. A thrown error with no HTTP status is a
+// network failure or timeout; envelope/JSON errors carry no status either but
+// never reach here as a transient fault, so only fetch-level errors count.
+const RETRYABLE_STATUS = new Set([429, 500, 502, 503, 504]);
+const MAX_POLL_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';
+}
+async function fetchPredictionWithRetry(id, retryDelayMs) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await fetchPrediction(id);
+        }
+        catch (err) {
+            const reason = err?.message ?? String(err);
+            if (!isTransient(err))
+                throw new Error(`${reason} (task_id: ${id})`);
+            if (attempt >= MAX_POLL_RETRIES) {
+                throw new Error(`Status check failed after ${attempt + 1} attempts: ${reason} (task_id: ${id}) — the task may still be running`);
+            }
+            await new Promise((r) => setTimeout(r, retryDelayMs * (attempt + 1)));
+        }
+    }
 }
 export async function deletePredictions(ids) {
     await apiPost('/api/v3/predictions/delete', { ids });
@@ -168,12 +204,13 @@ export async function submitPrediction(model, input, opts = {}) {
 }
 /**
  * Poll a prediction until it reaches a terminal status. `onTick` fires each
- * round so the caller can keep a spinner honest.
+ * round so the caller can keep a spinner honest. Transient status-read
+ * failures are retried; submit is never retried.
  */
 export async function waitForPrediction(id, opts = {}) {
     const interval = opts.intervalMs ?? 1000;
     for (;;) {
-        const item = await fetchPrediction(id);
+        const item = await fetchPredictionWithRetry(id, opts.retryDelayMs ?? 1000);
         opts.onTick?.(item.status);
         if (item.status === 'completed')
             return item;

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/cli",
-  "version": "0.4.9",
+  "version": "0.4.10",
   "description": "WaveSpeed CLI — one command to run any WaveSpeed AI model from your terminal.",
   "publishConfig": {
     "access": "public"