speechflow 0.9.5 → 0.9.7

package/dst/speechflow-node-gemma.js

@@ -10,7 +10,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 /*  standard dependencies  */
 const node_stream_1 = __importDefault(require("node:stream"));
-const node_events_1 = require("node:events");
 /*  external dependencies  */
 const ollama_1 = require("ollama");
 /*  internal dependencies  */
@@ -23,6 +22,65 @@ class SpeechFlowNodeGemma extends speechflow_node_1.default {
     ollama = 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" +
@@ -69,17 +127,14 @@ class SpeechFlowNodeGemma extends speechflow_node_1.default {
         }
     };
     /*  construct node  */
-    constructor(id, opts, args) {
-        super(id, opts, args);
+    constructor(id, cfg, opts, args) {
+        super(id, cfg, opts, args);
         /*  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)$/ }
         });
-        /*  sanity check situation  */
-        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";
@@ -111,27 +166,33 @@ class SpeechFlowNodeGemma extends speechflow_node_1.default {
             return response.message.content;
         };
         /*  establish a duplex stream and connect it to Ollama  */
-        const queue = new node_events_1.EventEmitter();
-        this.stream = new node_stream_1.default.Duplex({
-            write(chunk, encoding, callback) {
-                const data = chunk.toString();
-                if (data === "") {
-                    queue.emit("result", "");
-                    callback();
-                }
+        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 {
-                    translate(data).then((result) => {
-                        queue.emit("result", result);
+                    if (chunk.payload === "") {
+                        this.push(chunk);
                         callback();
-                    }).catch((err) => {
-                        callback(err);
-                    });
+                    }
+                    else {
+                        translate(chunk.payload).then((payload) => {
+                            const chunkNew = chunk.clone();
+                            chunkNew.payload = payload;
+                            this.push(chunkNew);
+                            callback();
+                        }).catch((err) => {
+                            callback(err);
+                        });
+                    }
                 }
             },
-            read(size) {
-                queue.once("result", (result) => {
-                    this.push(result);
-                });
+            final(callback) {
+                this.push(null);
+                callback();
             }
         });
     }

package/dst/speechflow-node-mqtt.d.ts

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

package/dst/speechflow-node-mqtt.js

@@ -0,0 +1,181 @@
+"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_stream_1 = __importDefault(require("node:stream"));
+/*  external dependencies  */
+const mqtt_1 = __importDefault(require("mqtt"));
+const pure_uuid_1 = __importDefault(require("pure-uuid"));
+/*  internal dependencies  */
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+const utils = __importStar(require("./speechflow-utils"));
+/*  SpeechFlow node for MQTT networking  */
+class SpeechFlowNodeMQTT extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "mqtt";
+    /*  internal state  */
+    broker = null;
+    clientId = (new pure_uuid_1.default(1)).format();
+    /*  construct node  */
+    constructor(id, cfg, opts, args) {
+        super(id, cfg, opts, args);
+        /*  declare node configuration parameters  */
+        this.configure({
+            url: { type: "string", pos: 0, val: "", match: /^(?:|(?:ws|mqtt):\/\/(.+?):(\d+)(?:\/.*)?)$/ },
+            username: { type: "string", pos: 1, val: "", match: /^.+$/ },
+            password: { type: "string", pos: 2, val: "", match: /^.+$/ },
+            topicRead: { type: "string", pos: 3, val: "", match: /^.+$/ },
+            topicWrite: { type: "string", pos: 4, val: "", match: /^.+$/ },
+            mode: { type: "string", pos: 5, val: "w", match: /^(?:r|w|rw)$/ },
+            type: { type: "string", pos: 6, val: "text", match: /^(?:audio|text)$/ }
+        });
+        /*  logical parameter sanity check  */
+        if ((this.params.mode === "w" || this.params.mode === "rw") && this.params.topicWrite === "")
+            throw new Error("writing to MQTT requires a topicWrite parameter");
+        if ((this.params.mode === "r" || this.params.mode === "rw") && this.params.topicRead === "")
+            throw new Error("reading from MQTT requires a topicRead parameter");
+        /*  declare node input/output format  */
+        if (this.params.mode === "rw") {
+            this.input = this.params.type;
+            this.output = this.params.type;
+        }
+        else if (this.params.mode === "r") {
+            this.input = "none";
+            this.output = this.params.type;
+        }
+        else if (this.params.mode === "w") {
+            this.input = this.params.type;
+            this.output = "none";
+        }
+    }
+    /*  open node  */
+    async open() {
+        /*  connect remotely to a MQTT broker  */
+        this.broker = mqtt_1.default.connect(this.params.url, {
+            protocolId: "MQTT",
+            protocolVersion: 5,
+            username: this.params.username,
+            password: this.params.password,
+            clientId: this.clientId,
+            clean: true,
+            resubscribe: true,
+            keepalive: 60, /* 60s */
+            reconnectPeriod: 2 * 1000, /*  2s */
+            connectTimeout: 30 * 1000 /* 30s */
+        });
+        this.broker.on("error", (error) => {
+            this.log("error", `error on MQTT ${this.params.url}: ${error.message}`);
+        });
+        this.broker.on("connect", (packet) => {
+            this.log("info", `connection opened to MQTT ${this.params.url}`);
+            if (this.params.mode !== "w" && !packet.sessionPresent)
+                this.broker.subscribe([this.params.topicRead], () => { });
+        });
+        this.broker.on("reconnect", () => {
+            this.log("info", `connection re-opened to MQTT ${this.params.url}`);
+        });
+        this.broker.on("disconnect", (packet) => {
+            this.log("info", `connection closed to MQTT ${this.params.url}`);
+        });
+        const chunkQueue = new utils.SingleQueue();
+        this.broker.on("message", (topic, payload, packet) => {
+            if (topic !== this.params.topicRead)
+                return;
+            try {
+                const chunk = utils.streamChunkDecode(payload);
+                chunkQueue.write(chunk);
+            }
+            catch (_err) {
+                this.log("warning", `received invalid CBOR chunk from MQTT ${this.params.url}`);
+            }
+        });
+        const broker = this.broker;
+        const topicWrite = this.params.topicWrite;
+        const type = this.params.type;
+        const mode = this.params.mode;
+        this.stream = new node_stream_1.default.Duplex({
+            writableObjectMode: true,
+            readableObjectMode: true,
+            decodeStrings: false,
+            write(chunk, encoding, callback) {
+                if (mode === "r")
+                    callback(new Error("write operation on read-only node"));
+                else if (chunk.type !== type)
+                    callback(new Error(`written chunk is not of ${type} type`));
+                else if (!broker.connected)
+                    callback(new Error("still no MQTT connection available"));
+                else {
+                    const data = Buffer.from(utils.streamChunkEncode(chunk));
+                    broker.publish(topicWrite, data, { qos: 2, retain: false }, (err) => {
+                        if (err)
+                            callback(new Error(`failed to publish to MQTT topic "${topicWrite}": ${err}`));
+                        else
+                            callback();
+                    });
+                }
+            },
+            read(size) {
+                if (mode === "w")
+                    throw new Error("read operation on write-only node");
+                chunkQueue.read().then((chunk) => {
+                    this.push(chunk, "binary");
+                });
+            }
+        });
+    }
+    /*  close node  */
+    async close() {
+        /*  close Websocket server  */
+        if (this.broker !== null) {
+            if (this.broker.connected)
+                this.broker.end();
+            this.broker = null;
+        }
+        /*  close stream  */
+        if (this.stream !== null) {
+            this.stream.destroy();
+            this.stream = null;
+        }
+    }
+}
+exports.default = SpeechFlowNodeMQTT;

package/dst/speechflow-node-opus.d.ts

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

package/dst/speechflow-node-opus.js

@@ -0,0 +1,135 @@
+"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 OPUS text-to-text translation  */
+class SpeechFlowNodeOPUS extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "opus";
+    /*  internal state  */
+    translator = null;
+    /*  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)$/ }
+        });
+        /*  sanity check situation  */
+        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 OPUS  */
+        const 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"
+        });
+        if (this.translator === null)
+            throw new Error("failed to instantiate translator pipeline");
+        /*  provide text-to-text translation  */
+        const translate = async (text) => {
+            const result = await this.translator(text);
+            return Array.isArray(result) ?
+                result[0].translation_text :
+                result.translation_text;
+        };
+        /*  establish a duplex stream and connect it to Ollama  */
+        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 OPUS  */
+        if (this.translator !== null) {
+            this.translator.dispose();
+            this.translator = null;
+        }
+    }
+}
+exports.default = SpeechFlowNodeOPUS;

