n8n-nodes-github-copilot 3.38.25 → 3.38.35

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitHubCopilotChatModel = void 0;
 const openai_1 = require("@langchain/openai");
+const messages_1 = require("@langchain/core/messages");
 const GitHubCopilotModels_1 = require("../../shared/models/GitHubCopilotModels");
 const GitHubCopilotEndpoints_1 = require("../../shared/utils/GitHubCopilotEndpoints");
 const DynamicModelLoader_1 = require("../../shared/models/DynamicModelLoader");
@@ -14,12 +15,18 @@ class GitHubCopilotChatOpenAI extends openai_1.ChatOpenAI {
         this.context = context;
         this.options = options;
     }
+    invocationParams(options) {
+        const params = super.invocationParams(options);
+        params.model = this.model;
+        return params;
+    }
     async _generate(messages, options) {
         var _a;
         if (!messages || messages.length === 0) {
-            throw new Error("No messages provided for generation");
+            throw new Error('No messages provided for generation');
         }
-        let copilotMessages = messages.map(msg => {
+        let hasVisionContent = false;
+        let copilotMessages = messages.map((msg) => {
             let role;
             switch (msg._getType()) {
                 case 'human':
@@ -35,19 +42,66 @@ class GitHubCopilotChatOpenAI extends openai_1.ChatOpenAI {
                     console.warn(`⚠️ Unknown message type: ${msg._getType()}, defaulting to 'user'`);
                     role = 'user';
             }
-            let content = msg.content;
-            if (typeof content === 'string') {
+            let content = '';
+            const rawContent = msg.content;
+            if (typeof rawContent === 'string') {
+                if (rawContent.includes('data:image/') || rawContent.match(/\[.*image.*\]/i)) {
+                    hasVisionContent = true;
+                    console.log(`👁️ Vision content detected in string message (data URL or image reference)`);
+                }
+                content = rawContent;
             }
-            else if (Array.isArray(content)) {
-                console.warn(`⚠️ Complex content detected, stringifying:`, content);
-                content = JSON.stringify(content);
+            else if (Array.isArray(rawContent)) {
+                const hasImageContent = rawContent.some((part) => {
+                    if (typeof part === 'object' && part !== null) {
+                        const p = part;
+                        if (p.type === 'image_url' || p.type === 'image' || p.image_url !== undefined) {
+                            return true;
+                        }
+                        if (typeof p.url === 'string' && p.url.startsWith('data:image/')) {
+                            return true;
+                        }
+                        if (p.image || p.imageUrl || p.image_data) {
+                            return true;
+                        }
+                    }
+                    return false;
+                });
+                if (hasImageContent) {
+                    hasVisionContent = true;
+                    console.log(`👁️ Vision content detected in array message`);
+                    content = rawContent.map((part) => {
+                        if (typeof part === 'object' && part !== null) {
+                            const p = part;
+                            if (p.type === 'text') {
+                                return { type: 'text', text: String(p.text || '') };
+                            }
+                            else if (p.type === 'image_url' || p.type === 'image' || p.image_url) {
+                                const imageUrl = (p.image_url || p.image || p);
+                                const url = String((imageUrl === null || imageUrl === void 0 ? void 0 : imageUrl.url) || p.url || p.imageUrl || p.image_data || '');
+                                return {
+                                    type: 'image_url',
+                                    image_url: {
+                                        url,
+                                        detail: (imageUrl === null || imageUrl === void 0 ? void 0 : imageUrl.detail) || 'auto',
+                                    },
+                                };
+                            }
+                        }
+                        return { type: 'text', text: String(part) };
+                    });
+                }
+                else {
+                    console.warn(`⚠️ Complex content detected, stringifying:`, rawContent);
+                    content = JSON.stringify(rawContent);
+                }
             }
-            else if (content === null || content === undefined) {
+            else if (rawContent === null || rawContent === undefined) {
                 content = '';
             }
             else {
-                console.warn(`⚠️ Non-string content detected, stringifying:`, typeof content);
-                content = JSON.stringify(content);
+                console.warn(`⚠️ Non-string content detected, stringifying:`, typeof rawContent);
+                content = JSON.stringify(rawContent);
             }
             return {
                 role,
@@ -55,7 +109,7 @@ class GitHubCopilotChatOpenAI extends openai_1.ChatOpenAI {
             };
         });
         if (this.options.systemMessage && this.options.systemMessage.trim()) {
-            const hasSystemMessage = copilotMessages.some(msg => msg.role === 'system');
+            const hasSystemMessage = copilotMessages.some((msg) => msg.role === 'system');
             if (!hasSystemMessage) {
                 copilotMessages.unshift({
                     role: 'system',
@@ -64,57 +118,65 @@ class GitHubCopilotChatOpenAI extends openai_1.ChatOpenAI {
                 console.log(`🔧 Added system message from options`);
             }
         }
-        const validMessages = copilotMessages.filter(msg => {
-            if (!msg.content || msg.content.trim() === '') {
+        const validMessages = copilotMessages.filter((msg) => {
+            const isEmpty = Array.isArray(msg.content)
+                ? msg.content.length === 0
+                : (!msg.content || (typeof msg.content === 'string' && msg.content.trim() === ''));
+            if (isEmpty) {
                 console.warn(`⚠️ Filtering out empty message with role: ${msg.role}`);
                 return false;
             }
             return true;
         });
         if (validMessages.length === 0) {
-            throw new Error("No valid messages after filtering empty content");
+            throw new Error('No valid messages after filtering empty content');
         }
         const requestBody = {
-            model: this.modelName || this.model,
+            model: this.model,
             messages: validMessages,
             temperature: this.temperature,
             max_tokens: this.maxTokens,
             top_p: this.topP,
             stream: this.options.enableStreaming || false,
         };
-        if (this.options.tools && this.options.tools.length > 0) {
-            requestBody.tools = this.options.tools;
-            requestBody.tool_choice = this.options.tool_choice || "auto";
-            console.log(`🔧 Request includes ${this.options.tools.length} tools`);
+        if (this.options.tools && JSON.parse(this.options.tools).length > 0) {
+            requestBody.tools = JSON.parse(this.options.tools);
+            requestBody.tool_choice = this.options.tool_choice || 'auto';
+            console.log(`🔧 Request includes ${requestBody.tools.length} tools`);
         }
         const startTime = Date.now();
+        const shouldUseVision = hasVisionContent || this.options.enableVision === true;
+        if (shouldUseVision) {
+            console.log(`👁️ Sending vision request with Copilot-Vision-Request header (auto=${hasVisionContent}, manual=${this.options.enableVision})`);
+        }
         try {
-            const response = await (0, GitHubCopilotApiUtils_1.makeGitHubCopilotRequest)(this.context, GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.ENDPOINTS.CHAT_COMPLETIONS, requestBody, false);
+            const response = await (0, GitHubCopilotApiUtils_1.makeGitHubCopilotRequest)(this.context, GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.ENDPOINTS.CHAT_COMPLETIONS, requestBody, shouldUseVision);
             const endTime = Date.now();
             const latency = endTime - startTime;
             console.log(`⏱️ GitHub Copilot API call completed in ${latency}ms`);
             if (!response.choices || response.choices.length === 0) {
-                throw new Error("GitHub Copilot API returned no choices in response");
+                throw new Error('GitHub Copilot API returned no choices in response');
             }
             const choice = response.choices[0];
             if (!choice.message) {
-                throw new Error("GitHub Copilot API returned choice without message");
+                throw new Error('GitHub Copilot API returned choice without message');
             }
-            const langchainMessage = {
-                _getType: () => choice.message.role,
-                content: choice.message.content || "",
-                tool_calls: choice.message.tool_calls,
-            };
+            const langchainMessage = new messages_1.AIMessage({
+                content: choice.message.content || '',
+            });
             console.log(`📝 Response: role=${choice.message.role}, content_length=${((_a = choice.message.content) === null || _a === void 0 ? void 0 : _a.length) || 0}, finish_reason=${choice.finish_reason}`);
+            const generation = {
+                text: choice.message.content || '',
+                generationInfo: {
+                    finish_reason: choice.finish_reason,
+                },
+                message: langchainMessage,
+            };
             return {
-                generations: [[{
-                            text: choice.message.content || "",
-                            generationInfo: {
-                                finish_reason: choice.finish_reason,
-                            },
-                            message: langchainMessage,
-                        }]],
-                tokenUsage: response.usage,
+                generations: [generation],
+                llmOutput: {
+                    tokenUsage: response.usage,
+                },
             };
         }
         catch (error) {
@@ -128,149 +190,156 @@ class GitHubCopilotChatOpenAI extends openai_1.ChatOpenAI {
 class GitHubCopilotChatModel {
     constructor() {
         this.description = {
-            displayName: "GitHub Copilot Chat Model",
-            name: "gitHubCopilotChatModel",
-            icon: "file:../../shared/icons/copilot.svg",
-            group: ["transform"],
+            displayName: 'GitHub Copilot Chat Model',
+            name: 'gitHubCopilotChatModel',
+            icon: 'file:../../shared/icons/copilot.svg',
+            group: ['transform'],
             version: 1,
-            description: "GitHub Copilot chat model for AI workflows with full support for tools and function calling - access GPT-5, Claude, Gemini and more using your Copilot subscription",
+            description: 'GitHub Copilot chat model for AI workflows with full support for tools and function calling - access GPT-5, Claude, Gemini and more using your Copilot subscription',
             defaults: {
-                name: "GitHub Copilot Chat Model",
+                name: 'GitHub Copilot Chat Model',
             },
             codex: {
-                categories: ["AI"],
+                categories: ['AI'],
                 subcategories: {
-                    AI: ["Language Models", "Root Nodes"],
-                    "Language Models": ["Chat Models (Recommended)"],
+                    AI: ['Language Models', 'Root Nodes'],
+                    'Language Models': ['Chat Models (Recommended)'],
                 },
                 resources: {
                     primaryDocumentation: [
                         {
-                            url: "https://docs.github.com/copilot/using-github-copilot/using-github-copilot-chat",
+                            url: 'https://docs.github.com/copilot/using-github-copilot/using-github-copilot-chat',
                         },
                     ],
                 },
             },
             inputs: [],
-            outputs: ["ai_languageModel"],
-            outputNames: ["Model"],
+            outputs: ['ai_languageModel'],
+            outputNames: ['Model'],
             credentials: [
                 {
-                    name: "githubCopilotApi",
+                    name: 'githubCopilotApi',
                     required: true,
                 },
             ],
             properties: [
                 ...ModelProperties_1.CHAT_MODEL_PROPERTIES,
                 {
-                    displayName: "Options",
-                    name: "options",
-                    placeholder: "Add Option",
-                    description: "Additional options for the GitHub Copilot model",
-                    type: "collection",
+                    displayName: 'Options',
+                    name: 'options',
+                    placeholder: 'Add Option',
+                    description: 'Additional options for the GitHub Copilot model',
+                    type: 'collection',
                     default: {},
                     options: [
                         {
-                            displayName: "Temperature",
-                            name: "temperature",
+                            displayName: 'Temperature',
+                            name: 'temperature',
                             default: 0.7,
                             typeOptions: { maxValue: 2, minValue: 0, numberPrecision: 1 },
-                            description: "Controls randomness in output. Lower values make responses more focused.",
-                            type: "number",
+                            description: 'Controls randomness in output. Lower values make responses more focused.',
+                            type: 'number',
                         },
                         {
-                            displayName: "Maximum Number of Tokens",
-                            name: "maxTokens",
+                            displayName: 'Maximum Number of Tokens',
+                            name: 'maxTokens',
                             default: 1000,
-                            description: "The maximum number of tokens to generate",
-                            type: "number",
+                            description: 'The maximum number of tokens to generate',
+                            type: 'number',
                             typeOptions: {
                                 maxValue: 32768,
                             },
                         },
                         {
-                            displayName: "Top P",
-                            name: "topP",
+                            displayName: 'Top P',
+                            name: 'topP',
                             default: 1,
                             typeOptions: { maxValue: 1, minValue: 0, numberPrecision: 2 },
-                            description: "Controls diversity of output by nucleus sampling",
-                            type: "number",
+                            description: 'Controls diversity of output by nucleus sampling',
+                            type: 'number',
                         },
                         {
-                            displayName: "Enable Streaming",
-                            name: "enableStreaming",
-                            type: "boolean",
+                            displayName: 'Enable Streaming',
+                            name: 'enableStreaming',
+                            type: 'boolean',
                             default: false,
-                            description: "Enable streaming responses for real-time output (experimental)",
+                            description: 'Enable streaming responses for real-time output (experimental)',
                         },
                         {
-                            displayName: "System Message",
-                            name: "systemMessage",
-                            type: "string",
-                            default: "",
-                            description: "System message to set the behavior of the assistant",
+                            displayName: 'System Message',
+                            name: 'systemMessage',
+                            type: 'string',
+                            default: '',
+                            description: 'System message to set the behavior of the assistant',
                             typeOptions: {
                                 rows: 3,
                             },
                         },
                         {
-                            displayName: "Auto Retry on 403 Error",
-                            name: "enableRetry",
-                            type: "boolean",
+                            displayName: 'Auto Retry on 403 Error',
+                            name: 'enableRetry',
+                            type: 'boolean',
                             default: true,
-                            description: "Automatically retry requests when hitting TPM (Transactions Per Minute) quota limits (HTTP 403)",
+                            description: 'Automatically retry requests when hitting TPM (Transactions Per Minute) quota limits (HTTP 403)',
                         },
                         {
-                            displayName: "Request Timeout (seconds)",
-                            name: "timeout",
-                            type: "number",
+                            displayName: 'Request Timeout (seconds)',
+                            name: 'timeout',
+                            type: 'number',
                             default: 120,
-                            description: "Maximum time to wait for API response (in seconds)",
+                            description: 'Maximum time to wait for API response (in seconds)',
                             typeOptions: {
                                 minValue: 10,
                                 maxValue: 300,
                             },
                         },
                         {
-                            displayName: "Tools (Function Calling)",
-                            name: "tools",
-                            type: "string",
-                            default: "",
-                            description: "Optional: Array of tools/functions available to the model (OpenAI format). Leave empty if not using function calling.",
+                            displayName: 'Tools (Function Calling)',
+                            name: 'tools',
+                            type: 'string',
+                            default: '',
+                            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.",
                             typeOptions: {
                                 rows: 6,
                             },
                         },
                         {
-                            displayName: "Tool Choice",
-                            name: "tool_choice",
-                            type: "options",
+                            displayName: 'Tool Choice',
+                            name: 'tool_choice',
+                            type: 'options',
                             options: [
                                 {
-                                    name: "Auto",
-                                    value: "auto",
-                                    description: "Let the model decide when to use tools",
+                                    name: 'Auto',
+                                    value: 'auto',
+                                    description: 'Let the model decide when to use tools',
                                 },
                                 {
-                                    name: "Required",
-                                    value: "required",
-                                    description: "Force the model to use at least one tool",
+                                    name: 'Required',
+                                    value: 'required',
+                                    description: 'Force the model to use at least one tool',
                                 },
                                 {
-                                    name: "None",
-                                    value: "none",
-                                    description: "Disable tool usage",
+                                    name: 'None',
+                                    value: 'none',
+                                    description: 'Disable tool usage',
                                 },
                             ],
-                            default: "auto",
-                            description: "Control how the model uses tools",
+                            default: 'auto',
+                            description: 'Control how the model uses tools',
                             displayOptions: {
                                 show: {
-                                    tools: ["/.+/"],
+                                    tools: ['/.+/'],
                                 },
                             },
                         },
+                        {
+                            displayName: 'Enable Vision (Image Processing)',
+                            name: 'enableVision',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Enable vision capabilities for processing images. Required when sending images via chat. Only works with vision-capable models (GPT-4o, GPT-5, Claude, etc.).',
+                        },
                     ],
                 },
             ],
@@ -284,10 +353,10 @@ class GitHubCopilotChatModel {
         };
     }
     async supplyData(itemIndex) {
-        let model = this.getNodeParameter("model", itemIndex);
-        if (model === "__manual__") {
-            const customModel = this.getNodeParameter("customModel", itemIndex);
-            if (!customModel || customModel.trim() === "") {
+        let model = this.getNodeParameter('model', itemIndex);
+        if (model === '__manual__') {
+            const customModel = this.getNodeParameter('customModel', itemIndex);
+            if (!customModel || customModel.trim() === '') {
                 throw new Error("Custom model name is required when selecting '✏️ Enter Custom Model Name'");
             }
             model = customModel;
@@ -296,24 +365,24 @@ class GitHubCopilotChatModel {
         else {
             console.log(`✅ Using model from list: ${model}`);
         }
-        const options = this.getNodeParameter("options", itemIndex, {});
+        const options = this.getNodeParameter('options', itemIndex, {});
         const modelInfo = GitHubCopilotModels_1.GitHubCopilotModelsManager.getModelByValue(model);
-        const credentials = (await this.getCredentials("githubCopilotApi"));
+        const credentials = (await this.getCredentials('githubCopilotApi'));
         const token = credentials.token;
         if (!token) {
-            console.error("❌ Available credential properties:", Object.keys(credentials));
-            throw new Error("GitHub Copilot: No token found in credentials. Available properties: " +
-                Object.keys(credentials).join(", "));
+            console.error('❌ Available credential properties:', Object.keys(credentials));
+            throw new Error('GitHub Copilot: No token found in credentials. Available properties: ' +
+                Object.keys(credentials).join(', '));
         }
-        const tokenPrefix = token.substring(0, Math.min(4, token.indexOf("_") + 1)) || token.substring(0, 4);
+        const tokenPrefix = token.substring(0, Math.min(4, token.indexOf('_') + 1)) || token.substring(0, 4);
         const tokenSuffix = token.substring(Math.max(0, token.length - 5));
         console.log(`🔍 GitHub Copilot ChatModel OAuth2 Debug: Using token ${tokenPrefix}...${tokenSuffix}`);
-        if (!token.startsWith("gho_") &&
-            !token.startsWith("ghu_") &&
-            !token.startsWith("github_pat_")) {
+        if (!token.startsWith('gho_') &&
+            !token.startsWith('ghu_') &&
+            !token.startsWith('github_pat_')) {
             console.warn(`⚠️ Unexpected token format: ${tokenPrefix}...${tokenSuffix}. Trying API call anyway.`);
         }
-        const safeModel = modelInfo ? model : GitHubCopilotModels_1.DEFAULT_MODELS.GENERAL;
+        const safeModel = 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);
@@ -331,7 +400,7 @@ class GitHubCopilotChatModel {
                 }
             }
             catch (error) {
-                console.log(`⚠️ Failed to parse tools JSON: ${error instanceof Error ? error.message : "Unknown error"}`);
+                console.log(`⚠️ Failed to parse tools JSON: ${error instanceof Error ? error.message : 'Unknown error'}`);
             }
         }
         const modelConfig = {
@@ -342,22 +411,26 @@ class GitHubCopilotChatModel {
             maxRetries: options.enableRetry !== false ? options.maxRetries || 3 : 0,
             ...(parsedTools.length > 0 && {
                 tools: parsedTools,
-                tool_choice: options.tool_choice || "auto",
+                tool_choice: options.tool_choice || 'auto',
             }),
             configuration: {
                 baseURL: GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.BASE_URL,
                 apiKey: token,
                 defaultHeaders: {
-                    "User-Agent": "GitHubCopilotChat/1.0.0 n8n/3.10.1",
-                    Accept: "application/json",
-                    "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)}`,
+                    'User-Agent': 'GitHubCopilotChat/0.35.0',
+                    'Accept': 'application/json',
+                    'Editor-Version': `vscode/${minVSCodeVersion}`,
+                    'Editor-Plugin-Version': 'copilot-chat/0.35.0',
+                    'X-Request-Id': `n8n-chatmodel-${Date.now()}-${Math.random().toString(36).substring(7)}`,
+                    'X-GitHub-Api-Version': '2025-05-01',
+                    'X-Interaction-Type': 'copilot-chat',
+                    'OpenAI-Intent': 'conversation-panel',
+                    'Copilot-Integration-Id': 'vscode-chat',
                     ...additionalHeaders,
                     ...(options.enableVision &&
                         (safeModelInfo === null || safeModelInfo === void 0 ? void 0 : safeModelInfo.capabilities.vision) && {
-                        "Copilot-Vision-Request": "true",
-                        "Copilot-Media-Request": "true",
+                        'Copilot-Vision-Request': 'true',
+                        'Copilot-Media-Request': 'true',
                     }),
                 },
             },

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

@@ -1,4 +1,4 @@
-import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription, ILoadOptionsFunctions, INodePropertyOptions } from "n8n-workflow";
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription, ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
 export declare class GitHubCopilotEmbeddings implements INodeType {
     description: INodeTypeDescription;
     methods: {