n8n-nodes-github-copilot 3.20.0 → 3.22.0

package/dist/credentials/GitHubCopilotApi.credentials.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitHubCopilotApi = void 0;
+const GitHubCopilotEndpoints_1 = require("../shared/utils/GitHubCopilotEndpoints");
 class GitHubCopilotApi {
     constructor() {
         this.name = 'githubCopilotApi';
@@ -39,8 +40,8 @@ class GitHubCopilotApi {
         };
         this.test = {
             request: {
-                baseURL: 'https://api.githubcopilot.com',
-                url: '/models',
+                baseURL: GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.BASE_URL,
+                url: GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.ENDPOINTS.MODELS,
                 method: 'GET',
             },
         };

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

@@ -10,7 +10,7 @@ class GitHubCopilotChatAPI {
         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"]}}',

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitHubCopilotChatModel = void 0;
 const openai_1 = require("@langchain/openai");
 const GitHubCopilotModels_1 = require("../../shared/models/GitHubCopilotModels");
+const GitHubCopilotEndpoints_1 = require("../../shared/utils/GitHubCopilotEndpoints");
 class GitHubCopilotChatModel {
     constructor() {
         this.description = {
@@ -131,7 +132,7 @@ class GitHubCopilotChatModel {
             maxTokens: Math.min(options.maxTokens || 1000, (safeModelInfo === null || safeModelInfo === void 0 ? void 0 : safeModelInfo.capabilities.maxOutputTokens) || 4096),
             topP: options.topP || 1,
             configuration: {
-                baseURL: 'https://api.githubcopilot.com',
+                baseURL: GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.BASE_URL,
                 apiKey: token,
                 defaultHeaders: {
                     'User-Agent': 'GitHubCopilotChat/1.0.0 n8n/3.10.1',

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

@@ -1,60 +1,87 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitHubCopilotTest = void 0;
-async function listAvailableModels(token) {
-    var _a, _b;
-    try {
-        const response = await fetch('https://api.githubcopilot.com/models', {
-            method: 'GET',
-            headers: {
-                'Authorization': `Bearer ${token}`,
-                'Accept': 'application/json',
-                'Content-Type': 'application/json',
-            },
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`API Error ${response.status}: ${errorText}`);
+const GitHubCopilotEndpoints_1 = require("../../shared/utils/GitHubCopilotEndpoints");
+async function listAvailableModels(token, enableRetry = true, maxRetries = 3) {
+    const retryInfo = {
+        attempts: 1,
+        retries: [],
+        totalDelay: 0,
+    };
+    for (let attempt = 1; attempt <= maxRetries + 1; attempt++) {
+        try {
+            const response = await fetch(GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.getModelsUrl(), {
+                method: 'GET',
+                headers: GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.getAuthHeaders(token),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                if (GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.isTpmQuotaError(response.status) && enableRetry && attempt <= maxRetries) {
+                    const delay = GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.getRetryDelay(attempt);
+                    retryInfo.retries.push({
+                        attempt: attempt,
+                        error: `HTTP ${response.status}: ${errorText}`,
+                        delay: delay,
+                        timestamp: new Date().toISOString(),
+                    });
+                    retryInfo.totalDelay += delay;
+                    retryInfo.attempts = attempt + 1;
+                    console.log(`Attempt ${attempt} failed with 403, retrying in ${delay}ms...`);
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    continue;
+                }
+                throw new Error(`API Error ${response.status}: ${errorText}`);
+            }
+            const data = await response.json();
+            const summary = {
+                success: true,
+                timestamp: new Date().toISOString(),
+                retryInfo: {
+                    totalAttempts: retryInfo.attempts,
+                    totalRetries: retryInfo.retries.length,
+                    totalDelay: retryInfo.totalDelay,
+                    retryDetails: retryInfo.retries,
+                    retryEnabled: enableRetry,
+                    maxRetries: maxRetries,
+                },
+                ...data,
+            };
+            return summary;
         }
-        const data = await response.json();
-        const enabledModels = ((_a = data.data) === null || _a === void 0 ? void 0 : _a.filter((model) => model.model_picker_enabled !== false)) || [];
-        const modelsByProvider = {};
-        enabledModels.forEach((model) => {
-            const provider = model.name.split('/')[0] || 'unknown';
-            if (!modelsByProvider[provider]) {
-                modelsByProvider[provider] = [];
+        catch (error) {
+            if (attempt >= maxRetries + 1 || !enableRetry) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+                return {
+                    success: false,
+                    timestamp: new Date().toISOString(),
+                    error: errorMessage,
+                    details: 'Failed to fetch models from GitHub Copilot API',
+                    retryInfo: {
+                        totalAttempts: retryInfo.attempts,
+                        totalRetries: retryInfo.retries.length,
+                        totalDelay: retryInfo.totalDelay,
+                        retryDetails: retryInfo.retries,
+                        retryEnabled: enableRetry,
+                        maxRetries: maxRetries,
+                    },
+                };
             }
-            modelsByProvider[provider].push({
-                id: model.id,
-                name: model.name,
-                displayName: model.display_name,
-                capabilities: model.capabilities || [],
-            });
-        });
-        const summary = {
-            success: true,
-            timestamp: new Date().toISOString(),
-            totalModels: ((_b = data.data) === null || _b === void 0 ? void 0 : _b.length) || 0,
-            enabledModels: enabledModels.length,
-            modelsByProvider,
-            models: enabledModels.map((model) => ({
-                id: model.id,
-                name: model.name,
-                displayName: model.display_name,
-                capabilities: model.capabilities || [],
-            })),
-        };
-        return summary;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-        return {
-            success: false,
-            timestamp: new Date().toISOString(),
-            error: errorMessage,
-            details: 'Failed to fetch models from GitHub Copilot API',
-        };
+        }
     }
+    return {
+        success: false,
+        timestamp: new Date().toISOString(),
+        error: 'Maximum retry attempts exceeded',
+        details: 'Failed to fetch models after all retry attempts',
+        retryInfo: {
+            totalAttempts: retryInfo.attempts,
+            totalRetries: retryInfo.retries.length,
+            totalDelay: retryInfo.totalDelay,
+            retryDetails: retryInfo.retries,
+            retryEnabled: enableRetry,
+            maxRetries: maxRetries,
+        },
+    };
 }
 class GitHubCopilotTest {
     constructor() {
@@ -93,6 +120,25 @@ class GitHubCopilotTest {
                     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',
+                    type: 'number',
+                    default: 3,
+                    description: 'Maximum number of retry attempts for 403 errors',
+                    displayOptions: {
+                        show: {
+                            enableRetry: [true],
+                        },
+                    },
+                },
             ],
         };
     }
@@ -102,18 +148,20 @@ 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 credentials = await this.getCredentials('githubCopilotApi', i);
                 if (!(credentials === null || credentials === void 0 ? void 0 : credentials.token)) {
-                    throw new Error('GitHub Copilot API credentials are required');
+                    throw new Error(GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.ERRORS.CREDENTIALS_REQUIRED);
                 }
                 const token = credentials.token;
-                if (!token.startsWith('gho_')) {
-                    throw new Error('Invalid token format. GitHub Copilot API requires tokens starting with "gho_"');
+                if (!GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.validateToken(token)) {
+                    throw new Error(GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.ERRORS.INVALID_TOKEN);
                 }
                 let result = {};
                 switch (testFunction) {
                     case 'listModels':
-                        result = await listAvailableModels(token);
+                        result = await listAvailableModels(token, enableRetry, maxRetries);
                         break;
                     default:
                         throw new Error(`Unknown test function: ${testFunction}`);

package/dist/shared/utils/GitHubCopilotApiUtils.js

@@ -9,6 +9,7 @@ exports.validateFileSize = validateFileSize;
 exports.estimateTokens = estimateTokens;
 exports.validateTokenLimit = validateTokenLimit;
 exports.truncateToTokenLimit = truncateToTokenLimit;
+const GitHubCopilotEndpoints_1 = require("./GitHubCopilotEndpoints");
 async function makeGitHubCopilotRequest(context, endpoint, body, hasMedia = false) {
     var _a;
     const credentials = await context.getCredentials('githubCopilotApi');
@@ -42,7 +43,7 @@ async function makeGitHubCopilotRequest(context, endpoint, body, hasMedia = fals
         headers,
         body: JSON.stringify(body),
     };
-    const response = await fetch(`https://api.githubcopilot.com${endpoint}`, options);
+    const response = await fetch(`${GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.BASE_URL}${endpoint}`, options);
     if (!response.ok) {
         const errorText = await response.text();
         const tokenPrefix = token.substring(0, 4);

package/dist/shared/utils/GitHubCopilotEndpoints.d.ts

@@ -0,0 +1,67 @@
+export declare const GITHUB_COPILOT_API: {
+    readonly BASE_URL: "https://api.githubcopilot.com";
+    readonly GITHUB_BASE_URL: "https://api.github.com";
+    readonly ENDPOINTS: {
+        readonly MODELS: "/models";
+        readonly CHAT_COMPLETIONS: "/chat/completions";
+        readonly ORG_BILLING: (org: string) => string;
+        readonly ORG_SEATS: (org: string) => string;
+        readonly USER_COPILOT: "/user/copilot_access";
+    };
+    readonly URLS: {
+        readonly MODELS: "https://api.githubcopilot.com/models";
+        readonly CHAT_COMPLETIONS: "https://api.githubcopilot.com/chat/completions";
+        readonly ORG_BILLING: (org: string) => string;
+        readonly ORG_SEATS: (org: string) => string;
+        readonly USER_COPILOT: "https://api.github.com/user/copilot_access";
+    };
+    readonly HEADERS: {
+        readonly DEFAULT: {
+            readonly Accept: "application/json";
+            readonly 'Content-Type': "application/json";
+        };
+        readonly WITH_AUTH: (token: string) => {
+            Authorization: string;
+            Accept: string;
+            'Content-Type': string;
+        };
+        readonly VSCODE_CLIENT: {
+            readonly 'User-Agent': "VSCode-Copilot";
+            readonly 'X-GitHub-Api-Version': "2022-11-28";
+        };
+    };
+    readonly RATE_LIMITS: {
+        readonly TPM_RETRY_DELAY_BASE: 1000;
+        readonly TPM_RETRY_MAX_DELAY: 10000;
+        readonly DEFAULT_MAX_RETRIES: 3;
+        readonly EXPONENTIAL_BACKOFF_FACTOR: 2;
+    };
+    readonly STATUS_CODES: {
+        readonly OK: 200;
+        readonly UNAUTHORIZED: 401;
+        readonly FORBIDDEN: 403;
+        readonly NOT_FOUND: 404;
+        readonly TOO_MANY_REQUESTS: 429;
+        readonly INTERNAL_SERVER_ERROR: 500;
+    };
+    readonly ERRORS: {
+        readonly INVALID_TOKEN: "Invalid token format. GitHub Copilot API requires tokens starting with \"gho_\"";
+        readonly CREDENTIALS_REQUIRED: "GitHub Copilot API credentials are required";
+        readonly TPM_QUOTA_EXCEEDED: "TPM (Transactions Per Minute) quota exceeded";
+        readonly API_ERROR: (status: number, message: string) => string;
+    };
+};
+export type GitHubCopilotEndpoint = keyof typeof GITHUB_COPILOT_API.ENDPOINTS;
+export type GitHubCopilotUrl = keyof typeof GITHUB_COPILOT_API.URLS;
+export type GitHubCopilotStatusCode = typeof GITHUB_COPILOT_API.STATUS_CODES[keyof typeof GITHUB_COPILOT_API.STATUS_CODES];
+export declare class GitHubCopilotEndpoints {
+    static getModelsUrl(): string;
+    static getChatCompletionsUrl(): string;
+    static getOrgBillingUrl(org: string): string;
+    static getOrgSeatsUrl(org: string): string;
+    static getUserCopilotUrl(): string;
+    static getAuthHeaders(token: string, includeVSCodeHeaders?: boolean): Record<string, string>;
+    static getRetryDelay(attempt: number): number;
+    static isTpmQuotaError(statusCode: number): boolean;
+    static validateToken(token: string): boolean;
+}

package/dist/shared/utils/GitHubCopilotEndpoints.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHubCopilotEndpoints = exports.GITHUB_COPILOT_API = void 0;
+exports.GITHUB_COPILOT_API = {
+    BASE_URL: 'https://api.githubcopilot.com',
+    GITHUB_BASE_URL: 'https://api.github.com',
+    ENDPOINTS: {
+        MODELS: '/models',
+        CHAT_COMPLETIONS: '/chat/completions',
+        ORG_BILLING: (org) => `/orgs/${org}/copilot/billing`,
+        ORG_SEATS: (org) => `/orgs/${org}/copilot/billing/seats`,
+        USER_COPILOT: '/user/copilot_access',
+    },
+    URLS: {
+        MODELS: 'https://api.githubcopilot.com/models',
+        CHAT_COMPLETIONS: 'https://api.githubcopilot.com/chat/completions',
+        ORG_BILLING: (org) => `https://api.github.com/orgs/${org}/copilot/billing`,
+        ORG_SEATS: (org) => `https://api.github.com/orgs/${org}/copilot/billing/seats`,
+        USER_COPILOT: 'https://api.github.com/user/copilot_access',
+    },
+    HEADERS: {
+        DEFAULT: {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+        },
+        WITH_AUTH: (token) => ({
+            'Authorization': `Bearer ${token}`,
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+        }),
+        VSCODE_CLIENT: {
+            'User-Agent': 'VSCode-Copilot',
+            'X-GitHub-Api-Version': '2022-11-28',
+        },
+    },
+    RATE_LIMITS: {
+        TPM_RETRY_DELAY_BASE: 1000,
+        TPM_RETRY_MAX_DELAY: 10000,
+        DEFAULT_MAX_RETRIES: 3,
+        EXPONENTIAL_BACKOFF_FACTOR: 2,
+    },
+    STATUS_CODES: {
+        OK: 200,
+        UNAUTHORIZED: 401,
+        FORBIDDEN: 403,
+        NOT_FOUND: 404,
+        TOO_MANY_REQUESTS: 429,
+        INTERNAL_SERVER_ERROR: 500,
+    },
+    ERRORS: {
+        INVALID_TOKEN: 'Invalid token format. GitHub Copilot API requires tokens starting with "gho_"',
+        CREDENTIALS_REQUIRED: 'GitHub Copilot API credentials are required',
+        TPM_QUOTA_EXCEEDED: 'TPM (Transactions Per Minute) quota exceeded',
+        API_ERROR: (status, message) => `API Error ${status}: ${message}`,
+    },
+};
+class GitHubCopilotEndpoints {
+    static getModelsUrl() {
+        return exports.GITHUB_COPILOT_API.URLS.MODELS;
+    }
+    static getChatCompletionsUrl() {
+        return exports.GITHUB_COPILOT_API.URLS.CHAT_COMPLETIONS;
+    }
+    static getOrgBillingUrl(org) {
+        return exports.GITHUB_COPILOT_API.URLS.ORG_BILLING(org);
+    }
+    static getOrgSeatsUrl(org) {
+        return exports.GITHUB_COPILOT_API.URLS.ORG_SEATS(org);
+    }
+    static getUserCopilotUrl() {
+        return exports.GITHUB_COPILOT_API.URLS.USER_COPILOT;
+    }
+    static getAuthHeaders(token, includeVSCodeHeaders = false) {
+        const headers = exports.GITHUB_COPILOT_API.HEADERS.WITH_AUTH(token);
+        if (includeVSCodeHeaders) {
+            return {
+                ...headers,
+                ...exports.GITHUB_COPILOT_API.HEADERS.VSCODE_CLIENT,
+            };
+        }
+        return headers;
+    }
+    static getRetryDelay(attempt) {
+        const delay = exports.GITHUB_COPILOT_API.RATE_LIMITS.TPM_RETRY_DELAY_BASE *
+            Math.pow(exports.GITHUB_COPILOT_API.RATE_LIMITS.EXPONENTIAL_BACKOFF_FACTOR, attempt - 1);
+        return Math.min(delay, exports.GITHUB_COPILOT_API.RATE_LIMITS.TPM_RETRY_MAX_DELAY);
+    }
+    static isTpmQuotaError(statusCode) {
+        return statusCode === exports.GITHUB_COPILOT_API.STATUS_CODES.FORBIDDEN;
+    }
+    static validateToken(token) {
+        return typeof token === 'string' && token.startsWith('gho_');
+    }
+}
+exports.GitHubCopilotEndpoints = GitHubCopilotEndpoints;

package/package.json

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