botium-connector-voip 0.0.5 → 0.0.7

package/dist/botium-connector-voip-cjs.js

@@ -7,6 +7,7 @@ var ws = require('ws');
 var lodash = require('lodash');
 var axios = require('axios');
 var debug$1 = require('debug');
+var path = require('path');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -15,6 +16,7 @@ var ws__default = /*#__PURE__*/_interopDefaultLegacy(ws);
 var lodash__default = /*#__PURE__*/_interopDefaultLegacy(lodash);
 var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 var debug__default = /*#__PURE__*/_interopDefaultLegacy(debug$1);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 
 const {
   v4: uuidv4
@@ -55,7 +57,13 @@ const Capabilities = {
   VOIP_ICE_TURN_SERVER: 'VOIP_ICE_TURN_SERVER',
   VOIP_ICE_TURN_USER: 'VOIP_ICE_TURN_USER',
   VOIP_ICE_TURN_PASSWORD: 'VOIP_ICE_TURN_PASSWORD',
-  VOIP_ICE_TURN_PROTOCOL: 'VOIP_ICE_TURN_PROTOCOL'
+  VOIP_ICE_TURN_PROTOCOL: 'VOIP_ICE_TURN_PROTOCOL',
+  VOIP_WEBSOCKET_CONNECT_MAXRETRIES: 'VOIP_WEBSOCKET_CONNECT_MAXRETRIES',
+  VOIP_WEBSOCKET_CONNECT_TIMEOUT: 'VOIP_WEBSOCKET_CONNECT_TIMEOUT',
+  VOIP_SILENCE_DURATION_TIMEOUT_ENABLE: 'VOIP_SILENCE_DURATION_TIMEOUT_ENABLE',
+  VOIP_SILENCE_DURATION_TIMEOUT: 'VOIP_SILENCE_DURATION_TIMEOUT',
+  VOIP_SILENCE_DURATION_TIMEOUT_START_ENABLE: 'VOIP_SILENCE_DURATION_TIMEOUT_START_ENABLE',
+  VOIP_SILENCE_DURATION_TIMEOUT_START: 'VOIP_SILENCE_DURATION_TIMEOUT_START'
 };
 const Defaults = {
   VOIP_STT_METHOD: 'POST',
@@ -63,9 +71,15 @@ const Defaults = {
   VOIP_TTS_METHOD: 'GET',
   VOIP_TTS_TIMEOUT: 10000,
   VOIP_STT_MESSAGE_HANDLING: 'ORIGINAL',
-  VOIP_STT_MESSAGE_HANDLING_TIMEOUT: 5000,
+  VOIP_STT_MESSAGE_HANDLING_TIMEOUT: 500,
   VOIP_STT_MESSAGE_HANDLING_DELIMITER: '. ',
-  VOIP_STT_MESSAGE_HANDLING_PUNCTUATION: '.!?'
+  VOIP_STT_MESSAGE_HANDLING_PUNCTUATION: '.!?',
+  VOIP_WEBSOCKET_CONNECT_TIMEOUT: 4000,
+  VOIP_WEBSOCKET_CONNECT_MAXRETRIES: 20,
+  VOIP_SILENCE_DURATION_TIMEOUT: 2500,
+  VOIP_SILENCE_DURATION_TIMEOUT_ENABLE: false,
+  VOIP_SILENCE_DURATION_TIMEOUT_START: 1000,
+  VOIP_SILENCE_DURATION_TIMEOUT_START_ENABLE: false
 };
 
 class BotiumConnectorVoip {
@@ -128,22 +142,32 @@ class BotiumConnectorVoip {
         stepId: null
       }
     };
+    this.stopCalled = false;
     this.fullRecord = '';
     this.end = false;
+    this.connected = false;
 
     const sendBotMsg = botMsg => {
       setTimeout(() => this.queueBotSays(botMsg), 0);
     };
 
-    const buildBotMsg = botMsgs => {
-      if (botMsgs.length === 1) return botMsgs[0];
+    const joinBotMsg = (botMsgs, joinLastPrevMsg) => {
       const botMsg = {};
       botMsg.messageText = botMsgs.map(m => m.messageText).join(this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING_DELIMITER]);
       botMsg.sourceData = botMsgs.map(m => m.sourceData);
+
+      if (lodash__default["default"].isNil(joinLastPrevMsg)) {
+        botMsg.sourceData[0].silenceDuration = botMsgs[0].sourceData.data.start;
+        botMsg.sourceData[0].voiceDuration = botMsgs[botMsgs.length - 1].sourceData.data.end - botMsgs[0].sourceData.data.start;
+      } else {
+        botMsg.sourceData[0].silenceDuration = botMsgs[0].sourceData.data.start - joinLastPrevMsg.sourceData.data.end;
+        botMsg.sourceData[0].voiceDuration = botMsgs[botMsgs.length - 1].sourceData.data.end - botMsgs[0].sourceData.data.start;
+      }
+
       return botMsg;
     };
 
-    const expandBotMsgs = botMsgs => {
+    const splitBotMsgs = botMsgs => {
       const splitSentences = s => s.match(new RegExp(`[^${this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING_PUNCTUATION]}]+[${this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING_PUNCTUATION]}]+`, 'g'));
 
       const botMsgsFinal = [];
@@ -154,11 +178,14 @@ class BotiumConnectorVoip {
         if (lodash__default["default"].isNil(sentences)) {
           botMsgsFinal.push(botMsg);
         } else {
+          let botMsgCount = 0;
+
           for (const sentence of sentences) {
             botMsgsFinal.push({
               messageText: sentence,
-              sourceData: botMsg.sourceData
+              sourceData: botMsgCount === 0 ? botMsg.sourceData : lodash__default["default"].omit(botMsg.sourceData, ['silenceDuration'])
             });
+            botMsgCount++;
           }
         }
       }
@@ -166,24 +193,68 @@ class BotiumConnectorVoip {
       return botMsgsFinal;
     };
 
+    let data = null;
+    let headers = null;
+
+    try {
+      const res = await axios__default["default"]({
+        method: 'post',
+        data: {
+          API_KEY: this.caps[Capabilities.VOIP_WORKER_APIKEY]
+        },
+        url: new URL(path__default["default"].join(`${this.caps[Capabilities.VOIP_WORKER_URL].replace('wss', 'https').replace('ws', 'http')}`, 'initCall')).toString()
+      });
+      data = res.data;
+      headers = res.headers;
+    } catch (err) {
+      return Promise.reject(new Error(`Connecting to VOIP Worker failed: ${err.response.data.message || 'Not reachable'}`));
+    }
+
     return new Promise((resolve, reject) => {
-      this.ws = new ws__default["default"](this.caps[Capabilities.VOIP_WORKER_URL]);
+      const wsEndpoint = `${this.caps[Capabilities.VOIP_WORKER_URL]}/ws/${data.port}`;
+
+      const connect = retryIndex => {
+        retryIndex = retryIndex || 0;
+        return new Promise((resolve, reject) => {
+          if ('set-cookie' in headers) {
+            this.ws = new ws__default["default"](wsEndpoint, {
+              headers: {
+                Cookie: headers['set-cookie']
+              }
+            });
+          } else {
+            this.ws = new ws__default["default"](wsEndpoint);
+          }
 
-      if (!lodash__default["default"].isArray(this.caps[Capabilities.VOIP_ICE_STUN_SERVERS])) {
-        if (this.caps[Capabilities.VOIP_ICE_STUN_SERVERS] === '') {
-          this.caps[Capabilities.VOIP_ICE_STUN_SERVERS] = [];
-        } else {
-          this.caps[Capabilities.VOIP_ICE_STUN_SERVERS] = this.caps[Capabilities.VOIP_ICE_STUN_SERVERS].split(',');
+          this.ws.on('open', () => {
+            resolve();
+          });
+          this.ws.on('error', () => {
+            if (retryIndex === this.caps[Capabilities.VOIP_WEBSOCKET_CONNECT_MAXRETRIES]) {
+              reject(new Error(`Websocket connection failed to ${wsEndpoint}`));
+            }
+
+            setTimeout(() => connect(retryIndex + 1).then(resolve).catch(reject), this.caps[Capabilities.VOIP_WEBSOCKET_CONNECT_TIMEOUT]);
+          });
+        });
+      };
+
+      connect().then(() => {
+        if (!lodash__default["default"].isArray(this.caps[Capabilities.VOIP_ICE_STUN_SERVERS])) {
+          if (this.caps[Capabilities.VOIP_ICE_STUN_SERVERS] === '') {
+            this.caps[Capabilities.VOIP_ICE_STUN_SERVERS] = [];
+          } else {
+            this.caps[Capabilities.VOIP_ICE_STUN_SERVERS] = this.caps[Capabilities.VOIP_ICE_STUN_SERVERS].split(',');
+          }
         }
-      }
 
-      this.wsOpened = false;
-      this.ws.on('open', () => {
+        this.silence = null;
+        this.msgCount = 0;
+        this.firstMsg = true;
         this.wsOpened = true;
-        debug(`Websocket connection to ${this.caps[Capabilities.VOIP_WORKER_ENDPOINT]} opened.`);
+        debug(`Websocket connection to ${wsEndpoint} opened.`);
         const request = {
           METHOD: 'initCall',
-          API_KEY: this.caps[Capabilities.VOIP_WORKER_APIKEY],
           SIP_CALLER_AUTO: this.caps[Capabilities.VOIP_SIP_POOL_CALLER_ENABLE],
           SIP_PROXY: this.caps[Capabilities.VOIP_SIP_PROXY],
           SIP_CALLER_URI: this.caps[Capabilities.VOIP_SIP_CALLER_URI],
@@ -200,6 +271,7 @@ class BotiumConnectorVoip {
           ICE_TURN_USERNAME: this.caps[Capabilities.VOIP_ICE_TURN_USER],
           ICE_TURN_PASSWORD: this.caps[Capabilities.VOIP_ICE_TURN_PASSWORD],
           ICE_TURN_PROTOCOL: this.caps[Capabilities.VOIP_ICE_TURN_PROTOCOL] || 'TCP',
+          MIN_SILENCE_DURATION: this.caps[Capabilities.VOIP_SILENCE_DURATION_TIMEOUT_ENABLE] ? this.caps[Capabilities.VOIP_SILENCE_DURATION_TIMEOUT] : null,
           STT_CONFIG: {
             stt_url: this.caps[Capabilities.VOIP_STT_URL_STREAM],
             stt_params: this.caps[Capabilities.VOIP_STT_PARAMS_STREAM],
@@ -213,112 +285,162 @@ class BotiumConnectorVoip {
         };
         debug(JSON.stringify(request, null, 2));
         this.ws.send(JSON.stringify(request));
-      });
-      this.ws.on('close', async () => {
-        debug(`Websocket connection to ${this.caps[Capabilities.VOIP_WORKER_URL]} closed.`);
-      });
-      this.ws.on('error', err => {
-        debug(err);
+        this.ws.on('error', err => {
+          debug(err);
 
-        if (!this.wsOpened) {
-          this.end = true;
-          reject(new Error(`Websocket connection to ${this.caps[Capabilities.VOIP_WORKER_URL]} error: ${err.message || err}`));
-        }
-      });
-      this.ws.on('message', async data => {
-        const parsedData = JSON.parse(data);
+          if (!this.wsOpened) {
+            this.end = true;
+            reject(new Error(`${this.sessionId} - Websocket connection to ${wsEndpoint} error: ${err.message || err}`));
+          }
+        });
+        this.ws.on('message', async data => {
+          const parsedData = JSON.parse(data);
 
-        const parsedDataLog = lodash__default["default"].cloneDeep(parsedData);
+          const parsedDataLog = lodash__default["default"].cloneDeep(parsedData);
 
-        parsedDataLog.fullRecord = '<full_record_buffer>';
-        debug(JSON.stringify(parsedDataLog, null, 2));
+          parsedDataLog.fullRecord = '<full_record_buffer>';
+          debug(JSON.stringify(parsedDataLog, null, 2));
 
-        if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'initialized') {
-          this.sessionId = parsedData.voipConfig.sessionId;
-        }
+          if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'initialized') {
+            this.sessionId = parsedData.voipConfig.sessionId;
+          }
 
-        if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'unauthorized') {
-          reject(new Error('Error: Cannot open a call: SIP Authorization failed'));
-        }
+          if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'unauthorized') {
+            reject(new Error('Error: Cannot open a call: SIP Authorization failed'));
+          }
 
-        if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'forbidden' && parsedData.event !== 'onCallRegState') {
-          reject(new Error('Error: Cannot connect to VOIP Worker because of wrong API key'));
-        }
+          if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'forbidden' && parsedData.event === 'onCallRegState') {
+            reject(new Error('Error: Sip Registration failed'));
+          }
 
-        if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'forbidden' && parsedData.event === 'onCallRegState') {
-          reject(new Error('Error: Sip Registration failed'));
-        }
+          if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'connected') {
+            resolve();
+          }
 
-        if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'connected') {
-          resolve();
-        }
+          if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'disconnected') {
+            const apiKey = this._extractApiKey(this._getBody(Capabilities.VOIP_STT_BODY));
 
-        if (parsedData && parsedData.type === 'callinfo' && parsedData.status === 'disconnected') {
-          const apiKey = this._extractApiKey(this._getBody(Capabilities.VOIP_STT_BODY));
+            if (parsedData.connectDuration && parsedData.connectDuration > 0) {
+              this.eventEmitter.emit('CONSUMPTION_METADATA', this, {
+                type: lodash__default["default"].isNil(apiKey) ? 'INBUILT' : 'THIRD_PARTY',
+                metricName: 'consumption.e2e.voip.stt.seconds',
+                credits: parsedData.connectDuration,
+                apiKey
+              });
+            }
+          }
 
-          if (parsedData.connectDuration && parsedData.connectDuration > 0) {
-            this.eventEmitter.emit('CONSUMPTION_METADATA', this.container, {
-              type: lodash__default["default"].isNil(apiKey) ? 'INBUILT' : 'THIRD_PARTY',
-              metricName: 'consumption.e2e.voip.stt.seconds',
-              credits: parsedData.connectDuration,
-              apiKey
-            });
+          if (parsedData && parsedData.type === 'error') {
+            this.end = true;
+            reject(new Error(`Error: ${parsedData.message}`));
+            sendBotMsg(new Error(`Error: ${parsedData.message}`));
           }
-        }
 
-        if (parsedData && parsedData.type === 'error') {
-          reject(new Error(`Error: ${parsedData.message}`));
-        }
+          if (parsedData && parsedData.type === 'silence') {
+            this.end = true;
 
-        if (parsedData && parsedData.type === 'fullRecord') {
-          this.end = true;
-          this.eventEmitter.emit('MESSAGE_ATTACHMENT', this.container, {
-            name: 'full_record.wav',
-            mimeType: 'audio/wav',
-            base64: parsedData.fullRecord
-          });
-          this.Stop();
-        }
+            if (parsedData.data.silence.length > 0) {
+              sendBotMsg(new Error(`Silence Duration of ${parsedData.data.silence[0][2].toFixed(2)}s exceeded General Silence Duration Timeout of ${this.caps[Capabilities.VOIP_SILENCE_DURATION_TIMEOUT] / 1000}s`));
+              this.Stop();
+            }
+          }
 
-        if (parsedData && parsedData.data && parsedData.data.final === false) {
-          if (!this.sentenceBuilding) {
-            this.sentenceBuilding = true;
-            this.sentencesBuilding++;
+          if (parsedData && parsedData.type === 'fullRecord') {
+            this.eventEmitter.emit('MESSAGE_ATTACHMENT', this.container, {
+              name: 'full_record.wav',
+              mimeType: 'audio/wav',
+              base64: parsedData.fullRecord
+            });
           }
-        }
 
-        if (parsedData && parsedData.data && parsedData.data.final) {
-          const botMsg = {
-            messageText: parsedData.data.message,
-            sourceData: parsedData
-          };
-          this.botMsgs.push(botMsg);
+          if (parsedData && parsedData.data && parsedData.data.final === false) {
+            if (this.caps[Capabilities.VOIP_SILENCE_DURATION_TIMEOUT_START_ENABLE] && parsedData.data.start && parsedData.data.start * 1000 > this.caps[Capabilities.VOIP_SILENCE_DURATION_TIMEOUT_START]) {
+              sendBotMsg(new Error(`Silence Duration of ${parsedData.data.start}s exceeded Start Silence Duration Timeout of ${this.caps[Capabilities.VOIP_SILENCE_DURATION_TIMEOUT_START] / 1000}s`));
+              this.Stop();
+            }
 
-          if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'ORIGINAL') {
-            this.botMsgs.forEach(botMsg => sendBotMsg(botMsg));
-            this.botMsgs = [];
+            if (this.prevData) {
+              if (!lodash__default["default"].isNil(parsedData.data.start) && parsedData.data.start - this.prevData.data.end > parseInt(this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING_TIMEOUT]) / 1000) {
+                if (this.botMsgs.length > 0) {
+                  sendBotMsg(joinBotMsg(this.botMsgs, this.joinLastPrevMsg));
+                  this.firstMsg = false;
+                  this.joinLastPrevMsg = this.botMsgs[this.botMsgs.length - 1];
+                  this.botMsgs = [];
+                }
+              }
+            }
           }
 
-          if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'EXPAND') {
-            const botMsgsExpanded = expandBotMsgs(this.botMsgs);
-            botMsgsExpanded.forEach(botMsg => sendBotMsg(botMsg));
-            this.botMsgs = [];
-          }
+          if (parsedData && parsedData.data && parsedData.data.type === 'stt' && parsedData.data.final) {
+            if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'ORIGINAL') {
+              let botMsg = {
+                messageText: parsedData.data.message
+              };
+
+              if (this.firstMsg) {
+                const sourceData = parsedData;
+                sourceData.silenceDuration = parsedData.data.start;
+                sourceData.voiceDuration = parsedData.data.end - parsedData.data.start;
+                botMsg = Object.assign({}, botMsg, {
+                  sourceData
+                });
+                this.firstMsg = false;
+              } else {
+                const sourceData = parsedData;
+                sourceData.silenceDuration = parsedData.data.start - this.prevData.data.end;
+                sourceData.voiceDuration = parsedData.data.end - parsedData.data.start;
+                botMsg = Object.assign({}, botMsg, {
+                  sourceData
+                });
+              }
+
+              this.prevData = parsedData;
+              this.botMsgs.push(botMsg);
+              this.botMsgs.forEach(botMsg => sendBotMsg(botMsg));
+              this.botMsgs = [];
+            }
 
-          if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'CONCAT') {
-            this.sentenceBuilding = false;
-            this.sentencesFinal++;
-            clearTimeout(this.sendMessageTimeout);
-            this.sendMessageTimeout = setTimeout(() => {
-              if (this.sentenceBuilding === false && this.sentencesBuilding === this.sentencesFinal) {
-                sendBotMsg(buildBotMsg(this.botMsgs));
-                this.botMsgs = [];
-                this.sentencesBuilding = 0;
-                this.sentencesFinal = 0;
+            if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'SPLIT' || this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'EXPAND') {
+              let botMsg = {
+                messageText: parsedData.data.message
+              };
+
+              if (this.firstMsg) {
+                const sourceData = parsedData;
+                sourceData.silenceDuration = parsedData.data.start;
+                sourceData.voiceDuration = parsedData.data.end - parsedData.data.start;
+                botMsg = Object.assign({}, botMsg, {
+                  sourceData
+                });
+                this.firstMsg = false;
+              } else {
+                const sourceData = parsedData;
+                sourceData.silenceDuration = parsedData.data.start - this.prevData.data.end;
+                sourceData.voiceDuration = parsedData.data.end - parsedData.data.start;
+                botMsg = Object.assign({}, botMsg, {
+                  sourceData
+                });
               }
-            }, this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING_TIMEOUT]);
+
+              this.prevData = parsedData;
+              this.botMsgs.push(botMsg);
+              const botMsgsExpanded = splitBotMsgs(this.botMsgs);
+              botMsgsExpanded.forEach(botMsg => sendBotMsg(botMsg));
+              this.botMsgs = [];
+            }
+
+            if (this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'JOIN' || this.caps[Capabilities.VOIP_STT_MESSAGE_HANDLING] === 'CONCAT') {
+              const botMsg = {
+                messageText: parsedData.data.message,
+                sourceData: parsedData
+              };
+              this.botMsgs.push(botMsg);
+              this.prevData = parsedData;
+            }
           }
-        }
+        });
+      }).catch(err => {
+        reject(new Error('Error: ' + err));
       });
     });
   }
