n8n-nodes-github-copilot 3.38.17 → 3.38.19

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

@@ -6,6 +6,7 @@ const GitHubCopilotModels_1 = require("../../shared/models/GitHubCopilotModels")
 const GitHubCopilotEndpoints_1 = require("../../shared/utils/GitHubCopilotEndpoints");
 const DynamicModelLoader_1 = require("../../shared/models/DynamicModelLoader");
 const ModelProperties_1 = require("../../shared/properties/ModelProperties");
+const ModelVersionRequirements_1 = require("../../shared/models/ModelVersionRequirements");
 class GitHubCopilotChatModel {
     constructor() {
         this.description = {
@@ -157,6 +158,9 @@ class GitHubCopilotChatModel {
         }
         const safeModel = modelInfo ? model : GitHubCopilotModels_1.DEFAULT_MODELS.GENERAL;
         const safeModelInfo = modelInfo || GitHubCopilotModels_1.GitHubCopilotModelsManager.getModelByValue(GitHubCopilotModels_1.DEFAULT_MODELS.GENERAL);
+        const minVSCodeVersion = (0, ModelVersionRequirements_1.getMinVSCodeVersion)(safeModel);
+        const additionalHeaders = (0, ModelVersionRequirements_1.getAdditionalHeaders)(safeModel);
+        console.log(`🔧 Model: ${safeModel} requires VS Code version: ${minVSCodeVersion}`);
         const modelConfig = {
             model: safeModel,
             temperature: options.temperature || 0.7,
@@ -169,9 +173,10 @@ class GitHubCopilotChatModel {
                 defaultHeaders: {
                     "User-Agent": "GitHubCopilotChat/1.0.0 n8n/3.10.1",
                     Accept: "application/json",
-                    "Editor-Version": "vscode/1.85.0",
+                    "Editor-Version": `vscode/${minVSCodeVersion}`,
                     "Editor-Plugin-Version": "copilot-chat/0.12.0",
                     "X-Request-Id": `n8n-chatmodel-${Date.now()}-${Math.random().toString(36).substring(7)}`,
+                    ...additionalHeaders,
                     ...(options.enableVision &&
                         (safeModelInfo === null || safeModelInfo === void 0 ? void 0 : safeModelInfo.capabilities.vision) && {
                         "Copilot-Vision-Request": "true",

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

@@ -122,6 +122,30 @@ class GitHubCopilotOpenAI {
                         content: "Hello! How can you help me?",
                     });
                 }
+                for (let msgIndex = 0; msgIndex < messages.length; msgIndex++) {
+                    const msg = messages[msgIndex];
+                    if (Array.isArray(msg.content)) {
+                        for (const contentItem of msg.content) {
+                            if (contentItem.type === 'file') {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `❌ GitHub Copilot API Error: File attachments cannot be used inside 'content' array.\n\n` +
+                                    `📋 INCORRECT FORMAT (OpenAI style - doesn't work):\n` +
+                                    `{\n` +
+                                    `  "role": "user",\n` +
+                                    `  "content": [\n` +
+                                    `    {"type": "text", "text": "Analyze this"},\n` +
+                                    `    {"type": "file", "file": "data:..."}  ❌ WRONG\n` +
+                                    `  ]\n` +
+                                    `}\n\n` +
+                                    `✅ CORRECT FORMAT (GitHub Copilot - message level):\n` +
+                                    `[\n` +
+                                    `  {"role": "user", "content": "Analyze this file"},\n` +
+                                    `  {"role": "user", "content": "data:image/png;base64,...", "type": "file"}  ✅ CORRECT\n` +
+                                    `]\n\n` +
+                                    `💡 Solution: Use separate messages with 'type' property at message level, not inside content array.`, { itemIndex: i });
+                            }
+                        }
+                    }
+                }
                 console.log('📤 Final messages being sent to API:', JSON.stringify(messages, null, 2));
                 const advancedOptions = this.getNodeParameter("advancedOptions", i, {});
                 let parsedTools = [];

package/dist/nodes/GitHubCopilotOpenAI/nodeProperties.js

@@ -27,15 +27,15 @@ exports.nodeProperties = [
         displayName: "Messages (JSON)",
         name: "messagesJson",
         type: "json",
-        default: `[
-  {
-    "role": "system",
-    "content": "You are a helpful assistant."
-  },
-  {
-    "role": "user",
-    "content": "Hello!"
-  }
+        default: `[
+  {
+    "role": "system",
+    "content": "You are a helpful assistant."
+  },
+  {
+    "role": "user",
+    "content": "Hello!"
+  }
 ]`,
         placeholder: "Enter messages as JSON array",
         description: "Array of messages in OpenAI format: [{\"role\": \"user\", \"content\": \"...\"}]",
@@ -255,24 +255,24 @@ exports.nodeProperties = [
                 typeOptions: {
                     rows: 10,
                 },
-                placeholder: `[
-  {
-    "type": "function",
-    "function": {
-      "name": "get_weather",
-      "description": "Get current weather",
-      "parameters": {
-        "type": "object",
-        "properties": {
-          "location": {
-            "type": "string",
-            "description": "City name"
-          }
-        },
-        "required": ["location"]
-      }
-    }
-  }
+                placeholder: `[
+  {
+    "type": "function",
+    "function": {
+      "name": "get_weather",
+      "description": "Get current weather",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "location": {
+            "type": "string",
+            "description": "City name"
+          }
+        },
+        "required": ["location"]
+      }
+    }
+  }
 ]`,
                 description: "Optional: Array of tools/functions available to the model (OpenAI format). Leave empty if not using function calling.",
                 hint: "JSON array of tool definitions in OpenAI format. Leave this field empty if you don't need function calling.",

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "n8n-nodes-github-copilot",
-    "version": "3.38.17",
+    "version": "3.38.19",
     "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/ModelVersionRequirements.d.ts

@@ -0,0 +1,16 @@
+export interface ModelRequirements {
+    minVSCodeVersion: string;
+    supportedEndpoints: string[];
+    preview?: boolean;
+    additionalHeaders?: Record<string, string>;
+    notes?: string;
+}
+export declare const MODEL_VERSION_REQUIREMENTS: Record<string, ModelRequirements>;
+export declare const DEFAULT_MODEL_REQUIREMENTS: ModelRequirements;
+export declare function getModelRequirements(model: string): ModelRequirements;
+export declare function modelSupportsEndpoint(model: string, endpoint: string): boolean;
+export declare function getRecommendedEndpoint(model: string): string;
+export declare function validateModelEndpoint(model: string, endpoint: string): void;
+export declare function getMinVSCodeVersion(model: string): string;
+export declare function isPreviewModel(model: string): boolean;
+export declare function getAdditionalHeaders(model: string): Record<string, string>;

package/dist/shared/models/ModelVersionRequirements.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MODEL_REQUIREMENTS = exports.MODEL_VERSION_REQUIREMENTS = void 0;
+exports.getModelRequirements = getModelRequirements;
+exports.modelSupportsEndpoint = modelSupportsEndpoint;
+exports.getRecommendedEndpoint = getRecommendedEndpoint;
+exports.validateModelEndpoint = validateModelEndpoint;
+exports.getMinVSCodeVersion = getMinVSCodeVersion;
+exports.isPreviewModel = isPreviewModel;
+exports.getAdditionalHeaders = getAdditionalHeaders;
+exports.MODEL_VERSION_REQUIREMENTS = {
+    "gpt-5-codex": {
+        minVSCodeVersion: "1.104.1",
+        supportedEndpoints: ["/responses"],
+        preview: true,
+        notes: "Preview model requiring VS Code 1.104.1 or newer. Only supports /responses endpoint."
+    },
+    "gpt-5": {
+        minVSCodeVersion: "1.95.0",
+        supportedEndpoints: ["/chat/completions", "/responses"],
+        preview: false,
+    },
+    "gpt-5-mini": {
+        minVSCodeVersion: "1.95.0",
+        supportedEndpoints: ["/chat/completions", "/responses"],
+        preview: false,
+    },
+    "o3": {
+        minVSCodeVersion: "1.95.0",
+        supportedEndpoints: ["/chat/completions", "/responses"],
+        preview: true,
+    },
+    "o3-2025-04-16": {
+        minVSCodeVersion: "1.95.0",
+        supportedEndpoints: ["/chat/completions", "/responses"],
+        preview: true,
+    },
+    "o4-mini": {
+        minVSCodeVersion: "1.95.0",
+        supportedEndpoints: ["/chat/completions", "/responses"],
+        preview: true,
+    },
+    "o4-mini-2025-04-16": {
+        minVSCodeVersion: "1.95.0",
+        supportedEndpoints: ["/chat/completions", "/responses"],
+        preview: true,
+    },
+};
+exports.DEFAULT_MODEL_REQUIREMENTS = {
+    minVSCodeVersion: "1.95.0",
+    supportedEndpoints: ["/chat/completions", "/responses"],
+    preview: false,
+};
+function getModelRequirements(model) {
+    return exports.MODEL_VERSION_REQUIREMENTS[model] || exports.DEFAULT_MODEL_REQUIREMENTS;
+}
+function modelSupportsEndpoint(model, endpoint) {
+    const requirements = getModelRequirements(model);
+    return requirements.supportedEndpoints.includes(endpoint);
+}
+function getRecommendedEndpoint(model) {
+    const requirements = getModelRequirements(model);
+    return requirements.supportedEndpoints[0] || "/chat/completions";
+}
+function validateModelEndpoint(model, endpoint) {
+    if (!modelSupportsEndpoint(model, endpoint)) {
+        const requirements = getModelRequirements(model);
+        throw new Error(`Model "${model}" does not support endpoint "${endpoint}". ` +
+            `Supported endpoints: ${requirements.supportedEndpoints.join(", ")}`);
+    }
+}
+function getMinVSCodeVersion(model) {
+    const requirements = getModelRequirements(model);
+    return requirements.minVSCodeVersion;
+}
+function isPreviewModel(model) {
+    const requirements = getModelRequirements(model);
+    return requirements.preview || false;
+}
+function getAdditionalHeaders(model) {
+    const requirements = getModelRequirements(model);
+    return requirements.additionalHeaders || {};
+}

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

@@ -0,0 +1,22 @@
+export interface ChunkRequest {
+    content: string;
+    embed: boolean;
+    qos: "Batch" | "Online";
+}
+export interface Chunk {
+    content: string;
+    embedding?: number[];
+    start: number;
+    end: number;
+    metadata?: Record<string, unknown>;
+}
+export interface ChunkResponse {
+    chunks: Chunk[];
+    total: number;
+    contentLength: number;
+}
+export declare function chunkFile(token: string, fileContent: string, embeddings?: boolean, qos?: "Batch" | "Online"): Promise<ChunkResponse>;
+export declare function selectRelevantChunks(chunks: Chunk[], queryEmbedding: number[], maxTokens?: number, minRelevance?: number): string;
+export declare function selectTopChunks(chunks: Chunk[], maxTokens?: number): string;
+export declare function estimateTokens(text: string): number;
+export declare function getQueryEmbedding(token: string, query: string): Promise<number[]>;

package/dist/shared/utils/FileChunkingApiUtils.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chunkFile = chunkFile;
+exports.selectRelevantChunks = selectRelevantChunks;
+exports.selectTopChunks = selectTopChunks;
+exports.estimateTokens = estimateTokens;
+exports.getQueryEmbedding = getQueryEmbedding;
+const GitHubCopilotEndpoints_1 = require("./GitHubCopilotEndpoints");
+async function chunkFile(token, fileContent, embeddings = true, qos = "Online") {
+    const url = "https://api.githubcopilot.com/chunks";
+    const headers = GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.getAuthHeaders(token, true);
+    const requestBody = {
+        content: fileContent,
+        embed: embeddings,
+        qos,
+    };
+    console.log(`🔪 Chunking file (${fileContent.length} chars, embed=${embeddings}, qos=${qos})`);
+    const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(requestBody),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Chunking API error: ${response.status} ${response.statusText}. ${errorText}`);
+    }
+    const data = await response.json();
+    console.log(`✅ Chunked into ${data.chunks.length} chunks`);
+    return data;
+}
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+        throw new Error("Vectors must have same length");
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+function selectRelevantChunks(chunks, queryEmbedding, maxTokens = 10000, minRelevance = 0.5) {
+    if (!chunks.length) {
+        return "";
+    }
+    const rankedChunks = chunks
+        .filter(chunk => chunk.embedding)
+        .map(chunk => ({
+        chunk,
+        relevance: cosineSimilarity(chunk.embedding, queryEmbedding),
+    }))
+        .filter(item => item.relevance >= minRelevance)
+        .sort((a, b) => b.relevance - a.relevance);
+    const selectedChunks = [];
+    let totalTokens = 0;
+    for (const item of rankedChunks) {
+        const chunkTokens = Math.ceil(item.chunk.content.length / 4);
+        if (totalTokens + chunkTokens > maxTokens) {
+            break;
+        }
+        selectedChunks.push(item.chunk.content);
+        totalTokens += chunkTokens;
+        console.log(`  ✓ Selected chunk (relevance: ${item.relevance.toFixed(3)}, tokens: ~${chunkTokens})`);
+    }
+    console.log(`📊 Selected ${selectedChunks.length}/${rankedChunks.length} chunks (~${totalTokens} tokens)`);
+    return selectedChunks.join("\n\n---\n\n");
+}
+function selectTopChunks(chunks, maxTokens = 10000) {
+    const selectedChunks = [];
+    let totalTokens = 0;
+    for (const chunk of chunks) {
+        const chunkTokens = Math.ceil(chunk.content.length / 4);
+        if (totalTokens + chunkTokens > maxTokens) {
+            break;
+        }
+        selectedChunks.push(chunk.content);
+        totalTokens += chunkTokens;
+    }
+    console.log(`📊 Selected ${selectedChunks.length}/${chunks.length} chunks (~${totalTokens} tokens)`);
+    return selectedChunks.join("\n\n---\n\n");
+}
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+async function getQueryEmbedding(token, query) {
+    const url = "https://api.githubcopilot.com/embeddings";
+    const headers = GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.getEmbeddingsHeaders(token);
+    const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+            input: [query],
+            model: "text-embedding-3-small",
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Embeddings API error: ${response.status} ${response.statusText}. ${errorText}`);
+    }
+    const data = await response.json();
+    return data.data[0].embedding;
+}

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

@@ -0,0 +1,36 @@
+export type FileProcessingMode = "direct" | "chunking" | "summarize" | "auto";
+export interface FileOptimizationOptions {
+    mode: FileProcessingMode;
+    model: string;
+    fileSize: number;
+    maxContextUsage?: number;
+    minRelevance?: number;
+}
+export interface OptimizationResult {
+    mode: "direct" | "chunking" | "summarize";
+    reason: string;
+    estimatedTokens: number;
+    maxAllowedTokens: number;
+    fitsInContext: boolean;
+}
+export declare function estimateFileTokens(fileSize: number, isBase64?: boolean): number;
+export declare function selectFileProcessingMode(options: FileOptimizationOptions): OptimizationResult;
+export declare function getOptimalChunkSettings(model: string, maxContextUsage?: number): {
+    maxChunks: number;
+    maxTokensPerChunk: number;
+    totalMaxTokens: number;
+};
+export declare function compressText(text: string): string;
+export declare function truncateToTokenLimit(text: string, maxTokens: number, addEllipsis?: boolean): {
+    content: string;
+    truncated: boolean;
+    originalTokens: number;
+    finalTokens: number;
+};
+export declare function getFileSizeCategory(sizeBytes: number): string;
+export declare function formatTokenCount(tokens: number): string;
+export declare function calculateSavings(originalTokens: number, optimizedTokens: number): {
+    savedTokens: number;
+    savingsPercent: number;
+    savingsRatio: string;
+};

package/dist/shared/utils/FileOptimizationUtils.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateFileTokens = estimateFileTokens;
+exports.selectFileProcessingMode = selectFileProcessingMode;
+exports.getOptimalChunkSettings = getOptimalChunkSettings;
+exports.compressText = compressText;
+exports.truncateToTokenLimit = truncateToTokenLimit;
+exports.getFileSizeCategory = getFileSizeCategory;
+exports.formatTokenCount = formatTokenCount;
+exports.calculateSavings = calculateSavings;
+const FileChunkingApiUtils_1 = require("./FileChunkingApiUtils");
+function estimateFileTokens(fileSize, isBase64 = true) {
+    const encodedSize = isBase64 ? fileSize * 1.33 : fileSize;
+    return Math.ceil(encodedSize / 4);
+}
+function selectFileProcessingMode(options) {
+    const { model, fileSize, mode, maxContextUsage = 0.5 } = options;
+    const maxContextTokens = 128000;
+    const maxAllowedTokens = Math.floor(maxContextTokens * maxContextUsage);
+    const estimatedTokens = estimateFileTokens(fileSize, true);
+    const fitsInContext = estimatedTokens <= maxAllowedTokens;
+    console.log(`📊 File Optimization Analysis:`);
+    console.log(`  File size: ${(fileSize / 1024).toFixed(2)} KB`);
+    console.log(`  Estimated tokens: ${estimatedTokens.toLocaleString()}`);
+    console.log(`  Max allowed (${(maxContextUsage * 100).toFixed(0)}%): ${maxAllowedTokens.toLocaleString()}`);
+    console.log(`  Model context: ${maxContextTokens.toLocaleString()} tokens`);
+    if (mode !== "auto") {
+        if (mode === "direct" && !fitsInContext) {
+            console.warn(`⚠️ Warning: Direct mode requested but file exceeds token limit`);
+        }
+        return {
+            mode,
+            reason: `User requested ${mode} mode`,
+            estimatedTokens,
+            maxAllowedTokens,
+            fitsInContext,
+        };
+    }
+    if (estimatedTokens < maxAllowedTokens * 0.3) {
+        return {
+            mode: "direct",
+            reason: `File is small (${estimatedTokens.toLocaleString()} tokens < 30% of limit)`,
+            estimatedTokens,
+            maxAllowedTokens,
+            fitsInContext: true,
+        };
+    }
+    else if (estimatedTokens < maxAllowedTokens * 0.8) {
+        return {
+            mode: "chunking",
+            reason: `File is medium-sized (${estimatedTokens.toLocaleString()} tokens, 30-80% of limit) - chunking recommended`,
+            estimatedTokens,
+            maxAllowedTokens,
+            fitsInContext: true,
+        };
+    }
+    else if (fitsInContext) {
+        return {
+            mode: "chunking",
+            reason: `File is large (${estimatedTokens.toLocaleString()} tokens, >80% of limit) - chunking strongly recommended`,
+            estimatedTokens,
+            maxAllowedTokens,
+            fitsInContext: true,
+        };
+    }
+    else {
+        return {
+            mode: "summarize",
+            reason: `File exceeds token limit (${estimatedTokens.toLocaleString()} > ${maxAllowedTokens.toLocaleString()} tokens) - summarization required`,
+            estimatedTokens,
+            maxAllowedTokens,
+            fitsInContext: false,
+        };
+    }
+}
+function getOptimalChunkSettings(model, maxContextUsage = 0.5) {
+    const maxContextTokens = 128000;
+    const totalMaxTokens = Math.floor(maxContextTokens * maxContextUsage);
+    const maxChunks = 10;
+    const maxTokensPerChunk = Math.floor(totalMaxTokens / maxChunks);
+    return {
+        maxChunks,
+        maxTokensPerChunk,
+        totalMaxTokens,
+    };
+}
+function compressText(text) {
+    return text
+        .replace(/ {2,}/g, " ")
+        .replace(/\n{3,}/g, "\n\n")
+        .replace(/\t/g, " ")
+        .split("\n")
+        .map(line => line.trim())
+        .join("\n")
+        .trim();
+}
+function truncateToTokenLimit(text, maxTokens, addEllipsis = true) {
+    const originalTokens = (0, FileChunkingApiUtils_1.estimateTokens)(text);
+    if (originalTokens <= maxTokens) {
+        return {
+            content: text,
+            truncated: false,
+            originalTokens,
+            finalTokens: originalTokens,
+        };
+    }
+    const maxChars = maxTokens * 4;
+    const truncated = text.slice(0, maxChars);
+    const ellipsis = addEllipsis ? "\n\n...[truncated]" : "";
+    const finalContent = truncated + ellipsis;
+    const finalTokens = (0, FileChunkingApiUtils_1.estimateTokens)(finalContent);
+    return {
+        content: finalContent,
+        truncated: true,
+        originalTokens,
+        finalTokens,
+    };
+}
+function getFileSizeCategory(sizeBytes) {
+    if (sizeBytes < 10 * 1024)
+        return "tiny (<10KB)";
+    if (sizeBytes < 50 * 1024)
+        return "small (<50KB)";
+    if (sizeBytes < 200 * 1024)
+        return "medium (<200KB)";
+    if (sizeBytes < 500 * 1024)
+        return "large (<500KB)";
+    if (sizeBytes < 1024 * 1024)
+        return "very large (<1MB)";
+    return "huge (>1MB)";
+}
+function formatTokenCount(tokens) {
+    if (tokens < 1000)
+        return `${tokens} tokens`;
+    if (tokens < 1000000)
+        return `${(tokens / 1000).toFixed(1)}K tokens`;
+    return `${(tokens / 1000000).toFixed(2)}M tokens`;
+}
+function calculateSavings(originalTokens, optimizedTokens) {
+    const savedTokens = originalTokens - optimizedTokens;
+    const savingsPercent = (savedTokens / originalTokens) * 100;
+    const savingsRatio = `${optimizedTokens.toLocaleString()}/${originalTokens.toLocaleString()}`;
+    return {
+        savedTokens,
+        savingsPercent,
+        savingsRatio,
+    };
+}

package/package.json

@@ -1,86 +1,86 @@
-{
-  "name": "n8n-nodes-github-copilot",
-  "version": "3.38.17",
-  "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",
-  "author": {
-    "name": "Sufficit",
-    "email": "development@sufficit.com.br"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/sufficit/n8n-nodes-github-copilot.git"
-  },
-  "scripts": {
-    "build": "tsc && gulp build:icons",
-    "dev": "tsc --watch",
-    "format": "prettier nodes credentials --write",
-    "lint": "eslint nodes credentials shared --ext .ts",
-    "lintfix": "eslint nodes credentials shared --ext .ts --fix",
-    "prepublishOnly": "npm run build"
-  },
-  "files": [
-    "dist"
-  ],
-  "n8n": {
-    "n8nNodesApiVersion": 1,
-    "credentials": [
-      "dist/credentials/GitHubCopilotApi.credentials.js"
-    ],
-    "nodes": [
-      "dist/nodes/GitHubCopilot/GitHubCopilot.node.js",
-      "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"
-    ]
-  },
-  "keywords": [
-    "n8n-community-node-package",
-    "github",
-    "copilot",
-    "n8n-ai-agent",
-    "ai",
-    "gpt-5",
-    "claude",
-    "gemini",
-    "chat-completion",
-    "image-analysis",
-    "audio-transcription",
-    "code-generation",
-    "automation"
-  ],
-  "engines": {
-    "node": ">=18.19",
-    "pnpm": ">=7.1"
-  },
-  "dependencies": {
-    "@langchain/openai": "^0.6.14",
-    "n8n-workflow": "^1.110.0"
-  },
-  "overrides": {
-    "form-data": "^4.0.4",
-    "mysql2": "^3.15.0",
-    "axios": "^1.12.0",
-    "pdfjs-dist": "^4.1.393",
-    "semver": "^7.5.4",
-    "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz",
-    "@azure/identity": "^4.2.1",
-    "pg-promise": "^11.5.5",
-    "snowflake-sdk": "^2.0.4"
-  },
-  "devDependencies": {
-    "@types/node": "^22.7.0",
-    "@typescript-eslint/eslint-plugin": "^8.7.0",
-    "@typescript-eslint/parser": "^8.7.0",
-    "eslint": "^8.57.0",
-    "gulp": "^5.0.1",
-    "n8n-core": "^1.112.1",
-    "n8n-workflow": "^1.110.0",
-    "prettier": "^3.3.0",
-    "typescript": "^5.6.2"
-  }
-}
+{
+  "name": "n8n-nodes-github-copilot",
+  "version": "3.38.19",
+  "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",
+  "author": {
+    "name": "Sufficit",
+    "email": "development@sufficit.com.br"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sufficit/n8n-nodes-github-copilot.git"
+  },
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "dev": "tsc --watch",
+    "format": "prettier nodes credentials --write",
+    "lint": "eslint nodes credentials shared --ext .ts",
+    "lintfix": "eslint nodes credentials shared --ext .ts --fix",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/GitHubCopilotApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/GitHubCopilot/GitHubCopilot.node.js",
+      "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"
+    ]
+  },
+  "keywords": [
+    "n8n-community-node-package",
+    "github",
+    "copilot",
+    "n8n-ai-agent",
+    "ai",
+    "gpt-5",
+    "claude",
+    "gemini",
+    "chat-completion",
+    "image-analysis",
+    "audio-transcription",
+    "code-generation",
+    "automation"
+  ],
+  "engines": {
+    "node": ">=18.19",
+    "pnpm": ">=7.1"
+  },
+  "dependencies": {
+    "@langchain/openai": "^0.6.14",
+    "n8n-workflow": "^1.110.0"
+  },
+  "overrides": {
+    "form-data": "^4.0.4",
+    "mysql2": "^3.15.0",
+    "axios": "^1.12.0",
+    "pdfjs-dist": "^4.1.393",
+    "semver": "^7.5.4",
+    "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz",
+    "@azure/identity": "^4.2.1",
+    "pg-promise": "^11.5.5",
+    "snowflake-sdk": "^2.0.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.7.0",
+    "@typescript-eslint/eslint-plugin": "^8.7.0",
+    "@typescript-eslint/parser": "^8.7.0",
+    "eslint": "^8.57.0",
+    "gulp": "^5.0.1",
+    "n8n-core": "^1.112.1",
+    "n8n-workflow": "^1.110.0",
+    "prettier": "^3.3.0",
+    "typescript": "^5.6.2"
+  }
+}