n8n-nodes-github-copilot 3.2.6 → 3.3.0

package/dist/nodes/GitHubCopilotChatAPI/GitHubCopilotChatAPI.node.js

@@ -43,7 +43,7 @@ class GitHubCopilotChatAPI {
                     const advancedOptions = this.getNodeParameter('advancedOptions', i, {});
                     const includeMedia = this.getNodeParameter('includeMedia', i, false);
                     if (includeMedia) {
-                        const validation = (0, modelCapabilities_1.validateModelCapabilities)(model, true, true);
+                        const validation = (0, modelCapabilities_1.validateModelCapabilities)(model, true, false);
                         if (!validation.isValid) {
                             throw new Error(validation.errorMessage || 'Model validation failed');
                         }
@@ -83,16 +83,10 @@ class GitHubCopilotChatAPI {
                                     },
                                 });
                             }
-                            else if (mediaResult.type === 'audio' && mediaResult.dataUrl) {
-                                contentArray.push({
-                                    type: 'text',
-                                    text: `Please analyze this audio file: ${mediaResult.description}\n\nAudio data (base64): ${mediaResult.dataUrl}`,
-                                });
-                            }
                             else {
                                 contentArray.push({
                                     type: 'text',
-                                    text: `[Media processing failed: ${mediaResult.description}]`,
+                                    text: `[Image processing failed: ${mediaResult.description}]`,
                                 });
                             }
                         }

package/dist/nodes/GitHubCopilotChatAPI/nodeProperties.js

