wavespeed 0.0.1

package/README.md

@@ -0,0 +1,145 @@
+# WaveSpeed JavaScript/TypeScript Client
+
+A JavaScript/TypeScript client for the WaveSpeed AI image generation API. This client is compatible with both JavaScript and TypeScript projects.
+
+## Installation
+
+```bash
+npm install wavespeed
+```
+
+## Usage
+
+### JavaScript
+
+```javascript
+const { WaveSpeed } = require('wavespeed');
+
+// Initialize the client with your API key
+const client = new WaveSpeed('YOUR_API_KEY');
+
+// Generate an image and wait for the result
+async function generateImage() {
+  const prediction = await client.run(
+    'wavespeed-ai/flux-dev',
+    {
+      prompt: 'A futuristic cityscape with flying cars and neon lights',
+      size: '1024*1024',
+      num_inference_steps: 28,
+      guidance_scale: 5.0,
+      num_images: 1,
+      seed: -1,
+      enable_safety_checker: true
+    }
+  );
+
+  // Print the generated image URLs
+  prediction.outputs.forEach((imgUrl, i) => {
+    console.log(`Image ${i+1}: ${imgUrl}`);
+  });
+}
+
+generateImage().catch(console.error);
+```
+
+### TypeScript
+
+```typescript
+import WaveSpeed from 'wavespeed';
+
+// Initialize the client with your API key
+const client = new WaveSpeed('YOUR_API_KEY');
+
+// Generate an image and wait for the result
+async function generateImage(): Promise<void> {
+  const input: Record<string, any> = {
+    prompt: 'A futuristic cityscape with flying cars and neon lights',
+    size: '1024*1024',
+    num_inference_steps: 28,
+    guidance_scale: 5.0,
+    num_images: 1,
+    seed: -1,
+    enable_safety_checker: true
+  };
+
+  const prediction = await client.run('wavespeed-ai/flux-dev', input);
+
+  // Print the generated image URLs
+  prediction.outputs.forEach((imgUrl, i) => {
+    console.log(`Image ${i+1}: ${imgUrl}`);
+  });
+}
+
+generateImage().catch(console.error);
+```
+
+## API Reference
+
+### WaveSpeed Client
+
+```typescript
+new WaveSpeed(apiKey?: string, options?: {
+  baseUrl?: string,
+  pollInterval?: number,
+  timeout?: number
+})
+```
+
+#### Parameters:
+- `apiKey` (string): Your WaveSpeed API key
+- `options` (object, optional):
+  - `baseUrl` (string): API base URL (default: 'https://api.wavespeed.ai/api/v2/')
+  - `pollInterval` (number): Interval in seconds for polling prediction status (default: 1)
+  - `timeout` (number): Timeout in seconds for API requests (default: 60)
+
+### Methods
+
+#### run
+
+```typescript
+run(modelId: string, input: Record<string, any>, options?: RequestOptions): Promise<Prediction>
+```
+
+Generate an image and wait for the result.
+
+#### create
+
+```typescript
+create(modelId: string, input: Record<string, any>, options?: RequestOptions): Promise<Prediction>
+```
+
+Create a prediction without waiting for it to complete.
+
+### Prediction Model
+
+The Prediction object contains information about an image generation job:
+
+```typescript
+prediction.id           // Unique ID of the prediction
+prediction.model        // Model ID used for the prediction
+prediction.status       // Status of the prediction (processing, completed, failed)
+prediction.input        // Input parameters used for the prediction
+prediction.outputs      // List of output image URLs
+prediction.urls.get     // URL to get the prediction status
+prediction.has_nsfw_contents // List of booleans indicating if each image has NSFW content
+prediction.created_at   // Creation timestamp
+prediction.error        // Error message (if any)
+prediction.executionTime // Time taken to execute the prediction in milliseconds
+```
+
+#### Methods
+
+```typescript
+prediction.wait(): Promise<Prediction>  // Wait for the prediction to complete
+prediction.reload(): Promise<Prediction>  // Reload the prediction status
+```
+
+## Environment Variables
+
+- `WAVESPEED_API_KEY`: Your WaveSpeed API key
+- `WAVESPEED_POLL_INTERVAL`: Interval in seconds for polling prediction status (default: 1)
+- `WAVESPEED_TIMEOUT`: Timeout in seconds for API requests (default: 60)
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Input parameters for image generation
+ */
+/**
+ * Prediction status
+ */
+export type PredictionStatus = 'created' | 'processing' | 'completed' | 'failed';
+/**
+ * Prediction URLs
+ */
+export interface PredictionUrls {
+    get: string;
+}
+/**
+ * Request options for fetch
+ */
+export interface RequestOptions extends RequestInit {
+    timeout?: number;
+}
+/**
+ * Prediction model representing an image generation job
+ */
+export declare class Prediction {
+    id: string;
+    model: string;
+    status: PredictionStatus;
+    input: Record<string, any>;
+    outputs: string[];
+    urls: PredictionUrls;
+    has_nsfw_contents: boolean[];
+    created_at: string;
+    error?: string;
+    executionTime?: number;
+    private client;
+    constructor(data: any, client: WaveSpeed);
+    /**
+     * Wait for the prediction to complete
+     */
+    wait(): Promise<Prediction>;
+    /**
+     * Reload the prediction status
+     */
+    reload(): Promise<Prediction>;
+}
+/**
+ * WaveSpeed client for generating images
+ */
+export declare class WaveSpeed {
+    private apiKey;
+    private baseUrl;
+    readonly pollInterval: number;
+    readonly timeout: number;
+    /**
+     * Create a new WaveSpeed client
+     *
+     * @param apiKey Your WaveSpeed API key (or set WAVESPEED_API_KEY environment variable)
+     * @param options Additional client options
+     */
+    constructor(apiKey?: string, options?: {
+        baseUrl?: string;
+        pollInterval?: number;
+        timeout?: number;
+    });
+    /**
+     * Fetch with timeout support
+     *
+     * @param path API path
+     * @param options Fetch options
+     */
+    fetchWithTimeout(path: string, options?: RequestOptions): Promise<Response>;
+    /**
+     * Generate an image and wait for the result
+     *
+     * @param modelId Model ID to use for prediction
+     * @param input Input parameters for the prediction
+     * @param options Additional fetch options
+     */
+    run(modelId: string, input: Record<string, any>, options?: RequestOptions): Promise<Prediction>;
+    /**
+     * Create a prediction without waiting for it to complete
+     *
+     * @param modelId Model ID to use for prediction
+     * @param input Input parameters for the prediction
+     * @param options Additional fetch options
+     */
+    create(modelId: string, input: Record<string, any>, options?: RequestOptions): Promise<Prediction>;
+}
+export default WaveSpeed;

