speechflow 2.0.3 → 2.1.0

package/speechflow-cli/src/speechflow-node-a2a-gtcrn-wt.ts

@@ -0,0 +1,68 @@
+/*
+**  SpeechFlow - Speech Processing Flow Graph
+**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+
+/*  standard dependencies  */
+import { parentPort, workerData }     from "node:worker_threads"
+
+/*  external dependencies  */
+import SherpaOnnx                     from "sherpa-onnx"
+import type {
+    SherpaOnnxDenoiserConfig,
+    SherpaOnnxOfflineSpeechDenoiser
+}                                     from "sherpa-onnx"
+
+/*  receive model path from parent thread  */
+const modelPath: string = workerData.modelPath
+
+/*  GTCRN state  */
+let denoiser: SherpaOnnxOfflineSpeechDenoiser
+
+/*  helper: log message to parent  */
+const log = (level: string, message: string) => {
+    parentPort!.postMessage({ type: "log", level, message })
+}
+
+/*  initialize globals  */
+;(async () => {
+    try {
+        /*  create denoiser  */
+        const config: SherpaOnnxDenoiserConfig = {
+            model: {
+                gtcrn: {
+                    model: modelPath
+                }
+            },
+            numThreads: 1
+        }
+        denoiser = SherpaOnnx.createOfflineSpeechDenoiser(config)
+        log("info", "GTCRN denoiser initialized")
+        parentPort!.postMessage({ type: "ready" })
+    }
+    catch (err) {
+        parentPort!.postMessage({ type: "failed", message: `failed to initialize GTCRN: ${err}` })
+        process.exit(1)
+    }
+})()
+
+/*  receive messages  */
+parentPort!.on("message", (msg) => {
+    if (msg.type === "process") {
+        const { id, samples } = msg
+
+        /*  process with GTCRN denoiser
+            NOTICE: GTCRN can also resample out input, but will always
+            produces 16KHz output, so we already fixate 16KHz input here!  */
+        const result = denoiser.run(samples, 16000)
+
+        /*  copy to transferable ArrayBuffer and send back to parent  */
+        const samplesDenoised = new Float32Array(result.samples)
+        parentPort!.postMessage({ type: "process-done", id, data: samplesDenoised }, [ samplesDenoised.buffer ])
+    }
+    else if (msg.type === "close") {
+        /*  shutdown this process  */
+        process.exit(0)
+    }
+})

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

