@ferchy/n8n-nodes-aimc-toolkit 0.1.8 → 0.1.9

package/README.md

@@ -10,6 +10,8 @@ AIMC Toolkit is a community node package for n8n with focused nodes:
 
 n8n is powerful, but real workflows often need basic utilities (validation, parsing, HTTP) and media tasks (convert, compress, merge). I built AIMC Toolkit to remove the busywork and keep workflows short, readable, and fast.
 
+**Inspiration**: The original idea was sparked by Kenkaii’s SuperCode. I’m grateful for that work and built AIMC Toolkit as my own version, tailored to my needs and expanded with improvements over time.
+
 ## Who This Is For
 
 - Automation builders who want fewer nodes and faster iterations.
@@ -74,6 +76,7 @@ brew install ffmpeg
 - Run once for all items or once per item.
 - Access libraries as globals (`axios`, `_`, `zod`) or via `libs`.
 - Built-in helpers (`utils.now`, `utils.safeJson`, `utils.toArray`).
+- **AIMC Connect Mode**: optional AI connectors for LLMs, tools, memory, and more.
 
 **Example: normalize data**
 ```javascript
@@ -105,6 +108,20 @@ result = {
 }
 ```
 
+**AIMC Connect Mode (AI)**
+Enable **AIMC Connect Mode** to attach AI connectors. When enabled, your code can use:
+
+- `ai` (object with all connectors)
+- `aiModel`, `aiTools`, `aiMemory`, `aiVectorStore`, `aiChain`, `aiDocument`
+
+Example:
+```javascript
+if (aiModel) {
+  const response = await aiModel.invoke('Summarize this input.');
+  return { summary: response };
+}
+```
+
 ### AIMC Media
 
 **Operations**

package/dist/nodes/AimcCode/AimcCode.node.js

