speechflow 2.3.1 → 2.4.0

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

@@ -23,8 +23,11 @@ export default class SpeechFlowNodeA2TDeepgram extends SpeechFlowNode {
     /*  internal state  */
     private dg:                Deepgram.LiveClient                      | null = null
     private closing                                                            = false
+    private reconfiguring                                                      = false
     private connectionTimeout: ReturnType<typeof setTimeout>            | null = null
     private queue:             util.AsyncQueue<SpeechFlowChunk | null>  | null = null
+    private metastore:         util.TimeStore<Map<string, any>>         | null = null
+    private suspended                                                          = false
 
     /*  construct node  */
     constructor (id: string, cfg: { [ id: string ]: any }, opts: { [ id: string ]: any }, args: any[]) {
@@ -39,7 +42,8 @@ export default class SpeechFlowNodeA2TDeepgram extends SpeechFlowNode {
             language:    { type: "string",  val: "multi",  pos: 2 },
             interim:     { type: "boolean", val: false,    pos: 3 },
             endpointing: { type: "number",  val: 0,        pos: 4 },
-            keywords:    { type: "string",  val: "",       pos: 5 }
+            keywords:    { type: "string",  val: "",       pos: 5 },
+            suspended:   { type: "boolean", val: false,    pos: 6 }
         })
 
         /*  sanity check parameters  */
@@ -51,43 +55,55 @@ export default class SpeechFlowNodeA2TDeepgram extends SpeechFlowNode {
         this.output = "text"
     }
 
-    /*  one-time status of node  */
-    async status () {
-        let balance = 0
+    /*  receive external request  */
+    async receiveRequest (params: any[]) {
+        if (this.closing)
+            throw new Error("deepgram: node already destroyed")
         try {
-            const deepgram = Deepgram.createClient(this.params.keyAdm)
-            const response = await deepgram.manage.getProjects()
-            if (response !== null && response.error === null && response.result?.projects) {
-                for (const project of response.result.projects) {
-                    const balanceResponse = await deepgram.manage.getProjectBalances(project.project_id)
-                    if (balanceResponse !== null && balanceResponse.error === null && balanceResponse.result?.balances)
-                        balance += balanceResponse.result.balances[0]?.amount ?? 0
-                }
+            if (params.length === 2 && params[0] === "suspended") {
+                if (typeof params[1] !== "boolean")
+                    throw new Error("deepgram: invalid suspended argument in external request")
+                const suspended = params[1]
+                await this.setSuspended(suspended)
+                this.sendResponse([ "deepgram", "suspended", suspended ])
             }
-            else if (response !== null && response.error !== null)
-                this.log("warning", `API error fetching projects: ${response.error}`)
+            else
+                throw new Error("deepgram: invalid arguments in external request")
         }
         catch (error) {
-            this.log("warning", `failed to fetch balance: ${error}`)
+            this.log("error", `receive request error: ${error}`)
+            throw error
         }
-        return { balance: balance.toFixed(2) }
     }
 
-    /*  open node  */
-    async open () {
-        /*  sanity check situation  */
-        if (this.config.audioBitDepth !== 16 || !this.config.audioLittleEndian)
-            throw new Error("Deepgram node currently supports PCM-S16LE audio only")
-
-        /*  clear destruction flag  */
-        this.closing = false
-
-        /*  create queue for results  */
-        this.queue = new util.AsyncQueue<SpeechFlowChunk | null>()
-
-        /*  create a store for the meta information  */
-        const metastore = new util.TimeStore<Map<string, any>>()
+    /*  change suspended flag  */
+    async setSuspended (suspended: boolean) {
+        if (this.closing) {
+            this.log("warning", "attempted to set suspended flag on destroyed node")
+            return
+        }
+        if (suspended === this.suspended)
+            return
+        this.log("info", `switching to ${suspended ? "SUSPENDED" : "UNSUSPENDED"} operation`)
+        this.suspended = suspended
+        if (suspended) {
+            /*  going suspended -- tear down Deepgram API connection  */
+            this.reconfiguring = true
+            try {
+                await this.closeConnection()
+            }
+            finally {
+                this.reconfiguring = false
+            }
+        }
+        else {
+            /*  going unsuspended -- re-establish Deepgram API connection  */
+            await this.openConnection()
+        }
+    }
 
+    /*  open Deepgram API connection  */
+    private async openConnection () {
         /*  configure Deepgram connection options  */
         const interim     = this.params.interim as boolean
         const endpointing = this.params.endpointing as number
@@ -138,7 +154,7 @@ export default class SpeechFlowNodeA2TDeepgram extends SpeechFlowNode {
 
         /*  hook onto Deepgram API events  */
         this.dg.on(Deepgram.LiveTranscriptionEvents.Transcript, async (data) => {
-            if (this.closing || this.queue === null)
+            if (this.closing || this.queue === null || this.metastore === null)
                 return
             const text  = (data.channel?.alternatives[0]?.transcript ?? "") as string
             const words = (data.channel?.alternatives[0]?.words ?? []) as
@@ -154,12 +170,12 @@ export default class SpeechFlowNodeA2TDeepgram extends SpeechFlowNode {
                     `"${text}"`)
                 const start = Duration.fromMillis(data.start * 1000).plus(this.timeZeroOffset)
                 const end   = start.plus({ seconds: data.duration })
-                const metas = metastore.fetch(start, end)
+                const metas = this.metastore.fetch(start, end)
                 const meta = metas.toReversed().reduce((prev: Map<string, any>, curr: Map<string, any>) => {
                     curr.forEach((val, key) => { prev.set(key, val) })
                     return prev
                 }, new Map<string, any>())
-                metastore.prune(start)
+                this.metastore.prune(start)
                 meta.set("words", words.map((word) => {
                     const start = Duration.fromMillis(word.start * 1000).plus(this.timeZeroOffset)
                     const end   = Duration.fromMillis(word.end * 1000).plus(this.timeZeroOffset)
@@ -180,14 +196,11 @@ export default class SpeechFlowNodeA2TDeepgram extends SpeechFlowNode {
         })
         this.dg.on(Deepgram.LiveTranscriptionEvents.Close, () => {
             this.log("info", "connection close")
-            if (!this.closing && this.queue !== null)
-                this.queue.write(null)
-        })
-        this.dg.on(Deepgram.LiveTranscriptionEvents.Error, (error: Error) => {
-            this.log("error", `error: ${error.message}`)
-            if (!this.closing && this.queue !== null)
+            /*  NOTICE: suppress EOF signalling while reconfiguring (mute toggle),
+                since the connection is being torn down deliberately and the
+                graph must keep running  */
+            if (!this.closing && !this.reconfiguring && this.queue !== null)
                 this.queue.write(null)
-            this.emit("error", error)
         })
 
         /*  wait for Deepgram API to be available  */
@@ -215,6 +228,90 @@ export default class SpeechFlowNodeA2TDeepgram extends SpeechFlowNode {
             })
         })
 
+        /*  NOTICE: register permanent Error handler only AFTER the open
+            handshake -- during open, the transient .once above is the sole
+            Error listener so the caller's promise rejects without a parallel
+            stream emission tearing down the graph prematurely.  */
+        this.dg.on(Deepgram.LiveTranscriptionEvents.Error, (error: Error) => {
+            this.log("warning", `error: ${error.message}`)
+            /*  NOTICE: do not write null to the queue here -- a transient error
+                must not be misinterpreted as end-of-stream by downstream nodes;
+                the subsequent Deepgram Close event will signal real EOF. Also
+                do not emit("error") on the node itself, since nothing listens
+                for it and it would become an uncaughtException tearing down
+                the whole graph. Route via the stream instead, where it is
+                downgraded to a warning by the graph supervisor.  */
+            if (!this.closing && this.stream !== null)
+                this.stream.emit("error", error)
+        })
+    }
+
+    /*  close Deepgram API connection  */
+    private async closeConnection () {
+        /*  cleanup pending connection timer  */
+        if (this.connectionTimeout !== null) {
+            clearTimeout(this.connectionTimeout)
+            this.connectionTimeout = null
+        }
+
+        /*  close Deepgram connection and remove listeners  */
+        if (this.dg !== null) {
+            try {
+                this.dg.removeAllListeners()
+                this.dg.requestClose()
+                this.log("info", "connection closed")
+            }
+            catch (error) {
+                this.log("warning", `error during Deepgram cleanup: ${error}`)
+            }
+            this.dg = null
+        }
+    }
+
+    /*  one-time status of node  */
+    async status () {
+        let balance = 0
+        try {
+            const deepgram = Deepgram.createClient(this.params.keyAdm)
+            const response = await deepgram.manage.getProjects()
+            if (response !== null && response.error === null && response.result?.projects) {
+                for (const project of response.result.projects) {
+                    const balanceResponse = await deepgram.manage.getProjectBalances(project.project_id)
+                    if (balanceResponse !== null && balanceResponse.error === null && balanceResponse.result?.balances)
+                        balance += balanceResponse.result.balances[0]?.amount ?? 0
+                }
+            }
+            else if (response !== null && response.error !== null)
+                this.log("warning", `API error fetching projects: ${response.error}`)
+        }
+        catch (error) {
+            this.log("warning", `failed to fetch balance: ${error}`)
+        }
+        return { balance: balance.toFixed(2) }
+    }
+
+    /*  open node  */
+    async open () {
+        /*  sanity check situation  */
+        if (this.config.audioBitDepth !== 16 || !this.config.audioLittleEndian)
+            throw new Error("Deepgram node currently supports PCM-S16LE audio only")
+
+        /*  clear destruction flag  */
+        this.closing = false
+
+        /*  create queue for results  */
+        this.queue = new util.AsyncQueue<SpeechFlowChunk | null>()
+
+        /*  create a store for the meta information  */
+        this.metastore = new util.TimeStore<Map<string, any>>()
+
+        /*  determine initial suspended state from configuration  */
+        this.suspended = this.params.suspended as boolean
+
+        /*  establish Deepgram API connection (unless starting suspended)  */
+        if (!this.suspended)
+            await this.openConnection()
+
         /*  remember opening time to receive time zero offset  */
         this.timeOpen = DateTime.now()
 
@@ -227,7 +324,7 @@ export default class SpeechFlowNodeA2TDeepgram extends SpeechFlowNode {
             decodeStrings:      false,
             highWaterMark:      1,
             write (chunk: SpeechFlowChunk, encoding, callback) {
-                if (self.closing || self.dg === null) {
+                if (self.closing) {
                     callback(new Error("stream already destroyed"))
                     return
                 }
@@ -235,11 +332,14 @@ export default class SpeechFlowNodeA2TDeepgram extends SpeechFlowNode {
                     callback(new Error("expected audio input chunk"))
                 else if (!Buffer.isBuffer(chunk.payload))
                     callback(new Error("expected Buffer input chunk"))
+                else if (self.suspended || self.dg === null)
+                    /*  drop audio entirely -- do not forward to Deepgram  */
+                    callback()
                 else {
                     if (chunk.payload.byteLength > 0) {
                         self.log("debug", `send data (${chunk.payload.byteLength} bytes)`)
-                        if (chunk.meta.size > 0)
-                            metastore.store(chunk.timestampStart, chunk.timestampEnd, chunk.meta)
+                        if (chunk.meta.size > 0 && self.metastore !== null)
+                            self.metastore.store(chunk.timestampStart, chunk.timestampEnd, chunk.meta)
                         try {
                             /*  send buffer (and intentionally discard all time information)  */
                             self.dg.send(chunk.payload.buffer.slice(
@@ -257,17 +357,19 @@ export default class SpeechFlowNodeA2TDeepgram extends SpeechFlowNode {
             },
             async final (callback) {
                 /*  short-circuiting in case of own closing  */
-                if (self.closing || self.dg === null) {
+                if (self.closing) {
                     callback()
                     return
                 }
 
                 /*  close Deepgram API  */
-                try {
-                    self.dg.requestClose()
-                }
-                catch (error) {
-                    self.log("warning", `error closing Deepgram connection: ${error}`)
+                if (self.dg !== null) {
+                    try {
+                        self.dg.requestClose()
+                    }
+                    catch (error) {
+                        self.log("warning", `error closing Deepgram connection: ${error}`)
+                    }
                 }
 
                 /*  await all read operations  */
@@ -307,34 +409,22 @@ export default class SpeechFlowNodeA2TDeepgram extends SpeechFlowNode {
         /*  indicate closing first to stop all async operations  */
         this.closing = true
 
-        /*  cleanup all timers  */
-        if (this.connectionTimeout !== null) {
-            clearTimeout(this.connectionTimeout)
-            this.connectionTimeout = null
-        }
-
         /*  shutdown stream  */
         if (this.stream !== null) {
             await util.destroyStream(this.stream)
             this.stream = null
         }
 
-        /*  close Deepgram connection and remove listeners  */
-        if (this.dg !== null) {
-            try {
-                this.dg.removeAllListeners()
-                this.dg.requestClose()
-            }
-            catch (error) {
-                this.log("warning", `error during Deepgram cleanup: ${error}`)
-            }
-            this.dg = null
-        }
+        /*  close Deepgram API connection  */
+        await this.closeConnection()
 
         /*  signal EOF to any pending read operations  */
         if (this.queue !== null) {
             this.queue.write(null)
             this.queue = null
         }
+
+        /*  discard meta information store  */
+        this.metastore = null
     }
 }

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

@@ -190,10 +190,16 @@ export default class SpeechFlowNodeA2TGoogle extends SpeechFlowNode {
             }
         })
         this.recognizeStream.on("error", (error: Error) => {
-            this.log("error", `error: ${error.message}`)
-            if (!this.closing && this.queue !== null)
-                this.queue.write(null)
-            this.emit("error", error)
+            this.log("warning", `error: ${error.message}`)
+            /*  NOTICE: do not write null to the queue here -- a transient error
+                must not be misinterpreted as end-of-stream by downstream nodes;
+                the subsequent recognize stream end event will signal real EOF.
+                Also do not emit("error") on the node itself, since nothing
+                listens for it and it would become an uncaughtException tearing
+                down the whole graph. Route via the stream instead, where it is
+                downgraded to a warning by the graph supervisor.  */
+            if (!this.closing && this.stream !== null)
+                this.stream.emit("error", error)
         })
         this.recognizeStream.on("end", () => {
             this.log("info", "stream ended")

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

@@ -145,10 +145,16 @@ export default class SpeechFlowNodeA2TOpenAI extends SpeechFlowNode {
                 this.queue.write(null)
         })
         this.ws.on("error", (err) => {
-            this.log("error", `WebSocket connection error: ${err}`)
-            if (!this.closing && this.queue !== null)
-                this.queue.write(null)
-            this.emit("error", err)
+            this.log("warning", `WebSocket connection error: ${err}`)
+            /*  NOTICE: do not write null to the queue here -- a transient error
+                must not be misinterpreted as end-of-stream by downstream nodes;
+                the subsequent WebSocket close event will signal real EOF. Also
+                do not emit("error") on the node itself, since nothing listens
+                for it and it would become an uncaughtException tearing down
+                the whole graph. Route via the stream instead, where it is
+                downgraded to a warning by the graph supervisor.  */
+            if (!this.closing && this.stream !== null)
+                this.stream.emit("error", err)
         })
 
         /*  track speech timing by item_id (OpenAI provides timestamps via VAD events)  */

package/speechflow-cli/src/{speechflow-node-t2t-spellcheck.ts → speechflow-node-t2t-proofread.ts}

@@ -13,79 +13,65 @@ import * as util                           from "./speechflow-util"
 import { LLM, type LLMCompleteMessage }    from "./speechflow-util-llm"
 
 /*  internal utility types  */
-type ConfigEntry = { systemPrompt: string, chat: LLMCompleteMessage[] }
-type Config      = { [ key: string ]: ConfigEntry }
+type PromptParts = {
+    systemPrompt: string,
+    chat:         LLMCompleteMessage[]
+}
+type Config = { [ key: string ]: PromptParts }
 
-/*  SpeechFlow node for LLM-based text-to-text spellchecking  */
-export default class SpeechFlowNodeT2TSpellcheck extends SpeechFlowNode {
+/*  SpeechFlow node for LLM-based text-to-text proofreading  */
+export default class SpeechFlowNodeT2TProofread extends SpeechFlowNode {
     /*  declare official node name  */
-    public static name = "t2t-spellcheck"
+    public static name = "t2t-proofread"
 
     /*  internal state  */
     private llm: LLM | null = null
 
-    /*  internal LLM setup  */
+    /*  internal LLM setup: prompt parts per language  */
     private setup: Config = {
-        /*  English (EN) spellchecking  */
+        /*  English (EN) proofreading  */
         "en": {
             systemPrompt:
-                "You are a proofreader and spellchecker for English.\n" +
+                "You are a strict text corrector for English.\n" +
+                "Correct spelling, punctuation and grammar.\n" +
                 "Output only the corrected text.\n" +
-                "Do NOT use markdown.\n" +
-                "Do NOT give any explanations.\n" +
-                "Do NOT give any introduction.\n" +
-                "Do NOT give any comments.\n" +
-                "Do NOT give any preamble.\n" +
-                "Do NOT give any prolog.\n" +
-                "Do NOT give any epilog.\n" +
-                "Do NOT change the grammar.\n" +
-                "Do NOT use synonyms for words.\n" +
-                "Keep all words.\n" +
-                "Fill in missing commas.\n" +
-                "Fill in missing points.\n" +
-                "Fill in missing question marks.\n" +
-                "Fill in missing hyphens.\n" +
-                "Focus ONLY on the word spelling.\n" +
                 "The text you have to correct is:\n",
             chat: [
-                { role: "user",      content: "I luve my wyfe" },
+                { role: "user",      content: "I luve my wyfe." },
                 { role: "assistant", content: "I love my wife." },
                 { role: "user",      content: "The weether is wunderfull!" },
                 { role: "assistant", content: "The weather is wonderful!" },
-                { role: "user",      content: "The life awesome but I'm hungry." },
-                { role: "assistant", content: "The life is awesome, but I'm hungry." }
+                { role: "user",      content: "Hello how are you today" },
+                { role: "assistant", content: "Hello, how are you today?" },
+                { role: "user",      content: "I went to the store and bought some milk eggs and bread" },
+                { role: "assistant", content: "I went to the store and bought some milk, eggs, and bread." },
+                { role: "user",      content: "She don't likes apples." },
+                { role: "assistant", content: "She doesn't like apples." },
+                { role: "user",      content: "Yesterday I go to the park." },
+                { role: "assistant", content: "Yesterday I went to the park." }
             ]
         },
 
-        /*  German (DE) spellchecking  */
+        /*  German (DE) proofreading  */
         "de": {
             systemPrompt:
-                "Du bist ein Korrekturleser und Rechtschreibprüfer für Deutsch.\n" +
+                "Du bist ein strikter Textkorrektor für Deutsch.\n" +
+                "Korrigiere die Rechtschreibung, die Zeichensetzung und die Grammatik.\n" +
                 "Gib nur den korrigierten Text aus.\n" +
-                "Benutze KEIN Markdown.\n" +
-                "Gib KEINE Erklärungen.\n" +
-                "Gib KEINE Einleitung.\n" +
-                "Gib KEINE Kommentare.\n" +
-                "Gib KEINE Präambel.\n" +
-                "Gib KEINEN Prolog.\n" +
-                "Gib KEINEN Epilog.\n" +
-                "Ändere NICHT die Grammatik.\n" +
-                "Verwende KEINE Synonyme für Wörter.\n" +
-                "Behalte alle Wörter bei.\n" +
-                "Füge fehlende Kommas ein.\n" +
-                "Füge fehlende Punkte ein.\n" +
-                "Füge fehlende Fragezeichen ein.\n" +
-                "Füge fehlende Bindestriche ein.\n" +
-                "Füge fehlende Gedankenstriche ein.\n" +
-                "Fokussiere dich NUR auf die Rechtschreibung der Wörter.\n" +
                 "Der von dir zu korrigierende Text ist:\n",
             chat: [
-                { role: "user",      content: "Ich ljebe meine Frao" },
+                { role: "user",      content: "Ich ljebe meine Frao." },
                 { role: "assistant", content: "Ich liebe meine Frau." },
                 { role: "user",      content: "Die Wedter ist wunderschoen." },
                 { role: "assistant", content: "Das Wetter ist wunderschön." },
-                { role: "user",      content: "Das Leben einfach großartig aber ich bin hungrig." },
-                { role: "assistant", content: "Das Leben ist einfach großartig, aber ich bin hungrig." }
+                { role: "user",      content: "Hallo wie geht es dir heute" },
+                { role: "assistant", content: "Hallo, wie geht es dir heute?" },
+                { role: "user",      content: "Ich bin in den Laden gegangen und habe Milch Eier und Brot gekauft" },
+                { role: "assistant", content: "Ich bin in den Laden gegangen und habe Milch, Eier und Brot gekauft." },
+                { role: "user",      content: "Er gehen nach Hause." },
+                { role: "assistant", content: "Er geht nach Hause." },
+                { role: "user",      content: "Gestern ich gehe in den Park." },
+                { role: "assistant", content: "Gestern ging ich in den Park." }
             ]
         }
     }
@@ -96,17 +82,13 @@ export default class SpeechFlowNodeT2TSpellcheck extends SpeechFlowNode {
 
         /*  declare node configuration parameters  */
         this.configure({
-            lang:     { type: "string", pos: 0, val: "en",                     match: /^(?:de|en)$/ },
-            provider: { type: "string",         val: "ollama",                 match: /^(?:openai|anthropic|google|ollama|transformers)$/ },
-            api:      { type: "string",         val: "http://127.0.0.1:11434", match: /^https?:\/\/.+?(:\d+)?$/ },
-            model:    { type: "string",         val: "gemma3:4b-it-q4_K_M",    match: /^.+$/ },
-            key:      { type: "string",         val: "",                       match: /^.*$/ }
+            lang:        { type: "string",  pos: 0, val: "en",                     match: /^(?:de|en)$/ },
+            provider:    { type: "string",          val: "ollama",                 match: /^(?:openai|anthropic|google|ollama|transformers)$/ },
+            api:         { type: "string",          val: "http://127.0.0.1:11434", match: /^https?:\/\/.+?(:\d+)?$/ },
+            model:       { type: "string",          val: "gemma4:e4b",             match: /^.+$/ },
+            key:         { type: "string",          val: "",                       match: /^.*$/ }
         })
 
-        /*  tell effective mode  */
-        this.log("info", `spellchecking language "${this.params.lang}" ` +
-            `via ${this.params.provider} LLM (model: ${this.params.model})`)
-
         /*  declare node input/output format  */
         this.input  = "text"
         this.output = "text"
@@ -114,6 +96,10 @@ export default class SpeechFlowNodeT2TSpellcheck extends SpeechFlowNode {
 
     /*  open node  */
     async open () {
+        /*  tell effective mode  */
+        this.log("info", `proofreading language "${this.params.lang}" ` +
+            `via ${this.params.provider} LLM (model: ${this.params.model})`)
+
         /*  instantiate LLM  */
         this.llm = new LLM({
             provider:    this.params.provider,
@@ -127,12 +113,13 @@ export default class SpeechFlowNodeT2TSpellcheck extends SpeechFlowNode {
         })
         await this.llm.open()
 
-        /*  provide text-to-text spellchecking  */
+        /*  provide text-to-text proofreading  */
         const llm = this.llm
-        const spellcheck = async (text: string) => {
+        const proofread = async (text: string) => {
             const cfg = this.setup[this.params.lang]
             if (!cfg)
                 throw new Error(`unsupported language: ${this.params.lang}`)
+            this.log("info", `PROMPT "${cfg.systemPrompt}", chat: ${JSON.stringify(cfg.chat)}`)
             return llm.complete({
                 system:   cfg.systemPrompt,
                 messages: cfg.chat,
@@ -154,7 +141,7 @@ export default class SpeechFlowNodeT2TSpellcheck extends SpeechFlowNode {
                     callback()
                 }
                 else {
-                    spellcheck(chunk.payload).then((payload) => {
+                    proofread(chunk.payload).then((payload) => {
                         const chunkNew = chunk.clone()
                         chunkNew.payload = payload
                         this.push(chunkNew)

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

@@ -83,7 +83,7 @@ export default class SpeechFlowNodeT2TSummary extends SpeechFlowNode {
         this.configure({
             provider: { type: "string",         val: "ollama",                 match: /^(?:openai|anthropic|google|ollama|transformers)$/ },
             api:      { type: "string",         val: "http://127.0.0.1:11434", match: /^https?:\/\/.+?(:\d+)?$/ },
-            model:    { type: "string",         val: "gemma3:4b-it-q4_K_M",    match: /^.+$/ },
+            model:    { type: "string",         val: "gemma4:e4b",             match: /^.+$/ },
             key:      { type: "string",         val: "",                       match: /^.*$/ },
             lang:     { type: "string", pos: 0, val: "en",                     match: /^(?:en|de)$/ },
             size:     { type: "number", pos: 1, val: 4,                        match: (n: number) => n >= 1 && n <= 20 },

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

@@ -109,7 +109,7 @@ export default class SpeechFlowNodeT2TTranslate extends SpeechFlowNode {
             dst:      { type: "string", pos: 1, val: "en",                     match: /^(?:de|en)$/ },
             provider: { type: "string",         val: "ollama",                 match: /^(?:openai|anthropic|google|ollama|transformers)$/ },
             api:      { type: "string",         val: "http://127.0.0.1:11434", match: /^https?:\/\/.+?(:\d+)?$/ },
-            model:    { type: "string",         val: "gemma3:4b-it-q4_K_M",    match: /^.+$/ },
+            model:    { type: "string",         val: "gemma4:e4b",             match: /^.+$/ },
             key:      { type: "string",         val: "",                       match: /^.*$/ }
         })
 

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

@@ -192,7 +192,10 @@ export default class SpeechFlowNodeXIODevice extends SpeechFlowNode {
 
         /*  pass-through PortAudio errors  */
         this.io!.on("error", (err) => {
-            this.emit("error", err)
+            /*  NOTICE: do not emit("error") on the node itself, since nothing
+                listens for it and it would become an uncaughtException tearing
+                down the whole graph. Route via the stream instead, where it is
+                handled by the graph supervisor.  */
             this.stream?.emit("error", err)
         })
 

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

@@ -95,7 +95,10 @@ export default class SpeechFlowNodeXIOExec extends SpeechFlowNode {
         /*  handle subprocess errors  */
         this.subprocess.on("error", (err) => {
             this.log("error", `subprocess error: ${err.message}`)
-            this.emit("error", err)
+            /*  NOTICE: do not emit("error") on the node itself, since nothing
+                listens for it and it would become an uncaughtException tearing
+                down the whole graph. Route via the stream instead, where it is
+                handled by the graph supervisor.  */
             if (this.stream !== null && !this.stream.destroyed)
                 this.stream.emit("error", err)
         })

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

@@ -31,6 +31,7 @@ export type LLMConfig = {
     temperature?:   number
     maxTokens?:     number
     cacheDir?:      string
+    thinking?:      boolean
 }
 export type LLMCompleteOptions = {
     system?:        string
@@ -64,6 +65,7 @@ export class LLM extends EventEmitter {
             temperature:   0.7,
             maxTokens:     1024,
             cacheDir:      "",
+            thinking:      false,
             ...config
         } as Required<LLMConfig>
 
@@ -255,7 +257,8 @@ export class LLM extends EventEmitter {
                 max_tokens:  this.config.maxTokens,
                 temperature: this.config.temperature,
                 system:      systemMessage?.content,
-                messages:    chatMessages as Anthropic.MessageParam[]
+                messages:    chatMessages as Anthropic.MessageParam[],
+                ...(!this.config.thinking ? { thinking: { type: "disabled" } } : {})
             }).catch((err) => {
                 throw new Error(`failed to perform Anthropic chat completion: ${err}`, { cause: err })
             })
@@ -284,7 +287,8 @@ export class LLM extends EventEmitter {
                 config: {
                     maxOutputTokens: this.config.maxTokens,
                     temperature:     this.config.temperature,
-                    ...(systemInstruction ? { systemInstruction } : {})
+                    ...(systemInstruction ? { systemInstruction } : {}),
+                    ...(!this.config.thinking ? { thinkingConfig: { thinkingBudget: 0 } } : {})
                 }
             }).catch((err) => {
                 throw new Error(`failed to perform Google chat completion: ${err}`, { cause: err })
@@ -303,6 +307,7 @@ export class LLM extends EventEmitter {
                 model:      this.config.model,
                 messages,
                 keep_alive: "10m",
+                think:      this.config.thinking,
                 options: {
                     num_predict: this.config.maxTokens,
                     temperature: this.config.temperature