package/dst/speechflow-node-subtitle.d.ts

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

package/dst/speechflow-node-subtitle.js

@@ -0,0 +1,96 @@
+"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"));
+/*  internal dependencies  */
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+/*  SpeechFlow node for subtitle (text-to-text) "translations"  */
+class SpeechFlowNodeSubtitle extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "subtitle";
+    /*  internal state  */
+    sequenceNo = 1;
+    /*  construct node  */
+    constructor(id, cfg, opts, args) {
+        super(id, cfg, opts, args);
+        /*  declare node configuration parameters  */
+        this.configure({
+            format: { type: "string", pos: 0, val: "srt", match: /^(?:srt|vtt)$/ }
+        });
+        /*  declare node input/output format  */
+        this.input = "text";
+        this.output = "text";
+    }
+    /*  open node  */
+    async open() {
+        this.sequenceNo = 1;
+        /*  provide text-to-subtitle conversion  */
+        const convert = async (chunk) => {
+            if (typeof chunk.payload !== "string")
+                throw new Error("chunk payload type must be string");
+            let text = chunk.payload;
+            if (this.params.format === "srt") {
+                const start = chunk.timestampStart.toFormat("hh:mm:ss,SSS");
+                const end = chunk.timestampEnd.toFormat("hh:mm:ss,SSS");
+                text = `${this.sequenceNo++}\n` +
+                    `${start} --> ${end}\n` +
+                    `${text}\n\n`;
+            }
+            else if (this.params.format === "vtt") {
+                const start = chunk.timestampStart.toFormat("hh:mm:ss.SSS");
+                const end = chunk.timestampEnd.toFormat("hh:mm:ss.SSS");
+                text = `${this.sequenceNo++}\n` +
+                    `${start} --> ${end}\n` +
+                    `${text}\n\n`;
+            }
+            return text;
+        };
+        /*  establish a duplex stream  */
+        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 {
+                        convert(chunk).then((payload) => {
+                            const chunkNew = chunk.clone();
+                            chunkNew.payload = payload;
+                            this.push(chunkNew);
+                            callback();
+                        }).catch((err) => {
+                            callback(err);
+                        });
+                    }
+                }
+            },
+            final(callback) {
+                this.push(null);
+                callback();
+            }
+        });
+    }
+    /*  open node  */
+    async close() {
+        /*  close stream  */
+        if (this.stream !== null) {
+            this.stream.destroy();
+            this.stream = null;
+        }
+    }
+}
+exports.default = SpeechFlowNodeSubtitle;

package/dst/speechflow-node-t2a-elevenlabs.d.ts

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