speechflow 0.9.4 → 0.9.7

package/dst/speechflow-node-t2a-elevenlabs.js

@@ -0,0 +1,182 @@
+"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 ElevenLabs = __importStar(require("@elevenlabs/elevenlabs-js"));
+const get_stream_1 = require("get-stream");
+const speex_resampler_1 = __importDefault(require("speex-resampler"));
+/*  internal dependencies  */
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+/*  SpeechFlow node for Elevenlabs text-to-speech conversion  */
+class SpeechFlowNodeElevenlabs extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "elevenlabs";
+    /*  internal state  */
+    elevenlabs = null;
+    static speexInitialized = false;
+    /*  construct node  */
+    constructor(id, cfg, opts, args) {
+        super(id, cfg, opts, args);
+        /*  declare node configuration parameters  */
+        this.configure({
+            key: { type: "string", val: process.env.SPEECHFLOW_KEY_ELEVENLABS },
+            voice: { type: "string", val: "Brian", pos: 0, match: /^(?:.+)$/ },
+            language: { type: "string", val: "en", pos: 1, match: /^(?:de|en)$/ },
+            speed: { type: "number", val: 1.05, pos: 2, match: (n) => n >= 0.7 && n <= 1.2 },
+            optimize: { type: "string", val: "latency", pos: 3, match: /^(?:latency|quality)$/ }
+        });
+        /*  declare node input/output format  */
+        this.input = "text";
+        this.output = "audio";
+    }
+    /*  open node  */
+    async open() {
+        /*  establish ElevenLabs API connection  */
+        this.elevenlabs = new ElevenLabs.ElevenLabsClient({
+            apiKey: this.params.key
+        });
+        /*  determine maximum sample rate of ElevenLabs tier  */
+        const maxSampleRates = {
+            "free": 16000,
+            "starter": 22050,
+            "creator": 24000,
+            "independent_publisher": 44100,
+            "growing_business": 44100,
+            "enterprise": 44100
+        };
+        const sub = await this.elevenlabs.user.subscription.get();
+        const tier = (sub.tier ?? "free");
+        this.log("info", `determined ElevenLabs tier: "${tier}"`);
+        let maxSampleRate = 16000;
+        if (maxSampleRates[tier] !== undefined)
+            maxSampleRate = maxSampleRates[tier];
+        this.log("info", `determined maximum audio sample rate: ${maxSampleRate}`);
+        /*  determine voice for text-to-speech operation
+            (for details see https://elevenlabs.io/text-to-speech)  */
+        const voices = await this.elevenlabs.voices.getAll();
+        let voice = voices.voices.find((voice) => voice.name === this.params.voice);
+        if (voice === undefined) {
+            voice = voices.voices.find((voice) => voice.name.startsWith(this.params.voice));
+            if (voice === undefined)
+                throw new Error(`invalid ElevenLabs voice "${this.params.voice}"`);
+        }
+        const info = Object.keys(voice.labels ?? {}).length > 0 ?
+            (", " + Object.entries(voice.labels)
+                .map(([key, val]) => `${key}: "${val}"`).join(", ")) : "";
+        this.log("info", `selected voice: name: "${voice.name}"${info}`);
+        /*  perform text-to-speech operation with Elevenlabs API  */
+        const model = this.params.optimize === "quality" ?
+            "eleven_multilingual_v2" :
+            "eleven_flash_v2_5";
+        const speechStream = (text) => {
+            this.log("info", `ElevenLabs: send text "${text}"`);
+            return this.elevenlabs.textToSpeech.convert(voice.voiceId, {
+                text,
+                modelId: model,
+                languageCode: this.params.language,
+                outputFormat: `pcm_${maxSampleRate}`,
+                seed: 815, /* arbitrary, but fixated by us */
+                voiceSettings: {
+                    speed: this.params.speed
+                }
+            }, {
+                timeoutInSeconds: 30,
+                maxRetries: 10
+            });
+        };
+        /*  establish resampler from ElevenLabs's maximum 24Khz
+            output to our standard audio sample rate (48KHz)  */
+        if (!SpeechFlowNodeElevenlabs.speexInitialized) {
+            /*  at least once initialize resampler  */
+            await speex_resampler_1.default.initPromise;
+            SpeechFlowNodeElevenlabs.speexInitialized = true;
+        }
+        const resampler = new speex_resampler_1.default(1, maxSampleRate, this.config.audioSampleRate, 7);
+        /*  create transform stream and connect it to the ElevenLabs API  */
+        const log = (level, msg) => { this.log(level, msg); };
+        this.stream = new node_stream_1.default.Transform({
+            writableObjectMode: true,
+            readableObjectMode: true,
+            decodeStrings: false,
+            transform(chunk, encoding, callback) {
+                if (Buffer.isBuffer(chunk.payload))
+                    callback(new Error("invalid chunk payload type"));
+                else {
+                    speechStream(chunk.payload).then((stream) => {
+                        (0, get_stream_1.getStreamAsBuffer)(stream).then((buffer) => {
+                            const bufferResampled = resampler.processChunk(buffer);
+                            log("info", `ElevenLabs: received audio (buffer length: ${buffer.byteLength})`);
+                            const chunkNew = chunk.clone();
+                            chunkNew.type = "audio";
+                            chunkNew.payload = bufferResampled;
+                            this.push(chunkNew);
+                            callback();
+                        }).catch((error) => {
+                            callback(error);
+                        });
+                    }).catch((error) => {
+                        callback(error);
+                    });
+                }
+            },
+            final(callback) {
+                this.push(null);
+                callback();
+            }
+        });
+    }
+    /*  close node  */
+    async close() {
+        /*  destroy stream  */
+        if (this.stream !== null) {
+            this.stream.destroy();
+            this.stream = null;
+        }
+        /*  destroy ElevenLabs API  */
+        if (this.elevenlabs !== null)
+            this.elevenlabs = null;
+    }
+}
+exports.default = SpeechFlowNodeElevenlabs;

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

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

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

