speechstate 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/speechstate.js

@@ -12,21 +12,21 @@ const speechstate = (0, xstate_1.createMachine)({
     id: "speechstate",
     type: "parallel",
     states: {
-        asrTtsSpawner: {
-            initial: "idle",
+        AsrTtsSpawner: {
+            initial: "Idle",
             states: {
-                idle: { on: { PREPARE: "createAudioContext" } },
-                createAudioContext: {
+                Idle: { on: { PREPARE: "CreateAudioContext" } },
+                CreateAudioContext: {
                     invoke: {
                         id: "createAudioContext",
                         src: "audioContext",
                         onDone: {
-                            target: "spawn",
+                            target: "Spawn",
                             actions: (0, xstate_1.assign)({ audioContext: ({ event }) => event.output }),
                         },
                     },
                 },
-                spawn: {
+                Spawn: {
                     entry: [
                         (0, xstate_1.assign)({
                             ttsRef: ({ context, spawn }) => {
@@ -48,6 +48,8 @@ const speechstate = (0, xstate_1.createMachine)({
                                         locale: context.settings.locale,
                                         audioContext: context.audioContext,
                                         azureCredentials: context.settings.azureCredentials,
+                                        azureLanguageCredentials: context.settings.azureLanguageCredentials,
+                                        speechRecognitionEndpointId: context.settings.speechRecognitionEndpointId,
                                     },
                                 });
                             },
@@ -55,68 +57,68 @@ const speechstate = (0, xstate_1.createMachine)({
                     ],
                     after: {
                         300000: {
-                            target: "spawn",
+                            target: "Spawn",
                         },
                     },
                 },
             },
         },
-        asrTtsManager: {
-            initial: "initialize",
+        AsrTtsManager: {
+            initial: "Initialize",
             on: {
                 TTS_READY: {
                     actions: () => console.debug("[TTS→SpSt] TTS_READY"),
-                    target: ".preReady",
+                    target: ".PreReady",
                 },
                 ASR_READY: {
                     actions: () => console.debug("[ASR→SpSt] ASR_READY"),
-                    target: ".preReady",
+                    target: ".PreReady",
                 },
                 // ASR_ERROR not implemented
                 TTS_ERROR: {
                     actions: () => console.error("[TTS→SpSt] TTS_ERROR"),
-                    target: ".fail",
+                    target: ".Fail",
                 },
                 ASR_NOINPUT: {
                     actions: [
                         () => console.debug("[ASR→SpSt] NOINPUT"),
                         (0, xstate_1.sendParent)({ type: "ASR_NOINPUT" }),
                     ],
-                    target: ".ready",
+                    target: ".Ready",
                 },
             },
             states: {
-                initialize: {},
-                preReady: {
+                Initialize: {},
+                PreReady: {
                     on: {
                         TTS_READY: {
                             actions: () => console.debug("[TTS→SpSt] TTS_READY"),
-                            target: "ready",
+                            target: "Ready",
                         },
                         ASR_READY: {
                             actions: () => console.debug("[ASR→SpSt] ASR_READY"),
-                            target: "ready",
+                            target: "Ready",
                         },
                     },
                 },
-                ready: {
-                    initial: "idle",
+                Ready: {
+                    initial: "Idle",
                     entry: [
                         () => console.debug("[SpSt] All ready"),
                         (0, xstate_1.sendParent)({ type: "ASRTTS_READY" }),
                     ],
                     states: {
-                        idle: {
+                        Idle: {
                             on: {
-                                LISTEN: { target: "waitForRecogniser" },
+                                LISTEN: { target: "WaitForRecogniser" },
                                 SPEAK: [
                                     {
-                                        target: "speaking",
+                                        target: "Speaking",
                                     },
                                 ],
                             },
                         },
-                        speaking: {
+                        Speaking: {
                             entry: [
                                 ({ event }) => console.debug("[SpSt→TTS] SPEAK", event.value),
                                 ({ context, event }) => context.ttsRef.send({
@@ -148,7 +150,7 @@ const speechstate = (0, xstate_1.createMachine)({
                                     ],
                                 },
                                 SPEAK_COMPLETE: {
-                                    target: "idle",
+                                    target: "Idle",
                                     actions: [
                                         () => console.debug("[TTS→SpSt] SPEAK_COMPLETE"),
                                         (0, xstate_1.sendParent)({ type: "SPEAK_COMPLETE" }),
@@ -156,7 +158,7 @@ const speechstate = (0, xstate_1.createMachine)({
                                 },
                             },
                         },
-                        waitForRecogniser: {
+                        WaitForRecogniser: {
                             entry: [
                                 ({ event }) => console.debug("[SpSt→ASR] START", event.value),
                                 ({ context, event }) => context.asrRef.send({
@@ -166,7 +168,7 @@ const speechstate = (0, xstate_1.createMachine)({
                             ],
                             on: {
                                 ASR_STARTED: {
-                                    target: "recognising",
+                                    target: "Recognising",
                                     actions: [
                                         () => console.debug("[ASR→SpSt] ASR_STARTED"),
                                         (0, xstate_1.sendParent)({ type: "ASR_STARTED" }),
@@ -174,7 +176,7 @@ const speechstate = (0, xstate_1.createMachine)({
                                 },
                             },
                         },
-                        recognising: {
+                        Recognising: {
                             on: {
                                 CONTROL: {
                                     actions: [
@@ -184,21 +186,31 @@ const speechstate = (0, xstate_1.createMachine)({
                                         }),
                                     ],
                                 },
+                                STOP: {
+                                    target: "Idle",
+                                    actions: [
+                                        () => console.debug("[SpSt→ASR] STOP"),
+                                        ({ context }) => context.asrRef.send({
+                                            type: "STOP",
+                                        }),
+                                    ],
+                                },
                                 RECOGNISED: {
                                     actions: [
-                                        ({ event }) => console.debug("[ASR→SpSt] RECOGNISED", event.value),
+                                        ({ event }) => console.debug("[ASR→SpSt] RECOGNISED", event.value, event.nluValue),
                                         (0, xstate_1.sendParent)(({ event }) => ({
                                             type: "RECOGNISED",
                                             value: event.value,
+                                            nluValue: event.nluValue,
                                         })),
                                     ],
-                                    target: "idle",
+                                    target: "Idle",
                                 },
                             },
                         },
                     },
                 },
-                fail: {},
+                Fail: {},
             },
         },
     },

package/dist/tts.d.ts

@@ -1,10 +1,10 @@
-import { AzureCredentials, Agenda } from "./types";
+import { AzureSpeechCredentials, Agenda } from "./types";
 interface MySpeechSynthesisUtterance extends SpeechSynthesisUtterance {
     new (s: string): any;
 }
 interface TTSInit {
     audioContext: AudioContext;
-    azureCredentials: string | AzureCredentials;
+    azureCredentials: string | AzureSpeechCredentials;
     ttsDefaultVoice: string;
 }
 interface TTSContext extends TTSInit {
@@ -14,6 +14,8 @@ interface TTSContext extends TTSInit {
     wsaVoice?: SpeechSynthesisVoice;
     wsaUtt?: MySpeechSynthesisUtterance;
     agenda?: Agenda;
+    buffer?: string;
+    utteranceFromStream?: string;
 }
 type TTSEvent = {
     type: "PREPARE";
@@ -34,9 +36,79 @@ type TTSEvent = {
     value: Agenda;
 } | {
     type: "TTS_STARTED";
+} | {
+    type: "STREAMING_CHUNK";
+    value: string;
+} | {
+    type: "STREAMING_DONE";
 } | {
     type: "SPEAK_COMPLETE";
 };
-export declare const ttsMachine: import("xstate").StateMachine<TTSContext, TTSEvent, Record<string, import("xstate").AnyActorRef>, import("xstate").ProvidedActor, import("xstate").ParameterizedObject, import("xstate").ParameterizedObject, string, import("xstate").StateValue, string, TTSInit, {}, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, TTSEvent, import("xstate").ProvidedActor, import("xstate").ParameterizedObject, import("xstate").ParameterizedObject, string, string>>;
+export declare const ttsMachine: import("xstate").StateMachine<TTSContext, TTSEvent, {
+    [x: string]: import("xstate").ActorRef<import("xstate").CallbackSnapshot<{}>, import("xstate").EventObject> | import("xstate").ActorRef<import("xstate").PromiseSnapshot<string, any>, {
+        [k: string]: unknown;
+        type: string;
+    }> | import("xstate").ActorRef<import("xstate").CallbackSnapshot<Agenda>, import("xstate").EventObject>;
+}, {
+    src: "getToken";
+    logic: import("xstate").PromiseActorLogic<string, any>;
+    id: string;
+} | {
+    src: "createEventsFromStream";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, Agenda>;
+    id: string;
+} | {
+    src: "ponyfill";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {}>;
+    id: string;
+} | {
+    src: "start";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {}>;
+    id: string;
+}, {
+    type: "ttsStop";
+    params: unknown;
+} | {
+    type: "addFiller";
+    params: {};
+}, {
+    type: "bufferContainsUtterancePartReadyToBeSpoken";
+    params: unknown;
+}, "FILLER_DELAY", "GetToken" | "Fail" | "Ponyfill" | {
+    Ready?: "Idle" | {
+        BufferedSpeaker?: Required<{
+            Buffer?: "BufferIdle" | "Buffering" | "BufferingDone";
+            Speaker?: "SpeakingIdle" | "PrepareSpeech" | {
+                Speak?: "Go" | "Paused";
+            };
+        }>;
+        Speaking?: "Go" | "Paused";
+    };
+}, string, TTSInit, {}, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, TTSEvent, {
+    src: "getToken";
+    logic: import("xstate").PromiseActorLogic<string, any>;
+    id: string;
+} | {
+    src: "createEventsFromStream";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, Agenda>;
+    id: string;
+} | {
+    src: "ponyfill";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {}>;
+    id: string;
+} | {
+    src: "start";
+    logic: import("xstate").CallbackActorLogic<import("xstate").EventObject, {}>;
+    id: string;
+}, {
+    type: "ttsStop";
+    params: unknown;
+} | {
+    type: "addFiller";
+    params: {};
+}, {
+    type: "bufferContainsUtterancePartReadyToBeSpoken";
+    params: unknown;
+}, "FILLER_DELAY", string>>;
 export {};
 //# sourceMappingURL=tts.d.ts.map

package/dist/tts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tts.d.ts","sourceRoot":"","sources":["../src/tts.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEnD,UAAU,0BAA2B,SAAQ,wBAAwB;IACnE,KAAK,CAAC,EAAE,MAAM,OAAE;CACjB;AAED,UAAU,OAAO;IACf,YAAY,EAAE,YAAY,CAAC;IAC3B,gBAAgB,EAAE,MAAM,GAAG,gBAAgB,CAAC;IAC5C,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,UAAU,UAAW,SAAQ,OAAO;IAClC,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,MAAM,CAAC,EAAE,0BAA0B,CAAC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,KAAK,QAAQ,GACT;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IACE,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE;QACL,MAAM,EAAE,eAAe,CAAC;QACxB,MAAM,EAAE,0BAA0B,CAAC;KACpC,CAAC;CACH,GACD;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAE/B,eAAO,MAAM,UAAU,sdA+KtB,CAAC"}
+{"version":3,"file":"tts.d.ts","sourceRoot":"","sources":["../src/tts.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,sBAAsB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEzD,UAAU,0BAA2B,SAAQ,wBAAwB;IACnE,KAAK,CAAC,EAAE,MAAM,OAAE;CACjB;AAED,UAAU,OAAO;IACf,YAAY,EAAE,YAAY,CAAC;IAC3B,gBAAgB,EAAE,MAAM,GAAG,sBAAsB,CAAC;IAClD,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,UAAU,UAAW,SAAQ,OAAO;IAClC,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,MAAM,CAAC,EAAE,0BAA0B,CAAC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,KAAK,QAAQ,GACT;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IACE,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE;QACL,MAAM,EAAE,eAAe,CAAC;QACxB,MAAM,EAAE,0BAA0B,CAAC;KACpC,CAAC;CACH,GACD;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,GAC1B;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAI/B,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA4WrB,CAAC"}

package/dist/tts.js

@@ -5,13 +5,96 @@ const xstate_1 = require("xstate");
 const getToken_1 = require("./getToken");
 const TextToSpeech_1 = require("web-speech-cognitive-services/lib/SpeechServices/TextToSpeech");
 const REGION = "northeurope";
-exports.ttsMachine = (0, xstate_1.createMachine)({
-    id: "tts",
+const UTTERANCE_CHUNK_REGEX = /(^.*([!?]+|([.,]+\s)))/;
+exports.ttsMachine = (0, xstate_1.setup)({
     types: {},
+    actions: {
+        ttsStop: ({ context }) => {
+            context.wsaTTS.cancel();
+        },
+        addFiller: (0, xstate_1.assign)(({ context }) => {
+            const spaceIndex = context.buffer.lastIndexOf(" ");
+            return {
+                buffer: context.buffer.substring(0, spaceIndex) +
+                    " um," +
+                    context.buffer.substring(spaceIndex),
+            };
+        }),
+    },
+    actors: {
+        getToken: getToken_1.getToken,
+        createEventsFromStream: (0, xstate_1.fromCallback)(({ sendBack, input }) => {
+            const stream = new EventSource(input.stream);
+            stream.onmessage = function (event) {
+                console.log(JSON.parse(event.data));
+                sendBack(JSON.parse(event.data));
+            };
+        }),
+        ponyfill: (0, xstate_1.fromCallback)(({ sendBack, input }) => {
+            const ponyfill = (0, TextToSpeech_1.default)({
+                audioContext: input.audioContext,
+                credentials: {
+                    region: REGION, // TODO
+                    authorizationToken: input.azureAuthorizationToken,
+                },
+            });
+            const { speechSynthesis, SpeechSynthesisUtterance } = ponyfill;
+            const tts = speechSynthesis;
+            const ttsUtterance = SpeechSynthesisUtterance;
+            tts.addEventListener("voiceschanged", () => {
+                const voices = tts.getVoices();
+                if (voices.length > 0) {
+                    console.debug("[TTS] READY");
+                    sendBack({
+                        type: "READY",
+                        value: { wsaTTS: tts, wsaUtt: ttsUtterance },
+                    });
+                }
+                else {
+                    console.error("[TTS] No voices available");
+                    sendBack({ type: "ERROR" });
+                }
+            });
+        }),
+        start: (0, xstate_1.fromCallback)(({ sendBack, input }) => {
+            if (["", " "].includes(input.utterance)) {
+                console.debug("[TTS] SPEAK: ", input.utterance);
+                input.wsaTTS.speak("");
+            }
+            else {
+                console.debug("[TTS] SPEAK: ", input.utterance);
+                const content = wrapSSML(input.utterance, input.voice, input.ttsLexicon, 1); // todo speech rate;
+                const utterance = new input.wsaUtt(content);
+                utterance.addEventListener("start", () => {
+                    sendBack({ type: "TTS_STARTED" });
+                    console.debug("[TTS] TTS_STARTED");
+                });
+                utterance.addEventListener("end", () => {
+                    sendBack({ type: "SPEAK_COMPLETE" });
+                    console.debug("[TTS] SPEAK_COMPLETE");
+                });
+                input.wsaTTS.speak(utterance);
+            }
+        }),
+    },
+    guards: {
+        bufferContainsUtterancePartReadyToBeSpoken: ({ context }) => {
+            const m = context.buffer.match(UTTERANCE_CHUNK_REGEX);
+            return !!m;
+        },
+    },
+    delays: {
+        FILLER_DELAY: ({ context }) => {
+            return context.agenda.fillerDelay;
+        },
+    },
+}).createMachine({
+    id: "tts",
     context: ({ input }) => ({
         ttsDefaultVoice: input.ttsDefaultVoice || "en-US-DavisNeural",
         audioContext: input.audioContext,
         azureCredentials: input.azureCredentials,
+        buffer: "",
     }),
     initial: "GetToken",
     on: {
@@ -33,9 +116,164 @@ exports.ttsMachine = (0, xstate_1.createMachine)({
             states: {
                 Idle: {
                     on: {
-                        SPEAK: {
-                            target: "Speaking",
-                            actions: (0, xstate_1.assign)({ agenda: ({ event }) => event.value }),
+                        SPEAK: [
+                            {
+                                target: "BufferedSpeaker",
+                                guard: ({ event }) => !!event.value.stream,
+                                actions: (0, xstate_1.assign)({
+                                    agenda: ({ event }) => event.value.fillerDelay
+                                        ? event.value
+                                        : Object.assign(Object.assign({}, event.value), { fillerDelay: 500 }),
+                                }),
+                            },
+                            {
+                                target: "Speaking",
+                                actions: (0, xstate_1.assign)({ agenda: ({ event }) => event.value }),
+                            },
+                        ],
+                    },
+                },
+                BufferedSpeaker: {
+                    type: "parallel",
+                    invoke: {
+                        id: "createEventsFromStream",
+                        src: "createEventsFromStream",
+                        input: ({ context }) => context.agenda,
+                    },
+                    on: {
+                        STOP: {
+                            target: "Idle",
+                        },
+                        SPEAK_COMPLETE: [
+                            {
+                                guard: (0, xstate_1.stateIn)("#BufferingDone"),
+                                target: "Idle",
+                                actions: (0, xstate_1.sendParent)({ type: "SPEAK_COMPLETE" }),
+                            },
+                        ],
+                    },
+                    states: {
+                        Buffer: {
+                            initial: "BufferIdle",
+                            states: {
+                                BufferIdle: {
+                                    id: "BufferIdle",
+                                    on: {
+                                        STREAMING_CHUNK: {
+                                            target: "Buffering",
+                                        },
+                                    },
+                                },
+                                Buffering: {
+                                    id: "Buffering",
+                                    on: {
+                                        STREAMING_CHUNK: [
+                                            {
+                                                target: "Buffering",
+                                                reenter: true,
+                                            },
+                                        ],
+                                        STREAMING_DONE: [
+                                            {
+                                                target: "BufferingDone",
+                                            },
+                                        ],
+                                    },
+                                    entry: [
+                                        (0, xstate_1.assign)({
+                                            buffer: ({ context, event }) => context.buffer + event.value,
+                                        }),
+                                    ],
+                                },
+                                BufferingDone: {
+                                    id: "BufferingDone",
+                                },
+                            },
+                        },
+                        Speaker: {
+                            initial: "SpeakingIdle",
+                            states: {
+                                SpeakingIdle: {
+                                    always: [
+                                        {
+                                            target: "Speak",
+                                            guard: (0, xstate_1.stateIn)("#BufferingDone"),
+                                            actions: (0, xstate_1.assign)({
+                                                utteranceFromStream: ({ context }) => context.buffer,
+                                            }),
+                                        },
+                                        {
+                                            target: "PrepareSpeech",
+                                            guard: "bufferContainsUtterancePartReadyToBeSpoken",
+                                        },
+                                    ],
+                                    after: {
+                                        FILLER_DELAY: {
+                                            target: "SpeakingIdle",
+                                            reenter: true,
+                                            actions: "addFiller",
+                                            guard: ({ context }) => context.buffer.includes(" "),
+                                        },
+                                    },
+                                },
+                                PrepareSpeech: {
+                                    entry: [
+                                        (0, xstate_1.assign)(({ context }) => {
+                                            let utterancePart;
+                                            let restOfBuffer;
+                                            const match = context.buffer.match(UTTERANCE_CHUNK_REGEX);
+                                            utterancePart = match[0];
+                                            restOfBuffer = context.buffer.substring(utterancePart.length);
+                                            return {
+                                                buffer: restOfBuffer,
+                                                utteranceFromStream: utterancePart,
+                                            };
+                                        }),
+                                    ],
+                                    always: [
+                                        {
+                                            target: "Speak",
+                                        },
+                                    ],
+                                },
+                                Speak: {
+                                    initial: "Go",
+                                    on: {
+                                        TTS_STARTED: {
+                                            actions: (0, xstate_1.sendParent)({ type: "TTS_STARTED" }),
+                                        },
+                                        SPEAK_COMPLETE: [
+                                            {
+                                                guard: (0, xstate_1.stateIn)("#Buffering"),
+                                                target: "SpeakingIdle",
+                                            },
+                                        ],
+                                    },
+                                    states: {
+                                        Go: {
+                                            invoke: {
+                                                src: "start",
+                                                input: ({ context }) => ({
+                                                    wsaTTS: context.wsaTTS,
+                                                    wsaUtt: context.wsaUtt,
+                                                    ttsLexicon: context.ttsLexicon,
+                                                    voice: context.agenda.voice || context.ttsDefaultVoice,
+                                                    utterance: context.utteranceFromStream,
+                                                }),
+                                            },
+                                            on: {
+                                                CONTROL: "Paused",
+                                            },
+                                            exit: "ttsStop",
+                                        },
+                                        Paused: {
+                                            on: {
+                                                CONTROL: "Go",
+                                            },
+                                        },
+                                    },
+                                },
+                            },
                         },
                     },
                 },
@@ -113,61 +351,6 @@ exports.ttsMachine = (0, xstate_1.createMachine)({
             },
         },
     },
-}, {
-    actions: {
-        ttsStop: ({ context }) => {
-            context.wsaTTS.cancel();
-        },
-    },
-    actors: {
-        getToken: getToken_1.getToken,
-        ponyfill: (0, xstate_1.fromCallback)(({ sendBack, input }) => {
-            const ponyfill = (0, TextToSpeech_1.default)({
-                audioContext: input.audioContext,
-                credentials: {
-                    region: REGION,
-                    authorizationToken: input.azureAuthorizationToken,
-                },
-            });
-            const { speechSynthesis, SpeechSynthesisUtterance } = ponyfill;
-            const tts = speechSynthesis;
-            const ttsUtterance = SpeechSynthesisUtterance;
-            tts.addEventListener("voiceschanged", () => {
-                const voices = tts.getVoices();
-                if (voices.length > 0) {
-                    console.debug("[TTS] READY");
-                    sendBack({
-                        type: "READY",
-                        value: { wsaTTS: tts, wsaUtt: ttsUtterance },
-                    });
-                }
-                else {
-                    console.error("[TTS] No voices available");
-                    sendBack({ type: "ERROR" });
-                }
-            });
-        }),
-        start: (0, xstate_1.fromCallback)(({ sendBack, input }) => {
-            if (["", " "].includes(input.utterance)) {
-                console.debug("[TTS] SPEAK: ", input.utterance);
-                input.wsaTTS.speak("");
-            }
-            else {
-                console.debug("[TTS] SPEAK: ", input.utterance);
-                const content = wrapSSML(input.utterance, input.voice, input.ttsLexicon, 1); // todo speech rate;
-                const utterance = new input.wsaUtt(content);
-                utterance.addEventListener("start", () => {
-                    sendBack({ type: "TTS_STARTED" });
-                    console.debug("[TTS] TTS_STARTED");
-                });
-                utterance.addEventListener("end", () => {
-                    sendBack({ type: "SPEAK_COMPLETE" });
-                    console.debug("[TTS] SPEAK_COMPLETE");
-                });
-                input.wsaTTS.speak(utterance);
-            }
-        }),
-    },
 });
 const wrapSSML = (text, voice, lexicon, speechRate) => {
     let content = `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="http://www.w3.org/2001/mstts" xml:lang="en-US"><voice name="${voice}">`;

package/dist/types.d.ts

@@ -1,18 +1,32 @@
-export interface AzureCredentials {
+export interface AzureSpeechCredentials {
     endpoint: string;
     key: string;
 }
+/**
+ * @deprecated use `AzureSpeechCredentials` instead
+ */
+export interface AzureCredentials extends AzureSpeechCredentials {
+}
+export interface AzureLanguageCredentials {
+    endpoint: string;
+    key: string;
+    projectName: string;
+    deploymentName: string;
+}
 export interface Settings {
-    locale: string;
-    azureCredentials: string | AzureCredentials;
-    asrDefaultCompleteTimeout: number;
-    asrDefaultNoInputTimeout: number;
-    ttsDefaultVoice: string;
+    locale?: string;
+    azureCredentials: string | AzureCredentials | AzureSpeechCredentials;
+    azureLanguageCredentials?: AzureLanguageCredentials;
+    asrDefaultCompleteTimeout?: number;
+    asrDefaultNoInputTimeout?: number;
+    ttsDefaultVoice?: string;
+    speechRecognitionEndpointId?: string;
 }
 export interface Agenda {
     utterance: string;
     voice?: string;
-    stream?: ReadableStream<string>;
+    stream?: string;
+    fillerDelay?: number;
 }
 export interface Hypothesis {
     utterance: string;
@@ -23,5 +37,6 @@ export interface RecogniseParameters {
     completeTimeout?: number;
     locale?: string;
     hints?: string[];
+    nlu?: boolean | AzureLanguageCredentials;
 }
 //# sourceMappingURL=types.d.ts.map