speechflow 1.7.1 → 2.0.0

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

@@ -86,7 +86,8 @@ export default class SpeechFlowNodeT2TAmazon extends SpeechFlowNode {
                     })
                     const out = await this.client!.send(cmd)
                     return (out.TranslatedText ?? "").trim()
-                } catch (e: any) {
+                }
+                catch (e: any) {
                     lastError = e
                     attempt += 1
 

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

@@ -0,0 +1,136 @@
+/*
+**  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 path   from "node:path"
+import Stream from "node:stream"
+
+/*  external dependencies  */
+import * as Transformers from "@huggingface/transformers"
+
+/*  internal dependencies  */
+import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+import * as util                           from "./speechflow-util"
+
+/*  SpeechFlow node for OPUS text-to-text translation  */
+export default class SpeechFlowNodeT2TOPUS extends SpeechFlowNode {
+    /*  declare official node name  */
+    public static name = "t2t-opus"
+
+    /*  internal state  */
+    private translator: Transformers.TranslationPipeline | 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({
+            src: { type: "string", pos: 0, val: "de", match: /^(?:de|en)$/ },
+            dst: { type: "string", pos: 1, val: "en", match: /^(?:de|en)$/ }
+        })
+
+        /*  sanity check parameters  */
+        if (this.params.src === this.params.dst)
+            throw new Error("source and destination languages cannot be the same")
+
+        /*  declare node input/output format  */
+        this.input  = "text"
+        this.output = "text"
+    }
+
+    /*  open node  */
+    async open () {
+        /*  track download progress when instantiating Transformers engine and model  */
+        const model = `onnx-community/opus-mt-${this.params.src}-${this.params.dst}`
+        const progressState = new Map<string, number>()
+        const progressCallback: Transformers.ProgressCallback = (progress: any) => {
+            let artifact = model
+            if (typeof progress.file === "string")
+                artifact += `:${progress.file}`
+            let percent = 0
+            if (typeof progress.loaded === "number" && typeof progress.total === "number")
+                percent = (progress.loaded / progress.total) * 100
+            else if (typeof progress.progress === "number")
+                percent = progress.progress
+            if (percent > 0)
+                progressState.set(artifact, percent)
+        }
+        const interval = setInterval(() => {
+            for (const [ artifact, percent ] of progressState) {
+                this.log("info", `downloaded ${percent.toFixed(2)}% of artifact "${artifact}"`)
+                if (percent >= 100.0)
+                    progressState.delete(artifact)
+            }
+        }, 1000)
+
+        /*  instantiate Transformers engine and model  */
+        const pipeline = Transformers.pipeline("translation", model, {
+            cache_dir: path.join(this.config.cacheDir, "transformers"),
+            dtype:     "q4",
+            device:    "auto",
+            progress_callback: progressCallback
+        })
+        this.translator = await pipeline
+        if (this.translator === null)
+            throw new Error("failed to instantiate translator pipeline")
+
+        /*  clear progress interval again  */
+        clearInterval(interval)
+
+        /*  provide text-to-text translation  */
+        const translate = async (text: string) => {
+            const result = await this.translator!(text)
+            const single = Array.isArray(result) ? result[0] : result
+            return (single as Transformers.TranslationSingle).translation_text
+        }
+
+        /*  establish a duplex stream and connect it to Transformers  */
+        this.stream = new Stream.Transform({
+            readableObjectMode: true,
+            writableObjectMode: true,
+            decodeStrings:      false,
+            highWaterMark:      1,
+            transform (chunk: SpeechFlowChunk, encoding, callback) {
+                if (Buffer.isBuffer(chunk.payload))
+                    callback(new Error("invalid chunk payload type"))
+                else if (chunk.payload === "") {
+                    this.push(chunk)
+                    callback()
+                }
+                else {
+                    translate(chunk.payload).then((payload) => {
+                        const chunkNew = chunk.clone()
+                        chunkNew.payload = payload
+                        this.push(chunkNew)
+                        callback()
+                    }).catch((error: unknown) => {
+                        callback(util.ensureError(error))
+                    })
+                }
+            },
+            final (callback) {
+                callback()
+            }
+        })
+    }
+
+    /*  close node  */
+    async close () {
+        /*  shutdown stream  */
+        if (this.stream !== null) {
+            await util.destroyStream(this.stream)
+            this.stream = null
+        }
+
+        /*  shutdown Transformers  */
+        if (this.translator !== null) {
+            this.translator.dispose()
+            this.translator = null
+        }
+    }
+}
+

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

