wavespeed 0.0.15 → 0.2.2

package/dist/api/client.js

@@ -0,0 +1,402 @@
+"use strict";
+/**
+ * WaveSpeed API client implementation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const config_1 = require("../config");
+/**
+ * WaveSpeed API client.
+ *
+ * Example:
+ *     const client = new Client("your-api-key");
+ *     const output = await client.run("wavespeed-ai/z-image/turbo", { prompt: "Cat" });
+ *
+ *     // With sync mode (single request, waits for result)
+ *     const output2 = await client.run("wavespeed-ai/z-image/turbo", { prompt: "Cat" }, { enableSyncMode: true });
+ *
+ *     // With retry
+ *     const output3 = await client.run("wavespeed-ai/z-image/turbo", { prompt: "Cat" }, { maxRetries: 3 });
+ */
+class Client {
+    /**
+     * Initialize the client.
+     *
+     * Args:
+     *     apiKey: WaveSpeed API key. If not provided, uses wavespeed.config.api.apiKey.
+     *     options.baseUrl: Base URL for the API. If not provided, uses wavespeed.config.api.baseUrl.
+     *     options.connectionTimeout: Timeout for HTTP requests in seconds.
+     *     options.timeout: Total API call timeout in seconds.
+     *     options.maxRetries: Maximum number of retries for the entire operation.
+     *     options.maxConnectionRetries: Maximum retries for individual HTTP requests.
+     *     options.retryInterval: Base interval between retries in seconds.
+     */
+    constructor(apiKey, options) {
+        var _a, _b, _c, _d, _e;
+        this.apiKey = apiKey || config_1.api.apiKey || '';
+        this.baseUrl = ((options === null || options === void 0 ? void 0 : options.baseUrl) || config_1.api.baseUrl).replace(/\/+$/, '');
+        this.connectionTimeout = (_a = options === null || options === void 0 ? void 0 : options.connectionTimeout) !== null && _a !== void 0 ? _a : config_1.api.connectionTimeout;
+        this.timeout = (_b = options === null || options === void 0 ? void 0 : options.timeout) !== null && _b !== void 0 ? _b : config_1.api.timeout;
+        this.maxRetries = (_c = options === null || options === void 0 ? void 0 : options.maxRetries) !== null && _c !== void 0 ? _c : config_1.api.maxRetries;
+        this.maxConnectionRetries = (_d = options === null || options === void 0 ? void 0 : options.maxConnectionRetries) !== null && _d !== void 0 ? _d : config_1.api.maxConnectionRetries;
+        this.retryInterval = (_e = options === null || options === void 0 ? void 0 : options.retryInterval) !== null && _e !== void 0 ? _e : config_1.api.retryInterval;
+    }
+    /**
+     * Get request headers with authentication.
+     */
+    _getHeaders() {
+        if (!this.apiKey) {
+            throw new Error('API key is required. Set WAVESPEED_API_KEY environment variable ' +
+                'or pass apiKey to Client().');
+        }
+        return {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${this.apiKey}`,
+        };
+    }
+    /**
+     * Submit a prediction request.
+     *
+     * Args:
+     *     model: Model identifier.
+     *     input: Input parameters.
+     *     enableSyncMode: If true, wait for result in single request.
+     *     timeout: Request timeout in seconds.
+     *
+     * Returns:
+     *     Tuple of [requestId, result]. In async mode, result is null.
+     *     In sync mode, requestId is null and result contains the response.
+     *
+     * Throws:
+     *     Error: If submission fails after retries.
+     */
+    async _submit(model, input, enableSyncMode = false, timeout) {
+        var _a, _b;
+        const url = `${this.baseUrl}/api/v3/${model}`;
+        const body = input ? { ...input } : {};
+        if (enableSyncMode) {
+            body.enable_sync_mode = true;
+        }
+        const requestTimeout = timeout !== null && timeout !== void 0 ? timeout : this.timeout;
+        // Use connection timeout for connect, request_timeout for read
+        const connectTimeout = requestTimeout
+            ? Math.min(this.connectionTimeout, requestTimeout)
+            : this.connectionTimeout;
+        const timeoutMs = connectTimeout * 1000;
+        let lastError;
+        // Connection-level retries
+        for (let retry = 0; retry <= this.maxConnectionRetries; retry++) {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const response = await fetch(url, {
+                    method: 'POST',
+                    headers: this._getHeaders(),
+                    body: JSON.stringify(body),
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    throw new Error(`Failed to submit prediction: HTTP ${response.status}: ${errorText}`);
+                }
+                const result = await response.json();
+                if (enableSyncMode) {
+                    return [null, result];
+                }
+                const requestId = (_a = result.data) === null || _a === void 0 ? void 0 : _a.id;
+                if (!requestId) {
+                    throw new Error(`No request ID in response: ${JSON.stringify(result)}`);
+                }
+                return [requestId, null];
+            }
+            catch (error) {
+                clearTimeout(timeoutId);
+                lastError = error;
+                const isConnectionError = error.name === 'AbortError' ||
+                    error.name === 'TypeError' ||
+                    ((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes('fetch'));
+                if (isConnectionError && retry < this.maxConnectionRetries) {
+                    const delay = this.retryInterval * (retry + 1) * 1000;
+                    console.log(`Connection error on attempt ${retry + 1}/${this.maxConnectionRetries + 1}:`);
+                    console.error(error);
+                    console.log(`Retrying in ${delay}ms...`);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+                else if (retry >= this.maxConnectionRetries) {
+                    throw new Error(`Failed to submit prediction after ${this.maxConnectionRetries + 1} attempts: ${lastError === null || lastError === void 0 ? void 0 : lastError.message}`);
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * Get prediction result.
+     *
+     * Args:
+     *     requestId: The prediction request ID.
+     *     timeout: Request timeout in seconds.
+     *
+     * Returns:
+     *     Full API response.
+     *
+     * Throws:
+     *     Error: If fetching result fails after retries.
+     */
+    async _getResult(requestId, timeout) {
+        var _a;
+        const url = `${this.baseUrl}/api/v3/predictions/${requestId}/result`;
+        const requestTimeout = timeout !== null && timeout !== void 0 ? timeout : this.timeout;
+        const connectTimeout = requestTimeout
+            ? Math.min(this.connectionTimeout, requestTimeout)
+            : this.connectionTimeout;
+        const timeoutMs = connectTimeout * 1000;
+        let lastError;
+        // Connection-level retries
+        for (let retry = 0; retry <= this.maxConnectionRetries; retry++) {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const response = await fetch(url, {
+                    method: 'GET',
+                    headers: this._getHeaders(),
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    throw new Error(`Failed to get result for task ${requestId}: HTTP ${response.status}: ${errorText}`);
+                }
+                return await response.json();
+            }
+            catch (error) {
+                clearTimeout(timeoutId);
+                lastError = error;
+                const isConnectionError = error.name === 'AbortError' ||
+                    error.name === 'TypeError' ||
+                    ((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes('fetch'));
+                if (isConnectionError && retry < this.maxConnectionRetries) {
+                    const delay = this.retryInterval * (retry + 1) * 1000;
+                    console.log(`Connection error getting result on attempt ${retry + 1}/${this.maxConnectionRetries + 1}:`);
+                    console.error(error);
+                    console.log(`Retrying in ${delay}ms...`);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+                else if (retry >= this.maxConnectionRetries) {
+                    throw new Error(`Failed to get result for task ${requestId} after ${this.maxConnectionRetries + 1} attempts: ${lastError === null || lastError === void 0 ? void 0 : lastError.message}`);
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * Wait for prediction to complete.
+     *
+     * Args:
+     *     requestId: The prediction request ID.
+     *     timeout: Maximum wait time in seconds (undefined = no timeout).
+     *     pollInterval: Time between polls in seconds.
+     *
+     * Returns:
+     *     Dict with "outputs" array.
+     *
+     * Throws:
+     *     Error: If prediction fails.
+     *     Error: If prediction times out.
+     */
+    async _wait(requestId, timeout, pollInterval) {
+        const startTime = Date.now();
+        while (true) {
+            // Check timeout
+            if (timeout !== undefined) {
+                const elapsed = (Date.now() - startTime) / 1000;
+                if (elapsed >= timeout) {
+                    throw new Error(`Prediction timed out after ${timeout} seconds (task_id: ${requestId})`);
+                }
+            }
+            const result = await this._getResult(requestId, timeout);
+            const data = result.data || {};
+            const status = data.status;
+            if (status === 'completed') {
+                return { outputs: data.outputs || [] };
+            }
+            if (status === 'failed') {
+                const error = data.error || 'Unknown error';
+                throw new Error(`Prediction failed (task_id: ${requestId}): ${error}`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollInterval * 1000));
+        }
+    }
+    /**
+     * Determine if an error is worth retrying at the task level.
+     *
+     * Args:
+     *     error: The exception to check.
+     *
+     * Returns:
+     *     True if the error is retryable.
+     */
+    _isRetryableError(error) {
+        if (!error)
+            return false;
+        // Always retry timeout and connection errors
+        const errorStr = error.toString().toLowerCase();
+        if (errorStr.includes('timeout') || errorStr.includes('connection')) {
+            return true;
+        }
+        // Retry server errors (5xx) and rate limiting (429)
+        if (errorStr.includes('http 5') || errorStr.includes('429')) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Run a model and wait for the output.
+     *
+     * Args:
+     *     model: Model identifier (e.g., "wavespeed-ai/flux-dev").
+     *     input: Input parameters for the model.
+     *     options.timeout: Maximum time to wait for completion (undefined = no timeout).
+     *     options.pollInterval: Interval between status checks in seconds.
+     *     options.enableSyncMode: If true, use synchronous mode (single request).
+     *     options.maxRetries: Maximum task-level retries (overrides client setting).
+     *
+     * Returns:
+     *     Dict containing "outputs" array with model outputs.
+     *
+     * Throws:
+     *     Error: If API key is not configured.
+     *     Error: If the prediction fails.
+     *     Error: If the prediction times out.
+     */
+    async run(model, input, options) {
+        var _a, _b, _c, _d;
+        const taskRetries = (_a = options === null || options === void 0 ? void 0 : options.maxRetries) !== null && _a !== void 0 ? _a : this.maxRetries;
+        const timeout = (_b = options === null || options === void 0 ? void 0 : options.timeout) !== null && _b !== void 0 ? _b : this.timeout;
+        const pollInterval = (_c = options === null || options === void 0 ? void 0 : options.pollInterval) !== null && _c !== void 0 ? _c : 1.0;
+        const enableSyncMode = (_d = options === null || options === void 0 ? void 0 : options.enableSyncMode) !== null && _d !== void 0 ? _d : false;
+        let lastError;
+        for (let attempt = 0; attempt <= taskRetries; attempt++) {
+            try {
+                const [requestId, syncResult] = await this._submit(model, input, enableSyncMode, timeout);
+                if (enableSyncMode) {
+                    // In sync mode, extract outputs from the result
+                    const data = (syncResult === null || syncResult === void 0 ? void 0 : syncResult.data) || {};
+                    const status = data.status;
+                    if (status !== 'completed') {
+                        const error = data.error || 'Unknown error';
+                        const requestId = data.id || 'unknown';
+                        throw new Error(`Prediction failed (task_id: ${requestId}): ${error}`);
+                    }
+                    return { outputs: data.outputs || [] };
+                }
+                if (requestId) {
+                    return await this._wait(requestId, timeout, pollInterval);
+                }
+                throw new Error('Invalid response from _submit');
+            }
+            catch (error) {
+                lastError = error;
+                const isRetryable = this._isRetryableError(error);
+                if (!isRetryable || attempt >= taskRetries) {
+                    throw error;
+                }
+                console.log(`Task attempt ${attempt + 1}/${taskRetries + 1} failed: ${error}`);
+                const delay = this.retryInterval * (attempt + 1) * 1000;
+                console.log(`Retrying in ${delay}ms...`);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+        // Should not reach here, but just in case
+        if (lastError) {
+            throw lastError;
+        }
+        throw new Error(`All ${taskRetries + 1} attempts failed`);
+    }
+    /**
+     * Upload a file to WaveSpeed.
+     *
+     * Args:
+     *     file: File path string to upload.
+     *     options.timeout: Total API call timeout in seconds.
+     *
+     * Returns:
+     *     URL of the uploaded file.
+     *
+     * Throws:
+     *     Error: If API key is not configured.
+     *     Error: If file path does not exist.
+     *     Error: If upload fails.
+     *
+     * Example:
+     *     const url = await client.upload("/path/to/image.png");
+     *     console.log(url);
+     */
+    async upload(file, options) {
+        var _a, _b;
+        if (!this.apiKey) {
+            throw new Error('API key is required. Set WAVESPEED_API_KEY environment variable ' +
+                'or pass apiKey to Client().');
+        }
+        const url = `${this.baseUrl}/api/v3/media/upload/binary`;
+        const headers = {
+            'Authorization': `Bearer ${this.apiKey}`,
+        };
+        const timeout = (_a = options === null || options === void 0 ? void 0 : options.timeout) !== null && _a !== void 0 ? _a : this.timeout;
+        const requestTimeout = Math.min(this.connectionTimeout, timeout);
+        const timeoutMs = requestTimeout * 1000;
+        // Node.js environment check
+        let fs;
+        let path;
+        try {
+            fs = require('fs');
+            path = require('path');
+        }
+        catch (err) {
+            throw new Error('File path uploads are only supported in Node.js environments.');
+        }
+        if (!fs.existsSync(file)) {
+            throw new Error(`File not found: ${file}`);
+        }
+        const data = fs.readFileSync(file);
+        const filename = path.basename(file);
+        const form = new FormData();
+        const blob = new Blob([data]);
+        form.append('file', blob, filename);
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers,
+                body: form,
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Failed to upload file: HTTP ${response.status}: ${errorText}`);
+            }
+            const result = await response.json();
+            if (result.code !== 200) {
+                throw new Error(`Upload failed: ${result.message || 'Unknown error'}`);
+            }
+            const downloadUrl = (_b = result.data) === null || _b === void 0 ? void 0 : _b.download_url;
+            if (!downloadUrl) {
+                throw new Error('Upload failed: no download_url in response');
+            }
+            return downloadUrl;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            throw error;
+        }
+    }
+}
+exports.Client = Client;