package/dist/index.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaveSpeed = exports.Prediction = void 0;
+const url_1 = require("url");
+/**
+ * Prediction model representing an image generation job
+ */
+class Prediction {
+    constructor(data, client) {
+        this.id = data.id;
+        this.model = data.model;
+        this.status = data.status;
+        this.input = data.input;
+        this.outputs = data.outputs || [];
+        this.urls = data.urls;
+        this.has_nsfw_contents = data.has_nsfw_contents || [];
+        this.created_at = data.created_at;
+        this.error = data.error;
+        this.executionTime = data.executionTime;
+        this.client = client;
+    }
+    /**
+     * Wait for the prediction to complete
+     */
+    async wait() {
+        if (this.status === 'completed' || this.status === 'failed') {
+            return this;
+        }
+        return new Promise((resolve, reject) => {
+            const checkStatus = async () => {
+                try {
+                    const updated = await this.reload();
+                    if (updated.status === 'completed' || updated.status === 'failed') {
+                        resolve(updated);
+                    }
+                    else {
+                        setTimeout(checkStatus, this.client.pollInterval * 1000);
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                }
+            };
+            checkStatus();
+        });
+    }
+    /**
+     * Reload the prediction status
+     */
+    async reload() {
+        const response = await this.client.fetchWithTimeout(`predictions/${this.id}/result`);
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to reload prediction: ${response.status} ${errorText}`);
+        }
+        const data = await response.json();
+        const updatedPrediction = new Prediction(data.data, this.client);
+        // Update this instance with new data
+        Object.assign(this, updatedPrediction);
+        return this;
+    }
+}
+exports.Prediction = Prediction;
+/**
+ * WaveSpeed client for generating images
+ */
+class WaveSpeed {
+    /**
+     * Create a new WaveSpeed client
+     *
+     * @param apiKey Your WaveSpeed API key (or set WAVESPEED_API_KEY environment variable)
+     * @param options Additional client options
+     */
+    constructor(apiKey, options = {}) {
+        this.baseUrl = 'https://api.wavespeed.ai/api/v2/';
+        this.apiKey = apiKey || process.env.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;
+    }
+    /**
+     * Fetch with timeout support
+     *
+     * @param path API path
+     * @param options Fetch options
+     */
+    async fetchWithTimeout(path, options = {}) {
+        const { timeout = this.timeout * 1000, ...fetchOptions } = options;
+        // Ensure headers exist
+        fetchOptions.headers = {
+            ...fetchOptions.headers,
+            '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);
+        }
+    }
+    /**
+     * Generate an image and wait for the result
+     *
+     * @param modelId Model ID to use for prediction
+     * @param input Input parameters for the prediction
+     * @param options Additional fetch options
+     */
+    async run(modelId, input, options) {
+        const prediction = await this.create(modelId, input, options);
+        return prediction.wait();
+    }
+    /**
+     * Create a prediction without waiting for it to complete
+     *
+     * @param modelId Model ID to use for prediction
+     * @param input Input parameters for the prediction
+     * @param options Additional fetch options
+     */
+    async create(modelId, input, options) {
+        const response = await this.fetchWithTimeout(`${modelId}`, {
+            method: 'POST',
+            body: JSON.stringify(input),
+            ...options
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to create prediction: ${response.status} ${errorText}`);
+        }
+        const data = await response.json();
+        return new Prediction(data.data, this);
+    }
+}
+exports.WaveSpeed = WaveSpeed;
+// Export default and named exports for different import styles
+exports.default = WaveSpeed;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "wavespeed",
+  "version": "0.0.1",
+  "description": "Client SDK for Wavespeed API",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src --ext .ts",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "api",
+    "client",
+    "sdk",
+    "wavespeed"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.5",
+    "@types/node": "^20.8.2",
+    "@typescript-eslint/eslint-plugin": "^6.7.4",
+    "@typescript-eslint/parser": "^6.7.4",
+    "eslint": "^8.50.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.2.2"
+  },
+  "dependencies": {},
+  "files": [
+    "dist"
+  ]
+}