@@ -0,0 +1,93 @@
+/*
+**  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 Stream       from "node:stream"
+
+/*  external dependencies  */
+import BadWordsNext from "bad-words-next"
+import en           from "bad-words-next/lib/en"
+import de           from "bad-words-next/lib/de"
+
+/*  internal dependencies  */
+import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+import * as util                           from "./speechflow-util"
+
+/*  language data mapping  */
+const langData: { [ lang: string ]: typeof en } = { en, de }
+
+/*  SpeechFlow node for text-to-text profanity filtering  */
+export default class SpeechFlowNodeT2TProfanity extends SpeechFlowNode {
+    /*  declare official node name  */
+    public static name = "t2t-profanity"
+
+    /*  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({
+            lang:        { type: "string", val: "en", match: /^(?:en|de)$/ },
+            placeholder: { type: "string", val: "***" },
+            mode:        { type: "string", val: "replace", match: /^(?:replace|repeat)$/ }
+        })
+
+        /*  declare node input/output format  */
+        this.input  = "text"
+        this.output = "text"
+    }
+
+    /*  open node  */
+    async open () {
+        /*  create profanity filter instance  */
+        const filter = util.run("creating profanity filter", () =>
+            new BadWordsNext({
+                data:            langData[this.params.lang],
+                placeholder:     this.params.placeholder,
+                placeholderMode: this.params.mode as "replace" | "repeat"
+            })
+        )
+
+        /*  apply profanity filtering  */
+        const censor = (text: string): string =>
+            filter.filter(text)
+
+        /*  establish a transform stream and connect it to profanity filtering  */
+        this.stream = new Stream.Transform({
+            readableObjectMode: true,
+            writableObjectMode: true,
+            decodeStrings:      false,
+            highWaterMark:      1,
+            transform (chunk: SpeechFlowChunk, encoding, callback) {
+                if (Buffer.isBuffer(chunk.payload))
+                    callback(new Error("invalid chunk payload type"))
+                else if (chunk.payload === "") {
+                    this.push(chunk)
+                    callback()
+                }
+                else {
+                    const payload = censor(chunk.payload)
+                    const chunkNew = chunk.clone()
+                    chunkNew.payload = payload
+                    this.push(chunkNew)
+                    callback()
+                }
+            },
+            final (callback) {
+                callback()
+            }
+        })
+    }
+
+    /*  close node  */
+    async close () {
+        /*  shutdown stream  */
+        if (this.stream !== null) {
+            await util.destroyStream(this.stream)
+            this.stream = null
+        }
+    }
+}

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

