wavespeed 0.0.2 → 0.0.4

package/dist/index.d.ts

@@ -16,6 +16,7 @@ export interface PredictionUrls {
  */
 export interface RequestOptions extends RequestInit {
     timeout?: number;
+    maxRetries?: number;
 }
 /**
  * Prediction model representing an image generation job
@@ -68,6 +69,14 @@ export declare class WaveSpeed {
      * @param options Fetch options
      */
     fetchWithTimeout(path: string, options?: RequestOptions): Promise<Response>;
+    /**
+     * Calculate backoff time with exponential backoff and jitter
+     * @param retryCount Current retry attempt number
+     * @param initialBackoff Initial backoff time in ms
+     * @returns Backoff time in ms
+     * @private
+     */
+    _getBackoffTime(retryCount: number, initialBackoff: number): number;
     /**
      * Generate an image and wait for the result
      *

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+/**
+ * Input parameters for image generation
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaveSpeed = exports.Prediction = void 0;
-const url_1 = require("url");
 /**
  * Prediction model representing an image generation job
  */
@@ -73,15 +75,23 @@ class WaveSpeed {
      */
     constructor(apiKey, options = {}) {
         this.baseUrl = 'https://api.wavespeed.ai/api/v2/';
-        this.apiKey = apiKey || process.env.WAVESPEED_API_KEY || '';
+        // Browser-friendly environment variable handling
+        const getEnvVar = (name) => {
+            // Try to get from process.env for Node.js environments
+            if (typeof process !== 'undefined' && process.env && process.env[name]) {
+                return process.env[name];
+            }
+            return undefined;
+        };
+        this.apiKey = apiKey || getEnvVar('WAVESPEED_API_KEY') || '';
         if (!this.apiKey) {
             throw new Error('API key is required. Provide it as a parameter or set the WAVESPEED_API_KEY environment variable.');
         }
         if (options.baseUrl) {
             this.baseUrl = options.baseUrl;
         }
-        this.pollInterval = options.pollInterval || Number(process.env.WAVESPEED_POLL_INTERVAL) || 1;
-        this.timeout = options.timeout || Number(process.env.WAVESPEED_TIMEOUT) || 60;
+        this.pollInterval = options.pollInterval || Number(getEnvVar('WAVESPEED_POLL_INTERVAL')) || 1;
+        this.timeout = options.timeout || Number(getEnvVar('WAVESPEED_TIMEOUT')) || 60;
     }
     /**
      * Fetch with timeout support
@@ -97,21 +107,78 @@ class WaveSpeed {
             'Authorization': `Bearer ${this.apiKey}`,
             'Content-Type': 'application/json'
         };
-        const controller = new AbortController();
-        const id = setTimeout(() => controller.abort(), timeout);
-        try {
-            // Construct the full URL by joining baseUrl and path
-            const url = new url_1.URL(path, this.baseUrl).toString();
-            const response = await fetch(url, {
-                ...fetchOptions,
-                signal: controller.signal
-            });
-            return response;
-        }
-        finally {
-            clearTimeout(id);
+        // Default retry options
+        const maxRetries = options.maxRetries || 3;
+        const initialBackoff = 1000; // 1 second
+        let retryCount = 0;
+        // Function to determine if a response should be retried
+        const shouldRetry = (response) => {
+            // Retry on rate limit (429) for all requests
+            // For GET requests, also retry on server errors (5xx)
+            const method = (fetchOptions.method || 'GET').toUpperCase();
+            return response.status === 429 || (method === 'GET' && response.status >= 500);
+        };
+        while (true) {
+            // Use AbortController for timeout (supported in modern browsers)
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+            try {
+                // Construct the full URL by joining baseUrl and path
+                const url = new URL(path.startsWith('/') ? path.substring(1) : path, this.baseUrl).toString();
+                const response = await fetch(url, {
+                    ...fetchOptions,
+                    signal: controller.signal
+                });
+                // If the response is successful or we've used all retries, return it
+                if (response.ok || !shouldRetry(response) || retryCount >= maxRetries) {
+                    return response;
+                }
+                // Otherwise, increment retry count and wait before retrying
+                retryCount++;
+                const backoffTime = this._getBackoffTime(retryCount, initialBackoff);
+                // Log retry information if console is available
+                if (typeof console !== 'undefined') {
+                    console.warn(`Request failed with status ${response.status}. Retrying (${retryCount}/${maxRetries}) in ${Math.round(backoffTime)}ms...`);
+                }
+                // Wait for backoff time before retrying
+                await new Promise(resolve => setTimeout(resolve, backoffTime));
+            }
+            catch (error) {
+                // If the error is due to timeout or network issues and we have retries left
+                if (error instanceof Error &&
+                    (error.name === 'AbortError' || error.name === 'TypeError') &&
+                    retryCount < maxRetries) {
+                    retryCount++;
+                    const backoffTime = this._getBackoffTime(retryCount, initialBackoff);
+                    // Log retry information if console is available
+                    if (typeof console !== 'undefined') {
+                        console.warn(`Request failed with error: ${error.message}. Retrying (${retryCount}/${maxRetries}) in ${Math.round(backoffTime)}ms...`);
+                    }
+                    // Wait for backoff time before retrying
+                    await new Promise(resolve => setTimeout(resolve, backoffTime));
+                }
+                else {
+                    // If we're out of retries or it's a non-retryable error, throw it
+                    throw error;
+                }
+            }
+            finally {
+                clearTimeout(timeoutId);
+            }
         }
     }
+    /**
+     * Calculate backoff time with exponential backoff and jitter
+     * @param retryCount Current retry attempt number
+     * @param initialBackoff Initial backoff time in ms
+     * @returns Backoff time in ms
+     * @private
+     */
+    _getBackoffTime(retryCount, initialBackoff) {
+        const backoff = initialBackoff * Math.pow(2, retryCount);
+        // Add jitter (random value between 0 and backoff/2)
+        return backoff + Math.random() * (backoff / 2);
+    }
     /**
      * Generate an image and wait for the result
      *
@@ -147,3 +214,7 @@ class WaveSpeed {
 exports.WaveSpeed = WaveSpeed;
 // Export default and named exports for different import styles
 exports.default = WaveSpeed;
+// Add browser global for UMD-style usage
+if (typeof window !== 'undefined') {
+    window.WaveSpeed = WaveSpeed;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wavespeed",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "WaveSpeed Client SDK for Wavespeed API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,4 +34,4 @@
   "files": [
     "dist"
   ]
-}
+}