@fonoster/apiserver 0.15.21 → 0.16.0

package/dist/applications/createGetFnUtil.d.ts

@@ -5,22 +5,22 @@ declare function createGetFnUtil(prisma: Prisma): (ref: string) => Promise<{
     };
     textToSpeech: {
         ref: string;
-        credentials: string | null;
         config: import("@prisma/client/runtime/library").JsonValue;
+        credentials: string | null;
         productRef: string;
         applicationRef: string;
     };
     speechToText: {
         ref: string;
-        credentials: string | null;
         config: import("@prisma/client/runtime/library").JsonValue;
+        credentials: string | null;
         productRef: string;
         applicationRef: string;
     };
     intelligence: {
         ref: string;
-        credentials: string | null;
         config: import("@prisma/client/runtime/library").JsonValue;
+        credentials: string | null;
         productRef: string;
         applicationRef: string;
     };

package/dist/core/httpBridge.js

@@ -38,36 +38,10 @@ const logger_1 = require("@fonoster/logger");
 const express_1 = __importDefault(require("express"));
 const envs_1 = require("../envs");
 const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
-const CONTENT_TYPE = "audio/L16;rate=16000;channels=1";
 function httpBridge(identityConfig, params) {
     const { port } = params;
     const app = (0, express_1.default)();
     const streamMap = new Map();
-    app.get("/api/sounds/:id", (req, res) => {
-        const idWithoutExtension = req.params.id.split(".")[0];
-        const stream = streamMap.get(idWithoutExtension);
-        if (!stream) {
-            res.status(404).send(`Stream not found for id: ${req.params.id}`);
-            return;
-        }
-        res.setHeader("content-type", CONTENT_TYPE);
-        stream.on("error", (error) => {
-            logger.error(`error reading file: ${error.message}`);
-            if (!res.headersSent) {
-                res.status(500).send("Error reading file!");
-            }
-            else {
-                res.end();
-            }
-        });
-        stream.on("end", () => {
-            res.end();
-        });
-        stream.on("close", () => {
-            res.end();
-        });
-        stream.pipe(res);
-    });
     app.get("/api/identity/accept-invite", (req, res) => __awaiter(this, void 0, void 0, function* () {
         try {
             yield (0, identity_1.createUpdateMembershipStatus)(identityConfig)(req.query.token);

package/dist/voice/VoiceDispatcher.js

@@ -78,6 +78,7 @@ class VoiceDispatcher {
                 vc.on(common_1.StreamContent.SAY_REQUEST, (0, handlers_1.createSayHandler)(ari, vc).bind(this));
                 vc.on(common_1.StreamContent.GATHER_REQUEST, (0, handlers_1.createGatherHandler)(vc).bind(this));
                 vc.on(common_1.StreamContent.DIAL_REQUEST, (0, handlers_1.createDialHandler)(ari, vc).bind(this));
+                vc.on(common_1.StreamContent.STOP_SAY_REQUEST, (0, handlers_1.createStopSayHandler)(vc).bind(this));
                 vc.on(common_1.StreamContent.PLAYBACK_CONTROL_REQUEST, (0, handlers_1.createPlaybackControlHandler)(ari, vc).bind(this));
                 vc.on(common_1.StreamContent.START_STREAM_GATHER_REQUEST, (0, handlers_1.createStreamGatherHandler)(vc).bind(this));
                 vc.on(common_1.StreamContent.STOP_STREAM_GATHER_REQUEST, () => {

package/dist/voice/client/AudioSocketHandler.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Copyright (C) 2025 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.
+ */
+import { Stream } from "stream";
+import { VoiceClientConfig } from "@fonoster/common";
+import { AudioStream } from "@fonoster/streams";
+declare class AudioSocketHandler {
+    private audioSocket;
+    private audioStream;
+    private transcriptionsStream;
+    private config;
+    constructor(params: {
+        transcriptionsStream: Stream;
+        config: VoiceClientConfig;
+    });
+    setupAudioSocket(port: number): Promise<void>;
+    getAudioStream(): AudioStream;
+    close(): void;
+}
+export { AudioSocketHandler };

package/dist/voice/client/AudioSocketHandler.js

@@ -0,0 +1,68 @@
+"use strict";
+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.AudioSocketHandler = void 0;
+const logger_1 = require("@fonoster/logger");
+const streams_1 = require("@fonoster/streams");
+const transcribeOnConnection_1 = require("../transcribeOnConnection");
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+class AudioSocketHandler {
+    constructor(params) {
+        this.transcriptionsStream = params.transcriptionsStream;
+        this.config = params.config;
+    }
+    setupAudioSocket(port) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                logger.verbose("creating audio socket", { port });
+                this.audioSocket = new streams_1.AudioSocket();
+                this.audioSocket.onConnection((req, res) => __awaiter(this, void 0, void 0, function* () {
+                    logger.verbose("audio socket connection received", {
+                        ref: req.ref,
+                        sessionRef: this.config.sessionRef
+                    });
+                    (0, transcribeOnConnection_1.transcribeOnConnection)(this.transcriptionsStream)(req, res);
+                    res.onClose(() => {
+                        logger.verbose("session audio stream closed", {
+                            sessionRef: this.config.sessionRef
+                        });
+                    });
+                    res.onError((err) => {
+                        logger.error("session audio stream error", {
+                            error: err,
+                            sessionRef: this.config.sessionRef
+                        });
+                    });
+                    this.audioStream = res;
+                    resolve();
+                }));
+                this.audioSocket.listen(port, () => {
+                    logger.verbose("audio socket listening", {
+                        port,
+                        appRef: this.config.appRef
+                    });
+                });
+            });
+        });
+    }
+    getAudioStream() {
+        return this.audioStream;
+    }
+    close() {
+        try {
+            this.audioSocket.close();
+        }
+        catch (e) {
+            // Ignore errors on close
+        }
+    }
+}
+exports.AudioSocketHandler = AudioSocketHandler;

package/dist/voice/client/AuthorizationHandler.d.ts

@@ -0,0 +1,13 @@
+import { VoiceClientConfig } from "@fonoster/common";
+import { Client } from "ari-client";
+declare class AuthorizationHandler {
+    private config;
+    private ari;
+    constructor(params: {
+        config: VoiceClientConfig;
+        ari: Client;
+    });
+    checkAuthorization(): Promise<boolean>;
+    private handleUnauthorizedSession;
+}
+export { AuthorizationHandler };

package/dist/voice/client/AuthorizationHandler.js

@@ -0,0 +1,78 @@
+"use strict";
+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.AuthorizationHandler = void 0;
+/**
+ * Copyright (C) 2025 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 authz_1 = require("@fonoster/authz");
+const logger_1 = require("@fonoster/logger");
+const envs_1 = require("../../envs");
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+class AuthorizationHandler {
+    constructor(params) {
+        this.config = params.config;
+        this.ari = params.ari;
+    }
+    checkAuthorization() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!envs_1.AUTHZ_SERVICE_ENABLED) {
+                return true;
+            }
+            const { sessionRef: channelId, accessKeyId } = this.config;
+            try {
+                const authz = new authz_1.AuthzClient(`${envs_1.AUTHZ_SERVICE_HOST}:${envs_1.AUTHZ_SERVICE_PORT}`);
+                const authorized = yield authz.checkSessionAuthorized({ accessKeyId });
+                if (!authorized) {
+                    logger.verbose("rejected unauthorized session", { channelId });
+                    yield this.handleUnauthorizedSession();
+                    return false;
+                }
+                return true;
+            }
+            catch (e) {
+                logger.error("authz service error", e);
+                yield this.handleUnauthorizedSession();
+                return false;
+            }
+        });
+    }
+    handleUnauthorizedSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { sessionRef: channelId } = this.config;
+            try {
+                yield this.ari.channels.answer({ channelId });
+                yield this.ari.channels.play({ channelId, media: "sound:unavailable" });
+                yield new Promise((resolve) => setTimeout(resolve, 2000));
+                yield this.ari.channels.hangup({ channelId });
+            }
+            catch (e) {
+                logger.error("error handling unauthorized session", e);
+            }
+        });
+    }
+}
+exports.AuthorizationHandler = AuthorizationHandler;

package/dist/voice/client/ExternalMediaHandler.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Copyright (C) 2025 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.
+ */
+import { VoiceClientConfig } from "@fonoster/common";
+import { Bridge, Client } from "ari-client";
+declare class ExternalMediaHandler {
+    private ari;
+    private bridge;
+    private config;
+    constructor(params: {
+        ari: Client;
+        config: VoiceClientConfig;
+    });
+    setupExternalMedia(port: number): Promise<void>;
+    getBridge(): Bridge;
+}
+export { ExternalMediaHandler };

package/dist/voice/client/ExternalMediaHandler.js

@@ -0,0 +1,59 @@
+"use strict";
+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.ExternalMediaHandler = void 0;
+const logger_1 = require("@fonoster/logger");
+const types_1 = require("../types");
+const createExternalMediaConfig_1 = require("../utils/createExternalMediaConfig");
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+class ExternalMediaHandler {
+    constructor(params) {
+        this.ari = params.ari;
+        this.config = params.config;
+    }
+    setupExternalMedia(port) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bridge = this.ari.Bridge();
+            const channel = this.ari.Channel();
+            yield bridge.create({ type: "mixing" });
+            logger.verbose("creating external media config", {
+                port,
+                sessionRef: this.config.sessionRef,
+                bridgeId: bridge.id
+            });
+            channel.externalMedia((0, createExternalMediaConfig_1.createExternalMediaConfig)(port));
+            channel.once(types_1.AriEvent.STASIS_START, (_, channel) => __awaiter(this, void 0, void 0, function* () {
+                bridge.addChannel({ channel: [this.config.sessionRef, channel.id] });
+                logger.verbose("added channel to bridge", {
+                    sessionRef: this.config.sessionRef,
+                    channelId: channel.id
+                });
+            }));
+            channel.once("ChannelLeftBridge", () => __awaiter(this, void 0, void 0, function* () {
+                logger.verbose("channel left bridge", {
+                    sessionRef: this.config.sessionRef,
+                    bridgeId: bridge.id
+                });
+                try {
+                    yield bridge.destroy();
+                }
+                catch (e) {
+                    // We can only try
+                }
+            }));
+            this.bridge = bridge;
+        });
+    }
+    getBridge() {
+        return this.bridge;
+    }
+}
+exports.ExternalMediaHandler = ExternalMediaHandler;

