n8n-nodes-github-copilot 3.2.3 → 3.2.5

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

@@ -4,55 +4,7 @@ exports.GitHubCopilotChatAPI = void 0;
 const utils_1 = require("./utils");
 const nodeProperties_1 = require("./nodeProperties");
 const modelCapabilities_1 = require("./utils/modelCapabilities");
-async function processAudioFileLegacy(context, itemIndex) {
-    const audioSource = context.getNodeParameter('audioSource', itemIndex);
-    try {
-        const audioFile = context.getNodeParameter('audioFile', itemIndex, '');
-        const audioUrl = context.getNodeParameter('audioUrl', itemIndex, '');
-        const audioProperty = context.getNodeParameter('audioBinaryProperty', itemIndex, '');
-        const result = await (0, utils_1.processAudioFile)(context, itemIndex, audioSource, audioFile, audioUrl, audioProperty);
-        const tokenValidation = (0, utils_1.validateTokenLimit)(result.estimatedTokens, 100000);
-        if (!tokenValidation.valid) {
-            return {
-                dataUrl: '',
-                description: (0, utils_1.createAudioSummary)(result.filename, result.size)
-            };
-        }
-        const optimized = (0, utils_1.optimizeAudioForTokens)(result.data, 80000);
-        let description = `Audio file: ${result.filename} (${Math.round(result.size / 1024)}KB)`;
-        if (optimized.truncated) {
-            description += ` - Compressed from ${optimized.originalTokens} to ${optimized.finalTokens} tokens`;
-        }
-        return {
-            dataUrl: `data:${result.mimeType};base64,${optimized.data}`,
-            description
-        };
-    }
-    catch (error) {
-        return {
-            dataUrl: '',
-            description: `Error processing audio: ${error instanceof Error ? error.message : 'Unknown error'}`
-        };
-    }
-}
-async function processImageFileLegacy(context, itemIndex) {
-    const imageSource = context.getNodeParameter('imageSource', itemIndex);
-    try {
-        const imageFile = context.getNodeParameter('imageFile', itemIndex, '');
-        const imageUrl = context.getNodeParameter('imageUrl', itemIndex, '');
-        const imageProperty = context.getNodeParameter('imageBinaryProperty', itemIndex, '');
-        const result = await (0, utils_1.processImageFile)(context, itemIndex, imageSource, imageFile, imageUrl, imageProperty);
-        const tokenValidation = (0, utils_1.validateTokenLimit)(result.estimatedTokens, 50000);
-        if (!tokenValidation.valid) {
-            throw new Error(`Image too large: ${result.estimatedTokens} estimated tokens. Please use a smaller image.`);
-        }
-        const optimizedData = (0, utils_1.compressImageToTokenLimit)(result.data, 40000);
-        return `data:${result.mimeType};base64,${optimizedData}`;
-    }
-    catch (error) {
-        throw new Error(`Error processing image: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}
+const mediaDetection_1 = require("./utils/mediaDetection");
 class GitHubCopilotChatAPI {
     constructor() {
         this.description = {
@@ -89,15 +41,16 @@ class GitHubCopilotChatAPI {
                     const userMessage = this.getNodeParameter('message', i);
                     const systemMessage = this.getNodeParameter('systemMessage', i, '');
                     const advancedOptions = this.getNodeParameter('advancedOptions', i, {});
-                    const includeImage = this.getNodeParameter('includeImage', i, false);
-                    const includeAudio = this.getNodeParameter('includeAudio', i, false);
-                    const validation = (0, modelCapabilities_1.validateModelCapabilities)(model, includeImage, includeAudio);
-                    if (!validation.isValid) {
-                        throw new Error(validation.errorMessage || 'Model validation failed');
-                    }
-                    if (validation.warnings) {
-                        for (const warning of validation.warnings) {
-                            console.warn(`GitHub Copilot API Warning: ${warning}`);
+                    const includeMedia = this.getNodeParameter('includeMedia', i, false);
+                    if (includeMedia) {
+                        const validation = (0, modelCapabilities_1.validateModelCapabilities)(model, true, true);
+                        if (!validation.isValid) {
+                            throw new Error(validation.errorMessage || 'Model validation failed');
+                        }
+                        if (validation.warnings) {
+                            for (const warning of validation.warnings) {
+                                console.warn(`GitHub Copilot API Warning: ${warning}`);
+                            }
                         }
                     }
                     const messages = [];
@@ -108,7 +61,11 @@ class GitHubCopilotChatAPI {
                         });
                     }
                     let userContent = userMessage;
-                    if (includeImage || includeAudio) {
+                    if (includeMedia) {
+                        const mediaSource = this.getNodeParameter('mediaSource', i);
+                        const mediaFile = this.getNodeParameter('mediaFile', i, '');
+                        const mediaUrl = this.getNodeParameter('mediaUrl', i, '');
+                        const mediaBinaryProperty = this.getNodeParameter('mediaBinaryProperty', i, '');
                         const contentArray = [];
                         if (userMessage.trim()) {
                             contentArray.push({
@@ -116,30 +73,35 @@ class GitHubCopilotChatAPI {
                                 text: userMessage,
                             });
                         }
-                        if (includeImage) {
-                            const imageDataUrl = await processImageFileLegacy(this, i);
-                            contentArray.push({
-                                type: 'image_url',
-                                image_url: {
-                                    url: imageDataUrl,
-                                },
-                            });
-                        }
-                        if (includeAudio) {
-                            const audioResult = await processAudioFileLegacy(this, i);
-                            if (audioResult.dataUrl) {
+                        try {
+                            const mediaResult = await (0, mediaDetection_1.processMediaFile)(this, i, mediaSource, mediaFile, mediaUrl, mediaBinaryProperty);
+                            if (mediaResult.type === 'image' && mediaResult.dataUrl) {
+                                contentArray.push({
+                                    type: 'image_url',
+                                    image_url: {
+                                        url: mediaResult.dataUrl,
+                                    },
+                                });
+                            }
+                            else if (mediaResult.type === 'audio' && mediaResult.dataUrl) {
                                 contentArray.push({
                                     type: 'text',
-                                    text: `Please analyze this audio file: ${audioResult.description}\n\nAudio data (base64): ${audioResult.dataUrl}`,
+                                    text: `Please analyze this audio file: ${mediaResult.description}\n\nAudio data (base64): ${mediaResult.dataUrl}`,
                                 });
                             }
                             else {
                                 contentArray.push({
                                     type: 'text',
-                                    text: `[Audio processing failed: ${audioResult.description}]`,
+                                    text: `[Media processing failed: ${mediaResult.description}]`,
                                 });
                             }
                         }
+                        catch (error) {
+                            contentArray.push({
+                                type: 'text',
+                                text: `[Media processing error: ${error instanceof Error ? error.message : 'Unknown error'}]`,
+                            });
+                        }
                         userContent = contentArray;
                     }
                     messages.push({
@@ -152,7 +114,7 @@ class GitHubCopilotChatAPI {
                         stream: false,
                         ...advancedOptions,
                     };
-                    const hasMedia = includeImage || includeAudio;
+                    const hasMedia = includeMedia;
                     const response = await (0, utils_1.makeApiRequest)(this, '/chat/completions', requestBody, hasMedia);
                     const result = {
                         message: ((_b = (_a = response.choices[0]) === null || _a === void 0 ? void 0 : _a.message) === null || _b === void 0 ? void 0 : _b.content) || '',

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',
+                description: 'OpenAI GPT-5 (Latest and most capable) ✓ Images ✓ Audio',
             },
             {
                 name: 'GPT-5 Mini',
                 value: 'gpt-5-mini',
-                description: 'OpenAI GPT-5 Mini (Faster, cost-effective) ✓ Images',
+                description: 'OpenAI GPT-5 Mini (Faster, cost-effective) ✓ Images ✓ Audio',
             },
             {
                 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',
+                description: 'Google Gemini 2.5 Pro (Multimodal capabilities) ✓ Images ✓ Audio',
             },
             {
                 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',
+                description: 'OpenAI GPT-4.1 specialized for coding assistance ✓ Images ✓ Audio',
             },
         ],
         default: 'gpt-5-mini',
@@ -78,31 +78,31 @@ exports.nodeProperties = [
         description: 'System message to set the behavior of the AI model',
     },
     {
-        displayName: 'Include Image',
-        name: 'includeImage',
+        displayName: 'Include Media',
+        name: 'includeMedia',
         type: 'boolean',
         default: false,
-        description: 'Whether to include an image in the message. ✓ Supported by GPT and Gemini models via GitHub Copilot API.',
+        description: 'Whether to include a media file in the message. Supported: Images (PNG, JPEG, GIF, WebP) and Audio files. Type is auto-detected.',
     },
     {
-        displayName: 'Image Source',
-        name: 'imageSource',
+        displayName: 'Media Source',
+        name: 'mediaSource',
         type: 'options',
         displayOptions: {
             show: {
-                includeImage: [true],
+                includeMedia: [true],
             },
         },
         options: [
             {
                 name: 'Manual Input',
                 value: 'manual',
-                description: 'Provide image as base64 string or file path',
+                description: 'Provide media as base64 string or file path',
             },
             {
                 name: 'URL',
                 value: 'url',
-                description: 'Download image from URL',
+                description: 'Download media from URL',
             },
             {
                 name: 'Binary Data',
@@ -111,127 +111,49 @@ exports.nodeProperties = [
             },
         ],
         default: 'manual',
-        description: 'Source of the image data',
+        description: 'Source of the media data',
     },
     {
-        displayName: 'Image File',
-        name: 'imageFile',
+        displayName: 'Media File',
+        name: 'mediaFile',
         type: 'string',
         displayOptions: {
             show: {
-                includeImage: [true],
-                imageSource: ['manual'],
+                includeMedia: [true],
+                mediaSource: ['manual'],
             },
         },
         default: '',
         placeholder: 'Paste base64 string or file path',
-        description: 'Image as base64 string or file path',
+        description: 'Media file as base64 string or file path (Images: PNG/JPEG/GIF/WebP, Audio: MP3/WAV/M4A)',
     },
     {
-        displayName: 'Image URL',
-        name: 'imageUrl',
+        displayName: 'Media URL',
+        name: 'mediaUrl',
         type: 'string',
         displayOptions: {
             show: {
-                includeImage: [true],
-                imageSource: ['url'],
+                includeMedia: [true],
+                mediaSource: ['url'],
             },
         },
         default: '',
-        placeholder: 'https://example.com/image.jpg',
-        description: 'URL of the image to download and include',
+        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)',
     },
     {
-        displayName: 'Image Binary Property',
-        name: 'imageBinaryProperty',
+        displayName: 'Media Binary Property',
+        name: 'mediaBinaryProperty',
         type: 'string',
         displayOptions: {
             show: {
-                includeImage: [true],
-                imageSource: ['binary'],
+                includeMedia: [true],
+                mediaSource: ['binary'],
             },
         },
         default: 'data',
         placeholder: 'data',
-        description: 'Name of the binary property containing the image',
-    },
-    {
-        displayName: 'Include Audio',
-        name: 'includeAudio',
-        type: 'boolean',
-        default: false,
-        description: 'Whether to include an audio file in the message. ⚠️ Audio is sent as base64 text to models for analysis (GitHub Copilot API limitation).',
-    },
-    {
-        displayName: 'Audio Source',
-        name: 'audioSource',
-        type: 'options',
-        displayOptions: {
-            show: {
-                includeAudio: [true],
-            },
-        },
-        options: [
-            {
-                name: 'Manual Input',
-                value: 'manual',
-                description: 'Provide audio as base64 string or file path',
-            },
-            {
-                name: 'URL',
-                value: 'url',
-                description: 'Download audio from URL',
-            },
-            {
-                name: 'Binary Data',
-                value: 'binary',
-                description: 'Use binary data from previous node',
-            },
-        ],
-        default: 'manual',
-        description: 'Source of the audio data',
-    },
-    {
-        displayName: 'Audio File',
-        name: 'audioFile',
-        type: 'string',
-        displayOptions: {
-            show: {
-                includeAudio: [true],
-                audioSource: ['manual'],
-            },
-        },
-        default: '',
-        placeholder: 'Paste base64 string or file path',
-        description: 'Audio as base64 string or file path',
-    },
-    {
-        displayName: 'Audio URL',
-        name: 'audioUrl',
-        type: 'string',
-        displayOptions: {
-            show: {
-                includeAudio: [true],
-                audioSource: ['url'],
-            },
-        },
-        default: '',
-        placeholder: 'https://example.com/audio.mp3',
-        description: 'URL of the audio file to download and include',
-    },
-    {
-        displayName: 'Audio Binary Property',
-        name: 'audioBinaryProperty',
-        type: 'string',
-        displayOptions: {
-            show: {
-                includeAudio: [true],
-                audioSource: ['binary'],
-            },
-        },
-        default: 'data',
-        placeholder: 'data',
-        description: 'Name of the binary property containing the audio file',
+        description: 'Name of the binary property containing the media file',
     },
     {
         displayName: 'Advanced Options',

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

@@ -7,3 +7,9 @@ export declare function processMediaFile(context: IExecuteFunctions, itemIndex:
 }>;
 export declare function isImageMimeType(mimeType: string): boolean;
 export declare function isAudioMimeType(mimeType: string): boolean;
+export declare function validateImageFormat(mimeType: string): {
+    isValid: boolean;
+    error?: string;
+};
+export declare function getFileExtensionFromMimeType(mimeType: string): string;
+export declare function suggestImageConversion(mimeType: string): string;

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

@@ -1,15 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAudioMimeType = exports.isImageMimeType = exports.processMediaFile = void 0;
+exports.suggestImageConversion = exports.getFileExtensionFromMimeType = exports.validateImageFormat = exports.isAudioMimeType = exports.isImageMimeType = exports.processMediaFile = void 0;
 const index_1 = require("./index");
 async function processMediaFile(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty) {
     try {
         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)`,
+                description: `Image file: ${imageResult.filename} (${Math.round(imageResult.size / 1024)}KB, ${imageResult.mimeType})`,
                 mimeType: imageResult.mimeType,
             };
         }
@@ -24,7 +28,13 @@ async function processMediaFile(context, itemIndex, source, mediaFile, mediaUrl,
                 };
             }
             catch (audioError) {
-                throw new Error(`File is neither a valid image nor audio file. Image error: ${imageError instanceof Error ? imageError.message : 'Unknown'}. Audio error: ${audioError instanceof Error ? audioError.message : 'Unknown'}`);
+                const supportedImageFormats = ['PNG', 'JPEG', 'GIF', 'WebP'];
+                const supportedAudioFormats = ['MP3', 'WAV', 'M4A', 'OGG'];
+                throw new Error(`File is neither a valid image nor audio file.\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'}`);
             }
         }
     }
