@ferchy/n8n-nodes-aimc-toolkit 0.1.4 → 0.1.6

package/README.md

@@ -1,9 +1,11 @@
 # AIMC Toolkit for n8n
 
-AIMC Toolkit is a community node package for n8n with two focused nodes:
+AIMC Toolkit is a community node package for n8n with focused nodes:
 
 - **AIMC Code**: run JavaScript with a practical toolbox of libraries.
 - **AIMC Media**: FFmpeg-powered media operations without extra glue nodes.
+- **AIMC TTS**: CPU-friendly text-to-speech using Piper.
+- **AIMC Docling**: OCR/document extraction using Docling.
 
 ## Why I Built This
 
@@ -21,6 +23,8 @@ n8n is powerful, but real workflows often need basic utilities (validation, pars
 - **Fewer nodes, cleaner flows**: consolidate multiple steps into one code node.
 - **Media ready**: convert, compress, merge, and inspect media in one place.
 - **Practical libraries**: parsing, validation, dates, and web utilities built in.
+- **Local voice**: generate speech on a CPU server without paid APIs.
+- **Document extraction**: pull clean text/markdown from PDFs and scans.
 
 ## Installation
 
@@ -145,6 +149,57 @@ Audio File Path: /path/to/audio.mp3
 **Large Files**
 Use **Input Mode = File Path** to avoid loading big files into memory.
 
+### AIMC TTS (Piper)
+
+**What it does**
+Generate speech locally using Piper (CPU-friendly, no external API). Output is WAV audio.
+
+**Requirements**
+- Python 3 installed
+- Piper installed: `pip install piper-tts`
+- A downloaded voice model
+
+**Download a voice**
+```bash
+python3 -m piper.download_voices en_US-lessac-medium
+```
+
+**Example**
+```
+Text: Hello from AIMC Toolkit
+Voice Name: en_US-lessac-medium
+Output Mode: Binary
+```
+
+**Tips**
+- Use **Output Mode = File Path** for large audio.
+- For custom voice storage, set **Data Dir**.
+
+### AIMC Docling (OCR + Document Parsing)
+
+**What it does**
+Extracts clean text/markdown from PDFs, images, and common document formats using Docling.
+
+**Requirements**
+- Python 3 installed
+- Docling installed: `pip install docling`
+
+**Input modes**
+- Binary (from n8n)
+- File Path (local file)
+- URL (public file URL)
+
+**Output formats**
+- Markdown (default)
+- JSON (structured output when available)
+- Plain Text (markdown stripped)
+
+**Example**
+```
+Input Mode: Binary
+Output Format: Markdown
+```
+
 ## Library Reference (AIMC Code)
 
 Libraries are available as globals or via `libs.<name>`.

package/dist/nodes/AimcDocling/AimcDocling.node.d.ts

@@ -0,0 +1,5 @@
+import { INodeExecutionData, INodeType, INodeTypeDescription, IExecuteFunctions } from 'n8n-workflow';
+export declare class AimcDocling implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/AimcDocling/AimcDocling.node.js

@@ -0,0 +1,270 @@
+"use strict";
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AimcDocling = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+let doclingChecked = null;
+async function ensureDoclingAvailable(pythonPath) {
+    if (doclingChecked) {
+        if (!doclingChecked.ok) {
+            throw new Error(doclingChecked.message || 'Docling not available');
+        }
+        return;
+    }
+    try {
+        await execFileAsync(pythonPath, ['-c', 'import docling'], {
+            timeout: 10000,
+            maxBuffer: 1024 * 1024,
+        });
+        doclingChecked = { ok: true };
+    }
+    catch (error) {
+        const message = error instanceof Error && error.message
+            ? error.message
+            : 'Docling not available';
+        doclingChecked = { ok: false, message };
+        throw new Error(message);
+    }
+}
+async function createTempDir() {
+    return fs.promises.mkdtemp(path.join(os.tmpdir(), 'aimc-docling-'));
+}
+function safeFileName(name) {
+    return name.replace(/[^a-zA-Z0-9._-]/g, '_');
+}
+class AimcDocling {
+    constructor() {
+        this.description = {
+            displayName: 'AIMC Docling',
+            name: 'aimcDocling',
+            icon: 'file:aimc-docling.svg',
+            group: ['transform'],
+            version: 1,
+            description: 'Document extraction using Docling (OCR, PDF, DOCX).',
+            defaults: {
+                name: 'AIMC Docling',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            properties: [
+                {
+                    displayName: 'Input Mode',
+                    name: 'inputMode',
+                    type: 'options',
+                    options: [
+                        { name: 'Binary', value: 'binary' },
+                        { name: 'File Path', value: 'filePath' },
+                        { name: 'URL', value: 'url' },
+                    ],
+                    default: 'binary',
+                },
+                {
+                    displayName: 'Binary Property',
+                    name: 'binaryProperty',
+                    type: 'string',
+                    default: 'data',
+                    displayOptions: {
+                        show: {
+                            inputMode: ['binary'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'File Path',
+                    name: 'inputFilePath',
+                    type: 'string',
+                    default: '',
+                    placeholder: '/path/to/document.pdf',
+                    displayOptions: {
+                        show: {
+                            inputMode: ['filePath'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'URL',
+                    name: 'inputUrl',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'https://example.com/file.pdf',
+                    displayOptions: {
+                        show: {
+                            inputMode: ['url'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Output Format',
+                    name: 'outputFormat',
+                    type: 'options',
+                    options: [
+                        { name: 'Markdown', value: 'markdown' },
+                        { name: 'JSON', value: 'json' },
+                        { name: 'Plain Text', value: 'text' },
+                    ],
+                    default: 'markdown',
+                },
+                {
+                    displayName: 'Python Path',
+                    name: 'pythonPath',
+                    type: 'string',
+                    default: 'python3',
+                    description: 'Path to Python binary with docling installed.',
+                },
+                {
+                    displayName: 'Timeout (Seconds)',
+                    name: 'timeoutSeconds',
+                    type: 'number',
+                    default: 120,
+                    typeOptions: {
+                        minValue: 30,
+                        maxValue: 1800,
+                    },
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const results = [];
+        for (let index = 0; index < items.length; index++) {
+            const item = items[index];
+            const inputMode = this.getNodeParameter('inputMode', index);
+            const binaryProperty = this.getNodeParameter('binaryProperty', index, 'data');
+            const inputFilePath = this.getNodeParameter('inputFilePath', index, '');
+            const inputUrl = this.getNodeParameter('inputUrl', index, '');
+            const outputFormat = this.getNodeParameter('outputFormat', index, 'markdown');
+            const pythonPath = this.getNodeParameter('pythonPath', index, 'python3');
+            const timeoutSeconds = this.getNodeParameter('timeoutSeconds', index, 120);
+            let tempDir = null;
+            let source = '';
+            if (inputMode === 'binary') {
+                const binary = this.helpers.assertBinaryData(index, binaryProperty);
+                const buffer = await this.helpers.getBinaryDataBuffer(index, binaryProperty);
+                tempDir = await createTempDir();
+                const name = safeFileName(binary.fileName || `document.${binary.fileExtension || 'bin'}`);
+                const filePath = path.join(tempDir, name);
+                await fs.promises.writeFile(filePath, buffer);
+                source = filePath;
+            }
+            else if (inputMode === 'filePath') {
+                if (!inputFilePath) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'File Path is required.');
+                }
+                source = inputFilePath;
+            }
+            else {
+                if (!inputUrl) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'URL is required.');
+                }
+                source = inputUrl;
+            }
+            try {
+                await ensureDoclingAvailable(pythonPath);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Docling not available';
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Docling not found. Install with: pip install docling. ${message}`);
+            }
+            const script = `
++import json
++import sys
++from docling.document_converter import DocumentConverter
++
++source = ${JSON.stringify(source)}
++fmt = ${JSON.stringify(outputFormat)}
++
++converter = DocumentConverter()
++result = converter.convert(source)
++doc = result.document
++
++if fmt == 'markdown':
++    content = doc.export_to_markdown()
++elif fmt == 'text':
++    content = doc.export_to_markdown()
++    # naive text conversion
++    content = content.replace('#', '').replace('*', '')
++else:
++    try:
++        content = doc.model_dump()
++    except Exception:
++        content = {'text': doc.export_to_markdown()}
++
++payload = {"format": fmt, "content": content}
++print("__AIMC_RESULT__" + json.dumps(payload, default=str))
++`;
+            try {
+                const { stdout, stderr } = await execFileAsync(pythonPath, ['-c', script], {
+                    timeout: Math.max(30, timeoutSeconds) * 1000,
+                    maxBuffer: 20 * 1024 * 1024,
+                });
+                const combined = `${stdout}\n${stderr}`.trim();
+                const marker = '__AIMC_RESULT__';
+                const markerIndex = combined.lastIndexOf(marker);
+                if (markerIndex === -1) {
+                    throw new Error('Docling did not return a result.');
+                }
+                const jsonPayload = combined.slice(markerIndex + marker.length).trim();
+                const payload = JSON.parse(jsonPayload);
+                results.push({
+                    json: {
+                        ...item.json,
+                        docling: {
+                            format: payload.format,
+                            content: payload.content,
+                        },
+                    },
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Docling failed: ${message}`);
+            }
+            finally {
+                if (tempDir) {
+                    await fs.promises.rm(tempDir, { recursive: true, force: true });
+                }
+            }
+        }
+        return [results];
+    }
+}
+exports.AimcDocling = AimcDocling;

package/dist/nodes/AimcDocling/aimc-docling.svg

@@ -0,0 +1,20 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64">
+  <defs>
+    <linearGradient id="aimc-docling-bg" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0%" stop-color="#0A1021"/>
+      <stop offset="100%" stop-color="#0B1B3A"/>
+    </linearGradient>
+    <linearGradient id="aimc-docling-glow" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0%" stop-color="#7DD3FC"/>
+      <stop offset="100%" stop-color="#0EA5E9"/>
+    </linearGradient>
+  </defs>
+  <rect x="6" y="6" width="52" height="52" rx="10" fill="url(#aimc-docling-bg)"/>
+  <path d="M22 16H38L44 22V48H22Z" fill="#0F172A" stroke="#1E3A8A" stroke-width="2"/>
+  <path d="M38 16V22H44" stroke="#1E3A8A" stroke-width="2" fill="none"/>
+  <rect x="24" y="26" width="16" height="3" rx="1.5" fill="url(#aimc-docling-glow)"/>
+  <rect x="24" y="32" width="12" height="3" rx="1.5" fill="url(#aimc-docling-glow)"/>
+  <rect x="24" y="38" width="18" height="3" rx="1.5" fill="url(#aimc-docling-glow)"/>
+  <circle cx="46" cy="44" r="6" fill="#0B1223" stroke="#38BDF8" stroke-width="2"/>
+  <path d="M46 40V44L49 46" stroke="#38BDF8" stroke-width="2" stroke-linecap="round"/>
+</svg>

package/dist/nodes/AimcTts/AimcTts.node.d.ts

@@ -0,0 +1,5 @@
+import { INodeExecutionData, INodeType, INodeTypeDescription, IExecuteFunctions } from 'n8n-workflow';
+export declare class AimcTts implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/AimcTts/AimcTts.node.js

@@ -0,0 +1,276 @@
+"use strict";
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AimcTts = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+let piperChecked = null;
+async function ensurePiperAvailable(pythonPath) {
+    if (piperChecked) {
+        if (!piperChecked.ok) {
+            throw new Error(piperChecked.message || 'Piper not available');
+        }
+        return;
+    }
+    try {
+        await execFileAsync(pythonPath, ['-m', 'piper', '--help'], {
+            timeout: 10000,
+            maxBuffer: 1024 * 1024,
+        });
+        piperChecked = { ok: true };
+    }
+    catch (error) {
+        const message = error instanceof Error && error.message
+            ? error.message
+            : 'Piper not available';
+        piperChecked = { ok: false, message };
+        throw new Error(message);
+    }
+}
+async function createTempDir() {
+    return fs.promises.mkdtemp(path.join(os.tmpdir(), 'aimc-tts-'));
+}
+class AimcTts {
+    constructor() {
+        this.description = {
+            displayName: 'AIMC TTS',
+            name: 'aimcTts',
+            icon: 'file:aimc-tts.svg',
+            group: ['transform'],
+            version: 1,
+            description: 'Text-to-speech using Piper (CPU-friendly).',
+            defaults: {
+                name: 'AIMC TTS',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            properties: [
+                {
+                    displayName: 'Text',
+                    name: 'text',
+                    type: 'string',
+                    default: '',
+                    typeOptions: {
+                        rows: 4,
+                    },
+                    description: 'Text to synthesize. Supports expressions from input data.',
+                },
+                {
+                    displayName: 'Voice Name',
+                    name: 'voice',
+                    type: 'string',
+                    default: 'en_US-lessac-medium',
+                    description: 'Piper voice name (downloaded via piper).',
+                },
+                {
+                    displayName: 'Data Dir',
+                    name: 'dataDir',
+                    type: 'string',
+                    default: '',
+                    description: 'Optional custom voice data directory.',
+                },
+                {
+                    displayName: 'Python Path',
+                    name: 'pythonPath',
+                    type: 'string',
+                    default: 'python3',
+                    description: 'Path to Python binary with piper-tts installed.',
+                },
+                {
+                    displayName: 'Sentence Silence (seconds)',
+                    name: 'sentenceSilence',
+                    type: 'number',
+                    default: 0,
+                    typeOptions: {
+                        minValue: 0,
+                        maxValue: 10,
+                    },
+                    description: 'Silence added after each sentence except the last.',
+                },
+                {
+                    displayName: 'Volume',
+                    name: 'volume',
+                    type: 'number',
+                    default: 1,
+                    typeOptions: {
+                        minValue: 0.1,
+                        maxValue: 3,
+                    },
+                    description: 'Volume multiplier (1.0 = default).',
+                },
+                {
+                    displayName: 'Disable Normalization',
+                    name: 'noNormalize',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Disable automatic volume normalization.',
+                },
+                {
+                    displayName: 'Timeout (Seconds)',
+                    name: 'timeoutSeconds',
+                    type: 'number',
+                    default: 60,
+                    typeOptions: {
+                        minValue: 10,
+                        maxValue: 600,
+                    },
+                },
+                {
+                    displayName: 'Output Mode',
+                    name: 'outputMode',
+                    type: 'options',
+                    options: [
+                        { name: 'Binary', value: 'binary' },
+                        { name: 'File Path', value: 'filePath' },
+                    ],
+                    default: 'binary',
+                },
+                {
+                    displayName: 'Output Binary Property',
+                    name: 'outputBinaryProperty',
+                    type: 'string',
+                    default: 'data',
+                    displayOptions: {
+                        show: {
+                            outputMode: ['binary'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Output File Path',
+                    name: 'outputFilePath',
+                    type: 'string',
+                    default: '',
+                    placeholder: '/path/to/output.wav',
+                    displayOptions: {
+                        show: {
+                            outputMode: ['filePath'],
+                        },
+                    },
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const results = [];
+        for (let index = 0; index < items.length; index++) {
+            const item = items[index];
+            const text = this.getNodeParameter('text', index, '');
+            const voice = this.getNodeParameter('voice', index);
+            const dataDir = this.getNodeParameter('dataDir', index, '');
+            const pythonPath = this.getNodeParameter('pythonPath', index, 'python3');
+            const sentenceSilence = this.getNodeParameter('sentenceSilence', index, 0);
+            const volume = this.getNodeParameter('volume', index, 1);
+            const noNormalize = this.getNodeParameter('noNormalize', index, false);
+            const timeoutSeconds = this.getNodeParameter('timeoutSeconds', index, 60);
+            const outputMode = this.getNodeParameter('outputMode', index, 'binary');
+            const outputBinaryProperty = this.getNodeParameter('outputBinaryProperty', index, 'data');
+            const outputFilePath = this.getNodeParameter('outputFilePath', index, '');
+            if (!text || !text.trim()) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Text is required.');
+            }
+            try {
+                await ensurePiperAvailable(pythonPath);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Piper not available';
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Piper not found. Install piper-tts and voices. ${message}`);
+            }
+            let tempDir = null;
+            let outputPath = outputFilePath;
+            if (outputMode === 'filePath' && !outputPath) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Output File Path is required.');
+            }
+            if (outputMode === 'binary') {
+                tempDir = await createTempDir();
+                outputPath = path.join(tempDir, 'speech.wav');
+            }
+            const args = ['-m', 'piper', '-m', voice, '-f', outputPath];
+            if (dataDir) {
+                args.push('--data-dir', dataDir);
+            }
+            if (sentenceSilence > 0) {
+                args.push('--sentence-silence', sentenceSilence.toString());
+            }
+            if (volume && volume !== 1) {
+                args.push('--volume', volume.toString());
+            }
+            if (noNormalize) {
+                args.push('--no-normalize');
+            }
+            args.push('--', text);
+            try {
+                await execFileAsync(pythonPath, args, {
+                    timeout: Math.max(10, timeoutSeconds) * 1000,
+                    maxBuffer: 1024 * 1024,
+                });
+                const outputItem = {
+                    json: {
+                        ...item.json,
+                        tts: {
+                            voice,
+                            outputPath: outputMode === 'filePath' ? outputPath : undefined,
+                        },
+                    },
+                };
+                if (outputMode === 'binary') {
+                    const data = await fs.promises.readFile(outputPath);
+                    const binaryData = await this.helpers.prepareBinaryData(data, 'speech.wav');
+                    outputItem.binary = {
+                        [outputBinaryProperty]: binaryData,
+                    };
+                }
+                results.push(outputItem);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `TTS failed: ${message}`);
+            }
+            finally {
+                if (tempDir) {
+                    await fs.promises.rm(tempDir, { recursive: true, force: true });
+                }
+            }
+        }
+        return [results];
+    }
+}
+exports.AimcTts = AimcTts;

package/dist/nodes/AimcTts/aimc-tts.svg

@@ -0,0 +1,19 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64">
+  <defs>
+    <linearGradient id="aimc-tts-bg" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0%" stop-color="#0A1021"/>
+      <stop offset="100%" stop-color="#0B1B3A"/>
+    </linearGradient>
+    <linearGradient id="aimc-tts-glow" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0%" stop-color="#7DD3FC"/>
+      <stop offset="100%" stop-color="#0EA5E9"/>
+    </linearGradient>
+  </defs>
+  <rect x="6" y="6" width="52" height="52" rx="10" fill="url(#aimc-tts-bg)"/>
+  <rect x="26" y="18" width="12" height="22" rx="6" fill="url(#aimc-tts-glow)"/>
+  <path d="M22 30C22 36 26 40 32 40C38 40 42 36 42 30" stroke="#38BDF8" stroke-width="2.5" fill="none" stroke-linecap="round"/>
+  <path d="M24 46H40" stroke="#1E3A8A" stroke-width="2" stroke-linecap="round"/>
+  <path d="M32 40V46" stroke="#1E3A8A" stroke-width="2" stroke-linecap="round"/>
+  <path d="M14 24C18 20 20 20 22 24" stroke="#1E3A8A" stroke-width="1.5" fill="none" stroke-linecap="round"/>
+  <path d="M50 24C46 20 44 20 42 24" stroke="#1E3A8A" stroke-width="1.5" fill="none" stroke-linecap="round"/>
+</svg>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ferchy/n8n-nodes-aimc-toolkit",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "AIMC Toolkit nodes for n8n: code execution and media operations.",
   "license": "MIT",
   "author": "Ferchy",
@@ -28,7 +28,9 @@
     "n8nNodesApiVersion": 1,
     "nodes": [
       "dist/nodes/AimcCode/AimcCode.node.js",
-      "dist/nodes/AimcMedia/AimcMedia.node.js"
+      "dist/nodes/AimcMedia/AimcMedia.node.js",
+      "dist/nodes/AimcTts/AimcTts.node.js",
+      "dist/nodes/AimcDocling/AimcDocling.node.js"
     ]
   },
   "dependencies": {