@@ -0,0 +1,219 @@
+/*
+**  SpeechFlow - Speech Processing Flow Graph
+**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+
+/*  standard dependencies  */
+import fs                                  from "node:fs"
+import path                                from "node:path"
+import Stream                              from "node:stream"
+import { Worker }                          from "node:worker_threads"
+
+/*  external dependencies  */
+import axios                               from "axios"
+import SpeexResampler                      from "speex-resampler"
+
+/*  internal dependencies  */
+import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+import * as util                           from "./speechflow-util"
+
+/*  SpeechFlow node for GTCRN based noise suppression in audio-to-audio passing  */
+export default class SpeechFlowNodeA2AGTCRN extends SpeechFlowNode {
+    /*  declare official node name  */
+    public static name = "a2a-gtcrn"
+
+    /*  internal state  */
+    private closing = false
+    private worker: Worker | null = null
+    private resamplerDown: SpeexResampler | null = null
+    private resamplerUp:   SpeexResampler | null = null
+
+    /*  construct node  */
+    constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
+        super(id, cfg, opts, args)
+
+        /*  declare node configuration parameters  */
+        this.configure({})
+
+        /*  declare node input/output format  */
+        this.input  = "audio"
+        this.output = "audio"
+    }
+
+    /*  open node  */
+    async open () {
+        /*  clear destruction flag  */
+        this.closing = false
+
+        /*  ensure GTCRN ONNX model is available  */
+        const modelUrl  = "https://github.com/k2-fsa/sherpa-onnx/" +
+            "releases/download/speech-enhancement-models/gtcrn_simple.onnx"
+        const modelDir  = path.join(this.config.cacheDir, "gtcrn")
+        const modelPath = path.resolve(modelDir, "gtcrn_simple.onnx")
+        const stat = await fs.promises.stat(modelPath).catch(() => null)
+        if (stat === null) {
+            this.log("info", `GTCRN model downloading from "${modelUrl}"`)
+            await fs.promises.mkdir(modelDir, { recursive: true })
+            const response = await axios.get(modelUrl, {
+                responseType: "arraybuffer",
+                onDownloadProgress: (progressEvent) => {
+                    if (progressEvent.total) {
+                        const percent = (progressEvent.loaded / progressEvent.total) * 100
+                        this.log("info", `GTCRN model download: ${percent.toFixed(1)}%`)
+                    }
+                }
+            })
+            await fs.promises.writeFile(modelPath, Buffer.from(response.data))
+            this.log("info", `GTCRN model downloaded to "${modelPath}"`)
+        }
+
+        /*  establish resamplers from SpeechFlow's internal 48KHz
+            to GTCRN's required 16KHz format and back  */
+        this.resamplerDown = new SpeexResampler(1, this.config.audioSampleRate, 16000, 7)
+        this.resamplerUp   = new SpeexResampler(1, 16000, this.config.audioSampleRate, 7)
+
+        /*  initialize worker  */
+        this.worker = new Worker(path.resolve(__dirname, "speechflow-node-a2a-gtcrn-wt.js"), {
+            workerData: { modelPath }
+        })
+        this.worker.on("error", (err) => {
+            this.log("error", `GTCRN worker thread error: ${err}`)
+            this.stream?.emit("error", err)
+        })
+        this.worker.on("exit", (code) => {
+            if (code !== 0)
+                this.log("error", `GTCRN worker thread exited with error code ${code}`)
+            else
+                this.log("info", `GTCRN worker thread exited with regular code ${code}`)
+        })
+
+        /*  wait for worker to be ready  */
+        await new Promise<void>((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error("GTCRN worker thread initialization timeout"))
+            }, 60 * 1000)
+            const onMessage = (msg: any) => {
+                if (typeof msg === "object" && msg !== null && msg.type === "log")
+                    this.log(msg.level, msg.message)
+                else if (typeof msg === "object" && msg !== null && msg.type === "ready") {
+                    clearTimeout(timeout)
+                    this.worker!.off("message", onMessage)
+                    resolve()
+                }
+                else if (typeof msg === "object" && msg !== null && msg.type === "failed") {
+                    clearTimeout(timeout)
+                    this.worker!.off("message", onMessage)
+                    reject(new Error(msg.message ?? "GTCRN worker thread initialization failed"))
+                }
+            }
+            this.worker!.on("message", onMessage)
+            this.worker!.once("error", (err) => {
+                clearTimeout(timeout)
+                reject(err)
+            })
+        })
+
+        /*  receive message from worker  */
+        const pending = new Map<string, (arr: Float32Array<ArrayBuffer>) => void>()
+        this.worker.on("exit", () => {
+            pending.clear()
+        })
+        this.worker.on("message", (msg: any) => {
+            if (typeof msg === "object" && msg !== null && msg.type === "process-done") {
+                const cb = pending.get(msg.id)
+                pending.delete(msg.id)
+                if (cb)
+                    cb(msg.data)
+                else
+                    this.log("warning", `GTCRN worker thread sent back unexpected id: ${msg.id}`)
+            }
+            else if (typeof msg === "object" && msg !== null && msg.type === "log")
+                this.log(msg.level, msg.message)
+            else
+                this.log("warning", `GTCRN worker thread sent unexpected message: ${JSON.stringify(msg)}`)
+        })
+
+        /*  send message to worker  */
+        let seq = 0
+        const workerProcess = async (samples: Float32Array<ArrayBuffer>) => {
+            if (this.closing)
+                return samples
+            const id = `${seq++}`
+            return new Promise<Float32Array<ArrayBuffer>>((resolve) => {
+                pending.set(id, (result) => { resolve(result) })
+                this.worker!.postMessage({ type: "process", id, samples }, [ samples.buffer ])
+            })
+        }
+
+        /*  establish a transform stream  */
+        const self = this
+        this.stream = new Stream.Transform({
+            readableObjectMode: true,
+            writableObjectMode: true,
+            decodeStrings:      false,
+            transform (chunk: SpeechFlowChunk & { payload: Buffer }, encoding, callback) {
+                if (self.closing) {
+                    callback(new Error("stream already destroyed"))
+                    return
+                }
+                if (!Buffer.isBuffer(chunk.payload))
+                    callback(new Error("invalid chunk payload type"))
+                else {
+                    /*  resample Buffer from 48KHz (SpeechFlow) to 16KHz (GTCRN)  */
+                    const resampledDown = self.resamplerDown!.processChunk(chunk.payload)
+
+                    /*  convert Buffer into Float32Array  */
+                    const payload = util.convertBufToF32(resampledDown)
+
+                    /*  process with GTCRN  */
+                    workerProcess(payload).then((result: Float32Array<ArrayBuffer>) => {
+                        /*  convert Float32Array into Buffer  */
+                        const buf = util.convertF32ToBuf(result)
+
+                        /*  resample Buffer from 16KHz (GTCRN) back to 48KHz (SpeechFlow)  */
+                        const resampledUp = self.resamplerUp!.processChunk(buf)
+
+                        /*  update chunk  */
+                        chunk.payload = resampledUp
+
+                        /*  forward updated chunk  */
+                        this.push(chunk)
+                        callback()
+                    }).catch((err: unknown) => {
+                        const error = util.ensureError(err)
+                        self.log("warning", `processing of chunk failed: ${error.message}`)
+                        callback(error)
+                    })
+                }
+            },
+            final (callback) {
+                callback()
+            }
+        })
+    }
+
+    /*  close node  */
+    async close () {
+        /*  indicate closing  */
+        this.closing = true
+
+        /*  shutdown worker  */
+        if (this.worker !== null) {
+            this.worker.terminate()
+            this.worker = null
+        }
+
+        /*  shutdown stream  */
+        if (this.stream !== null) {
+            await util.destroyStream(this.stream)
+            this.stream = null
+        }
+
+        /*  destroy resamplers  */
+        if (this.resamplerDown !== null)
+            this.resamplerDown = null
+        if (this.resamplerUp !== null)
+            this.resamplerUp = null
+    }
+}

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

