muapi-js 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SamurAIGPT
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,219 @@
+<<<<<<< HEAD
+# MuAPI JavaScript SDK
+
+Official JavaScript SDK for MuAPI.
+
+Generate images, videos, audio, edit media, upload files, track predictions, and access MuAPI models directly from Node.js applications.
+
+---
+
+## Installation
+
+```bash
+npm install muapi-js
+```
+
+---
+
+## Authentication
+
+```javascript
+import { MuAPI } from "muapi-js";
+
+const client = new MuAPI("YOUR_API_KEY");
+```
+
+---
+
+# Quick Start
+
+## Generate an Image
+
+```javascript
+import { MuAPI } from "muapi-js";
+
+const client = new MuAPI("YOUR_API_KEY");
+
+const result = await client.images.generate({
+  prompt: "A futuristic city at sunset",
+  model: "flux-dev",
+});
+
+console.log(result);
+```
+
+---
+
+## Edit an Image
+
+```javascript
+const result = await client.images.edit({
+  prompt: "Turn this image into anime style",
+  image: "https://example.com/image.jpg",
+  model: "flux-kontext-dev",
+});
+
+console.log(result);
+```
+
+---
+
+## Generate a Video
+
+```javascript
+const result = await client.videos.generate({
+  prompt: "A cinematic drone shot over mountains",
+  model: "kling-master",
+});
+
+console.log(result);
+```
+
+---
+
+## Image to Video
+
+```javascript
+const result = await client.videos.fromImage({
+  prompt: "The subject smiles and waves",
+  image: "https://example.com/image.jpg",
+  model: "kling-master",
+});
+
+console.log(result);
+```
+
+---
+
+## Generate Audio
+
+```javascript
+const result = await client.audio.fromText({
+  prompt: "Relaxing ocean waves",
+  duration: 10,
+});
+
+console.log(result);
+```
+
+---
+
+## Upload Files
+
+```javascript
+const upload = await client.uploads.upload(
+  "./image.jpg"
+);
+
+console.log(upload);
+```
+
+---
+
+## Track Predictions
+
+```javascript
+const image = await client.images.generate({
+  prompt: "A futuristic city",
+});
+
+const result = await client.predictions.wait(
+  image.request_id || image.id
+);
+
+console.log(result);
+```
+
+---
+
+## Models API
+
+### List Categories
+
+```javascript
+console.log(
+  client.models.categories()
+);
+```
+
+### Get Model Details
+
+```javascript
+console.log(
+  client.models.get("flux-dev")
+);
+```
+
+---
+
+## Account API
+
+```javascript
+const balance =
+  await client.account.balance();
+
+console.log(balance);
+```
+
+---
+
+## Error Handling
+
+```javascript
+import {
+  MuAPI,
+  MuAPIError
+} from "muapi-js";
+
+try {
+  await client.images.generate({
+    prompt: "test"
+  });
+} catch (error) {
+  if (error instanceof MuAPIError) {
+    console.log(error.status);
+    console.log(error.message);
+  }
+}
+```
+
+---
+
+## Examples
+
+```text
+examples/
+├── image-generate.js
+├── image-edit.js
+├── video-generate.js
+├── image-to-video.js
+├── audio-generate.js
+├── upload-file.js
+├── prediction-test.js
+├── models-list.js
+└── account-balance.js
+```
+
+---
+
+## Features
+
+* Image Generation
+* Image Editing
+* Video Generation
+* Image-to-Video
+* Audio Generation
+* File Uploads
+* Prediction Polling
+* Model Discovery
+* Account Management
+* Custom Error Handling
+
+---
+
+## License
+
+MIT
+=======
+# muapi-javascript
+Javascript sdk for Muapi

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "muapi-js",
+  "version": "1.0.0",
+  "description": "Official JavaScript SDK for MuAPI",
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "muapi",
+    "ai",
+    "image-generation",
+    "video-generation",
+    "audio-generation"
+  ],
+  "author": "MuAPI",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.10.0",
+    "form-data": "^4.0.4"
+  }
+}

package/src/account.js

@@ -0,0 +1,17 @@
+export class AccountAPI {
+    constructor(client) {
+        this.client = client;
+    }
+
+    async balance() {
+        return this.client.get(
+            "account/balance"
+        );
+    }
+
+    async info() {
+        return this.client.get(
+            "account/balance"
+        );
+    }
+}

package/src/audio.js

