n8n-nodes-github-copilot 3.1.0 → 3.2.0

package/dist/nodes/GitHubCopilotChatAPI/GitHubCopilotChatAPI.node.backup.d.ts

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

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

@@ -0,0 +1,651 @@
+"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 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}`);
+    }
+    const optimized = await optimizeAudioForAPI(audioBuffer, filename);
+    if (optimized.buffer.length === 0) {
+        return {
+            dataUrl: '',
+            description: optimized.description
+        };
+    }
+    const mimeType = getAudioMimeType(filename);
+    const base64String = optimized.buffer.toString('base64');
+    const estimatedTokens = estimateTokenCount(base64String);
+    if (estimatedTokens > 100000) {
+        return {
+            dataUrl: '',
+            description: `Audio file too large for processing (estimated ${estimatedTokens} tokens). ${optimized.description}`
+        };
+    }
+    return {
+        dataUrl: `data:${mimeType};base64,${base64String}`,
+        description: optimized.description
+    };
+}
+async function processImageFile(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}`);
+    }
+    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';
+    }
+}
+function estimateTokenCount(base64String) {
+    return Math.ceil((base64String.length * 0.75) + 100);
+}
+async function optimizeImageForAPI(imageBuffer, filename) {
+    const maxSizeBytes = 1024 * 1024;
+    if (imageBuffer.length <= maxSizeBytes) {
+        return imageBuffer;
+    }
+    try {
+        return imageBuffer;
+    }
+    catch (error) {
+        throw new Error(`Image too large (${Math.round(imageBuffer.length / 1024)}KB). Please use an image smaller than 1MB.`);
+    }
+}
+async function optimizeAudioForAPI(audioBuffer, filename) {
+    const maxSizeBytes = 2 * 1024 * 1024;
+    if (audioBuffer.length <= maxSizeBytes) {
+        return {
+            buffer: audioBuffer,
+            description: `Audio file: ${filename} (${Math.round(audioBuffer.length / 1024)}KB)`
+        };
+    }
+    const sizeInMB = Math.round(audioBuffer.length / (1024 * 1024) * 100) / 100;
+    const description = `Large audio file: ${filename} (${sizeInMB}MB). This file is too large to process directly. Please use a smaller audio file (under 2MB) or split it into smaller segments.`;
+    return {
+        buffer: Buffer.alloc(0),
+        description
+    };
+}
+class GitHubCopilotChatAPI {
+    constructor() {
+        this.description = {
+            displayName: 'GitHub Copilot Chat API',
+            name: 'gitHubCopilotChatAPI',
+            icon: 'file:copilot.svg',
+            group: ['AI'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["model"]}}',
+            description: 'Use official GitHub Copilot Chat API with your subscription - access GPT-5, Claude, Gemini and more',
+            defaults: {
+                name: 'GitHub Copilot Chat API',
+            },
+            inputs: ["main"],
+            outputs: ["main"],
+            credentials: [
+                {
+                    name: 'githubApi',
+                    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'],
+                        },
+                    },
+                },
+            ],
+        };
+    }
+    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);
+                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);
+                    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 = [
+                        {
+                            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}`
+                        }
+                    ];
+                    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 });
+                    }
+                    messages.push({
+                        role: 'user',
+                        content: [
+                            { type: 'text', text: message },
+                            { type: 'image_url', image_url: { url: imageBase64 } }
+                        ]
+                    });
+                    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 {
+                    throw new Error(`Unknown operation: ${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.GitHubCopilotChatAPI = GitHubCopilotChatAPI;