package/dist/voice/client/GrpcClientHandler.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Copyright (C) 2025 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.
+ */
+import { Stream } from "stream";
+import { VoiceClientConfig, VoiceIn, VoiceSessionStreamClient } from "@fonoster/common";
+declare class GrpcClientHandler {
+    private config;
+    private verbsStream;
+    private grpcClient;
+    private voice;
+    constructor(params: {
+        config: VoiceClientConfig;
+        verbsStream: Stream;
+    });
+    setupGrpcClient(): Promise<void>;
+    private setupEventHandlers;
+    getVoiceStream(): VoiceSessionStreamClient;
+    sendResponse(response: VoiceIn): void;
+    close(): void;
+}
+export { GrpcClientHandler };

package/dist/voice/client/GrpcClientHandler.js

@@ -0,0 +1,101 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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.GrpcClientHandler = void 0;
+const common_1 = require("@fonoster/common");
+const logger_1 = require("@fonoster/logger");
+const grpc = __importStar(require("@grpc/grpc-js"));
+const VoiceServiceClientConstructor_1 = require("../utils/VoiceServiceClientConstructor");
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+class GrpcClientHandler {
+    constructor(params) {
+        this.config = params.config;
+        this.verbsStream = params.verbsStream;
+    }
+    setupGrpcClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.grpcClient = new VoiceServiceClientConstructor_1.VoiceServiceClientConstructor(this.config.endpoint, grpc.credentials.createInsecure());
+            const metadata = new grpc.Metadata();
+            metadata.add("accessKeyId", this.config.accessKeyId);
+            metadata.add("token", this.config.sessionToken);
+            this.voice = this.grpcClient.createSession(metadata);
+            this.setupEventHandlers();
+            // Initialize the session
+            this.voice.write({ request: this.config });
+        });
+    }
+    setupEventHandlers() {
+        this.voice.on(common_1.StreamEvent.DATA, (data) => {
+            this.verbsStream.emit(data.content, data);
+        });
+        this.voice.on(common_1.StreamEvent.ERROR, (error) => {
+            if (error.code === grpc.status.UNAVAILABLE) {
+                logger.error(`voice server not available at "${this.config.endpoint}"`);
+                return;
+            }
+            logger.error(`grpc stream error: ${error.message}`);
+        });
+    }
+    getVoiceStream() {
+        return this.voice;
+    }
+    sendResponse(response) {
+        try {
+            this.voice.write(response);
+        }
+        catch (error) {
+            logger.error(`error sending response: ${error.message}`);
+        }
+    }
+    close() {
+        try {
+            this.voice.end();
+            this.grpcClient.close();
+        }
+        catch (e) {
+            // Ignore errors on close
+        }
+    }
+}
+exports.GrpcClientHandler = GrpcClientHandler;