@@ -0,0 +1,19 @@
+export class AudioAPI {
+    constructor(client) {
+        this.client = client;
+    }
+
+    async fromText({
+        prompt,
+        duration = 10,
+        model = "mmaudio"
+    }) {
+        return this.client.post(
+            "mmaudio-v2/text-to-audio",
+            {
+                prompt,
+                duration
+            }
+        );
+    }
+}

package/src/client.js

@@ -0,0 +1,84 @@
+import axios from "axios";
+import { MuAPIError } from "./errors.js";
+
+const BASE_URL = "https://api.muapi.ai/api/v1";
+
+export class MuAPIClient {
+    constructor(apiKey) {
+        if (!apiKey) {
+            throw new MuAPIError(
+                "API key is required. Pass your MuAPI API key when creating the client."
+            );
+        }
+
+        this.apiKey = apiKey;
+    }
+
+    headers() {
+        return {
+            "x-api-key": this.apiKey,
+            "Content-Type": "application/json",
+        };
+    }
+
+    async post(endpoint, payload) {
+        try {
+            const response = await axios.post(
+                `${BASE_URL}/${endpoint}`,
+                payload,
+                {
+                    headers: this.headers(),
+                }
+            );
+
+            return response.data;
+        } catch (error) {
+            throw new MuAPIError(
+                error.response?.data?.detail ||
+                error.message,
+                error.response?.status,
+                error.response?.data
+            );
+        }
+    }
+
+    async get(endpoint) {
+        try {
+            const response = await axios.get(
+                `${BASE_URL}/${endpoint}`,
+                {
+                    headers: this.headers(),
+                }
+            );
+
+            return response.data;
+        } catch (error) {
+            throw new MuAPIError(
+                error.response?.data?.detail ||
+                error.message,
+                error.response?.status,
+                error.response?.data
+            );
+        }
+    }
+
+    async getPrediction(id) {
+        try {
+            const response = await axios.get(
+                `${BASE_URL}/predictions/${id}/result`,
+                {
+                    headers: this.headers(),
+                }
+            );
+
+            return response.data;
+        } catch (error) {
+            throw new MuAPIError(
+                error.response?.data?.detail ||
+                error.message,
+                error.response?.status,
+                error.response?.data
+            );
+        }
+    }
+}

package/src/errors.js

@@ -0,0 +1,9 @@
+export class MuAPIError extends Error {
+    constructor(message, status = null, data = null) {
+        super(message);
+
+        this.name = "MuAPIError";
+        this.status = status;
+        this.data = data;
+    }
+}

package/src/images.js

@@ -0,0 +1,63 @@
+import {
+    T2I_MODELS,
+    I2I_MODELS
+} from "./modelRegistry.js";
+
+export class ImagesAPI {
+    constructor(client) {
+        this.client = client;
+    }
+
+    async generate({
+        prompt,
+        model = "flux-dev",
+        numImages = 1,
+        width = 1024,
+        height = 1024,
+    }) {
+        const endpoint = T2I_MODELS[model];
+
+        if (!endpoint) {
+            throw new Error(
+                `Unknown model: ${model}`
+            );
+        }
+
+        return this.client.post(endpoint, {
+            prompt,
+            num_images: numImages,
+            width,
+            height,
+        });
+    }
+
+    async edit({
+        prompt,
+        image,
+        model = "flux-kontext-dev",
+        aspectRatio = "1:1",
+        numImages = 1,
+    }) {
+        const endpoint = I2I_MODELS[model];
+
+        if (!endpoint) {
+            throw new Error(
+                `Unknown model: ${model}`
+            );
+        }
+
+        return this.client.post(endpoint, {
+            prompt,
+            image_url: image,
+            aspect_ratio: aspectRatio,
+            num_images: numImages,
+        });
+    }
+
+    models() {
+        return {
+            textToImage: Object.keys(T2I_MODELS),
+            imageToImage: Object.keys(I2I_MODELS),
+        };
+    }
+}

package/src/index.js

@@ -0,0 +1,33 @@
+import { MuAPIClient } from "./client.js";
+import { ImagesAPI } from "./images.js";
+import { VideosAPI } from "./videos.js";
+import { AudioAPI } from "./audio.js";
+import { PredictionsAPI } from "./predictions.js";
+import { UploadsAPI } from "./uploads.js";
+import { ModelsAPI } from "./model.js";
+import { AccountAPI } from "./account.js";
+
+export class MuAPI {
+    constructor(apiKey) {
+        const client = new MuAPIClient(apiKey);
+
+        this.images = new ImagesAPI(client);
+        this.videos = new VideosAPI(client);
+        this.audio = new AudioAPI(client);
+        this.predictions = new PredictionsAPI(client);
+        this.uploads = new UploadsAPI(client);
+        this.models = new ModelsAPI();
+        this.account = new AccountAPI(client);
+    }
+}
+
+export {
+    ImagesAPI,
+    VideosAPI,
+    AudioAPI,
+    PredictionsAPI,
+    UploadsAPI,
+    ModelsAPI,
+    AccountAPI
+};
+export { MuAPIError } from "./errors.js";