@@ -0,0 +1,201 @@
+/*
+**  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 Stream                              from "node:stream"
+
+/*  internal dependencies  */
+import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+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 }
+
+/*  SpeechFlow node for text-to-text punctuation restoration  */
+export default class SpeechFlowNodeT2TPunctuation extends SpeechFlowNode {
+    /*  declare official node name  */
+    public static name = "t2t-punctuation"
+
+    /*  internal state  */
+    private llm: LLM | null = null
+
+    /*  internal LLM setup  */
+    private setup: Config = {
+        /*  English (EN) punctuation restoration  */
+        "en": {
+            systemPrompt:
+                "You are a punctuation restoration specialist for English.\n" +
+                "Your task is to add missing punctuation to unpunctuated text.\n" +
+                "Output only the punctuated 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 words.\n" +
+                "Do NOT add or remove words.\n" +
+                "Do NOT fix spelling errors.\n" +
+                "Do NOT change the grammar.\n" +
+                "Do NOT use synonyms.\n" +
+                "Keep all original words exactly as they are.\n" +
+                "Add periods at sentence endings.\n" +
+                "Add commas where appropriate.\n" +
+                "Add question marks for questions.\n" +
+                "Add exclamation marks where appropriate.\n" +
+                "Add colons and semicolons where appropriate.\n" +
+                "Capitalize first letters of sentences.\n" +
+                "The text you have to punctuate is:\n",
+            chat: [
+                { 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: "what time is it i need to leave soon" },
+                { role: "assistant", content: "What time is it? I need to leave soon." },
+                { role: "user",      content: "thats amazing i cant believe it worked" },
+                { role: "assistant", content: "That's amazing! I can't believe it worked!" }
+            ]
+        },
+
+        /*  German (DE) punctuation restoration  */
+        "de": {
+            systemPrompt:
+                "Du bist ein Spezialist für Zeichensetzung im Deutschen.\n" +
+                "Deine Aufgabe ist es, fehlende Satzzeichen in unpunktierten Text einzufügen.\n" +
+                "Gib nur den punktierten Text aus.\n" +
+                "Benutze KEIN Markdown.\n" +
+                "Gib KEINE Erklärungen.\n" +
+                "Gib KEINE Einleitung.\n" +
+                "Gib KEINE Kommentare.\n" +
+                "Gib KEINE Preamble.\n" +
+                "Gib KEINEN Prolog.\n" +
+                "Gib KEINEN Epilog.\n" +
+                "Ändere NICHT die Wörter.\n" +
+                "Füge KEINE Wörter hinzu oder entferne welche.\n" +
+                "Korrigiere KEINE Rechtschreibfehler.\n" +
+                "Ändere NICHT die Grammatik.\n" +
+                "Verwende KEINE Synonyme.\n" +
+                "Behalte alle ursprünglichen Wörter genau bei.\n" +
+                "Füge Punkte am Satzende ein.\n" +
+                "Füge Kommas an passenden Stellen ein.\n" +
+                "Füge Fragezeichen bei Fragen ein.\n" +
+                "Füge Ausrufezeichen an passenden Stellen ein.\n" +
+                "Füge Doppelpunkte und Semikolons an passenden Stellen ein.\n" +
+                "Großschreibe die ersten Buchstaben von Sätzen.\n" +
+                "Der von dir zu punktierende Text ist:\n",
+            chat: [
+                { 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: "wie spät ist es ich muss bald los" },
+                { role: "assistant", content: "Wie spät ist es? Ich muss bald los." },
+                { role: "user",      content: "das ist fantastisch ich kann nicht glauben dass es funktioniert hat" },
+                { role: "assistant", content: "Das ist fantastisch! Ich kann nicht glauben, dass es funktioniert hat!" }
+            ]
+        }
+    }
+
+    /*  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({
+            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)$/ }
+        })
+
+        /*  tell effective mode  */
+        this.log("info", `punctuation restoration for language "${this.params.lang}" ` +
+            `via ${this.params.provider} LLM (model: ${this.params.model})`)
+
+        /*  declare node input/output format  */
+        this.input  = "text"
+        this.output = "text"
+    }
+
+    /*  open node  */
+    async open () {
+        /*  instantiate LLM  */
+        this.llm = new LLM({
+            provider:    this.params.provider,
+            api:         this.params.api,
+            model:       this.params.model,
+            key:         this.params.key,
+            temperature: 0.7,
+            topP:        0.5
+        })
+        this.llm.on("log", (level: string, message: string) => {
+            this.log(level as "info" | "warning" | "error", message)
+        })
+        await this.llm.open()
+
+        /*  provide text-to-text punctuation restoration  */
+        const llm = this.llm!
+        const punctuate = async (text: string) => {
+            const cfg = this.setup[this.params.lang]
+            if (!cfg)
+                throw new Error(`unsupported language: ${this.params.lang}`)
+            return llm.complete({
+                system:   cfg.systemPrompt,
+                messages: cfg.chat,
+                prompt:   text
+            })
+        }
+
+        /*  establish a transform stream for punctuation restoration  */
+        this.stream = new Stream.Transform({
+            readableObjectMode: true,
+            writableObjectMode: true,
+            decodeStrings:      false,
+            highWaterMark:      1,
+            transform (chunk: SpeechFlowChunk, encoding, callback) {
+                if (Buffer.isBuffer(chunk.payload))
+                    callback(new Error("invalid chunk payload type"))
+                else if (chunk.payload === "") {
+                    this.push(chunk)
+                    callback()
+                }
+                else {
+                    punctuate(chunk.payload).then((payload) => {
+                        const chunkNew = chunk.clone()
+                        chunkNew.payload = payload
+                        this.push(chunkNew)
+                        callback()
+                    }).catch((error: unknown) => {
+                        callback(util.ensureError(error))
+                    })
+                }
+            },
+            final (callback) {
+                callback()
+            }
+        })
+    }
+
+    /*  close node  */
+    async close () {
+        /*  shutdown stream  */
+        if (this.stream !== null) {
+            await util.destroyStream(this.stream)
+            this.stream = null
+        }
+
+        /*  shutdown LLM  */
+        if (this.llm !== null) {
+            await this.llm.close()
+            this.llm = null
+        }
+    }
+}

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

