n8n-nodes-github-copilot 3.20.0 → 3.23.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/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,6 +5,7 @@ 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 = {
@@ -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

@@ -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 = {
@@ -98,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],
+                                },
+                            },
+                        },
                     ],
                 },
             ],
@@ -130,8 +150,9 @@ 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: '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/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/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.23.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",