package/src/model.js

@@ -0,0 +1,92 @@
+import {
+    T2I_MODELS,
+    T2V_MODELS,
+    I2V_MODELS
+} from "./modelRegistry.js";
+
+export class ModelsAPI {
+    list(category = "all") {
+        switch (category) {
+            case "image":
+                return T2I_MODELS;
+
+            case "text-to-video":
+                return T2V_MODELS;
+
+            case "image-to-video":
+                return I2V_MODELS;
+
+            case "video":
+                return {
+                    textToVideo: T2V_MODELS,
+                    imageToVideo: I2V_MODELS,
+                };
+
+            case "all":
+            default:
+                return {
+                    image: T2I_MODELS,
+                    textToVideo: T2V_MODELS,
+                    imageToVideo: I2V_MODELS,
+                };
+        }
+    }
+
+    categories() {
+        return [
+            "image",
+            "text-to-video",
+            "image-to-video",
+        ];
+    }
+
+    get(modelName) {
+        if (modelName in T2I_MODELS) {
+            return {
+                name: modelName,
+                category: "image",
+                endpoint: T2I_MODELS[modelName],
+            };
+        }
+
+        if (modelName in T2V_MODELS) {
+            return {
+                name: modelName,
+                category: "text-to-video",
+                endpoint: T2V_MODELS[modelName],
+            };
+        }
+
+        if (modelName in I2V_MODELS) {
+            return {
+                name: modelName,
+                category: "image-to-video",
+                endpoint: I2V_MODELS[modelName],
+            };
+        }
+
+        throw new Error(
+            `Model '${modelName}' not found`
+        );
+    }
+
+    exists(modelName) {
+        return (
+            modelName in T2I_MODELS ||
+            modelName in T2V_MODELS ||
+            modelName in I2V_MODELS
+        );
+    }
+
+    imageModels() {
+        return Object.keys(T2I_MODELS);
+    }
+
+    textToVideoModels() {
+        return Object.keys(T2V_MODELS);
+    }
+
+    imageToVideoModels() {
+        return Object.keys(I2V_MODELS);
+    }
+}

package/src/modelRegistry.js

