wip

lib/tasks/gather.js

@@ -824,13 +824,14 @@ class TaskGather extends SttTask {
       if (code === 413 && error === 'Too much speech') return this._resolve('timeout');
     }
     this.logger.info({evt}, 'TaskGather:_onJambonzError');
+    const errMessage = evt.error || evt.Message;
     writeAlerts({
       account_sid: cs.accountSid,
       alert_type: AlertType.STT_FAILURE,
-      message: `Custom speech vendor ${this.vendor} error: ${evt.error}`,
+      message: `Speech vendor ${this.vendor} error: ${errMessage}`,
       vendor: this.vendor,
     }).catch((err) => this.logger.info({err}, 'Error generating alert for jambonz custom connection failure'));
-    this.notifyError({msg: 'ASR error', details:`Custom speech vendor ${this.vendor} error: ${evt.error}`});
+    this.notifyError({msg: 'ASR error', details:`Speech vendor ${this.vendor} error: ${evt.error}`});
   }
 
   _onVendorConnectFailure(cs, _ep, evt) {

lib/tasks/stt-task.js

@@ -53,7 +53,7 @@ class SttTask extends Task {
   }
 
   async _initSpeechCredentials(cs, vendor, label) {
-    const {getNuanceAccessToken, getIbmAccessToken} = this.cs.srf.locals.dbHelpers;
+    const {getNuanceAccessToken, getIbmAccessToken, getAwsAuthToken} = this.cs.srf.locals.dbHelpers;
     let credentials = cs.getSpeechCredentials(vendor, 'stt', label);
 
     if (!credentials) {
@@ -87,6 +87,15 @@ class SttTask extends Task {
       this.logger.debug({stt_api_key}, `got ibm access token ${servedFromCache ? 'from cache' : ''}`);
       credentials = {...credentials, access_token, stt_region};
     }
+    else if (vendor == 'aws') {
+      /* get AWS access token */
+      const {accessKeyId, secretAccessKey, securityToken, region } = credentials;
+      if (!securityToken) {
+        const { servedFromCache, ...newCredentials} = await getAwsAuthToken(accessKeyId, secretAccessKey, region);
+        this.logger.debug({newCredentials}, `got aws security token ${servedFromCache ? 'from cache' : ''}`);
+        credentials = {...newCredentials, region};
+      }
+    }
     return credentials;
   }
 

lib/utils/install-srf-locals.js

@@ -178,6 +178,7 @@ function installSrfLocals(srf, logger) {
     synthAudio,
     getNuanceAccessToken,
     getIbmAccessToken,
+    getAwsAuthToken
   } = require('@jambonz/speech-utils')({redis_client: client}, logger);
   const {
     writeAlerts,
@@ -231,6 +232,7 @@ function installSrfLocals(srf, logger) {
       getListPosition,
       getNuanceAccessToken,
       getIbmAccessToken,
+      getAwsAuthToken,
       addToSortedSet,
       retrieveFromSortedSet,
       retrieveByPatternSortedSet,

lib/utils/transcription-utils.js

@@ -60,7 +60,13 @@ const stickyVars = {
   aws: [
     'AWS_VOCABULARY_NAME',
     'AWS_VOCABULARY_FILTER_METHOD',
-    'AWS_VOCABULARY_FILTER_NAME'
+    'AWS_VOCABULARY_FILTER_NAME',
+    'AWS_LANGUAGE_MODEL_NAME',
+    'AWS_ACCESS_KEY_ID',
+    'AWS_SECRET_ACCESS_KEY',
+    'AWS_REGION',
+    'AWS_SECURITY_TOKEN',
+    'AWS_PII_ENTITY_TYPES'
   ],
   nuance: [
     'NUANCE_ACCESS_TOKEN',
@@ -368,11 +374,19 @@ const normalizeMicrosoft = (evt, channel, language) => {
 
 const normalizeAws = (evt, channel, language) => {
   const copy = JSON.parse(JSON.stringify(evt));
+  const alternatives = evt.Transcript?.Results[0]?.Alternatives.map((alt) => {
+    const items = alt.Items.filter((item) => item.Type === 'pronunciation' && 'Confidence' in item);
+    const confidence = items.reduce((acc, item) => acc + item.Confidence, 0) / items.length;
+    return {
+      transcript: alt.Transcript,
+      confidence
+    };
+  });
   return {
     language_code: language,
     channel_tag: channel,
-    is_final: evt[0].is_final,
-    alternatives: evt[0].alternatives,
+    is_final: evt.Transcript?.Results[0].IsPartial === false,
+    alternatives,
     vendor: {
       name: 'aws',
       evt: copy
@@ -483,16 +497,29 @@ module.exports = (logger) => {
       };
     }
     else if (['aws', 'polly'].includes(vendor)) {
+      const {awsOptions = {}} = rOpts;
+      const vocabularyName = awsOptions.vocabularyName || rOpts.vocabularyName;
+      const vocabularyFilterName = awsOptions.vocabularyFilterName || rOpts.vocabularyFilterName;
+      const filterMethod = awsOptions.vocabularyFilterMethod || rOpts.filterMethod;
       opts = {
         ...opts,
-        ...(rOpts.vocabularyName && {AWS_VOCABULARY_NAME: rOpts.vocabularyName}),
-        ...(rOpts.vocabularyFilterName && {AWS_VOCABULARY_FILTER_NAME: rOpts.vocabularyFilterName}),
-        ...(rOpts.filterMethod && {AWS_VOCABULARY_FILTER_METHOD: rOpts.filterMethod}),
+        ...(vocabularyName && {AWS_VOCABULARY_NAME: vocabularyName}),
+        ...(vocabularyFilterName && {AWS_VOCABULARY_FILTER_NAME: vocabularyFilterName}),
+        ...(filterMethod && {AWS_VOCABULARY_FILTER_METHOD: filterMethod}),
         ...(sttCredentials && {
           AWS_ACCESS_KEY_ID: sttCredentials.accessKeyId,
           AWS_SECRET_ACCESS_KEY: sttCredentials.secretAccessKey,
-          AWS_REGION: sttCredentials.region
+          AWS_REGION: sttCredentials.region,
+          AWS_SECURITY_TOKEN: sttCredentials.securityToken
         }),
+        ...(awsOptions.accessKey && {AWS_ACCESS_KEY_ID: awsOptions.accessKey}),
+        ...(awsOptions.secretKey && {AWS_SECRET_ACCESS_KEY: awsOptions.secretKey}),
+        ...(awsOptions.region && {AWS_REGION: awsOptions.region}),
+        ...(awsOptions.securityToken && {AWS_SECURITY_TOKEN: awsOptions.securityToken}),
+        ...(awsOptions.languageModelName && {AWS_LANGUAGE_MODEL_NAME: awsOptions.languageModelName}),
+        ...(awsOptions.piiEntityTypes?.length && {AWS_PII_ENTITY_TYPES: awsOptions.piiEntityTypes.join(',')}),
+        ...(awsOptions.piiIdentifyEntities && {AWS_PII_IDENTIFY_ENTITIES: true}),
+        ...(awsOptions.languageModelName && {AWS_LANGUAGE_MODEL_NAME: awsOptions.languageModelName}),
       };
     }
     else if ('microsoft' === vendor) {
@@ -801,6 +828,17 @@ module.exports = (logger) => {
       if (clientId && secret) return {client_id: clientId, secret};
       if (kryptonEndpoint) return {nuance_stt_uri: kryptonEndpoint};
     }
+    else if (recognizer.vendor === 'aws') {
+      const {accessKey, secretKey, region, securityToken} = recognizer.awsOptions || {};
+      if (accessKey || secretKey || region || securityToken) {
+        return {
+          accessKeyId: accessKey,
+          secretAccessKey: secretKey,
+          region,
+          securityToken
+        };
+      }
+    }
     else if (recognizer.vendor === 'nvidia') {
       const {rivaUri} = recognizer.nvidiaOptions || {};
       if (rivaUri) return {riva_uri: rivaUri};

package.json

@@ -31,19 +31,19 @@
     "@jambonz/http-health-check": "^0.0.1",
     "@jambonz/mw-registrar": "^0.2.4",
     "@jambonz/realtimedb-helpers": "^0.8.7",
-    "@jambonz/speech-utils": "^0.0.29",
+    "@jambonz/speech-utils": "^0.0.30",
     "@jambonz/stats-collector": "^0.1.9",
     "@jambonz/time-series": "^0.2.8",
-    "@jambonz/verb-specifications": "^0.0.46",
-    "@opentelemetry/api": "^1.4.0",
-    "@opentelemetry/exporter-jaeger": "^1.9.0",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.35.0",
-    "@opentelemetry/exporter-zipkin": "^1.9.0",
-    "@opentelemetry/instrumentation": "^0.35.0",
-    "@opentelemetry/resources": "^1.9.0",
-    "@opentelemetry/sdk-trace-base": "^1.9.0",
-    "@opentelemetry/sdk-trace-node": "^1.9.0",
-    "@opentelemetry/semantic-conventions": "^1.9.0",
+    "@jambonz/verb-specifications": "^0.0.49",
+    "@opentelemetry/api": "^1.7.0",
+    "@opentelemetry/exporter-jaeger": "^1.18.1",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.45.1",
+    "@opentelemetry/exporter-zipkin": "^1.18.1",
+    "@opentelemetry/instrumentation": "^0.45.1",
+    "@opentelemetry/resources": "^1.18.1",
+    "@opentelemetry/sdk-trace-base": "^1.18.1",
+    "@opentelemetry/sdk-trace-node": "^1.18.1",
+    "@opentelemetry/semantic-conventions": "^1.18.1",
     "bent": "^7.3.12",
     "debug": "^4.3.4",
     "deepcopy": "^2.1.0",