speechflow 1.6.2 → 1.6.4

package/speechflow-cli/src/speechflow-node-a2a-meter.ts

@@ -33,12 +33,16 @@ export default class SpeechFlowNodeA2AMeter extends SpeechFlowNode {
         /*  declare node configuration parameters  */
         this.configure({
             interval:  { type: "number", pos: 0, val: 250 },
+            mode:      { type: "string", pos: 1, val: "filter", match: /^(?:filter|sink)$/ },
             dashboard: { type: "string",         val: "" }
         })
 
         /*  declare node input/output format  */
         this.input  = "audio"
-        this.output = "audio"
+        if (this.params.mode === "filter")
+            this.output = "audio"
+        else if (this.params.mode === "sink")
+            this.output = "none"
     }
 
     /*  open node  */
@@ -53,7 +57,7 @@ export default class SpeechFlowNodeA2AMeter extends SpeechFlowNode {
         /*  internal state  */
         const sampleWindowDuration = 3 /* LUFS-S requires 3s */
         const sampleWindowSize = Math.floor(this.config.audioSampleRate * sampleWindowDuration)
-        let sampleWindow = new Float32Array(sampleWindowSize)
+        const sampleWindow = new Float32Array(sampleWindowSize)
         sampleWindow.fill(0, 0, sampleWindowSize)
         let lufss = -60
         let rms   = -60
@@ -66,10 +70,8 @@ export default class SpeechFlowNodeA2AMeter extends SpeechFlowNode {
         /*  define chunk processing function  */
         const processChunk = (chunkData: Float32Array) => {
             /*  update internal audio sample sliding window  */
-            const newWindow = new Float32Array(sampleWindowSize)
-            newWindow.set(sampleWindow.slice(chunkData.length), 0)
-            newWindow.set(chunkData, sampleWindowSize - chunkData.length)
-            sampleWindow = newWindow
+            sampleWindow.set(sampleWindow.subarray(chunkData.length), 0)
+            sampleWindow.set(chunkData, sampleWindowSize - chunkData.length)
 
             /*  calculate the LUFS-S and RMS metric  */
             const audioData = {
@@ -151,7 +153,8 @@ export default class SpeechFlowNodeA2AMeter extends SpeechFlowNode {
                         self.chunkBuffer = newBuffer
 
                         /*  pass-through original audio chunk  */
-                        this.push(chunk)
+                        if (self.params.mode === "filter")
+                            this.push(chunk)
                         callback()
                     }
                     catch (error) {
@@ -160,7 +163,7 @@ export default class SpeechFlowNodeA2AMeter extends SpeechFlowNode {
                 }
             },
             final (callback) {
-                if (self.destroyed) {
+                if (self.destroyed || self.params.mode === "sink") {
                     callback()
                     return
                 }

package/speechflow-cli/src/speechflow-node-a2t-deepgram.ts

@@ -123,7 +123,10 @@ export default class SpeechFlowNodeA2TDeepgram extends SpeechFlowNode {
             if (text === "")
                 this.log("info", `empty/dummy text received (start: ${data.start}s, duration: ${data.duration.toFixed(2)}s)`)
             else {
-                this.log("info", `text received (start: ${data.start}s, duration: ${data.duration.toFixed(2)}s): "${text}"`)
+                this.log("info", `text received (start: ${data.start}s, ` +
+                    `duration: ${data.duration.toFixed(2)}s, ` +
+                    `kind: ${isFinal ? "final" : "intermediate"}): ` +
+                    `${text}"`)
                 const start = Duration.fromMillis(data.start * 1000).plus(this.timeZeroOffset)
                 const end   = start.plus({ seconds: data.duration })
                 const metas = metastore.fetch(start, end)

package/speechflow-cli/src/speechflow-node-x2x-trace.ts

@@ -18,6 +18,9 @@ export default class SpeechFlowNodeX2XTrace extends SpeechFlowNode {
     /*  declare official node name  */
     public static name = "x2x-trace"
 
+    /*  internal state  */
+    private destroyed = false
+
     /*  construct node  */
     constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
         super(id, cfg, opts, args)
@@ -26,6 +29,7 @@ export default class SpeechFlowNodeX2XTrace extends SpeechFlowNode {
         this.configure({
             type:      { type: "string", pos: 0, val: "audio", match: /^(?:audio|text)$/ },
             name:      { type: "string", pos: 1, val: "trace" },
+            mode:      { type: "string", pos: 2, val: "filter", match: /^(?:filter|sink)$/ },
             dashboard: { type: "string",         val: "" }
         })
 
@@ -35,7 +39,10 @@ export default class SpeechFlowNodeX2XTrace extends SpeechFlowNode {
 
         /*  declare node input/output format  */
         this.input  = this.params.type
-        this.output = this.params.type
+        if (this.params.mode === "filter")
+            this.output = this.params.type
+        else if (this.params.mode === "sink")
+            this.output = "none"
     }
 
     /*  open node  */
@@ -48,6 +55,9 @@ export default class SpeechFlowNodeX2XTrace extends SpeechFlowNode {
                 this.log(level, msg)
         }
 
+        /*  clear destruction flag  */
+        this.destroyed = false
+
         /*  helper functions for formatting  */
         const fmtTime = (t: Duration) => t.toFormat("hh:mm:ss.SSS")
         const fmtMeta = (meta: Map<string, any>) => {
@@ -74,6 +84,10 @@ export default class SpeechFlowNodeX2XTrace extends SpeechFlowNode {
             highWaterMark:      1,
             transform (chunk: SpeechFlowChunk, encoding, callback) {
                 let error: Error | undefined
+                if (self.destroyed) {
+                    callback(new Error("stream already destroyed"))
+                    return
+                }
                 if (Buffer.isBuffer(chunk.payload)) {
                     if (self.params.type === "audio")
                         log("debug", fmtChunkBase(chunk) +
@@ -94,7 +108,9 @@ export default class SpeechFlowNodeX2XTrace extends SpeechFlowNode {
                     else
                         error = new Error(`${self.params.type} chunk: seen String instead of Buffer chunk type`)
                 }
-                if (error !== undefined)
+                if (self.params.mode === "sink")
+                    callback()
+                else if (error !== undefined)
                     callback(error)
                 else {
                     this.push(chunk, encoding)
@@ -102,6 +118,10 @@ export default class SpeechFlowNodeX2XTrace extends SpeechFlowNode {
                 }
             },
             final (callback) {
+                if (self.destroyed || self.params.mode === "sink") {
+                    callback()
+                    return
+                }
                 this.push(null)
                 callback()
             }
@@ -115,5 +135,8 @@ export default class SpeechFlowNodeX2XTrace extends SpeechFlowNode {
             this.stream.destroy()
             this.stream = null
         }
+
+        /*  indicate destruction  */
+        this.destroyed = true
     }
 }

package/speechflow-cli/src/speechflow-node-xio-device.ts

@@ -83,6 +83,84 @@ export default class SpeechFlowNodeXIODevice extends SpeechFlowNode {
         return device
     }
 
+    /*  NOTICE: "naudion" actually implements Stream.{Readable,Writable,Duplex}, but
+        declares just its sub-interface NodeJS.{Readable,Writable,Duplex}Stream,
+        so it is correct to cast it back to Stream.{Readable,Writable,Duplex}
+        in the following device stream setup functions!  */
+
+    /*  INTERNAL: setup duplex stream  */
+    private setupDuplexStream (device: PortAudio.DeviceInfo, highwaterMark: number) {
+        if (device.maxInputChannels === 0)
+            throw new Error(`device "${device.id}" does not have any input channels (required by read/write mode)`)
+        if (device.maxOutputChannels === 0)
+            throw new Error(`device "${device.id}" does not have any output channels (required by read/write mode)`)
+        this.log("info", `resolved "${this.params.device}" to duplex device "${device.id}"`)
+        this.io = PortAudio.AudioIO({
+            inOptions: {
+                deviceId:     device.id,
+                channelCount: this.config.audioChannels,
+                sampleRate:   this.config.audioSampleRate,
+                sampleFormat: this.config.audioBitDepth,
+                highwaterMark
+            },
+            outOptions: {
+                deviceId:     device.id,
+                channelCount: this.config.audioChannels,
+                sampleRate:   this.config.audioSampleRate,
+                sampleFormat: this.config.audioBitDepth,
+                highwaterMark
+            }
+        })
+        this.stream = this.io as unknown as Stream.Duplex
+
+        /*  convert regular stream into object-mode stream  */
+        const wrapper1 = util.createTransformStreamForWritableSide()
+        const wrapper2 = util.createTransformStreamForReadableSide("audio", () => this.timeZero)
+        this.stream = Stream.compose(wrapper1, this.stream, wrapper2)
+    }
+
+    /*  INTERNAL: setup input stream  */
+    private setupInputStream (device: PortAudio.DeviceInfo, highwaterMark: number) {
+        if (device.maxInputChannels === 0)
+            throw new Error(`device "${device.id}" does not have any input channels (required by read mode)`)
+        this.log("info", `resolved "${this.params.device}" to input device "${device.id}"`)
+        this.io = PortAudio.AudioIO({
+            inOptions: {
+                deviceId:      device.id,
+                channelCount:  this.config.audioChannels,
+                sampleRate:    this.config.audioSampleRate,
+                sampleFormat:  this.config.audioBitDepth,
+                highwaterMark
+            }
+        })
+        this.stream = this.io as unknown as Stream.Readable
+
+        /*  convert regular stream into object-mode stream  */
+        const wrapper = util.createTransformStreamForReadableSide("audio", () => this.timeZero)
+        this.stream = Stream.compose(this.stream, wrapper)
+    }
+
+    /*  INTERNAL: setup output stream  */
+    private setupOutputStream (device: PortAudio.DeviceInfo, highwaterMark: number) {
+        if (device.maxOutputChannels === 0)
+            throw new Error(`device "${device.id}" does not have any output channels (required by write mode)`)
+        this.log("info", `resolved "${this.params.device}" to output device "${device.id}"`)
+        this.io = PortAudio.AudioIO({
+            outOptions: {
+                deviceId:     device.id,
+                channelCount: this.config.audioChannels,
+                sampleRate:   this.config.audioSampleRate,
+                sampleFormat: this.config.audioBitDepth,
+                highwaterMark
+            }
+        })
+        this.stream = this.io as unknown as Stream.Writable
+
+        /*  convert regular stream into object-mode stream  */
+        const wrapper = util.createTransformStreamForWritableSide()
+        this.stream = Stream.compose(wrapper, this.stream)
+    }
+
     /*  open node  */
     async open () {
         if (this.params.device === "")
@@ -104,107 +182,48 @@ export default class SpeechFlowNodeXIODevice extends SpeechFlowNode {
             (this.config.audioBitDepth / 8)
         ) / (1000 / this.params.chunk)
 
-        /*  establish device connection
-            Notice: "naudion" actually implements Stream.{Readable,Writable,Duplex}, but
-            declares just its sub-interface NodeJS.{Readable,Writable,Duplex}Stream,
-            so it is correct to cast it back to Stream.{Readable,Writable,Duplex}  */
-        /*  FIXME: the underlying PortAudio outputs verbose/debugging messages  */
-        if (this.params.mode === "rw") {
-            /*  input/output device  */
-            if (device.maxInputChannels === 0)
-                throw new Error(`device "${device.id}" does not have any input channels (required by read/write mode)`)
-            if (device.maxOutputChannels === 0)
-                throw new Error(`device "${device.id}" does not have any output channels (required by read/write mode)`)
-            this.log("info", `resolved "${this.params.device}" to duplex device "${device.id}"`)
-            this.io = PortAudio.AudioIO({
-                inOptions: {
-                    deviceId:     device.id,
-                    channelCount: this.config.audioChannels,
-                    sampleRate:   this.config.audioSampleRate,
-                    sampleFormat: this.config.audioBitDepth,
-                    highwaterMark
-                },
-                outOptions: {
-                    deviceId:     device.id,
-                    channelCount: this.config.audioChannels,
-                    sampleRate:   this.config.audioSampleRate,
-                    sampleFormat: this.config.audioBitDepth,
-                    highwaterMark
-                }
-            })
-            this.stream = this.io as unknown as Stream.Duplex
-
-            /*  convert regular stream into object-mode stream  */
-            const wrapper1 = util.createTransformStreamForWritableSide()
-            const wrapper2 = util.createTransformStreamForReadableSide("audio", () => this.timeZero)
-            this.stream = Stream.compose(wrapper1, this.stream, wrapper2)
-        }
-        else if (this.params.mode === "r") {
-            /*  input device  */
-            if (device.maxInputChannels === 0)
-                throw new Error(`device "${device.id}" does not have any input channels (required by read mode)`)
-            this.log("info", `resolved "${this.params.device}" to input device "${device.id}"`)
-            this.io = PortAudio.AudioIO({
-                inOptions: {
-                    deviceId:      device.id,
-                    channelCount:  this.config.audioChannels,
-                    sampleRate:    this.config.audioSampleRate,
-                    sampleFormat:  this.config.audioBitDepth,
-                    highwaterMark
-                }
-            })
-            this.stream = this.io as unknown as Stream.Readable
-
-            /*  convert regular stream into object-mode stream  */
-            const wrapper = util.createTransformStreamForReadableSide("audio", () => this.timeZero)
-            this.stream = Stream.compose(this.stream, wrapper)
-        }
-        else if (this.params.mode === "w") {
-            /*  output device  */
-            if (device.maxOutputChannels === 0)
-                throw new Error(`device "${device.id}" does not have any output channels (required by write mode)`)
-            this.log("info", `resolved "${this.params.device}" to output device "${device.id}"`)
-            this.io = PortAudio.AudioIO({
-                outOptions: {
-                    deviceId:     device.id,
-                    channelCount: this.config.audioChannels,
-                    sampleRate:   this.config.audioSampleRate,
-                    sampleFormat: this.config.audioBitDepth,
-                    highwaterMark
-                }
-            })
-            this.stream = this.io as unknown as Stream.Writable
-
-            /*  convert regular stream into object-mode stream  */
-            const wrapper = util.createTransformStreamForWritableSide()
-            this.stream = Stream.compose(wrapper, this.stream)
-        }
-        else
-            throw new Error(`device "${device.id}" does not have any input or output channels`)
+        /*  establish device stream  */
+        if (this.params.mode === "rw")
+            this.setupDuplexStream(device, highwaterMark)
+        else if (this.params.mode === "r")
+            this.setupInputStream(device, highwaterMark)
+        else if (this.params.mode === "w")
+            this.setupOutputStream(device, highwaterMark)
 
         /*  pass-through PortAudio errors  */
-        this.io.on("error", (err) => {
+        this.io!.on("error", (err) => {
             this.emit("error", err)
         })
 
         /*  start PortAudio  */
-        this.io.start()
+        this.io!.start()
     }
 
     /*  close node  */
     async close () {
         /*  shutdown PortAudio  */
         if (this.io !== null) {
-            await new Promise<void>((resolve) => {
-                this.io!.abort(() => {
-                    resolve()
-                })
-            })
-            await new Promise<void>((resolve) => {
-                this.io!.quit(() => {
-                    resolve()
-                })
-            })
+            const catchHandler = (err: unknown) => {
+                const error = util.ensureError(err)
+                if (!error.message.match(/AudioIO Quit expects 1 argument/))
+                    throw error
+            }
+            await Promise.race([
+                util.timeoutPromise(2 * 1000, "PortAudio abort timeout"),
+                new Promise<void>((resolve) => {
+                    this.io!.abort(() => {
+                        resolve()
+                    })
+                }).catch(catchHandler)
+            ])
+            await Promise.race([
+                util.timeoutPromise(2 * 1000, "PortAudio quit timeout"),
+                new Promise<void>((resolve) => {
+                    this.io!.quit(() => {
+                        resolve()
+                    })
+                }).catch(catchHandler)
+            ])
             this.io = null
         }
     }

package/speechflow-cli/src/speechflow-util-error.ts

@@ -4,6 +4,13 @@
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 
+/*  helper function for promise-based timeout  */
+export function timeoutPromise (duration: number = 10 * 1000, info = "timeout") {
+    return new Promise<void>((resolve, reject) => {
+        setTimeout(() => { reject(new Error(info)) }, duration)
+    })
+}
+
 /*  helper function for retrieving an Error object  */
 export function ensureError (error: unknown, prefix?: string, debug = false): Error {
     if (error instanceof Error && prefix === undefined && debug === false)