n8n-nodes-github-copilot 3.27.5 → 3.28.0

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

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHubCopilotOpenAI = void 0;
+const nodeProperties_1 = require("./nodeProperties");
+class GitHubCopilotOpenAI {
+    constructor() {
+        this.description = {
+            displayName: "GitHub Copilot OpenAI",
+            name: "gitHubCopilotOpenAI",
+            icon: "file:../../shared/icons/copilot.svg",
+            group: ["AI"],
+            version: 1,
+            subtitle: "={{$parameter[\"operation\"] + \": \" + $parameter[\"model\"]}}",
+            description: "OpenAI-compatible GitHub Copilot Chat API with full support for messages, tools, and all OpenAI parameters",
+            defaults: {
+                name: "GitHub Copilot OpenAI",
+            },
+            inputs: ["main"],
+            outputs: ["main"],
+            credentials: [
+                {
+                    name: "githubCopilotApi",
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            credentialType: ["githubCopilotApi"],
+                        },
+                    },
+                },
+                {
+                    name: "githubCopilotOAuth2Api",
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            credentialType: ["githubCopilotOAuth2Api"],
+                        },
+                    },
+                },
+            ],
+            properties: nodeProperties_1.nodeProperties,
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const operation = this.getNodeParameter("operation", i);
+                if (operation === "chat") {
+                    const model = this.getNodeParameter("model", i, "gpt-4o");
+                    const messagesParam = this.getNodeParameter("messages", i, {
+                        message: [],
+                    });
+                    const temperature = this.getNodeParameter("temperature", i, 1);
+                    const tools = this.getNodeParameter("tools", i, "");
+                    const messages = [];
+                    if (messagesParam.message && Array.isArray(messagesParam.message)) {
+                        for (const msg of messagesParam.message) {
+                            messages.push({
+                                role: msg.role,
+                                content: msg.content,
+                            });
+                        }
+                    }
+                    if (messages.length === 0) {
+                        messages.push({
+                            role: "user",
+                            content: "Hello! How can you help me?",
+                        });
+                    }
+                    const modelMapping = {
+                        "gpt-4": "gpt-4o",
+                        "gpt-4o": "gpt-4o",
+                        "gpt-4o-mini": "gpt-4o-mini",
+                        "claude-3-5-sonnet": "claude-3.5-sonnet",
+                    };
+                    const copilotModel = modelMapping[model] || "gpt-4o";
+                    const mockResponse = {
+                        id: `chatcmpl-${Date.now()}`,
+                        object: "chat.completion",
+                        created: Math.floor(Date.now() / 1000),
+                        model: model,
+                        choices: [
+                            {
+                                index: 0,
+                                message: {
+                                    role: "assistant",
+                                    content: `🚀 GitHub Copilot OpenAI Mock Response
+
+**Request Details:**
+- Model: ${model} → ${copilotModel}
+- Messages: ${messages.length}
+- Temperature: ${temperature}
+- Tools: ${tools ? "Yes" : "No"}
+
+**Sample Messages:**
+${messages
+                                        .map((msg, idx) => `${idx + 1}. [${msg.role}]: ${msg.content.substring(0, 100)}${msg.content.length > 100 ? "..." : ""}`)
+                                        .join("\n")}
+
+This is a mock response. The real GitHub Copilot integration will be implemented next.`,
+                                },
+                                finish_reason: "stop",
+                            },
+                        ],
+                        usage: {
+                            prompt_tokens: 50,
+                            completion_tokens: 125,
+                            total_tokens: 175,
+                        },
+                    };
+                    returnData.push({
+                        json: mockResponse,
+                        pairedItem: { item: i },
+                    });
+                }
+                else {
+                    throw new Error(`Unknown operation: ${operation}`);
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: {
+                                message: error instanceof Error ? error.message : "Unknown error",
+                                type: "api_error",
+                                code: "github_copilot_openai_error",
+                            },
+                        },
+                        pairedItem: { item: i },
+                    });
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        return [returnData];
+    }
+}
+exports.GitHubCopilotOpenAI = GitHubCopilotOpenAI;

package/dist/nodes/GitHubCopilotOpenAI/nodeProperties.d.ts

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

package/dist/nodes/GitHubCopilotOpenAI/nodeProperties.js

