speechflow 0.9.8 → 0.9.9

package/dst/speechflow-node-t2t-openai.js

@@ -0,0 +1,225 @@
+"use strict";
+/*
+**  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>
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*  standard dependencies  */
+const node_stream_1 = __importDefault(require("node:stream"));
+/*  external dependencies  */
+const openai_1 = __importDefault(require("openai"));
+/*  internal dependencies  */
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+/*  SpeechFlow node for OpenAI/GPT text-to-text translation  */
+class SpeechFlowNodeOpenAI extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "openai";
+    /*  internal state  */
+    openai = null;
+    /*  internal LLM setup  */
+    setup = {
+        /*  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, cfg, opts, args) {
+        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_1.default({
+            baseURL: this.params.api,
+            apiKey: this.params.key,
+            dangerouslyAllowBrowser: true
+        });
+        /*  provide text-to-text translation  */
+        const translate = async (text) => {
+            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 node_stream_1.default.Transform({
+            readableObjectMode: true,
+            writableObjectMode: true,
+            decodeStrings: false,
+            transform(chunk, 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;
+    }
+}
+exports.default = SpeechFlowNodeOpenAI;

package/dst/speechflow-node-t2t-opus.js

@@ -87,7 +87,7 @@ class SpeechFlowNodeOPUS extends speechflow_node_1.default {
                 result[0].translation_text :
                 result.translation_text;
         };
-        /*  establish a duplex stream and connect it to Ollama  */
+        /*  establish a duplex stream and connect it to OPUS  */
         this.stream = new node_stream_1.default.Transform({
             readableObjectMode: true,
             writableObjectMode: true,

package/dst/speechflow-node-t2t-transformers.d.ts

@@ -0,0 +1,14 @@
+import SpeechFlowNode from "./speechflow-node";
+export default class SpeechFlowNodeTransformers extends SpeechFlowNode {
+    static name: string;
+    private translator;
+    private generator;
+    private setup;
+    constructor(id: string, cfg: {
+        [id: string]: any;
+    }, opts: {
+        [id: string]: any;
+    }, args: any[]);
+    open(): Promise<void>;
+    close(): Promise<void>;
+}

package/dst/speechflow-node-t2t-transformers.js

@@ -0,0 +1,260 @@
+"use strict";
+/*
+**  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>
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*  standard dependencies  */
+const node_path_1 = __importDefault(require("node:path"));
+const node_stream_1 = __importDefault(require("node:stream"));
+/*  external dependencies  */
+const Transformers = __importStar(require("@huggingface/transformers"));
+/*  internal dependencies  */
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+/*  SpeechFlow node for Transformers text-to-text translation  */
+class SpeechFlowNodeTransformers extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "transformers";
+    /*  internal state  */
+    translator = null;
+    generator = null;
+    /*  internal LLM setup  */
+    setup = {
+        /*  SmolLM3: English (EN) to German (DE) translation  */
+        "SmolLM3:en-de": {
+            systemPrompt: "/no_think\n" +
+                "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 live is awesome." },
+                { role: "assistant", content: "Das Leben ist einfach großartig." }
+            ]
+        },
+        /*  SmolLM3: German (DE) to English (EN) translation  */
+        "SmolLM3:de-en": {
+            systemPrompt: "/no_think\n" +
+                "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 live is awesome." }
+            ]
+        }
+    };
+    /*  construct node  */
+    constructor(id, cfg, opts, args) {
+        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)$/ },
+            model: { type: "string", val: "OPUS", match: /^(?:OPUS|SmolLM3)$/ }
+        });
+        /*  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() {
+        /*  instantiate Transformers engine and model  */
+        let model = "";
+        const progressState = new Map();
+        const progressCallback = (progress) => {
+            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 >= 1.0)
+                    progressState.delete(artifact);
+            }
+        }, 1000);
+        if (this.params.model === "OPUS") {
+            model = `onnx-community/opus-mt-${this.params.src}-${this.params.dst}`;
+            this.translator = await Transformers.pipeline("translation", model, {
+                cache_dir: node_path_1.default.join(this.config.cacheDir, "opus"),
+                dtype: "q4",
+                device: "gpu",
+                progress_callback: progressCallback
+            });
+            clearInterval(interval);
+            if (this.translator === null)
+                throw new Error("failed to instantiate translator pipeline");
+        }
+        else if (this.params.model === "SmolLM3") {
+            model = "HuggingFaceTB/SmolLM3-3B-ONNX";
+            this.generator = await Transformers.pipeline("text-generation", model, {
+                cache_dir: node_path_1.default.join(this.config.cacheDir, "transformers"),
+                dtype: "q4",
+                device: "gpu",
+                progress_callback: progressCallback
+            });
+            clearInterval(interval);
+            if (this.generator === null)
+                throw new Error("failed to instantiate generator pipeline");
+        }
+        else
+            throw new Error("invalid model");
+        /*  provide text-to-text translation  */
+        const translate = async (text) => {
+            if (this.params.model === "OPUS") {
+                const result = await this.translator(text);
+                return Array.isArray(result) ?
+                    result[0].translation_text :
+                    result.translation_text;
+            }
+            else if (this.params.model === "SmolLM3") {
+                const key = `SmolLM3:${this.params.src}-${this.params.dst}`;
+                const cfg = this.setup[key];
+                const messages = [
+                    { role: "system", content: cfg.systemPrompt },
+                    ...cfg.chat,
+                    { role: "user", content: text }
+                ];
+                const result = await this.generator(messages, {
+                    max_new_tokens: 100,
+                    temperature: 0.6,
+                    top_p: 0.95,
+                    streamer: new Transformers.TextStreamer(this.generator.tokenizer, {
+                        skip_prompt: true,
+                        skip_special_tokens: true
+                    })
+                });
+                const generatedText = Array.isArray(result) ?
+                    result[0].generated_text :
+                    result.generated_text;
+                const response = typeof generatedText === "string" ?
+                    generatedText :
+                    generatedText.at(-1).content;
+                return response;
+            }
+            else
+                throw new Error("invalid model");
+        };
+        /*  establish a duplex stream and connect it to Transformers  */
+        this.stream = new node_stream_1.default.Transform({
+            readableObjectMode: true,
+            writableObjectMode: true,
+            decodeStrings: false,
+            transform(chunk, 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) => {
+                            chunk = chunk.clone();
+                            chunk.payload = payload;
+                            this.push(chunk);
+                            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 Transformers  */
+        if (this.translator !== null) {
+            this.translator.dispose();
+            this.translator = null;
+        }
+        if (this.generator !== null) {
+            this.generator.dispose();
+            this.generator = null;
+        }
+    }
+}
+exports.default = SpeechFlowNodeTransformers;

package/dst/speechflow-node-x2x-trace.js

@@ -48,7 +48,7 @@ class SpeechFlowNodeTrace extends speechflow_node_1.default {
                 const fmt = (t) => t.toFormat("hh:mm:ss.SSS");
                 if (Buffer.isBuffer(chunk.payload)) {
                     if (type === "audio")
-                        log("info", `writing ${type} chunk: start=${fmt(chunk.timestampStart)} ` +
+                        log("debug", `writing ${type} chunk: start=${fmt(chunk.timestampStart)} ` +
                             `end=${fmt(chunk.timestampEnd)} kind=${chunk.kind} type=${chunk.type} ` +
                             `payload-type=Buffer payload-bytes=${chunk.payload.byteLength}`);
                     else
@@ -56,7 +56,7 @@ class SpeechFlowNodeTrace extends speechflow_node_1.default {
                 }
                 else {
                     if (type === "text")
-                        log("info", `writing ${type} chunk: start=${fmt(chunk.timestampStart)} ` +
+                        log("debug", `writing ${type} chunk: start=${fmt(chunk.timestampStart)} ` +
                             `end=${fmt(chunk.timestampEnd)} kind=${chunk.kind} type=${chunk.type}` +
                             `payload-type=String payload-length=${chunk.payload.length} ` +
                             `payload-encoding=${encoding} payload-content="${chunk.payload.toString()}"`);