@fonoster/apiserver 0.6.6 → 0.7.0

package/dist/voice/integrations/types.d.ts

@@ -7,7 +7,7 @@ type IntegrationConfig = {
 type IntegrationsContainer = {
     ref: string;
     accessKeyId: string;
-    appEndpoint: string;
+    endpoint: string;
     tts: AbstractTextToSpeech<unknown>;
     stt: AbstractSpeechToText<unknown>;
 };

package/dist/voice/makeCreateVoiceClient.js

@@ -43,24 +43,18 @@ function makeCreateVoiceClient(createContainer) {
         const { ari, event, channel } = params;
         const { id: sessionRef, caller } = event.channel;
         const { name: callerName, number: callerNumber } = caller;
-        const getChannelVar = (0, makeGetChannelVar_1.makeGetChannelVar)(channel);
+        const getChannelVar = (0, makeGetChannelVar_1.makeGetChannelVarWithoutThrow)(channel);
         // Variables set by Asterisk's dialplan
         const appRef = (_a = (yield getChannelVar(types_1.ChannelVar.APP_REF))) === null || _a === void 0 ? void 0 : _a.value;
         const ingressNumber = ((_b = (yield getChannelVar(types_1.ChannelVar.INGRESS_NUMBER))) === null || _b === void 0 ? void 0 : _b.value) || "";
-        const { accessKeyId, appEndpoint, tts, stt } = yield createContainer(appRef);
+        const { accessKeyId, endpoint, tts, stt } = yield createContainer(appRef);
         const sessionToken = yield createToken({ accessKeyId, appRef });
-        let metadataStr;
-        try {
-            metadataStr = (_c = (yield getChannelVar(types_1.ChannelVar.METADATA))) === null || _c === void 0 ? void 0 : _c.value;
-        }
-        catch (e) {
-            // Do nothing
-        }
+        const metadataStr = (_c = (yield getChannelVar(types_1.ChannelVar.METADATA))) === null || _c === void 0 ? void 0 : _c.value;
         const config = {
             appRef,
             sessionRef,
             accessKeyId,
-            appEndpoint,
+            endpoint,
             callerName,
             callerNumber,
             ingressNumber,

package/dist/voice/makeGetChannelVar.d.ts

@@ -1,4 +1,5 @@
 import { Channel } from "ari-client";
 import { ChannelVar } from "./types";
 declare function makeGetChannelVar(channel: Channel): (variable: ChannelVar) => Promise<import("ari-client").Variable>;
-export { makeGetChannelVar };
+declare function makeGetChannelVarWithoutThrow(channel: Channel): (variable: ChannelVar) => Promise<import("ari-client").Variable>;
+export { makeGetChannelVar, makeGetChannelVarWithoutThrow };

package/dist/voice/makeGetChannelVar.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeGetChannelVar = makeGetChannelVar;
+exports.makeGetChannelVarWithoutThrow = makeGetChannelVarWithoutThrow;
 const ChannelVarNotFoundError_1 = require("./ChannelVarNotFoundError");
 function makeGetChannelVar(channel) {
     return (variable) => __awaiter(this, void 0, void 0, function* () {
@@ -23,3 +24,15 @@ function makeGetChannelVar(channel) {
         }
     });
 }
+function makeGetChannelVarWithoutThrow(channel) {
+    return (variable) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield channel.getChannelVar({
+                variable
+            });
+        }
+        catch (e) {
+            return null;
+        }
+    });
+}

package/dist/voice/stt/AbstractSpeechToText.d.ts

@@ -1,11 +1,12 @@
 import { Stream } from "stream";
 import * as z from "zod";
