n8n-nodes-github-copilot 3.2.2 → 3.2.4

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

@@ -3,55 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitHubCopilotChatAPI = void 0;
 const utils_1 = require("./utils");
 const nodeProperties_1 = require("./nodeProperties");
-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 modelCapabilities_1 = require("./utils/modelCapabilities");
+const mediaDetection_1 = require("./utils/mediaDetection");
 class GitHubCopilotChatAPI {
     constructor() {
         this.description = {
@@ -88,8 +41,18 @@ 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 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 = [];
                     if (systemMessage) {
                         messages.push({
@@ -98,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({
@@ -106,37 +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: 'input_audio',
-                                    input_audio: {
-                                        data: audioResult.dataUrl.split(',')[1],
-                                        format: audioResult.dataUrl.includes('mp3') ? 'mp3' : 'wav'
+                                    type: 'image_url',
+                                    image_url: {
+                                        url: mediaResult.dataUrl,
                                     },
                                 });
+                            }
+                            else if (mediaResult.type === 'audio' && mediaResult.dataUrl) {
                                 contentArray.push({
                                     type: 'text',
-                                    text: `Please transcribe this audio: ${audioResult.description}`,
+                                    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({
@@ -149,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,32 +24,32 @@ exports.nodeProperties = [
             {
                 name: 'GPT-5',
                 value: 'gpt-5',
-                description: 'OpenAI GPT-5 (Latest and most capable)',
+                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)',
+                description: 'OpenAI GPT-5 Mini (Faster, cost-effective) ✓ Images ✓ Audio',
             },
             {
                 name: 'Claude Opus 4.1',
                 value: 'claude-opus-4.1',
-                description: 'Anthropic Claude Opus 4.1 (Advanced reasoning)',
+                description: 'Anthropic Claude Opus 4.1 (Advanced reasoning) ✗ Text only',
             },
             {
                 name: 'Gemini 2.5 Pro',
                 value: 'gemini-2.5-pro',
-                description: 'Google Gemini 2.5 Pro (Multimodal capabilities)',
+                description: 'Google Gemini 2.5 Pro (Multimodal capabilities) ✓ Images ✓ Audio',
             },
             {
                 name: 'Grok Code Fast 1',
                 value: 'grok-code-fast-1',
-                description: 'xAI Grok Code Fast 1 (Optimized for coding)',
+                description: 'xAI Grok Code Fast 1 (Optimized for coding) ✗ Text only',
             },
             {
                 name: 'GPT-4.1 Copilot',
                 value: 'gpt-4.1-copilot',
-                description: 'OpenAI GPT-4.1 specialized for coding assistance',
+                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',
+        description: 'Whether to include a media file (image or audio) in the message. 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 (auto-detects image/audio)',
     },
     {
-        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',
     },
     {
-        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',
-    },
-    {
-        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

@@ -0,0 +1,9 @@
+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';
+    dataUrl?: string;
+    description: string;
+    mimeType: string;
+}>;
+export declare function isImageMimeType(mimeType: string): boolean;
+export declare function isAudioMimeType(mimeType: string): boolean;

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+            return {
+                type: 'image',
+                dataUrl: `data:${imageResult.mimeType};base64,${imageResult.data}`,
+                description: `Image file: ${imageResult.filename} (${Math.round(imageResult.size / 1024)}KB)`,
+                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)`,
+                    mimeType: audioResult.mimeType,
+                };
+            }
+            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'}`);
+            }
+        }
+    }
+    catch (error) {
+        return {
+            type: 'unknown',
+            description: `Error processing media file: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            mimeType: 'unknown',
+        };
+    }
+}
+exports.processMediaFile = processMediaFile;
+function isImageMimeType(mimeType) {
+    return mimeType.startsWith('image/') && !mimeType.includes('svg');
+}
+exports.isImageMimeType = isImageMimeType;
+function isAudioMimeType(mimeType) {
+    return mimeType.startsWith('audio/') ||
+        mimeType === 'application/ogg' ||
+        mimeType === 'video/mp4';
+}
+exports.isAudioMimeType = isAudioMimeType;

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

@@ -0,0 +1,5 @@
+import { ModelCapabilities, ModelValidationResult } from './types';
+export declare const MODEL_CAPABILITIES: Record<string, ModelCapabilities>;
+export declare function validateModelCapabilities(model: string, includeImage: boolean, includeAudio: boolean): ModelValidationResult;
+export declare function getSupportedModels(requireImages?: boolean, requireAudio?: boolean): string[];
+export declare function getModelInfo(model: string): ModelCapabilities | null;

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelInfo = exports.getSupportedModels = exports.validateModelCapabilities = exports.MODEL_CAPABILITIES = void 0;
+exports.MODEL_CAPABILITIES = {
+    'gpt-5': {
+        supportsImages: true,
+        supportsAudio: true,
+        maxContextTokens: 200000,
+        description: 'OpenAI GPT-5 with image support and audio analysis via GitHub Copilot API',
+    },
+    'gpt-5-mini': {
+        supportsImages: true,
+        supportsAudio: true,
+        maxContextTokens: 128000,
+        description: 'OpenAI GPT-5 Mini with image support and audio analysis via GitHub Copilot API',
+    },
+    'gpt-4.1-copilot': {
+        supportsImages: true,
+        supportsAudio: true,
+        maxContextTokens: 128000,
+        description: 'OpenAI GPT-4.1 with image support and audio analysis via GitHub Copilot API',
+    },
+    'claude-opus-4.1': {
+        supportsImages: false,
+        supportsAudio: false,
+        maxContextTokens: 200000,
+        description: 'Anthropic Claude Opus 4.1 - Text only via GitHub Copilot API',
+    },
+    'claude-3.5-sonnet': {
+        supportsImages: false,
+        supportsAudio: false,
+        maxContextTokens: 200000,
+        description: 'Anthropic Claude 3.5 Sonnet - Text only via GitHub Copilot API',
+    },
+    'gemini-2.5-pro': {
+        supportsImages: true,
+        supportsAudio: true,
+        maxContextTokens: 1000000,
+        description: 'Google Gemini 2.5 Pro with multimodal support via GitHub Copilot API',
+    },
+    'gemini-2.0-flash': {
+        supportsImages: true,
+        supportsAudio: true,
+        maxContextTokens: 1000000,
+        description: 'Google Gemini 2.0 Flash with multimodal support via GitHub Copilot API',
+    },
+    'grok-code-fast-1': {
+        supportsImages: false,
+        supportsAudio: false,
+        maxContextTokens: 128000,
+        description: 'xAI Grok Code Fast 1 - Text only via GitHub Copilot API',
+    },
+    'o3': {
+        supportsImages: false,
+        supportsAudio: false,
+        maxContextTokens: 200000,
+        description: 'OpenAI o3 - Text only via GitHub Copilot API',
+    },
+    'o3-mini': {
+        supportsImages: false,
+        supportsAudio: false,
+        maxContextTokens: 128000,
+        description: 'OpenAI o3-mini - Text only via GitHub Copilot API',
+    },
+};
+function validateModelCapabilities(model, includeImage, includeAudio) {
+    const capabilities = exports.MODEL_CAPABILITIES[model];
+    if (!capabilities) {
+        return {
+            isValid: false,
+            errorMessage: `Unknown model: ${model}. Please check if the model name is correct.`,
+        };
+    }
+    const warnings = [];
+    let isValid = true;
+    let errorMessage;
+    if (includeImage && !capabilities.supportsImages) {
+        isValid = false;
+        errorMessage = `Model ${model} does not support image input. Please disable image upload or choose a different model (e.g., GPT-5, Gemini 2.5 Pro).`;
+    }
+    if (includeAudio && !capabilities.supportsAudio) {
+        isValid = false;
+        errorMessage = `Model ${model} does not support audio input. Please disable audio upload or choose a different model (e.g., GPT-5, Gemini 2.5 Pro).`;
+    }
+    if (model.includes('claude') && (includeImage || includeAudio)) {
+        warnings.push('Claude models typically work best with text-only input via GitHub Copilot API.');
+    }
+    if (model.includes('grok') && (includeImage || includeAudio)) {
+        warnings.push('Grok models are optimized for coding tasks and work best with text input.');
+    }
+    return {
+        isValid,
+        errorMessage,
+        warnings: warnings.length > 0 ? warnings : undefined,
+    };
+}
+exports.validateModelCapabilities = validateModelCapabilities;
+function getSupportedModels(requireImages = false, requireAudio = false) {
+    return Object.entries(exports.MODEL_CAPABILITIES)
+        .filter(([, capabilities]) => {
+        if (requireImages && !capabilities.supportsImages)
+            return false;
+        if (requireAudio && !capabilities.supportsAudio)
+            return false;
+        return true;
+    })
+        .map(([model]) => model);
+}
+exports.getSupportedModels = getSupportedModels;
+function getModelInfo(model) {
+    return exports.MODEL_CAPABILITIES[model] || null;
+}
+exports.getModelInfo = getModelInfo;

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

@@ -9,10 +9,6 @@ export interface ChatMessageContent {
     image_url?: {
         url: string;
     };
-    input_audio?: {
-        data: string;
-        format: string;
-    };
 }
 export interface CopilotResponse {
     choices: Array<{
@@ -48,3 +44,14 @@ export interface OptimizationOptions {
     quality?: number;
     maxSizeKB?: number;
 }
+export interface ModelCapabilities {
+    supportsImages: boolean;
+    supportsAudio: boolean;
+    maxContextTokens: number;
+    description: string;
+}
+export interface ModelValidationResult {
+    isValid: boolean;
+    errorMessage?: string;
+    warnings?: string[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-github-copilot",
-  "version": "3.2.2",
+  "version": "3.2.4",
   "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",