n8n-nodes-github-copilot 3.1.0 → 3.2.1

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

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

package/dist/nodes/GitHubCopilotChatAPI/nodeProperties.js

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeProperties = void 0;
+exports.nodeProperties = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        options: [
+            {
+                name: 'Chat Completion',
+                value: 'chat',
+                description: 'Send messages to GitHub Copilot Chat API',
+            },
+        ],
+        default: 'chat',
+    },
+    {
+        displayName: 'Model',
+        name: 'model',
+        type: 'options',
+        options: [
+            {
+                name: 'GPT-5',
+                value: 'gpt-5',
+                description: 'OpenAI GPT-5 (Latest and most capable)',
+            },
+            {
+                name: 'GPT-5 Mini',
+                value: 'gpt-5-mini',
+                description: 'OpenAI GPT-5 Mini (Faster, cost-effective)',
+            },
+            {
+                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 Code Fast 1 (Optimized for coding)',
+            },
+            {
+                name: 'GPT-4.1 Copilot',
+                value: 'gpt-4.1-copilot',
+                description: 'OpenAI GPT-4.1 specialized for coding assistance',
+            },
+        ],
+        default: 'gpt-5-mini',
+        description: 'Select AI model to use',
+    },
+    {
+        displayName: 'Message',
+        name: 'message',
+        type: 'string',
+        typeOptions: {
+            rows: 4,
+        },
+        default: '',
+        placeholder: 'What can I help you with?',
+        description: 'The message to send to the AI model',
+    },
+    {
+        displayName: 'System Message',
+        name: 'systemMessage',
+        type: 'string',
+        typeOptions: {
+            rows: 3,
+        },
+        default: '',
+        placeholder: 'You are a helpful assistant...',
+        description: 'System message to set the behavior of the AI model',
+    },
+    {
+        displayName: 'Include Image',
+        name: 'includeImage',
+        type: 'boolean',
+        default: false,
+        description: 'Whether to include an image in the message',
+    },
+    {
+        displayName: 'Image Source',
+        name: 'imageSource',
+        type: 'options',
+        displayOptions: {
+            show: {
+                includeImage: [true],
+            },
+        },
+        options: [
+            {
+                name: 'Manual Input',
+                value: 'manual',
+                description: 'Provide image as base64 string or file path',
+            },
+            {
+                name: 'URL',
+                value: 'url',
+                description: 'Download image from URL',
+            },
+            {
+                name: 'Binary Data',
+                value: 'binary',
+                description: 'Use binary data from previous node',
+            },
+        ],
+        default: 'manual',
+        description: 'Source of the image data',
+    },
+    {
+        displayName: 'Image File',
+        name: 'imageFile',
+        type: 'string',
+        displayOptions: {
+            show: {
+                includeImage: [true],
+                imageSource: ['manual'],
+            },
+        },
+        default: '',
+        placeholder: 'Paste base64 string or file path',
+        description: 'Image as base64 string or file path',
+    },
+    {
+        displayName: 'Image URL',
+        name: 'imageUrl',
+        type: 'string',
+        displayOptions: {
+            show: {
+                includeImage: [true],
+                imageSource: ['url'],
+            },
+        },
+        default: '',
+        placeholder: 'https://example.com/image.jpg',
+        description: 'URL of the image to download and include',
+    },
+    {
+        displayName: 'Image Binary Property',
+        name: 'imageBinaryProperty',
+        type: 'string',
+        displayOptions: {
+            show: {
+                includeImage: [true],
+                imageSource: ['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',
+    },
+    {
+        displayName: 'Advanced Options',
+        name: 'advancedOptions',
+        type: 'collection',
+        placeholder: 'Add Field',
+        default: {},
+        options: [
+            {
+                displayName: 'Temperature',
+                name: 'temperature',
+                type: 'number',
+                typeOptions: {
+                    minValue: 0,
+                    maxValue: 2,
+                    numberPrecision: 2,
+                },
+                default: 1,
+                description: 'Controls randomness of the response. Higher values make output more random.',
+            },
+            {
+                displayName: 'Max Tokens',
+                name: 'max_tokens',
+                type: 'number',
+                typeOptions: {
+                    minValue: 1,
+                    maxValue: 128000,
+                },
+                default: 4096,
+                description: 'Maximum number of tokens to generate in the response',
+            },
+            {
+                displayName: 'Top P',
+                name: 'top_p',
+                type: 'number',
+                typeOptions: {
+                    minValue: 0,
+                    maxValue: 1,
+                    numberPrecision: 2,
+                },
+                default: 1,
+                description: 'Alternative to temperature, controls diversity via nucleus sampling',
+            },
+        ],
+    },
+];

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

@@ -0,0 +1,11 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+import { ProcessedFileResult } from './types';
+export declare function processAudioFile(context: IExecuteFunctions, itemIndex: number, audioSource: string, audioFile?: string, audioUrl?: string, audioProperty?: string): Promise<ProcessedFileResult>;
+export declare function chunkAudioData(base64Data: string, maxChunkSize?: number): string[];
+export declare function optimizeAudioForTokens(base64Data: string, maxTokens?: number): {
+    data: string;
+    truncated: boolean;
+    originalTokens: number;
+    finalTokens: number;
+};
+export declare function createAudioSummary(filename: string, size: number, duration?: number): string;

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAudioSummary = exports.optimizeAudioForTokens = exports.chunkAudioData = exports.processAudioFile = void 0;
+const helpers_1 = require("./helpers");
+async function processAudioFile(context, itemIndex, audioSource, audioFile, audioUrl, audioProperty) {
+    var _a, _b;
+    let audioBuffer;
+    let filename;
+    switch (audioSource) {
+        case 'file':
+            if (!audioFile) {
+                throw new Error('Audio file content is required when source is "file"');
+            }
+            audioBuffer = Buffer.from(audioFile, 'base64');
+            filename = 'uploaded_audio.mp3';
+            break;
+        case 'url':
+            if (!audioUrl) {
+                throw new Error('Audio URL is required when source is "url"');
+            }
+            audioBuffer = await (0, helpers_1.downloadFileFromUrl)(audioUrl);
+            filename = audioUrl.split('/').pop() || 'downloaded_audio.mp3';
+            break;
+        case 'binary':
+            if (!audioProperty) {
+                throw new Error('Audio property name is required when source is "binary"');
+            }
+            audioBuffer = await (0, helpers_1.getFileFromBinary)(context, itemIndex, audioProperty);
+            const items = context.getInputData();
+            const item = items[itemIndex];
+            filename = ((_b = (_a = item.binary) === null || _a === void 0 ? void 0 : _a[audioProperty]) === null || _b === void 0 ? void 0 : _b.fileName) || 'binary_audio.mp3';
+            break;
+        default:
+            throw new Error(`Invalid audio source: ${audioSource}`);
+    }
+    (0, helpers_1.validateFileSize)(audioBuffer, 25600);
+    const base64Audio = audioBuffer.toString('base64');
+    const estimatedTokens = (0, helpers_1.estimateTokens)(base64Audio);
+    if (estimatedTokens > 100000) {
+        throw new Error(`Audio file too large (${estimatedTokens} estimated tokens). Consider using a smaller file.`);
+    }
+    const mimeType = (0, helpers_1.getAudioMimeType)(filename);
+    return {
+        data: base64Audio,
+        mimeType,
+        filename,
+        size: audioBuffer.length,
+        estimatedTokens
+    };
+}
+exports.processAudioFile = processAudioFile;
+function chunkAudioData(base64Data, maxChunkSize = 50000) {
+    const chunks = [];
+    for (let i = 0; i < base64Data.length; i += maxChunkSize) {
+        chunks.push(base64Data.slice(i, i + maxChunkSize));
+    }
+    return chunks;
+}
+exports.chunkAudioData = chunkAudioData;
+function optimizeAudioForTokens(base64Data, maxTokens = 100000) {
+    const originalTokens = (0, helpers_1.estimateTokens)(base64Data);
+    if (originalTokens <= maxTokens) {
+        return {
+            data: base64Data,
+            truncated: false,
+            originalTokens,
+            finalTokens: originalTokens
+        };
+    }
+    const compressionRatio = maxTokens / originalTokens;
+    const targetLength = Math.floor(base64Data.length * compressionRatio);
+    const compressedData = base64Data.slice(0, Math.max(targetLength, 1000));
+    return {
+        data: compressedData,
+        truncated: true,
+        originalTokens,
+        finalTokens: (0, helpers_1.estimateTokens)(compressedData)
+    };
+}
+exports.optimizeAudioForTokens = optimizeAudioForTokens;
+function createAudioSummary(filename, size, duration) {
+    const sizeKB = Math.round(size / 1024);
+    const durationText = duration ? ` (${Math.round(duration)}s)` : '';
+    return `Audio file: ${filename} - ${sizeKB}KB${durationText}. File too large for direct processing, providing description instead.`;
+}
+exports.createAudioSummary = createAudioSummary;

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

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IExecuteFunctions } from 'n8n-workflow';
+import { CopilotResponse } from './types';
+export declare function makeApiRequest(context: IExecuteFunctions, endpoint: string, body: Record<string, unknown>, hasVision?: boolean): Promise<CopilotResponse>;
+export declare function downloadFileFromUrl(url: string): Promise<Buffer>;
+export declare function getFileFromBinary(context: IExecuteFunctions, itemIndex: number, propertyName: string): Promise<Buffer>;
+export declare function getImageMimeType(filename: string): string;
+export declare function getAudioMimeType(filename: string): string;
+export declare function validateFileSize(buffer: Buffer, maxSizeKB?: number): void;
+export declare function estimateTokens(base64String: string): number;
+export declare function validateTokenLimit(estimatedTokens: number, maxTokens?: number): {
+    valid: boolean;
+    message?: string;
+};
+export declare function truncateToTokenLimit(content: string, maxTokens?: number): {
+    content: string;
+    truncated: boolean;
+    originalTokens: number;
+    finalTokens: number;
+};

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

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncateToTokenLimit = exports.validateTokenLimit = exports.estimateTokens = exports.validateFileSize = exports.getAudioMimeType = exports.getImageMimeType = exports.getFileFromBinary = exports.downloadFileFromUrl = exports.makeApiRequest = void 0;
+async function makeApiRequest(context, endpoint, body, hasVision = false) {
+    const credentials = await context.getCredentials('githubApi');
+    const headers = {
+        'Authorization': `Bearer ${credentials.accessToken}`,
+        'Content-Type': 'application/json',
+        'User-Agent': 'n8n-github-copilot-chat-api-node',
+    };
+    if (hasVision) {
+        headers['Copilot-Vision-Request'] = 'true';
+    }
+    const options = {
+        method: 'POST',
+        headers,
+        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();
+}
+exports.makeApiRequest = makeApiRequest;
+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());
+}
+exports.downloadFileFromUrl = downloadFileFromUrl;
+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}"`);
+    }
+}
+exports.getFileFromBinary = getFileFromBinary;
+function getImageMimeType(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';
+    }
+}
+exports.getImageMimeType = getImageMimeType;
+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';
+    }
+}
+exports.getAudioMimeType = getAudioMimeType;
+function validateFileSize(buffer, maxSizeKB = 1024) {
+    const sizeKB = buffer.length / 1024;
+    if (sizeKB > maxSizeKB) {
+        throw new Error(`File size ${sizeKB.toFixed(2)}KB exceeds limit of ${maxSizeKB}KB`);
+    }
+}
+exports.validateFileSize = validateFileSize;
+function estimateTokens(base64String) {
+    return Math.ceil((base64String.length / 4 * 3) / 4);
+}
+exports.estimateTokens = estimateTokens;
+function validateTokenLimit(estimatedTokens, maxTokens = 128000) {
+    if (estimatedTokens <= maxTokens) {
+        return { valid: true };
+    }
+    return {
+        valid: false,
+        message: `Content too large: ${estimatedTokens} tokens exceeds limit of ${maxTokens}. Consider using smaller files or text.`
+    };
+}
+exports.validateTokenLimit = validateTokenLimit;
+function truncateToTokenLimit(content, maxTokens = 100000) {
+    const originalTokens = Math.ceil(content.length / 4);
+    if (originalTokens <= maxTokens) {
+        return {
+            content,
+            truncated: false,
+            originalTokens,
+            finalTokens: originalTokens
+        };
+    }
+    const targetLength = Math.floor(content.length * (maxTokens / originalTokens));
+    const truncatedContent = content.slice(0, targetLength) + '...[truncated]';
+    return {
+        content: truncatedContent,
+        truncated: true,
+        originalTokens,
+        finalTokens: Math.ceil(truncatedContent.length / 4)
+    };
+}
+exports.truncateToTokenLimit = truncateToTokenLimit;

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

