n8n-nodes-github-copilot 3.4.0 → 3.5.0

package/dist/nodes/GitHubCopilotChatAPI/utils/audioProcessor.d.ts

@@ -1,11 +0,0 @@
-import { IExecuteFunctions } from 'n8n-workflow';
-import { ProcessedFileResult } from './types';
-export declare function processAudioFile(context: IExecuteFunctions, itemIndex: number, audioSource: string, audioFile?: string, audioUrl?: string, audioProperty?: string): Promise<ProcessedFileResult>;
-export declare function chunkAudioData(base64Data: string, maxChunkSize?: number): string[];
-export declare function optimizeAudioForTokens(base64Data: string, maxTokens?: number): {
-    data: string;
-    truncated: boolean;
-    originalTokens: number;
-    finalTokens: number;
-};
-export declare function createAudioSummary(filename: string, size: number, duration?: number): string;

package/dist/nodes/GitHubCopilotChatAPI/utils/audioProcessor.js

@@ -1,86 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAudioSummary = exports.optimizeAudioForTokens = exports.chunkAudioData = exports.processAudioFile = void 0;
-const helpers_1 = require("./helpers");
-async function processAudioFile(context, itemIndex, audioSource, audioFile, audioUrl, audioProperty) {
-    var _a, _b;
-    let audioBuffer;
-    let filename;
-    switch (audioSource) {
-        case 'file':
-            if (!audioFile) {
-                throw new Error('Audio file content is required when source is "file"');
-            }
-            audioBuffer = Buffer.from(audioFile, 'base64');
-            filename = 'uploaded_audio.mp3';
-            break;
-        case 'url':
-            if (!audioUrl) {
-                throw new Error('Audio URL is required when source is "url"');
-            }
-            audioBuffer = await (0, helpers_1.downloadFileFromUrl)(audioUrl);
-            filename = audioUrl.split('/').pop() || 'downloaded_audio.mp3';
-            break;
-        case 'binary':
-            if (!audioProperty) {
-                throw new Error('Audio property name is required when source is "binary"');
-            }
-            audioBuffer = await (0, helpers_1.getFileFromBinary)(context, itemIndex, audioProperty);
-            const items = context.getInputData();
-            const item = items[itemIndex];
-            filename = ((_b = (_a = item.binary) === null || _a === void 0 ? void 0 : _a[audioProperty]) === null || _b === void 0 ? void 0 : _b.fileName) || 'binary_audio.mp3';
-            break;
-        default:
-            throw new Error(`Invalid audio source: ${audioSource}`);
-    }
-    (0, helpers_1.validateFileSize)(audioBuffer, 25600);
-    const base64Audio = audioBuffer.toString('base64');
-    const estimatedTokens = (0, helpers_1.estimateTokens)(base64Audio);
-    if (estimatedTokens > 100000) {
-        throw new Error(`Audio file too large (${estimatedTokens} estimated tokens). Consider using a smaller file.`);
-    }
-    const mimeType = (0, helpers_1.getAudioMimeType)(filename);
-    return {
-        data: base64Audio,
-        mimeType,
-        filename,
-        size: audioBuffer.length,
-        estimatedTokens
-    };
-}
-exports.processAudioFile = processAudioFile;
-function chunkAudioData(base64Data, maxChunkSize = 50000) {
-    const chunks = [];
-    for (let i = 0; i < base64Data.length; i += maxChunkSize) {
-        chunks.push(base64Data.slice(i, i + maxChunkSize));
-    }
-    return chunks;
-}
-exports.chunkAudioData = chunkAudioData;
-function optimizeAudioForTokens(base64Data, maxTokens = 100000) {
-    const originalTokens = (0, helpers_1.estimateTokens)(base64Data);
-    if (originalTokens <= maxTokens) {
-        return {
-            data: base64Data,
-            truncated: false,
-            originalTokens,
-            finalTokens: originalTokens
-        };
-    }
-    const compressionRatio = maxTokens / originalTokens;
-    const targetLength = Math.floor(base64Data.length * compressionRatio);
-    const compressedData = base64Data.slice(0, Math.max(targetLength, 1000));
-    return {
-        data: compressedData,
-        truncated: true,
-        originalTokens,
-        finalTokens: (0, helpers_1.estimateTokens)(compressedData)
-    };
-}
-exports.optimizeAudioForTokens = optimizeAudioForTokens;
-function createAudioSummary(filename, size, duration) {
-    const sizeKB = Math.round(size / 1024);
-    const durationText = duration ? ` (${Math.round(duration)}s)` : '';
-    return `Audio file: ${filename} - ${sizeKB}KB${durationText}. File too large for direct processing, providing description instead.`;
-}
-exports.createAudioSummary = createAudioSummary;

package/dist/nodes/N8nAiAgent/N8nAiAgent.node.d.ts

