n8n-nodes-github-copilot 4.4.17 → 4.5.0

package/dist/nodes/GitHubCopilotOpenAI/execute/chatCompletion.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+export declare function executeChatCompletion(context: IExecuteFunctions, items: INodeExecutionData[], i: number): Promise<Record<string, any>>;

package/dist/nodes/GitHubCopilotOpenAI/execute/chatCompletion.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeChatCompletion = executeChatCompletion;
+const n8n_workflow_1 = require("n8n-workflow");
+const utils_1 = require("../../GitHubCopilotChatAPI/utils");
+const GitHubCopilotEndpoints_1 = require("../../../shared/utils/GitHubCopilotEndpoints");
+const GitHubCopilotModels_1 = require("../../../shared/models/GitHubCopilotModels");
+const DynamicModelsManager_1 = require("../../../shared/utils/DynamicModelsManager");
+const parseMessages_1 = require("./parseMessages");
+const MODEL_MAPPING = {
+    'gpt-4': 'gpt-4o',
+    'gpt-4o': 'gpt-4o',
+    'gpt-4o-mini': 'gpt-4o-mini',
+    'gpt-4-turbo': 'gpt-4o',
+    'claude-3-5-sonnet': 'claude-3.5-sonnet',
+    'claude-3.5-sonnet-20241022': 'claude-3.5-sonnet',
+    o1: 'o1',
+    'o1-preview': 'o1-preview',
+    'o1-mini': 'o1-mini',
+};
+function resolveModel(context, i) {
+    const modelSource = context.getNodeParameter('modelSource', i, 'fromList');
+    if (modelSource === 'custom') {
+        const custom = context.getNodeParameter('customModel', i);
+        if (!(custom === null || custom === void 0 ? void 0 : custom.trim()))
+            throw new Error("Custom model name is required when using 'Custom (Manual Entry)' mode");
+        console.log(`🔧 Using custom model: ${custom}`);
+        return custom;
+    }
+    const selected = context.getNodeParameter('model', i);
+    if (selected === '__manual__') {
+        const manual = context.getNodeParameter('customModel', i);
+        if (!(manual === null || manual === void 0 ? void 0 : manual.trim()))
+            throw new Error("Custom model name is required when selecting '✏️ Enter Custom Model Name'");
+        console.log(`✏️ Using manually entered model: ${manual}`);
+        return manual;
+    }
+    console.log(`📋 Using model from list: ${selected}`);
+    return selected;
+}
+function detectVisionContent(messages) {
+    for (const msg of messages) {
+        const content = msg.content;
+        const type = msg.type;
+        if (type === 'file' || type === 'image')
+            return true;
+        if (typeof content === 'string') {
+            const trimmed = content.trim();
+            const isDataUrl = /^data:image\/[a-z]+;base64,[A-Za-z0-9+\/=]{100,}/i.test(trimmed);
+            if (isDataUrl || trimmed.startsWith('copilot-file://'))
+                return true;
+        }
+        else if (Array.isArray(content)) {
+            for (const part of content) {
+                if ((part === null || part === void 0 ? void 0 : part.type) === 'image_url' || (part === null || part === void 0 ? void 0 : part.type) === 'image' || (part === null || part === void 0 ? void 0 : part.image_url) || (part === null || part === void 0 ? void 0 : part.type) === 'file') {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+async function resolveVisionModel(context, copilotModel, advancedOptions, i) {
+    var _a, _b;
+    const credentials = await context.getCredentials('githubCopilotApi');
+    const oauthToken = credentials.oauthToken;
+    let supportsVision = DynamicModelsManager_1.DynamicModelsManager.modelSupportsVision(oauthToken, copilotModel);
+    if (supportsVision === null) {
+        const modelInfo = GitHubCopilotModels_1.GitHubCopilotModelsManager.getModelByValue(copilotModel);
+        supportsVision = !!(((_a = modelInfo === null || modelInfo === void 0 ? void 0 : modelInfo.capabilities) === null || _a === void 0 ? void 0 : _a.vision) || ((_b = modelInfo === null || modelInfo === void 0 ? void 0 : modelInfo.capabilities) === null || _b === void 0 ? void 0 : _b.multimodal));
+        console.log(`👁️ Vision check for ${copilotModel}: static list, supported=${supportsVision}`);
+    }
+    else {
+        console.log(`👁️ Vision check for ${copilotModel}: API cache, supported=${supportsVision}`);
+    }
+    if (supportsVision)
+        return copilotModel;
+    const enableFallback = advancedOptions.enableVisionFallback || false;
+    if (!enableFallback) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Model ${copilotModel} does not support vision. Enable "Vision Fallback" in Advanced Options and select a vision-capable model.`, { itemIndex: i });
+    }
+    const fallbackRaw = advancedOptions.visionFallbackModel;
+    const fallback = fallbackRaw === '__manual__'
+        ? advancedOptions.visionFallbackCustomModel
+        : fallbackRaw;
+    if (!(fallback === null || fallback === void 0 ? void 0 : fallback.trim())) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Vision fallback enabled but no fallback model was selected or provided.', { itemIndex: i });
+    }
+    console.log(`👁️ Model ${copilotModel} lacks vision - falling back to: ${fallback}`);
+    return fallback;
+}
+function parseResponseFormat(requestBodyFromJson, advancedOptions) {
+    if (requestBodyFromJson === null || requestBodyFromJson === void 0 ? void 0 : requestBodyFromJson.response_format) {
+        const rf = requestBodyFromJson.response_format;
+        console.log('📋 response_format from JSON body:', JSON.stringify(rf));
+        return rf;
+    }
+    const uiValue = advancedOptions.response_format || 'text';
+    if (uiValue && uiValue !== 'text') {
+        console.log('📋 response_format from UI:', uiValue);
+        return { type: uiValue };
+    }
+    if (advancedOptions.response_format && typeof advancedOptions.response_format === 'string') {
+        try {
+            const parsed = JSON.parse(advancedOptions.response_format);
+            console.log('📋 response_format from advancedOptions:', JSON.stringify(parsed));
+            return parsed;
+        }
+        catch {
+            console.log('⚠️ Failed to parse response_format from advancedOptions');
+        }
+    }
+    return undefined;
+}
+function cleanJsonFromMarkdown(content) {
+    const trimmed = content.trim();
+    const match = trimmed.match(/^```(?:json)?\s*\n([\s\S]*?)\n```\s*$/);
+    if (match === null || match === void 0 ? void 0 : match[1])
+        return match[1].trim();
+    return trimmed;
+}
+function buildOpenAIResponse(response, model, response_format) {
+    const result = {
+        id: response.id || `chatcmpl-${Date.now()}`,
+        object: response.object || 'chat.completion',
+        created: response.created || Math.floor(Date.now() / 1000),
+        model,
+        choices: response.choices.map((choice, idx) => {
+            var _a;
+            console.log(`\n📝 Processing choice ${idx}: role=${choice.message.role}`);
+            let processedContent = choice.message.content;
+            if (choice.message.content != null && (response_format === null || response_format === void 0 ? void 0 : response_format.type) === 'json_object') {
+                processedContent = cleanJsonFromMarkdown(choice.message.content);
+            }
+            const choiceObj = {
+                index: choice.index,
+                message: {
+                    role: choice.message.role,
+                    content: processedContent,
+                    refusal: choice.message.refusal || null,
+                    annotations: choice.message.annotations || [],
+                },
+                logprobs: choice.logprobs || null,
+                finish_reason: choice.finish_reason,
+            };
+            if ((_a = choice.message.tool_calls) === null || _a === void 0 ? void 0 : _a.length) {
+                choiceObj.message.tool_calls = choice.message.tool_calls;
+            }
+            return choiceObj;
+        }),
+        usage: response.usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+    };
+    if (response.system_fingerprint) {
+        result.system_fingerprint = response.system_fingerprint;
+    }
+    return result;
+}
+async function executeChatCompletion(context, items, i) {
+    var _a, _b, _c, _d, _e, _f;
+    const model = resolveModel(context, i);
+    const { messages, requestBodyFromJson } = await (0, parseMessages_1.parseMessages)(context, items, i);
+    const advancedOptions = context.getNodeParameter('advancedOptions', i, {});
+    let max_tokens = advancedOptions.max_tokens || 4096;
+    if (!max_tokens || max_tokens <= 0 || isNaN(max_tokens))
+        max_tokens = 4096;
+    const temperature = (_a = advancedOptions.temperature) !== null && _a !== void 0 ? _a : 1;
+    const top_p = (_b = advancedOptions.top_p) !== null && _b !== void 0 ? _b : 1;
+    const frequency_penalty = (_c = advancedOptions.frequency_penalty) !== null && _c !== void 0 ? _c : 0;
+    const presence_penalty = (_d = advancedOptions.presence_penalty) !== null && _d !== void 0 ? _d : 0;
+    const seed = advancedOptions.seed || 0;
+    const stream = (_e = advancedOptions.stream) !== null && _e !== void 0 ? _e : false;
+    const user = advancedOptions.user || undefined;
+    const stop = advancedOptions.stop || undefined;
+    let parsedTools = [];
+    const tools = advancedOptions.tools;
+    if (tools) {
+        try {
+            if (Array.isArray(tools) && tools.length > 0) {
+                parsedTools = tools;
+            }
+            else if (typeof tools === 'string' && tools.trim()) {
+                const parsed = JSON.parse(tools);
+                if (Array.isArray(parsed) && parsed.length > 0)
+                    parsedTools = parsed;
+            }
+        }
+        catch {
+            console.log('⚠️ Failed to parse tools, ignoring');
+        }
+    }
+    const response_format = parseResponseFormat(requestBodyFromJson, advancedOptions);
+    let copilotModel = MODEL_MAPPING[model] || model;
+    const hasVisionContent = detectVisionContent(messages);
+    if (hasVisionContent) {
+        copilotModel = await resolveVisionModel(context, copilotModel, advancedOptions, i);
+    }
+    const requestBody = {
+        model: copilotModel,
+        messages,
+        stream,
+        temperature,
+        max_tokens,
+    };
+    if (top_p !== 1)
+        requestBody.top_p = top_p;
+    if (frequency_penalty !== 0)
+        requestBody.frequency_penalty = frequency_penalty;
+    if (presence_penalty !== 0)
+        requestBody.presence_penalty = presence_penalty;
+    if (user)
+        requestBody.user = user;
+    if (stop) {
+        try {
+            requestBody.stop = JSON.parse(stop);
+        }
+        catch {
+            requestBody.stop = stop;
+        }
+    }
+    if (parsedTools.length > 0) {
+        requestBody.tools = parsedTools;
+        const tool_choice = advancedOptions.tool_choice || 'auto';
+        if (tool_choice !== 'auto')
+            requestBody.tool_choice = tool_choice;
+    }
+    if (response_format)
+        requestBody.response_format = response_format;
+    if (seed > 0)
+        requestBody.seed = seed;
+    console.log(`🚀 Sending request: model=${copilotModel}, messages=${messages.length}, vision=${hasVisionContent}`);
+    let response;
+    try {
+        response = await (0, utils_1.makeApiRequest)(context, GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.ENDPOINTS.CHAT_COMPLETIONS, requestBody, hasVisionContent);
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `${errorMsg}\n\n🤖 Model used: ${copilotModel}`);
+    }
+    const retriesUsed = ((_f = response._retryMetadata) === null || _f === void 0 ? void 0 : _f.retries) || 0;
+    if (retriesUsed > 0)
+        console.log(`ℹ️ Request completed with ${retriesUsed} retry(ies)`);
+    return buildOpenAIResponse(response, model, response_format);
+}

package/dist/nodes/GitHubCopilotOpenAI/execute/listModels.d.ts

@@ -0,0 +1,2 @@
+import { IDataObject, IExecuteFunctions } from 'n8n-workflow';
+export declare function executeListModels(context: IExecuteFunctions, i: number): Promise<IDataObject>;

package/dist/nodes/GitHubCopilotOpenAI/execute/listModels.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeListModels = executeListModels;
+const GitHubCopilotEndpoints_1 = require("../../../shared/utils/GitHubCopilotEndpoints");
+const modelsApi_1 = require("../utils/modelsApi");
+async function executeListModels(context, i) {
+    const filter = context.getNodeParameter('modelsFilter', i, 'enabled');
+    const credentials = await context.getCredentials('githubCopilotApi', i);
+    const token = credentials.token;
+    if (!token)
+        throw new Error(GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.ERRORS.CREDENTIALS_REQUIRED);
+    if (!GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.validateToken(token))
+        throw new Error(GitHubCopilotEndpoints_1.GITHUB_COPILOT_API.ERRORS.INVALID_TOKEN);
+    return (0, modelsApi_1.fetchModelsOpenAIFormat)(token, filter);
+}

package/dist/nodes/GitHubCopilotOpenAI/execute/parseMessages.d.ts

@@ -0,0 +1,17 @@
+import { IDataObject, IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+export interface ParsedMessages {
+    messages: Array<{
+        role: string;
+        content: any;
+    }>;
+    requestBodyFromJson: IDataObject | undefined;
+}
+export declare function validateMessages(messages: Array<{
+    role: string;
+    content: any;
+}>, context: IExecuteFunctions, itemIndex: number): void;
+export declare function normalizeMessages(messages: Array<{
+    role: string;
+    content: any;
+}>): void;
+export declare function parseMessages(context: IExecuteFunctions, items: INodeExecutionData[], i: number): Promise<ParsedMessages>;

package/dist/nodes/GitHubCopilotOpenAI/execute/parseMessages.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMessages = validateMessages;
+exports.normalizeMessages = normalizeMessages;
+exports.parseMessages = parseMessages;
+const n8n_workflow_1 = require("n8n-workflow");
+const utils_1 = require("../../GitHubCopilotChatAPI/utils");
+function parseJsonMode(messagesJson) {
+    let parsed;
+    if (typeof messagesJson === 'object') {
+        parsed = messagesJson;
+        console.log('📥 Received messages as direct object/array (no parsing needed)');
+    }
+    else {
+        parsed = JSON.parse(messagesJson);
+        console.log('📥 Parsed messages from JSON string');
+    }
+    if (Array.isArray(parsed)) {
+        return { messages: parsed, requestBodyFromJson: undefined };
+    }
+    else if (parsed.messages && Array.isArray(parsed.messages)) {
+        console.log('📥 Full OpenAI request body received:', JSON.stringify(parsed, null, 2));
+        return { messages: parsed.messages, requestBodyFromJson: parsed };
+    }
+    return { messages: parsed, requestBodyFromJson: undefined };
+}
+async function processBinaryMessage(context, items, msg, message, itemIndex) {
+    var _a;
+    const keyToUse = msg.binaryPropertyName || 'data';
+    const binaryKeyData = items[itemIndex].binary;
+    if (!(binaryKeyData === null || binaryKeyData === void 0 ? void 0 : binaryKeyData[keyToUse])) {
+        const available = binaryKeyData ? Object.keys(binaryKeyData).join(', ') : 'none';
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Binary property '${keyToUse}' not found. Available binary properties: ${available}`, { itemIndex });
+    }
+    try {
+        const binaryData = binaryKeyData[keyToUse];
+        let mimeType = binaryData.mimeType || 'application/octet-stream';
+        const buffer = await context.helpers.getBinaryDataBuffer(itemIndex, keyToUse);
+        if (!mimeType.startsWith('image/')) {
+            const detected = (0, utils_1.getImageMimeType)(buffer);
+            if (detected !== 'application/octet-stream') {
+                mimeType = detected;
+            }
+            else {
+                console.warn(`⚠️ Could not detect image type for '${keyToUse}', using image/jpeg fallback`);
+                if (mimeType === 'application/octet-stream')
+                    mimeType = 'image/jpeg';
+            }
+        }
+        if (!mimeType.startsWith('image/')) {
+            console.warn(`⚠️ Forcing '${mimeType}' to 'image/jpeg' for schema compliance`);
+            mimeType = 'image/jpeg';
+        }
+        const base64 = buffer.toString('base64');
+        const dataUrl = `data:${mimeType};base64,${base64}`;
+        const contentArray = [];
+        const caption = msg.caption;
+        if (caption === null || caption === void 0 ? void 0 : caption.trim()) {
+            contentArray.push({ type: 'text', text: caption });
+        }
+        else if (((_a = message.content) === null || _a === void 0 ? void 0 : _a.trim()) &&
+            message.content !== '[object Object]') {
+            contentArray.push({ type: 'text', text: message.content });
+        }
+        contentArray.push({ type: 'image_url', image_url: { url: dataUrl, detail: 'auto' } });
+        message.role = 'user';
+        message.content = contentArray;
+        delete message.type;
+        console.log(`📎 Attached binary file '${keyToUse}' (${mimeType}) as image_url`);
+    }
+    catch (err) {
+        if (err instanceof n8n_workflow_1.NodeOperationError)
+            throw err;
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Failed to read binary file '${keyToUse}': ${errorMessage}`, { itemIndex });
+    }
+}
+async function parseManualMode(context, items, i) {
+    const messagesParam = context.getNodeParameter('messages', i, { message: [] });
+    console.log('📥 Manual mode - messagesParam:', JSON.stringify(messagesParam, null, 2));
+    const messages = [];
+    if (messagesParam.message && Array.isArray(messagesParam.message)) {
+        for (const msg of messagesParam.message) {
+            const message = {
+                role: msg.role,
+                content: msg.content,
+            };
+            const msgType = msg.type || 'text';
+            if (msgType === 'file_binary') {
+                await processBinaryMessage(context, items, msg, message, i);
+            }
+            else if (msgType === 'file') {
+                message.type = 'file';
+            }
+            messages.push(message);
+        }
+    }
+    console.log('📥 Manual mode - parsed messages:', JSON.stringify(messages, null, 2));
+    return messages;
+}
+function validateMessages(messages, context, itemIndex) {
+    for (const msg of messages) {
+        if (Array.isArray(msg.content)) {
+            for (const contentItem of msg.content) {
+                if (contentItem.type === 'file') {
+                    throw new n8n_workflow_1.NodeOperationError(context.getNode(), `❌ GitHub Copilot API Error: File attachments cannot be used inside 'content' array.\n\n` +
+                        `✅ CORRECT FORMAT (GitHub Copilot - message level):\n` +
+                        `[{"role": "user", "content": "data:image/png;base64,...", "type": "file"}]`, { itemIndex });
+                }
+            }
+        }
+    }
+}
+function normalizeMessages(messages) {
+    for (let idx = 0; idx < messages.length; idx++) {
+        const msg = messages[idx];
+        if (msg.content !== null &&
+            msg.content !== undefined &&
+            typeof msg.content === 'object' &&
+            !Array.isArray(msg.content)) {
+            msg.content = JSON.stringify(msg.content, null, 2);
+            console.log(`🔄 Auto-converted message[${idx}].content from object to JSON string`);
+        }
+    }
+}
+async function parseMessages(context, items, i) {
+    const messagesInputMode = context.getNodeParameter('messagesInputMode', i, 'manual');
+    let result;
+    if (messagesInputMode === 'json') {
+        const messagesJson = context.getNodeParameter('messagesJson', i, '[]');
+        try {
+            result = parseJsonMode(messagesJson);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse messages JSON: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    else {
+        const messages = await parseManualMode(context, items, i);
+        result = { messages, requestBodyFromJson: undefined };
+    }
+    if (result.messages.length === 0) {
+        result.messages.push({ role: 'user', content: 'Hello! How can you help me?' });
+    }
+    console.log('📤 Final messages being sent to API:', JSON.stringify(result.messages, null, 2));
+    validateMessages(result.messages, context, i);
+    normalizeMessages(result.messages);
+    return result;
+}