# NodeJS sample

### 1/ Authenticate into OSAIS as a Client App

Your application needs to be authenticated into OSAIS. Our authToken has a validity of 3 days, but we recommend authenticating into OSAIS every 24 hours.

```javascript
const async_login = async function (){
    try {
        let response = await axios.post("https://opensourceais.com/api/v1/public/client/login", {
            token: <your_token>,
            secret: <your_secret>
        }, {
            headers: { 
                name: 'content-type',
                value: 'application/json'
            }
        });
        if(response && response.data) {
            // response.data contains the authentication token as {authToken: ...}
            // user the authToken in Bearer of next calls
            return response.data;             
        }

        throw {
            data: null,
            status: 400,
            statusText: "Could not authenticate as a client"
        }
    }
    catch (err) {
        throw err;
    }
}
```

### 2/ Implement routes for receiving notifications from OSAIS

You application needs to implement two routes for receiving notifications from the AI. One route is for the stage notification, and one route is for the file upload notification and processing.

```javascript

// this route will receive all notifications
router.post("/notify", function(req, res, next) {
    routeUtils.apiPost(req, res, myClient.async_testClientNotify.bind(testClient), {
        uid: req.body.uid? parseInt(req.body.uid): null,
        stage: req.body.stage? parseInt(req.body.stage): 0,
        token: req.body.token? req.body.token: "0",
        cycle: req.body.cycle? parseInt(req.body.cycle) : 0,
        engine: req.body.engine? req.body.engine : null,
        username: req.body.username? req.body.username : null,
        filename: req.body.filename? req.body.filename : null,
        descr: req.body.descr
    });
});

// this route will receive the file from the AI
router.post("/upload",  imgServices.uploadImg, function(req, res, next) {
    routeUtils.apiPost(req, res, myClient.async_onUploadImage.bind(testClient), {
        uid: req.body.uid? parseInt(req.body.uid): null,
        token: req.body.token? req.body.token: "0",
        cycle: req.body.cycle? parseInt(req.body.cycle) : 0,
        filename: req.ai? req.ai.filename: null,
        engine: req.body.engine? req.body.engine : null,
    });
});

```

### 3/ Send an AI request to OSAIS&#x20;

Your application can call AIs by sending a POST request to OSAIS. Each AI has its own route into OSAIS, which is simple api/v1/private/client/ai/\<name\_of\_the\_ai>. Here below are two examples, one for AI Ping, one for AI Stable Diffusion.

```javascript
const async_aiPing = async function (objParam, authToken) {
    try {
        let response = await axios.post"https://opensourceais.com/api/v1/private/client/ai/ping", {
            url_upload: objParam.url_upload,           // the input image
            width: 512,
            height: 512
        }, {
            headers: { 
                Authorization: "Bearer "+ authToken,
                name: 'content-type',
                value: 'application/json'
            }
        });

        if(response && response.data) {
            return response.data; 
        }

        throw {
            data: null,
            status: 400,
            statusText: "could not call AI Ping"
        };                
    }
    catch(err){
        throw err;
    }
}
```

```javascript

const async_aiStableDiffusion = async function (objParam, authToken) {
    try {
        let response = await axios.post"https://opensourceais.com/api/v1/private/client/ai/diffusion", {

            url_upload: objParam.url_upload,           // did we request an image upload?
            word: "a zombie in london",                // the text input
            width: 512,
            height: 512,
            strength: 0.5,
            seed: 1,
            steps: 20,
        }, {
            headers: { 
                Authorization: "Bearer "+ authToken,
                name: 'content-type',
                value: 'application/json'
            }
        });

        if(response && response.data) {
            return response.data; 
        }

        throw {
            data: null,
            status: 400,
            statusText: "could not call AI Stable Diffusion"
        };                
    }
    catch(err){
        throw err;
    }
}
```

### 4/ Understand what to process on the Notification calls

Notifications are received on the /notify route. Here are the various possible stages that can be received. Note that images can still be received after the AI has stopped processing. It is also possible that several images are received, one per notification, if the AI was requested to output multiple files.

```javascript

AI_PROGRESS_ERROR: -1,           // we stopped the request in error
AI_PROGRESS_REQSENT: 0,          // the request got sent to a specific AI (not yet acknowledged)
AI_PROGRESS_REQRECEIVED: 1,      // the request was received and acknowledged by the AI, but job not yet started
AI_PROGRESS_START_AI: 2,         // the AI started processin ghte request
AI_PROGRESS_INIT_IMAGE: 3,       // the AI starts procesing the file (image, or other)
AI_PROGRESS_DONE_IMAGE: 4,       // the AI finished processing the file 
AI_PROGRESS_STOP_AI: 5,          // the AI has finished processing the request

```

AI generated files (in the case of Stable Diffusion, images) are received on the /upload route. Note that in this case, via our service "imgServices.uploadImg", we used multer to process the image immediately. here is the code for this.

```javascript

const multer = require('multer');
const uploadImg= multer({
    storage: multer.diskStorage({
        destination: function (req, file, cb) {
            cb(null, _getDirectory());
        },
        filename: function (req, file, cb) {
            let ext = file.originalname.split(".").pop().toLowerCase();
            let _filename=_getDirectory()+file.originalname;
            req.ai={
                filename:_filename,
                ext: ext
            };
            cb(null, file.originalname);
        }
    }), 
    limits: {fileSize: 1024000},     // 1Mb
    fileFilter(req, file, cb) {
        if (!file.originalname.match(/\.(png|jpg|jpeg)$/)){
            cb(new Error('Unreconised format - Please upload an image.'))
        }
        cb(undefined, true)
    }
}).single('image');


```

{% hint style="warning" %}
Both endpoints **/notify** and **/upload** must reply to the OSAIS caller, with a specific JSON content, so that OSAIS acknowledges that the request was received and processed correctly.&#x20;
{% endhint %}

It is important to return correct calls, since for example, in the case of a badly configured nGROK (calling an unknown endpoint), the notification endpoint would still return (no error) but it would not be a valid acknowledgement that the request was processed correctly by the receiving application.

The expected returned data is a properly formed JSON as below

```
{
    data: {
        token: <your token id>
        uid: <the uid of the processed item>
    }
}
```

Both the \<token> and the \<uid> are passed in parameters to the notification endpoint, so it is just a matter for the receiving application to send them back as acknowledgement of having processed the notification.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://incubiq.gitbook.io/opensourceais/sample-app/nodejs-sample.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.