n8n-nodes-github-copilot 3.36.0 → 3.37.1

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

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

package/dist/nodes/GitHubCopilotEmbeddings/GitHubCopilotEmbeddings.node.js

@@ -0,0 +1,403 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHubCopilotEmbeddings = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const OAuthTokenManager_1 = require("../../shared/utils/OAuthTokenManager");
+const GitHubCopilotEndpoints_1 = require("../../shared/utils/GitHubCopilotEndpoints");
+const DynamicModelLoader_1 = require("../../shared/models/DynamicModelLoader");
+async function executeEmbeddingsWithRetry(oauthToken, requestBody, enableRetry, maxRetries) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            const response = await fetch(`${GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.BASE_URL}${GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.ENDPOINTS.EMBEDDINGS}`, {
+                method: "POST",
+                headers: GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.getEmbeddingsHeaders(oauthToken),
+                body: JSON.stringify(requestBody),
+            });
+            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 + 1);
+                    console.log(`Attempt ${attempt + 1} failed with ${response.status}, 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());
+            return data;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt < maxRetries && enableRetry) {
+                const delay = GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.getRetryDelay(attempt + 1);
+                console.log(`Attempt ${attempt + 1} failed, retrying in ${delay}ms...`);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                continue;
+            }
+            throw lastError;
+        }
+    }
+    throw lastError || new Error("Maximum retry attempts exceeded");
+}
+class GitHubCopilotEmbeddings {
+    constructor() {
+        this.description = {
+            displayName: "GitHub Copilot Embeddings",
+            name: "gitHubCopilotEmbeddings",
+            icon: "file:../../shared/icons/copilot.svg",
+            group: ["transform"],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: "Generate text embeddings using GitHub Copilot API",
+            defaults: {
+                name: "GitHub Copilot Embeddings",
+            },
+            inputs: ["main"],
+            outputs: ["main"],
+            credentials: [
+                {
+                    name: "githubCopilotApi",
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: "Operation",
+                    name: "operation",
+                    type: "options",
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: "Generate Embeddings",
+                            value: "generate",
+                            description: "Generate vector embeddings for text input",
+                            action: "Generate embeddings for text",
+                        },
+                    ],
+                    default: "generate",
+                },
+                {
+                    displayName: "Model",
+                    name: "model",
+                    type: "options",
+                    typeOptions: {
+                        loadOptionsMethod: "getAvailableEmbeddingModels",
+                    },
+                    options: [
+                        {
+                            name: "Text Embedding 3 Small",
+                            value: "text-embedding-3-small",
+                            description: "OpenAI's text-embedding-3-small model (recommended)",
+                        },
+                        {
+                            name: "Text Embedding Ada 002",
+                            value: "text-embedding-ada-002",
+                            description: "Legacy embedding model",
+                        },
+                        {
+                            name: "Text Embedding 3 Small (Inference)",
+                            value: "text-embedding-3-small-inference",
+                            description: "Optimized inference variant",
+                        },
+                    ],
+                    default: "text-embedding-3-small",
+                    description: "The embedding model to use. Models are auto-discovered from your GitHub Copilot subscription.",
+                },
+                {
+                    displayName: "Custom Model Name",
+                    name: "customModel",
+                    type: "string",
+                    default: "",
+                    required: true,
+                    placeholder: "e.g., text-embedding-3-large",
+                    description: "Enter the exact model name to use",
+                    displayOptions: {
+                        show: {
+                            model: ["__manual__"],
+                        },
+                    },
+                },
+                {
+                    displayName: "Input Mode",
+                    name: "inputMode",
+                    type: "options",
+                    options: [
+                        {
+                            name: "Single Text",
+                            value: "single",
+                            description: "Embed a single text string",
+                        },
+                        {
+                            name: "Batch (Array)",
+                            value: "batch",
+                            description: "Embed multiple texts in a single request (more efficient)",
+                        },
+                        {
+                            name: "From Field",
+                            value: "field",
+                            description: "Embed text from a specific field in each input item",
+                        },
+                    ],
+                    default: "single",
+                    description: "How to provide the text input",
+                },
+                {
+                    displayName: "Text",
+                    name: "text",
+                    type: "string",
+                    typeOptions: {
+                        rows: 4,
+                    },
+                    default: "",
+                    required: true,
+                    placeholder: "Enter text to embed",
+                    description: "The text to generate embeddings for",
+                    displayOptions: {
+                        show: {
+                            inputMode: ["single"],
+                        },
+                    },
+                },
+                {
+                    displayName: "Texts",
+                    name: "texts",
+                    type: "string",
+                    typeOptions: {
+                        rows: 8,
+                    },
+                    default: "",
+                    required: true,
+                    placeholder: '["Text 1", "Text 2", "Text 3"]',
+                    description: "JSON array of texts to embed in a single request (more efficient than multiple calls)",
+                    displayOptions: {
+                        show: {
+                            inputMode: ["batch"],
+                        },
+                    },
+                },
+                {
+                    displayName: "Field Name",
+                    name: "fieldName",
+                    type: "string",
+                    default: "text",
+                    required: true,
+                    placeholder: "text",
+                    description: "Name of the field containing the text to embed",
+                    displayOptions: {
+                        show: {
+                            inputMode: ["field"],
+                        },
+                    },
+                },
+                {
+                    displayName: "Options",
+                    name: "options",
+                    type: "collection",
+                    placeholder: "Add Option",
+                    default: {},
+                    options: [
+                        {
+                            displayName: "Dimensions",
+                            name: "dimensions",
+                            type: "number",
+                            default: 1536,
+                            description: "The number of dimensions for the embedding. Only supported by text-embedding-3-small.",
+                            typeOptions: {
+                                minValue: 1,
+                                maxValue: 1536,
+                            },
+                            placeholder: "1536",
+                            hint: "Common values: 512, 768, 1024, 1536",
+                        },
+                        {
+                            displayName: "Encoding Format",
+                            name: "encoding_format",
+                            type: "options",
+                            options: [
+                                {
+                                    name: "Float",
+                                    value: "float",
+                                    description: "Standard floating point format (default)",
+                                },
+                                {
+                                    name: "Base64",
+                                    value: "base64",
+                                    description: "Base64-encoded format (more compact)",
+                                },
+                            ],
+                            default: "float",
+                            description: "The format to return the embeddings in",
+                        },
+                        {
+                            displayName: "Return Full Response",
+                            name: "returnFullResponse",
+                            type: "boolean",
+                            default: false,
+                            description: "Whether to return the full API response including usage statistics",
+                        },
+                        {
+                            displayName: "Enable Retry",
+                            name: "enableRetry",
+                            type: "boolean",
+                            default: true,
+                            description: "Whether to retry on TPM quota errors (403)",
+                        },
+                        {
+                            displayName: "Max Retries",
+                            name: "maxRetries",
+                            type: "number",
+                            default: 3,
+                            description: "Maximum number of retry attempts",
+                            displayOptions: {
+                                show: {
+                                    enableRetry: [true],
+                                },
+                            },
+                        },
+                    ],
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getAvailableEmbeddingModels() {
+                    return await DynamicModelLoader_1.loadAvailableEmbeddingModels.call(this);
+                },
+            },
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const operation = this.getNodeParameter("operation", i);
+                const selectedModel = this.getNodeParameter("model", i);
+                let model;
+                if (selectedModel === "__manual__") {
+                    model = this.getNodeParameter("customModel", i);
+                    if (!model || model.trim() === "") {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Custom model name is required when selecting '✏️ Enter Custom Model Name'");
+                    }
+                    console.log(`✏️ Using manually entered embedding model: ${model}`);
+                }
+                else {
+                    model = selectedModel;
+                    console.log(`✅ Using embedding model from list: ${model}`);
+                }
+                const inputMode = this.getNodeParameter("inputMode", i);
+                const options = this.getNodeParameter("options", i, {});
+                const credentials = await this.getCredentials("githubCopilotApi", i);
+                const githubToken = credentials.token;
+                if (!githubToken) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), "GitHub token is required");
+                }
+                if (!GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.validateToken(githubToken)) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Invalid GitHub token format. Token must start with 'gho_' or 'github_pat_'");
+                }
+                const oauthToken = await OAuthTokenManager_1.OAuthTokenManager.getValidOAuthToken(githubToken);
+                const enableRetry = options.enableRetry !== false;
+                const maxRetries = options.maxRetries || 3;
+                let input;
+                switch (inputMode) {
+                    case "single":
+                        input = this.getNodeParameter("text", i);
+                        if (!input || input.trim() === "") {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Text input cannot be empty");
+                        }
+                        input = [input];
+                        break;
+                    case "batch":
+                        const textsStr = this.getNodeParameter("texts", i);
+                        try {
+                            const parsed = JSON.parse(textsStr);
+                            if (!Array.isArray(parsed)) {
+                                throw new Error("Input must be a JSON array");
+                            }
+                            input = parsed;
+                        }
+                        catch (error) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid JSON array: ${error instanceof Error ? error.message : "Unknown error"}`);
+                        }
+                        break;
+                    case "field":
+                        const fieldName = this.getNodeParameter("fieldName", i);
+                        const fieldValue = items[i].json[fieldName];
+                        if (!fieldValue) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Field '${fieldName}' not found in input data`);
+                        }
+                        input = [String(fieldValue)];
+                        break;
+                    default:
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown input mode: ${inputMode}`);
+                }
+                const requestBody = {
+                    model,
+                    input,
+                };
+                if (options.dimensions) {
+                    requestBody.dimensions = options.dimensions;
+                }
+                if (options.encoding_format) {
+                    requestBody.encoding_format = options.encoding_format;
+                }
+                const result = await executeEmbeddingsWithRetry(oauthToken, requestBody, enableRetry, maxRetries);
+                const returnFullResponse = options.returnFullResponse === true;
+                if (returnFullResponse) {
+                    returnData.push({
+                        json: result,
+                        pairedItem: { item: i },
+                    });
+                }
+                else {
+                    if (inputMode === "batch") {
+                        const embeddings = result.data.map((item) => ({
+                            index: item.index,
+                            embedding: item.embedding,
+                            dimensions: item.embedding.length,
+                        }));
+                        returnData.push({
+                            json: {
+                                model: result.model,
+                                embeddings,
+                                usage: result.usage,
+                            },
+                            pairedItem: { item: i },
+                        });
+                    }
+                    else {
+                        const embeddingData = result.data[0];
+                        returnData.push({
+                            json: {
+                                embedding: embeddingData.embedding,
+                                dimensions: embeddingData.embedding.length,
+                                model: result.model,
+                                usage: result.usage,
+                            },
+                            pairedItem: { item: i },
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error instanceof Error ? error.message : "Unknown error occurred",
+                            operation: this.getNodeParameter("operation", i),
+                        },
+                        pairedItem: { item: i },
+                    });
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        return [returnData];
+    }
+}
+exports.GitHubCopilotEmbeddings = GitHubCopilotEmbeddings;

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

