n8n-nodes-github-copilot 3.22.0 → 3.24.0

package/dist/nodes/GitHubCopilot/GitHubCopilot.node.js

@@ -49,7 +49,7 @@ class GitHubCopilot {
         this.description = {
             displayName: 'GitHub Copilot',
             name: 'gitHubCopilot',
-            icon: 'file:githubcopilot.svg',
+            icon: 'file:../../shared/icons/copilot.svg',
             group: ['transform'],
             version: 1,
             subtitle: '={{$parameter["operation"]}}',

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

@@ -5,12 +5,13 @@ const utils_1 = require("./utils");
 const nodeProperties_1 = require("./nodeProperties");
 const mediaDetection_1 = require("./utils/mediaDetection");
 const GitHubCopilotModels_1 = require("../../shared/models/GitHubCopilotModels");
+const GitHubCopilotEndpoints_1 = require("../../shared/utils/GitHubCopilotEndpoints");
 class GitHubCopilotChatAPI {
     constructor() {
         this.description = {
             displayName: 'GitHub Copilot Chat API',
             name: 'gitHubCopilotChatAPI',
-            icon: 'file:../../../shared/icons/copilot.svg',
+            icon: 'file:../../shared/icons/copilot.svg',
             group: ['AI'],
             version: 1,
             subtitle: '={{$parameter["operation"] + ": " + $parameter["model"]}}',
@@ -30,7 +31,7 @@ class GitHubCopilotChatAPI {
         };
     }
     async execute() {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const items = this.getInputData();
         const returnData = [];
         for (let i = 0; i < items.length; i++) {
@@ -41,6 +42,8 @@ class GitHubCopilotChatAPI {
                     const userMessage = this.getNodeParameter('message', i);
                     const systemMessage = this.getNodeParameter('systemMessage', i, '');
                     const advancedOptions = this.getNodeParameter('advancedOptions', i, {});
+                    const enableRetry = advancedOptions.enableRetry !== false;
+                    const maxRetries = advancedOptions.maxRetries || 3;
                     const includeMedia = this.getNodeParameter('includeMedia', i, false);
                     const modelInfo = GitHubCopilotModels_1.GitHubCopilotModelsManager.getModelByValue(model);
                     if (includeMedia) {
@@ -104,13 +107,36 @@ class GitHubCopilotChatAPI {
                         ...advancedOptions,
                     };
                     const hasMedia = includeMedia;
-                    const response = await (0, utils_1.makeApiRequest)(this, '/chat/completions', requestBody, hasMedia);
+                    let response = null;
+                    let attempt = 1;
+                    while (attempt <= maxRetries + 1) {
+                        try {
+                            response = await (0, utils_1.makeApiRequest)(this, GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.ENDPOINTS.CHAT_COMPLETIONS, requestBody, hasMedia);
+                            break;
+                        }
+                        catch (error) {
+                            const isLastAttempt = attempt >= maxRetries + 1;
+                            const errorObj = error;
+                            const is403Error = errorObj.status === 403 || ((_a = errorObj.message) === null || _a === void 0 ? void 0 : _a.includes('403'));
+                            if (is403Error && enableRetry && !isLastAttempt) {
+                                const delay = Math.min(1000 * Math.pow(2, attempt - 1), 30000);
+                                console.log(`GitHub Copilot API attempt ${attempt} failed with 403, retrying in ${delay}ms...`);
+                                await new Promise(resolve => setTimeout(resolve, delay));
+                                attempt++;
+                                continue;
+                            }
+                            throw error;
+                        }
+                    }
+                    if (!response) {
+                        throw new Error('Failed to get response from GitHub Copilot API after all retry attempts');
+                    }
                     const result = {
-                        message: ((_b = (_a = response.choices[0]) === null || _a === void 0 ? void 0 : _a.message) === null || _b === void 0 ? void 0 : _b.content) || '',
+                        message: ((_c = (_b = response.choices[0]) === null || _b === void 0 ? void 0 : _b.message) === null || _c === void 0 ? void 0 : _c.content) || '',
                         model,
                         operation,
                         usage: response.usage || null,
-                        finish_reason: ((_c = response.choices[0]) === null || _c === void 0 ? void 0 : _c.finish_reason) || 'unknown',
+                        finish_reason: ((_d = response.choices[0]) === null || _d === void 0 ? void 0 : _d.finish_reason) || 'unknown',
                     };
                     returnData.push({
                         json: result,

package/dist/nodes/GitHubCopilotChatAPI/nodeProperties.js

@@ -167,6 +167,25 @@ exports.nodeProperties = [
                 default: 1,
                 description: 'Alternative to temperature, controls diversity via nucleus sampling',
             },
+            {
+                displayName: 'Auto Retry on 403 Error',
+                name: 'enableRetry',
+                type: 'boolean',
+                default: true,
+                description: 'Automatically retry requests when hitting TPM (Transactions Per Minute) quota limits (HTTP 403)',
+            },
+            {
+                displayName: 'Max Retry Attempts',
+                name: 'maxRetries',
+                type: 'number',
+                default: 3,
+                description: 'Maximum number of retry attempts for 403 errors',
+                displayOptions: {
+                    show: {
+                        enableRetry: [true],
+                    },
+                },
+            },
         ],
     },
 ];

package/dist/nodes/GitHubCopilotChatModel/GitHubCopilotChatModel.node.js

@@ -99,6 +99,25 @@ class GitHubCopilotChatModel {
                                 rows: 3,
                             },
                         },
+                        {
+                            displayName: 'Auto Retry on 403 Error',
+                            name: 'enableRetry',
+                            type: 'boolean',
+                            default: true,
+                            description: 'Automatically retry requests when hitting TPM (Transactions Per Minute) quota limits (HTTP 403)',
+                        },
+                        {
+                            displayName: 'Max Retry Attempts',
+                            name: 'maxRetries',
+                            type: 'number',
+                            default: 3,
+                            description: 'Maximum number of retry attempts for 403 errors',
+                            displayOptions: {
+                                show: {
+                                    enableRetry: [true],
+                                },
+                            },
+                        },
                     ],
                 },
             ],
@@ -131,6 +150,7 @@ class GitHubCopilotChatModel {
             temperature: options.temperature || 0.7,
             maxTokens: Math.min(options.maxTokens || 1000, (safeModelInfo === null || safeModelInfo === void 0 ? void 0 : safeModelInfo.capabilities.maxOutputTokens) || 4096),
             topP: options.topP || 1,
+            maxRetries: options.enableRetry !== false ? (options.maxRetries || 3) : 0,
             configuration: {
                 baseURL: GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.BASE_URL,
                 apiKey: token,

package/dist/nodes/GitHubCopilotTest/GitHubCopilotTest.node.js

@@ -83,6 +83,230 @@ async function listAvailableModels(token, enableRetry = true, maxRetries = 3) {
         },
     };
 }
+async function consolidatedModelTest(token, enableRetry = true, maxRetries = 3) {
+    const testStartTime = Date.now();
+    const testResults = {};
+    let totalTests = 0;
+    let successfulTests = 0;
+    let failedTests = 0;
+    try {
+        console.log('🧪 Starting Consolidated Model Test...');
+        const modelsResponse = await listAvailableModels(token, enableRetry, maxRetries);
+        if (!modelsResponse.success || !modelsResponse.data) {
+            return {
+                success: false,
+                timestamp: new Date().toISOString(),
+                error: 'Failed to fetch models list for consolidated test',
+                details: modelsResponse,
+            };
+        }
+        const availableModels = modelsResponse.data;
+        const testMessage = "Hello! Please respond with just 'OK' to confirm you're working.";
+        const testsPerModel = 5;
+        console.log(`📊 Testing ${availableModels.length} models, ${testsPerModel} times each...`);
+        for (const modelItem of availableModels) {
+            const model = modelItem;
+            const modelId = model.id || model.name;
+            const modelResults = {
+                modelInfo: {
+                    id: modelId,
+                    name: model.name || modelId,
+                    vendor: model.vendor || 'unknown',
+                    capabilities: model.capabilities || {},
+                },
+                tests: [],
+                summary: {
+                    totalAttempts: 0,
+                    successful: 0,
+                    failed: 0,
+                    successRate: 0,
+                    avgResponseTime: 0,
+                    avgTokensUsed: 0,
+                },
+            };
+            console.log(`🔍 Testing model: ${modelId}`);
+            for (let testNum = 1; testNum <= testsPerModel; testNum++) {
+                const testStart = Date.now();
+                totalTests++;
+                modelResults.summary.totalAttempts++;
+                try {
+                    const response = await fetch(GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.getChatCompletionsUrl(), {
+                        method: 'POST',
+                        headers: GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.getAuthHeaders(token),
+                        body: JSON.stringify({
+                            model: modelId,
+                            messages: [
+                                {
+                                    role: 'user',
+                                    content: testMessage
+                                }
+                            ],
+                            max_tokens: 10,
+                            temperature: 0.1,
+                        }),
+                    });
+                    const testEnd = Date.now();
+                    const responseTime = testEnd - testStart;
+                    if (response.ok) {
+                        const data = await response.json();
+                        successfulTests++;
+                        modelResults.summary.successful++;
+                        const choices = data.choices || [];
+                        const firstChoice = choices[0] || {};
+                        const message = firstChoice.message || {};
+                        const usage = data.usage || {};
+                        const testResult = {
+                            testNumber: testNum,
+                            success: true,
+                            responseTime: responseTime,
+                            response: message.content || 'No content',
+                            usage: usage || null,
+                            finishReason: firstChoice.finish_reason || 'unknown',
+                            timestamp: new Date().toISOString(),
+                        };
+                        modelResults.tests.push(testResult);
+                        const totalTokens = usage.total_tokens;
+                        if (totalTokens) {
+                            modelResults.summary.avgTokensUsed += totalTokens;
+                        }
+                    }
+                    else {
+                        const errorText = await response.text();
+                        failedTests++;
+                        modelResults.summary.failed++;
+                        modelResults.tests.push({
+                            testNumber: testNum,
+                            success: false,
+                            responseTime: responseTime,
+                            error: `HTTP ${response.status}: ${errorText}`,
+                            timestamp: new Date().toISOString(),
+                        });
+                    }
+                }
+                catch (error) {
+                    const testEnd = Date.now();
+                    const responseTime = testEnd - testStart;
+                    failedTests++;
+                    modelResults.summary.failed++;
+                    modelResults.tests.push({
+                        testNumber: testNum,
+                        success: false,
+                        responseTime: responseTime,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+            const successfulResponses = modelResults.tests.filter((t) => {
+                const test = t;
+                return test.success === true;
+            });
+            if (successfulResponses.length > 0) {
+                const totalResponseTime = successfulResponses.reduce((sum, t) => {
+                    const test = t;
+                    return sum + (test.responseTime || 0);
+                }, 0);
+                modelResults.summary.avgResponseTime = Math.round(totalResponseTime / successfulResponses.length);
+                modelResults.summary.avgTokensUsed = Math.round(modelResults.summary.avgTokensUsed / successfulResponses.length);
+            }
+            modelResults.summary.successRate = Math.round((modelResults.summary.successful / modelResults.summary.totalAttempts) * 100);
+            testResults[modelId] = modelResults;
+        }
+        const testEndTime = Date.now();
+        const totalTestTime = testEndTime - testStartTime;
+        const consolidatedSummary = {
+            success: true,
+            timestamp: new Date().toISOString(),
+            testConfiguration: {
+                testsPerModel: testsPerModel,
+                totalModels: availableModels.length,
+                totalTests: totalTests,
+                retryEnabled: enableRetry,
+                maxRetries: maxRetries,
+            },
+            overallResults: {
+                totalTests: totalTests,
+                successfulTests: successfulTests,
+                failedTests: failedTests,
+                overallSuccessRate: Math.round((successfulTests / totalTests) * 100),
+                totalTestTime: totalTestTime,
+                avgTimePerTest: Math.round(totalTestTime / totalTests),
+            },
+            modelResults: testResults,
+            recommendations: generateTestRecommendations(testResults),
+        };
+        console.log('✅ Consolidated test completed successfully!');
+        return consolidatedSummary;
+    }
+    catch (error) {
+        return {
+            success: false,
+            timestamp: new Date().toISOString(),
+            error: error instanceof Error ? error.message : 'Unknown error in consolidated test',
+            partialResults: testResults,
+            testDuration: Date.now() - testStartTime,
+        };
+    }
+}
+function generateTestRecommendations(testResults) {
+    const recommendations = [];
+    const modelStats = Object.entries(testResults).map(([modelId, results]) => {
+        const modelResult = results;
+        const summary = modelResult.summary;
+        const modelInfo = modelResult.modelInfo;
+        return {
+            modelId,
+            successRate: summary.successRate,
+            avgResponseTime: summary.avgResponseTime,
+            vendor: modelInfo.vendor,
+        };
+    });
+    const bestModels = modelStats
+        .filter(m => m.successRate === 100)
+        .sort((a, b) => a.avgResponseTime - b.avgResponseTime)
+        .slice(0, 3);
+    if (bestModels.length > 0) {
+        recommendations.push({
+            type: 'best_performance',
+            title: 'Top Performing Models (100% success rate)',
+            models: bestModels,
+            description: 'These models completed all tests successfully with fastest response times',
+        });
+    }
+    const problematicModels = modelStats.filter(m => m.successRate < 80);
+    if (problematicModels.length > 0) {
+        recommendations.push({
+            type: 'attention_needed',
+            title: 'Models Requiring Attention (< 80% success rate)',
+            models: problematicModels,
+            description: 'These models had reliability issues during testing',
+        });
+    }
+    const vendorStats = modelStats.reduce((acc, model) => {
+        const vendor = model.vendor;
+        if (!acc[vendor]) {
+            acc[vendor] = { count: 0, totalSuccessRate: 0, avgResponseTime: 0 };
+        }
+        const stats = acc[vendor];
+        stats.count++;
+        stats.totalSuccessRate += model.successRate;
+        stats.avgResponseTime += model.avgResponseTime;
+        return acc;
+    }, {});
+    Object.keys(vendorStats).forEach(vendor => {
+        const vendorData = vendorStats[vendor];
+        vendorData.avgSuccessRate = Math.round(vendorData.totalSuccessRate / vendorData.count);
+        vendorData.avgResponseTime = Math.round(vendorData.avgResponseTime / vendorData.count);
+    });
+    recommendations.push({
+        type: 'vendor_analysis',
+        title: 'Performance by Vendor',
+        vendors: vendorStats,
+        description: 'Comparative analysis of model performance by vendor',
+    });
+    return recommendations;
+}
 class GitHubCopilotTest {
     constructor() {
         this.description = {
@@ -116,6 +340,11 @@ class GitHubCopilotTest {
                             value: 'listModels',
                             description: 'Get all models available for your GitHub Copilot subscription',
                         },
+                        {
+                            name: 'Consolidated Model Test',
+                            value: 'consolidatedTest',
+                            description: 'Test all available models 5 times each and generate comprehensive report',
+                        },
                     ],
                     default: 'listModels',
                     description: 'Select the test function to execute',
@@ -163,6 +392,9 @@ class GitHubCopilotTest {
                     case 'listModels':
                         result = await listAvailableModels(token, enableRetry, maxRetries);
                         break;
+                    case 'consolidatedTest':
+                        result = await consolidatedModelTest(token, enableRetry, maxRetries);
+                        break;
                     default:
                         throw new Error(`Unknown test function: ${testFunction}`);
                 }

package/dist/shared/icons/copilot.svg

@@ -0,0 +1,34 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24">
+  <defs>
+    <linearGradient id="copilotGradient" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#1f6feb;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#0969da;stop-opacity:1" />
+    </linearGradient>
+  </defs>
+  
+  <!-- GitHub Copilot inspired icon -->
+  <circle cx="12" cy="12" r="11" fill="url(#copilotGradient)" stroke="#ffffff" stroke-width="1"/>
+  
+  <!-- Copilot face -->
+  <ellipse cx="12" cy="10" rx="8" ry="6" fill="#ffffff" opacity="0.9"/>
+  
+  <!-- Eyes -->
+  <circle cx="9" cy="9" r="1.5" fill="#1f6feb"/>
+  <circle cx="15" cy="9" r="1.5" fill="#1f6feb"/>
+  
+  <!-- Light reflection in eyes -->
+  <circle cx="9.5" cy="8.5" r="0.5" fill="#ffffff"/>
+  <circle cx="15.5" cy="8.5" r="0.5" fill="#ffffff"/>
+  
+  <!-- Mouth/Interface line -->
+  <path d="M8 12 L16 12" stroke="#1f6feb" stroke-width="1.5" stroke-linecap="round"/>
+  
+  <!-- Code brackets -->
+  <path d="M6 15 L8 17 L6 19" stroke="#ffffff" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" fill="none"/>
+  <path d="M18 15 L16 17 L18 19" stroke="#ffffff" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" fill="none"/>
+  
+  <!-- AI indicator dots -->
+  <circle cx="10" cy="17" r="0.5" fill="#ffffff" opacity="0.8"/>
+  <circle cx="12" cy="17" r="0.5" fill="#ffffff" opacity="0.6"/>
+  <circle cx="14" cy="17" r="0.5" fill="#ffffff" opacity="0.4"/>
+</svg>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-github-copilot",
-  "version": "3.22.0",
+  "version": "3.24.0",
   "description": "n8n community node for GitHub Copilot with CLI integration, Chat API access, and AI Chat Model for workflows - access GPT-5, Claude, Gemini and more using your Copilot subscription",
   "license": "MIT",
   "homepage": "https://github.com/sufficit/n8n-nodes-github-copilot",