n8n-nodes-github-copilot 4.2.1 → 4.4.0

package/dist/nodes/GitHubCopilotOpenAI/nodeProperties.js

@@ -27,15 +27,15 @@ exports.nodeProperties = [
         displayName: 'Messages (JSON)',
         name: 'messagesJson',
         type: 'json',
-        default: `[
-  {
-    "role": "system",
-    "content": "You are a helpful assistant."
-  },
-  {
-    "role": "user",
-    "content": "Hello!"
-  }
+        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": "..."}]',
@@ -255,24 +255,24 @@ exports.nodeProperties = [
                 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"]
-      }
-    }
-  }
+                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). 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.",
@@ -351,6 +351,43 @@ exports.nodeProperties = [
                 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. Enable this if you want to send images but your primary model does not support vision.',
+            },
+            {
+                displayName: 'Vision Fallback Model',
+                name: 'visionFallbackModel',
+                type: 'options',
+                typeOptions: {
+                    loadOptionsMethod: 'getVisionFallbackModels',
+                },
+                default: '',
+                description: 'Select a vision-capable model to use when processing images with a non-vision primary model',
+                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/GitHubCopilotPGVector/GitHubCopilotPGVector.node.d.ts

@@ -0,0 +1,10 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription, ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
+export declare class GitHubCopilotPGVector implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getAvailableEmbeddingModels(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/GitHubCopilotPGVector/GitHubCopilotPGVector.node.js

@@ -0,0 +1,421 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHubCopilotPGVector = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const OAuthTokenManager_1 = require("../../shared/utils/OAuthTokenManager");
+const GitHubCopilotEndpoints_1 = require("../../shared/utils/GitHubCopilotEndpoints");
+const DynamicModelLoader_1 = require("../../shared/models/DynamicModelLoader");
+const EmbeddingsApiUtils_1 = require("../../shared/utils/EmbeddingsApiUtils");
+class GitHubCopilotPGVector {
+    constructor() {
+        this.description = {
+            displayName: 'GitHub Copilot PGVector',
+            name: 'gitHubCopilotPGVector',
+            icon: 'file:../../shared/icons/copilot.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: 'GitHub Copilot Embeddings for Postgres PGVector Store',
+            defaults: {
+                name: 'GitHub Copilot PGVector',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'githubCopilotApi',
+                    required: true,
+                },
+                {
+                    name: 'postgres',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Insert Documents',
+                            value: 'insert',
+                            description: 'Insert documents with embeddings into PGVector',
+                            action: 'Insert documents into PGVector',
+                        },
+                        {
+                            name: 'Search Similar',
+                            value: 'search',
+                            description: 'Search for similar documents using vector similarity',
+                            action: 'Search similar documents',
+                        },
+                        {
+                            name: 'Create Table',
+                            value: 'createTable',
+                            description: 'Create PGVector table with embeddings column',
+                            action: 'Create PGVector table',
+                        },
+                    ],
+                    default: 'insert',
+                },
+                {
+                    displayName: 'Embedding Model',
+                    name: 'model',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getAvailableEmbeddingModels',
+                    },
+                    options: [
+                        {
+                            name: 'Text Embedding 3 Small',
+                            value: 'text-embedding-3-small',
+                            description: "OpenAI's text-embedding-3-small model (recommended)",
+                        },
+                        {
+                            name: 'Text Embedding Ada 002',
+                            value: 'text-embedding-ada-002',
+                            description: 'Legacy embedding model',
+                        },
+                    ],
+                    default: 'text-embedding-3-small',
+                    description: 'Embedding model to use',
+                },
+                {
+                    displayName: 'Table Name',
+                    name: 'tableName',
+                    type: 'string',
+                    default: 'documents',
+                    required: true,
+                    placeholder: 'documents',
+                    description: 'Name of the PGVector table',
+                    displayOptions: {
+                        show: {
+                            operation: ['insert', 'search', 'createTable'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Text Field',
+                    name: 'textField',
+                    type: 'string',
+                    default: 'text',
+                    required: true,
+                    placeholder: 'text',
+                    description: 'Field name containing the text to embed',
+                    displayOptions: {
+                        show: {
+                            operation: ['insert'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Metadata Fields',
+                    name: 'metadataFields',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'title,author,date',
+                    description: 'Comma-separated list of metadata fields to store (optional)',
+                    displayOptions: {
+                        show: {
+                            operation: ['insert'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Query Text',
+                    name: 'queryText',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    placeholder: 'Search query text',
+                    description: 'Text to search for similar documents',
+                    displayOptions: {
+                        show: {
+                            operation: ['search'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'limit',
+                    type: 'number',
+                    default: 10,
+                    description: 'Maximum number of results to return',
+                    displayOptions: {
+                        show: {
+                            operation: ['search'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Distance Threshold',
+                    name: 'distanceThreshold',
+                    type: 'number',
+                    default: 1.0,
+                    description: 'Maximum cosine distance for results (0-2, lower is more similar)',
+                    displayOptions: {
+                        show: {
+                            operation: ['search'],
+                        },
+                    },
+                    typeOptions: {
+                        minValue: 0,
+                        maxValue: 2,
+                        numberPrecision: 2,
+                    },
+                },
+                {
+                    displayName: 'Vector Dimensions',
+                    name: 'vectorDimensions',
+                    type: 'number',
+                    default: 1536,
+                    description: 'Number of dimensions for the embedding vector',
+                    displayOptions: {
+                        show: {
+                            operation: ['createTable'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Dimensions',
+                            name: 'dimensions',
+                            type: 'number',
+                            default: 1536,
+                            description: 'The number of dimensions for the embedding (text-embedding-3-small supports 512-1536)',
+                            typeOptions: {
+                                minValue: 1,
+                                maxValue: 1536,
+                            },
+                        },
+                        {
+                            displayName: 'Embedding Column Name',
+                            name: 'embeddingColumn',
+                            type: 'string',
+                            default: 'embedding',
+                            description: 'Name of the column storing embeddings',
+                        },
+                        {
+                            displayName: 'ID Column Name',
+                            name: 'idColumn',
+                            type: 'string',
+                            default: 'id',
+                            description: 'Name of the ID column',
+                        },
+                        {
+                            displayName: 'Text Column Name',
+                            name: 'textColumn',
+                            type: 'string',
+                            default: 'content',
+                            description: 'Name of the column storing text content',
+                        },
+                        {
+                            displayName: 'Batch Size',
+                            name: 'batchSize',
+                            type: 'number',
+                            default: 10,
+                            description: 'Number of documents to process in each batch',
+                            typeOptions: {
+                                minValue: 1,
+                                maxValue: 100,
+                            },
+                        },
+                        {
+                            displayName: 'Enable Retry',
+                            name: 'enableRetry',
+                            type: 'boolean',
+                            default: true,
+                            description: 'Whether to retry on TPM quota errors (403)',
+                        },
+                    ],
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getAvailableEmbeddingModels() {
+                    return await DynamicModelLoader_1.loadAvailableEmbeddingModels.call(this);
+                },
+            },
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const operation = this.getNodeParameter('operation', 0);
+        const postgresCredentials = await this.getCredentials('postgres', 0);
+        const githubCredentials = await this.getCredentials('githubCopilotApi', 0);
+        const githubToken = githubCredentials.token;
+        if (!GitHubCopilotEndpoints_1.GitHubCopilotEndpoints.validateToken(githubToken)) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Invalid GitHub token format. Token must start with 'gho_' or 'github_pat_'");
+        }
+        const oauthToken = await OAuthTokenManager_1.OAuthTokenManager.getValidOAuthToken(githubToken);
+        const tableName = this.getNodeParameter('tableName', 0);
+        const model = this.getNodeParameter('model', 0);
+        const options = this.getNodeParameter('options', 0, {});
+        const { Client } = require('pg');
+        const pgClient = new Client({
+            host: postgresCredentials.host,
+            port: postgresCredentials.port,
+            user: postgresCredentials.user,
+            password: postgresCredentials.password,
+            database: postgresCredentials.database,
+        });
+        try {
+            await pgClient.connect();
+            switch (operation) {
+                case 'createTable': {
+                    const vectorDimensions = this.getNodeParameter('vectorDimensions', 0);
+                    const embeddingColumn = options.embeddingColumn || 'embedding';
+                    const idColumn = options.idColumn || 'id';
+                    const textColumn = options.textColumn || 'content';
+                    await pgClient.query('CREATE EXTENSION IF NOT EXISTS vector');
+                    const createTableQuery = `
+						CREATE TABLE IF NOT EXISTS ${tableName} (
+							${idColumn} SERIAL PRIMARY KEY,
+							${textColumn} TEXT NOT NULL,
+							metadata JSONB,
+							${embeddingColumn} vector(${vectorDimensions}),
+							created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+						);
+						
+						CREATE INDEX IF NOT EXISTS ${tableName}_${embeddingColumn}_idx 
+						ON ${tableName} USING ivfflat (${embeddingColumn} vector_cosine_ops)
+						WITH (lists = 100);
+					`;
+                    await pgClient.query(createTableQuery);
+                    returnData.push({
+                        json: {
+                            success: true,
+                            message: `Table ${tableName} created with ${vectorDimensions} dimensions`,
+                            table: tableName,
+                            dimensions: vectorDimensions,
+                        },
+                    });
+                    break;
+                }
+                case 'insert': {
+                    const textField = this.getNodeParameter('textField', 0);
+                    const metadataFieldsStr = this.getNodeParameter('metadataFields', 0, '');
+                    const metadataFields = metadataFieldsStr
+                        ? metadataFieldsStr.split(',').map((f) => f.trim())
+                        : [];
+                    const batchSize = options.batchSize || 10;
+                    const embeddingColumn = options.embeddingColumn || 'embedding';
+                    const textColumn = options.textColumn || 'content';
+                    const dimensions = options.dimensions;
+                    for (let i = 0; i < items.length; i += batchSize) {
+                        const batch = items.slice(i, Math.min(i + batchSize, items.length));
+                        const texts = batch.map((item) => String(item.json[textField]));
+                        const requestBody = {
+                            model,
+                            input: texts,
+                        };
+                        if (dimensions) {
+                            requestBody.dimensions = dimensions;
+                        }
+                        const embeddingResponse = await (0, EmbeddingsApiUtils_1.executeEmbeddingsRequest)(oauthToken, requestBody, options.enableRetry !== false, 3);
+                        for (let j = 0; j < batch.length; j++) {
+                            const item = batch[j];
+                            const embedding = embeddingResponse.data[j].embedding;
+                            const text = texts[j];
+                            const metadata = {};
+                            metadataFields.forEach((field) => {
+                                if (item.json[field] !== undefined) {
+                                    metadata[field] = item.json[field];
+                                }
+                            });
+                            const insertQuery = `
+								INSERT INTO ${tableName} (${textColumn}, metadata, ${embeddingColumn})
+								VALUES ($1, $2, $3)
+								RETURNING *
+							`;
+                            const result = await pgClient.query(insertQuery, [
+                                text,
+                                JSON.stringify(metadata),
+                                `[${embedding.join(',')}]`,
+                            ]);
+                            returnData.push({
+                                json: {
+                                    success: true,
+                                    id: result.rows[0].id,
+                                    text: text.substring(0, 100) + (text.length > 100 ? '...' : ''),
+                                    dimensions: embedding.length,
+                                },
+                                pairedItem: { item: i + j },
+                            });
+                        }
+                    }
+                    break;
+                }
+                case 'search': {
+                    const queryText = this.getNodeParameter('queryText', 0);
+                    const limit = this.getNodeParameter('limit', 0);
+                    const distanceThreshold = this.getNodeParameter('distanceThreshold', 0);
+                    const embeddingColumn = options.embeddingColumn || 'embedding';
+                    const textColumn = options.textColumn || 'content';
+                    const dimensions = options.dimensions;
+                    const requestBody = {
+                        model,
+                        input: [queryText],
+                    };
+                    if (dimensions) {
+                        requestBody.dimensions = dimensions;
+                    }
+                    const embeddingResponse = await (0, EmbeddingsApiUtils_1.executeEmbeddingsRequest)(oauthToken, requestBody, options.enableRetry !== false, 3);
+                    const queryEmbedding = embeddingResponse.data[0].embedding;
+                    const searchQuery = `
+						SELECT 
+							*,
+							(${embeddingColumn} <=> $1::vector) as distance
+						FROM ${tableName}
+						WHERE (${embeddingColumn} <=> $1::vector) < $2
+						ORDER BY ${embeddingColumn} <=> $1::vector
+						LIMIT $3
+					`;
+                    const searchResult = await pgClient.query(searchQuery, [
+                        `[${queryEmbedding.join(',')}]`,
+                        distanceThreshold,
+                        limit,
+                    ]);
+                    searchResult.rows.forEach((row) => {
+                        returnData.push({
+                            json: {
+                                id: row.id,
+                                text: row[textColumn],
+                                metadata: row.metadata,
+                                distance: row.distance,
+                                similarity: 1 - row.distance / 2,
+                            },
+                        });
+                    });
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            if (this.continueOnFail()) {
+                returnData.push({
+                    json: {
+                        error: error instanceof Error ? error.message : 'Unknown error occurred',
+                    },
+                });
+            }
+            else {
+                throw error;
+            }
+        }
+        finally {
+            await pgClient.end();
+        }
+        return [returnData];
+    }
+}
+exports.GitHubCopilotPGVector = GitHubCopilotPGVector;

package/dist/package.json

@@ -1,7 +1,7 @@
 {
     "name": "n8n-nodes-github-copilot",
-    "version": "4.2.1",
-    "description": "n8n community node for GitHub Copilot with CLI, Chat API, AI Chat Model, and n8n v2 Chat Hub integration - access GPT-5, Claude Sonnet 4.5, Gemini and more using your Copilot subscription",
+    "version": "4.4.0",
+    "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",
     "author": {
@@ -21,8 +21,7 @@
         "prepublishOnly": "npm run build"
     },
     "files": [
-        "dist",
-        "shared"
+        "dist"
     ],
     "n8n": {
         "n8nNodesApiVersion": 1,

package/dist/shared/models/DynamicModelLoader.d.ts

@@ -1,3 +1,4 @@
 import { ILoadOptionsFunctions, INodePropertyOptions } from "n8n-workflow";
 export declare function loadAvailableModels(this: ILoadOptionsFunctions, forceRefresh?: boolean): Promise<INodePropertyOptions[]>;
+export declare function loadAvailableVisionModels(this: ILoadOptionsFunctions, forceRefresh?: boolean): Promise<INodePropertyOptions[]>;
 export declare function loadAvailableEmbeddingModels(this: ILoadOptionsFunctions, forceRefresh?: boolean): Promise<INodePropertyOptions[]>;

package/dist/shared/models/DynamicModelLoader.js

@@ -1,12 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadAvailableModels = loadAvailableModels;
+exports.loadAvailableVisionModels = loadAvailableVisionModels;
 exports.loadAvailableEmbeddingModels = loadAvailableEmbeddingModels;
 const DynamicModelsManager_1 = require("../utils/DynamicModelsManager");
 const OAuthTokenManager_1 = require("../utils/OAuthTokenManager");
 async function loadAvailableModels(forceRefresh = false) {
     return loadModelsWithFilter.call(this, "chat", forceRefresh);
 }
+async function loadAvailableVisionModels(forceRefresh = false) {
+    const allOptions = await loadModelsWithFilter.call(this, "chat", forceRefresh);
+    const visionOptions = allOptions.filter((opt) => { var _a; return opt.name.includes("👁️") || ((_a = opt.description) === null || _a === void 0 ? void 0 : _a.includes("Vision")); });
+    const manualOption = {
+        name: "✏️ Enter Custom Model Name",
+        value: "__manual__",
+        description: "Type your own model name (for new/beta models)",
+    };
+    const hasManual = visionOptions.some((o) => o.value === "__manual__");
+    return hasManual ? visionOptions : [manualOption, ...visionOptions];
+}
 async function loadAvailableEmbeddingModels(forceRefresh = false) {
     return loadModelsWithFilter.call(this, "embeddings", forceRefresh);
 }

package/dist/shared/models/GitHubCopilotModels.d.ts

@@ -5,8 +5,8 @@ export interface ModelCapability {
     maxContextTokens: number;
     maxOutputTokens: number;
     streaming: boolean;
-    provider: "OpenAI" | "Anthropic" | "Google" | "Microsoft";
-    category: "chat" | "reasoning" | "coding" | "vision" | "multimodal";
+    provider: "OpenAI" | "Anthropic" | "Google" | "Microsoft" | "xAI";
+    category: "chat" | "reasoning" | "coding" | "vision" | "multimodal" | "versatile" | "powerful" | "lightweight";
 }
 export interface GitHubCopilotModel {
     value: string;
@@ -15,16 +15,19 @@ export interface GitHubCopilotModel {
     capabilities: ModelCapability;
     recommended: boolean;
     status: "stable" | "preview" | "experimental";
+    isPremium?: boolean;
 }
 export declare const GITHUB_COPILOT_MODELS: GitHubCopilotModel[];
 export declare class GitHubCopilotModelsManager {
     static getAllModels(): GitHubCopilotModel[];
     static getToolsCapableModels(): GitHubCopilotModel[];
     static getVisionCapableModels(): GitHubCopilotModel[];
-    static getModelsByProvider(provider: "OpenAI" | "Anthropic" | "Google" | "Microsoft"): GitHubCopilotModel[];
-    static getModelsByCategory(category: "chat" | "reasoning" | "coding" | "vision" | "multimodal"): GitHubCopilotModel[];
+    static getModelsByProvider(provider: "OpenAI" | "Anthropic" | "Google" | "Microsoft" | "xAI"): GitHubCopilotModel[];
+    static getModelsByCategory(category: "chat" | "reasoning" | "coding" | "vision" | "multimodal" | "versatile" | "powerful" | "lightweight"): GitHubCopilotModel[];
     static getRecommendedModels(): GitHubCopilotModel[];
     static getStableModels(): GitHubCopilotModel[];
+    static getFreeModels(): GitHubCopilotModel[];
+    static getPremiumModels(): GitHubCopilotModel[];
     static getModelByValue(value: string): GitHubCopilotModel | undefined;
     static toN8nOptions(models?: GitHubCopilotModel[]): Array<{
         name: string;
@@ -34,10 +37,13 @@ export declare class GitHubCopilotModelsManager {
     static getModelsForUseCase(useCase: "general" | "coding" | "vision" | "reasoning" | "tools"): GitHubCopilotModel[];
 }
 export declare const DEFAULT_MODELS: {
-    readonly GENERAL: "gpt-4o-mini";
-    readonly CODING: "o3-mini";
+    readonly GENERAL: "gpt-4.1";
+    readonly CODING: "gpt-5-codex";
     readonly VISION: "gpt-4o";
-    readonly REASONING: "claude-sonnet-4";
-    readonly TOOLS: "gpt-5";
+    readonly VISION_FALLBACK: "gpt-4.1";
+    readonly REASONING: "o3-mini";
+    readonly TOOLS: "gpt-4.1";
     readonly MULTIMODAL: "gemini-2.5-pro";
+    readonly FREE: "gpt-4.1";
+    readonly PREMIUM: "gpt-5.2";
 };