package/dist/voice/client/SpeechHandler.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Copyright (C) 2025 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.
+ */
+import { Stream } from "stream";
+import { SayOptions } from "@fonoster/common";
+import { AudioStream } from "@fonoster/streams";
+import { Client } from "ari-client";
+import { SpeechResult } from "../stt/types";
+import { SpeechToText, TextToSpeech } from "../types";
+declare class SpeechHandler {
+    private tts;
+    private stt;
+    private ari;
+    private transcriptionsStream;
+    private audioStream;
+    private sessionRef;
+    constructor(params: {
+        tts: TextToSpeech;
+        stt: SpeechToText;
+        ari: Client;
+        transcriptionsStream: Stream;
+        audioStream: AudioStream;
+        sessionRef: string;
+    });
+    synthesize(text: string, options: SayOptions): Promise<string>;
+    stopSynthesis(): Promise<void>;
+    transcribe(): Promise<SpeechResult>;
+    startSpeechGather(callback: (stream: {
+        speech: string;
+        responseTime: number;
+    }) => void): void;
+    startDtmfGather(callback: (event: {
+        digit: string;
+    }) => void): Promise<void>;
+    waitForDtmf(params: {
+        finishOnKey: string;
+        maxDigits: number;
+        timeout: number;
+        onDigitReceived: () => void;
+    }): Promise<{
+        digits: string;
+    }>;
+    stopStreamGather(): void;
+}
+export { SpeechHandler };