-import { SpeechResult, StreamSpeechResult, SttConfig } from "./types";
-declare abstract class AbstractSpeechToText<E, T extends SttConfig = SttConfig> {
+import { SpeechResult, StreamSpeech, SttConfig } from "./types";
+import { SpeechToText } from "../types";
+declare abstract class AbstractSpeechToText<E, T extends SttConfig = SttConfig> implements SpeechToText {
     abstract readonly engineName: E;
     config: T;
     constructor(config: T);
-    abstract streamTranscribe(stream: Stream): StreamSpeechResult;
+    abstract streamTranscribe(stream: Stream): StreamSpeech;
     abstract transcribe(stream: Stream): Promise<SpeechResult>;
     getName(): E;
     static getConfigValidationSchema(): z.Schema;

package/dist/voice/stt/Deepgram.d.ts

@@ -0,0 +1,18 @@
+import { Stream } from "stream";
+import * as z from "zod";
+import { AbstractSpeechToText } from "./AbstractSpeechToText";
+import { DeepgramSttConfig, SpeechResult, StreamSpeech } from "./types";
+import { SpeechToText } from "../types";
+declare const DeepgramClient: any;
+declare const ENGINE_NAME = "stt.deepgram";
+declare class Deepgram extends AbstractSpeechToText<typeof ENGINE_NAME> implements SpeechToText {
+    client: typeof DeepgramClient;
+    engineConfig: DeepgramSttConfig;
+    readonly engineName = "stt.deepgram";
+    constructor(config: DeepgramSttConfig);
+    streamTranscribe(stream: Stream): StreamSpeech;
+    transcribe(stream: Stream): Promise<SpeechResult>;
+    static getConfigValidationSchema(): z.Schema;
+    static getCredentialsValidationSchema(): z.Schema;
+}
+export { Deepgram, ENGINE_NAME };

package/dist/voice/stt/Deepgram.js

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENGINE_NAME = exports.Deepgram = void 0;
+/* eslint-disable @typescript-eslint/no-var-requires */
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const stream_1 = require("stream");
+const common_1 = require("@fonoster/common");
+const logger_1 = require("@fonoster/logger");
+const z = __importStar(require("zod"));
+const AbstractSpeechToText_1 = require("./AbstractSpeechToText");
+const types_1 = require("./types");
+const { DeepgramClient, LiveTranscriptionEvents, createClient } = require("@deepgram/sdk"); // Why Deepgram :(
+const ENGINE_NAME = "stt.deepgram";
+exports.ENGINE_NAME = ENGINE_NAME;
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+class Deepgram extends AbstractSpeechToText_1.AbstractSpeechToText {
+    constructor(config) {
+        super(config);
+        this.engineName = ENGINE_NAME;
+        this.client = createClient(config.credentials.apiKey);
+        this.engineConfig = config;
+    }
+    streamTranscribe(stream) {
+        const connection = this.client.listen.live(buildTranscribeConfig(this.engineConfig.config));
+        const out = new stream_1.Stream();
+        connection.on(LiveTranscriptionEvents.Open, () => {
+            // WARNING: This is a workaround to keep the connection open while the system
+            // is playing a file which causes the stream to be paused. We need to look into why
+            // the stream is being paused.
+            const keepAliveInterval = setInterval(() => {
+                const keepAliveMsg = JSON.stringify({ type: "KeepAlive" });
+                connection.send(keepAliveMsg);
+            }, 3000);
+            stream.on("data", (chunk) => {
+                connection.send(chunk);
+            });
+            connection.on(LiveTranscriptionEvents.Transcript, (data) => {
+                if (!data.channel.alternatives[0].transcript || !data.speech_final) {
+                    return;
+                }
+                out.emit("data", {
+                    speech: data.channel.alternatives[0].transcript
+                });
+            });
+            connection.on(LiveTranscriptionEvents.Error, (err) => {
+                logger.warn("error on Deepgram connection", { err });
+                clearInterval(keepAliveInterval);
+                connection.destroy();
+            });
+        });
+        return out;
+    }
+    transcribe(stream) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const connection = this.client.listen.live(buildTranscribeConfig(this.engineConfig.config));
+                stream.on("data", (chunk) => {
+                    connection.send(chunk);
+                });
+                connection.on(LiveTranscriptionEvents.Open, () => {
+                    connection.on(LiveTranscriptionEvents.Transcript, (data) => {
+                        if (data.channel.alternatives[0].transcript && data.speech_final) {
+                            const result = {
+                                speech: data.channel.alternatives[0].transcript,
+                                isFinal: true
+                            };
+                            resolve(result);
+                            connection.destroy();
+                        }
+                    });
+                    connection.on(LiveTranscriptionEvents.Error, (err) => {
+                        logger.warn("error on Deepgram connection", { err });
+                        reject(err);
+                    });
+                });
+                stream.on("end", () => {
+                    connection.destroy();
+                });
+                stream.on("error", (err) => {
+                    connection.destroy();
+                    reject(err);
+                });
+            });
+        });
+    }
+    static getConfigValidationSchema() {
+        return z.object({
+            languageCode: z.nativeEnum(common_1.VoiceLanguage).optional().nullable(),
+            model: z.nativeEnum(types_1.DeepgramModel).optional().nullable()
+        });
+    }
+    static getCredentialsValidationSchema() {
+        return z.object({
+            apiKey: z.string()
+        });
+    }
+}
+exports.Deepgram = Deepgram;
+function buildTranscribeConfig(config) {
+    return {
+        model: config.model || types_1.DeepgramModel.NOVA_2_PHONECALL,
+        encoding: "linear16",
+        sample_rate: 16000,
+        language: config.languageCode || common_1.VoiceLanguage.EN_US,
+        smart_format: true
+    };
+}