@@ -147,6 +147,7 @@ function normalizeResult(result, fallbackItems) {
     ];
 }
 function buildSandbox(params) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     const cache = {};
     const sandbox = {
         items: params.items,
@@ -161,6 +162,16 @@ function buildSandbox(params) {
                 : params.items.map((entry) => entry.json),
         },
         params: params.nodeParams,
+        ai: params.aiContext || {},
+        aiModel: (_a = params.aiContext) === null || _a === void 0 ? void 0 : _a.languageModel,
+        aiTools: (_b = params.aiContext) === null || _b === void 0 ? void 0 : _b.tools,
+        aiMemory: (_c = params.aiContext) === null || _c === void 0 ? void 0 : _c.memory,
+        aiChain: (_d = params.aiContext) === null || _d === void 0 ? void 0 : _d.chain,
+        aiDocument: (_e = params.aiContext) === null || _e === void 0 ? void 0 : _e.document,
+        aiEmbedding: (_f = params.aiContext) === null || _f === void 0 ? void 0 : _f.embedding,
+        aiOutputParser: (_g = params.aiContext) === null || _g === void 0 ? void 0 : _g.outputParser,
+        aiTextSplitter: (_h = params.aiContext) === null || _h === void 0 ? void 0 : _h.textSplitter,
+        aiVectorStore: (_j = params.aiContext) === null || _j === void 0 ? void 0 : _j.vectorStore,
         utils: {
             now: () => new Date().toISOString(),
             sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
@@ -294,7 +305,32 @@ class AimcCode {
             defaults: {
                 name: 'AIMC Code',
             },
-            inputs: ['main'],
+            inputs: `={{ 
+			((values, aiMode) => {
+				const connectorTypes = {
+					'${"ai_chain"}': 'Chain',
+					'${"ai_document"}': 'Document',
+					'${"ai_embedding"}': 'Embedding',
+					'${"ai_languageModel"}': 'Language Model',
+					'${"ai_memory"}': 'Memory',
+					'${"ai_outputParser"}': 'Output Parser',
+					'${"ai_textSplitter"}': 'Text Splitter',
+					'${"ai_tool"}': 'Tool',
+					'${"ai_vectorStore"}': 'Vector Store',
+					'${"main"}': 'Main'
+				};
+				const baseInputs = [{ displayName: '', type: '${"main"}' }];
+				if (aiMode && values) {
+					return baseInputs.concat(values.map(value => ({
+						type: value.type,
+						required: value.required,
+						maxConnections: value.maxConnections === -1 ? undefined : value.maxConnections,
+						displayName: connectorTypes[value.type] !== 'Main' ? connectorTypes[value.type] : undefined
+					})));
+				}
+				return baseInputs;
+			})($parameter.aiConnections?.input, $parameter.aiConnectMode)
+		}}`,
             outputs: ['main'],
             properties: [
                 {
@@ -333,6 +369,67 @@ class AimcCode {
                         maxValue: 300,
                     },
                 },
+                {
+                    displayName: 'AIMC Connect Mode',
+                    name: 'aiConnectMode',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Enable AI connector inputs for models, tools, memory, and more.',
+                },
+                {
+                    displayName: 'AI Connections',
+                    name: 'aiConnections',
+                    placeholder: 'Add AI Connection',
+                    type: 'fixedCollection',
+                    displayOptions: {
+                        show: {
+                            aiConnectMode: [true],
+                        },
+                    },
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    default: {},
+                    options: [
+                        {
+                            name: 'input',
+                            displayName: 'Input',
+                            values: [
+                                {
+                                    displayName: 'Type',
+                                    name: 'type',
+                                    type: 'options',
+                                    options: [
+                                        { name: 'Chain', value: 'ai_chain' },
+                                        { name: 'Document', value: 'ai_document' },
+                                        { name: 'Embedding', value: 'ai_embedding' },
+                                        { name: 'Language Model', value: 'ai_languageModel' },
+                                        { name: 'Memory', value: 'ai_memory' },
+                                        { name: 'Output Parser', value: 'ai_outputParser' },
+                                        { name: 'Text Splitter', value: 'ai_textSplitter' },
+                                        { name: 'Tool', value: 'ai_tool' },
+                                        { name: 'Vector Store', value: 'ai_vectorStore' },
+                                    ],
+                                    default: 'ai_languageModel',
+                                },
+                                {
+                                    displayName: 'Max Connections',
+                                    name: 'maxConnections',
+                                    type: 'number',
+                                    default: 1,
+                                    description: 'Set -1 for unlimited connections',
+                                },
+                                {
+                                    displayName: 'Required',
+                                    name: 'required',
+                                    type: 'boolean',
+                                    default: false,
+                                    description: 'Whether this connection is required',
+                                },
+                            ],
+                        },
+                    ],
+                },
                 {
                     displayName: 'JavaScript Code',
                     name: 'code',
@@ -410,8 +507,38 @@ class AimcCode {
         const language = this.getNodeParameter('language', 0, 'javascript');
         const mode = this.getNodeParameter('mode', 0, 'runOnceForAllItems');
         const timeoutSeconds = this.getNodeParameter('timeoutSeconds', 0, 30);
+        const aiConnectMode = this.getNodeParameter('aiConnectMode', 0, false);
         const timeoutMs = Math.max(1, timeoutSeconds) * 1000;
         const nodeParams = this.getNode().parameters;
+        const aiContext = {};
+        const fetchAi = async (type) => {
+            if (!aiConnectMode) {
+                return undefined;
+            }
+            const getter = this
+                .getInputConnectionData;
+            if (!getter) {
+                return undefined;
+            }
+            try {
+                const value = await getter(type, 0);
+                return Array.isArray(value) ? value[0] : value;
+            }
+            catch {
+                return undefined;
+            }
+        };
+        if (aiConnectMode) {
+            aiContext.chain = await fetchAi('ai_chain');
+            aiContext.document = await fetchAi('ai_document');
+            aiContext.embedding = await fetchAi('ai_embedding');
+            aiContext.languageModel = await fetchAi('ai_languageModel');
+            aiContext.memory = await fetchAi('ai_memory');
+            aiContext.outputParser = await fetchAi('ai_outputParser');
+            aiContext.textSplitter = await fetchAi('ai_textSplitter');
+            aiContext.tools = await fetchAi('ai_tool');
+            aiContext.vectorStore = await fetchAi('ai_vectorStore');
+        }
         if (language === 'python') {
             const pythonCode = this.getNodeParameter('pythonCode', 0, '');
             if (!pythonCode.trim()) {
@@ -477,6 +604,7 @@ class AimcCode {
                         item,
                         mode,
                         nodeParams,
+                        aiContext,
                     });
                     const result = await runCode(sandbox);
                     const normalized = normalizeResult(result, [item]);
@@ -488,6 +616,7 @@ class AimcCode {
                 items,
                 mode,
                 nodeParams,
+                aiContext,
             });
             const result = await runCode(sandbox);
             const normalized = normalizeResult(result, items);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ferchy/n8n-nodes-aimc-toolkit",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "AIMC Toolkit nodes for n8n: code execution and media operations.",
   "license": "MIT",
   "author": "Ferchy",