n8n-nodes-github-copilot 3.1.0 → 3.2.1

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

@@ -1,183 +1,55 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitHubCopilotChatAPI = void 0;
-async function makeApiRequest(context, endpoint, body) {
-    const credentials = await context.getCredentials('githubApi');
-    const options = {
-        method: 'POST',
-        headers: {
-            'Authorization': `Bearer ${credentials.accessToken}`,
-            'Content-Type': 'application/json',
-            'User-Agent': 'n8n-github-copilot-chat/3.0.0',
-        },
-        body: JSON.stringify(body),
-    };
-    const response = await fetch(`https://api.githubcopilot.com${endpoint}`, options);
-    if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`GitHub Copilot API error: ${response.status} ${response.statusText}. ${errorText}`);
-    }
-    return await response.json();
-}
-async function downloadFileFromUrl(url) {
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Failed to download file from URL: ${response.status} ${response.statusText}`);
-    }
-    return Buffer.from(await response.arrayBuffer());
-}
-async function getFileFromBinary(context, itemIndex, propertyName) {
-    const items = context.getInputData();
-    const item = items[itemIndex];
-    if (!item.binary || !item.binary[propertyName]) {
-        throw new Error(`No binary data found in property "${propertyName}"`);
-    }
-    const binaryData = item.binary[propertyName];
-    if (binaryData.data) {
-        return Buffer.from(binaryData.data, 'base64');
-    }
-    else if (binaryData.id) {
-        return await context.helpers.getBinaryDataBuffer(itemIndex, propertyName);
-    }
-    else {
-        throw new Error(`Invalid binary data format in property "${propertyName}"`);
-    }
-}
-async function processAudioFile(context, itemIndex) {
+const utils_1 = require("./utils");
+const nodeProperties_1 = require("./nodeProperties");
+async function processAudioFileLegacy(context, itemIndex) {
     const audioSource = context.getNodeParameter('audioSource', itemIndex);
-    let audioBuffer;
-    let filename = 'audio.mp3';
-    switch (audioSource) {
-        case 'manual':
-            const audioFile = context.getNodeParameter('audioFile', itemIndex);
-            if (audioFile.startsWith('data:audio/')) {
-                const base64Data = audioFile.split(',')[1];
-                audioBuffer = Buffer.from(base64Data, 'base64');
-            }
-            else if (audioFile.match(/^[A-Za-z0-9+/=]+$/)) {
-                audioBuffer = Buffer.from(audioFile, 'base64');
-            }
-            else {
-                const fs = await Promise.resolve().then(() => __importStar(require('fs')));
-                audioBuffer = fs.readFileSync(audioFile);
-                filename = audioFile.split(/[\\\/]/).pop() || 'audio.mp3';
-            }
-            break;
-        case 'url':
-            const audioUrl = context.getNodeParameter('audioUrl', itemIndex);
-            audioBuffer = await downloadFileFromUrl(audioUrl);
-            filename = audioUrl.split('/').pop() || 'audio.mp3';
-            break;
-        case 'binary':
-            const audioBinaryProperty = context.getNodeParameter('audioBinaryProperty', itemIndex);
-            audioBuffer = await getFileFromBinary(context, itemIndex, audioBinaryProperty);
-            const items = context.getInputData();
-            const item = items[itemIndex];
-            if (item.binary && item.binary[audioBinaryProperty] && item.binary[audioBinaryProperty].fileName) {
-                filename = item.binary[audioBinaryProperty].fileName || 'audio.mp3';
-            }
-            break;
-        default:
-            throw new Error(`Unknown audio source: ${audioSource}`);
+    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'}`
+        };
     }
-    const mimeType = getAudioMimeType(filename);
-    return `data:${mimeType};base64,${audioBuffer.toString('base64')}`;
 }
