speechflow 0.9.8 → 1.0.0

package/src/speechflow-node-t2a-kokoro.ts

@@ -0,0 +1,160 @@
+/*
+**  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 { KokoroTTS }         from "kokoro-js"
+import SpeexResampler        from "speex-resampler"
+
+/*  internal dependencies  */
+import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+
+/*  SpeechFlow node for Kokoro text-to-speech conversion  */
+export default class SpeechFlowNodeKokoro extends SpeechFlowNode {
+    /*  declare official node name  */
+    public static name = "kokoro"
+
+    /*  internal state  */
+    private kokoro: KokoroTTS | null = null
+    private static speexInitialized = false
+
+    /*  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({
+            voice:    { type: "string", val: "Aoede", pos: 0, match: /^(?:Aoede|Heart|Puck|Fenrir)$/ },
+            language: { type: "string", val: "en",    pos: 1, match: /^(?:en)$/ },
+            speed:    { type: "number", val: 1.25,    pos: 2, match: (n: number) => n >= 1.0 && n <= 1.30 },
+        })
+
+        /*  declare node input/output format  */
+        this.input  = "text"
+        this.output = "audio"
+    }
+
+    /*  open node  */
+    async open () {
+        /*  establish Kokoro  */
+        const model = "onnx-community/Kokoro-82M-v1.0-ONNX"
+        const progressState = new Map<string, number>()
+        const 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 as number / progress.total as number) * 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 >= 1.0)
+                    progressState.delete(artifact)
+            }
+        }, 1000)
+        this.kokoro = await KokoroTTS.from_pretrained(model, {
+            dtype: "q4f16",
+            progress_callback: progressCallback
+        })
+        clearInterval(interval)
+        if (this.kokoro === null)
+            throw new Error("failed to instantiate Kokoro")
+
+        /*  establish resampler from Kokoro's maximum 24Khz
+            output to our standard audio sample rate (48KHz)  */
+        if (!SpeechFlowNodeKokoro.speexInitialized) {
+            /*  at least once initialize resampler  */
+            await SpeexResampler.initPromise
+            SpeechFlowNodeKokoro.speexInitialized = true
+        }
+        const resampler = new SpeexResampler(1, 24000, this.config.audioSampleRate, 7)
+
+        /*  determine voice for text-to-speech operation  */
+        const voices = {
+            "Aoede":  "af_aoede",
+            "Heart":  "af_heart",
+            "Puck":   "am_puck",
+            "Fenrir": "am_fenrir"
+        }
+        const voice = ((voices as any)[this.params.voice]) as string | undefined
+        if (voice === undefined)
+            throw new Error(`invalid Kokoro voice "${this.params.voice}"`)
+
+        /*  perform text-to-speech operation with Elevenlabs API  */
+        const text2speech = async (text: string) => {
+            this.log("info", `Kokoro: input: "${text}"`)
+            const audio = await this.kokoro!.generate(text, {
+                speed: this.params.speed,
+                voice: voice as any
+            })
+            if (audio.sampling_rate !== 24000)
+                throw new Error("expected 24KHz sampling rate in Kokoro output")
+
+            /*  convert audio samples from PCM/F32/24Khz to PCM/I16/24KHz  */
+            const samples = audio.audio
+            const buffer1 = Buffer.alloc(samples.length * 2)
+            for (let i = 0; i < samples.length; i++) {
+                const sample = Math.max(-1, Math.min(1, samples[i]))
+                buffer1.writeInt16LE(sample * 0x7FFF, i * 2)
+            }
+
+            /*  resample audio samples from PCM/I16/24Khz to PCM/I16/48KHz  */
+            const buffer2 = resampler.processChunk(buffer1)
+
+            return buffer2
+        }
+
+        /*  create transform stream and connect it to the Kokoro API  */
+        const log = (level: string, msg: string) => { this.log(level, msg) }
+        this.stream = new Stream.Transform({
+            writableObjectMode: true,
+            readableObjectMode: true,
+            decodeStrings:      false,
+            transform (chunk: SpeechFlowChunk, encoding, callback) {
+                if (Buffer.isBuffer(chunk.payload))
+                    callback(new Error("invalid chunk payload type"))
+                else {
+                    text2speech(chunk.payload).then((buffer) => {
+                        log("info", `Kokoro: received audio (buffer length: ${buffer.byteLength})`)
+                        chunk = chunk.clone()
+                        chunk.type = "audio"
+                        chunk.payload = buffer
+                        this.push(chunk)
+                        callback()
+                    }).catch((err) => {
+                        callback(err)
+                    })
+                }
+            },
+            final (callback) {
+                this.push(null)
+                callback()
+            }
+        })
+    }
+
+    /*  close node  */
+    async close () {
+        /*  destroy stream  */
+        if (this.stream !== null) {
+            this.stream.destroy()
+            this.stream = null
+        }
+
+        /*  destroy Kokoro API  */
+        if (this.kokoro !== null)
+            this.kokoro = null
+    }
+}
+