@@ -0,0 +1,326 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeProperties = void 0;
+exports.nodeProperties = [
+    {
+        displayName: "Credential Type",
+        name: "credentialType",
+        type: "options",
+        options: [
+            {
+                name: "GitHub Copilot API (Manual Token)",
+                value: "githubCopilotApi",
+                description: "Use manual GitHub CLI token",
+            },
+            {
+                name: "GitHub Copilot OAuth2 (with Helper)",
+                value: "githubCopilotOAuth2Api",
+                description: "Use OAuth2 credential with helper script",
+            },
+        ],
+        default: "githubCopilotApi",
+        description: "Type of credential to use for GitHub Copilot authentication",
+    },
+    {
+        displayName: "Operation",
+        name: "operation",
+        type: "options",
+        noDataExpression: true,
+        options: [
+            {
+                name: "Chat Completion",
+                value: "chat",
+                description: "Send messages to GitHub Copilot Chat API with full OpenAI compatibility",
+            },
+        ],
+        default: "chat",
+    },
+    {
+        displayName: "Model",
+        name: "model",
+        type: "string",
+        default: "gpt-4o",
+        placeholder: "gpt-4o",
+        description: "The model to use for the completion. Supports all OpenAI model names that map to GitHub Copilot models.",
+    },
+    {
+        displayName: "Messages",
+        name: "messages",
+        type: "fixedCollection",
+        typeOptions: {
+            multipleValues: true,
+            sortable: true,
+        },
+        default: {
+            message: [
+                {
+                    role: "user",
+                    content: "",
+                },
+            ],
+        },
+        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",
+                    },
+                ],
+            },
+        ],
+        description: "Array of messages for the conversation",
+    },
+    {
+        displayName: "Tools",
+        name: "tools",
+        type: "json",
+        default: "",
+        placeholder: `[
+  {
+    "type": "function",
+    "function": {
+      "name": "get_weather",
+      "description": "Get current weather",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "location": {
+            "type": "string",
+            "description": "City name"
+          }
+        },
+        "required": ["location"]
+      }
+    }
+  }
+]`,
+        description: "Array of tools/functions available to the model (OpenAI format)",
+        hint: "JSON array of tool definitions in OpenAI format",
+    },
+    {
+        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: "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: 4096,
+        },
+        default: "",
+        placeholder: "1000",
+        description: "Maximum number of tokens to generate",
+    },
+    {
+        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: "",
+        placeholder: "12345",
+        description: "Seed for deterministic sampling",
+    },
+    {
+        displayName: "User ID",
+        name: "user",
+        type: "string",
+        default: "",
+        placeholder: "user-123",
+        description: "Unique identifier for the end-user",
+    },
+    {
+        displayName: "Advanced Options",
+        name: "advancedOptions",
+        type: "collection",
+        placeholder: "Add Advanced Option",
+        default: {},
+        options: [
+            {
+                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",
+            },
+        ],
+    },
+];

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

@@ -0,0 +1,2 @@
+export * from "./types";
+export { mapOpenAIModelToCopilot, convertOpenAIMessagesToCopilot, convertCopilotResponseToOpenAI, parseOpenAIRequest, debugLog, } from "./openaiCompat";

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

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugLog = exports.parseOpenAIRequest = exports.convertCopilotResponseToOpenAI = exports.convertOpenAIMessagesToCopilot = exports.mapOpenAIModelToCopilot = void 0;
+__exportStar(require("./types"), exports);
+var openaiCompat_1 = require("./openaiCompat");
+Object.defineProperty(exports, "mapOpenAIModelToCopilot", { enumerable: true, get: function () { return openaiCompat_1.mapOpenAIModelToCopilot; } });
+Object.defineProperty(exports, "convertOpenAIMessagesToCopilot", { enumerable: true, get: function () { return openaiCompat_1.convertOpenAIMessagesToCopilot; } });
+Object.defineProperty(exports, "convertCopilotResponseToOpenAI", { enumerable: true, get: function () { return openaiCompat_1.convertCopilotResponseToOpenAI; } });
+Object.defineProperty(exports, "parseOpenAIRequest", { enumerable: true, get: function () { return openaiCompat_1.parseOpenAIRequest; } });
+Object.defineProperty(exports, "debugLog", { enumerable: true, get: function () { return openaiCompat_1.debugLog; } });

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

@@ -0,0 +1,95 @@
+import { IDataObject, IExecuteFunctions } from "n8n-workflow";
+export interface OpenAIMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    name?: string;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+}
+export interface ToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface OpenAITool {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: IDataObject;
+    };
+}
+export interface OpenAIRequest {
+    model: string;
+    messages: OpenAIMessage[];
+    tools?: OpenAITool[];
+    tool_choice?: "auto" | "none" | "required" | {
+        type: "function";
+        function: {
+            name: string;
+        };
+    };
+    response_format?: {
+        type: "text" | "json_object";
+    };
+    temperature?: number;
+    max_tokens?: number;
+    top_p?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    stop?: string | string[];
+    stream?: boolean;
+    seed?: number;
+    user?: string;
+}
+export interface OpenAIResponse {
+    id: string;
+    object: "chat.completion";
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        message: {
+            role: "assistant";
+            content: string | null;
+            tool_calls?: ToolCall[];
+        };
+        finish_reason: "stop" | "length" | "tool_calls" | "content_filter";
+    }>;
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+export interface CopilotRequest {
+    model: string;
+    message: string;
+    system_message?: string;
+    temperature?: number;
+    max_tokens?: number;
+    tools?: OpenAITool[];
+    tool_choice?: string;
+}
+export interface CopilotResponse {
+    message: string;
+    model: string;
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    finish_reason: string;
+    tool_calls?: ToolCall[];
+}
+export declare function mapOpenAIModelToCopilot(openaiModel: string): string;
+export declare function convertOpenAIMessagesToCopilot(messages: OpenAIMessage[]): {
+    message: string;
+    system_message?: string;
+};
+export declare function convertCopilotResponseToOpenAI(copilotResponse: CopilotResponse, model: string): OpenAIResponse;
+export declare function parseOpenAIRequest(context: IExecuteFunctions, itemIndex: number): OpenAIRequest;
+export declare function debugLog(context: IExecuteFunctions, itemIndex: number, message: string, data?: unknown): void;