@@ -408,6 +408,145 @@ function generateTestRecommendations(testResults) {
     });
     return recommendations;
 }
+async function testEmbeddingModels(token, enableRetry = true, maxRetries = 3) {
+    var _a, _b, _c, _d;
+    const testStartTime = Date.now();
+    try {
+        console.log("🧪 Testing embedding models...");
+        const modelsUrl = `${GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.URLS.MODELS}`;
+        const modelsResponse = await fetch(modelsUrl, {
+            method: "GET",
+            headers: GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.getAuthHeaders(token),
+        });
+        if (!modelsResponse.ok) {
+            throw new Error(`Failed to fetch models: ${modelsResponse.status}`);
+        }
+        const modelsData = (await modelsResponse.json());
+        const embeddingModels = modelsData.data.filter((model) => {
+            var _a;
+            const modelType = (_a = model.capabilities) === null || _a === void 0 ? void 0 : _a.type;
+            return modelType === "embeddings";
+        });
+        console.log(`📊 Found ${embeddingModels.length} embedding models to test`);
+        const testResults = {};
+        const testText = "This is a test sentence for embeddings generation.";
+        for (const model of embeddingModels) {
+            console.log(`\n🔬 Testing model: ${model.name} (${model.id})`);
+            const modelResults = {
+                modelId: model.id,
+                modelName: model.name,
+                vendor: model.vendor,
+                tests: [],
+                summary: {
+                    successCount: 0,
+                    failureCount: 0,
+                    avgResponseTime: 0,
+                    totalResponseTime: 0,
+                    successRate: 0,
+                },
+            };
+            const testsPerModel = 3;
+            for (let testNum = 1; testNum <= testsPerModel; testNum++) {
+                const testStart = Date.now();
+                try {
+                    const requestBody = {
+                        model: model.id,
+                        input: [testText],
+                    };
+                    const response = await fetch(GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.getEmbeddingsUrl(), {
+                        method: "POST",
+                        headers: GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.getEmbeddingsHeaders(token),
+                        body: JSON.stringify(requestBody),
+                    });
+                    const testDuration = Date.now() - testStart;
+                    if (response.ok) {
+                        const data = (await response.json());
+                        const embeddingLength = ((_c = (_b = (_a = data.data) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.embedding) === null || _c === void 0 ? void 0 : _c.length) || 0;
+                        modelResults.tests.push({
+                            testNumber: testNum,
+                            success: true,
+                            responseTime: testDuration,
+                            embeddingDimensions: embeddingLength,
+                            tokensUsed: ((_d = data.usage) === null || _d === void 0 ? void 0 : _d.total_tokens) || 0,
+                        });
+                        modelResults.summary.successCount++;
+                        modelResults.summary.totalResponseTime += testDuration;
+                        console.log(`  ✅ Test ${testNum}/${testsPerModel}: Success (${testDuration}ms, ${embeddingLength}D)`);
+                    }
+                    else {
+                        const errorText = await response.text();
+                        modelResults.tests.push({
+                            testNumber: testNum,
+                            success: false,
+                            responseTime: testDuration,
+                            error: `HTTP ${response.status}: ${errorText.substring(0, 100)}`,
+                        });
+                        modelResults.summary.failureCount++;
+                        console.log(`  ❌ Test ${testNum}/${testsPerModel}: Failed (${response.status})`);
+                    }
+                }
+                catch (error) {
+                    const testDuration = Date.now() - testStart;
+                    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+                    modelResults.tests.push({
+                        testNumber: testNum,
+                        success: false,
+                        responseTime: testDuration,
+                        error: errorMessage,
+                    });
+                    modelResults.summary.failureCount++;
+                    console.log(`  ❌ Test ${testNum}/${testsPerModel}: Error - ${errorMessage}`);
+                }
+                if (testNum < testsPerModel) {
+                    await new Promise((resolve) => setTimeout(resolve, 500));
+                }
+            }
+            const successCount = modelResults.summary.successCount;
+            if (successCount > 0) {
+                modelResults.summary.avgResponseTime = Math.round(modelResults.summary.totalResponseTime / successCount);
+            }
+            modelResults.summary.successRate = Math.round((successCount / testsPerModel) * 100);
+            testResults[model.id] = modelResults;
+        }
+        const testDuration = Date.now() - testStartTime;
+        const allModels = Object.values(testResults);
+        const totalTests = allModels.length * 3;
+        const successfulTests = allModels.reduce((sum, m) => sum + m.summary.successCount, 0);
+        return {
+            success: true,
+            timestamp: new Date().toISOString(),
+            testDuration: testDuration,
+            testDurationFormatted: `${Math.floor(testDuration / 1000)}s`,
+            testConfig: {
+                testsPerModel: 3,
+                totalModels: embeddingModels.length,
+                totalTests: totalTests,
+                retryEnabled: enableRetry,
+                maxRetries: maxRetries,
+            },
+            overallResults: {
+                totalTests: totalTests,
+                successfulTests: successfulTests,
+                failedTests: totalTests - successfulTests,
+                overallSuccessRate: Math.round((successfulTests / totalTests) * 100),
+            },
+            modelResults: testResults,
+            availableModels: embeddingModels.map((m) => ({
+                id: m.id,
+                name: m.name,
+                vendor: m.vendor,
+            })),
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            timestamp: new Date().toISOString(),
+            error: error instanceof Error ? error.message : "Unknown error in embedding models test",
+            testDuration: Date.now() - testStartTime,
+        };
+    }
+}
 class GitHubCopilotTest {
     constructor() {
         this.description = {
@@ -446,6 +585,11 @@ class GitHubCopilotTest {
                             value: "refreshCache",
                             description: "Force refresh the cached models list (clears cache and fetches fresh data from API)",
                         },
+                        {
+                            name: "Test Embedding Models",
+                            value: "testEmbeddings",
+                            description: "Test all embedding models (text-embedding-*) with sample text generation",
+                        },
                         {
                             name: "Consolidated Model Test",
                             value: "consolidatedTest",
@@ -531,6 +675,9 @@ class GitHubCopilotTest {
                     case "refreshCache":
                         result = await refreshModelsCache(token, enableRetry, maxRetries);
                         break;
+                    case "testEmbeddings":
+                        result = await testEmbeddingModels(token, enableRetry, maxRetries);
+                        break;
                     case "consolidatedTest":
                         result = await consolidatedModelTest(token, enableRetry, maxRetries, testsPerModel);
                         break;

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "n8n-nodes-github-copilot",
-    "version": "3.36.0",
+    "version": "3.37.1",
     "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",
@@ -33,6 +33,7 @@
             "dist/nodes/GitHubCopilotAuthHelper/GitHubCopilotAuthHelper.node.js",
             "dist/nodes/GitHubCopilotChatAPI/GitHubCopilotChatAPI.node.js",
             "dist/nodes/GitHubCopilotChatModel/GitHubCopilotChatModel.node.js",
+            "dist/nodes/GitHubCopilotEmbeddings/GitHubCopilotEmbeddings.node.js",
             "dist/nodes/GitHubCopilotOpenAI/GitHubCopilotOpenAI.node.js",
             "dist/nodes/GitHubCopilotTest/GitHubCopilotTest.node.js"
         ]

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

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

package/dist/shared/models/DynamicModelLoader.js

@@ -1,14 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadAvailableModels = loadAvailableModels;
+exports.loadAvailableEmbeddingModels = loadAvailableEmbeddingModels;
 const DynamicModelsManager_1 = require("../utils/DynamicModelsManager");
 const OAuthTokenManager_1 = require("../utils/OAuthTokenManager");
 async function loadAvailableModels(forceRefresh = false) {
+    return loadModelsWithFilter.call(this, "chat", forceRefresh);
+}
+async function loadAvailableEmbeddingModels(forceRefresh = false) {
+    return loadModelsWithFilter.call(this, "embeddings", forceRefresh);
+}
+async function loadModelsWithFilter(modelType, forceRefresh = false) {
     try {
         const credentials = await this.getCredentials("githubCopilotApi");
         if (!credentials || !credentials.token) {
             console.warn("⚠️ No credentials found for dynamic model loading");
-            return getDefaultModelsWithManualInput();
+            return [
+                {
+                    name: "✏️ Enter Custom Model Name",
+                    value: "__manual__",
+                    description: "Type your own model name (no credentials found)",
+                },
+            ];
         }
         const githubToken = credentials.token;
         let oauthToken;
@@ -17,13 +30,21 @@ async function loadAvailableModels(forceRefresh = false) {
         }
         catch (error) {
             console.error("❌ Failed to generate OAuth token for model loading:", error);
-            return getDefaultModelsWithManualInput();
+            return [
+                {
+                    name: "✏️ Enter Custom Model Name",
+                    value: "__manual__",
+                    description: "Type your own model name (OAuth generation failed)",
+                },
+            ];
         }
         if (forceRefresh) {
             DynamicModelsManager_1.DynamicModelsManager.clearCache(oauthToken);
             console.log("🔄 Force refreshing models list...");
         }
-        const models = await DynamicModelsManager_1.DynamicModelsManager.getAvailableModels(oauthToken);
+        const allModels = await DynamicModelsManager_1.DynamicModelsManager.getAvailableModels(oauthToken);
+        const models = DynamicModelsManager_1.DynamicModelsManager.filterModelsByType(allModels, modelType);
+        console.log(`🔍 Filtered ${models.length} ${modelType} models from ${allModels.length} total models`);
         const options = DynamicModelsManager_1.DynamicModelsManager.modelsToN8nOptions(models);
         const optionsWithManualInput = [
             {
@@ -33,50 +54,17 @@ async function loadAvailableModels(forceRefresh = false) {
             },
             ...options,
         ];
-        console.log(`✅ Loaded ${options.length} models dynamically (+ manual input option)`);
+        console.log(`✅ Loaded ${options.length} ${modelType} models dynamically (+ manual input option)`);
         return optionsWithManualInput;
     }
     catch (error) {
         console.error("❌ Error loading dynamic models:", error);
-        return getDefaultModelsWithManualInput();
+        return [
+            {
+                name: "✏️ Enter Custom Model Name",
+                value: "__manual__",
+                description: "Type your own model name (discovery failed, using previous cache if available)",
+            },
+        ];
     }
 }
-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/utils/DynamicModelsManager.d.ts

@@ -15,6 +15,7 @@ export declare class DynamicModelsManager {
     private static hashToken;
     private static fetchModelsFromAPI;
     static getAvailableModels(oauthToken: string): Promise<CopilotModel[]>;
+    static filterModelsByType(models: CopilotModel[], type: string): CopilotModel[];
     static modelsToN8nOptions(models: CopilotModel[]): Array<{
         name: string;
         value: string;

package/dist/shared/utils/DynamicModelsManager.js

@@ -69,6 +69,13 @@ class DynamicModelsManager {
             throw error;
         }
     }
+    static filterModelsByType(models, type) {
+        return models.filter((model) => {
+            var _a;
+            const modelType = (_a = model.capabilities) === null || _a === void 0 ? void 0 : _a.type;
+            return modelType === type;
+        });
+    }
     static modelsToN8nOptions(models) {
         return models.map((model) => {
             const badges = [];

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

@@ -4,6 +4,7 @@ export declare const GITHUB_COPILOT_API: {
     readonly ENDPOINTS: {
         readonly MODELS: "/models";
         readonly CHAT_COMPLETIONS: "/chat/completions";
+        readonly EMBEDDINGS: "/embeddings";
         readonly ORG_BILLING: (org: string) => string;
         readonly ORG_SEATS: (org: string) => string;
         readonly USER_COPILOT: "/user/copilot_access";
@@ -11,6 +12,7 @@ export declare const GITHUB_COPILOT_API: {
     readonly URLS: {
         readonly MODELS: "https://api.githubcopilot.com/models";
         readonly CHAT_COMPLETIONS: "https://api.githubcopilot.com/chat/completions";
+        readonly EMBEDDINGS: "https://api.githubcopilot.com/embeddings";
         readonly ORG_BILLING: (org: string) => string;
         readonly ORG_SEATS: (org: string) => string;
         readonly USER_COPILOT: "https://api.github.com/user/copilot_access";
@@ -57,10 +59,13 @@ export type GitHubCopilotStatusCode = typeof GITHUB_COPILOT_API.STATUS_CODES[key
 export declare class GitHubCopilotEndpoints {
     static getModelsUrl(): string;
     static getChatCompletionsUrl(): string;
+    static getEmbeddingsUrl(): string;
     static getOrgBillingUrl(org: string): string;
     static getOrgSeatsUrl(org: string): string;
     static getUserCopilotUrl(): string;
     static getAuthHeaders(token: string, includeVSCodeHeaders?: boolean): Record<string, string>;
+    static getEmbeddingsHeaders(token: string): Record<string, string>;
+    private static generateUUID;
     static getRetryDelay(attempt: number): number;
     static isTpmQuotaError(statusCode: number): boolean;
     static validateToken(token: string): boolean;

package/dist/shared/utils/GitHubCopilotEndpoints.js

@@ -7,6 +7,7 @@ exports.GITHUB_COPILOT_API = {
     ENDPOINTS: {
         MODELS: "/models",
         CHAT_COMPLETIONS: "/chat/completions",
+        EMBEDDINGS: "/embeddings",
         ORG_BILLING: (org) => `/orgs/${org}/copilot/billing`,
         ORG_SEATS: (org) => `/orgs/${org}/copilot/billing/seats`,
         USER_COPILOT: "/user/copilot_access",
@@ -14,6 +15,7 @@ exports.GITHUB_COPILOT_API = {
     URLS: {
         MODELS: "https://api.githubcopilot.com/models",
         CHAT_COMPLETIONS: "https://api.githubcopilot.com/chat/completions",
+        EMBEDDINGS: "https://api.githubcopilot.com/embeddings",
         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",
@@ -61,6 +63,9 @@ class GitHubCopilotEndpoints {
     static getChatCompletionsUrl() {
         return exports.GITHUB_COPILOT_API.URLS.CHAT_COMPLETIONS;
     }
+    static getEmbeddingsUrl() {
+        return exports.GITHUB_COPILOT_API.URLS.EMBEDDINGS;
+    }
     static getOrgBillingUrl(org) {
         return exports.GITHUB_COPILOT_API.URLS.ORG_BILLING(org);
     }
@@ -80,6 +85,26 @@ class GitHubCopilotEndpoints {
         }
         return headers;
     }
+    static getEmbeddingsHeaders(token) {
+        const sessionId = `${this.generateUUID()}-${Date.now()}`;
+        return {
+            "Authorization": `Bearer ${token}`,
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "Editor-Version": "vscode/1.95.0",
+            "Editor-Plugin-Version": "copilot/1.0.0",
+            "User-Agent": "GitHub-Copilot/1.0 (n8n-node)",
+            "Vscode-Sessionid": sessionId,
+            "X-GitHub-Api-Version": "2025-08-20",
+        };
+    }
+    static generateUUID() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === "x" ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
     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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-github-copilot",
-  "version": "3.36.0",
+  "version": "3.37.1",
   "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",
@@ -33,6 +33,7 @@
       "dist/nodes/GitHubCopilotAuthHelper/GitHubCopilotAuthHelper.node.js",
       "dist/nodes/GitHubCopilotChatAPI/GitHubCopilotChatAPI.node.js",
       "dist/nodes/GitHubCopilotChatModel/GitHubCopilotChatModel.node.js",
+      "dist/nodes/GitHubCopilotEmbeddings/GitHubCopilotEmbeddings.node.js",
       "dist/nodes/GitHubCopilotOpenAI/GitHubCopilotOpenAI.node.js",
       "dist/nodes/GitHubCopilotTest/GitHubCopilotTest.node.js"
     ]