speechflow 1.6.7 → 1.7.0

package/speechflow-cli/package.json

@@ -18,34 +18,34 @@
         "cli-io":                               "0.9.13",
         "yargs":                                "18.0.0",
         "flowlink":                             "1.2.3",
-        "js-yaml":                              "4.1.0",
+        "js-yaml":                              "4.1.1",
         "@gpeng/naudiodon":                     "2.4.1",
         "@deepgram/sdk":                        "4.11.2",
-        "deepl-node":                           "1.19.1",
-        "@elevenlabs/elevenlabs-js":            "2.17.0",
+        "deepl-node":                           "1.22.0",
+        "@elevenlabs/elevenlabs-js":            "2.26.0",
         "get-stream":                           "9.0.1",
-        "@dotenvx/dotenvx":                     "1.51.0",
+        "@dotenvx/dotenvx":                     "1.51.1",
         "speex-resampler":                      "3.0.1",
         "@sapphi-red/speex-preprocess-wasm":    "0.4.0",
         "@shiguredo/rnnoise-wasm":              "2025.1.5",
-        "@aws-sdk/client-transcribe-streaming": "3.901.0",
-        "@aws-sdk/client-translate":            "3.901.0",
-        "@aws-sdk/client-polly":                "3.901.0",
-        "@google-cloud/translate":              "9.2.0",
-        "node-web-audio-api":                   "1.0.4",
+        "@aws-sdk/client-transcribe-streaming": "3.946.0",
+        "@aws-sdk/client-translate":            "3.946.0",
+        "@aws-sdk/client-polly":                "3.946.0",
+        "@google-cloud/translate":              "9.3.0",
+        "node-web-audio-api":                   "1.0.7",
         "object-path":                          "0.11.8",
-        "glob":                                 "11.0.3",
+        "glob":                                 "13.0.0",
         "ws":                                   "8.18.3",
         "bufferutil":                           "4.0.9",
         "utf-8-validate":                       "6.0.5",
-        "@hapi/hapi":                           "21.4.3",
+        "@hapi/hapi":                           "21.4.4",
         "@hapi/boom":                           "10.0.1",
         "@hapi/inert":                          "7.1.0",
         "hapi-plugin-header":                   "1.1.8",
         "hapi-plugin-websocket":                "2.4.11",
         "@opensumi/reconnecting-websocket":     "4.4.0",
-        "ollama":                               "0.6.0",
-        "openai":                               "6.1.0",
+        "ollama":                               "0.6.3",
+        "openai":                               "6.10.0",
         "@rse/ffmpeg":                          "1.4.2",
         "ffmpeg-stream":                        "1.0.1",
         "installed-packages":                   "1.0.13",
@@ -53,11 +53,11 @@
         "wav":                                  "1.0.2",
         "mqtt":                                 "5.14.1",
         "cbor2":                                "2.0.1",
-        "arktype":                              "2.1.22",
+        "arktype":                              "2.1.28",
         "pure-uuid":                            "1.8.1",
         "wavefile":                             "11.0.0",
         "audio-inspect":                        "0.0.4",
-        "@huggingface/transformers":            "3.7.5",
+        "@huggingface/transformers":            "3.8.1",
         "kokoro-js":                            "1.2.1",
         "@ericedouard/vad-node-realtime":       "0.2.0",
         "osc-js":                               "2.4.1",