@@ -1,5 +0,0 @@
-import { INodeType, INodeTypeDescription } from 'n8n-workflow';
-export declare class N8nAiAgent implements INodeType {
-    description: INodeTypeDescription;
-    supplyData(this: any, itemIndex: number): Promise<any>;
-}

package/dist/nodes/N8nAiAgent/N8nAiAgent.node.js

@@ -1,152 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.N8nAiAgent = void 0;
-class N8nAiAgent {
-    constructor() {
-        this.description = {
-            displayName: 'N8N AI Agent Model',
-            name: 'n8nAiAgent',
-            icon: 'file:n8n-ai.svg',
-            group: ['transform'],
-            version: 1,
-            description: 'N8N AI Agent chat model for advanced AI capabilities with tool calling and memory',
-            defaults: {
-                name: 'N8N AI Agent Model',
-            },
-            codex: {
-                categories: ['AI'],
-                subcategories: {
-                    AI: ['Language Models', 'Root Nodes'],
-                    'Language Models': ['Chat Models (Recommended)'],
-                },
-                resources: {
-                    primaryDocumentation: [
-                        {
-                            url: 'https://docs.n8n.io/',
-                        },
-                    ],
-                },
-            },
-            inputs: [],
-            outputs: ["ai_languageModel"],
-            outputNames: ['Model'],
-            credentials: [
-                {
-                    name: 'n8nApi',
-                    required: true,
-                },
-            ],
-            properties: [
-                {
-                    displayName: 'Model',
-                    name: 'model',
-                    type: 'options',
-                    default: 'n8n-ai-agent',
-                    description: 'The N8N AI Agent model to use',
-                    options: [
-                        {
-                            name: 'N8N AI Agent',
-                            value: 'n8n-ai-agent',
-                            description: 'N8N AI Agent with tool calling and memory capabilities',
-                        },
-                        {
-                            name: 'N8N AI Agent Pro',
-                            value: 'n8n-ai-agent-pro',
-                            description: 'Enhanced version with advanced features',
-                        },
-                    ],
-                },
-                {
-                    displayName: 'Options',
-                    name: 'options',
-                    placeholder: 'Add Option',
-                    description: 'Additional options for the AI model',
-                    type: 'collection',
-                    default: {},
-                    options: [
-                        {
-                            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',
-                        },
-                        {
-                            displayName: 'Maximum Number of Tokens',
-                            name: 'maxTokens',
-                            default: 1000,
-                            description: 'The maximum number of tokens to generate',
-                            type: 'number',
-                            typeOptions: {
-                                maxValue: 32768,
-                            },
-                        },
-                        {
-                            displayName: 'Enable Tools',
-                            name: 'enableTools',
-                            type: 'boolean',
-                            default: false,
-                            description: 'Whether to enable tool calling capabilities',
-                        },
-                        {
-                            displayName: 'Enable Memory',
-                            name: 'enableMemory',
-                            type: 'boolean',
-                            default: false,
-                            description: 'Whether to enable conversation memory',
-                        },
-                    ],
-                },
-            ],
-        };
-    }
-    async supplyData(itemIndex) {
-        const credentials = await this.getCredentials('n8nApi');
-        const model = this.getNodeParameter('model', itemIndex);
-        const options = this.getNodeParameter('options', itemIndex, {});
-        const mockModel = {
-            _call: async (messages, options) => {
-                const apiKey = credentials.apiKey;
-                const baseUrl = credentials.baseUrl || 'http://localhost:5678';
-                const requestBody = {
-                    model: model,
-                    messages: messages,
-                    temperature: (options === null || options === void 0 ? void 0 : options.temperature) || 0.7,
-                    max_tokens: (options === null || options === void 0 ? void 0 : options.maxTokens) || 1000,
-                    tools: (options === null || options === void 0 ? void 0 : options.enableTools) || false,
-                    memory: (options === null || options === void 0 ? void 0 : options.enableMemory) || false,
-                };
-                try {
-                    const response = await fetch(`${baseUrl}/api/v1/ai-agent/chat`, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            'Authorization': `Bearer ${apiKey}`,
-                        },
-                        body: JSON.stringify(requestBody),
-                    });
-                    if (!response.ok) {
-                        throw new Error(`API request failed: ${response.statusText}`);
-                    }
-                    const result = await response.json();
-                    return result.response || result.message || 'No response from AI agent';
-                }
-                catch (error) {
-                    return `N8N AI Agent response using model: ${model} (${error instanceof Error ? error.message : 'Error'})`;
-                }
-            },
-            _modelType: 'chat_model',
-            _llmType: 'n8n-ai-agent',
-            modelName: model,
-            temperature: options.temperature || 0.7,
-            maxTokens: options.maxTokens || 1000,
-            enableTools: options.enableTools || false,
-            enableMemory: options.enableMemory || false,
-        };
-        return {
-            response: mockModel,
-        };
-    }
-}
-exports.N8nAiAgent = N8nAiAgent;