@@ -394,6 +516,17 @@ class BotiumConnectorVoip {
         }
 
         if (msg && msg.media && msg.media.length > 0 && msg.media[0].buffer) {
+          const request = JSON.stringify({
+            METHOD: 'sendAudio',
+            sessionId: this.sessionId,
+            b64_buffer: msg.media[0].buffer.toString('base64')
+          });
+          this.ws.send(request);
+          msg.attachments.push({
+            name: msg.media[0].mediaUri,
+            mimeType: msg.media[0].mimeType,
+            base64: msg.media[0].buffer.toString('base64')
+          });
           const {
             data
           } = await axios__default["default"]({
@@ -409,19 +542,9 @@ class BotiumConnectorVoip {
 
           if (data && data.duration) {
             duration = parseInt(data.duration);
+          } else {
+            reject(new Error('Getting audio duration from Speech Api failed'));
           }
-
-          const request = JSON.stringify({
-            METHOD: 'sendAudio',
-            sessionId: this.sessionId,
-            b64_buffer: msg.media[0].buffer.toString('base64')
-          });
-          msg.attachments.push({
-            name: msg.media[0].mediaUri,
-            mimeType: msg.media[0].mimeType,
-            base64: msg.media[0].buffer.toString('base64')
-          });
-          this.ws.send(request);
         }
 
         setTimeout(resolve, duration * 1000);
@@ -430,28 +553,30 @@ class BotiumConnectorVoip {
   }
 
   async Stop() {
-    debug('Stop called');
-    const request = JSON.stringify({
-      METHOD: 'stopCall',
-      sessionId: this.sessionId
-    });
-    this.ws.send(request);
-    await new Promise(resolve => {
-      setTimeout(resolve, 50000);
-      setInterval(() => {
-        if (this.end) {
-          resolve();
-        }
-      }, 1000);
-    });
+    debug(`${this.sessionId} - Stop called`);
 
-    if (this.ws) {
-      this.ws.close();
+    if (this.ws && this.ws.readyState !== ws__default["default"].CLOSED) {
+      const request = JSON.stringify({
+        METHOD: 'stopCall',
+        sessionId: this.sessionId
+      });
+      this.ws.send(request);
+      await new Promise(resolve => {
+        setTimeout(resolve, 10000);
+        setInterval(() => {
+          if (this.end) {
+            this.wsOpened = false;
+            this.ws = null;
+            this.view = {};
+            resolve();
+          }
+        }, 1000);
+      });
+    } else {
+      this.wsOpened = false;
+      this.ws = null;
+      this.view = {};
     }
-
-    this.wsOpened = false;
-    this.ws = null;
-    this.view = {};
   }
 
   _getParams(capParams) {