# JavaScript SDK

> FlyMy.AI Models JavaScript / TypeScript SDK: install, authenticate, predict, stream, and use async tasks from Node or the browser.

The FlyMyAI SDK is a TypeScript library for interacting with the FlyMyAI API. It provides functionality for making predictions and handling long-running operations.

## Installation

To install the SDK, use npm or yarn:

```bash
npm install flymyai-js-client
```

or

```bash
yarn add flymyai-js-client
```

## Usage

### Initialization

To use the FlyMyAI SDK, you need to initialize it with your API key.

```javascript
import { FlyMyAI } from "flymyai-js-client";

const client = new FlyMyAI({ apiKey: "YOUR_API_KEY" });
```

### Making Predictions

You can make predictions by calling the `predict` method. Here's an example:

```javascript
const payload = {
  prompt: "Funny cat with stupid dog",
  height: 1024,
  width: 1024,
  num_inference_steps: 26,
  guidance_scale: "0",
  seed: 1654,
  negative_prompt: "0",
};

const model = "flymyai/flux-schnell-fast";
const apiKey = process.env.REACT_APP_FLYMYAI_API_KEY || "";

const client = new FlyMyAI({ apiKey });

try {
  const result = await client.predict(payload, model);
  console.log("Prediction result:", result.output_data["sample"][0]);
} catch (error) {
  console.error("Error making prediction:", error);
}
```

### Long-Running Predictions with Polling

For operations requiring extended processing time, use predictAsync with polling:

```javascript
const client = new FlyMyAI({
  apiKey: "YOUR_API_KEY",
});

const model = "flymyai/flux-schnell-lora";
const payload = {
  prompt: "a robotic funny cat with robotic stupid dog",
  height: 1024,
  width: 1024,
  num_inference_steps: 4,
  guidance_scale: "0",
  seed: 1654,
  lora_url:
    "https://civitai.com/api/download/models/730973?type=Model&format=SafeTensor",
  lora_scale: "0.9",
};

try {
  const result = await client.predictAsync(payload, model, {
    interval: 3000, // Poll every 3 seconds
    signal: AbortSignal.timeout(3_600_000), // 1 hour timeout
  });
  console.log(
    "Prediction URL:",
    result.inference_responses[0].response.sample[0].url
  );
} catch (error) {
  if (error instanceof FlyMyAIError) {
    console.error("Prediction failed:", error.message);
  }
}
```

### Waiting for all requests to be completed

```javascript
import { FlyMyAI } from "flymyai-js-client";

async function main() {
  const apiKey = "fly-secret-key";
  const model = "flymyai/model-name";
  const client = new FlyMyAI({ apiKey });

  const payloads: Array<Record<string, any>> = Array.from(
    { length: 9 },
    (_, count) => ({
      prompt: "a robotic funny cat with robotic stupid dog",
      height: 1024,
      width: 1024,
      num_inference_steps: 4,
      guidance_scale: "0",
      seed: 1654,
      lora_url:
        "https://civitai.com/api/download/models/730973?type=Model&format=SafeTensor",
      lora_scale: "0.9",
    })
  );

  try {
    const results = await Promise.all(
      payloads.map((payload) =>
        client.predictAsync<AsyncPredictionResult>(payload, model, {
          interval: 3000,
          signal: createAbortSignal(36_000_000),
        })
      )
    );

    for (const result of results) {
      const url = result.inference_responses?.[0]?.response?.sample?.[0]?.url;
      if (url) {
        console.log(result.inference_responses[0].response.sample[0].url);
      }
    }
  } catch (error) {
    console.error("Error processing predictions:", error);
  }
}

main().catch(console.error);
```

### Separately getting predict_id and the result of generation

#### Get predict_id

```javascript
try {
  // Start the async prediction and get the prediction ID
  const predictionId = await client.asyncPredict(payload, model);
  console.log("Async prediction started. Prediction ID:", predictionId);

  // You can now store this predictionId to check results later
  // or pass it to another system component
} catch (error) {
  if (error instanceof FlyMyAIError) {
    console.error("Failed to start async prediction:", error.message);
  } else {
    console.error("Unknown error:", error);
  }
}
```

#### Retrieve the final results when ready

```javascript
try {
  const result = await client.checkAsyncResult(model, storedPredictionId);

  if (result.status === "pending") {
    console.log("Prediction is still processing");
  } else {
    console.log(
      "Final prediction result:",
      result.inference_responses[0].response.sample[0].url
    );
  }
} catch (error) {
  console.error("Error checking prediction status:", error);
}
```

### Error Handling

Uses custom error handling. If an error occurs, a `FlyMyAIError` will be thrown. You can catch it like this:

```javascript
try {
  const response = await flyMyAI.predict(payload, model);
} catch (error) {
  if (error instanceof FlyMyAIError) {
    console.error("FlyMyAI error:", error.message);
  } else {
    console.error("Unknown error:", error);
  }
}
```

## Additional Resources

- [GitHub Repository](https://github.com/FlyMyAI/flymyai-js)
- [API Reference](https://docs.flymy.ai/api/overview.md)
- [Examples Repository](https://github.com/FlyMyAI/examples)