n8n-nodes-github-copilot 3.32.3 → 3.35.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,6 +30,13 @@ 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;
@@ -37,7 +45,29 @@ class GitHubCopilotChatAPI {
         for (let i = 0; i < items.length; i++) {
             try {
                 const operation = this.getNodeParameter("operation", i);
-                const model = this.getNodeParameter("model", i);
+                const modelSource = this.getNodeParameter("modelSource", i, "fromList");
+                let model;
+                if (modelSource === "custom") {
+                    model = this.getNodeParameter("customModel", i);
+                    if (!model || model.trim() === "") {
+                        throw new Error("Custom model name is required when using 'Custom (Manual Entry)' mode");
+                    }
+                    console.log(`🔧 Using custom model: ${model}`);
+                }
+                else {
+                    const selectedModel = this.getNodeParameter("model", i);
+                    if (selectedModel === "__manual__") {
+                        model = this.getNodeParameter("customModel", i);
+                        if (!model || model.trim() === "") {
+                            throw new Error("Custom model name is required when selecting '✏️ Enter Custom Model Name'");
+                        }
+                        console.log(`✏️ Using manually entered model: ${model}`);
+                    }
+                    else {
+                        model = selectedModel;
+                        console.log(`✅ Using model from list: ${model}`);
+                    }
+                }
                 if (operation === "chat") {
                     const userMessage = this.getNodeParameter("message", i);
                     const systemMessage = this.getNodeParameter("systemMessage", i, "");
@@ -47,9 +77,12 @@ class GitHubCopilotChatAPI {
                     const includeMedia = this.getNodeParameter("includeMedia", i, false);
                     const modelInfo = GitHubCopilotModels_1.GitHubCopilotModelsManager.getModelByValue(model);
                     if (includeMedia) {
-                        if (!(modelInfo === null || modelInfo === void 0 ? void 0 : modelInfo.capabilities.vision) && !(modelInfo === null || modelInfo === void 0 ? void 0 : modelInfo.capabilities.multimodal)) {
+                        if (modelInfo && !(modelInfo === null || modelInfo === void 0 ? void 0 : modelInfo.capabilities.vision) && !(modelInfo === null || modelInfo === void 0 ? void 0 : modelInfo.capabilities.multimodal)) {
                             throw new Error(`Model ${model} does not support vision/image processing. Please select a model with vision capabilities.`);
                         }
+                        else if (!modelInfo) {
+                            console.warn(`⚠️ Model ${model} not found in known models list. Vision capability unknown - proceeding anyway.`);
+                        }
                     }
                     const messages = [];
                     if (systemMessage) {

package/dist/nodes/GitHubCopilotChatAPI/nodeProperties.js

@@ -17,13 +17,68 @@ exports.nodeProperties = [
         ],
         default: "chat",
     },
+    {
+        displayName: "Model Source",
+        name: "modelSource",
+        type: "options",
+        options: [
+            {
+                name: "From List (Auto-Discovered)",
+                value: "fromList",
+                description: "Select from available models based on your subscription",
+            },
+            {
+                name: "Custom (Manual Entry)",
+                value: "custom",
+                description: "Enter model name manually (use at your own risk)",
+            },
+        ],
+        default: "fromList",
+        description: "Choose how to specify the model",
+    },
     {
         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)",
+        displayOptions: {
+            show: {
+                modelSource: ["fromList"],
+            },
+        },
+    },
+    {
+        displayName: "Custom Model Name",
+        name: "customModel",
+        type: "string",
+        default: "",
+        placeholder: "gpt-4o, claude-3.5-sonnet, grok-code-fast-1, etc.",
+        description: "Enter the model name manually. Use at your own risk if the model is not available in your subscription.",
+        hint: "Examples: gpt-4o, gpt-4o-mini, claude-3.5-sonnet, gemini-2.0-flash-exp, grok-code-fast-1",
+        displayOptions: {
+            show: {
+                modelSource: ["custom"],
+            },
+        },
+    },
+    {
+        displayName: "Custom Model Name",
+        name: "customModel",
+        type: "string",
+        default: "",
+        placeholder: "gpt-4o, claude-3.5-sonnet, grok-code-fast-1, etc.",
+        description: "Enter the model name manually. This is useful for new/beta models not yet in the list.",
+        hint: "Examples: gpt-4o, gpt-4o-mini, claude-3.5-sonnet, gemini-2.0-flash-exp, grok-code-fast-1",
+        displayOptions: {
+            show: {
+                modelSource: ["fromList"],
+                model: ["__manual__"],
+            },
+        },
     },
     {
         displayName: "Message",

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "n8n-nodes-github-copilot",
-    "version": "3.32.3",
+    "version": "3.35.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, forceRefresh?: boolean): Promise<INodePropertyOptions[]>;

package/dist/shared/models/DynamicModelLoader.js

@@ -0,0 +1,82 @@
+"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(forceRefresh = false) {
+    try {
+        const credentials = await this.getCredentials("githubCopilotApi");
+        if (!credentials || !credentials.token) {
+            console.warn("⚠️ No credentials found for dynamic model loading");
+            return getDefaultModelsWithManualInput();
+        }
+        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 getDefaultModelsWithManualInput();
+        }
+        if (forceRefresh) {
+            DynamicModelsManager_1.DynamicModelsManager.clearCache(oauthToken);
+            console.log("🔄 Force refreshing models list...");
+        }
+        const models = await DynamicModelsManager_1.DynamicModelsManager.getAvailableModels(oauthToken);
+        const options = DynamicModelsManager_1.DynamicModelsManager.modelsToN8nOptions(models);
+        const optionsWithManualInput = [
+            {
+                name: "✏️ Enter Custom Model Name",
+                value: "__manual__",
+                description: "Type your own model name (for new/beta models)",
+            },
+            ...options,
+        ];
+        console.log(`✅ Loaded ${options.length} models dynamically (+ manual input option)`);
+        return optionsWithManualInput;
+    }
+    catch (error) {
+        console.error("❌ Error loading dynamic models:", error);
+        return getDefaultModelsWithManualInput();
+    }
+}
+function getDefaultModelsWithManualInput() {
+    return [
+        {
+            name: "✏️ Enter Custom Model Name",
+            value: "__manual__",
+            description: "Type your own model name (for new/beta models)",
+        },
+        ...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/properties/ModelSelectionProperty.d.ts

@@ -0,0 +1,4 @@
+import { INodeProperties } from "n8n-workflow";
+export declare const modelSelectionProperty: INodeProperties;
+export declare const modelRefreshProperty: INodeProperties;
+export declare const refreshTriggerProperty: INodeProperties;

package/dist/shared/properties/ModelSelectionProperty.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshTriggerProperty = exports.modelRefreshProperty = exports.modelSelectionProperty = void 0;
+const GitHubCopilotModels_1 = require("../models/GitHubCopilotModels");
+exports.modelSelectionProperty = {
+    displayName: "Model",
+    name: "model",
+    type: "options",
+    typeOptions: {
+        loadOptionsMethod: "getAvailableModels",
+        loadOptionsDependsOn: ["refresh"],
+    },
+    default: GitHubCopilotModels_1.DEFAULT_MODELS.GENERAL,
+    required: true,
+    description: "Select a model from your subscription or enter a custom model name",
+    placeholder: "Select model or type custom name (e.g., gpt-4o, claude-3.5-sonnet)",
+    hint: "Models are loaded based on your GitHub Copilot subscription. Use the refresh button to update the list.",
+    validateType: "string",
+    ignoreValidationDuringExecution: false,
+};
+exports.modelRefreshProperty = {
+    displayName: "Refresh Models",
+    name: "refreshModels",
+    type: "button",
+    typeOptions: {
+        action: "refreshModels",
+    },
+    default: "",
+    description: "Click to refresh the list of available models from your subscription",
+    displayOptions: {
+        show: {
+            operation: ["chat"],
+        },
+    },
+};
+exports.refreshTriggerProperty = {
+    displayName: "Refresh Trigger",
+    name: "refresh",
+    type: "hidden",
+    default: 0,
+    description: "Internal field to trigger model list refresh",
+};

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

@@ -0,0 +1,32 @@
+interface CopilotModel {
+    id: string;
+    name: string;
+    display_name?: string;
+    model_picker_enabled?: boolean;
+    capabilities?: any;
+    vendor?: string;
+    version?: string;
+    preview?: boolean;
+}
+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,141 @@
+"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());
+        console.log(`✅ Fetched ${data.data.length} models from API`);
+        return data.data;
+    }
+    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) => {
+            const badges = [];
+            if (model.capabilities) {
+                const supports = model.capabilities.supports || {};
+                if (supports.streaming)
+                    badges.push("🔄 Streaming");
+                if (supports.tool_calls)
+                    badges.push("🔧 Tools");
+                if (supports.vision)
+                    badges.push("👁️ Vision");
+                if (supports.structured_outputs)
+                    badges.push("📋 Structured");
+                if (supports.parallel_tool_calls)
+                    badges.push("⚡ Parallel");
+                if (supports.max_thinking_budget)
+                    badges.push("🧠 Reasoning");
+            }
+            const displayName = model.display_name || model.name || model.id;
+            const badgesText = badges.length > 0 ? ` [${badges.join(" • ")}]` : "";
+            let description = "";
+            if (model.capabilities) {
+                const limits = model.capabilities.limits || {};
+                const parts = [];
+                if (limits.max_context_window_tokens) {
+                    parts.push(`Context: ${(limits.max_context_window_tokens / 1000).toFixed(0)}k`);
+                }
+                if (limits.max_output_tokens) {
+                    parts.push(`Output: ${(limits.max_output_tokens / 1000).toFixed(0)}k`);
+                }
+                if (model.vendor) {
+                    parts.push(`Provider: ${model.vendor}`);
+                }
+                description = parts.join(" • ");
+            }
+            return {
+                name: `${displayName}${badgesText}`,
+                value: model.id,
+                description: description || 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.3",
+  "version": "3.35.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",