@@ -0,0 +1,133 @@
+"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 DeepL = __importStar(require("deepl-node"));
+/*  internal dependencies  */
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+/*  SpeechFlow node for DeepL text-to-text translations  */
+class SpeechFlowNodeDeepL extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "deepl";
+    /*  internal state  */
+    deepl = null;
+    /*  construct node  */
+    constructor(id, cfg, opts, args) {
+        super(id, cfg, opts, args);
+        /*  declare node configuration parameters  */
+        this.configure({
+            key: { type: "string", val: process.env.SPEECHFLOW_KEY_DEEPL },
+            src: { type: "string", pos: 0, val: "de", match: /^(?:de|en)$/ },
+            dst: { type: "string", pos: 1, val: "en", match: /^(?:de|en)$/ },
+            optimize: { type: "string", pos: 2, val: "latency", match: /^(?:latency|quality)$/ }
+        });
+        /*  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 DeepL API SDK  */
+        this.deepl = new DeepL.Translator(this.params.key);
+        /*  provide text-to-text translation  */
+        const translate = async (text) => {
+            const src = this.params.src === "en" ? "en-US" : this.params.src;
+            const dst = this.params.dst === "en" ? "en-US" : this.params.dst;
+            const result = await this.deepl.translateText(text, src, dst, {
+                splitSentences: "off",
+                modelType: this.params.optimize === "latency" ?
+                    "latency_optimized" : "prefer_quality_optimized",
+                preserveFormatting: true,
+                formality: "prefer_more"
+            });
+            return (result?.text ?? text);
+        };
+        /*  establish a duplex stream and connect it to DeepL translation  */
+        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 DeepL API  */
+        if (this.deepl !== null)
+            this.deepl = null;
+    }
+}
+exports.default = SpeechFlowNodeDeepL;

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

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

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

@@ -0,0 +1,80 @@
+"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 wrap_text_1 = __importDefault(require("wrap-text"));
+/*  internal dependencies  */
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+/*  SpeechFlow node for text-to-text formatting  */
+class SpeechFlowNodeFormat extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "format";
+    /*  construct node  */
+    constructor(id, cfg, opts, args) {
+        super(id, cfg, opts, args);
+        /*  declare node configuration parameters  */
+        this.configure({
+            width: { type: "number", val: 80 }
+        });
+        /*  declare node input/output format  */
+        this.input = "text";
+        this.output = "text";
+    }
+    /*  open node  */
+    async open() {
+        /*  provide text-to-text formatter  */
+        const format = async (text) => {
+            text = (0, wrap_text_1.default)(text, this.params.width);
+            text = text.replace(/([^\n])$/, "$1\n");
+            return text;
+        };
+        /*  establish a duplex stream and connect it to DeepL translation  */
+        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 {
+                        format(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();
+            }
+        });
+    }
+    /*  open node  */
+    async close() {
+        /*  close stream  */
+        if (this.stream !== null) {
+            this.stream.destroy();
+            this.stream = null;
+        }
+    }
+}
+exports.default = SpeechFlowNodeFormat;

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

@@ -0,0 +1,13 @@
+import SpeechFlowNode from "./speechflow-node";
+export default class SpeechFlowNodeGemma extends SpeechFlowNode {
+    static name: string;
+    private ollama;
+    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-gemma.js

@@ -0,0 +1,213 @@
+"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 ollama_1 = require("ollama");
+/*  internal dependencies  */
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+/*  SpeechFlow node for Gemma/Ollama text-to-text translation  */
+class SpeechFlowNodeGemma extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "gemma";
+    /*  internal state  */
+    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" +
+                "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" +
+                "Directly translate text from Enlish (EN) to 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" +
+                "Directly translate text from German (DE) to 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({
+            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)$/ }
+        });
+        /*  declare node input/output format  */
+        this.input = "text";
+        this.output = "text";
+    }
+    /*  open node  */
+    async open() {
+        /*  instantiate Ollama API  */
+        this.ollama = new ollama_1.Ollama({ host: this.params.api });
+        /*  provide text-to-text translation  */
+        const translate = async (text) => {
+            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",
+                messages: [
+                    { role: "system", content: cfg.systemPrompt },
+                    ...cfg.chat,
+                    { role: "user", content: text }
+                ],
+                keep_alive: "10m",
+                options: {
+                    repeat_penalty: 1.1,
+                    temperature: 0.7,
+                    seed: 1,
+                    top_k: 10,
+                    top_p: 0.5
+                }
+            });
+            return response.message.content;
+        };
+        /*  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 Ollama  */
+        if (this.ollama !== null) {
+            this.ollama.abort();
+            this.ollama = null;
+        }
+    }
+}
+exports.default = SpeechFlowNodeGemma;

package/dst/speechflow-node-t2t-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>;
+}