package/dist/api/index.d.ts

@@ -0,0 +1,86 @@
+/**
+ * WaveSpeed API client module.
+ *
+ * Provides a simple interface to run WaveSpeed AI models.
+ *
+ * Example usage:
+ *     import wavespeed from 'wavespeed';
+ *
+ *     const output = await wavespeed.run(
+ *         "wavespeed-ai/z-image/turbo",
+ *         { prompt: "A beautiful sunset over mountains" }
+ *     );
+ *
+ *     console.log(output["outputs"][0]);  // First output URL
+ *
+ *     // Upload a file
+ *     const url = await wavespeed.upload("/path/to/image.png");
+ *     console.log(url);
+ */
+import { Client } from './client';
+import type { RunOptions } from './client';
+export { Client };
+export type { RunOptions };
+/**
+ * Run a model and wait for the output.
+ *
+ * Args:
+ *     model: Model identifier (e.g., "wavespeed-ai/flux-dev").
+ *     input: Input parameters for the model.
+ *     options.timeout: Maximum time to wait for completion (undefined = no timeout).
+ *     options.pollInterval: Interval between status checks in seconds.
+ *     options.enableSyncMode: If true, use synchronous mode (single request).
+ *     options.maxRetries: Maximum retries for this request (overrides default setting).
+ *
+ * Returns:
+ *     Dict containing "outputs" array with model outputs.
+ *
+ * Throws:
+ *     Error: If API key is not configured.
+ *     Error: If the prediction fails.
+ *     Error: If the prediction times out.
+ *
+ * Example:
+ *     const output = await run(
+ *         "wavespeed-ai/z-image/turbo",
+ *         { prompt: "A cat sitting on a windowsill" }
+ *     );
+ *     console.log(output["outputs"][0]);  // First output URL
+ *
+ *     // With sync mode
+ *     const output2 = await run(
+ *         "wavespeed-ai/z-image/turbo",
+ *         { prompt: "A cat" },
+ *         { enableSyncMode: true }
+ *     );
+ *
+ *     // With retry
+ *     const output3 = await run(
+ *         "wavespeed-ai/z-image/turbo",
+ *         { prompt: "A cat" },
+ *         { maxRetries: 3 }
+ *     );
+ */
+export declare function run(model: string, input?: Record<string, any>, options?: RunOptions): Promise<Record<string, any>>;
+/**
+ * Upload a file to WaveSpeed.
+ *
+ * Args:
+ *     file: File path string to upload.
+ *     options.timeout: Total API call timeout in seconds.
+ *
+ * Returns:
+ *     URL of the uploaded file.
+ *
+ * Throws:
+ *     Error: If API key is not configured.
+ *     Error: If file path does not exist.
+ *     Error: If upload fails.
+ *
+ * Example:
+ *     const url = await upload("/path/to/image.png");
+ *     console.log(url);
+ */
+export declare function upload(file: string, options?: {
+    timeout?: number;
+}): Promise<string>;