@@ -0,0 +1,8 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+import { ProcessedFileResult, OptimizationOptions } from './types';
+export declare function processImageFile(context: IExecuteFunctions, itemIndex: number, imageSource: string, imageFile?: string, imageUrl?: string, imageProperty?: string, optimization?: OptimizationOptions): Promise<ProcessedFileResult>;
+export declare function compressImageToTokenLimit(base64Data: string, maxTokens?: number): string;
+export declare function resizeImageDimensions(originalWidth: number, originalHeight: number, maxWidth?: number, maxHeight?: number): {
+    width: number;
+    height: number;
+};

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

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resizeImageDimensions = exports.compressImageToTokenLimit = exports.processImageFile = void 0;
+const helpers_1 = require("./helpers");
+async function processImageFile(context, itemIndex, imageSource, imageFile, imageUrl, imageProperty, optimization) {
+    var _a, _b;
+    let imageBuffer;
+    let filename;
+    switch (imageSource) {
+        case 'file':
+            if (!imageFile) {
+                throw new Error('Image file content is required when source is "file"');
+            }
+            imageBuffer = Buffer.from(imageFile, 'base64');
+            filename = 'uploaded_image.jpg';
+            break;
+        case 'url':
+            if (!imageUrl) {
+                throw new Error('Image URL is required when source is "url"');
+            }
+            imageBuffer = await (0, helpers_1.downloadFileFromUrl)(imageUrl);
+            filename = imageUrl.split('/').pop() || 'downloaded_image.jpg';
+            break;
+        case 'binary':
+            if (!imageProperty) {
+                throw new Error('Image property name is required when source is "binary"');
+            }
+            imageBuffer = await (0, helpers_1.getFileFromBinary)(context, itemIndex, imageProperty);
+            const items = context.getInputData();
+            const item = items[itemIndex];
+            filename = ((_b = (_a = item.binary) === null || _a === void 0 ? void 0 : _a[imageProperty]) === null || _b === void 0 ? void 0 : _b.fileName) || 'binary_image.jpg';
+            break;
+        default:
+            throw new Error(`Invalid image source: ${imageSource}`);
+    }
+    if (optimization) {
+        imageBuffer = await optimizeImage(imageBuffer, optimization);
+    }
+    (0, helpers_1.validateFileSize)(imageBuffer, 20480);
+    const base64Image = imageBuffer.toString('base64');
+    const estimatedTokens = (0, helpers_1.estimateTokens)(base64Image);
+    if (estimatedTokens > 50000) {
+        const compressedBuffer = await optimizeImage(imageBuffer, {
+            quality: 70,
+            maxSizeKB: (optimization === null || optimization === void 0 ? void 0 : optimization.maxSizeKB) || 1024
+        });
+        const compressedBase64 = compressedBuffer.toString('base64');
+        const compressedTokens = (0, helpers_1.estimateTokens)(compressedBase64);
+        if (compressedTokens < estimatedTokens) {
+            return {
+                data: compressedBase64,
+                mimeType: (0, helpers_1.getImageMimeType)(filename),
+                filename,
+                size: compressedBuffer.length,
+                estimatedTokens: compressedTokens
+            };
+        }
+    }
+    const mimeType = (0, helpers_1.getImageMimeType)(filename);
+    return {
+        data: base64Image,
+        mimeType,
+        filename,
+        size: imageBuffer.length,
+        estimatedTokens
+    };
+}
+exports.processImageFile = processImageFile;
+async function optimizeImage(buffer, options) {
+    if (options.maxSizeKB && buffer.length / 1024 > options.maxSizeKB) {
+        const compressionRatio = Math.min(0.8, options.maxSizeKB / (buffer.length / 1024));
+        const targetSize = Math.floor(buffer.length * compressionRatio);
+        if (targetSize < buffer.length) {
+            return buffer.slice(0, Math.max(targetSize, 1024));
+        }
+    }
+    return buffer;
+}
+function compressImageToTokenLimit(base64Data, maxTokens = 50000) {
+    const estimatedTokens = (0, helpers_1.estimateTokens)(base64Data);
+    if (estimatedTokens <= maxTokens) {
+        return base64Data;
+    }
+    const compressionRatio = maxTokens / estimatedTokens;
+    const targetLength = Math.floor(base64Data.length * compressionRatio);
+    return base64Data.slice(0, Math.max(targetLength, 1000));
+}
+exports.compressImageToTokenLimit = compressImageToTokenLimit;
+function resizeImageDimensions(originalWidth, originalHeight, maxWidth = 1024, maxHeight = 1024) {
+    let { width, height } = { width: originalWidth, height: originalHeight };
+    if (width > maxWidth) {
+        height = (height * maxWidth) / width;
+        width = maxWidth;
+    }
+    if (height > maxHeight) {
+        width = (width * maxHeight) / height;
+        height = maxHeight;
+    }
+    return { width: Math.round(width), height: Math.round(height) };
+}
+exports.resizeImageDimensions = resizeImageDimensions;

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

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

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

@@ -0,0 +1,20 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./audioProcessor"), exports);
+__exportStar(require("./imageProcessor"), exports);