@tiledesk/tiledesk-tybot-connector 0.2.130 → 0.2.131-rc2

package/CHANGELOG.md

@@ -17,6 +17,13 @@ available on:
 - Added flowError on JSONCondition when result = null
 - Added fix on Filler -->
 
+# v0.2.131-rc2
+- changed API_URL with API_ENDPOINT
+
+# v0.2.131-rc1
+- added: AUDIO_RECORD vxml action as reply_v2 actionType
+- added: DirAddTags action
+
 # v0.2.130
 - (TiledeskChatbotUtil) fix process.env.API_ENDPOINT => process.env.API_URL
 - index.js /block => added "token": "NO-TOKEN"

package/index.js

@@ -30,7 +30,7 @@ const { DirectivesChatbotPlug } = require('./tiledeskChatbotPlugs/DirectivesChat
 let mongoose = require('mongoose');
 // const { Directives } = require('./tiledeskChatbotPlugs/directives/Directives.js');
 const { TiledeskChatbotUtil } = require('./models/TiledeskChatbotUtil.js'); //require('@tiledesk/tiledesk-chatbot-util');
-let APIURL = null;
+let API_ENDPOINT = null;
 let staticBots;
 
 router.post('/ext/:botid', async (req, res) => {
@@ -160,7 +160,7 @@ router.post('/ext/:botid', async (req, res) => {
     botId: botId,
     bot: bot,
     token: token,
-    APIURL: APIURL,
+    APIURL: API_ENDPOINT,
     APIKEY: "___",
     tdcache: tdcache,
     requestId: requestId,
@@ -206,7 +206,7 @@ router.post('/ext/:botid', async (req, res) => {
           directives: directives,
           chatbot: chatbot,
           supportRequest: message.request,
-          TILEDESK_API_ENDPOINT: APIURL,
+          API_ENDPOINT: API_ENDPOINT,
           TILEBOT_ENDPOINT:process.env.TYBOT_ENDPOINT,
           token: token,
           log: log,
@@ -232,7 +232,7 @@ router.post('/ext/:botid', async (req, res) => {
     reply.attributes.splits = true;
     reply.attributes.markbot = true;
     reply.attributes.fillParams = true;
-    let extEndpoint = `${APIURL}/modules/tilebot/`;
+    let extEndpoint = `${API_ENDPOINT}/modules/tilebot/`;
     if (process.env.TYBOT_ENDPOINT) {
       extEndpoint = `${process.env.TYBOT_ENDPOINT}`;
     }
@@ -264,7 +264,7 @@ router.post('/ext/:projectId/requests/:requestId/messages', async (req, res) =>
   const tdclient = new TiledeskClient({
     projectId: projectId,
     token: token,
-    APIURL: APIURL,
+    APIURL: API_ENDPOINT,
     APIKEY: "___",
     log: false
   });
@@ -309,10 +309,10 @@ router.post('/ext/:projectId/requests/:requestId/messages', async (req, res) =>
   }
   if (log) {
     console.log("/ext request....", JSON.stringify(request));
-    console.log("/ext APIURL....", APIURL);
+    console.log("/ext API_ENDPOINT....", API_ENDPOINT);
     console.log("/ext process.env.TYBOT_ENDPOINT....", process.env.TYBOT_ENDPOINT);
   }
-  let directivesPlug = new DirectivesChatbotPlug({supportRequest: request, TILEDESK_API_ENDPOINT: APIURL, TILEBOT_ENDPOINT:process.env.TYBOT_ENDPOINT, token: token, log: log, HELP_CENTER_API_ENDPOINT: process.env.HELP_CENTER_API_ENDPOINT, cache: tdcache});
+  let directivesPlug = new DirectivesChatbotPlug({supportRequest: request, API_ENDPOINT: API_ENDPOINT, TILEBOT_ENDPOINT:process.env.TYBOT_ENDPOINT, token: token, log: log, HELP_CENTER_API_ENDPOINT: process.env.HELP_CENTER_API_ENDPOINT, cache: tdcache});
   // let directivesPlug = null;
   // PIPELINE-EXT
   // if (log) {console.log("answer to process:", JSON.stringify(answer));}
@@ -542,7 +542,7 @@ router.post('/echobot', (req, res) => {
   const tdclient = new TiledeskClient({
     projectId: projectId,
     token: token,
-    APIURL: APIURL,
+    APIURL: API_ENDPOINT,
     APIKEY: "___",
     log: false
   });
@@ -619,8 +619,8 @@ async function startApp(settings, completionCallback) {
     throw new Error("settings.API_ENDPOINT is mandatory id no settings.bots.");
   }
   else {
-    APIURL = settings.API_ENDPOINT;
-    console.log("(Tilebot) settings.API_ENDPOINT:", APIURL);
+    API_ENDPOINT = settings.API_ENDPOINT;
+    console.log("(Tilebot) settings.API_ENDPOINT:", API_ENDPOINT);
   }
 
   if (settings.REDIS_HOST && settings.REDIS_PORT) {
@@ -730,7 +730,7 @@ async function checkRequest(request_id, id_project) {
 function sendMessageToBot(TILEBOT_ENDPOINT, message, botId, callback) {
   // const jwt_token = this.fixToken(token);
   if (!TILEBOT_ENDPOINT) {
-    TILEBOT_ENDPOINT = `${APIURL}/modules/tilebot`
+    TILEBOT_ENDPOINT = `${API_ENDPOINT}/modules/tilebot`
   }
   const url = `${TILEBOT_ENDPOINT}/ext/${botId}`;
   console.log("sendMessageToBot URL", url);

package/models/TiledeskChatbotUtil.js

@@ -517,10 +517,13 @@ class TiledeskChatbotUtil {
                 await chatbot.addParameter(TiledeskChatbotConst.REQ_CHATBOT_TOKEN, chatbotToken); // DEPRECATED
                 await chatbot.addParameter(TiledeskChatbotConst.REQ_CHATBOT_TOKEN_v2, "JWT " + chatbotToken);
             }
-            if (process.env.TILEDESK_API) {
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_CHATBOT_TOKEN, chatbotToken); // DEPRECATED
-                await chatbot.addParameter(TiledeskChatbotConst.REQ_CHATBOT_TOKEN_v2, "JWT " + chatbotToken);
-            }
+            /**
+             * RefactoringCheck: can this be deleted?
+             */
+            // if (process.env.TILEDESK_API) {
+            //     await chatbot.addParameter(TiledeskChatbotConst.REQ_CHATBOT_TOKEN, chatbotToken); // DEPRECATED
+            //     await chatbot.addParameter(TiledeskChatbotConst.REQ_CHATBOT_TOKEN_v2, "JWT " + chatbotToken);
+            // }
             
             if (process.env.API_URL) {
                 await chatbot.addParameter(TiledeskChatbotConst.API_BASE_URL, process.env.API_URL);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiledesk/tiledesk-tybot-connector",
-  "version": "0.2.130",
+  "version": "0.2.131-rc2",
   "description": "Tiledesk Tybot connector",
   "main": "index.js",
   "scripts": {

package/tiledeskChatbotPlugs/DirectivesChatbotPlug.js

@@ -52,7 +52,8 @@ const { DirIfOnlineAgentsV2 } = require('./directives/DirIfOnlineAgentsV2');
 const { DirContactUpdate } = require('./directives/DirContactUpdate');
 const { DirClearTranscript } = require('./directives/DirClearTranscript');
 const { DirMoveToUnassigned } = require('./directives/DirMoveToUnassigned');
-const { DirWhatsappStatic, DirSendWhatsapp } = require('./directives/DirSendWhatsapp');
+const { DirAddTags } = require('./directives/DirAddTags');
+const { DirSendWhatsapp } = require('./directives/DirSendWhatsapp');
 
 class DirectivesChatbotPlug {
 
@@ -64,7 +65,7 @@ class DirectivesChatbotPlug {
 
   constructor(config) {
     this.supportRequest = config.supportRequest;
-    this.API_URL = config.TILEDESK_API_ENDPOINT;
+    this.API_ENDPOINT = config.API_ENDPOINT;
     this.TILEBOT_ENDPOINT = config.TILEBOT_ENDPOINT;
     this.token = config.token;
     this.log = config.log;
@@ -124,7 +125,7 @@ class DirectivesChatbotPlug {
     // console.log("supportRequest is:", JSON.stringify(supportRequest))
     
     const token = this.token;
-    const API_URL = this.API_URL;
+    const API_ENDPOINT = this.API_ENDPOINT;
     const TILEBOT_ENDPOINT = this.TILEBOT_ENDPOINT;
 
     // const requestId = supportRequest.request_id
@@ -141,7 +142,7 @@ class DirectivesChatbotPlug {
       tdclient = new TiledeskClient({
         projectId: projectId,
         token: token,
-        APIURL: API_URL,
+        APIURL: API_ENDPOINT,
         APIKEY: "___",
         log: this.log
       });
@@ -158,7 +159,7 @@ class DirectivesChatbotPlug {
       supportRequest: supportRequest,
       reply: this.reply,
       requestId: supportRequest.request_id,
-      TILEDESK_APIURL: API_URL,
+      API_ENDPOINT: API_ENDPOINT,
       TILEBOT_ENDPOINT: TILEBOT_ENDPOINT,
       departmentId: depId,
       tdcache: tdcache,
@@ -348,6 +349,13 @@ class DirectivesChatbotPlug {
         this.process(next_dir);
       });
     }
+    else if (directive_name === Directives.AUDIO_RECORD) {
+      // console.log("...DirReply");
+      new DirReply(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
     else if (directive_name === Directives.RANDOM_REPLY) {
       // console.log("...DirRandomReply");
       new DirRandomReply(context).execute(directive, async () => {
@@ -712,14 +720,12 @@ class DirectivesChatbotPlug {
       });
     }
     else if (directive_name === Directives.CLEAR_TRANSCRIPT) {
-      console.log("...CLEAR_TRANSCRIPT");
       new DirClearTranscript(context).execute(directive, async () => {
         let next_dir = await this.nextDirective(this.directives);
         this.process(next_dir);
       });
     }
     else if (directive_name === Directives.MOVE_TO_UNASSIGNED) {
-      console.log("...MOVE_TO_UNASSIGNED");
       new DirMoveToUnassigned(context).execute(directive, async () => {
         let next_dir = await this.nextDirective(this.directives);
         this.process(next_dir);
@@ -732,6 +738,20 @@ class DirectivesChatbotPlug {
         this.process(next_dir);
       });
     }
+    else if (directive_name === Directives.ADD_TAGS) {
+      // console.log(".....DirAddTags")
+      new DirAddTags(context).execute(directive, async (stop) => {
+        if (context.log) { console.log("GPTTask stop?", stop);}
+        if (stop == true) {
+          if (context.log) { console.log("Stopping Actions on:", JSON.stringify(directive));}
+          this.theend();
+        }
+        else {
+          let next_dir = await this.nextDirective(this.directives);
+          this.process(next_dir);
+        }
+      });
+    }
     else {
       //console.log("Unhandled Post-message Directive:", directive_name);
       let next_dir = await this.nextDirective(this.directives);
@@ -748,7 +768,7 @@ class DirectivesChatbotPlug {
     }
     const supportRequest = this.supportRequest;
     const token = this.token;
-    const API_URL = this.API_URL;
+    const API_ENDPOINT = this.API_ENDPOINT;
     // const requestId = supportRequest.request_id
     // let depId;
     // if (supportRequest.department && supportRequest.department._id) {
@@ -758,7 +778,7 @@ class DirectivesChatbotPlug {
     const tdclient = new TiledeskClient({
       projectId: projectId,
       token: token,
-      APIURL: API_URL,
+      APIURL: API_ENDPOINT,
       APIKEY: "___",
       log: false
     });

package/tiledeskChatbotPlugs/directives/DirAddTags.js

@@ -0,0 +1,369 @@
+const axios = require("axios").default;
+const { TiledeskChatbot } = require("../../models/TiledeskChatbot");
+const { Filler } = require("../Filler");
+let https = require("https");
+const { DirIntent } = require("./DirIntent");
+const { TiledeskChatbotConst } = require("../../models/TiledeskChatbotConst");
+const { TiledeskChatbotUtil } = require("../../models/TiledeskChatbotUtil");
+const req = require("express/lib/request");
+const { rejects } = require("assert");
+const { update } = require("../../models/faq");
+require('dotenv').config();
+
+class DirAddTags {
+
+  constructor(context) {
+    if (!context) {
+      throw new Error('context object is mandatory');
+    }
+    this.context = context;
+    this.chatbot = this.context.chatbot;
+    this.tdcache = this.context.tdcache;
+    this.requestId = this.context.requestId;
+    this.tdClient = this.context.tdclient;
+    this.API_ENDPOINT = this.context.API_ENDPOINT;
+    // this.intentDir = new DirIntent(context);
+    this.log = context.log;
+    // this.log = true;
+  }
+
+  execute(directive, callback) {
+    if (this.log) { console.log("AddTags directive: ", directive); }
+    let action;
+    if (directive.action) {
+      action = directive.action;
+    }
+    else {
+      console.error("Incorrect directive: ", JSON.stringify(directive));
+      callback();
+      return;
+    }
+    this.go(action, (stop) => {
+      callback(stop);
+    })
+  }
+
+  async go(action, callback) {
+    if (this.log) { console.log("(DirAddTags) action:", JSON.stringify(action)); }
+    if (!this.tdcache) {
+      console.error("Error: (DirAddTags) tdcache is mandatory");
+      callback();
+      return;
+    }
+
+    // default value
+    let target = "request";
+    let pushToList = false;
+
+    target = action.target
+    pushToList = action.pushToList
+
+    if (!action.tags || action.tags === '') {
+      console.error("Error: (DirAddTags) tags attribute is mandatory")
+      await this.chatbot.addParameter("flowError", "Add tags Error: tags attribute is mandatory");
+      callback();
+      return;
+    }
+
+    let requestVariables = null;
+    requestVariables =
+      await TiledeskChatbot.allParametersStatic(
+        this.tdcache, this.requestId
+      )
+
+    const filler = new Filler();
+    const filled_tags = filler.fill(action.tags, requestVariables);
+  
+    if (this.log) {
+      console.log("(DirAddTags) tags: ", filled_tags);
+    }
+
+    // let request = await this.tdClient.getRequestById(this.requestId);
+    // if (this.log) { console.log('(DirAddTags) request detail: ', request) }
+    // if(!request){
+    //   if (this.log) { console.log("(DirAddTags) - request not found for request_id:", this.requestId); }
+    //   callback();
+    //   return;
+    // }
+
+    /** use case: CONVERSATION */
+    if(target === 'request'){
+      
+      let newTags = filled_tags.split(',').filter(tag => tag !== '').map(el => el.trim())
+
+      if(action.pushToList){
+        newTags.forEach(async (tag) => {
+          let tags = await this.addNewTag(tag)
+          if(!tags){
+            callback();
+            return;
+          }
+        })
+      }
+
+      if (this.log) { console.log('(DirAddTags) UPDATE request with newTags', newTags) }
+      let updatedRequest = await this.updateRequestWithTags(newTags)
+      if(!updatedRequest){
+        callback();
+        return;
+      }
+
+    }
+
+    /** use case: LEAD */
+    if(target === 'lead'){
+      let newTags = filled_tags.split(',').filter(tag => tag !== '').map(el => el.trim())
+
+      let request = await this.tdClient.getRequestById(this.requestId);
+      if (this.log) { console.log('(DirAddTags) request detail: ', request) }
+      if(!request){
+        if (this.log) { console.log("(DirAddTags) - request not found for request_id:", this.requestId); }
+        callback();
+        return;
+      }
+
+      if(action.pushToList){
+        newTags.forEach(async (tag) => {
+          let tags = await this.addNewTag(tag)
+          if(!tags){
+            callback();
+            return;
+          }
+        })
+      }
+
+      if (this.log) {  console.log('(DirAddTags) UPDATE lead with newTags', newTags) }
+      let updatedLead = await this.updateLeadWithTags(request.lead._id, newTags)
+      if(!updatedLead){
+        callback();
+        return;
+      }
+    }
+    
+    callback();
+    return;
+    
+
+  }
+
+  async convertToJson(data) {
+
+    return new Promise((resolve) => {
+      let json = null;
+      try {
+        json = JSON.parse(data);
+        resolve(json)
+      } catch (err) {
+        resolve(data)
+      }
+    })
+
+  }
+
+  async #executeCondition(result, trueIntent, trueIntentAttributes, falseIntent, falseIntentAttributes, callback) {
+    let trueIntentDirective = null;
+    if (trueIntent) {
+      trueIntentDirective = DirIntent.intentDirectiveFor(trueIntent, trueIntentAttributes);
+    }
+    let falseIntentDirective = null;
+    if (falseIntent) {
+      falseIntentDirective = DirIntent.intentDirectiveFor(falseIntent, falseIntentAttributes);
+    }
+    if (result === true) {
+      if (trueIntentDirective) {
+        this.intentDir.execute(trueIntentDirective, () => {
+          if (callback) {
+            callback();
+          }
+        })
+      }
+      else {
+        if (this.log) { console.log("No trueIntentDirective specified"); }
+        if (callback) {
+          callback();
+        }
+      }
+    }
+    else {
+      if (falseIntentDirective) {
+        this.intentDir.execute(falseIntentDirective, () => {
+          if (callback) {
+            callback();
+          }
+        });
+      }
+      else {
+        if (this.log) { console.log("No falseIntentDirective specified"); }
+        if (callback) {
+          callback();
+        }
+      }
+    }
+  }
+
+  async #assignAttributes(action, answer) {
+    if (this.log) {
+      console.log("assignAttributes action:", action)
+      console.log("assignAttributes answer:", answer)
+    }
+    if (this.context.tdcache) {
+      if (action.assignReplyTo && answer) {
+        await TiledeskChatbot.addParameterStatic(this.context.tdcache, this.context.requestId, action.assignReplyTo, answer);
+      }
+      // Debug log
+      if (this.log) {
+        const all_parameters = await TiledeskChatbot.allParametersStatic(this.context.tdcache, this.context.requestId);
+        for (const [key, value] of Object.entries(all_parameters)) {
+          if (this.log) { console.log("(DirAddTags) request parameter:", key, "value:", value, "type:", typeof value) }
+        }
+      }
+    }
+  }
+
+  #myrequest(options, callback) {
+    if (this.log) {
+      console.log("API URL:", options.url);
+      console.log("** Options:", JSON.stringify(options));
+    }
+    let axios_options = {
+      url: options.url,
+      method: options.method,
+      params: options.params,
+      headers: options.headers
+    }
+    if (options.json !== null) {
+      axios_options.data = options.json
+    }
+    if (this.log) {
+      console.log("axios_options:", JSON.stringify(axios_options));
+    }
+    if (options.url.startsWith("https:")) {
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+      axios_options.httpsAgent = httpsAgent;
+    }
+    axios(axios_options)
+      .then((res) => {
+        if (this.log) {
+          console.log("Response for url:", options.url);
+          console.log("Response headers:\n", JSON.stringify(res.headers));
+        }
+        if (res && res.status == 200 && res.data) {
+          if (callback) {
+            callback(null, res.data);
+          }
+        }
+        else {
+          if (callback) {
+            callback(new Error("Response status is not 200"), null);
+          }
+        }
+      })
+      .catch((error) => {
+        if (callback) {
+          callback(error, null);
+        }
+      });
+  }
+
+  async addNewTag(tag){
+    return new Promise((resolve, rejects)=> {
+      const HTTPREQUEST = {
+        url: this.API_ENDPOINT + "/" + this.context.projectId + "/tags",
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': 'JWT ' + this.context.token
+        },
+        method: "POST",
+        json: {
+          tag: tag,
+          color: '#f0806f'
+        }
+      }
+      this.#myrequest(
+        HTTPREQUEST, async (err, resbody) => {
+          if (err) {
+            console.error("(httprequest) DirAddTags add tags to list err: ", err);
+            resolve(true)
+          } else {
+            if (resbody) {
+              resolve(true)
+            } else {
+              resolve(false)
+            }
+          }
+        }
+      )
+    })
+  }
+
+
+  async updateRequestWithTags(tags) {
+    return new Promise((resolve) => {
+      let json = []
+      let filteredTags = tags.map((tag) => ({tag: tag, color: '#f0806f'}))
+      json.push(...filteredTags)
+      if (this.log) {
+        console.log('(httprequest) DirAddTags updateRequestWithTags tags--> ', json)
+      }
+      const HTTPREQUEST = {
+        url: this.API_ENDPOINT + "/" + this.context.projectId + "/requests/" + this.requestId + '/tag',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': 'JWT ' + this.context.token
+        },
+        method: "PUT",
+        json: json
+      }
+
+      this.#myrequest(
+        HTTPREQUEST, async (err, resbody) => {
+          if (err) {
+            console.error("(httprequest) DirAddTags patch request with new tags err: ", err);
+            resolve(true)
+          } else {
+            if (resbody) {
+              resolve(resbody)
+            } else {
+              resolve(false)
+            }
+          }
+        }
+      )
+    })
+  }
+
+  async updateLeadWithTags(lead_id, tags) {
+    return new Promise((resolve) => {
+      const HTTPREQUEST = {
+        url: this.API_ENDPOINT + "/" + this.context.projectId + "/leads/" + lead_id + '/tag',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': 'JWT ' + this.context.token
+        },
+        method: "PUT",
+        json: tags
+      }
+
+      this.#myrequest(
+        HTTPREQUEST, async (err, resbody) => {
+          if (err) {
+            console.error("(httprequest) DirAddTags put lead with new tags err: ", err);
+            resolve(true)
+          } else {
+            if (resbody) {
+              resolve(resbody)
+            } else {
+              resolve(false)
+            }
+          }
+        }
+      )
+    })
+  }
+
+
+}
+
+module.exports = { DirAddTags }

package/tiledeskChatbotPlugs/directives/DirAskGPT.js

@@ -15,6 +15,7 @@ class DirAskGPT {
     this.tdcache = this.context.tdcache;
     this.requestId = this.context.requestId;
     this.intentDir = new DirIntent(context);
+    this.API_ENDPOINT = this.context.API_ENDPOINT;
     this.log = context.log;
   }
 
@@ -88,17 +89,13 @@ class DirAskGPT {
     const filler = new Filler();
     const filled_question = filler.fill(action.question, requestVariables);
 
-    const server_base_url = process.env.API_ENDPOINT || process.env.API_URL;
     const kb_endpoint = process.env.KB_ENDPOINT;
-    if (this.log) {
-      console.log("DirAskGPT ApiEndpoint URL: ", server_base_url);
-      console.log("DirAskGPT KbEndpoint URL: ", kb_endpoint);
-    }
+    if (this.log) { console.log("DirAskGPT KbEndpoint URL: ", kb_endpoint); }
 
-    let key = await this.getKeyFromIntegrations(server_base_url);
+    let key = await this.getKeyFromIntegrations();
     if (!key) {
       if (this.log) { console.log("DirAskGPT - Key not found in Integrations. Searching in kb settings..."); }
-      key = await this.getKeyFromKbSettings(server_base_url);
+      key = await this.getKeyFromKbSettings();
     }
 
     if (!key) {
@@ -120,7 +117,7 @@ class DirAskGPT {
     }
 
     if (publicKey === true) {
-      let keep_going = await this.checkQuoteAvailability(server_base_url);
+      let keep_going = await this.checkQuoteAvailability();
       if (keep_going === false) {
         if (this.log) { console.log("DirAskGPT - Quota exceeded for tokens. Skip the action")}
         callback();
@@ -167,7 +164,7 @@ class DirAskGPT {
 
           // if (publicKey === true) {
           //   let token_usage = resbody.usage.total_tokens;
-          //   this.updateQuote(server_base_url, token_usage);
+          //   this.updateQuote(token_usage);
           // }
           
           if (trueIntent) {
@@ -305,11 +302,11 @@ class DirAskGPT {
       });
   }
 
-  async getKeyFromIntegrations(server_base_url) {
+  async getKeyFromIntegrations() {
     return new Promise((resolve) => {
 
       const INTEGRATIONS_HTTPREQUEST = {
-        url: server_base_url + "/" + this.context.projectId + "/integration/name/openai",
+        url: this.API_ENDPOINT + "/" + this.context.projectId + "/integration/name/openai",
         headers: {
           'Content-Type': 'application/json',
           'Authorization': 'JWT ' + this.context.token
@@ -337,11 +334,11 @@ class DirAskGPT {
     })
   }
 
-  async getKeyFromKbSettings(server_base_url) {
+  async getKeyFromKbSettings() {
     return new Promise((resolve) => {
 
       const KB_HTTPREQUEST = {
-        url: server_base_url + "/" + this.context.projectId + "/kbsettings",
+        url: this.API_ENDPOINT + "/" + this.context.projectId + "/kbsettings",
         headers: {
           'Content-Type': 'application/json',
           'Authorization': 'JWT ' + this.context.token