@tiledesk/tiledesk-server 2.10.36 → 2.10.37

package/CHANGELOG.md

@@ -5,6 +5,12 @@
 🚀        IN PRODUCTION                        🚀
 (https://www.npmjs.com/package/@tiledesk/tiledesk-server/v/2.3.77) 
 
+# 2.10.37
+- added voice-duration quota
+- added webhook endpoint for auto reindexing
+- updated vxml-connector to 0.1.70
+
+
 # 2.10.36
 - updated tybot-connector to 0.2.138
 

package/models/kb_setting.js

@@ -109,6 +109,14 @@ var KBSchema = new Schema({
       type: Array,
       required: false
     }
+  },
+  refresh_rate: {
+    type: String,
+    required: false
+  },
+  last_refresh: {
+    type: Date,
+    required: false
   }
 }, {
   timestamps: true

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiledesk/tiledesk-server",
   "description": "The Tiledesk server module",
-  "version": "2.10.36",
+  "version": "2.10.37",
   "scripts": {
     "start": "node ./bin/www",
     "pretest": "mongodb-runner start",
@@ -52,7 +52,7 @@
     "@tiledesk/tiledesk-whatsapp-connector": "^0.1.75",
     "@tiledesk/tiledesk-whatsapp-jobworker": "^0.0.10",
     "@tiledesk/tiledesk-sms-connector": "^0.1.11",
-    "@tiledesk/tiledesk-vxml-connector": "^0.1.67",
+    "@tiledesk/tiledesk-vxml-connector": "^0.1.70",
     "@tiledesk/tiledesk-voice-twilio-connector": "^0.1.12",
     "@tiledesk/tiledesk-multi-worker": "^0.1.6",
     "amqplib": "^0.5.5",

package/routes/kb.js

@@ -6,7 +6,7 @@ var router = express.Router();
 var winston = require('../config/winston');
 var multer = require('multer')
 var upload = multer()
-const openaiService = require('../services/openaiService');
+const aiService = require('../services/aiService');
 const JobManager = require('../utils/jobs-worker-queue-manager/JobManagerV2');
 const { Scheduler } = require('../services/Scheduler');
 var configGlobal = require('../config/global');
@@ -18,7 +18,6 @@ let Integration = require('../models/integrations');
 var parsecsv = require("fast-csv");
 
 const { MODELS_MULTIPLIER } = require('../utils/aiUtils');
-const { body } = require('express-validator');
 
 const AMQP_MANAGER_URL = process.env.AMQP_MANAGER_URL;
 const JOB_TOPIC_EXCHANGE = process.env.JOB_TOPIC_EXCHANGE_TRAIN || 'tiledesk-trainer';
@@ -190,7 +189,7 @@ router.post('/scrape/status', async (req, res) => {
   let ns = namespaces.find(n => n.id === data.namespace);
   data.engine = ns.engine || default_engine;
 
-  openaiService.scrapeStatus(data).then(async (response) => {
+  aiService.scrapeStatus(data).then(async (response) => {
 
     winston.debug("scrapeStatus response.data: ", response.data);
 
@@ -294,7 +293,7 @@ router.post('/qa', async (req, res) => {
     return res.status(200).send({ success: true, message: "Question skipped in test environment"});
   }
 
-  openaiService.askNamespace(data).then((resp) => {
+  aiService.askNamespace(data).then((resp) => {
     winston.debug("qa resp: ", resp.data);
     let answer = resp.data;
 
@@ -353,7 +352,7 @@ router.delete('/delete', async (req, res) => {
   let ns = namespaces.find(n => n.id === data.namespace);
   data.engine = ns.engine || default_engine;
 
-  openaiService.deleteIndex(data).then((resp) => {
+  aiService.deleteIndex(data).then((resp) => {
     winston.debug("delete resp: ", resp.data);
     res.status(200).send(resp.data);
   }).catch((err) => {
@@ -392,7 +391,7 @@ router.delete('/deleteall', async (req, res) => {
 
   winston.verbose("/deleteall data: ", data);
 
-  openaiService.deleteNamespace(data).then((resp) => {
+  aiService.deleteNamespace(data).then((resp) => {
     winston.debug("delete namespace resp: ", resp.data);
     res.status(200).send(resp.data);
   }).catch((err) => {
@@ -497,7 +496,7 @@ router.get('/namespace/:id/chunks/:content_id', async (req, res) => {
     return res.status(200).send({ success: true, message: "Get chunks skipped in test environment"});
   }
 
-  openaiService.getContentChunks(namespace_id, content_id, engine).then((resp) => {
+  aiService.getContentChunks(namespace_id, content_id, engine).then((resp) => {
     let chunks = resp.data;
     winston.debug("chunks for content " + content_id);
     winston.debug("chunks found ", chunks);
@@ -659,7 +658,7 @@ router.delete('/namespace/:id', async (req, res) => {
 
   if (req.query.contents_only && (req.query.contents_only === true || req.query.contents_only === 'true')) {
 
-    openaiService.deleteNamespace(data).then(async (resp) => {
+    aiService.deleteNamespace(data).then(async (resp) => {
       winston.debug("delete namespace resp: ", resp.data);
 
       let deleteResponse = await KB.deleteMany({ id_project: project_id, namespace: namespace_id }).catch((err) => {
@@ -693,7 +692,7 @@ router.delete('/namespace/:id', async (req, res) => {
       return res.status(403).send({ success: false, error: "Default namespace cannot be deleted" });
     }
 
-    openaiService.deleteNamespace(data).then(async (resp) => {
+    aiService.deleteNamespace(data).then(async (resp) => {
       winston.debug("delete namespace resp: ", resp.data);
 
       let deleteResponse = await KB.deleteMany({ id_project: project_id, namespace: namespace_id }).catch((err) => {
@@ -926,6 +925,7 @@ router.post('/', async (req, res) => {
     new_kb.scrape_type = 1;
   }
   if (new_kb.type === 'url') {
+    new_kb.refresh = body.refresh;
     if (!body.scrape_type || body.scrape_type === 2) {
       new_kb.scrape_type = 2;
       new_kb.scrape_options = await setDefaultScrapeOptions();
@@ -999,6 +999,7 @@ router.post('/multi', upload.single('uploadFile'), async (req, res) => {
   let project_id = req.projectid;
   let scrape_type = req.body.scrape_type;
   let scrape_options = req.body.scrape_options;
+  let refresh_rate = req.body.refresh_rate;
 
   let namespace_id = req.query.namespace;
   if (!namespace_id) {
@@ -1056,7 +1057,8 @@ router.post('/multi', upload.single('uploadFile'), async (req, res) => {
       content: "",
       namespace: namespace_id,
       status: -1,
-      scrape_type: scrape_type
+      scrape_type: scrape_type,
+      refresh_rate: refresh_rate
     }
 
     if (!kb.scrape_type) {
@@ -1316,7 +1318,7 @@ router.delete('/:kb_id', async (req, res) => {
 
   winston.verbose("/:delete_id data: ", data);
 
-  openaiService.deleteIndex(data).then((resp) => {
+  aiService.deleteIndex(data).then((resp) => {
     winston.debug("delete resp: ", resp.data);
     if (resp.data.success === true) {
       KB.findByIdAndDelete(kb_id, (err, deletedKb) => {
@@ -1432,9 +1434,6 @@ async function updateStatus(id, status) {
 
 async function scheduleScrape(resources) {
 
-  // let data = {
-  //     resources: resources
-  // }
   let scheduler = new Scheduler({ jobManager: jobManager });
 
   resources.forEach(r => {
@@ -1451,7 +1450,6 @@ async function scheduleScrape(resources) {
     });
   })
 
-
   return true;
 }
 
@@ -1470,7 +1468,7 @@ async function startScrape(data) {
   winston.verbose("status of kb " + data.id + " updated: " + status_updated);
 
   return new Promise((resolve, reject) => {
-    openaiService.singleScrape(data).then(async (resp) => {
+    aiService.singleScrape(data).then(async (resp) => {
       winston.debug("singleScrape resp: ", resp.data);
       let status_updated = await updateStatus(data.id, 300);
       winston.verbose("status of kb " + data.id + " updated: " + status_updated);

package/routes/kbsettings.js

@@ -4,7 +4,7 @@ var { KBSettings } = require('../models/kb_setting');
 // var KB = require('../models/kb_setting')
 var router = express.Router();
 var winston = require('../config/winston');
-const openaiService = require('../services/openaiService');
+const aiService = require('../services/aiService');
 
 router.get('/', async (req, res) => {
     let project_id = req.projectid;
@@ -105,7 +105,7 @@ router.post('/qa', async (req, res) => {
     let data = req.body;
     winston.debug("/qa data: ", data);
 
-    openaiService.ask(data).then((resp) => {
+    aiService.ask(data).then((resp) => {
         winston.debug("qa resp: ", resp.data);
         res.status(200).send(resp.data);
     }).catch((err) => {
@@ -121,7 +121,7 @@ router.post('/startscrape', async (req, res) => {
     let data = req.body;
     winston.debug("/startscrape data: ", data);
 
-    openaiService.startScrape(data).then((resp) => {
+    aiService.startScrape(data).then((resp) => {
         winston.debug("startScrape resp: ", resp.data);
         res.status(200).send(resp.data);
     }).catch((err) => {
@@ -143,7 +143,7 @@ router.post('/checkstatus', async (req, res) => {
         url_list: [ req.body.full_url ]
     }
 
-    openaiService.checkStatus(data).then((resp) => {
+    aiService.checkStatus(data).then((resp) => {
         winston.debug("checkStatus resp: ", resp);
         winston.debug("checkStatus resp: ", resp.data);
         winston.debug("checkStatus resp: ", resp.data[full_url]);

package/routes/openai.js

@@ -1,7 +1,7 @@
 var express = require('express');
 var router = express.Router();
 var { KBSettings } = require('../models/kb_setting');
-var openaiService = require('../services/openaiService');
+var aiService = require('../services/aiService');
 var winston = require('../config/winston');
 const { QuoteManager } = require('../services/QuoteManager');
 const { MODELS_MULTIPLIER } = require('../utils/aiUtils');
@@ -70,7 +70,7 @@ router.post('/', async (req, res) => {
             winston.info("No multiplier found for AI model")
         }
 
-        openaiService.completions(json, gptkey).then(async (response) => {
+        aiService.completions(json, gptkey).then(async (response) => {
             let data = { createdAt: new Date(), tokens: response.data.usage.total_tokens, multiplier: multiplier }
             if (usePublicKey === true) {
                 let incremented_key = await quoteManager.incrementTokenCount(req.project, data);

package/routes/webhook.js

@@ -1,9 +1,124 @@
 var express = require('express');
 var router = express.Router();
-var { KB } = require('../models/kb_setting');
+var { KB, Namespace } = require('../models/kb_setting');
 var winston = require('../config/winston');
+const JobManager = require('../utils/jobs-worker-queue-manager/JobManagerV2');
+const { Scheduler } = require('../services/Scheduler');
+const { AiReindexService } = require('../services/aiReindexService');
 
 const KB_WEBHOOK_TOKEN = process.env.KB_WEBHOOK_TOKEN || 'kbcustomtoken';
+const AMQP_MANAGER_URL = process.env.AMQP_MANAGER_URL;
+const JOB_TOPIC_EXCHANGE = process.env.JOB_TOPIC_EXCHANGE_TRAIN || 'tiledesk-trainer';
+
+let jobManager = new JobManager(AMQP_MANAGER_URL, {
+  debug: false,
+  topic: JOB_TOPIC_EXCHANGE,
+  exchange: JOB_TOPIC_EXCHANGE
+})
+
+jobManager.connectAndStartPublisher((status, error) => {
+  if (error) {
+    winston.error("connectAndStartPublisher error: ", error);
+  } else {
+    winston.info("KbRoute - ConnectPublisher done with status: ", status);
+  }
+})
+
+let default_engine = {
+  name: "pinecone",
+  type: process.env.PINECONE_TYPE,
+  apikey: "",
+  vector_size: 1536,
+  index_name: process.env.PINECONE_INDEX
+}
+
+router.post('/kb/reindex', async (req, res) => {
+
+  winston.verbose("/kb/reindex webhook called")
+  winston.debug("(webhook) req.body: ", req.body);
+
+  if (!req.headers['x-auth-token']) {
+    winston.error("(webhook) Unauthorized: A x-auth-token must be provided")
+    return res.status(401).send({ success: false, error: "Unauthorized", message: "A x-auth-token must be provided" })
+  }
+
+  if (req.headers['x-auth-token'] != KB_WEBHOOK_TOKEN) {
+    winston.error("(webhook) Unauthorized: You don't have the authorization to accomplish this operation")
+    return res.status(401).send({ success: false, error: "Unauthorized", message: "You don't have the authorization to accomplish this operation" });
+  }
+  
+  let content_id = req.body.content_id;
+
+  let kb = await KB.findById(content_id).catch( async (err) => {
+    winston.error("(webhook) Error getting kb content: ", err);
+    return res.status(500).send({ success: false, error: "Error getting content with id " + content_id });
+  })
+
+  if (!kb) {
+    winston.warn("(webhook) Kb content not found with id " + content_id + ". Deleting scheduler...");
+
+    // Assuming the content has been deleted. The scheduler should be stopped and deleted.
+    res.status(200).send({ success: true, message: "Content no longer exists. Deleting scheduler..." })
+
+    setTimeout( async () => {
+      let aiReindexService = new AiReindexService();
+      let deleteResponse = await aiReindexService.delete(content_id).catch((err) => {
+        winston.error("(webhook) Error deleting scheduler ", err);
+        winston.error("(webhook) Error deleting scheduler " + err);
+        return;
+      });
+      winston.verbose("(webhook) delete response: ", deleteResponse);
+      return;
+    }, 10000);
+    
+  } else {
+
+    let json = {
+      id: kb._id,
+      type: kb.type,
+      source: kb.source,
+      content: "",
+      namespace: kb.namespace,
+      refresh_rate: kb.refresh_rate,
+      last_refresh: kb.last_refresh
+    }
+  
+    if (kb.scrape_type) {
+      json.scrape_type = kb.scrape_type
+    }
+  
+    if (kb.scrape_options) {
+      json.parameters_scrape_type_4 = {
+        tags_to_extract: kb.scrape_options.tags_to_extract,
+        unwanted_tags: kb.scrape_options.unwanted_tags,
+        unwanted_classnames: kb.scrape_options.unwanted_classnames
+      }
+    }
+  
+    let namespace = await Namespace.findOne({ id: kb.namespace }).catch((err) => {
+      winston.error("(webhook) Error getting namespace ", err)
+      return res.status(500).send({ success: false, error: err })
+    })
+  
+    if (!namespace) {
+      winston.warn("(webhook) Namespace not found with id " + kb.namespace);
+      return res.status(500).send({ success: false, error: err })
+    }
+  
+    json.engine = namespace.engine || default_engine;
+  
+    let resources = [];
+    resources.push(json);
+  
+    if (process.env.NODE_ENV !== 'test') {
+      scheduleScrape(resources);
+    }
+  
+    res.status(200).send({ success: true, message: "Content queued for reindexing" });
+
+  }
+})
+
 
 router.post('/kb/status', async (req, res) => {
 
@@ -52,4 +167,22 @@ router.post('/kb/status', async (req, res) => {
 
 })
 
+async function scheduleScrape(resources) {
+
+  let scheduler = new Scheduler({ jobManager: jobManager });
+
+  resources.forEach(r => {
+    winston.debug("(Webhook) Schedule job with following data: ", r);
+    scheduler.trainSchedule(r, async (err, result) => {
+      if (err) {
+        winston.error("Scheduling error: ", err);
+      } else {
+        winston.info("Scheduling result: ", result);
+      }
+    });
+  })
+
+  return true;
+}
+
 module.exports = router;

package/services/QuoteManager.js

@@ -16,15 +16,15 @@ const emailEvent = require('../event/emailEvent');
 
 
 const PLANS_LIST = {
-    FREE_TRIAL: { requests: 200,    messages: 0,    tokens: 100000,      email: 200,     chatbots: 20,      namespace: 3,   kbs: 50     }, // same as PREMIUM
-    SANDBOX:    { requests: 200,    messages: 0,    tokens: 100000,      email: 200,     chatbots: 2,       namespace: 1,   kbs: 50     },
-    BASIC:      { requests: 800,    messages: 0,    tokens: 2000000,     email: 200,     chatbots: 5,       namespace: 1,   kbs: 150    },
-    PREMIUM:    { requests: 3000,   messages: 0,    tokens: 5000000,     email: 200,     chatbots: 20,      namespace: 3,   kbs: 300    },
-    TEAM:       { requests: 5000,   messages: 0,    tokens: 10000000,    email: 200,     chatbots: 50,      namespace: 10,  kbs: 1000   },
-    CUSTOM:     { requests: 5000,   messages: 0,    tokens: 10000000,    email: 200,     chatbots: 50,      namespace: 10,  kbs: 1000   },
+    FREE_TRIAL: { requests: 200,    messages: 0,    tokens: 100000,     voice_duration: 0,       email: 200,     chatbots: 20,      namespace: 3,   kbs: 50     }, // same as PREMIUM
+    SANDBOX:    { requests: 200,    messages: 0,    tokens: 100000,     voice_duration: 0,       email: 200,     chatbots: 2,       namespace: 1,   kbs: 50     },
+    BASIC:      { requests: 800,    messages: 0,    tokens: 2000000,    voice_duration: 0,       email: 200,     chatbots: 5,       namespace: 1,   kbs: 150    },
+    PREMIUM:    { requests: 3000,   messages: 0,    tokens: 5000000,    voice_duration: 0,       email: 200,     chatbots: 20,      namespace: 3,   kbs: 300    },
+    TEAM:       { requests: 5000,   messages: 0,    tokens: 10000000,   voice_duration: 0,       email: 200,     chatbots: 50,      namespace: 10,  kbs: 1000   },
+    CUSTOM:     { requests: 5000,   messages: 0,    tokens: 10000000,   voice_duration: 120000,  email: 200,     chatbots: 50,      namespace: 10,  kbs: 1000   },
 }
 
-const typesList = ['requests', 'messages', 'email', 'tokens', 'chatbots', 'kbs']
+const typesList = ['requests', 'messages', 'email', 'tokens', 'voice_duration', 'chatbots', 'kbs']
 
 let quotes_enabled = true;
 
@@ -95,6 +95,25 @@ class QuoteManager {
         this.sendEmailIfQuotaExceeded(project, data, 'tokens', key);
         return key;
     }
+
+    async incrementVoiceDurationCount(project, request) {
+
+        this.project = project;
+        let key = await this.generateKey(request, 'voice_duration');
+        winston.verbose("[QuoteManager] incrementVoiceDurationCount key: " + key);
+
+        if (quotes_enabled === false) {
+            winston.debug("QUOTES DISABLED - incrementVoiceDurationCount")
+            return key;
+        }
+
+        if (request?.duration) {
+            let duration = Math.round(request.duration / 1000); // from ms to s
+            await this.tdCache.incrby(key, duration);
+    
+            this.sendEmailIfQuotaExceeded(project, request, 'voice_duration', key);
+        }
+    }
     // INCREMENT KEY SECTION - END
 
 
@@ -228,7 +247,7 @@ class QuoteManager {
         winston.verbose("limits for current plan: ", limits)
 
         let quote = await this.getCurrentQuote(project, object, type);
-        winston.verbose("getCurrentQuote resp: ", quote)
+        winston.verbose("getCurrentQuote resp: " + quote)
 
         if (quote == null) {
             return true;
@@ -494,13 +513,21 @@ class QuoteManager {
             if (quotes_enabled === true) {
                 winston.verbose("request.create.quote event catched");
                 let result = await this.incrementRequestsCount(payload.project, payload.request);
-
-                
                 return result;
             } else {
                 winston.verbose("QUOTES DISABLED - request.create.quote event")
             }
         })
+
+        requestEvent.on('request.close.quote', async (payload) => {
+            if (quotes_enabled === true) {
+                winston.verbose("request.close.quote event catched");
+                let result = await this.incrementVoiceDurationCount(payload.project, payload.request);
+                return result;
+            } else {
+                winston.verbose("QUOTES DISABLED - request.close.quote event")
+            }
+        })
         // REQUESTS EVENTS - END
 
 

package/services/aiReindexService.js

@@ -0,0 +1,151 @@
+var winston = require('../config/winston');
+const axios = require("axios").default;
+require('dotenv').config();
+
+class AiReindexService {
+
+    constructor() {
+        
+        this.BASE_URL = process.env.SCHEDULER_BASEURL;
+        winston.verbose("(ReindexScheduler) BASE_URL: " + this.BASE_URL)
+        if (!this.BASE_URL) {
+            throw new Error("Missing paramter BASE_URL");
+        }
+
+        this.TOKEN = process.env.SCHEDULER_TOKEN;
+        winston.verbose("(ReindexScheduler) TOKEN: " + this.TOKEN)
+        if (!this.TOKEN) {
+            throw new Error("Missing paramter TOKEN");
+        }
+
+        this.PROJECT = process.env.SCHEDULER_PROJECT;
+        winston.verbose("(ReindexScheduler) PROJECT: " + this.PROJECT)
+        if (!this.PROJECT) {
+            throw new Error("Missing paramter PROJECT");
+        }
+
+    }
+
+    async delete(content_id) {
+
+        return new Promise( async (resolve, reject) => {
+
+            let scheduler = await this.findScheduler(content_id).catch((err) => {
+                reject(err);
+            })
+
+            winston.verbose("(AiReindexService) delete() - scheduler: ", scheduler);
+
+            if (!scheduler) {
+                reject("Scheduler not found for content id " + content_id);
+            }
+
+            let isOfflineS = await this.offlineScheduler(scheduler.id).catch((err) => {
+                reject(err);
+            })
+
+            winston.verbose("(AiReindexService) delete() - isOfflineS: ", isOfflineS)
+
+            let isOffline = await this.offlineWorkflow(scheduler.processDefinitionCode).catch((err) => {
+                reject(err);
+            })
+
+            winston.verbose("(AiReindexService) delete() - isOffline: ", isOffline)
+
+            let deleteResponse = await this.deleteWorkflow(scheduler.processDefinitionCode).catch((err) => {
+                reject(err);
+            })
+
+            winston.verbose("(AiReindexService) delete() - deleteResponse: ", deleteResponse)
+            
+            resolve(deleteResponse);
+        })
+    }
+    
+    async findScheduler(id) {
+
+        return new Promise( async (resolve, reject) => {
+            await axios({
+                url: `${this.BASE_URL}/projects/${this.PROJECT}/schedules/list`,
+                method: 'POST',
+                headers: {
+                    token: this.TOKEN
+                }
+            }).then((response) => {
+
+                let scheduler = response.data.data.find(s => s.processDefinitionName === "auto-reindex-" + id);
+                if (!scheduler) {
+                    resolve(null);
+                } else {
+                    resolve(scheduler);
+    
+                }
+
+            }).catch((err) => {
+                reject(err);
+            })
+        })
+    }
+    
+    async offlineScheduler(id) {
+    
+        return new Promise( async (resolve, reject) => {
+            await axios({
+                url: `${this.BASE_URL}/projects/${this.PROJECT}/schedules/${id}/offline`,
+                method: 'POST',
+                headers: {
+                    token: this.TOKEN
+                }
+            }).then((response) => {
+                resolve(response.data);
+            }).catch((err) => {
+                reject(err);
+            })
+        })
+    }
+    
+    async offlineWorkflow(code) {
+    
+        return new Promise( async (resolve, reject) => {
+    
+            const queryParams = {
+                releaseState: "OFFLINE"
+            }
+            await axios({
+                url: `${this.BASE_URL}/projects/${this.PROJECT}/process-definition/${code}/release`,
+                method: 'POST',
+                headers: {
+                    token: this.TOKEN
+                },
+                params: queryParams
+              }).then((response) => {
+                resolve(response.data);
+              }).catch((err) => {
+                reject(err);
+              })
+        })
+    }
+    
+    async deleteWorkflow(code) {
+    
+        return new Promise( async (resolve, reject) => {
+    
+            const queryParams = {
+                releaseState: "OFFLINE"
+            }
+            await axios({
+                url: `${this.BASE_URL}/projects/${this.PROJECT}/process-definition/${code}`,
+                method: 'DELETE',
+                headers: {
+                    token: this.TOKEN
+                }
+              }).then((response) => {
+                resolve(response.data);
+              }).catch((err) => {
+                reject(err);
+              })
+        })
+    }
+}
+
+module.exports = { AiReindexService };

package/services/{openaiService.js → aiService.js}

@@ -9,7 +9,7 @@ let kb_endpoint_train = process.env.KB_ENDPOINT_TRAIN;
 let kb_endpoint_qa = process.env.KB_ENDPOINT_QA;
 let secret = process.env.JWT_SECRET_KEY;
 
-class OpenaiService {
+class AiService {
 
   // OPEN AI
   completions(data, gptkey) {
@@ -228,6 +228,6 @@ class OpenaiService {
 
 }
 
-var openaiService = new OpenaiService();
+var aiService = new AiService();
 
-module.exports = openaiService;
+module.exports = aiService;