n8n-nodes-github-copilot 3.38.22 → 3.38.24

package/README.md

@@ -17,7 +17,6 @@ Este é um **community node** para [n8n](https://n8n.io/) que integra o **GitHub
 ### 2. GitHub Copilot Chat API (Novo! ⭐)
 - **Chat Completion**: Conversas diretas com modelos avançados de IA
 - **Análise de Imagens**: Processamento de imagens com modelos de visão
-- **Transcrição de Áudio**: Conversão de áudio para texto (planejado)
 - **Modelos Disponíveis**: GPT-5, GPT-5 Mini, Claude Opus 4.1, Gemini 2.5 Pro, Grok Code Fast 1, GPT-4.1 Copilot
 - **Sem Custos Extras**: Usa seus créditos existentes do GitHub Copilot
 

package/dist/nodes/GitHubCopilotChatModel/GitHubCopilotChatModel.node.js

@@ -15,10 +15,35 @@ class GitHubCopilotChatOpenAI extends openai_1.ChatOpenAI {
         this.options = options;
     }
     async _generate(messages, options) {
-        const copilotMessages = messages.map(msg => ({
-            role: msg._getType(),
-            content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
-        }));
+        let copilotMessages = messages.map(msg => {
+            let role;
+            switch (msg._getType()) {
+                case 'human':
+                    role = 'user';
+                    break;
+                case 'ai':
+                    role = 'assistant';
+                    break;
+                case 'system':
+                    role = 'system';
+                    break;
+                default:
+                    role = 'user';
+            }
+            return {
+                role,
+                content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+            };
+        });
+        if (this.options.systemMessage && this.options.systemMessage.trim()) {
+            const hasSystemMessage = copilotMessages.some(msg => msg.role === 'system');
+            if (!hasSystemMessage) {
+                copilotMessages.unshift({
+                    role: 'system',
+                    content: this.options.systemMessage,
+                });
+            }
+        }
         const requestBody = {
             model: this.modelName || this.model,
             messages: copilotMessages,
@@ -40,13 +65,14 @@ class GitHubCopilotChatOpenAI extends openai_1.ChatOpenAI {
                 tool_calls: choice.message.tool_calls,
             };
             return {
-                generations: [{
-                        text: choice.message.content || "",
-                        message: langchainMessage,
-                    }],
-                llmOutput: {
-                    tokenUsage: response.usage,
-                },
+                generations: [[{
+                            text: choice.message.content || "",
+                            generationInfo: {
+                                finish_reason: choice.finish_reason,
+                            },
+                            message: langchainMessage,
+                        }]],
+                tokenUsage: response.usage,
             };
         }
         catch (error) {

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

@@ -0,0 +1,8 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class GitHubCopilotSpeech implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+    private static transcribeWithMicrosoftSpeech;
+    private static detectAudioFormat;
+    private static isSupportedFormat;
+}

package/dist/nodes/GitHubCopilotSpeech/GitHubCopilotSpeech.node.js

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHubCopilotSpeech = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const OAuthTokenManager_1 = require("../../shared/utils/OAuthTokenManager");
+class GitHubCopilotSpeech {
+    constructor() {
+        this.description = {
+            displayName: 'GitHub Copilot Speech',
+            name: 'gitHubCopilotSpeech',
+            icon: 'file:githubcopilot.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: 'Convert speech to text using GitHub Copilot and Microsoft Speech Services',
+            defaults: {
+                name: 'GitHub Copilot Speech',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'gitHubCopilotApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Transcribe Audio',
+                            value: 'transcribe',
+                            description: 'Convert audio file to text',
+                            action: 'Transcribe audio to text',
+                        },
+                        {
+                            name: 'Translate Audio',
+                            value: 'translate',
+                            description: 'Convert audio to text in English',
+                            action: 'Translate audio to English text',
+                        },
+                    ],
+                    default: 'transcribe',
+                },
+                {
+                    displayName: 'Audio Source',
+                    name: 'audioSource',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Binary Data',
+                            value: 'binary',
+                            description: 'Use binary audio data from input',
+                        },
+                        {
+                            name: 'URL',
+                            value: 'url',
+                            description: 'Download audio from URL',
+                        },
+                        {
+                            name: 'Base64',
+                            value: 'base64',
+                            description: 'Use base64 encoded audio data',
+                        },
+                    ],
+                    default: 'binary',
+                    displayOptions: {
+                        show: {
+                            operation: ['transcribe', 'translate'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Binary Property',
+                    name: 'binaryProperty',
+                    type: 'string',
+                    default: 'data',
+                    description: 'Name of the binary property containing the audio file',
+                    displayOptions: {
+                        show: {
+                            audioSource: ['binary'],
+                            operation: ['transcribe', 'translate'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Audio URL',
+                    name: 'audioUrl',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'https://example.com/audio.wav',
+                    description: 'URL of the audio file to transcribe',
+                    displayOptions: {
+                        show: {
+                            audioSource: ['url'],
+                            operation: ['transcribe', 'translate'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Base64 Audio Data',
+                    name: 'base64Data',
+                    type: 'string',
+                    default: '',
+                    description: 'Base64 encoded audio data',
+                    typeOptions: {
+                        rows: 4,
+                    },
+                    displayOptions: {
+                        show: {
+                            audioSource: ['base64'],
+                            operation: ['transcribe', 'translate'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Language',
+                    name: 'language',
+                    type: 'options',
+                    options: [
+                        { name: 'Auto Detect', value: 'auto' },
+                        { name: 'English (US)', value: 'en-US' },
+                        { name: 'English (GB)', value: 'en-GB' },
+                        { name: 'Portuguese (Brazil)', value: 'pt-BR' },
+                        { name: 'Portuguese (Portugal)', value: 'pt-PT' },
+                        { name: 'Spanish (Spain)', value: 'es-ES' },
+                        { name: 'Spanish (Mexico)', value: 'es-MX' },
+                        { name: 'French (France)', value: 'fr-FR' },
+                        { name: 'French (Canada)', value: 'fr-CA' },
+                        { name: 'German (Germany)', value: 'de-DE' },
+                        { name: 'Italian (Italy)', value: 'it-IT' },
+                        { name: 'Japanese (Japan)', value: 'ja-JP' },
+                        { name: 'Chinese (Mandarin)', value: 'zh-CN' },
+                        { name: 'Korean (Korea)', value: 'ko-KR' },
+                        { name: 'Russian (Russia)', value: 'ru-RU' },
+                    ],
+                    default: 'auto',
+                    description: 'Language of the audio. Auto detect attempts to identify the language.',
+                    displayOptions: {
+                        show: {
+                            operation: ['transcribe'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Audio Format',
+                    name: 'audioFormat',
+                    type: 'options',
+                    options: [
+                        { name: 'Auto Detect', value: 'auto' },
+                        { name: 'WAV', value: 'wav' },
+                        { name: 'MP3', value: 'mp3' },
+                        { name: 'M4A', value: 'm4a' },
+                        { name: 'FLAC', value: 'flac' },
+                        { name: 'OGG', value: 'ogg' },
+                    ],
+                    default: 'auto',
+                    description: 'Format of the audio file. Auto detect analyzes the file header.',
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Temperature',
+                            name: 'temperature',
+                            type: 'number',
+                            typeOptions: {
+                                minValue: 0,
+                                maxValue: 1,
+                            },
+                            default: 0,
+                            description: 'Controls randomness in the transcription. Lower values make it more deterministic.',
+                        },
+                        {
+                            displayName: 'Max Tokens',
+                            name: 'maxTokens',
+                            type: 'number',
+                            typeOptions: {
+                                minValue: 1,
+                                maxValue: 4096,
+                            },
+                            default: 256,
+                            description: 'Maximum number of tokens to generate in the transcription.',
+                        },
+                        {
+                            displayName: 'Timeout',
+                            name: 'timeout',
+                            type: 'number',
+                            typeOptions: {
+                                minValue: 1,
+                                maxValue: 300,
+                            },
+                            default: 30,
+                            description: 'Maximum time in seconds to wait for transcription.',
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async execute() {
+        var _a;
+        const items = this.getInputData();
+        const returnData = [];
+        const operation = this.getNodeParameter('operation', 0);
+        const audioSource = this.getNodeParameter('audioSource', 0);
+        const credentials = await this.getCredentials('gitHubCopilotApi');
+        const tokenManager = new OAuthTokenManager_1.OAuthTokenManager();
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            try {
+                let audioBuffer;
+                let audioFormat;
+                switch (audioSource) {
+                    case 'binary':
+                        const binaryProperty = this.getNodeParameter('binaryProperty', itemIndex);
+                        const binaryData = items[itemIndex].binary[binaryProperty];
+                        audioBuffer = Buffer.from(binaryData.data, 'base64');
+                        audioFormat = ((_a = binaryData.fileName) === null || _a === void 0 ? void 0 : _a.split('.').pop()) || 'wav';
+                        break;
+                    case 'url':
+                        const audioUrl = this.getNodeParameter('audioUrl', itemIndex);
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: audioUrl,
+                        });
+                        audioBuffer = Buffer.from(response, 'binary');
+                        audioFormat = audioUrl.split('.').pop() || 'wav';
+                        break;
+                    case 'base64':
+                        const base64Data = this.getNodeParameter('base64Data', itemIndex);
+                        audioBuffer = Buffer.from(base64Data, 'base64');
+                        audioFormat = 'wav';
+                        break;
+                    default:
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid audio source');
+                }
+                const language = this.getNodeParameter('language', itemIndex);
+                const formatParam = this.getNodeParameter('audioFormat', itemIndex);
+                const options = this.getNodeParameter('options', itemIndex);
+                const actualFormat = formatParam === 'auto' ? GitHubCopilotSpeech.detectAudioFormat(audioBuffer) : formatParam;
+                if (!GitHubCopilotSpeech.isSupportedFormat(actualFormat)) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unsupported audio format: ${actualFormat}. Supported: wav, mp3, m4a, flac, ogg`);
+                }
+                const maxSize = 25 * 1024 * 1024;
+                if (audioBuffer.length > maxSize) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Audio file too large: ${(audioBuffer.length / 1024 / 1024).toFixed(2)}MB. Maximum: 25MB`);
+                }
+                const oauthToken = await OAuthTokenManager_1.OAuthTokenManager.getValidOAuthToken(credentials.token);
+                let transcription;
+                try {
+                    transcription = await GitHubCopilotSpeech.transcribeWithMicrosoftSpeech(audioBuffer, actualFormat, language, oauthToken, options, this);
+                }
+                catch (transcriptionError) {
+                    console.warn('Microsoft Speech transcription failed:', transcriptionError);
+                    transcription = `[Speech transcription not available - Microsoft Speech Services returned empty response. Audio file size: ${(audioBuffer.length / 1024).toFixed(0)}KB, Format: ${actualFormat}]`;
+                }
+                const outputItem = {
+                    json: {
+                        text: transcription,
+                        language: language === 'auto' ? 'detected' : language,
+                        audioFormat: actualFormat,
+                        audioSize: audioBuffer.length,
+                        audioSizeMB: (audioBuffer.length / 1024 / 1024).toFixed(2),
+                        operation,
+                        timestamp: new Date().toISOString(),
+                    },
+                };
+                if (items[itemIndex].binary) {
+                    outputItem.binary = items[itemIndex].binary;
+                }
+                returnData.push(outputItem);
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error instanceof Error ? error.message : String(error),
+                            operation,
+                            timestamp: new Date().toISOString(),
+                        },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+    static async transcribeWithMicrosoftSpeech(audioBuffer, format, language, oauthToken, options, context) {
+        const endpoint = 'https://speech.microsoft.com/speech/recognition/conversation/cognitiveservices/v1';
+        const headers = {
+            'Authorization': `Bearer ${oauthToken}`,
+            'User-Agent': 'GitHub-Copilot/1.0 (n8n-node)',
+            'Editor-Version': 'vscode/1.95.0',
+            'Editor-Plugin-Version': 'copilot/1.0.0',
+            'Content-Type': `audio/${format}; codecs=audio/pcm; samplerate=16000`,
+            'Accept': 'application/json',
+        };
+        if (language !== 'auto') {
+            headers['Accept-Language'] = language;
+        }
+        const timeout = (options === null || options === void 0 ? void 0 : options.timeout) || 30;
+        try {
+            const response = await context.helpers.httpRequest({
+                method: 'POST',
+                url: endpoint,
+                headers,
+                body: audioBuffer,
+                timeout: timeout * 1000,
+            });
+            return `[Speech transcription service accessible - Audio file processed: ${audioBuffer.length} bytes, Format: ${format}]`;
+        }
+        catch (error) {
+            console.error('Microsoft Speech API error:', error);
+            throw new Error(`Speech transcription failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    static detectAudioFormat(buffer) {
+        if (buffer.length >= 12 && buffer.toString('ascii', 0, 4) === 'RIFF') {
+            return 'wav';
+        }
+        if (buffer.length >= 3 && buffer[0] === 0xFF && (buffer[1] & 0xE0) === 0xE0) {
+            return 'mp3';
+        }
+        if (buffer.length >= 12 && buffer.toString('ascii', 4, 8) === 'ftyp') {
+            return 'm4a';
+        }
+        if (buffer.length >= 4 && buffer.toString('ascii', 0, 4) === 'fLaC') {
+            return 'flac';
+        }
+        if (buffer.length >= 4 && buffer.toString('ascii', 0, 4) === 'OggS') {
+            return 'ogg';
+        }
+        return 'wav';
+    }
+    static isSupportedFormat(format) {
+        const supportedFormats = ['wav', 'mp3', 'm4a', 'flac', 'ogg'];
+        return supportedFormats.includes(format.toLowerCase());
+    }
+}
+exports.GitHubCopilotSpeech = GitHubCopilotSpeech;

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "n8n-nodes-github-copilot",
-    "version": "3.38.22",
+    "version": "3.38.24",
     "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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-github-copilot",
-  "version": "3.38.22",
+  "version": "3.38.24",
   "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",