n8n-nodes-github-copilot 3.23.0 → 3.26.0

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

@@ -83,6 +83,229 @@ async function listAvailableModels(token, enableRetry = true, maxRetries = 3) {
         },
     };
 }
+async function consolidatedModelTest(token, enableRetry = true, maxRetries = 3, testsPerModel = 5) {
+    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.";
+        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,28 +339,59 @@ 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 ⚠️ This test may take up to 2 minutes to complete',
+                        },
                     ],
                     default: 'listModels',
                     description: 'Select the test function to execute',
                 },
                 {
-                    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',
+                    displayName: 'Tests Per Model',
+                    name: 'testsPerModel',
                     type: 'number',
-                    default: 3,
-                    description: 'Maximum number of retry attempts for 403 errors',
+                    default: 5,
+                    description: 'Number of times to test each model (affects accuracy of results)',
                     displayOptions: {
                         show: {
-                            enableRetry: [true],
+                            testFunction: ['consolidatedTest'],
                         },
                     },
+                    typeOptions: {
+                        minValue: 1,
+                        maxValue: 20,
+                    },
+                },
+                {
+                    displayName: 'Advanced Options',
+                    name: 'advancedOptions',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    description: 'Additional options for the test execution',
+                    options: [
+                        {
+                            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],
+                                },
+                            },
+                        },
+                    ],
                 },
             ],
         };
@@ -148,8 +402,12 @@ class GitHubCopilotTest {
         for (let i = 0; i < items.length; i++) {
             try {
                 const testFunction = this.getNodeParameter('testFunction', i);
-                const enableRetry = this.getNodeParameter('enableRetry', i);
-                const maxRetries = this.getNodeParameter('maxRetries', i);
+                const advancedOptions = this.getNodeParameter('advancedOptions', i, {});
+                const enableRetry = advancedOptions.enableRetry !== false;
+                const maxRetries = advancedOptions.maxRetries || 3;
+                const testsPerModel = testFunction === 'consolidatedTest'
+                    ? this.getNodeParameter('testsPerModel', i)
+                    : 5;
                 const credentials = await this.getCredentials('githubCopilotApi', i);
                 if (!(credentials === null || credentials === void 0 ? void 0 : credentials.token)) {
                     throw new Error(GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.ERRORS.CREDENTIALS_REQUIRED);
@@ -163,6 +421,9 @@ class GitHubCopilotTest {
                     case 'listModels':
                         result = await listAvailableModels(token, enableRetry, maxRetries);
                         break;
+                    case 'consolidatedTest':
+                        result = await consolidatedModelTest(token, enableRetry, maxRetries, testsPerModel);
+                        break;
                     default:
                         throw new Error(`Unknown test function: ${testFunction}`);
                 }

package/package.json

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