@@ -38,7 +48,14 @@ async function processMediaFile(context, itemIndex, source, mediaFile, mediaUrl,
 }
 exports.processMediaFile = processMediaFile;
 function isImageMimeType(mimeType) {
-    return mimeType.startsWith('image/') && !mimeType.includes('svg');
+    const supportedFormats = [
+        'image/png',
+        'image/jpeg',
+        'image/jpg',
+        'image/gif',
+        'image/webp'
+    ];
+    return supportedFormats.includes(mimeType.toLowerCase());
 }
 exports.isImageMimeType = isImageMimeType;
 function isAudioMimeType(mimeType) {
@@ -47,3 +64,36 @@ function isAudioMimeType(mimeType) {
         mimeType === 'video/mp4';
 }
 exports.isAudioMimeType = isAudioMimeType;
+function validateImageFormat(mimeType) {
+    if (!isImageMimeType(mimeType)) {
+        const supportedFormats = ['PNG', 'JPEG', 'GIF', 'WebP'];
+        return {
+            isValid: false,
+            error: `Unsupported image format: ${mimeType}. GitHub Copilot API only supports: ${supportedFormats.join(', ')}`
+        };
+    }
+    return { isValid: true };
+}
+exports.validateImageFormat = validateImageFormat;
+function getFileExtensionFromMimeType(mimeType) {
+    const mimeToExt = {
+        'image/png': 'png',
+        'image/jpeg': 'jpg',
+        'image/jpg': 'jpg',
+        'image/gif': 'gif',
+        'image/webp': 'webp',
+        'image/bmp': 'bmp',
+        'image/tiff': 'tiff',
+        'image/svg+xml': 'svg',
+    };
+    return mimeToExt[mimeType.toLowerCase()] || 'unknown';
+}
+exports.getFileExtensionFromMimeType = getFileExtensionFromMimeType;
+function suggestImageConversion(mimeType) {
+    const ext = getFileExtensionFromMimeType(mimeType);
+    const supportedFormats = ['PNG', 'JPEG', 'GIF', 'WebP'];
+    return `Image format ${ext.toUpperCase()} is not supported by GitHub Copilot API. ` +
+        `Please convert your image to one of these formats: ${supportedFormats.join(', ')}. ` +
+        `Recommended: Convert to PNG or WebP for best compatibility.`;
+}
+exports.suggestImageConversion = suggestImageConversion;

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: false,
+        supportsAudio: true,
         maxContextTokens: 200000,
-        description: 'OpenAI GPT-5 with image support via GitHub Copilot API',
+        description: 'OpenAI GPT-5 with image support and audio analysis via GitHub Copilot API',
     },
     'gpt-5-mini': {
         supportsImages: true,
-        supportsAudio: false,
+        supportsAudio: true,
         maxContextTokens: 128000,
-        description: 'OpenAI GPT-5 Mini with image support via GitHub Copilot API',
+        description: 'OpenAI GPT-5 Mini with image support and audio analysis via GitHub Copilot API',
     },
     'gpt-4.1-copilot': {
         supportsImages: true,
-        supportsAudio: false,
+        supportsAudio: true,
         maxContextTokens: 128000,
-        description: 'OpenAI GPT-4.1 with image support via GitHub Copilot API',
+        description: 'OpenAI GPT-4.1 with image support and audio analysis via GitHub Copilot API',
     },
     'claude-opus-4.1': {
         supportsImages: false,
@@ -34,15 +34,15 @@ exports.MODEL_CAPABILITIES = {
     },
     'gemini-2.5-pro': {
         supportsImages: true,
-        supportsAudio: false,
+        supportsAudio: true,
         maxContextTokens: 1000000,
-        description: 'Google Gemini 2.5 Pro via GitHub Copilot API',
+        description: 'Google Gemini 2.5 Pro with multimodal support via GitHub Copilot API',
     },
     'gemini-2.0-flash': {
         supportsImages: true,
-        supportsAudio: false,
+        supportsAudio: true,
         maxContextTokens: 1000000,
-        description: 'Google Gemini 2.0 Flash via GitHub Copilot API',
+        description: 'Google Gemini 2.0 Flash with multimodal support via GitHub Copilot API',
     },
     'grok-code-fast-1': {
         supportsImages: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-github-copilot",
-  "version": "3.2.3",
+  "version": "3.2.5",
   "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",
   "license": "MIT",
   "homepage": "https://github.com/sufficit/n8n-nodes-github-copilot",