@@ -81,11 +81,11 @@ export default class SpeechFlowNodeA2AMeter extends SpeechFlowNode {
 
             /*  grab the accumulated chunk data  */
             const chunkData = this.chunkBuffer
-            this.chunkBuffer = new Float32Array(0)
+            this.chunkBuffer = chunkData.subarray(samplesPerChunk)
 
             /*  update internal audio sample sliding window for LUFS-M  */
             if (chunkData.length > sampleWindow.length)
-                sampleWindow.set(chunkData.subarray(chunkData.length - sampleWindow.length), 0)
+                sampleWindow.set(chunkData.subarray(0, sampleWindow.length), 0)
             else {
                 sampleWindow.set(sampleWindow.subarray(chunkData.length), 0)
                 sampleWindow.set(chunkData, sampleWindow.length - chunkData.length)

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

@@ -29,7 +29,7 @@ class AsyncQueue<T> {
         const resolve = this.resolvers.shift()
         if (resolve) {
             if (v !== null)
-                resolve({ value: v })
+                resolve({ value: v, done: false })
             else
                 resolve({ value: null, done: true })
         }
@@ -70,6 +70,7 @@ export default class SpeechFlowNodeA2TAmazon extends SpeechFlowNode {
     /*  internal state  */
     private client:       TranscribeStreamingClient                | null = null
     private clientStream: AsyncIterable<TranscriptResultStream>    | null = null
+    private audioQueue:   AsyncQueue<Uint8Array>                   | null = null
     private closing                                                       = false
     private queue:        util.SingleQueue<SpeechFlowChunk | null> | null = null
 
@@ -127,7 +128,8 @@ export default class SpeechFlowNodeA2TAmazon extends SpeechFlowNode {
         })
 
         /*  create an AudioStream for Amazon Transcribe  */
-        const audioQueue = new AsyncQueue<Uint8Array>()
+        this.audioQueue = new AsyncQueue<Uint8Array>()
+        const audioQueue = this.audioQueue
         const audioStream = (async function * (q: AsyncQueue<Uint8Array>): AsyncIterable<AudioStream> {
             for await (const chunk of q) {
                 yield { AudioEvent: { AudioChunk: chunk } }
@@ -173,11 +175,11 @@ export default class SpeechFlowNodeA2TAmazon extends SpeechFlowNode {
                             return prev
                         }, new Map<string, any>())
                         if (this.params.interim) {
-                            const words = []
+                            const words: { word: string, start: Duration, end: Duration }[] = []
                             for (const item of alt.Items ?? []) {
                                 if (item.Type === "pronunciation") {
                                     words.push({
-                                        word:  item.Content,
+                                        word:  item.Content ?? "",
                                         start: Duration.fromMillis((item.StartTime ?? 0) * 1000).plus(this.timeZeroOffset),
                                         end:   Duration.fromMillis((item.EndTime   ?? 0) * 1000).plus(this.timeZeroOffset)
                                     })
@@ -273,10 +275,10 @@ export default class SpeechFlowNodeA2TAmazon extends SpeechFlowNode {
         /*  indicate closing first to stop all async operations  */
         this.closing = true
 
-        /*  close queue  */
-        if (this.queue !== null) {
-            this.queue.write(null)
-            this.queue = null
+        /*  shutdown stream  */
+        if (this.stream !== null) {
+            await util.destroyStream(this.stream)
+            this.stream = null
         }
 
         /*  close Amazon Transcribe connection  */
@@ -285,10 +287,17 @@ export default class SpeechFlowNodeA2TAmazon extends SpeechFlowNode {
             this.client = null
         }
 
-        /*  shutdown stream  */
-        if (this.stream !== null) {
-            await util.destroyStream(this.stream)
-            this.stream = null
+        /*  close audio queue  */
+        if (this.audioQueue !== null) {
+            this.audioQueue.push(null)
+            this.audioQueue.destroy()
+            this.audioQueue = null
+        }
+
+        /*  signal EOF to any pending read operations  */
+        if (this.queue !== null) {
+            this.queue.write(null)
+            this.queue = null
         }
     }
 }

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

@@ -37,7 +37,8 @@ export default class SpeechFlowNodeA2TDeepgram extends SpeechFlowNode {
             model:    { type: "string",  val: "nova-2", pos: 0 },
             version:  { type: "string",  val: "latest", pos: 1 },
             language: { type: "string",  val: "multi",  pos: 2 },
-            interim:  { type: "boolean", val: false,    pos: 3 }
+            interim:  { type: "boolean", val: false,    pos: 3 },
+            keywords: { type: "string",  val: "",       pos: 4 }
         })
 
         /*  sanity check parameters  */
@@ -86,34 +87,51 @@ export default class SpeechFlowNodeA2TDeepgram extends SpeechFlowNode {
         /*  create a store for the meta information  */
         const metastore = new util.TimeStore<Map<string, any>>()
 
-        /*  connect to Deepgram API  */
-        const deepgram = Deepgram.createClient(this.params.key)
-        let language = "en"
-        if (this.params.language !== "en") {
-            if (this.params.model.match(/^nova-2/))
-                language = this.params.language
-            else if (this.params.model.match(/^nova-3/))
-                language = "multi"
-        }
-        this.dg = deepgram.listen.live({
+        /*  configure Deepgram connection options  */
+        const options: Deepgram.LiveSchema = {
             mip_opt_out:      true,
             model:            this.params.model,
             version:          this.params.version,
-            language,
             channels:         this.config.audioChannels,
             sample_rate:      this.config.audioSampleRate,
             encoding:         "linear16",
             multichannel:     false,
             endpointing:      false,
             interim_results:  this.params.interim,
-            smart_format:     true,
+            smart_format:     false,
             punctuate:        true,
             filler_words:     true,
-            numerals:         true,
+            numerals:         false,
             diarize:          false,
             profanity_filter: false,
             redact:           false
-        })
+        }
+        const model    = this.params.model    as string
+        const language = this.params.language as string
+        const keywords = this.params.keywords as string
+        if (model.match(/^nova-2/) && language !== "en")
+            options.language = this.params.language
+        else if (model.match(/^nova-3/) && language !== "en")
+            options.language = "multi"
+        else
+            options.language = "en"
+        if (keywords !== "") {
+            if (model.match(/^nova-2/))
+                options.keywords = keywords.split(/(?:\s+|\s*,\s*)/).map((kw) => {
+                    let boost = 2
+                    if (kw.startsWith("-")) {
+                        kw = kw.slice(1)
+                        boost = -4
+                    }
+                    return `${kw}:${boost}`
+                })
+            else if (model.match(/^nova-3/))
+                options.keyterm = keywords.split(/(?:\s+|\s*,\s*)/).join(" ")
+        }
+
+        /*  connect to Deepgram API  */
+        const deepgram = Deepgram.createClient(this.params.key)
+        this.dg = deepgram.listen.live(options)
 
         /*  hook onto Deepgram API events  */
         this.dg.on(Deepgram.LiveTranscriptionEvents.Transcript, async (data) => {

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

@@ -170,9 +170,9 @@ export default class SpeechFlowNodeA2TOpenAI extends SpeechFlowNode {
         /*  track transcription text  */
         let text = ""
         this.ws.on("message", (data) => {
-            let ev: any
+            let ev: Record<string, unknown>
             try {
-                ev = JSON.parse(data.toString())
+                ev = JSON.parse(data.toString()) as Record<string, unknown>
             }
             catch (err) {
                 this.log("warning", `failed to parse WebSocket message: ${err}`)
@@ -194,8 +194,8 @@ export default class SpeechFlowNodeA2TOpenAI extends SpeechFlowNode {
                     if (this.params.interim && !this.closing && this.queue !== null) {
                         const itemId = ev.item_id as string
                         const timing = speechTiming.get(itemId)
-                        const start  = timing ? Duration.fromMillis(timing.startMs) : DateTime.now().diff(this.timeOpen!)
-                        const end    = timing ? Duration.fromMillis(timing.endMs)   : start
+                        const start  = timing !== undefined ? Duration.fromMillis(timing.startMs) : DateTime.now().diff(this.timeOpen!)
+                        const end    = timing !== undefined ? Duration.fromMillis(timing.endMs)   : start
                         const chunk  = new SpeechFlowChunk(start, end, "intermediate", "text", text)
                         chunk.meta = aggregateMeta(start, end)
                         this.queue.write(chunk)
@@ -207,8 +207,8 @@ export default class SpeechFlowNodeA2TOpenAI extends SpeechFlowNode {
                         text = ev.transcript as string
                         const itemId = ev.item_id as string
                         const timing = speechTiming.get(itemId)
-                        const start  = timing ? Duration.fromMillis(timing.startMs) : DateTime.now().diff(this.timeOpen!)
-                        const end    = timing ? Duration.fromMillis(timing.endMs)   : start
+                        const start  = timing !== undefined ? Duration.fromMillis(timing.startMs) : DateTime.now().diff(this.timeOpen!)
+                        const end    = timing !== undefined ? Duration.fromMillis(timing.endMs)   : start
                         const chunk  = new SpeechFlowChunk(start, end, "final", "text", text)
                         chunk.meta = aggregateMeta(start, end)
                         metastore.prune(start)
@@ -230,7 +230,7 @@ export default class SpeechFlowNodeA2TOpenAI extends SpeechFlowNode {
                     const itemId = ev.item_id as string
                     const audioEndMs = ev.audio_end_ms as number
                     const timing = speechTiming.get(itemId)
-                    if (timing)
+                    if (timing !== undefined)
                         timing.endMs = audioEndMs
                     break
                 }
@@ -239,7 +239,8 @@ export default class SpeechFlowNodeA2TOpenAI extends SpeechFlowNode {
                     break
                 }
                 case "error": {
-                    this.log("error", `error: ${ev.error?.message}`)
+                    const error = ev.error as { message?: string } | undefined
+                    this.log("error", `error: ${error?.message ?? "unknown error"}`)
                     break
                 }
                 default:

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

@@ -124,11 +124,9 @@ export default class SpeechFlowNodeT2AAmazon extends SpeechFlowNode {
             decodeStrings:      false,
             highWaterMark:      1,
             transform (chunk: SpeechFlowChunk, encoding, callback) {
-                if (self.closing) {
+                if (self.closing)
                     callback(new Error("stream already destroyed"))
-                    return
-                }
-                if (Buffer.isBuffer(chunk.payload))
+                else if (Buffer.isBuffer(chunk.payload))
                     callback(new Error("invalid chunk payload type"))
                 else if (chunk.payload === "")
                     callback()

package/speechflow-cli/src/speechflow-node-t2a-elevenlabs.ts

@@ -98,7 +98,7 @@ export default class SpeechFlowNodeT2AElevenlabs extends SpeechFlowNode {
         const voices = await this.elevenlabs.voices.getAll()
         let voice = voices.voices.find((v) => v.name === this.params.voice)
         if (voice === undefined) {
-            voice = voices.voices.find((v) => (v.name ?? "").startsWith(this.params.voice))
+            voice = voices.voices.find((v) => v.name?.startsWith(this.params.voice))
             if (voice === undefined)
                 throw new Error(`invalid ElevenLabs voice "${this.params.voice}"`)
         }
@@ -108,7 +108,7 @@ export default class SpeechFlowNodeT2AElevenlabs extends SpeechFlowNode {
             ""
         this.log("info", `selected voice: name: "${voice.name}"${info}`)
 
-        /*  perform text-to-speech operation with Elevenlabs API  */
+        /*  perform text-to-speech operation with ElevenLabs API  */
         const model = this.params.optimize === "quality" ?
             "eleven_turbo_v2_5" :
             "eleven_flash_v2_5"
@@ -131,7 +131,7 @@ export default class SpeechFlowNodeT2AElevenlabs extends SpeechFlowNode {
             })
         }
 
-        /*  establish resampler from ElevenLabs's tier-dependent
+        /*  establish resampler from ElevenLabs tier-dependent
             output sample rate to our standard audio sample rate (48KHz)  */
         this.resampler = new SpeexResampler(1, maxSampleRate, this.config.audioSampleRate, 7)
 

package/speechflow-cli/src/speechflow-node-t2a-google.ts

@@ -36,8 +36,8 @@ export default class SpeechFlowNodeT2AGoogle extends SpeechFlowNode {
             key:      { type: "string",         val: process.env.SPEECHFLOW_GOOGLE_KEY ?? "" },
             voice:    { type: "string", pos: 0, val: "en-US-Neural2-J" },
             language: { type: "string", pos: 1, val: "en-US" },
-            speed:    { type: "number", pos: 2, val: 1.0, match: (n: number) => n >=  0.25 && n <=  4.0 },
-            pitch:    { type: "number", pos: 3, val: 0.0, match: (n: number) => n >= -20.0 && n <= 20.0 }
+            speed:    { type: "number", pos: 2, val: 1.0, match: (n: number) => n >=   0.25 && n <=  4.0 },
+            pitch:    { type: "number", pos: 3, val: 0.0, match: (n: number) => n >= -20.0  && n <= 20.0 }
         })
 
         /*  validate API key  */

package/speechflow-cli/src/speechflow-node-t2a-supertonic.ts

@@ -139,7 +139,7 @@ export default class SpeechFlowNodeT2ASupertonic extends SpeechFlowNode {
             const samples = result.audio
             const outputSampleRate = result.sampling_rate
             if (outputSampleRate !== this.sampleRate)
-                this.log("warn", `unexpected sample rate ${outputSampleRate}Hz (expected ${this.sampleRate}Hz)`)
+                this.log("warning", `unexpected sample rate ${outputSampleRate}Hz (expected ${this.sampleRate}Hz)`)
 
             /*  calculate duration  */
             const duration = samples.length / outputSampleRate

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

@@ -85,15 +85,16 @@ export default class SpeechFlowNodeT2TAmazon extends SpeechFlowNode {
                     const out = await this.client!.send(cmd)
                     return (out.TranslatedText ?? "").trim()
                 }
-                catch (e: any) {
+                catch (e: unknown) {
                     lastError = e
                     attempt += 1
 
                     /*  simple backoff for transient errors  */
+                    const err = e as { name?: string, $retryable?: boolean }
                     const retriable =
-                        e?.name === "ThrottlingException"
-                        || e?.name === "ServiceUnavailableException"
-                        || e?.$retryable === true
+                        err?.name === "ThrottlingException"
+                        || err?.name === "ServiceUnavailableException"
+                        || err?.$retryable === true
                     if (!retriable || attempt >= maxRetries)
                         break
                     const delayMs = Math.min(1000 * Math.pow(2, attempt - 1), 5000)
@@ -135,17 +136,17 @@ export default class SpeechFlowNodeT2TAmazon extends SpeechFlowNode {
 
     /*  close node  */
     async close () {
-        /*  close Amazon Translate connection  */
-        if (this.client !== null) {
-            this.client.destroy()
-            this.client = null
-        }
-
         /*  shutdown stream  */
         if (this.stream !== null) {
             await util.destroyStream(this.stream)
             this.stream = null
         }
+
+        /*  close Amazon Translate connection  */
+        if (this.client !== null) {
+            this.client.destroy()
+            this.client = null
+        }
     }
 }
 

package/speechflow-cli/src/speechflow-node-t2t-deepl.ts

@@ -53,7 +53,7 @@ export default class SpeechFlowNodeT2TDeepL extends SpeechFlowNode {
         const usage = await deepl.getUsage()
         const limit = usage?.character?.limit ?? 1
         const percent = limit > 0 ? ((usage?.character?.count ?? 0) / limit * 100) : 0
-        return { usage: `${percent.toFixed(8)}%` }
+        return { usage: `${percent.toFixed(2)}%` }
     }
 
     /*  open node  */
@@ -63,7 +63,7 @@ export default class SpeechFlowNodeT2TDeepL extends SpeechFlowNode {
 
         /*  provide text-to-text translation  */
         const translate = async (text: string) => {
-            const src = this.params.src === "en" ? "en-US" : this.params.src
+            const src = this.params.src
             const dst = this.params.dst === "en" ? "en-US" : this.params.dst
             const result = await this.deepl!.translateText(text, src, dst, {
                 splitSentences: "off",
@@ -95,7 +95,7 @@ export default class SpeechFlowNodeT2TDeepL extends SpeechFlowNode {
                         this.push(chunkNew)
                         callback()
                     }).catch((error: unknown) => {
-                        callback(util.ensureError(error))
+                        callback(util.ensureError(error, "DeepL translation failed"))
                     })
                 }
             },