n8n-nodes-github-copilot 3.32.2 → 3.33.0

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

@@ -1,5 +1,10 @@
-import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from "n8n-workflow";
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription, ILoadOptionsFunctions, INodePropertyOptions } from "n8n-workflow";
 export declare class GitHubCopilotChatAPI implements INodeType {
     description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getAvailableModels(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
     execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
 }

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

@@ -6,6 +6,7 @@ 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");
+const DynamicModelLoader_1 = require("../../shared/models/DynamicModelLoader");
 class GitHubCopilotChatAPI {
     constructor() {
         this.description = {
@@ -29,9 +30,16 @@ class GitHubCopilotChatAPI {
             ],
             properties: nodeProperties_1.nodeProperties,
         };
+        this.methods = {
+            loadOptions: {
+                async getAvailableModels() {
+                    return await DynamicModelLoader_1.loadAvailableModels.call(this);
+                },
+            },
+        };
     }
     async execute() {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d;
         const items = this.getInputData();
         const returnData = [];
         for (let i = 0; i < items.length; i++) {
@@ -114,14 +122,13 @@ class GitHubCopilotChatAPI {
                     while (attempt <= totalAttempts) {
                         try {
                             response = await (0, utils_1.makeApiRequest)(this, GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.ENDPOINTS.CHAT_COMPLETIONS, requestBody, hasMedia);
-                            retriesUsed = ((_a = response._retryMetadata) === null || _a === void 0 ? void 0 : _a.retries) || 0;
-                            attempt = ((_b = response._retryMetadata) === null || _b === void 0 ? void 0 : _b.attempts) || 1;
+                            retriesUsed = attempt - 1;
                             break;
                         }
                         catch (error) {
                             const isLastAttempt = attempt >= totalAttempts;
                             const errorObj = error;
-                            const is403Error = errorObj.status === 403 || ((_c = errorObj.message) === null || _c === void 0 ? void 0 : _c.includes("403"));
+                            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}/${totalAttempts} failed with 403, retrying in ${delay}ms...`);
@@ -137,13 +144,12 @@ class GitHubCopilotChatAPI {
                         throw new Error(`Failed to get response from GitHub Copilot API after ${totalAttempts} attempts (${retriesUsed} retries)`);
                     }
                     const result = {
-                        message: ((_e = (_d = response.choices[0]) === null || _d === void 0 ? void 0 : _d.message) === null || _e === void 0 ? void 0 : _e.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: ((_f = response.choices[0]) === null || _f === void 0 ? void 0 : _f.finish_reason) || "unknown",
+                        finish_reason: ((_d = response.choices[0]) === null || _d === void 0 ? void 0 : _d.finish_reason) || "unknown",
                         retries: retriesUsed,
-                        attempts: attempt,
                     };
                     returnData.push({
                         json: result,

package/dist/nodes/GitHubCopilotChatAPI/nodeProperties.js

@@ -21,9 +21,11 @@ exports.nodeProperties = [
         displayName: "Model",
         name: "model",
         type: "options",
-        options: GitHubCopilotModels_1.GitHubCopilotModelsManager.toN8nOptions(),
+        typeOptions: {
+            loadOptionsMethod: "getAvailableModels",
+        },
         default: GitHubCopilotModels_1.DEFAULT_MODELS.GENERAL,
-        description: "Select the GitHub Copilot model to use",
+        description: "Select the GitHub Copilot model to use (loaded dynamically based on your subscription)",
     },
     {
         displayName: "Message",

package/dist/nodes/GitHubCopilotOpenAI/GitHubCopilotOpenAI.node.js

@@ -30,7 +30,7 @@ class GitHubCopilotOpenAI {
         };
     }
     async execute() {
-        var _a, _b;
+        var _a;
         const items = this.getInputData();
         const returnData = [];
         for (let i = 0; i < items.length; i++) {
@@ -165,9 +165,8 @@ class GitHubCopilotOpenAI {
                     }
                     const response = await (0, utils_1.makeApiRequest)(this, GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.ENDPOINTS.CHAT_COMPLETIONS, requestBody, false);
                     const retriesUsed = ((_a = response._retryMetadata) === null || _a === void 0 ? void 0 : _a.retries) || 0;
-                    const attemptsUsed = ((_b = response._retryMetadata) === null || _b === void 0 ? void 0 : _b.attempts) || 1;
                     if (retriesUsed > 0) {
-                        console.log(`ℹ️ Request completed after ${attemptsUsed} attempts (${retriesUsed} retries)`);
+                        console.log(`ℹ️ Request completed with ${retriesUsed} retry(ies)`);
                     }
                     const cleanJsonFromMarkdown = (content) => {
                         if (!content || typeof content !== 'string') {
@@ -238,7 +237,6 @@ class GitHubCopilotOpenAI {
                         },
                         ...(retriesUsed > 0 && {
                             _retry_info: {
-                                attempts: attemptsUsed,
                                 retries: retriesUsed,
                             }
                         }),

package/dist/package.json

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

package/dist/shared/models/DynamicModelLoader.d.ts

@@ -0,0 +1,2 @@
+import { ILoadOptionsFunctions, INodePropertyOptions } from "n8n-workflow";
+export declare function loadAvailableModels(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;

package/dist/shared/models/DynamicModelLoader.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAvailableModels = loadAvailableModels;
+const DynamicModelsManager_1 = require("../utils/DynamicModelsManager");
+const OAuthTokenManager_1 = require("../utils/OAuthTokenManager");
+async function loadAvailableModels() {
+    try {
+        const credentials = await this.getCredentials("githubCopilotApi");
+        if (!credentials || !credentials.token) {
+            console.warn("⚠️ No credentials found for dynamic model loading");
+            return getDefaultModels();
+        }
+        const githubToken = credentials.token;
+        let oauthToken;
+        try {
+            oauthToken = await OAuthTokenManager_1.OAuthTokenManager.getValidOAuthToken(githubToken);
+        }
+        catch (error) {
+            console.error("❌ Failed to generate OAuth token for model loading:", error);
+            return getDefaultModels();
+        }
+        const models = await DynamicModelsManager_1.DynamicModelsManager.getAvailableModels(oauthToken);
+        const options = DynamicModelsManager_1.DynamicModelsManager.modelsToN8nOptions(models);
+        console.log(`✅ Loaded ${options.length} models dynamically`);
+        return options;
+    }
+    catch (error) {
+        console.error("❌ Error loading dynamic models:", error);
+        return getDefaultModels();
+    }
+}
+function getDefaultModels() {
+    return [
+        {
+            name: "GPT-4o (Latest)",
+            value: "gpt-4o",
+            description: "Most capable GPT-4o model - Best for complex tasks",
+        },
+        {
+            name: "GPT-4o Mini",
+            value: "gpt-4o-mini",
+            description: "Faster and cheaper GPT-4o variant - Good for simple tasks",
+        },
+        {
+            name: "Claude 3.5 Sonnet",
+            value: "claude-3.5-sonnet",
+            description: "Anthropic's most capable model - Excellent reasoning",
+        },
+        {
+            name: "o1-preview",
+            value: "o1-preview",
+            description: "OpenAI's reasoning model (preview)",
+        },
+        {
+            name: "o1-mini",
+            value: "o1-mini",
+            description: "Faster reasoning model variant",
+        },
+    ];
+}

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

@@ -0,0 +1,29 @@
+interface CopilotModel {
+    id: string;
+    name: string;
+    display_name?: string;
+    model_picker_enabled?: boolean;
+    capabilities?: string[];
+}
+export declare class DynamicModelsManager {
+    private static cache;
+    private static readonly CACHE_DURATION_MS;
+    private static readonly MIN_REFRESH_INTERVAL_MS;
+    private static hashToken;
+    private static fetchModelsFromAPI;
+    static getAvailableModels(oauthToken: string): Promise<CopilotModel[]>;
+    static modelsToN8nOptions(models: CopilotModel[]): Array<{
+        name: string;
+        value: string;
+        description?: string;
+    }>;
+    static clearCache(oauthToken: string): void;
+    static clearAllCache(): void;
+    static getCacheInfo(oauthToken: string): {
+        cached: boolean;
+        modelsCount: number;
+        expiresIn: number;
+        fetchedAt: string;
+    } | null;
+}
+export {};

package/dist/shared/utils/DynamicModelsManager.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicModelsManager = void 0;
+const GitHubCopilotEndpoints_1 = require("./GitHubCopilotEndpoints");
+class DynamicModelsManager {
+    static hashToken(token) {
+        let hash = 0;
+        for (let i = 0; i < token.length; i++) {
+            const char = token.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash;
+        }
+        return `models_${Math.abs(hash).toString(36)}`;
+    }
+    static async fetchModelsFromAPI(oauthToken) {
+        const url = `${GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.BASE_URL}${GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.ENDPOINTS.MODELS}`;
+        console.log("🔄 Fetching available models from GitHub Copilot API...");
+        const response = await fetch(url, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${oauthToken}`,
+                Accept: "application/json",
+                "Content-Type": "application/json",
+                "User-Agent": "GitHub-Copilot/1.0 (n8n-node)",
+                "Editor-Version": "vscode/1.95.0",
+                "Editor-Plugin-Version": "copilot/1.0.0",
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`❌ Failed to fetch models: ${response.status} ${response.statusText}`);
+            console.error(`❌ Error details: ${errorText}`);
+            throw new Error(`Failed to fetch models: ${response.status} ${response.statusText}`);
+        }
+        const data = (await response.json());
+        const enabledModels = data.data.filter((model) => model.model_picker_enabled !== false);
+        console.log(`✅ Fetched ${enabledModels.length} enabled models (${data.data.length} total)`);
+        return enabledModels;
+    }
+    static async getAvailableModels(oauthToken) {
+        const tokenHash = this.hashToken(oauthToken);
+        const now = Date.now();
+        const cached = this.cache.get(tokenHash);
+        if (cached && cached.expiresAt > now) {
+            const remainingMinutes = Math.round((cached.expiresAt - now) / 60000);
+            console.log(`✅ Using cached models (expires in ${remainingMinutes} minutes)`);
+            return cached.models;
+        }
+        if (cached && now - cached.fetchedAt < this.MIN_REFRESH_INTERVAL_MS) {
+            const waitSeconds = Math.round((this.MIN_REFRESH_INTERVAL_MS - (now - cached.fetchedAt)) / 1000);
+            console.log(`⏰ Models fetched recently, using cache (min refresh interval: ${waitSeconds}s)`);
+            return cached.models;
+        }
+        try {
+            const models = await this.fetchModelsFromAPI(oauthToken);
+            this.cache.set(tokenHash, {
+                models,
+                fetchedAt: now,
+                expiresAt: now + this.CACHE_DURATION_MS,
+                tokenHash,
+            });
+            return models;
+        }
+        catch (error) {
+            console.error("❌ Failed to fetch models from API:", error);
+            if (cached) {
+                console.log("⚠️ Using expired cache as fallback");
+                return cached.models;
+            }
+            throw error;
+        }
+    }
+    static modelsToN8nOptions(models) {
+        return models.map((model) => ({
+            name: model.display_name || model.name || model.id,
+            value: model.id,
+            description: model.capabilities ? `Capabilities: ${model.capabilities.join(", ")}` : undefined,
+        }));
+    }
+    static clearCache(oauthToken) {
+        const tokenHash = this.hashToken(oauthToken);
+        this.cache.delete(tokenHash);
+        console.log("🗑️ Cleared models cache");
+    }
+    static clearAllCache() {
+        this.cache.clear();
+        console.log("🗑️ Cleared all models cache");
+    }
+    static getCacheInfo(oauthToken) {
+        const tokenHash = this.hashToken(oauthToken);
+        const cached = this.cache.get(tokenHash);
+        if (!cached) {
+            return null;
+        }
+        const now = Date.now();
+        return {
+            cached: true,
+            modelsCount: cached.models.length,
+            expiresIn: Math.max(0, cached.expiresAt - now),
+            fetchedAt: new Date(cached.fetchedAt).toISOString(),
+        };
+    }
+}
+exports.DynamicModelsManager = DynamicModelsManager;
+DynamicModelsManager.cache = new Map();
+DynamicModelsManager.CACHE_DURATION_MS = 60 * 60 * 1000;
+DynamicModelsManager.MIN_REFRESH_INTERVAL_MS = 5 * 60 * 1000;

package/dist/shared/utils/GitHubCopilotApiUtils.js

@@ -11,6 +11,7 @@ exports.validateTokenLimit = validateTokenLimit;
 exports.truncateToTokenLimit = truncateToTokenLimit;
 const GitHubCopilotEndpoints_1 = require("./GitHubCopilotEndpoints");
 const OAuthTokenManager_1 = require("./OAuthTokenManager");
+const DynamicModelsManager_1 = require("./DynamicModelsManager");
 async function makeGitHubCopilotRequest(context, endpoint, body, hasMedia = false, retryConfig) {
     var _a, _b, _c;
     const MAX_RETRIES = (_a = retryConfig === null || retryConfig === void 0 ? void 0 : retryConfig.maxRetries) !== null && _a !== void 0 ? _a : 3;
@@ -37,6 +38,13 @@ async function makeGitHubCopilotRequest(context, endpoint, body, hasMedia = fals
     try {
         token = await OAuthTokenManager_1.OAuthTokenManager.getValidOAuthToken(githubToken);
         console.log(`✅ OAuth token ready (auto-generated from GitHub token)`);
+        DynamicModelsManager_1.DynamicModelsManager.getAvailableModels(token)
+            .then((models) => {
+            console.log(`✅ Models list updated: ${models.length} models available`);
+        })
+            .catch((error) => {
+            console.warn(`⚠️ Failed to update models list: ${error instanceof Error ? error.message : String(error)}`);
+        });
     }
     catch (error) {
         throw new Error(`Failed to generate OAuth token: ${error instanceof Error ? error.message : String(error)}`);

package/package.json

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