n8n-nodes-github-copilot 4.4.17 → 4.5.1

package/dist/nodes/GitHubCopilotOpenAI/properties/chatCompletionProperties.js

@@ -0,0 +1,352 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHAT_COMPLETION_PROPERTIES = void 0;
+const ModelProperties_1 = require("../../../shared/properties/ModelProperties");
+exports.CHAT_COMPLETION_PROPERTIES = [
+    ...ModelProperties_1.CHAT_MODEL_PROPERTIES,
+    {
+        displayName: 'Messages Input Mode',
+        name: 'messagesInputMode',
+        type: 'options',
+        options: [
+            {
+                name: 'Manual (UI)',
+                value: 'manual',
+                description: 'Enter messages one by one using the UI',
+            },
+            {
+                name: 'JSON (Programmatic)',
+                value: 'json',
+                description: 'Provide messages as JSON array',
+            },
+        ],
+        default: 'manual',
+        description: 'How to provide the messages for the conversation',
+    },
+    {
+        displayName: 'Messages (JSON)',
+        name: 'messagesJson',
+        type: 'json',
+        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": "..."}]',
+        displayOptions: {
+            show: {
+                messagesInputMode: ['json'],
+            },
+        },
+    },
+    {
+        displayName: 'Messages',
+        name: 'messages',
+        type: 'fixedCollection',
+        typeOptions: {
+            multipleValues: true,
+            sortable: true,
+        },
+        default: {
+            message: [{ role: 'user', content: '' }],
+        },
+        displayOptions: {
+            show: {
+                messagesInputMode: ['manual'],
+            },
+        },
+        options: [
+            {
+                name: 'message',
+                displayName: 'Message',
+                values: [
+                    {
+                        displayName: 'Role',
+                        name: 'role',
+                        type: 'options',
+                        options: [
+                            {
+                                name: 'System',
+                                value: 'system',
+                                description: 'System message to set the behavior of the AI',
+                            },
+                            {
+                                name: 'User',
+                                value: 'user',
+                                description: 'Message from the user',
+                            },
+                            {
+                                name: 'Assistant',
+                                value: 'assistant',
+                                description: 'Previous response from the AI assistant',
+                            },
+                        ],
+                        default: 'user',
+                    },
+                    {
+                        displayName: 'Content',
+                        name: 'content',
+                        type: 'string',
+                        typeOptions: { rows: 3 },
+                        default: '',
+                        placeholder: 'Enter message content...',
+                        description: 'The content of the message',
+                        displayOptions: {
+                            show: { type: ['text', 'file'] },
+                        },
+                    },
+                    {
+                        displayName: 'Caption',
+                        name: 'caption',
+                        type: 'string',
+                        typeOptions: { rows: 2 },
+                        default: '',
+                        placeholder: 'Optional prompt for the image...',
+                        description: 'Text to accompany the image (optional)',
+                        displayOptions: {
+                            show: { type: ['file_binary'] },
+                        },
+                    },
+                    {
+                        displayName: 'Type',
+                        name: 'type',
+                        type: 'options',
+                        options: [
+                            { name: 'Text', value: 'text', description: 'Regular text message' },
+                            {
+                                name: 'File (URL / Base64)',
+                                value: 'file',
+                                description: 'File attachment using URL or Base64 string',
+                            },
+                            {
+                                name: 'File (Binary)',
+                                value: 'file_binary',
+                                description: 'File attachment from binary input',
+                            },
+                        ],
+                        default: 'text',
+                        description: 'The type of message content',
+                    },
+                    {
+                        displayName: 'Input Binary Field',
+                        name: 'binaryPropertyName',
+                        type: 'string',
+                        default: 'data',
+                        required: true,
+                        displayOptions: {
+                            show: { type: ['file_binary'] },
+                        },
+                        description: 'The name of the binary property that contains the file to upload',
+                    },
+                ],
+            },
+        ],
+        description: 'Array of messages for the conversation',
+    },
+    {
+        displayName: 'Advanced Options',
+        name: 'advancedOptions',
+        type: 'collection',
+        placeholder: 'Add Advanced Option',
+        default: {},
+        options: [
+            {
+                displayName: 'Response Format',
+                name: 'response_format',
+                type: 'options',
+                options: [
+                    { name: 'Text', value: 'text', description: 'Return response as plain text' },
+                    {
+                        name: 'JSON Object',
+                        value: 'json_object',
+                        description: 'Return response as JSON object',
+                    },
+                ],
+                default: 'text',
+                description: 'The format of the response',
+            },
+            {
+                displayName: 'Temperature',
+                name: 'temperature',
+                type: 'number',
+                typeOptions: { minValue: 0, maxValue: 2, numberPrecision: 2 },
+                default: 1,
+                description: 'Controls randomness in the response. Lower values make responses more focused and deterministic.',
+            },
+            {
+                displayName: 'Max Tokens',
+                name: 'max_tokens',
+                type: 'number',
+                typeOptions: { minValue: 1, maxValue: 16384 },
+                default: 4096,
+                placeholder: '4096',
+                description: 'Maximum number of tokens to generate in the response',
+                hint: 'Default: 4096 tokens. Increase for longer responses, decrease for shorter ones.',
+            },
+            {
+                displayName: 'Top P',
+                name: 'top_p',
+                type: 'number',
+                typeOptions: { minValue: 0, maxValue: 1, numberPrecision: 2 },
+                default: 1,
+                description: 'Controls diversity via nucleus sampling',
+            },
+            {
+                displayName: 'Frequency Penalty',
+                name: 'frequency_penalty',
+                type: 'number',
+                typeOptions: { minValue: -2, maxValue: 2, numberPrecision: 2 },
+                default: 0,
+                description: 'Penalty for repeated tokens based on their frequency',
+            },
+            {
+                displayName: 'Presence Penalty',
+                name: 'presence_penalty',
+                type: 'number',
+                typeOptions: { minValue: -2, maxValue: 2, numberPrecision: 2 },
+                default: 0,
+                description: 'Penalty for repeated tokens based on their presence',
+            },
+            {
+                displayName: 'Stop Sequences',
+                name: 'stop',
+                type: 'string',
+                default: '',
+                placeholder: '["\\n", "Human:", "AI:"]',
+                description: 'JSON array of strings where the API will stop generating tokens',
+            },
+            {
+                displayName: 'Stream',
+                name: 'stream',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to stream the response',
+            },
+            {
+                displayName: 'Seed',
+                name: 'seed',
+                type: 'number',
+                default: 0,
+                placeholder: '12345',
+                description: 'Seed for deterministic sampling (0 = disabled)',
+            },
+            {
+                displayName: 'User ID',
+                name: 'user',
+                type: 'string',
+                default: '',
+                placeholder: 'user-123',
+                description: 'Unique identifier for the end-user',
+            },
+            {
+                displayName: 'Tools (Function Calling)',
+                name: 'tools',
+                type: 'string',
+                default: '',
+                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"]
+      }
+    }
+  }
+]`,
+                description: 'Optional: Array of tools/functions available to the model (OpenAI format).',
+                hint: "JSON array of tool definitions in OpenAI format. Leave empty if not using function calling.",
+            },
+            {
+                displayName: 'Tool Choice',
+                name: 'tool_choice',
+                type: 'options',
+                options: [
+                    { name: 'Auto', value: 'auto', description: 'Let the model decide whether to call functions' },
+                    { name: 'None', value: 'none', description: 'Force the model to not call any functions' },
+                    { name: 'Required', value: 'required', description: 'Force the model to call at least one function' },
+                ],
+                default: 'auto',
+                description: 'Control how the model uses tools',
+                displayOptions: { show: { tools: ['/.+/'] } },
+            },
+            {
+                displayName: 'Enable Retry',
+                name: 'enableRetry',
+                type: 'boolean',
+                default: true,
+                description: 'Whether to retry failed requests',
+            },
+            {
+                displayName: 'Max Retries',
+                name: 'maxRetries',
+                type: 'number',
+                default: 3,
+                description: 'Maximum number of retries for failed requests',
+                displayOptions: { show: { enableRetry: [true] } },
+            },
+            {
+                displayName: 'Retry Delay (ms)',
+                name: 'retryDelay',
+                type: 'number',
+                default: 1000,
+                description: 'Delay between retries in milliseconds',
+                displayOptions: { show: { enableRetry: [true] } },
+            },
+            {
+                displayName: 'Request Timeout (ms)',
+                name: 'timeout',
+                type: 'number',
+                default: 60000,
+                description: 'Request timeout in milliseconds',
+            },
+            {
+                displayName: 'Debug Mode',
+                name: 'debugMode',
+                type: 'boolean',
+                default: false,
+                description: 'Enable debug logging',
+            },
+            {
+                displayName: 'Enable Vision Fallback',
+                name: 'enableVisionFallback',
+                type: 'boolean',
+                default: false,
+                description: 'When the primary model does not support vision, automatically use a vision-capable fallback model to process images.',
+            },
+            {
+                displayName: 'Vision Fallback Model',
+                name: 'visionFallbackModel',
+                type: 'options',
+                typeOptions: { loadOptionsMethod: 'getVisionFallbackModels' },
+                default: '',
+                description: 'Vision-capable model to use when the primary model does not support images',
+                displayOptions: { show: { enableVisionFallback: [true] } },
+            },
+            {
+                displayName: 'Custom Vision Model',
+                name: 'visionFallbackCustomModel',
+                type: 'string',
+                default: '',
+                placeholder: 'gpt-4o, claude-sonnet-4, gemini-2.0-flash, etc.',
+                description: 'Enter the model name manually for vision fallback',
+                hint: 'Enter the exact model ID for vision processing (e.g., gpt-4o, claude-sonnet-4)',
+                displayOptions: {
+                    show: { enableVisionFallback: [true], visionFallbackModel: ['__manual__'] },
+                },
+            },
+        ],
+    },
+];

package/dist/nodes/GitHubCopilotOpenAI/properties/modelsProperties.d.ts

@@ -0,0 +1,2 @@
+import { INodeProperties } from 'n8n-workflow';
+export declare const MODELS_PROPERTIES: INodeProperties[];

package/dist/nodes/GitHubCopilotOpenAI/properties/modelsProperties.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODELS_PROPERTIES = void 0;
+exports.MODELS_PROPERTIES = [
+    {
+        displayName: 'Filter',
+        name: 'modelsFilter',
+        type: 'options',
+        noDataExpression: true,
+        options: [
+            {
+                name: 'All Models',
+                value: 'all',
+                description: 'Return all models, including disabled ones',
+            },
+            {
+                name: 'Enabled Models',
+                value: 'enabled',
+                description: 'Only models with model_picker_enabled = true (default Copilot UI set)',
+            },
+            {
+                name: 'Chat Models Only',
+                value: 'chat',
+                description: 'Enabled chat models (excludes embeddings)',
+            },
+            {
+                name: 'Embedding Models Only',
+                value: 'embeddings',
+                description: 'Only embedding models (text-embedding-*)',
+            },
+        ],
+        default: 'enabled',
+        description: 'Which subset of models to return',
+    },
+];

package/dist/nodes/GitHubCopilotOpenAI/utils/modelsApi.d.ts

@@ -0,0 +1,3 @@
+import { IDataObject } from 'n8n-workflow';
+export type ModelsFilter = 'all' | 'enabled' | 'chat' | 'embeddings';
+export declare function fetchModelsOpenAIFormat(token: string, filter: ModelsFilter): Promise<IDataObject>;

package/dist/nodes/GitHubCopilotOpenAI/utils/modelsApi.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchModelsOpenAIFormat = fetchModelsOpenAIFormat;
+const GitHubCopilotEndpoints_1 = require("../../../shared/utils/GitHubCopilotEndpoints");
+function vendorToOwnedBy(vendor) {
+    if (!vendor)
+        return 'github-copilot';
+    return vendor.toLowerCase().replace(/\s+/g, '-');
+}
+function applyFilter(models, filter) {
+    switch (filter) {
+        case 'enabled':
+            return models.filter((m) => m.model_picker_enabled !== false);
+        case 'chat':
+            return models.filter((m) => { var _a; return m.model_picker_enabled !== false && ((_a = m.capabilities) === null || _a === void 0 ? void 0 : _a.type) !== 'embeddings'; });
+        case 'embeddings':
+            return models.filter((m) => { var _a; return ((_a = m.capabilities) === null || _a === void 0 ? void 0 : _a.type) === 'embeddings'; });
+        default:
+            return models;
+    }
+}
+async function fetchModelsOpenAIFormat(token, filter) {
+    var _a;
+    const response = await fetch(GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.getModelsUrl(), {
+        method: 'GET',
+        headers: GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.getAuthHeaders(token),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.ERRORS.API_ERROR(response.status, errorText));
+    }
+    const raw = (await response.json());
+    const allModels = (_a = raw.data) !== null && _a !== void 0 ? _a : [];
+    const filtered = applyFilter(allModels, filter);
+    const data = filtered.map((model) => {
+        var _a, _b, _c, _d;
+        return ({
+            id: model.id,
+            object: 'model',
+            created: 0,
+            owned_by: vendorToOwnedBy(model.vendor),
+            name: (_a = model.name) !== null && _a !== void 0 ? _a : model.id,
+            vendor: (_b = model.vendor) !== null && _b !== void 0 ? _b : 'GitHub Copilot',
+            version: model.version,
+            preview: (_c = model.preview) !== null && _c !== void 0 ? _c : false,
+            model_picker_enabled: (_d = model.model_picker_enabled) !== null && _d !== void 0 ? _d : true,
+            model_picker_category: model.model_picker_category,
+            capabilities: model.capabilities,
+            billing: model.billing,
+        });
+    });
+    return {
+        object: 'list',
+        data,
+        _meta: {
+            total: data.length,
+            source_total: allModels.length,
+            filter_applied: filter,
+            fetched_at: new Date().toISOString(),
+        },
+    };
+}

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "n8n-nodes-github-copilot",
-    "version": "4.4.17",
+    "version": "4.5.1",
     "description": "n8n community node for GitHub Copilot with CLI integration, Chat API access, and AI Chat Model for workflows with full tools and function calling support - access GPT-5, Claude, Gemini and more using your Copilot subscription",
     "license": "MIT",
     "homepage": "https://github.com/sufficit/n8n-nodes-github-copilot",
@@ -58,8 +58,10 @@
         "pnpm": ">=7.1"
     },
     "dependencies": {
-        "@langchain/openai": "^0.6.14",
-        "n8n-workflow": "^1.110.0"
+        "@langchain/openai": "^0.6.14"
+    },
+    "peerDependencies": {
+        "n8n-workflow": ">=1.0.0"
     },
     "overrides": {
         "form-data": "^4.0.4",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-github-copilot",
-  "version": "4.4.17",
+  "version": "4.5.1",
   "description": "n8n community node for GitHub Copilot with CLI integration, Chat API access, and AI Chat Model for workflows with full tools and function calling support - access GPT-5, Claude, Gemini and more using your Copilot subscription",
   "license": "MIT",
   "homepage": "https://github.com/sufficit/n8n-nodes-github-copilot",
@@ -58,8 +58,10 @@
     "pnpm": ">=7.1"
   },
   "dependencies": {
-    "@langchain/openai": "^0.6.14",
-    "n8n-workflow": "^1.110.0"
+    "@langchain/openai": "^0.6.14"
+  },
+  "peerDependencies": {
+    "n8n-workflow": ">=1.0.0"
   },
   "overrides": {
     "form-data": "^4.0.4",