package/dist/voice/stt/Google.d.ts

@@ -2,16 +2,15 @@ import { Stream } from "stream";
 import { SpeechClient } from "@google-cloud/speech";
 import * as z from "zod";
 import { AbstractSpeechToText } from "./AbstractSpeechToText";
-import { GoogleSttConfig, SpeechResult, StreamSpeechResult } from "./types";
+import { GoogleSttConfig, SpeechResult, StreamSpeech } from "./types";
+import { SpeechToText } from "../types";
 declare const ENGINE_NAME = "stt.google";
-declare class Google extends AbstractSpeechToText<typeof ENGINE_NAME> {
+declare class Google extends AbstractSpeechToText<typeof ENGINE_NAME> implements SpeechToText {
     client: SpeechClient;
-    config: GoogleSttConfig;
+    engineConfig: GoogleSttConfig;
     readonly engineName = "stt.google";
-    protected readonly AUDIO_ENCODING = "LINEAR16";
-    protected readonly SAMPLE_RATE_HERTZ = 16000;
     constructor(config: GoogleSttConfig);
-    streamTranscribe(_: Stream): StreamSpeechResult;
+    streamTranscribe(_: Stream): StreamSpeech;
     transcribe(stream: Stream): Promise<SpeechResult>;
     static getConfigValidationSchema(): z.Schema;
     static getCredentialsValidationSchema(): z.Schema;

package/dist/voice/stt/Google.js

@@ -39,32 +39,32 @@ const z = __importStar(require("zod"));
 const AbstractSpeechToText_1 = require("./AbstractSpeechToText");
 const ENGINE_NAME = "stt.google";
 exports.ENGINE_NAME = ENGINE_NAME;
-const AUDIO_ENCODING = "LINEAR16";
-const SAMPLE_RATE_HERTZ = 16000;
 class Google extends AbstractSpeechToText_1.AbstractSpeechToText {
     constructor(config) {
         super(config);
         this.engineName = ENGINE_NAME;
-        this.AUDIO_ENCODING = AUDIO_ENCODING;
-        this.SAMPLE_RATE_HERTZ = SAMPLE_RATE_HERTZ;
         this.client = new speech_1.SpeechClient(config);
-        this.config = Object.assign(Object.assign({}, config), { config: {
-                encoding: AUDIO_ENCODING,
-                sampleRateHertz: SAMPLE_RATE_HERTZ,
-                interimResults: false,
-                languageCode: config.languageCode
-            } });
+        this.engineConfig = config;
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     streamTranscribe(_) {
         // Not implemented
-        return null;
+        throw new Error("Stream Transcribe not implemented for Google Engine");
     }
     transcribe(stream) {
         return __awaiter(this, void 0, void 0, function* () {
+            const languageCode = this.engineConfig.config.languageCode || common_1.VoiceLanguage.EN_US;
+            const audioConfig = {
+                interimResults: false,
+                config: {
+                    encoding: "LINEAR16",
+                    sampleRateHertz: 16000,
+                    languageCode
+                }
+            };
             return new Promise((resolve, reject) => {
                 const recognizeStream = this.client
-                    .streamingRecognize(this.config)
+                    .streamingRecognize(audioConfig)
                     .on("error", (e) => reject(e))
                     .on("data", (data) => {
                     var _a;
@@ -86,7 +86,7 @@ class Google extends AbstractSpeechToText_1.AbstractSpeechToText {
     }
     static getConfigValidationSchema() {
         return z.object({
-            languageCode: z.nativeEnum(common_1.VoiceLanguage)
+            languageCode: z.nativeEnum(common_1.VoiceLanguage).optional().nullable()
         });
     }
     static getCredentialsValidationSchema() {

package/dist/voice/stt/SpeechToTextFactory.js

@@ -20,6 +20,7 @@ exports.SpeechToTextFactory = void 0;
  * limitations under the License.
  */
 const logger_1 = require("@fonoster/logger");
+const Deepgram_1 = require("./Deepgram");
 const Google_1 = require("./Google");
 const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
 class SpeechToTextFactory {
@@ -39,3 +40,4 @@ exports.SpeechToTextFactory = SpeechToTextFactory;
 SpeechToTextFactory.engines = new Map();
 // Register engines
 SpeechToTextFactory.registerEngine(Google_1.ENGINE_NAME, Google_1.Google);
+SpeechToTextFactory.registerEngine(Deepgram_1.ENGINE_NAME, Deepgram_1.Deepgram);

package/dist/voice/stt/types.d.ts

@@ -1,20 +1,23 @@
 import { VoiceLanguage } from "@fonoster/common/src/tts/types";
-type SttConfig = {
-    languageCode: VoiceLanguage;
-};
+declare enum DeepgramModel {
+    NOVA_2 = "nova-2",
+    NOVA_2_PHONECALL = "nova-2-phonecall",
+    NOVA_2_CONVERSATIONALAI = "nova-2-conversationalai"
+}
 type SpeechResult = {
     speech: string;
     isFinal: boolean;
 };
-type StreamSpeechResult = {
+type StreamSpeech = {
     on(events: string, callback: (result: SpeechResult) => void): void;
-    close: () => void;
 };
-type GoogleSttConfig = SttConfig & {
+type SttConfig = {
+    config: {
+        languageCode: VoiceLanguage;
+    };
+};
+type GoogleSttConfig = {
     config: {
-        encoding: "LINEAR16";
-        sampleRateHertz: 16000;
-        interimResults: boolean;
         languageCode: VoiceLanguage;
     };
     credentials: {
@@ -22,4 +25,13 @@ type GoogleSttConfig = SttConfig & {
         private_key: string;
     };
 };
-export { SttConfig, SpeechResult, StreamSpeechResult, GoogleSttConfig };
+type DeepgramSttConfig = {
+    config: {
+        languageCode: VoiceLanguage;
+        model: DeepgramModel;
+    };
+    credentials: {
+        apiKey: string;
+    };
+};
+export { SpeechResult, StreamSpeech, SttConfig, GoogleSttConfig, DeepgramSttConfig, DeepgramModel };

package/dist/voice/stt/types.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepgramModel = void 0;
+var DeepgramModel;
+(function (DeepgramModel) {
+    DeepgramModel["NOVA_2"] = "nova-2";
+    DeepgramModel["NOVA_2_PHONECALL"] = "nova-2-phonecall";
+    DeepgramModel["NOVA_2_CONVERSATIONALAI"] = "nova-2-conversationalai";
+})(DeepgramModel || (exports.DeepgramModel = DeepgramModel = {}));

package/dist/voice/tts/Deepgram.d.ts

@@ -0,0 +1,25 @@
+import * as z from "zod";
+import { AbstractTextToSpeech } from "./AbstractTextToSpeech";
+import { SynthOptions, TtsConfig } from "./types";
+declare const DeepgramClient: any;
+declare const ENGINE_NAME = "tts.deepgram";
+type DeepgramTtsConfig = TtsConfig & {
+    [key: string]: Record<string, string>;
+    credentials: {
+        apiKey: string;
+    };
+};
+declare class Deepgram extends AbstractTextToSpeech<typeof ENGINE_NAME> {
+    client: typeof DeepgramClient;
+    engineConfig: DeepgramTtsConfig;
+    readonly engineName = "tts.deepgram";
+    protected readonly OUTPUT_FORMAT = "sln16";
+    protected readonly CACHING_FIELDS: string[];
+    protected readonly AUDIO_ENCODING: "linear16";
+    protected readonly SAMPLE_RATE_HERTZ = 16000;
+    constructor(config: DeepgramTtsConfig);
+    synthesize(text: string, options: SynthOptions): Promise<string>;
+    static getConfigValidationSchema(): z.Schema;
+    static getCredentialsValidationSchema(): z.Schema;
+}
+export { Deepgram, ENGINE_NAME };

package/dist/voice/tts/Deepgram.js

@@ -0,0 +1,122 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENGINE_NAME = exports.Deepgram = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const fs = __importStar(require("fs"));
+const util = __importStar(require("util"));
+const common_1 = require("@fonoster/common");
+const logger_1 = require("@fonoster/logger");
+const z = __importStar(require("zod"));
+const AbstractTextToSpeech_1 = require("./AbstractTextToSpeech");
+const isSsml_1 = require("./isSsml");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { DeepgramClient, createClient } = require("@deepgram/sdk");
+const ENGINE_NAME = "tts.deepgram";
+exports.ENGINE_NAME = ENGINE_NAME;
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+class Deepgram extends AbstractTextToSpeech_1.AbstractTextToSpeech {
+    constructor(config) {
+        super(config);
+        this.engineName = ENGINE_NAME;
+        this.OUTPUT_FORMAT = "sln16";
+        this.CACHING_FIELDS = ["voice"];
+        this.AUDIO_ENCODING = "linear16";
+        this.SAMPLE_RATE_HERTZ = 16000;
+        this.client = createClient(config.credentials.apiKey);
+        this.engineConfig = config;
+    }
+    synthesize(text, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.verbose(`synthesize [input: ${text}, isSsml=${(0, isSsml_1.isSsml)(text)} options: ${JSON.stringify(options)}]`);
+            const effectiveOptions = Object.assign(Object.assign({}, this.engineConfig), options);
+            const { voice } = this.engineConfig.config;
+            const filename = this.createFilename(text, effectiveOptions);
+            if (this.fileExists(this.getFullPathToFile(filename))) {
+                return this.getFilenameWithoutExtension(filename);
+            }
+            const response = yield this.client.speak.request({ text }, {
+                model: voice || common_1.DeepgramVoice.AURA_ASTERIA_EN,
+                encoding: this.AUDIO_ENCODING,
+                sample_rate: this.SAMPLE_RATE_HERTZ
+            });
+            const writeFile = util.promisify(fs.writeFile);
+            const audioBuffer = yield getAudioBuffer(yield response.getStream());
+            yield writeFile(this.getFullPathToFile(filename), audioBuffer, "binary");
+            return this.getFilenameWithoutExtension(filename);
+        });
+    }
+    static getConfigValidationSchema() {
+        return z.object({
+            voice: z.nativeEnum(common_1.DeepgramVoice)
+        });
+    }
+    static getCredentialsValidationSchema() {
+        return z.object({
+            apiKey: z.string()
+        });
+    }
+}
+exports.Deepgram = Deepgram;
+// helper function to convert stream to audio buffer
+const getAudioBuffer = (response) => __awaiter(void 0, void 0, void 0, function* () {
+    const reader = response.getReader();
+    const chunks = [];
+    // eslint-disable-next-line no-loops/no-loops, no-constant-condition
+    while (true) {
+        const { done, value } = yield reader.read();
+        if (done)
+            break;
+        chunks.push(value);
+    }
+    const dataArray = chunks.reduce((acc, chunk) => Uint8Array.from([...acc, ...chunk]), new Uint8Array(0));
+    return Buffer.from(dataArray.buffer);
+});

package/dist/voice/tts/Google.d.ts

@@ -12,11 +12,12 @@ type GoogleTtsConfig = TtsConfig & {
 };
 declare class Google extends AbstractTextToSpeech<typeof ENGINE_NAME> {
     client: TextToSpeechClient;
-    config: GoogleTtsConfig;
+    engineConfig: GoogleTtsConfig;
     readonly engineName = "tts.google";
     protected readonly OUTPUT_FORMAT = "sln16";
     protected readonly CACHING_FIELDS: string[];
     protected readonly AUDIO_ENCODING: "LINEAR16";
+    protected readonly SAMPLE_RATE_HERTZ = 16000;
     constructor(config: GoogleTtsConfig);
     synthesize(text: string, options: SynthOptions): Promise<string>;
     static getConfigValidationSchema(): z.Schema;

package/dist/voice/tts/Google.js

@@ -61,8 +61,6 @@ const AbstractTextToSpeech_1 = require("./AbstractTextToSpeech");
 const isSsml_1 = require("./isSsml");
 const ENGINE_NAME = "tts.google";
 exports.ENGINE_NAME = ENGINE_NAME;
-const AUDIO_ENCODING = "LINEAR16";
-const SAMPLE_RATE_HERTZ = 16000;
 const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
 class Google extends AbstractTextToSpeech_1.AbstractTextToSpeech {
     constructor(config) {
@@ -70,15 +68,16 @@ class Google extends AbstractTextToSpeech_1.AbstractTextToSpeech {
         this.engineName = ENGINE_NAME;
         this.OUTPUT_FORMAT = "sln16";
         this.CACHING_FIELDS = ["voice"];
-        this.AUDIO_ENCODING = AUDIO_ENCODING;
+        this.AUDIO_ENCODING = "LINEAR16";
+        this.SAMPLE_RATE_HERTZ = 16000;
         this.client = new text_to_speech_1.TextToSpeechClient(config);
-        this.config = config;
+        this.engineConfig = config;
     }
     synthesize(text, options) {
         return __awaiter(this, void 0, void 0, function* () {
             logger.verbose(`synthesize [input: ${text}, isSsml=${(0, isSsml_1.isSsml)(text)} options: ${JSON.stringify(options)}]`);
-            const effectiveOptions = Object.assign(Object.assign({}, this.config), options);
-            const { voice } = effectiveOptions;
+            const effectiveOptions = Object.assign(Object.assign({}, this.engineConfig), options);
+            const { voice } = this.engineConfig.config;
             const lang = `${voice.split("-")[0]}-${voice.split("-")[1]}`;
             const filename = this.createFilename(text, effectiveOptions);
             if (this.fileExists(this.getFullPathToFile(filename))) {
@@ -87,8 +86,8 @@ class Google extends AbstractTextToSpeech_1.AbstractTextToSpeech {
             const request = {
                 input: (0, isSsml_1.isSsml)(text) ? { ssml: text } : { text },
                 audioConfig: {
-                    audioEncoding: AUDIO_ENCODING,
-                    sampleRateHertz: SAMPLE_RATE_HERTZ
+                    audioEncoding: this.AUDIO_ENCODING,
+                    sampleRateHertz: this.SAMPLE_RATE_HERTZ
                 },
                 voice: {
                     languageCode: lang,

package/dist/voice/tts/TextToSpeechFactory.js

@@ -21,6 +21,7 @@ exports.TextToSpeechFactory = void 0;
  */
 const logger_1 = require("@fonoster/logger");
 const Azure_1 = require("./Azure");
+const Deepgram_1 = require("./Deepgram");
 const Google_1 = require("./Google");
 const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
 class TextToSpeechFactory {
@@ -41,3 +42,4 @@ TextToSpeechFactory.engines = new Map();
 // Register engines
 TextToSpeechFactory.registerEngine(Google_1.ENGINE_NAME, Google_1.Google);
 TextToSpeechFactory.registerEngine(Azure_1.ENGINE_NAME, Azure_1.Azure);
+TextToSpeechFactory.registerEngine(Deepgram_1.ENGINE_NAME, Deepgram_1.Deepgram);

package/dist/voice/types/ari.d.ts

@@ -16,6 +16,7 @@ declare enum ChannelVar {
     APP_REF = "APP_REF",
     APP_ENDPOINT = "APP_ENDPOINT",
     METADATA = "METADATA",
-    CURRENT_BRIDGE = "CURRENT_BRIDGE"
+    CURRENT_BRIDGE = "CURRENT_BRIDGE",
+    FROM_EXTERNAL_MEDIA = "FROM_EXTERNAL_MEDIA"
 }
 export { AriEvent, ChannelVar };

package/dist/voice/types/ari.js

@@ -40,4 +40,5 @@ var ChannelVar;
     ChannelVar["APP_ENDPOINT"] = "APP_ENDPOINT";
     ChannelVar["METADATA"] = "METADATA";
     ChannelVar["CURRENT_BRIDGE"] = "CURRENT_BRIDGE";
+    ChannelVar["FROM_EXTERNAL_MEDIA"] = "FROM_EXTERNAL_MEDIA";
 })(ChannelVar || (exports.ChannelVar = ChannelVar = {}));