@@ -5,31 +5,29 @@
 */
 
 /*  standard dependencies  */
-import Stream from "node:stream"
-
-/*  external dependencies  */
-import OpenAI from "openai"
+import Stream                              from "node:stream"
 
 /*  internal dependencies  */
 import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
 import * as util                           from "./speechflow-util"
+import { LLM, type LLMCompleteMessage }    from "./speechflow-util-llm"
 
 /*  internal utility types  */
-type ConfigEntry = { systemPrompt: string, chat: OpenAI.ChatCompletionMessageParam[] }
+type ConfigEntry = { systemPrompt: string, chat: LLMCompleteMessage[] }
 type Config      = { [ key: string ]: ConfigEntry }
 
-/*  SpeechFlow node for OpenAI/GPT text-to-text translation  */
-export default class SpeechFlowNodeT2TOpenAI extends SpeechFlowNode {
+/*  SpeechFlow node for LLM-based text-to-text spellchecking  */
+export default class SpeechFlowNodeT2TSpellcheck extends SpeechFlowNode {
     /*  declare official node name  */
-    public static name = "t2t-openai"
+    public static name = "t2t-spellcheck"
 
     /*  internal state  */
-    private openai: OpenAI | null = null
+    private llm: LLM | null = null
 
     /*  internal LLM setup  */
     private setup: Config = {
-        /*  English (EN) spellchecking only  */
-        "en-en": {
+        /*  English (EN) spellchecking  */
+        "en": {
             systemPrompt:
                 "You are a proofreader and spellchecker for English.\n" +
                 "Output only the corrected text.\n" +
@@ -59,8 +57,8 @@ export default class SpeechFlowNodeT2TOpenAI extends SpeechFlowNode {
             ]
         },
 
-        /*  German (DE) spellchecking only  */
-        "de-de": {
+        /*  German (DE) spellchecking  */
+        "de": {
             systemPrompt:
                 "Du bist ein Korrekturleser und Rechtschreibprüfer für Deutsch.\n" +
                 "Gib nur den korrigierten Text aus.\n" +
@@ -89,56 +87,6 @@ export default class SpeechFlowNodeT2TOpenAI extends SpeechFlowNode {
                 { 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." }
             ]
-        },
-
-        /*  English (EN) to German (DE) translation  */
-        "en-de": {
-            systemPrompt:
-                "You are a translator.\n" +
-                "Output only the requested text.\n" +
-                "Do not use markdown.\n" +
-                "Do not chat.\n" +
-                "Do not show any explanations.\n" +
-                "Do not show any introduction.\n" +
-                "Do not show any preamble.\n" +
-                "Do not show any prolog.\n" +
-                "Do not show any epilog.\n" +
-                "Get to the point.\n" +
-                "Preserve the original meaning, tone, and nuance.\n" +
-                "Directly translate text from English (EN) to fluent and natural German (DE) language.\n",
-            chat: [
-                { role: "user",      content: "I love my wife." },
-                { role: "assistant", content: "Ich liebe meine Frau." },
-                { role: "user",      content: "The weather is wonderful." },
-                { role: "assistant", content: "Das Wetter ist wunderschön." },
-                { role: "user",      content: "The life is awesome." },
-                { role: "assistant", content: "Das Leben ist einfach großartig." }
-            ]
-        },
-
-        /*  German (DE) to English (EN) translation  */
-        "de-en": {
-            systemPrompt:
-                "You are a translator.\n" +
-                "Output only the requested text.\n" +
-                "Do not use markdown.\n" +
-                "Do not chat.\n" +
-                "Do not show any explanations.\n" +
-                "Do not show any introduction.\n" +
-                "Do not show any preamble.\n" +
-                "Do not show any prolog.\n" +
-                "Do not show any epilog.\n" +
-                "Get to the point.\n" +
-                "Preserve the original meaning, tone, and nuance.\n" +
-                "Directly translate text from German (DE) to fluent and natural English (EN) language.\n",
-            chat: [
-                { role: "user",      content: "Ich liebe meine Frau." },
-                { role: "assistant", content: "I love my wife." },
-                { role: "user",      content: "Das Wetter ist wunderschön." },
-                { role: "assistant", content: "The weather is wonderful." },
-                { role: "user",      content: "Das Leben ist einfach großartig." },
-                { role: "assistant", content: "The life is awesome." }
-            ]
         }
     }
 
@@ -148,19 +96,16 @@ export default class SpeechFlowNodeT2TOpenAI extends SpeechFlowNode {
 
         /*  declare node configuration parameters  */
         this.configure({
-            src:   { type: "string", pos: 0, val: "de",                              match: /^(?:de|en)$/ },
-            dst:   { type: "string", pos: 1, val: "en",                              match: /^(?:de|en)$/ },
-            key:   { type: "string",         val: process.env.SPEECHFLOW_OPENAI_KEY, match: /^.+$/ },
-            api:   { type: "string",         val: "https://api.openai.com/v1",       match: /^https?:\/\/.+/ },
-            model: { type: "string",         val: "gpt-5-mini",                      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: "gemma3:4b-it-q4_K_M",    match: /^.+$/ },
+            key:      { type: "string",         val: "",                       match: /^.*$/ }
         })
 
         /*  tell effective mode  */
-        if (this.params.src === this.params.dst)
-            this.log("info", `OpenAI: operation mode: spellchecking for language "${this.params.src}"`)
-        else
-            this.log("info", `OpenAI: operation mode: translation from language "${this.params.src}"` +
-                ` to language "${this.params.dst}"`)
+        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"
@@ -169,39 +114,34 @@ export default class SpeechFlowNodeT2TOpenAI extends SpeechFlowNode {
 
     /*  open node  */
     async open () {
-        /*  validate API key  */
-        if (!this.params.key)
-            throw new Error("OpenAI API key is required")
-
-        /*  instantiate OpenAI API  */
-        this.openai = new OpenAI({
-            baseURL: this.params.api,
-            apiKey:  this.params.key,
-            timeout: 30000
+        /*  instantiate LLM  */
+        this.llm = new LLM({
+            provider:    this.params.provider,
+            api:         this.params.api,
+            model:       this.params.model,
+            key:         this.params.key,
+            temperature: 0.7,
+            topP:        0.5
         })
-
-        /*  provide text-to-text translation  */
-        const translate = async (text: string) => {
-            const key = `${this.params.src}-${this.params.dst}`
-            const cfg = this.setup[key]
-            if (!this.openai)
-                throw new Error("OpenAI client not available")
-            const completion = await this.openai.chat.completions.create({
-                model:       this.params.model,
-                temperature: this.params.model.endsWith("-mini") ? 1.0 : 0.7,
-                messages: [
-                    { role: "system", content: cfg.systemPrompt },
-                    ...cfg.chat,
-                    { role: "user", content: text }
-                ]
+        this.llm.on("log", (level: string, message: string) => {
+            this.log(level as "info" | "warning" | "error", message)
+        })
+        await this.llm.open()
+
+        /*  provide text-to-text spellchecking  */
+        const llm = this.llm!
+        const spellcheck = async (text: string) => {
+            const cfg = this.setup[this.params.lang]
+            if (!cfg)
+                throw new Error(`unsupported language: ${this.params.lang}`)
+            return llm.complete({
+                system:   cfg.systemPrompt,
+                messages: cfg.chat,
+                prompt:   text
             })
-            const content = completion?.choices?.[0]?.message?.content
-            if (!content)
-                throw new Error("OpenAI API returned empty content")
-            return content
         }
 
-        /*  establish a duplex stream and connect it to OpenAI  */
+        /*  establish a transform stream and connect it to LLM  */
         this.stream = new Stream.Transform({
             readableObjectMode: true,
             writableObjectMode: true,
@@ -215,7 +155,7 @@ export default class SpeechFlowNodeT2TOpenAI extends SpeechFlowNode {
                     callback()
                 }
                 else {
-                    translate(chunk.payload).then((payload) => {
+                    spellcheck(chunk.payload).then((payload) => {
                         const chunkNew = chunk.clone()
                         chunkNew.payload = payload
                         this.push(chunkNew)
@@ -239,9 +179,10 @@ export default class SpeechFlowNodeT2TOpenAI extends SpeechFlowNode {
             this.stream = null
         }
 
-        /*  shutdown OpenAI  */
-        if (this.openai !== null)
-            this.openai = null
+        /*  shutdown LLM  */
+        if (this.llm !== null) {
+            await this.llm.close()
+            this.llm = null
+        }
     }
 }
-