@@ -0,0 +1,200 @@
+export const T2I_MODELS = {
+    // Flux
+    "flux-dev": "flux-dev-image",
+    "flux-schnell": "flux-schnell-image",
+    "flux-krea": "flux-krea-dev",
+    "flux-kontext-dev": "flux-kontext-dev-t2i",
+    "flux-kontext-pro": "flux-kontext-pro-t2i",
+    "flux-kontext-max": "flux-kontext-max-t2i",
+    "flux-2-dev": "flux-2-dev",
+    "flux-2-pro": "flux-2-pro",
+    "flux-2-flex": "flux-2-flex",
+
+    // HiDream
+    "hidream-fast": "hidream_i1_fast_image",
+    "hidream-dev": "hidream_i1_dev_image",
+    "hidream-full": "hidream_i1_full_image",
+
+    // Wan
+    "wan2.1": "wan2.1-text-to-image",
+    "wan2.5": "wan2.5-text-to-image",
+    "wan2.6": "wan2.6-text-to-image",
+    "wan2.7": "wan2.7-text-to-image",
+
+    // GPT
+    "gpt4o": "gpt4o-text-to-image",
+    "gpt-image": "gpt-image-1.5",
+    "gpt-image-2": "gpt-image-2-text-to-image",
+
+    // Google
+    "imagen4": "google-imagen4",
+    "imagen4-fast": "google-imagen4-fast",
+    "imagen4-ultra": "google-imagen4-ultra",
+
+    // Midjourney
+    "midjourney": "midjourney-v7-text-to-image",
+    "midjourney-v7": "midjourney-v7",
+    "midjourney-v8": "midjourney-v8",
+    "midjourney-niji": "midjourney-niji",
+
+    // Seedream
+    "seedream": "bytedance-seedream-v4.5",
+    "seedream-v3": "bytedance-seedream-image",
+    "seedream-v4": "bytedance-seedream-v4",
+    "seedream-v4.5": "bytedance-seedream-v4.5",
+    "seedream-5": "seedream-5.0",
+
+    // Qwen
+    "qwen": "qwen-image",
+    "qwen-2": "qwen-image-2.0",
+    "qwen-2-pro": "qwen-image-2.0-pro",
+
+    // Nano Banana
+    "nano-banana": "nano-banana",
+    "nano-banana-pro": "nano-banana-pro",
+    "nano-banana-2": "nano-banana-2",
+
+    // Kling
+    "kling-o1": "kling-o1-text-to-image",
+    "kling-o3": "kling-o3-image",
+
+    // Others
+    "hunyuan": "hunyuan-image-2.1",
+    "hunyuan-3": "hunyuan-image-3.0",
+    "ideogram": "ideogram-v3-t2i",
+    "reve": "reve-text-to-image",
+    "sdxl": "sdxl-image",
+    "grok": "grok-imagine-text-to-image"
+};
+
+export const I2I_MODELS = {
+    "flux-kontext-dev": "flux-kontext-dev-i2i",
+    "flux-kontext-pro": "flux-kontext-pro-i2i",
+    "flux-kontext-max": "flux-kontext-max-i2i",
+
+    "gpt4o": "gpt4o-image-to-image",
+    "gpt4o-edit": "gpt4o-edit",
+    "gpt-image-edit": "gpt-image-1.5-edit",
+    "gpt-image-2-edit": "gpt-image-2-image-to-image",
+
+    "seededit": "bytedance-seededit-image",
+    "seedream-edit": "bytedance-seedream-edit-v4",
+    "seedream-v4.5-edit": "bytedance-seedream-v4.5-edit",
+
+    "midjourney": "midjourney-v7-image-to-image",
+    "midjourney-style": "midjourney-v7-style-reference",
+
+    "qwen": "qwen-image-edit",
+    "qwen-plus": "qwen-image-edit-plus",
+    "qwen-2-edit": "qwen-image-2.0-edit",
+
+    "nano-banana-edit": "nano-banana-edit",
+    "nano-banana-effects": "nano-banana-effects",
+
+    "reve": "reve-image-edit",
+
+    "wan2.5-edit": "wan2.5-image-edit",
+    "wan2.6-edit": "wan2.6-image-edit",
+    "wan2.7-edit": "wan2.7-image-edit"
+};
+
+export const T2V_MODELS = {
+    // Veo
+    "veo3": "veo3-text-to-video",
+    "veo3-fast": "veo3-fast-text-to-video",
+    "veo3.1": "veo3.1-text-to-video",
+    "veo4": "veo-4-text-to-video",
+
+    // Kling
+    "kling-master": "kling-v2.1-master-t2v",
+    "kling-v2.5-pro": "kling-v2.5-turbo-pro-t2v",
+    "kling-v2.6-pro": "kling-v2.6-pro-t2v",
+    "kling-v3-pro": "kling-v3.0-pro-text-to-video",
+
+    // Wan
+    "wan2.1": "wan2.1-text-to-video",
+    "wan2.2": "wan2.2-text-to-video",
+    "wan2.5": "wan2.5-text-to-video",
+    "wan2.6": "wan2.6-text-to-video",
+    "wan2.7": "wan2.7-text-to-video",
+
+    // Seedance
+    "seedance-pro": "seedance-pro-t2v",
+    "seedance-pro-fast": "seedance-pro-t2v-fast",
+
+    // Others
+    "runway": "runway-text-to-video",
+    "pixverse": "pixverse-v4.5-t2v",
+    "pixverse-v5": "pixverse-v5-t2v",
+    "pixverse-v6": "pixverse-v6-t2v",
+
+    "vidu": "vidu-v2.0-t2v",
+    "vidu-q2-pro": "vidu-q2-pro-text-to-video",
+    "vidu-q3-pro": "vidu-q3-pro-text-to-video",
+
+    "sora": "openai-sora",
+    "sora-2": "openai-sora-2-text-to-video",
+
+    "hunyuan": "hunyuan-text-to-video"
+};
+
+export const I2V_MODELS = {
+    // Kling
+    "kling-std": "kling-v2.1-standard-i2v",
+    "kling-pro": "kling-v2.1-pro-i2v",
+    "kling-master": "kling-v2.1-master-i2v",
+    "kling-v2.5-pro": "kling-v2.5-turbo-pro-i2v",
+
+    // Veo
+    "veo3": "veo3-image-to-video",
+    "veo3.1": "veo3.1-image-to-video",
+    "veo4": "veo-4-image-to-video",
+
+    // Wan
+    "wan2.1": "wan2.1-image-to-video",
+    "wan2.5": "wan2.5-image-to-video",
+    "wan2.6": "wan2.6-image-to-video",
+    "wan2.7": "wan2.7-image-to-video",
+
+    // Seedance
+    "seedance-pro": "seedance-pro-i2v",
+    "seedance-v2": "seedance-v2.0-i2v",
+    "seedance-2": "seedance-2-image-to-video",
+
+    // Others
+    "runway": "runway-image-to-video",
+
+    "pixverse-v4.5": "pixverse-v4.5-i2v",
+    "pixverse-v5": "pixverse-v5-i2v",
+    "pixverse-v6": "pixverse-v6-i2v",
+
+    "vidu": "vidu-v2.0-i2v",
+    "vidu-q2-pro": "vidu-q2-pro-image-to-video",
+    "vidu-q3-pro": "vidu-q3-pro-image-to-video",
+
+    "midjourney": "midjourney-v7-image-to-video",
+
+    "sora-2": "openai-sora-2-image-to-video",
+
+    "hunyuan": "hunyuan-image-to-video"
+};
+
+export const LIST_INPUT_I2V = new Set([
+    "wan2.1",
+    "wan2.5",
+    "wan2.6",
+    "wan2.7",
+
+    "seedance-pro",
+    "seedance-v2",
+    "seedance-2",
+
+    "vidu",
+    "vidu-q2-pro",
+
+    "pixverse-v4.5",
+    "pixverse-v5",
+    "pixverse-v6",
+
+    "sora-2"
+]);