@@ -24,12 +24,12 @@ exports.nodeProperties = [
             {
                 name: 'GPT-5',
                 value: 'gpt-5',
-                description: 'OpenAI GPT-5 (Latest and most capable) ✓ Images ✓ Audio',
+                description: 'OpenAI GPT-5 (Latest and most capable) ✓ Images',
             },
             {
                 name: 'GPT-5 Mini',
                 value: 'gpt-5-mini',
-                description: 'OpenAI GPT-5 Mini (Faster, cost-effective) ✓ Images ✓ Audio',
+                description: 'OpenAI GPT-5 Mini (Faster, cost-effective) ✓ Images',
             },
             {
                 name: 'Claude Opus 4.1',
@@ -39,7 +39,7 @@ exports.nodeProperties = [
             {
                 name: 'Gemini 2.5 Pro',
                 value: 'gemini-2.5-pro',
-                description: 'Google Gemini 2.5 Pro (Multimodal capabilities) ✓ Images ✓ Audio',
+                description: 'Google Gemini 2.5 Pro (Multimodal capabilities) ✓ Images',
             },
             {
                 name: 'Grok Code Fast 1',
@@ -49,7 +49,7 @@ exports.nodeProperties = [
             {
                 name: 'GPT-4.1 Copilot',
                 value: 'gpt-4.1-copilot',
-                description: 'OpenAI GPT-4.1 specialized for coding assistance ✓ Images ✓ Audio',
+                description: 'OpenAI GPT-4.1 specialized for coding assistance ✓ Images',
             },
         ],
         default: 'gpt-5-mini',
@@ -78,14 +78,14 @@ exports.nodeProperties = [
         description: 'System message to set the behavior of the AI model',
     },
     {
-        displayName: 'Include Media',
+        displayName: 'Include Image',
         name: 'includeMedia',
         type: 'boolean',
         default: false,
-        description: 'Whether to include a media file in the message. Supported: Images (PNG, JPEG, GIF, WebP) and Audio files. Type is auto-detected.',
+        description: 'Whether to include an image file in the message. Supported formats: PNG, JPEG, GIF, WebP.',
     },
     {
-        displayName: 'Media Source',
+        displayName: 'Image Source',
         name: 'mediaSource',
         type: 'options',
         displayOptions: {
@@ -97,12 +97,12 @@ exports.nodeProperties = [
             {
                 name: 'Manual Input',
                 value: 'manual',
-                description: 'Provide media as base64 string or file path',
+                description: 'Provide image as base64 string or file path',
             },
             {
                 name: 'URL',
                 value: 'url',
-                description: 'Download media from URL',
+                description: 'Download image from URL',
             },
             {
                 name: 'Binary Data',
@@ -111,10 +111,10 @@ exports.nodeProperties = [
             },
         ],
         default: 'manual',
-        description: 'Source of the media data',
+        description: 'Source of the image data',
     },
     {
-        displayName: 'Media File',
+        displayName: 'Image File',
         name: 'mediaFile',
         type: 'string',
         displayOptions: {
@@ -125,10 +125,10 @@ exports.nodeProperties = [
         },
         default: '',
         placeholder: 'Paste base64 string or file path',
-        description: 'Media file as base64 string or file path (Images: PNG/JPEG/GIF/WebP, Audio: MP3/WAV/M4A)',
+        description: 'Image file as base64 string or file path. Supported formats: PNG, JPEG, GIF, WebP.',
     },
     {
-        displayName: 'Media URL',
+        displayName: 'Image URL',
         name: 'mediaUrl',
         type: 'string',
         displayOptions: {
@@ -138,11 +138,11 @@ exports.nodeProperties = [
             },
         },
         default: '',
-        placeholder: 'https://example.com/file.jpg',
-        description: 'URL of the media file to download and include (Images: PNG/JPEG/GIF/WebP, Audio: MP3/WAV/M4A)',
+        placeholder: 'https://example.com/image.jpg',
+        description: 'URL of the image file to download. Supported formats: PNG, JPEG, GIF, WebP.',
     },
     {
-        displayName: 'Media Binary Property',
+        displayName: 'Image Binary Property',
         name: 'mediaBinaryProperty',
         type: 'string',
         displayOptions: {
@@ -153,7 +153,7 @@ exports.nodeProperties = [
         },
         default: 'data',
         placeholder: 'data',
-        description: 'Name of the binary property containing the media file',
+        description: 'Name of the binary property containing the image file',
     },
     {
         displayName: 'Advanced Options',

package/dist/nodes/GitHubCopilotChatAPI/utils/index.d.ts

@@ -1,4 +1,3 @@
 export * from './types';
 export * from './helpers';
-export * from './audioProcessor';
 export * from './imageProcessor';

package/dist/nodes/GitHubCopilotChatAPI/utils/index.js

@@ -16,5 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types"), exports);
 __exportStar(require("./helpers"), exports);
-__exportStar(require("./audioProcessor"), exports);
 __exportStar(require("./imageProcessor"), exports);

package/dist/nodes/GitHubCopilotChatAPI/utils/mediaDetection.d.ts

@@ -1,12 +1,11 @@
 import { IExecuteFunctions } from 'n8n-workflow';
 export declare function processMediaFile(context: IExecuteFunctions, itemIndex: number, source: 'manual' | 'url' | 'binary', mediaFile?: string, mediaUrl?: string, binaryProperty?: string): Promise<{
-    type: 'image' | 'audio' | 'unknown';
+    type: 'image' | 'unknown';
     dataUrl?: string;
     description: string;
     mimeType: string;
 }>;
 export declare function isImageMimeType(mimeType: string): boolean;
-export declare function isAudioMimeType(mimeType: string): boolean;
 export declare function validateImageFormat(mimeType: string): {
     isValid: boolean;
     error?: string;

package/dist/nodes/GitHubCopilotChatAPI/utils/mediaDetection.js

@@ -1,151 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.suggestImageConversion = exports.getFileExtensionFromMimeType = exports.validateImageFormat = exports.isAudioMimeType = exports.isImageMimeType = exports.processMediaFile = void 0;
+exports.suggestImageConversion = exports.getFileExtensionFromMimeType = exports.validateImageFormat = exports.isImageMimeType = exports.processMediaFile = void 0;
 const index_1 = require("./index");
-async function detectMimeType(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty) {
-    var _a, _b;
-    try {
-        if (source === 'binary') {
-            const binaryData = context.getInputData()[itemIndex].binary;
-            if (binaryData && binaryProperty && binaryData[binaryProperty]) {
-                return binaryData[binaryProperty].mimeType || 'application/octet-stream';
-            }
-        }
-        else if (source === 'url' && mediaUrl) {
-            const extension = (_a = mediaUrl.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
-            const extToMime = {
-                'png': 'image/png',
-                'jpg': 'image/jpeg',
-                'jpeg': 'image/jpeg',
-                'gif': 'image/gif',
-                'webp': 'image/webp',
-                'mp3': 'audio/mpeg',
-                'wav': 'audio/wav',
-                'm4a': 'audio/mp4',
-                'ogg': 'audio/ogg',
-                'mp4': 'video/mp4'
-            };
-            return extToMime[extension || ''] || 'application/octet-stream';
-        }
-        else if (source === 'manual' && mediaFile) {
-            if (mediaFile.startsWith('data:')) {
-                const mimeMatch = mediaFile.match(/data:([^;]+)/);
-                if (mimeMatch)
-                    return mimeMatch[1];
-            }
-            const extension = (_b = mediaFile.split('.').pop()) === null || _b === void 0 ? void 0 : _b.toLowerCase();
-            const extToMime = {
-                'png': 'image/png',
-                'jpg': 'image/jpeg',
-                'jpeg': 'image/jpeg',
-                'gif': 'image/gif',
-                'webp': 'image/webp',
-                'mp3': 'audio/mpeg',
-                'wav': 'audio/wav',
-                'm4a': 'audio/mp4',
-                'ogg': 'audio/ogg',
-                'mp4': 'video/mp4'
-            };
-            return extToMime[extension || ''] || 'application/octet-stream';
-        }
-    }
-    catch (error) {
-    }
-    return 'application/octet-stream';
-}
 async function processMediaFile(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty) {
     try {
-        const detectedMimeType = await detectMimeType(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty);
-        const isLikelyImage = isImageMimeType(detectedMimeType);
-        const isLikelyAudio = isAudioMimeType(detectedMimeType);
-        if (isLikelyAudio && !isLikelyImage) {
-            try {
-                const audioResult = await (0, index_1.processAudioFile)(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty);
-                return {
-                    type: 'audio',
-                    dataUrl: `data:${audioResult.mimeType};base64,${audioResult.data}`,
-                    description: `Audio file: ${audioResult.filename} (${Math.round(audioResult.size / 1024)}KB, ${audioResult.mimeType})`,
-                    mimeType: audioResult.mimeType,
-                };
-            }
-            catch (audioError) {
-                throw new Error(`Audio processing failed: ${audioError instanceof Error ? audioError.message : 'Unknown error'}`);
-            }
-        }
-        else if (isLikelyImage && !isLikelyAudio) {
-            try {
-                const imageResult = await (0, index_1.processImageFile)(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty);
-                const formatValidation = validateImageFormat(imageResult.mimeType);
-                if (!formatValidation.isValid) {
-                    throw new Error(suggestImageConversion(imageResult.mimeType));
-                }
-                return {
-                    type: 'image',
-                    dataUrl: `data:${imageResult.mimeType};base64,${imageResult.data}`,
-                    description: `Image file: ${imageResult.filename} (${Math.round(imageResult.size / 1024)}KB, ${imageResult.mimeType})`,
-                    mimeType: imageResult.mimeType,
-                };
-            }
-            catch (imageError) {
-                throw new Error(`Image processing failed: ${imageError instanceof Error ? imageError.message : 'Unknown error'}`);
-            }
-        }
-        else {
-            if (detectedMimeType.includes('mpeg') || detectedMimeType.includes('mp3')) {
-                try {
-                    const audioResult = await (0, index_1.processAudioFile)(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty);
-                    return {
-                        type: 'audio',
-                        dataUrl: `data:${audioResult.mimeType};base64,${audioResult.data}`,
-                        description: `Audio file: ${audioResult.filename} (${Math.round(audioResult.size / 1024)}KB, ${audioResult.mimeType})`,
-                        mimeType: audioResult.mimeType,
-                    };
-                }
-                catch (audioError) {
-                    throw new Error(`MPEG audio processing failed: ${audioError instanceof Error ? audioError.message : 'Unknown error'}`);
-                }
-            }
-            else {
-                try {
-                    const imageResult = await (0, index_1.processImageFile)(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty);
-                    const formatValidation = validateImageFormat(imageResult.mimeType);
-                    if (!formatValidation.isValid) {
-                        throw new Error(suggestImageConversion(imageResult.mimeType));
-                    }
-                    return {
-                        type: 'image',
-                        dataUrl: `data:${imageResult.mimeType};base64,${imageResult.data}`,
-                        description: `Image file: ${imageResult.filename} (${Math.round(imageResult.size / 1024)}KB, ${imageResult.mimeType})`,
-                        mimeType: imageResult.mimeType,
-                    };
-                }
-                catch (imageError) {
-                    try {
-                        const audioResult = await (0, index_1.processAudioFile)(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty);
-                        return {
-                            type: 'audio',
-                            dataUrl: `data:${audioResult.mimeType};base64,${audioResult.data}`,
-                            description: `Audio file: ${audioResult.filename} (${Math.round(audioResult.size / 1024)}KB, ${audioResult.mimeType})`,
-                            mimeType: audioResult.mimeType,
-                        };
-                    }
-                    catch (audioError) {
-                        const supportedImageFormats = ['PNG', 'JPEG', 'GIF', 'WebP'];
-                        const supportedAudioFormats = ['MP3', 'WAV', 'M4A', 'OGG'];
-                        throw new Error(`File is neither a valid image nor audio file (detected MIME: ${detectedMimeType}).\n` +
-                            `Supported image formats: ${supportedImageFormats.join(', ')}\n` +
-                            `Supported audio formats: ${supportedAudioFormats.join(', ')}\n` +
-                            `Image error: ${imageError instanceof Error ? imageError.message : 'Unknown'}\n` +
-                            `Audio error: ${audioError instanceof Error ? audioError.message : 'Unknown'}`);
-                    }
-                }
-            }
+        const imageResult = await (0, index_1.processImageFile)(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty);
+        const formatValidation = validateImageFormat(imageResult.mimeType);
+        if (!formatValidation.isValid) {
+            throw new Error(suggestImageConversion(imageResult.mimeType));
         }
+        return {
+            type: 'image',
+            dataUrl: `data:${imageResult.mimeType};base64,${imageResult.data}`,
+            description: `Image file: ${imageResult.filename} (${Math.round(imageResult.size / 1024)}KB, ${imageResult.mimeType})`,
+            mimeType: imageResult.mimeType,
+        };
     }
     catch (error) {
         return {
             type: 'unknown',
-            description: `Error processing media file: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            description: `Error processing image file: ${error instanceof Error ? error.message : 'Unknown error'}`,
             mimeType: 'unknown',
         };
     }
@@ -162,12 +36,6 @@ function isImageMimeType(mimeType) {
     return supportedFormats.includes(mimeType.toLowerCase());
 }
 exports.isImageMimeType = isImageMimeType;
-function isAudioMimeType(mimeType) {
-    return mimeType.startsWith('audio/') ||
-        mimeType === 'application/ogg' ||
-        mimeType === 'video/mp4';
-}
-exports.isAudioMimeType = isAudioMimeType;
 function validateImageFormat(mimeType) {
     if (!isImageMimeType(mimeType)) {
         const supportedFormats = ['PNG', 'JPEG', 'GIF', 'WebP'];

package/dist/nodes/GitHubCopilotChatAPI/utils/modelCapabilities.js

@@ -4,21 +4,21 @@ exports.getModelInfo = exports.getSupportedModels = exports.validateModelCapabil
 exports.MODEL_CAPABILITIES = {
     'gpt-5': {
         supportsImages: true,
-        supportsAudio: true,
+        supportsAudio: false,
         maxContextTokens: 200000,
-        description: 'OpenAI GPT-5 with image support and audio analysis via GitHub Copilot API',
+        description: 'OpenAI GPT-5 with image support via GitHub Copilot API',
     },
     'gpt-5-mini': {
         supportsImages: true,
-        supportsAudio: true,
+        supportsAudio: false,
         maxContextTokens: 128000,
-        description: 'OpenAI GPT-5 Mini with image support and audio analysis via GitHub Copilot API',
+        description: 'OpenAI GPT-5 Mini with image support via GitHub Copilot API',
     },
     'gpt-4.1-copilot': {
         supportsImages: true,
-        supportsAudio: true,
+        supportsAudio: false,
         maxContextTokens: 128000,
-        description: 'OpenAI GPT-4.1 with image support and audio analysis via GitHub Copilot API',
+        description: 'OpenAI GPT-4.1 with image support via GitHub Copilot API',
     },
     'claude-opus-4.1': {
         supportsImages: false,
@@ -34,9 +34,9 @@ exports.MODEL_CAPABILITIES = {
     },
     'gemini-2.5-pro': {
         supportsImages: true,
-        supportsAudio: true,
+        supportsAudio: false,
         maxContextTokens: 1000000,
-        description: 'Google Gemini 2.5 Pro with multimodal support via GitHub Copilot API',
+        description: 'Google Gemini 2.5 Pro with image support via GitHub Copilot API',
     },
     'gemini-2.0-flash': {
         supportsImages: true,

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

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

package/dist/nodes/N8nAiAgent/N8nAiAgent.node.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.N8nAiAgent = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const nodeProperties_1 = require("./nodeProperties");
+const mediaDetection_1 = require("../GitHubCopilotChatAPI/utils/mediaDetection");
+class N8nAiAgent {
+    constructor() {
+        this.description = {
+            displayName: 'N8N AI Agent',
+            name: 'n8nAiAgent',
+            icon: 'file:n8n-ai.svg',
+            group: ['AI'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["model"]}}',
+            description: 'Connect to N8N AI Agent service for advanced AI capabilities with tool calling and memory',
+            defaults: {
+                name: 'N8N AI Agent',
+            },
+            inputs: ["main"],
+            outputs: ["main"],
+            credentials: [
+                {
+                    name: 'n8nApi',
+                    required: true,
+                },
+            ],
+            properties: nodeProperties_1.nodeProperties,
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const operation = this.getNodeParameter('operation', i);
+                const model = this.getNodeParameter('model', i);
+                if (operation === 'chat') {
+                    const message = this.getNodeParameter('message', i);
+                    const includeMedia = this.getNodeParameter('includeMedia', i, false);
+                    const messages = [];
+                    const systemMessage = this.getNodeParameter('systemMessage', i, '');
+                    if (systemMessage) {
+                        messages.push({
+                            role: 'system',
+                            content: systemMessage,
+                        });
+                    }
+                    const messageContent = [
+                        {
+                            type: 'text',
+                            text: message,
+                        },
+                    ];
+                    if (includeMedia) {
+                        const mediaSource = this.getNodeParameter('mediaSource', i);
+                        const processedMedia = await (0, mediaDetection_1.processMediaFile)(this, i, mediaSource, this.getNodeParameter('mediaFile', i, ''), this.getNodeParameter('mediaUrl', i, ''), this.getNodeParameter('mediaProperty', i, ''));
+                        if (processedMedia && processedMedia.dataUrl) {
+                            messageContent.push({
+                                type: 'image_url',
+                                image_url: {
+                                    url: processedMedia.dataUrl,
+                                },
+                            });
+                        }
+                    }
+                    messages.push({
+                        role: 'user',
+                        content: messageContent,
+                    });
+                    const includeHistory = this.getNodeParameter('includeHistory', i, false);
+                    if (includeHistory) {
+                        const historyMessages = this.getNodeParameter('conversationHistory', i, []);
+                        messages.splice(-1, 0, ...historyMessages);
+                    }
+                    const advancedOptions = {};
+                    const maxTokens = this.getNodeParameter('maxTokens', i, 1000);
+                    const temperature = this.getNodeParameter('temperature', i, 0.7);
+                    const enableTools = this.getNodeParameter('enableTools', i, false);
+                    if (maxTokens > 0) {
+                        advancedOptions.max_tokens = maxTokens;
+                    }
+                    advancedOptions.temperature = temperature;
+                    if (enableTools) {
+                        const toolsConfig = this.getNodeParameter('toolsConfig', i, {});
+                        if (toolsConfig.tools && Array.isArray(toolsConfig.tools)) {
+                            advancedOptions.tools = toolsConfig.tools;
+                        }
+                    }
+                    const requestBody = {
+                        model,
+                        messages,
+                        stream: false,
+                        ...advancedOptions,
+                    };
+                    const response = await makeN8nAiAgentRequest(this, '/chat', requestBody, includeMedia);
+                    const result = {
+                        message: response.response || response.message || '',
+                        model,
+                        operation,
+                        usage: response.usage || null,
+                        tool_calls: response.tool_calls || null,
+                        memory: response.memory || null,
+                        finish_reason: response.finish_reason || 'completed',
+                    };
+                    returnData.push({
+                        json: result,
+                        pairedItem: { item: i },
+                    });
+                }
+                else if (operation === 'tools') {
+                    const toolName = this.getNodeParameter('toolName', i);
+                    const toolArguments = this.getNodeParameter('toolArguments', i, {});
+                    const context = this.getNodeParameter('context', i, '');
+                    const requestBody = {
+                        tool: toolName,
+                        arguments: toolArguments,
+                        context,
+                        model,
+                    };
+                    const response = await makeN8nAiAgentRequest(this, '/tools', requestBody, false);
+                    const result = {
+                        tool_name: toolName,
+                        result: response.result || response.response,
+                        execution_time: response.execution_time || null,
+                        operation,
+                        model,
+                    };
+                    returnData.push({
+                        json: result,
+                        pairedItem: { item: i },
+                    });
+                }
+                else if (operation === 'memory') {
+                    const memoryAction = this.getNodeParameter('memoryAction', i);
+                    const sessionId = this.getNodeParameter('sessionId', i, '');
+                    const requestBody = {
+                        action: memoryAction,
+                        session_id: sessionId,
+                    };
+                    if (memoryAction === 'store') {
+                        const memoryData = this.getNodeParameter('memoryData', i);
+                        requestBody.data = memoryData;
+                    }
+                    const response = await makeN8nAiAgentRequest(this, '/memory', requestBody, false);
+                    const result = {
+                        action: memoryAction,
+                        session_id: sessionId,
+                        data: response.data || response.memory,
+                        operation,
+                    };
+                    returnData.push({
+                        json: result,
+                        pairedItem: { item: i },
+                    });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                            operation: this.getNodeParameter('operation', i),
+                            model: this.getNodeParameter('model', i),
+                        },
+                        pairedItem: { item: i },
+                    });
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        return [returnData];
+    }
+}
+exports.N8nAiAgent = N8nAiAgent;
+async function makeN8nAiAgentRequest(context, endpoint, requestBody, hasMedia) {
+    const credentials = await context.getCredentials('n8nApi');
+    const baseUrl = credentials.baseUrl || 'http://localhost:5678';
+    const apiKey = credentials.apiKey;
+    if (!apiKey) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'N8N API key is required');
+    }
+    const options = {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`,
+            'User-Agent': 'N8nAiAgentNode/1.0',
+            ...(hasMedia && { 'AI-Vision-Request': 'true' }),
+        },
+        body: JSON.stringify(requestBody),
+        uri: `${baseUrl}/api/v1/ai-agent${endpoint}`,
+        json: true,
+    };
+    try {
+        const response = await context.helpers.request(options);
+        return response;
+    }
+    catch (error) {
+        const apiError = error;
+        if (apiError.statusCode === 401) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Invalid N8N API key');
+        }
+        else if (apiError.statusCode === 404) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'N8N AI Agent endpoint not found. Make sure AI Agent is enabled in your N8N instance.');
+        }
+        else {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `N8N AI Agent API error: ${apiError.message || String(error)}`);
+        }
+    }
+}

package/dist/nodes/N8nAiAgent/n8n-ai.svg

@@ -0,0 +1,35 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" width="100" height="100">
+  <!-- Background circle -->
+  <circle cx="50" cy="50" r="45" fill="#ff6d5a" stroke="#e55a4a" stroke-width="2"/>
+  
+  <!-- N8N Logo style -->
+  <g transform="translate(50,50)" fill="white">
+    <!-- Brain/Neural network pattern -->
+    <circle cx="-15" cy="-15" r="3" opacity="0.9"/>
+    <circle cx="0" cy="-20" r="3" opacity="0.9"/>
+    <circle cx="15" cy="-15" r="3" opacity="0.9"/>
+    <circle cx="-20" cy="0" r="3" opacity="0.9"/>
+    <circle cx="0" cy="0" r="4" opacity="1"/>
+    <circle cx="20" cy="0" r="3" opacity="0.9"/>
+    <circle cx="-15" cy="15" r="3" opacity="0.9"/>
+    <circle cx="0" cy="20" r="3" opacity="0.9"/>
+    <circle cx="15" cy="15" r="3" opacity="0.9"/>
+    
+    <!-- Connections -->
+    <line x1="-15" y1="-15" x2="0" y2="-20" stroke="white" stroke-width="1" opacity="0.6"/>
+    <line x1="0" y1="-20" x2="15" y2="-15" stroke="white" stroke-width="1" opacity="0.6"/>
+    <line x1="-20" y1="0" x2="-15" y2="-15" stroke="white" stroke-width="1" opacity="0.6"/>
+    <line x1="-20" y1="0" x2="0" y2="0" stroke="white" stroke-width="2" opacity="0.8"/>
+    <line x1="0" y1="0" x2="20" y2="0" stroke="white" stroke-width="2" opacity="0.8"/>
+    <line x1="20" y1="0" x2="15" y2="15" stroke="white" stroke-width="1" opacity="0.6"/>
+    <line x1="0" y1="0" x2="0" y2="20" stroke="white" stroke-width="2" opacity="0.8"/>
+    <line x1="-15" y1="15" x2="0" y2="20" stroke="white" stroke-width="1" opacity="0.6"/>
+    <line x1="0" y1="20" x2="15" y2="15" stroke="white" stroke-width="1" opacity="0.6"/>
+    
+    <!-- AI indicator -->
+    <text x="0" y="35" text-anchor="middle" font-family="Arial, sans-serif" font-size="12" font-weight="bold" fill="white">AI</text>
+  </g>
+  
+  <!-- N8N text at bottom -->
+  <text x="50" y="85" text-anchor="middle" font-family="Arial, sans-serif" font-size="10" font-weight="bold" fill="white">N8N</text>
+</svg>

package/dist/nodes/N8nAiAgent/nodeProperties.d.ts

@@ -0,0 +1,2 @@
+import { INodeProperties } from 'n8n-workflow';
+export declare const nodeProperties: INodeProperties[];

package/dist/nodes/N8nAiAgent/nodeProperties.js

@@ -0,0 +1,432 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeProperties = void 0;
+exports.nodeProperties = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        options: [
+            {
+                name: 'Chat',
+                value: 'chat',
+                description: 'Send a chat message to N8N AI Agent',
+                action: 'Send a chat message',
+            },
+            {
+                name: 'Use Tools',
+                value: 'tools',
+                description: 'Execute specific tools through AI Agent',
+                action: 'Execute tools',
+            },
+            {
+                name: 'Memory',
+                value: 'memory',
+                description: 'Manage AI Agent memory/context',
+                action: 'Manage memory',
+            },
+        ],
+        default: 'chat',
+    },
+    {
+        displayName: 'AI Model',
+        name: 'model',
+        type: 'options',
+        options: [
+            {
+                name: 'GPT-4 Turbo',
+                value: 'gpt-4-turbo',
+                description: 'OpenAI GPT-4 Turbo - Latest and most capable',
+            },
+            {
+                name: 'GPT-4',
+                value: 'gpt-4',
+                description: 'OpenAI GPT-4 - High quality reasoning',
+            },
+            {
+                name: 'GPT-3.5 Turbo',
+                value: 'gpt-3.5-turbo',
+                description: 'OpenAI GPT-3.5 Turbo - Fast and efficient',
+            },
+            {
+                name: 'Claude 3 Opus',
+                value: 'claude-3-opus',
+                description: 'Anthropic Claude 3 Opus - Superior reasoning',
+            },
+            {
+                name: 'Claude 3 Sonnet',
+                value: 'claude-3-sonnet',
+                description: 'Anthropic Claude 3 Sonnet - Balanced performance',
+            },
+            {
+                name: 'Claude 3 Haiku',
+                value: 'claude-3-haiku',
+                description: 'Anthropic Claude 3 Haiku - Fast responses',
+            },
+            {
+                name: 'Gemini Pro',
+                value: 'gemini-pro',
+                description: 'Google Gemini Pro - Multimodal capabilities',
+            },
+        ],
+        default: 'gpt-4-turbo',
+        description: 'Select the AI model to use',
+    },
+    {
+        displayName: 'Message',
+        name: 'message',
+        type: 'string',
+        typeOptions: {
+            rows: 3,
+        },
+        displayOptions: {
+            show: {
+                operation: ['chat'],
+            },
+        },
+        default: '',
+        placeholder: 'Enter your message here...',
+        description: 'The message to send to the AI Agent',
+        required: true,
+    },
+    {
+        displayName: 'System Message',
+        name: 'systemMessage',
+        type: 'string',
+        typeOptions: {
+            rows: 2,
+        },
+        displayOptions: {
+            show: {
+                operation: ['chat'],
+            },
+        },
+        default: '',
+        placeholder: 'You are a helpful AI assistant...',
+        description: 'System prompt to set the AI behavior and context',
+    },
+    {
+        displayName: 'Include Media',
+        name: 'includeMedia',
+        type: 'boolean',
+        displayOptions: {
+            show: {
+                operation: ['chat'],
+            },
+        },
+        default: false,
+        description: 'Whether to include images in the chat message',
+    },
+    {
+        displayName: 'Media Source',
+        name: 'mediaSource',
+        type: 'options',
+        options: [
+            {
+                name: 'Upload File',
+                value: 'manual',
+                description: 'Upload an image file directly',
+            },
+            {
+                name: 'From URL',
+                value: 'url',
+                description: 'Use an image from URL',
+            },
+            {
+                name: 'From Binary Data',
+                value: 'binary',
+                description: 'Use image from previous node binary data',
+            },
+        ],
+        displayOptions: {
+            show: {
+                operation: ['chat'],
+                includeMedia: [true],
+            },
+        },
+        default: 'manual',
+        description: 'Source of the media file',
+    },
+    {
+        displayName: 'Image File',
+        name: 'mediaFile',
+        type: 'string',
+        displayOptions: {
+            show: {
+                operation: ['chat'],
+                includeMedia: [true],
+                mediaSource: ['manual'],
+            },
+        },
+        default: '',
+        placeholder: 'Paste base64 image data...',
+        description: 'Base64 encoded image data',
+    },
+    {
+        displayName: 'Image URL',
+        name: 'mediaUrl',
+        type: 'string',
+        displayOptions: {
+            show: {
+                operation: ['chat'],
+                includeMedia: [true],
+                mediaSource: ['url'],
+            },
+        },
+        default: '',
+        placeholder: 'https://example.com/image.jpg',
+        description: 'URL of the image to analyze',
+    },
+    {
+        displayName: 'Binary Property',
+        name: 'mediaProperty',
+        type: 'string',
+        displayOptions: {
+            show: {
+                operation: ['chat'],
+                includeMedia: [true],
+                mediaSource: ['binary'],
+            },
+        },
+        default: 'data',
+        placeholder: 'data',
+        description: 'Name of the binary property containing the image',
+    },
+    {
+        displayName: 'Include Conversation History',
+        name: 'includeHistory',
+        type: 'boolean',
+        displayOptions: {
+            show: {
+                operation: ['chat'],
+            },
+        },
+        default: false,
+        description: 'Include previous messages for context',
+    },
+    {
+        displayName: 'Conversation History',
+        name: 'conversationHistory',
+        type: 'json',
+        typeOptions: {
+            rows: 4,
+        },
+        displayOptions: {
+            show: {
+                operation: ['chat'],
+                includeHistory: [true],
+            },
+        },
+        default: '[]',
+        placeholder: '[{"role": "user", "content": "Hello"}, {"role": "assistant", "content": "Hi there!"}]',
+        description: 'Previous messages in OpenAI chat format',
+    },
+    {
+        displayName: 'Enable Tools',
+        name: 'enableTools',
+        type: 'boolean',
+        displayOptions: {
+            show: {
+                operation: ['chat'],
+            },
+        },
+        default: false,
+        description: 'Allow AI to use tools and function calling',
+    },
+    {
+        displayName: 'Tools Configuration',
+        name: 'toolsConfig',
+        type: 'json',
+        typeOptions: {
+            rows: 6,
+        },
+        displayOptions: {
+            show: {
+                operation: ['chat'],
+                enableTools: [true],
+            },
+        },
+        default: '{"tools": []}',
+        placeholder: '{"tools": [{"type": "function", "function": {"name": "get_weather", "description": "Get weather info"}}]}',
+        description: 'Tools available to the AI Agent',
+    },
+    {
+        displayName: 'Tool Name',
+        name: 'toolName',
+        type: 'string',
+        displayOptions: {
+            show: {
+                operation: ['tools'],
+            },
+        },
+        default: '',
+        placeholder: 'get_weather',
+        description: 'Name of the tool to execute',
+        required: true,
+    },
+    {
+        displayName: 'Tool Arguments',
+        name: 'toolArguments',
+        type: 'json',
+        typeOptions: {
+            rows: 3,
+        },
+        displayOptions: {
+            show: {
+                operation: ['tools'],
+            },
+        },
+        default: '{}',
+        placeholder: '{"location": "São Paulo", "units": "celsius"}',
+        description: 'Arguments to pass to the tool',
+    },
+    {
+        displayName: 'Context',
+        name: 'context',
+        type: 'string',
+        typeOptions: {
+            rows: 2,
+        },
+        displayOptions: {
+            show: {
+                operation: ['tools'],
+            },
+        },
+        default: '',
+        placeholder: 'User is asking about weather in their city...',
+        description: 'Context for tool execution',
+    },
+    {
+        displayName: 'Memory Action',
+        name: 'memoryAction',
+        type: 'options',
+        options: [
+            {
+                name: 'Store',
+                value: 'store',
+                description: 'Store data in AI Agent memory',
+            },
+            {
+                name: 'Retrieve',
+                value: 'retrieve',
+                description: 'Retrieve data from AI Agent memory',
+            },
+            {
+                name: 'Clear',
+                value: 'clear',
+                description: 'Clear AI Agent memory',
+            },
+        ],
+        displayOptions: {
+            show: {
+                operation: ['memory'],
+            },
+        },
+        default: 'retrieve',
+        description: 'Action to perform on AI Agent memory',
+    },
+    {
+        displayName: 'Session ID',
+        name: 'sessionId',
+        type: 'string',
+        displayOptions: {
+            show: {
+                operation: ['memory'],
+            },
+        },
+        default: '',
+        placeholder: 'user-123',
+        description: 'Unique session identifier for memory isolation',
+    },
+    {
+        displayName: 'Memory Data',
+        name: 'memoryData',
+        type: 'json',
+        typeOptions: {
+            rows: 3,
+        },
+        displayOptions: {
+            show: {
+                operation: ['memory'],
+                memoryAction: ['store'],
+            },
+        },
+        default: '{}',
+        placeholder: '{"user_preferences": {"language": "pt-BR", "timezone": "America/Sao_Paulo"}}',
+        description: 'Data to store in memory',
+    },
+    {
+        displayName: 'Advanced Options',
+        name: 'advancedOptions',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        displayOptions: {
+            show: {
+                operation: ['chat'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Max Tokens',
+                name: 'maxTokens',
+                type: 'number',
+                default: 1000,
+                description: 'Maximum number of tokens to generate (0 for model default)',
+                typeOptions: {
+                    minValue: 0,
+                    maxValue: 4000,
+                },
+            },
+            {
+                displayName: 'Temperature',
+                name: 'temperature',
+                type: 'number',
+                default: 0.7,
+                description: 'Controls randomness (0.0 = deterministic, 1.0 = very random)',
+                typeOptions: {
+                    minValue: 0,
+                    maxValue: 1,
+                    numberPrecision: 2,
+                },
+            },
+            {
+                displayName: 'Top P',
+                name: 'topP',
+                type: 'number',
+                default: 1,
+                description: 'Controls diversity via nucleus sampling',
+                typeOptions: {
+                    minValue: 0.01,
+                    maxValue: 1,
+                    numberPrecision: 2,
+                },
+            },
+            {
+                displayName: 'Frequency Penalty',
+                name: 'frequencyPenalty',
+                type: 'number',
+                default: 0,
+                description: 'Reduces repetition of words',
+                typeOptions: {
+                    minValue: -2,
+                    maxValue: 2,
+                    numberPrecision: 2,
+                },
+            },
+            {
+                displayName: 'Presence Penalty',
+                name: 'presencePenalty',
+                type: 'number',
+                default: 0,
+                description: 'Encourages new topics',
+                typeOptions: {
+                    minValue: -2,
+                    maxValue: 2,
+                    numberPrecision: 2,
+                },
+            },
+        ],
+    },
+];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "n8n-nodes-github-copilot",
-  "version": "3.2.6",
-  "description": "n8n community node for GitHub Copilot with CLI integration and official Chat API access to GPT-5, Claude, Gemini and more using your existing Copilot credits",
+  "version": "3.3.0",
+  "description": "n8n community node for GitHub Copilot and N8N AI Agent with CLI integration and official Chat API access to GPT-5, Claude, Gemini and more using your existing Copilot credits",
   "license": "MIT",
   "homepage": "https://github.com/sufficit/n8n-nodes-github-copilot",
   "author": {
@@ -32,13 +32,15 @@
     ],
     "nodes": [
       "dist/nodes/GitHubCopilot/GitHubCopilot.node.js",
-      "dist/nodes/GitHubCopilotChatAPI/GitHubCopilotChatAPI.node.js"
+      "dist/nodes/GitHubCopilotChatAPI/GitHubCopilotChatAPI.node.js",
+      "dist/nodes/N8nAiAgent/N8nAiAgent.node.js"
     ]
   },
   "keywords": [
     "n8n-community-node-package",
     "github",
     "copilot",
+    "n8n-ai-agent",
     "ai",
     "gpt-5",
     "claude",