package/dist/api/index.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * WaveSpeed API client module.
+ *
+ * Provides a simple interface to run WaveSpeed AI models.
+ *
+ * Example usage:
+ *     import wavespeed from 'wavespeed';
+ *
+ *     const output = await wavespeed.run(
+ *         "wavespeed-ai/z-image/turbo",
+ *         { prompt: "A beautiful sunset over mountains" }
+ *     );
+ *
+ *     console.log(output["outputs"][0]);  // First output URL
+ *
+ *     // Upload a file
+ *     const url = await wavespeed.upload("/path/to/image.png");
+ *     console.log(url);
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+exports.run = run;
+exports.upload = upload;
+const client_1 = require("./client");
+Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
+// Default client instance
+let _defaultClient = null;
+/**
+ * Get or create the default client instance.
+ */
+function _getDefaultClient() {
+    if (_defaultClient === null) {
+        _defaultClient = new client_1.Client();
+    }
+    return _defaultClient;
+}
+/**
+ * Run a model and wait for the output.
+ *
+ * Args:
+ *     model: Model identifier (e.g., "wavespeed-ai/flux-dev").
+ *     input: Input parameters for the model.
+ *     options.timeout: Maximum time to wait for completion (undefined = no timeout).
+ *     options.pollInterval: Interval between status checks in seconds.
+ *     options.enableSyncMode: If true, use synchronous mode (single request).
+ *     options.maxRetries: Maximum retries for this request (overrides default setting).
+ *
+ * Returns:
+ *     Dict containing "outputs" array with model outputs.
+ *
+ * Throws:
+ *     Error: If API key is not configured.
+ *     Error: If the prediction fails.
+ *     Error: If the prediction times out.
+ *
+ * Example:
+ *     const output = await run(
+ *         "wavespeed-ai/z-image/turbo",
+ *         { prompt: "A cat sitting on a windowsill" }
+ *     );
+ *     console.log(output["outputs"][0]);  // First output URL
+ *
+ *     // With sync mode
+ *     const output2 = await run(
+ *         "wavespeed-ai/z-image/turbo",
+ *         { prompt: "A cat" },
+ *         { enableSyncMode: true }
+ *     );
+ *
+ *     // With retry
+ *     const output3 = await run(
+ *         "wavespeed-ai/z-image/turbo",
+ *         { prompt: "A cat" },
+ *         { maxRetries: 3 }
+ *     );
+ */
+async function run(model, input, options) {
+    return _getDefaultClient().run(model, input, options);
+}
+/**
+ * Upload a file to WaveSpeed.
+ *
+ * Args:
+ *     file: File path string to upload.
+ *     options.timeout: Total API call timeout in seconds.
+ *
+ * Returns:
+ *     URL of the uploaded file.
+ *
+ * Throws:
+ *     Error: If API key is not configured.
+ *     Error: If file path does not exist.
+ *     Error: If upload fails.
+ *
+ * Example:
+ *     const url = await upload("/path/to/image.png");
+ *     console.log(url);
+ */
+async function upload(file, options) {
+    return _getDefaultClient().upload(file, options);
+}