-async function processImageFile(context, itemIndex) {
+async function processImageFileLegacy(context, itemIndex) {
     const imageSource = context.getNodeParameter('imageSource', itemIndex);
-    let imageBuffer;
-    let filename = 'image.jpg';
-    switch (imageSource) {
-        case 'manual':
-            const imageFile = context.getNodeParameter('imageFile', itemIndex);
-            if (imageFile.startsWith('data:image/')) {
-                return imageFile;
-            }
-            else if (imageFile.match(/^[A-Za-z0-9+/=]+$/)) {
-                imageBuffer = Buffer.from(imageFile, 'base64');
-            }
-            else {
-                const fs = await Promise.resolve().then(() => __importStar(require('fs')));
-                imageBuffer = fs.readFileSync(imageFile);
-                filename = imageFile.split(/[\\\/]/).pop() || 'image.jpg';
-            }
-            break;
-        case 'url':
-            const imageUrl = context.getNodeParameter('imageUrl', itemIndex);
-            imageBuffer = await downloadFileFromUrl(imageUrl);
-            filename = imageUrl.split('/').pop() || 'image.jpg';
-            break;
-        case 'binary':
-            const imageBinaryProperty = context.getNodeParameter('imageBinaryProperty', itemIndex);
-            imageBuffer = await getFileFromBinary(context, itemIndex, imageBinaryProperty);
-            const items = context.getInputData();
-            const item = items[itemIndex];
-            if (item.binary && item.binary[imageBinaryProperty] && item.binary[imageBinaryProperty].fileName) {
-                filename = item.binary[imageBinaryProperty].fileName || 'image.jpg';
-            }
-            break;
-        default:
-            throw new Error(`Unknown image source: ${imageSource}`);
+    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}`;
     }
-    const mimeType = getMimeType(filename);
-    return `data:${mimeType};base64,${imageBuffer.toString('base64')}`;
-}
-function getMimeType(filename) {
-    const ext = filename.toLowerCase().split('.').pop();
-    switch (ext) {
-        case 'jpg':
-        case 'jpeg':
-            return 'image/jpeg';
-        case 'png':
-            return 'image/png';
-        case 'webp':
-            return 'image/webp';
-        case 'gif':
-            return 'image/gif';
-        default:
-            return 'image/jpeg';
-    }
-}
-function getAudioMimeType(filename) {
-    const ext = filename.toLowerCase().split('.').pop();
-    switch (ext) {
-        case 'mp3':
-            return 'audio/mpeg';
-        case 'wav':
-            return 'audio/wav';
-        case 'm4a':
-            return 'audio/mp4';
-        case 'flac':
-            return 'audio/flac';
-        case 'ogg':
-            return 'audio/ogg';
-        case 'aac':
-            return 'audio/aac';
-        default:
-            return 'audio/mpeg';
+    catch (error) {
+        throw new Error(`Error processing image: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
 class GitHubCopilotChatAPI {
@@ -201,384 +73,88 @@ class GitHubCopilotChatAPI {
                     required: true,
                 },
             ],
-            properties: [
-                {
-                    displayName: 'Operation',
-                    name: 'operation',
-                    type: 'options',
-                    options: [
-                        {
-                            name: 'Chat Completion',
-                            value: 'chatCompletion',
-                            description: 'Send a message and get AI response using Copilot models',
-                        },
-                        {
-                            name: 'Audio Transcription',
-                            value: 'audioTranscription',
-                            description: 'Transcribe audio file to text using Copilot',
-                        },
-                        {
-                            name: 'Image Analysis',
-                            value: 'imageAnalysis',
-                            description: 'Analyze image with AI (vision models)',
-                        },
-                    ],
-                    default: 'chatCompletion',
-                },
-                {
-                    displayName: 'Model',
-                    name: 'model',
-                    type: 'options',
-                    options: [
-                        {
-                            name: 'GPT-5 (Latest)',
-                            value: 'gpt-5',
-                            description: 'OpenAI GPT-5 - Latest and most advanced model',
-                        },
-                        {
-                            name: 'GPT-5 Mini',
-                            value: 'gpt-5-mini',
-                            description: 'OpenAI GPT-5 Mini - Faster and more efficient',
-                        },
-                        {
-                            name: 'Claude Opus 4.1',
-                            value: 'claude-opus-4.1',
-                            description: 'Anthropic Claude Opus 4.1 - Advanced reasoning',
-                        },
-                        {
-                            name: 'Gemini 2.5 Pro',
-                            value: 'gemini-2.5-pro',
-                            description: 'Google Gemini 2.5 Pro - Multimodal capabilities',
-                        },
-                        {
-                            name: 'Grok Code Fast 1',
-                            value: 'grok-code-fast-1',
-                            description: 'xAI Grok - Optimized for coding tasks',
-                        },
-                        {
-                            name: 'GPT-4.1 Copilot',
-                            value: 'gpt-4.1-copilot',
-                            description: 'GitHub Copilot optimized GPT-4.1 model',
-                        },
-                    ],
-                    default: 'gpt-5',
-                    description: 'Choose the AI model from your Copilot subscription',
-                },
-                {
-                    displayName: 'Message',
-                    name: 'message',
-                    type: 'string',
-                    typeOptions: {
-                        rows: 4,
-                    },
-                    default: '',
-                    placeholder: 'Enter your message here...',
-                    description: 'The message to send to the AI',
-                    displayOptions: {
-                        show: {
-                            operation: ['chatCompletion', 'imageAnalysis'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Audio Source',
-                    name: 'audioSource',
-                    type: 'options',
-                    options: [
-                        { name: 'File Path or Base64', value: 'manual' },
-                        { name: 'Download from URL', value: 'url' },
-                        { name: 'From Previous Node Binary', value: 'binary' },
-                    ],
-                    default: 'manual',
-                    description: 'Choose how to provide the audio file',
-                    displayOptions: {
-                        show: {
-                            operation: ['audioTranscription'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Audio File',
-                    name: 'audioFile',
-                    type: 'string',
-                    default: '',
-                    placeholder: 'Path to audio file or base64 data',
-                    description: 'Audio file to transcribe (supports MP3, WAV, M4A, FLAC, OGG)',
-                    displayOptions: {
-                        show: {
-                            operation: ['audioTranscription'],
-                            audioSource: ['manual'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Audio URL',
-                    name: 'audioUrl',
-                    type: 'string',
-                    default: '',
-                    placeholder: 'https://example.com/audio.mp3',
-                    description: 'URL to download audio file from',
-                    displayOptions: {
-                        show: {
-                            operation: ['audioTranscription'],
-                            audioSource: ['url'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Binary Property Name',
-                    name: 'audioBinaryProperty',
-                    type: 'string',
-                    default: 'data',
-                    placeholder: 'data',
-                    description: 'Name of the binary property containing the audio file',
-                    displayOptions: {
-                        show: {
-                            operation: ['audioTranscription'],
-                            audioSource: ['binary'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Audio Language',
-                    name: 'audioLanguage',
-                    type: 'options',
-                    options: [
-                        { name: 'Auto-detect', value: 'auto' },
-                        { name: 'Portuguese (Brazil)', value: 'pt' },
-                        { name: 'English', value: 'en' },
-                        { name: 'Spanish', value: 'es' },
-                        { name: 'French', value: 'fr' },
-                        { name: 'German', value: 'de' },
-                        { name: 'Italian', value: 'it' },
-                        { name: 'Japanese', value: 'ja' },
-                        { name: 'Chinese', value: 'zh' },
-                    ],
-                    default: 'auto',
-                    description: 'Language of the audio (helps with accuracy)',
-                    displayOptions: {
-                        show: {
-                            operation: ['audioTranscription'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Image Source',
-                    name: 'imageSource',
-                    type: 'options',
-                    options: [
-                        { name: 'File Path or Base64', value: 'manual' },
-                        { name: 'Download from URL', value: 'url' },
-                        { name: 'From Previous Node Binary', value: 'binary' },
-                    ],
-                    default: 'manual',
-                    description: 'Choose how to provide the image file',
-                    displayOptions: {
-                        show: {
-                            operation: ['imageAnalysis'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Image File',
-                    name: 'imageFile',
-                    type: 'string',
-                    default: '',
-                    placeholder: 'Path to image file or base64 data',
-                    description: 'Image file to analyze (supports JPG, PNG, WebP, GIF)',
-                    displayOptions: {
-                        show: {
-                            operation: ['imageAnalysis'],
-                            imageSource: ['manual'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Image URL',
-                    name: 'imageUrl',
-                    type: 'string',
-                    default: '',
-                    placeholder: 'https://example.com/image.jpg',
-                    description: 'URL to download image file from',
-                    displayOptions: {
-                        show: {
-                            operation: ['imageAnalysis'],
-                            imageSource: ['url'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Binary Property Name',
-                    name: 'imageBinaryProperty',
-                    type: 'string',
-                    default: 'data',
-                    placeholder: 'data',
-                    description: 'Name of the binary property containing the image file',
-                    displayOptions: {
-                        show: {
-                            operation: ['imageAnalysis'],
-                            imageSource: ['binary'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'System Prompt',
-                    name: 'systemPrompt',
-                    type: 'string',
-                    typeOptions: {
-                        rows: 2,
-                    },
-                    default: '',
-                    placeholder: 'You are a helpful assistant...',
-                    description: 'Optional system prompt to set AI behavior',
-                    displayOptions: {
-                        show: {
-                            operation: ['chatCompletion', 'imageAnalysis'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Temperature',
-                    name: 'temperature',
-                    type: 'number',
-                    typeOptions: {
-                        minValue: 0,
-                        maxValue: 2,
-                        numberStepSize: 0.1,
-                    },
-                    default: 1,
-                    description: 'Controls randomness: 0 = focused, 2 = creative',
-                    displayOptions: {
-                        show: {
-                            operation: ['chatCompletion', 'imageAnalysis'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Max Tokens',
-                    name: 'maxTokens',
-                    type: 'number',
-                    typeOptions: {
-                        minValue: 1,
-                        maxValue: 8192,
-                    },
-                    default: 2000,
-                    description: 'Maximum tokens in response',
-                    displayOptions: {
-                        show: {
-                            operation: ['chatCompletion', 'imageAnalysis'],
-                        },
-                    },
-                },
-            ],
+            properties: nodeProperties_1.nodeProperties,
         };
     }
     async execute() {
+        var _a, _b, _c;
         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);
-                let result;
-                if (operation === 'chatCompletion') {
-                    const message = this.getNodeParameter('message', i);
-                    const systemPrompt = this.getNodeParameter('systemPrompt', i);
-                    const temperature = this.getNodeParameter('temperature', i);
-                    const maxTokens = this.getNodeParameter('maxTokens', i);
+                if (operation === 'chat') {
+                    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 messages = [];
-                    if (systemPrompt) {
-                        messages.push({ role: 'system', content: systemPrompt });
-                    }
-                    messages.push({ role: 'user', content: message });
-                    const requestBody = {
-                        model: model,
-                        messages: messages,
-                        temperature: temperature,
-                        max_tokens: maxTokens,
-                        stream: false,
-                    };
-                    const response = await makeApiRequest(this, '/chat/completions', requestBody);
-                    result = {
-                        response: response.choices[0].message.content,
-                        model: model,
-                        usage: response.usage,
-                        finish_reason: response.choices[0].finish_reason,
-                        timestamp: new Date().toISOString(),
-                    };
-                }
-                else if (operation === 'audioTranscription') {
-                    const language = this.getNodeParameter('audioLanguage', i);
-                    const audioDataUrl = await processAudioFile(this, i);
-                    const transcriptionPrompt = language === 'auto'
-                        ? `Please transcribe this audio file to text. Detect the language automatically and provide the transcription.`
-                        : `Please transcribe this audio file to text. The audio is in ${language} language.`;
-                    const messages = [
-                        {
+                    if (systemMessage) {
+                        messages.push({
                             role: 'system',
-                            content: 'You are an expert at audio transcription. When given an audio file, provide an accurate transcription of the spoken content.'
-                        },
-                        {
-                            role: 'user',
-                            content: `${transcriptionPrompt}\n\nAudio file: ${audioDataUrl}`
+                            content: systemMessage,
+                        });
+                    }
+                    let userContent = userMessage;
+                    if (includeImage || includeAudio) {
+                        const contentArray = [];
+                        if (userMessage.trim()) {
+                            contentArray.push({
+                                type: 'text',
+                                text: userMessage,
+                            });
                         }
-                    ];
-                    const requestBody = {
-                        model: model,
-                        messages: messages,
-                        temperature: 0.1,
-                        max_tokens: 4000,
-                        stream: false,
-                    };
-                    const response = await makeApiRequest(this, '/chat/completions', requestBody);
-                    result = {
-                        transcription: response.choices[0].message.content,
-                        language: language,
-                        model: model,
-                        usage: response.usage,
-                        timestamp: new Date().toISOString(),
-                    };
-                }
-                else if (operation === 'imageAnalysis') {
-                    const message = this.getNodeParameter('message', i);
-                    const systemPrompt = this.getNodeParameter('systemPrompt', i);
-                    const temperature = this.getNodeParameter('temperature', i);
-                    const maxTokens = this.getNodeParameter('maxTokens', i);
-                    const imageBase64 = await processImageFile(this, i);
-                    const messages = [];
-                    if (systemPrompt) {
-                        messages.push({ role: 'system', content: systemPrompt });
+                        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) {
+                                contentArray.push({
+                                    type: 'text',
+                                    text: `[Audio included: ${audioResult.description}]`,
+                                });
+                            }
+                            else {
+                                contentArray.push({
+                                    type: 'text',
+                                    text: `[Audio processing failed: ${audioResult.description}]`,
+                                });
+                            }
+                        }
+                        userContent = contentArray;
                     }
                     messages.push({
                         role: 'user',
-                        content: [
-                            { type: 'text', text: message },
-                            { type: 'image_url', image_url: { url: imageBase64 } }
-                        ]
+                        content: userContent,
                     });
                     const requestBody = {
-                        model: model,
-                        messages: messages,
-                        temperature: temperature,
-                        max_tokens: maxTokens,
+                        model,
+                        messages,
                         stream: false,
+                        ...advancedOptions,
                     };
-                    const response = await makeApiRequest(this, '/chat/completions', requestBody);
-                    result = {
-                        response: response.choices[0].message.content,
-                        model: model,
-                        usage: response.usage,
-                        finish_reason: response.choices[0].finish_reason,
-                        timestamp: new Date().toISOString(),
+                    const response = await (0, utils_1.makeApiRequest)(this, '/chat/completions', requestBody, includeImage);
+                    const result = {
+                        message: ((_b = (_a = response.choices[0]) === null || _a === void 0 ? void 0 : _a.message) === null || _b === void 0 ? void 0 : _b.content) || '',
+                        model,
+                        operation,
+                        usage: response.usage || null,
+                        finish_reason: ((_c = response.choices[0]) === null || _c === void 0 ? void 0 : _c.finish_reason) || 'unknown',
                     };
+                    returnData.push({
+                        json: result,
+                        pairedItem: { item: i },
+                    });
                 }
-                else {
-                    throw new Error(`Unknown operation: ${operation}`);
-                }
-                returnData.push({
-                    json: result,
-                    pairedItem: { item: i },
-                });
             }
             catch (error) {
                 if (this.continueOnFail()) {