package/src/{speechflow-node-t2t-gemma.ts → speechflow-node-t2t-ollama.ts}

@@ -17,10 +17,10 @@ import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
 type ConfigEntry = { systemPrompt: string, chat: Array<{ role: string, content: string }> }
 type Config      = { [ key: string ]: ConfigEntry }
 
-/*  SpeechFlow node for Gemma/Ollama text-to-text translation  */
-export default class SpeechFlowNodeGemma extends SpeechFlowNode {
+/*  SpeechFlow node for Ollama text-to-text translation  */
+export default class SpeechFlowNodeOllama extends SpeechFlowNode {
     /*  declare official node name  */
-    public static name = "gemma"
+    public static name = "ollama"
 
     /*  internal state  */
     private ollama: Ollama | null = null
@@ -103,7 +103,8 @@ export default class SpeechFlowNodeGemma extends SpeechFlowNode {
                 "Do not show any prolog.\n" +
                 "Do not show any epilog.\n" +
                 "Get to the point.\n" +
-                "Directly translate text from Enlish (EN) to German (DE) language.\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: "system", content: "Ich liebe meine Frau." },
@@ -121,13 +122,14 @@ export default class SpeechFlowNodeGemma extends SpeechFlowNode {
                 "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 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" +
-                "Directly translate text from German (DE) to English (EN) language.\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: "system", content: "I love my wife." },
@@ -145,11 +147,19 @@ export default class SpeechFlowNodeGemma extends SpeechFlowNode {
 
         /*  declare node configuration parameters  */
         this.configure({
-            api: { type: "string", val: "http://127.0.0.1:11434", match: /^https?:\/\/.+?:\d+$/ },
-            src: { type: "string", pos: 0, val: "de", match: /^(?:de|en)$/ },
-            dst: { type: "string", pos: 1, val: "en", match: /^(?:de|en)$/ }
+            api:   { type: "string", val: "http://127.0.0.1:11434", match: /^https?:\/\/.+?:\d+$/ },
+            model: { type: "string", val: "gemma3:4b-it-q4_K_M", match: /^.+$/ },
+            src:   { type: "string", pos: 0, val: "de", match: /^(?:de|en)$/ },
+            dst:   { type: "string", pos: 1, val: "en", match: /^(?:de|en)$/ }
         })
 
+        /*  tell effective mode  */
+        if (this.params.src === this.params.dst)
+            this.log("info", `Ollama: operation mode: spellchecking for language "${this.params.src}"`)
+        else
+            this.log("info", `Ollama: operation mode: translation from language "${this.params.src}"` +
+                ` to language "${this.params.dst}"`)
+
         /*  declare node input/output format  */
         this.input  = "text"
         this.output = "text"
@@ -160,12 +170,36 @@ export default class SpeechFlowNodeGemma extends SpeechFlowNode {
         /*  instantiate Ollama API  */
         this.ollama = new Ollama({ host: this.params.api })
 
+        /*  ensure the model is available  */
+        const model  = this.params.model
+        const models = await this.ollama.list()
+        const exists = models.models.some((m) => m.name === model)
+        if (!exists) {
+            this.log("info", `Ollama: model "${model}" still not present in Ollama -- ` +
+                "automatically downloading model")
+            let artifact = ""
+            let percent  = 0
+            const interval = setInterval(() => {
+                this.log("info", `downloaded ${percent.toFixed(2)}% of artifact "${artifact}"`)
+            }, 1000)
+            const progress = await this.ollama.pull({ model, stream: true })
+            for await (const event of progress) {
+                if (event.digest)
+                    artifact = event.digest
+                if (event.completed && event.total)
+                    percent = (event.completed / event.total) * 100
+            }
+            clearInterval(interval)
+        }
+        else
+            this.log("info", `Ollama: model "${model}" already present in Ollama`)
+
         /*  provide text-to-text translation  */
         const translate = async (text: string) => {
             const key = `${this.params.src}-${this.params.dst}`
             const cfg = this.setup[key]
             const response = await this.ollama!.chat({
-                model: "gemma3:4b-it-q4_K_M",
+                model,
                 messages: [
                     { role: "system", content: cfg.systemPrompt },
                     ...cfg.chat,

package/src/speechflow-node-t2t-openai.ts

@@ -0,0 +1,246 @@
+/*
+**  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 OpenAI           from "openai"
+
+/*  internal dependencies  */
+import SpeechFlowNode, { SpeechFlowChunk } from "./speechflow-node"
+
+/*  internal utility types  */
+type ConfigEntry = { systemPrompt: string, chat: OpenAI.ChatCompletionMessageParam[] }
+type Config      = { [ key: string ]: ConfigEntry }
+
+/*  SpeechFlow node for OpenAI/GPT text-to-text translation  */
+export default class SpeechFlowNodeOpenAI extends SpeechFlowNode {
+    /*  declare official node name  */
+    public static name = "openai"
+
+    /*  internal state  */
+    private openai: OpenAI | null = null
+
+    /*  internal LLM setup  */
+    private setup: Config = {
+        /*  English (EN) spellchecking only  */
+        "en-en": {
+            systemPrompt:
+                "You are a proofreader and spellchecker for English.\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 gammar.\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: "system", content: "I love my wife." },
+                { role: "user",   content: "The weether is wunderfull!" },
+                { role: "system", content: "The weather is wonderful!" },
+                { role: "user",   content: "The live awesome but I'm hungry." },
+                { role: "system", content: "The live is awesome, but I'm hungry." }
+            ]
+        },
+
+        /*  German (DE) spellchecking only  */
+        "de-de": {
+            systemPrompt:
+                "Du bist ein Korrekturleser und Rechtschreibprüfer für Deutsch.\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 Preamble.\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: "system", content: "Ich liebe meine Frau." },
+                { role: "user",   content: "Die Wedter ist wunderschoen." },
+                { role: "system", content: "Das Wetter ist wunderschön." },
+                { role: "user",   content: "Das Leben einfach großartig aber ich bin hungrig." },
+                { role: "system", 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: "system", content: "Ich liebe meine Frau." },
+                { role: "user",   content: "The weather is wonderful." },
+                { role: "system", content: "Das Wetter ist wunderschön." },
+                { role: "user",   content: "The live is awesome." },
+                { role: "system", 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: "system", content: "I love my wife." },
+                { role: "user",   content: "Das Wetter ist wunderschön." },
+                { role: "system", content: "The weather is wonderful." },
+                { role: "user",   content: "Das Leben ist einfach großartig." },
+                { role: "system", content: "The live is awesome." }
+            ]
+        }
+    }
+
+    /*  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)$/   },
+            key:   { type: "string", val: process.env.SPEECHFLOW_KEY_OPENAI },
+            api:   { type: "string", val: "https://api.openai.com/v1", match: /^https?:\/\/.+?:\d+$/ },
+            model: { type: "string", val: "gpt-4o-mini" }
+        })
+
+        /*  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}"`)
+
+        /*  declare node input/output format  */
+        this.input  = "text"
+        this.output = "text"
+    }
+
+    /*  open node  */
+    async open () {
+        /*  instantiate OpenAI API  */
+        this.openai = new OpenAI({
+            baseURL: this.params.api,
+            apiKey:  this.params.key,
+            dangerouslyAllowBrowser: true
+        })
+
+        /*  provide text-to-text translation  */
+        const translate = async (text: string) => {
+            const key = `${this.params.src}-${this.params.dst}`
+            const cfg = this.setup[key]
+            const stream = this.openai!.chat.completions.stream({
+                stream:                true,
+                model:                 this.params.model,
+                seed:                  null,
+                temperature:           0.7,
+                n:                     1,
+                messages: [
+                    { role: "system", content: cfg.systemPrompt },
+                    ...cfg.chat,
+                    { role: "user", content: text }
+                ]
+            })
+            const completion = await stream.finalChatCompletion()
+            const translation = completion.choices[0].message.content!
+            if (!stream.ended)
+                stream.abort()
+            return translation
+        }
+
+        /*  establish a duplex stream and connect it to OpenAI  */
+        this.stream = new Stream.Transform({
+            readableObjectMode: true,
+            writableObjectMode: true,
+            decodeStrings:      false,
+            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((err) => {
+                            callback(err)
+                        })
+                    }
+                }
+            },
+            final (callback) {
+                this.push(null)
+                callback()
+            }
+        })
+    }
+
+    /*  close node  */
+    async close () {
+        /*  close stream  */
+        if (this.stream !== null) {
+            this.stream.destroy()
+            this.stream = null
+        }
+
+        /*  shutdown OpenAI  */
+        if (this.openai !== null)
+            this.openai = null
+    }
+}
+