package/dist/config.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Configuration module for WaveSpeed SDK.
+ */
+/**
+ * API client configuration options.
+ */
+export declare class api {
+    static apiKey: string | undefined;
+    static baseUrl: string;
+    static connectionTimeout: number;
+    static timeout: number;
+    static maxRetries: number;
+    static maxConnectionRetries: number;
+    static retryInterval: number;
+}

package/dist/config.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Configuration module for WaveSpeed SDK.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.api = void 0;
+/**
+ * Get environment variable value (works in both Node.js and browser)
+ */
+function getEnv(name) {
+    if (typeof process !== 'undefined' && process.env && process.env[name]) {
+        return process.env[name];
+    }
+    return undefined;
+}
+/**
+ * API client configuration options.
+ */
+class api {
+}
+exports.api = api;
+// Authentication
+api.apiKey = getEnv('WAVESPEED_API_KEY');
+// API base URL
+api.baseUrl = 'https://api.wavespeed.ai';
+// Connection timeout in seconds
+api.connectionTimeout = 10.0;
+// Total API call timeout in seconds
+api.timeout = 36000.0;
+// Maximum number of retries for the entire operation (task-level retries)
+api.maxRetries = 0;
+// Maximum number of retries for individual HTTP requests (connection errors, timeouts)
+api.maxConnectionRetries = 5;
+// Base interval between retries in seconds (actual delay = retryInterval * attempt)
+api.retryInterval = 1.0;