n8n-nodes-github-copilot 3.38.24 → 3.38.26

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

@@ -14,8 +14,17 @@ 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) {
-        let copilotMessages = messages.map(msg => {
+        var _a;
+        if (!messages || messages.length === 0) {
+            throw new Error('No messages provided for generation');
+        }
+        let copilotMessages = messages.map((msg) => {
             let role;
             switch (msg._getType()) {
                 case 'human':
@@ -28,54 +37,99 @@ class GitHubCopilotChatOpenAI extends openai_1.ChatOpenAI {
                     role = 'system';
                     break;
                 default:
+                    console.warn(`⚠️ Unknown message type: ${msg._getType()}, defaulting to 'user'`);
                     role = 'user';
             }
+            let content = msg.content;
+            if (typeof content === 'string') {
+            }
+            else if (Array.isArray(content)) {
+                console.warn(`⚠️ Complex content detected, stringifying:`, content);
+                content = JSON.stringify(content);
+            }
+            else if (content === null || content === undefined) {
+                content = '';
+            }
+            else {
+                console.warn(`⚠️ Non-string content detected, stringifying:`, typeof content);
+                content = JSON.stringify(content);
+            }
             return {
                 role,
-                content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+                content,
             };
         });
         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',
                     content: this.options.systemMessage,
                 });
+                console.log(`🔧 Added system message from options`);
             }
         }
+        const validMessages = copilotMessages.filter((msg) => {
+            if (!msg.content || msg.content.trim() === '') {
+                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');
+        }
         const requestBody = {
             model: this.modelName || this.model,
-            messages: copilotMessages,
+            messages: validMessages,
             temperature: this.temperature,
             max_tokens: this.maxTokens,
             top_p: this.topP,
-            stream: false,
+            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";
+            requestBody.tool_choice = this.options.tool_choice || 'auto';
+            console.log(`🔧 Request includes ${this.options.tools.length} tools`);
         }
+        const startTime = Date.now();
         try {
             const response = await (0, GitHubCopilotApiUtils_1.makeGitHubCopilotRequest)(this.context, GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.ENDPOINTS.CHAT_COMPLETIONS, requestBody, false);
+            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');
+            }
             const choice = response.choices[0];
+            if (!choice.message) {
+                throw new Error('GitHub Copilot API returned choice without message');
+            }
             const langchainMessage = {
                 _getType: () => choice.message.role,
-                content: choice.message.content || "",
+                content: choice.message.content || '',
                 tool_calls: choice.message.tool_calls,
             };
+            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}`);
             return {
-                generations: [[{
-                            text: choice.message.content || "",
-                            generationInfo: {
-                                finish_reason: choice.finish_reason,
-                            },
-                            message: langchainMessage,
-                        }]],
-                tokenUsage: response.usage,
+                generations: [
+                    {
+                        text: choice.message.content || '',
+                        generationInfo: {
+                            finish_reason: choice.finish_reason,
+                        },
+                        message: langchainMessage,
+                    },
+                ],
+                llmOutput: {
+                    tokenUsage: response.usage,
+                },
             };
         }
         catch (error) {
+            const endTime = Date.now();
+            const latency = endTime - startTime;
+            console.error(`❌ GitHub Copilot API call failed after ${latency}ms:`, error);
             throw new Error(`GitHub Copilot API error: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
@@ -83,147 +137,146 @@ 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 Vision",
-                            name: "enableVision",
-                            type: "boolean",
-                            default: true,
-                            description: "Whether to enable image processing capabilities",
+                            displayName: 'Enable Streaming',
+                            name: 'enableStreaming',
+                            type: 'boolean',
+                            default: false,
+                            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: "Max Retry Attempts",
-                            name: "maxRetries",
-                            type: "number",
-                            default: 3,
-                            description: "Maximum number of retry attempts for 403 errors",
-                            displayOptions: {
-                                show: {
-                                    enableRetry: [true],
-                                },
+                            displayName: 'Request Timeout (seconds)',
+                            name: 'timeout',
+                            type: 'number',
+                            default: 120,
+                            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: ['/.+/'],
                                 },
                             },
                         },
@@ -240,10 +293,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;
@@ -252,21 +305,21 @@ 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;
@@ -287,7 +340,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 = {
@@ -298,22 +351,22 @@ 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/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)}`,
                     ...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: {