@@ -69,22 +69,22 @@
         "@rse/stx":                             "1.1.2"
     },
     "devDependencies": {
-        "eslint":                               "9.37.0",
-        "@eslint/js":                           "9.37.0",
+        "eslint":                               "9.39.1",
+        "@eslint/js":                           "9.39.1",
         "neostandard":                          "0.12.2",
         "eslint-plugin-promise":                "7.2.1",
         "eslint-plugin-import":                 "2.32.0",
         "eslint-plugin-node":                   "11.1.0",
-        "typescript-eslint":                    "8.45.0",
-        "@typescript-eslint/eslint-plugin":     "8.45.0",
-        "@typescript-eslint/parser":            "8.45.0",
-        "oxlint":                               "1.19.0",
-        "eslint-plugin-oxlint":                 "1.19.0",
+        "typescript-eslint":                    "8.48.1",
+        "@typescript-eslint/eslint-plugin":     "8.48.1",
+        "@typescript-eslint/parser":            "8.48.1",
+        "oxlint":                               "1.31.0",
+        "eslint-plugin-oxlint":                 "1.31.0",
         "@biomejs/biome":                       "2.0.6",
         "eslint-config-biome":                  "2.1.3",
 
-        "@types/node":                          "24.6.2",
-        "@types/yargs":                         "17.0.33",
+        "@types/node":                          "24.10.1",
+        "@types/yargs":                         "17.0.35",
         "@types/js-yaml":                       "4.0.9",
         "@types/object-path":                   "0.11.4",
         "@types/ws":                            "8.18.1",
@@ -93,13 +93,14 @@
         "@types/luxon":                         "3.7.1",
         "@types/wrap-text":                     "1.0.2",
 
+        "check-dependencies":                   "2.0.0",
         "patch-package":                        "8.0.1",
         "stmux":                                "1.8.11",
-        "nodemon":                              "3.1.10",
+        "nodemon":                              "3.1.11",
         "shx":                                  "0.4.0",
-        "@yao-pkg/pkg":                         "6.7.0",
+        "@yao-pkg/pkg":                         "6.10.1",
         "typescript":                           "5.9.3",
-        "delay-cli":                            "2.0.0",
+        "delay-cli":                            "3.0.0",
         "cross-env":                            "10.1.0"
     },
     "overrides": {

package/speechflow-cli/src/speechflow-main-api.ts

@@ -69,8 +69,7 @@ export class APIServer {
             else {
                 await Promise.race<void>([
                     foundNode.receiveRequest(argList),
-                    new Promise<never>((resolve, reject) => setTimeout(() =>
-                        reject(new Error("timeout")), 10 * 1000))
+                    util.timeout(10 * 1000)
                 ]).catch((err: Error) => {
                     this.cli.log("warning", `external request to node <${name}> failed: ${err.message}`)
                     throw err
@@ -255,8 +254,7 @@ export class APIServer {
                 for (const n of graph.getGraphNodes()) {
                     Promise.race<void>([
                         n.receiveDashboard(info.type, info.id, info.kind, info.value),
-                        new Promise<never>((resolve, reject) => setTimeout(() =>
-                            reject(new Error("timeout")), 10 * 1000))
+                        util.timeout(10 * 1000)
                     ]).catch((err: Error) => {
                         this.cli.log("warning", `sending dashboard info to node <${n.id}> failed: ${err.message}`)
                     })
@@ -297,8 +295,7 @@ export class APIServer {
             }
             await Promise.race([
                 Promise.all(closePromises),
-                new Promise((resolve, reject) =>
-                    setTimeout(() => reject(new Error("timeout for all peers")), 5 * 1000))
+                util.timeout(5 * 1000)
             ]).catch((error: unknown) => {
                 this.cli.log("warning", `HAPI: WebSockets failed to close: ${util.ensureError(error).message}`)
             })

package/speechflow-cli/src/speechflow-main-graph.ts

@@ -174,8 +174,7 @@ export class NodeGraph {
             node.setTimeZero(this.timeZero)
             await Promise.race<void>([
                 node.open(),
-                new Promise<never>((resolve, reject) => setTimeout(() =>
-                    reject(new Error("timeout")), 30 * 1000))
+                util.timeout(30 * 1000)
             ]).catch((err: Error) => {
                 this.cli.log("error", `<${node.id}>: failed to open node <${node.id}>: ${err.message}`)
                 throw new Error(`failed to open node <${node.id}>: ${err.message}`)
@@ -225,11 +224,11 @@ export class NodeGraph {
                     this.shutdown("finished", args, api)
                 }
             }
-            node.stream.on("end", () => {
-                deactivateNode(node, `readable stream side of node <${node.id}> raised "end" event`)
-            })
             node.stream.on("finish", () => {
-                deactivateNode(node, `writable stream side of node <${node.id}> raised "finish" event`)
+                deactivateNode(node, `writable stream side (input) of node <${node.id}> raised "finish" event`)
+            })
+            node.stream.on("end", () => {
+                deactivateNode(node, `readable stream side (output) of node <${node.id}> raised "end" event`)
             })
         }
 
@@ -271,8 +270,7 @@ export class NodeGraph {
             this.cli.log("info", `close node <${node.id}>`)
             await Promise.race<void>([
                 node.close(),
-                new Promise<never>((resolve, reject) => setTimeout(() =>
-                    reject(new Error("timeout")), 10 * 1000))
+                util.timeout(10 * 1000)
             ]).catch((err: Error) => {
                 this.cli.log("warning", `node <${node.id}> failed to close: ${err.message}`)
             })

package/speechflow-cli/src/speechflow-main-status.ts

@@ -15,6 +15,7 @@ import chalk                 from "chalk"
 /*  internal dependencies  */
 import SpeechFlowNode        from "./speechflow-node"
 import { NodeConfig }        from "./speechflow-main-config"
+import * as util             from "./speechflow-util"
 
 /*  the node status manager  */
 export class NodeStatusManager {
@@ -48,8 +49,7 @@ export class NodeStatusManager {
             node._accessBus = accessBus
             const status = await Promise.race<{ [ key: string ]: string | number }>([
                 node.status(),
-                new Promise<never>((resolve, reject) => setTimeout(() =>
-                    reject(new Error("timeout")), 10 * 1000))
+                util.timeout(10 * 1000)
             ]).catch((err: Error) => {
                 this.cli.log("warning", `[${node.id}]: failed to gather status of node <${node.id}>: ${err.message}`)
                 return {} as { [ key: string ]: string | number }

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

@@ -99,7 +99,7 @@ export default class SpeechFlowNodeA2AFFMPEG extends SpeechFlowNode {
         })
 
         /*  wrap streams with conversions for chunk vs plain audio  */
-        const wrapper1 = util.createTransformStreamForWritableSide()
+        const wrapper1 = util.createTransformStreamForWritableSide("audio", 1)
         const wrapper2 = util.createTransformStreamForReadableSide("audio", () => this.timeZero)
         this.stream = Stream.compose(wrapper1, ffmpegStream, wrapper2)
     }
@@ -114,7 +114,9 @@ export default class SpeechFlowNodeA2AFFMPEG extends SpeechFlowNode {
 
         /*  shutdown FFmpeg  */
         if (this.ffmpeg !== null) {
-            util.run(() => this.ffmpeg!.kill(), () => {})
+            util.run("stopping FFmpeg process",
+                () => this.ffmpeg!.kill(),
+                () => {})
             this.ffmpeg = null
         }
     }

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

@@ -15,6 +15,8 @@ import * as util                           from "./speechflow-util"
 
 class AudioFiller extends EventEmitter {
     private emittedEndSamples = 0           /* stream position in samples already emitted */
+    private maxInputEndSamples = 0
+    private lastMeta: Map<string, any> | undefined = undefined
     private readonly bytesPerSample = 2     /* PCM I16 */
     private readonly bytesPerFrame: number
     private readonly sampleTolerance = 0.5  /* tolerance for floating-point sample comparisons */
@@ -25,12 +27,12 @@ class AudioFiller extends EventEmitter {
     }
 
     /*  optional helper to allow subscribing with strong typing  */
-    public on(event: "chunk", listener: (chunk: SpeechFlowChunk) => void): this
+    public on(event: "chunk", listener: (chunk: SpeechFlowChunk, type: string) => void): this
     public on(event: string, listener: (...args: any[]) => void): this {
         return super.on(event, listener)
     }
 
-    /*  convert fractional samples to duration  */
+    /*  convert fractional samples from duration  */
     private samplesFromDuration(duration: Duration): number {
         const seconds = duration.as("seconds")
         const samples = seconds * this.sampleRate
@@ -51,8 +53,9 @@ class AudioFiller extends EventEmitter {
         const payload = Buffer.alloc(frames * this.bytesPerFrame) /* already zeroed */
         const timestampStart = this.durationFromSamples(fromSamples)
         const timestampEnd   = this.durationFromSamples(toSamples)
-        const chunk = new SpeechFlowChunk(timestampStart, timestampEnd, "final", "audio", payload, meta ? new Map(meta) : undefined)
-        this.emit("chunk", chunk)
+        const chunk = new SpeechFlowChunk(timestampStart, timestampEnd,
+            "final", "audio", payload, meta ? new Map(meta) : undefined)
+        this.emit("chunk", chunk, "silence")
     }
 
     /*  add a chunk of audio for processing  */
@@ -62,6 +65,12 @@ class AudioFiller extends EventEmitter {
         if (endSamp < startSamp)
             throw new Error("invalid timestamps")
 
+        /*  track maximum input end timestamp and last metadata for trailing silence  */
+        if (endSamp > this.maxInputEndSamples) {
+            this.maxInputEndSamples = endSamp
+            this.lastMeta = chunk.meta ? new Map(chunk.meta) : undefined
+        }
+
         /*  if chunk starts beyond what we've emitted, insert silence for the gap  */
         if (startSamp > this.emittedEndSamples + this.sampleTolerance) {
             this.emitSilence(this.emittedEndSamples, startSamp, chunk.meta)
@@ -95,12 +104,20 @@ class AudioFiller extends EventEmitter {
         const outEndSamples   = outStartSamples + Math.floor(payload.length / this.bytesPerFrame)
         const timestampStart  = this.durationFromSamples(outStartSamples)
         const timestampEnd    = this.durationFromSamples(outEndSamples)
-        const c = new SpeechFlowChunk(timestampStart, timestampEnd, "final", "audio", payload, new Map(chunk.meta))
-        this.emit("chunk", c)
+        const c = new SpeechFlowChunk(timestampStart, timestampEnd,
+            "final", "audio", payload, new Map(chunk.meta))
+        this.emit("chunk", c, "content")
 
         /*  advance emitted cursor  */
         this.emittedEndSamples = Math.max(this.emittedEndSamples, outEndSamples)
     }
+
+    /*  signal end of processing and emit trailing silence  */
+    public done (): void {
+        /*  emit trailing silence if there's a gap between emitted and max input  */
+        if (this.maxInputEndSamples > this.emittedEndSamples + this.sampleTolerance)
+            this.emitSilence(this.emittedEndSamples, this.maxInputEndSamples, this.lastMeta)
+    }
 }
 
 /*  SpeechFlow node for filling audio gaps  */
@@ -137,12 +154,13 @@ export default class SpeechFlowNodeA2AFiller extends SpeechFlowNode {
         this.sendQueue = new util.AsyncQueue<SpeechFlowChunk | null>()
 
         /*  shift chunks from filler to send queue  */
-        this.filler.on("chunk", (chunk) => {
+        this.filler.on("chunk", (chunk, type) => {
             this.sendQueue?.write(chunk)
         })
 
         /*  establish a duplex stream  */
         const self = this
+        const reads = new util.PromiseSet<void>()
         this.stream = new Stream.Duplex({
             readableObjectMode: true,
             writableObjectMode: true,
@@ -154,8 +172,6 @@ export default class SpeechFlowNodeA2AFiller extends SpeechFlowNode {
                     callback(new Error("invalid chunk payload type"))
                 else {
                     try {
-                        if (self.closing || self.filler === null)
-                            throw new Error("stream already destroyed")
                         self.filler.add(chunk)
                         callback()
                     }
@@ -164,12 +180,37 @@ export default class SpeechFlowNodeA2AFiller extends SpeechFlowNode {
                     }
                 }
             },
+            async final (callback) {
+                /*  short-circuit processing in case of own closing  */
+                if (self.closing) {
+                    callback()
+                    return
+                }
+
+                /*  signal end of stream  */
+                if (self.filler !== null && self.sendQueue !== null) {
+                    /*  optionally emit trailing silence
+                        (we have to wait for its internal "emit" operation to happen)  */
+                    self.filler.done()
+                    await util.sleep(10)
+
+                    /*  signal end of stream  */
+                    self.sendQueue.write(null)
+                }
+
+                /*  await all read operations  */
+                await reads.awaitAll()
+
+                /*  signal end of streaming  */
+                this.push(null)
+                callback()
+            },
             read (size) {
                 if (self.closing || self.sendQueue === null) {
                     this.push(null)
                     return
                 }
-                self.sendQueue.read().then((chunk) => {
+                reads.add(self.sendQueue.read().then((chunk) => {
                     if (self.closing || self.sendQueue === null) {
                         this.push(null)
                         return
@@ -178,22 +219,18 @@ export default class SpeechFlowNodeA2AFiller extends SpeechFlowNode {
                         self.log("info", "received EOF signal")
                         this.push(null)
                     }
+                    else if (!(chunk.payload instanceof Buffer)) {
+                        self.log("warning", "invalid chunk (expected audio buffer)")
+                        this.push(null)
+                    }
                     else {
-                        self.log("debug", `received data (${chunk.payload.length} bytes)`)
+                        self.log("debug", `received data (${chunk.payload.byteLength} bytes)`)
                         this.push(chunk)
                     }
                 }).catch((error: unknown) => {
                     if (!self.closing && self.sendQueue !== null)
                         self.log("error", `queue read error: ${util.ensureError(error).message}`)
-                })
-            },
-            final (callback) {
-                if (self.closing) {
-                    callback()
-                    return
-                }
-                this.push(null)
-                callback()
+                }))
             }
         })
     }

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

@@ -73,11 +73,6 @@ export default class SpeechFlowNodeA2AGain extends SpeechFlowNode {
                 }
             },
             final (callback) {
-                if (self.closing) {
-                    callback()
-                    return
-                }
-                this.push(null)
                 callback()
             }
         })

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

@@ -363,8 +363,7 @@ export default class SpeechFlowNodeA2AGender extends SpeechFlowNode {
         if (this.classifier !== null) {
             try {
                 const disposePromise = this.classifier.dispose()
-                const timeoutPromise = new Promise((resolve) => setTimeout(resolve, 5000))
-                await Promise.race([ disposePromise, timeoutPromise ])
+                await Promise.race([ disposePromise, util.sleep(5000) ])
             }
             catch (error) {
                 this.log("warning", `error during classifier cleanup: ${error}`)

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

@@ -107,11 +107,6 @@ export default class SpeechFlowNodeA2AMute extends SpeechFlowNode {
                 }
             },
             final (callback) {
-                if (self.closing) {
-                    callback()
-                    return
-                }
-                this.push(null)
                 callback()
             }
         })

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

@@ -136,11 +136,6 @@ export default class SpeechFlowNodeA2ARNNoise extends SpeechFlowNode {
                 }
             },
             final (callback) {
-                if (self.closing) {
-                    callback()
-                    return
-                }
-                this.push(null)
                 callback()
             }
         })

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

@@ -108,11 +108,6 @@ export default class SpeechFlowNodeA2ASpeex extends SpeechFlowNode {
                 }
             },
             final (callback) {
-                if (self.closing) {
-                    callback()
-                    return
-                }
-                this.push(null)
                 callback()
             }
         })

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

@@ -181,7 +181,6 @@ export default class SpeechFlowNodeA2AWAV extends SpeechFlowNode {
                 }
             },
             final (callback) {
-                this.push(null)
                 callback()
             }
         })

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

@@ -202,8 +202,9 @@ export default class SpeechFlowNodeA2TAmazon extends SpeechFlowNode {
         /*  remember opening time to receive time zero offset  */
         this.timeOpen = DateTime.now()
 
-        /*  provide Duplex stream and internally attach to Deepgram API  */
+        /*  provide Duplex stream and internally attach to Amazon Transcribe API  */
         const self = this
+        const reads = new util.PromiseSet<void>()
         this.stream = new Stream.Duplex({
             writableObjectMode: true,
             readableObjectMode: true,
@@ -231,12 +232,29 @@ export default class SpeechFlowNodeA2TAmazon extends SpeechFlowNode {
                     callback()
                 }
             },
+            async final (callback) {
+                if (self.closing || self.client === null) {
+                    callback()
+                    return
+                }
+
+                /*  await all read operations  */
+                await reads.awaitAll()
+
+                util.run(
+                    () => self.client!.destroy(),
+                    (error: Error) => self.log("warning", `error closing Amazon Transcribe connection: ${error}`)
+                )
+                audioQueue.push(null) /*  do not push null to stream, let Amazon Transcribe do it  */
+                audioQueue.destroy()
+                callback()
+            },
             read (size) {
                 if (self.closing || self.queue === null) {
                     this.push(null)
                     return
                 }
-                self.queue.read().then((chunk) => {
+                reads.add(self.queue.read().then((chunk) => {
                     if (self.closing || self.queue === null) {
                         this.push(null)
                         return
@@ -252,20 +270,7 @@ export default class SpeechFlowNodeA2TAmazon extends SpeechFlowNode {
                 }).catch((error: unknown) => {
                     if (!self.closing && self.queue !== null)
                         self.log("error", `queue read error: ${util.ensureError(error).message}`)
-                })
-            },
-            final (callback) {
-                if (self.closing || self.client === null) {
-                    callback()
-                    return
-                }
-                util.run(
-                    () => self.client!.destroy(),
-                    (error: Error) => self.log("warning", `error closing Amazon Transcribe connection: ${error}`)
-                )
-                audioQueue.push(null) /*  do not push null to stream, let Amazon Transcribe do it  */
-                audioQueue.destroy()
-                callback()
+                }))
             }
         })
     }

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

@@ -187,6 +187,7 @@ export default class SpeechFlowNodeA2TDeepgram extends SpeechFlowNode {
 
         /*  provide Duplex stream and internally attach to Deepgram API  */
         const self = this
+        const reads = new util.PromiseSet<void>()
         this.stream = new Stream.Duplex({
             writableObjectMode: true,
             readableObjectMode: true,
@@ -217,12 +218,33 @@ export default class SpeechFlowNodeA2TDeepgram extends SpeechFlowNode {
                     callback()
                 }
             },
+            async final (callback) {
+                /*  short-circuiting in case of own closing  */
+                if (self.closing || self.dg === null) {
+                    callback()
+                    return
+                }
+
+                /*  close Deepgram API  */
+                try {
+                    self.dg.requestClose()
+                }
+                catch (error) {
+                    self.log("warning", `error closing Deepgram connection: ${error}`)
+                }
+
+                /*  await all read operations  */
+                await reads.awaitAll()
+
+                /*  NOTICE: do not push null here -- let the Deepgram close event handle it  */
+                callback()
+            },
             read (size) {
                 if (self.closing || self.queue === null) {
                     this.push(null)
                     return
                 }
-                self.queue.read().then((chunk) => {
+                reads.add(self.queue.read().then((chunk) => {
                     if (self.closing || self.queue === null) {
                         this.push(null)
                         return
@@ -238,21 +260,7 @@ export default class SpeechFlowNodeA2TDeepgram extends SpeechFlowNode {
                 }).catch((error: unknown) => {
                     if (!self.closing && self.queue !== null)
                         self.log("error", `queue read error: ${util.ensureError(error).message}`)
-                })
-            },
-            final (callback) {
-                if (self.closing || self.dg === null) {
-                    callback()
-                    return
-                }
-                try {
-                    self.dg.requestClose()
-                }
-                catch (error) {
-                    self.log("warning", `error closing Deepgram connection: ${error}`)
-                }
-                /*  NOTICE: do not push null here -- let the Deepgram close event handle it  */
-                callback()
+                }))
             }
         })
     }