package/dist/voice/client/SpeechHandler.js

@@ -0,0 +1,116 @@
+"use strict";
+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.SpeechHandler = void 0;
+const logger_1 = require("@fonoster/logger");
+const types_1 = require("../types");
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+class SpeechHandler {
+    constructor(params) {
+        this.tts = params.tts;
+        this.stt = params.stt;
+        this.ari = params.ari;
+        this.transcriptionsStream = params.transcriptionsStream;
+        this.audioStream = params.audioStream;
+        this.sessionRef = params.sessionRef;
+    }
+    synthesize(text, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { ref, stream } = this.tts.synthesize(text, options);
+            logger.verbose("starting audio synthesis", { ref });
+            try {
+                // Stop any active stream
+                this.audioStream.stop();
+                yield this.audioStream.playStream(stream);
+            }
+            catch (error) {
+                logger.error(`stream error for ref ${ref}: ${error.message}`, {
+                    errorDetails: error.stack || "No stack trace"
+                });
+            }
+            return ref;
+        });
+    }
+    stopSynthesis() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.audioStream.stop();
+        });
+    }
+    transcribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.stt.transcribe(this.transcriptionsStream);
+            }
+            catch (e) {
+                logger.warn("transcription error", e);
+                return {};
+            }
+        });
+    }
+    startSpeechGather(callback) {
+        const out = this.stt.streamTranscribe(this.transcriptionsStream);
+        out.on("data", callback);
+        out.on("error", (error) => __awaiter(this, void 0, void 0, function* () {
+            logger.error("speech recognition error", { error });
+            yield this.ari.channels.hangup({ channelId: this.sessionRef });
+        }));
+    }
+    startDtmfGather(callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const channel = yield this.ari.channels.get({ channelId: this.sessionRef });
+            channel.on(types_1.AriEvent.CHANNEL_DTMF_RECEIVED, (event) => {
+                const { digit } = event;
+                callback({ digit });
+            });
+        });
+    }
+    // Returns a promise that resolves when DTMF collection is complete
+    waitForDtmf(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { onDigitReceived, finishOnKey, maxDigits, timeout } = params;
+            let result = "";
+            let timeoutId = null;
+            const channel = yield this.ari.channels.get({ channelId: this.sessionRef });
+            return new Promise((resolve) => {
+                const resetTimer = () => {
+                    if (timeoutId) {
+                        clearTimeout(timeoutId);
+                    }
+                    timeoutId = setTimeout(() => {
+                        channel.removeListener(types_1.AriEvent.CHANNEL_DTMF_RECEIVED, dtmfListener);
+                        resolve({ digits: result });
+                    }, timeout);
+                };
+                const dtmfListener = (event) => {
+                    const { digit } = event;
+                    // Stops the global timeout
+                    onDigitReceived();
+                    resetTimer();
+                    if (digit !== finishOnKey) {
+                        result += digit;
+                    }
+                    if (result.length >= maxDigits || digit === finishOnKey) {
+                        clearTimeout(timeoutId);
+                        channel.removeListener(types_1.AriEvent.CHANNEL_DTMF_RECEIVED, dtmfListener);
+                        resolve({ digits: result });
+                    }
+                };
+                channel.on(types_1.AriEvent.CHANNEL_DTMF_RECEIVED, dtmfListener);
+                resetTimer(); // Start the initial timeout
+            });
+        });
+    }
+    // Placeholder for future implementation
+    stopStreamGather() {
+        throw new Error("Method 'stopStreamGather' not implemented.");
+    }
+}
+exports.SpeechHandler = SpeechHandler;