package/src/predictions.js

@@ -0,0 +1,29 @@
+export class PredictionsAPI {
+    constructor(client) {
+        this.client = client;
+    }
+
+    async get(id) {
+        return this.client.getPrediction(id);
+    }
+
+    async wait(id, interval = 3000) {
+        while (true) {
+            const result = await this.get(id);
+
+            if (result.status === "completed") {
+                return result;
+            }
+
+            if (result.status === "failed") {
+                throw new Error(
+                    result.error || "Generation failed"
+                );
+            }
+
+            await new Promise(resolve =>
+                setTimeout(resolve, interval)
+            );
+        }
+    }
+}

package/src/uploads.js

@@ -0,0 +1,31 @@
+import fs from "fs";
+import axios from "axios";
+import FormData from "form-data";
+
+export class UploadsAPI {
+    constructor(client) {
+        this.client = client;
+    }
+
+    async upload(filePath) {
+        const form = new FormData();
+
+        form.append(
+            "file",
+            fs.createReadStream(filePath)
+        );
+
+        const response = await axios.post(
+            "https://api.muapi.ai/api/v1/upload_file",
+            form,
+            {
+                headers: {
+                    ...form.getHeaders(),
+                    "x-api-key": this.client.apiKey,
+                },
+            }
+        );
+
+        return response.data;
+    }
+}

package/src/videos.js

@@ -0,0 +1,63 @@
+import {
+    T2V_MODELS,
+    I2V_MODELS,
+    LIST_INPUT_I2V
+} from "./modelRegistry.js";
+
+export class VideosAPI {
+    constructor(client) {
+        this.client = client;
+    }
+
+    async generate({
+        prompt,
+        model = "kling-master",
+        duration = 5,
+        aspectRatio = "16:9",
+    }) {
+        const endpoint = T2V_MODELS[model];
+
+        if (!endpoint) {
+            throw new Error(`Unknown model: ${model}`);
+        }
+
+        return this.client.post(endpoint, {
+            prompt,
+            duration,
+            aspect_ratio: aspectRatio,
+        });
+    }
+
+    async fromImage({
+        prompt,
+        image,
+        model = "kling-std",
+        duration = 5,
+        aspectRatio = "16:9",
+    }) {
+        const endpoint = I2V_MODELS[model];
+
+        if (!endpoint) {
+            throw new Error(
+                `Unknown model: ${model}`
+            );
+        }
+
+        const payload = {
+            prompt,
+            duration,
+            aspect_ratio: aspectRatio,
+        };
+
+        if (LIST_INPUT_I2V.has(model)) {
+            payload.images_list = [image];
+        } else {
+            payload.image_url = image;
+        }
+
+        return this.client.post(
+            endpoint,
+            payload
+        );
+    }
+}