n8n-nodes-vercel-ai-sdk-universal-temp 0.2.71 → 0.2.73

package/dist/nodes/shared/builders/descriptions.js

@@ -1,713 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.COMMON_INPUT_TYPES = exports.COMMON_OPERATIONS = exports.COMMON_CREDENTIALS = exports.COMMON_PROVIDERS = exports.NodeDescriptionBuilder = void 0;
-class NodeDescriptionBuilder {
-    constructor(displayName, name, descriptionText, icon) {
-        this.description = {
-            version: 2,
-            group: ['transform'],
-            inputs: ['main'],
-            outputs: ['main'],
-            defaults: {},
-            credentials: [],
-            properties: [],
-        };
-        this.description.displayName = displayName;
-        this.description.name = name;
-        this.description.description = descriptionText;
-        this.description.icon = icon;
-        this.description.defaults = { name: displayName };
-        this.description.subtitle = `={{$parameter["provider"] + ": " + $parameter["model"]}}`;
-    }
-    addProviderCredentials(providerMap) {
-        const credentials = Object.entries(providerMap).map(([provider, credentialName]) => ({
-            name: credentialName,
-            required: false,
-            displayOptions: {
-                show: {
-                    provider: [provider],
-                },
-            },
-        }));
-        this.description.credentials = credentials;
-        return this;
-    }
-    addResourceProperty(resourceName, resourceValue) {
-        const resourceProperty = {
-            displayName: 'Resource',
-            name: 'resource',
-            type: 'options',
-            required: true,
-            options: [{
-                    name: resourceName,
-                    value: resourceValue,
-                }],
-            default: resourceValue,
-            description: 'The resource to operate on',
-        };
-        this.description.properties.push(resourceProperty);
-        return this;
-    }
-    addProviderProperty(providers, resourceFilter) {
-        var _a;
-        const providerProperty = {
-            displayName: 'Provider',
-            name: 'provider',
-            type: 'options',
-            required: true,
-            noDataExpression: true,
-            options: providers,
-            default: ((_a = providers[0]) === null || _a === void 0 ? void 0 : _a.value) || 'google',
-            description: 'Choose which AI provider to use',
-        };
-        if (resourceFilter) {
-            providerProperty.displayOptions = {
-                show: {
-                    resource: [resourceFilter],
-                },
-            };
-        }
-        this.description.properties.push(providerProperty);
-        return this;
-    }
-    addModelProperty(resourceFilter, predefinedModels) {
-        var _a;
-        const modelProperty = {
-            displayName: 'Model Name or ID',
-            name: 'model',
-            type: 'options',
-            required: true,
-            default: ((_a = predefinedModels === null || predefinedModels === void 0 ? void 0 : predefinedModels[0]) === null || _a === void 0 ? void 0 : _a.value) || '',
-            description: 'Select which model to use. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
-        };
-        if (predefinedModels) {
-            modelProperty.options = predefinedModels;
-        }
-        else {
-            modelProperty.typeOptions = {
-                loadOptionsMethod: 'getModels',
-                loadOptionsDependsOn: ['provider'],
-            };
-        }
-        if (resourceFilter) {
-            modelProperty.displayOptions = {
-                show: {
-                    resource: [resourceFilter],
-                },
-            };
-        }
-        this.description.properties.push(modelProperty);
-        return this;
-    }
-    addOperationProperty(operations) {
-        var _a;
-        const operationProperty = {
-            displayName: 'Operation',
-            name: 'operation',
-            type: 'options',
-            required: true,
-            noDataExpression: true,
-            options: operations,
-            default: ((_a = operations[0]) === null || _a === void 0 ? void 0 : _a.value) || '',
-            description: 'Which type of output you want to generate',
-        };
-        this.description.properties.push(operationProperty);
-        return this;
-    }
-    addInputTypeProperty(types) {
-        var _a;
-        const inputTypeProperty = {
-            displayName: 'Input Type',
-            name: 'inputType',
-            type: 'options',
-            required: true,
-            noDataExpression: true,
-            options: types,
-            default: ((_a = types[0]) === null || _a === void 0 ? void 0 : _a.value) || 'prompt',
-            description: 'Choose how you want to provide input to the model',
-        };
-        this.description.properties.push(inputTypeProperty);
-        return this;
-    }
-    addTextInputs() {
-        this.description.properties.push({
-            displayName: 'System',
-            name: 'system',
-            type: 'string',
-            typeOptions: { rows: 4 },
-            displayOptions: { show: { inputType: ['prompt'] } },
-            default: 'You are a helpful assistant.',
-            description: "System prompt that specifies the model's behavior",
-            hint: "This field is optional, but can help guide the model's responses.",
-            requiresDataPath: 'single',
-        });
-        this.description.properties.push({
-            displayName: 'Cache System Instruction',
-            name: 'cacheSystemInstruction',
-            type: 'boolean',
-            default: false,
-            displayOptions: { show: { inputType: ['prompt'] } },
-            description: 'Cache the system instruction to reduce costs when making multiple requests with the same system context. Requires minimum 1,024 tokens (roughly 700-800 words).',
-        });
-        this.description.properties.push({
-            displayName: 'Prompt',
-            name: 'prompt',
-            type: 'string',
-            typeOptions: { rows: 4 },
-            displayOptions: { show: { inputType: ['prompt'] } },
-            default: '',
-            required: true,
-            description: 'The single text prompt to generate a completion for',
-            hint: 'You can drag data from previous nodes here using expressions.',
-            requiresDataPath: 'single',
-        });
-        this.description.properties.push({
-            displayName: 'Cache Prompt',
-            name: 'cachePrompt',
-            type: 'boolean',
-            default: false,
-            displayOptions: { show: { inputType: ['prompt'] } },
-            description: 'Cache the prompt text. Only useful if this prompt will be reused across multiple requests with different parameters or context.',
-        });
-        return this;
-    }
-    addMessagesInput() {
-        this.description.properties.push({
-            displayName: 'Messages',
-            name: 'messages',
-            type: 'fixedCollection',
-            typeOptions: {
-                multipleValues: true,
-                sortable: true,
-                minValue: 1,
-            },
-            displayOptions: { show: { inputType: ['messages'] } },
-            description: 'The messages for the conversation',
-            default: {
-                messagesUi: [
-                    { role: 'system', systemContent: 'You are a helpful assistant.' },
-                    { role: 'user', content: 'How can you help me?' },
-                ],
-            },
-            required: true,
-            options: [{
-                    name: 'messagesUi',
-                    displayName: 'Message',
-                    values: [
-                        {
-                            displayName: 'Role',
-                            name: 'role',
-                            type: 'options',
-                            noDataExpression: true,
-                            options: [
-                                { name: 'Assistant', value: 'assistant' },
-                                { name: 'System', value: 'system' },
-                                { name: 'User', value: 'user' },
-                            ],
-                            default: 'user',
-                            required: true,
-                        },
-                        {
-                            displayName: 'Cache Message',
-                            name: 'cacheMessage',
-                            type: 'boolean',
-                            default: false,
-                            description: 'Cache this message content. Useful for static context that will be reused across multiple requests. Requires minimum 1,024 tokens total in cached content.',
-                            displayOptions: {
-                                show: {
-                                    role: ['system', 'assistant', 'user'],
-                                    '/provider': ['google'],
-                                    '/inputType': ['messages'],
-                                },
-                            },
-                        },
-                        {
-                            displayName: 'System Content',
-                            name: 'systemContent',
-                            type: 'string',
-                            description: 'The text content if role is System',
-                            required: true,
-                            displayOptions: { show: { role: ['system'] } },
-                            typeOptions: { rows: 4 },
-                            default: '',
-                            requiresDataPath: 'single',
-                        },
-                        {
-                            displayName: 'Text Content',
-                            name: 'content',
-                            type: 'string',
-                            typeOptions: { rows: 4 },
-                            displayOptions: { show: { role: ['assistant', 'user'] } },
-                            default: '',
-                            description: 'Primary text content of the message',
-                            required: true,
-                            requiresDataPath: 'single',
-                        },
-                    ],
-                }],
-        });
-        return this;
-    }
-    addOptionsCollection(options) {
-        this.description.properties.push({
-            displayName: 'Options',
-            name: 'options',
-            type: 'collection',
-            placeholder: 'Add Option',
-            default: {},
-            options,
-        });
-        return this;
-    }
-    addTextInput(displayName, name, description, required = false) {
-        const textProperty = {
-            displayName,
-            name,
-            type: 'string',
-            typeOptions: { rows: 4 },
-            default: '',
-            description,
-        };
-        if (required) {
-            textProperty.required = true;
-        }
-        this.description.properties.push(textProperty);
-        return this;
-    }
-    addVoiceProperty() {
-        const voiceProperty = {
-            displayName: 'Voice',
-            name: 'voice',
-            type: 'options',
-            required: true,
-            typeOptions: {
-                loadOptionsMethod: 'getVoices',
-                loadOptionsDependsOn: ['provider'],
-            },
-            default: '',
-            description: 'The voice to use for speech generation',
-        };
-        this.description.properties.push(voiceProperty);
-        return this;
-    }
-    addPromptInput() {
-        const promptProperty = {
-            displayName: 'Prompt',
-            name: 'prompt',
-            type: 'string',
-            typeOptions: { rows: 4 },
-            default: '',
-            required: true,
-            description: 'The single text prompt to generate a completion for',
-            hint: 'You can drag data from previous nodes here using expressions.',
-            requiresDataPath: 'single',
-        };
-        this.description.properties.push(promptProperty);
-        return this;
-    }
-    addAudioSourceProperty() {
-        const audioSourceProperty = {
-            displayName: 'Audio Source',
-            name: 'audioSource',
-            type: 'options',
-            required: true,
-            options: [
-                {
-                    name: 'Binary Data',
-                    value: 'binary',
-                    description: 'Use binary data from n8n input',
-                },
-                {
-                    name: 'URL',
-                    value: 'url',
-                    description: 'Provide a URL to the audio file',
-                },
-            ],
-            default: 'binary',
-            description: 'Where the audio file is coming from',
-        };
-        this.description.properties.push(audioSourceProperty);
-        return this;
-    }
-    addAudioProperty() {
-        const audioProperty = {
-            displayName: 'Audio Property',
-            name: 'audioProperty',
-            type: 'string',
-            default: 'data',
-            required: true,
-            displayOptions: {
-                show: {
-                    audioSource: ['binary'],
-                },
-            },
-            description: 'Name of the binary property containing the audio data',
-        };
-        this.description.properties.push(audioProperty);
-        return this;
-    }
-    addAudioUrlProperty() {
-        const audioUrlProperty = {
-            displayName: 'Audio URL',
-            name: 'audioUrl',
-            type: 'string',
-            default: '',
-            required: true,
-            displayOptions: {
-                show: {
-                    audioSource: ['url'],
-                },
-            },
-            description: 'URL of the audio file to transcribe',
-            requiresDataPath: 'single',
-        };
-        this.description.properties.push(audioUrlProperty);
-        return this;
-    }
-    addEmbeddingOperationProperty() {
-        const operationProperty = {
-            displayName: 'Operation',
-            name: 'operation',
-            type: 'options',
-            required: true,
-            options: [
-                {
-                    name: 'Embed Single',
-                    value: 'embedSingle',
-                    description: 'Generate embedding for a single text',
-                },
-                {
-                    name: 'Embed Many',
-                    value: 'embedMany',
-                    description: 'Generate embeddings for multiple texts',
-                },
-                {
-                    name: 'Cosine Similarity',
-                    value: 'cosineSimilarity',
-                    description: 'Calculate similarity between two embeddings',
-                },
-            ],
-            default: 'embedSingle',
-            description: 'The operation to perform',
-        };
-        this.description.properties.push(operationProperty);
-        return this;
-    }
-    addEmbeddingProperties() {
-        this.description.properties.push({
-            displayName: 'Text',
-            name: 'text',
-            type: 'string',
-            typeOptions: { rows: 4 },
-            default: '',
-            required: true,
-            displayOptions: { show: { operation: ['embedSingle'] } },
-            description: 'The text to generate an embedding for',
-        });
-        this.description.properties.push({
-            displayName: 'Texts',
-            name: 'texts',
-            type: 'string',
-            typeOptions: { rows: 6 },
-            default: '',
-            required: true,
-            displayOptions: { show: { operation: ['embedMany'] } },
-            description: 'Texts to generate embeddings for (one per line)',
-        });
-        this.description.properties.push({
-            displayName: 'Embedding 1',
-            name: 'embedding1',
-            type: 'string',
-            default: '',
-            required: true,
-            displayOptions: { show: { operation: ['cosineSimilarity'] } },
-            description: 'First embedding vector as JSON array (e.g., [0.1, 0.2, 0.3])',
-        });
-        this.description.properties.push({
-            displayName: 'Embedding 2',
-            name: 'embedding2',
-            type: 'string',
-            default: '',
-            required: true,
-            displayOptions: { show: { operation: ['cosineSimilarity'] } },
-            description: 'Second embedding vector as JSON array (e.g., [0.1, 0.2, 0.3])',
-        });
-        return this;
-    }
-    addSystemProperties() {
-        this.description.properties.push({
-            displayName: 'System',
-            name: 'system',
-            type: 'string',
-            typeOptions: { rows: 4 },
-            displayOptions: { show: { inputType: ['prompt'] } },
-            default: 'You are a helpful assistant.',
-            description: "System prompt that specifies the model's behavior",
-            hint: "This field is optional, but can help guide the model's responses.",
-            requiresDataPath: 'single',
-        });
-        this.description.properties.push({
-            displayName: 'Cache System Instruction',
-            name: 'cacheSystemInstruction',
-            type: 'boolean',
-            default: false,
-            displayOptions: { show: { inputType: ['prompt'] } },
-            description: 'Cache the system instruction to reduce costs when making multiple requests with the same system context. Requires minimum 1,024 tokens (roughly 700-800 words).',
-        });
-        return this;
-    }
-    addPromptProperties() {
-        this.description.properties.push({
-            displayName: 'Prompt',
-            name: 'prompt',
-            type: 'string',
-            typeOptions: { rows: 4 },
-            displayOptions: { show: { inputType: ['prompt'] } },
-            default: '',
-            required: true,
-            description: 'The single text prompt to generate a completion for',
-            hint: 'You can drag data from previous nodes here using expressions.',
-            requiresDataPath: 'single',
-        });
-        this.description.properties.push({
-            displayName: 'Cache Prompt',
-            name: 'cachePrompt',
-            type: 'boolean',
-            default: false,
-            displayOptions: { show: { inputType: ['prompt'] } },
-            description: 'Cache the prompt text. Only useful if this prompt will be reused across multiple requests with different parameters or context.',
-        });
-        return this;
-    }
-    addGoogleProperties() {
-        this.description.properties.push({
-            displayName: 'Thinking Budget',
-            name: 'thinkingBudget',
-            type: 'number',
-            default: -1,
-            description: 'Maximum number of tokens to use for thinking (-1 = use model default)',
-            displayOptions: { show: { '/provider': ['google'] } },
-        });
-        this.description.properties.push({
-            displayName: 'Include Thoughts',
-            name: 'includeThoughts',
-            type: 'boolean',
-            default: false,
-            description: 'Whether to include the model\'s thinking process in the response',
-            displayOptions: { show: { '/provider': ['google'] } },
-        });
-        this.description.properties.push({
-            displayName: 'Custom Headers',
-            name: 'customHeaders',
-            type: 'fixedCollection',
-            typeOptions: { multipleValues: true },
-            default: {},
-            displayOptions: { show: { '/provider': ['google'] } },
-            description: 'Additional headers to send with Google API requests',
-            options: [{
-                    name: 'headers',
-                    displayName: 'Header',
-                    values: [
-                        {
-                            displayName: 'Name',
-                            name: 'name',
-                            type: 'string',
-                            default: '',
-                            description: 'Header name',
-                        },
-                        {
-                            displayName: 'Value',
-                            name: 'value',
-                            type: 'string',
-                            default: '',
-                            description: 'Header value',
-                        },
-                    ],
-                }],
-        });
-        this.description.properties.push({
-            displayName: 'Google Tools',
-            name: 'googleTools',
-            type: 'multiOptions',
-            displayOptions: { show: { '/provider': ['google'] } },
-            options: [
-                { name: 'Google Search', value: 'google_search' },
-                { name: 'URL Context', value: 'url_context' },
-                { name: 'Code Execution', value: 'code_execution' },
-            ],
-            default: [],
-            description: 'Google-specific tools to enable',
-        });
-        this.description.properties.push({
-            displayName: 'Safety Settings',
-            name: 'safetySettings',
-            type: 'fixedCollection',
-            typeOptions: { multipleValues: true },
-            displayOptions: { show: { '/provider': ['google'] } },
-            default: {},
-            description: 'Content safety settings for Google models',
-            options: [{
-                    name: 'settings',
-                    displayName: 'Setting',
-                    values: [
-                        {
-                            displayName: 'Category',
-                            name: 'category',
-                            type: 'options',
-                            options: [
-                                { name: 'Harassment', value: 'HARM_CATEGORY_HARASSMENT' },
-                                { name: 'Hate Speech', value: 'HARM_CATEGORY_HATE_SPEECH' },
-                                { name: 'Sexually Explicit', value: 'HARM_CATEGORY_SEXUALLY_EXPLICIT' },
-                                { name: 'Dangerous Content', value: 'HARM_CATEGORY_DANGEROUS_CONTENT' },
-                            ],
-                            default: '',
-                            required: true,
-                        },
-                        {
-                            displayName: 'Threshold',
-                            name: 'threshold',
-                            type: 'options',
-                            options: [
-                                { name: 'Block None', value: 'HARM_BLOCK_THRESHOLD_UNSPECIFIED' },
-                                { name: 'Block Few', value: 'BLOCK_LOW_AND_ABOVE' },
-                                { name: 'Block Some', value: 'BLOCK_MEDIUM_AND_ABOVE' },
-                                { name: 'Block Most', value: 'BLOCK_ONLY_HIGH' },
-                            ],
-                            default: 'BLOCK_MEDIUM_AND_ABOVE',
-                            required: true,
-                        },
-                    ],
-                }],
-        });
-        this.description.properties.push({
-            displayName: 'Response Modalities',
-            name: 'responseModalities',
-            type: 'multiOptions',
-            displayOptions: { show: { '/provider': ['google'] } },
-            options: [
-                { name: 'Text', value: 'text' },
-                { name: 'Image', value: 'image' },
-            ],
-            default: [],
-            description: 'Response modalities to generate',
-        });
-        this.description.properties.push({
-            displayName: 'Cache TTL (seconds)',
-            name: 'cacheTTL',
-            type: 'number',
-            default: 3600,
-            displayOptions: { show: { '/provider': ['google'] } },
-            description: 'How long to keep cached content (in seconds). Default: 3600 (1 hour). Longer TTL = more cost but better for repeated use.',
-        });
-        return this;
-    }
-    addUniversalAIOptions() {
-        this.addOptionsCollection([
-            {
-                displayName: 'Max Tokens',
-                name: 'maxTokens',
-                type: 'number',
-                default: 0,
-                description: 'Maximum number of tokens to generate (0 = use model default)',
-            },
-            {
-                displayName: 'Temperature',
-                name: 'temperature',
-                type: 'number',
-                default: 0.7,
-                typeOptions: { minValue: 0, maxValue: 2, numberPrecision: 2 },
-                description: 'Controls randomness. Lower = more focused, higher = more creative.',
-            },
-            {
-                displayName: 'Top P',
-                name: 'topP',
-                type: 'number',
-                default: 1,
-                typeOptions: { minValue: 0, maxValue: 1, numberPrecision: 2 },
-                description: 'Controls diversity via nucleus sampling. Lower = more focused.',
-            },
-            {
-                displayName: 'Top K',
-                name: 'topK',
-                type: 'number',
-                default: 0,
-                typeOptions: { minValue: 0 },
-                description: 'Limits token selection to top K options (0 = disabled)',
-                displayOptions: { show: { '/provider': ['google'] } },
-            },
-            {
-                displayName: 'Frequency Penalty',
-                name: 'frequencyPenalty',
-                type: 'number',
-                default: 0,
-                typeOptions: { minValue: -2, maxValue: 2, numberPrecision: 2 },
-                description: 'Reduces the likelihood of repeating the same words. Positive values decrease repetition.',
-            },
-            {
-                displayName: 'Presence Penalty',
-                name: 'presencePenalty',
-                type: 'number',
-                default: 0,
-                typeOptions: { minValue: -2, maxValue: 2, numberPrecision: 2 },
-                description: 'Encourages the model to talk about new topics. Positive values increase the likelihood of new topics.',
-            },
-            {
-                displayName: 'Seed',
-                name: 'seed',
-                type: 'number',
-                default: 0,
-                description: 'Random seed for reproducible results. 0 means no seed.',
-                typeOptions: { minValue: 0 },
-            },
-            {
-                displayName: 'Stop Sequences',
-                name: 'stopSequences',
-                type: 'string',
-                default: '',
-                description: 'Sequences where the API will stop generating further tokens. Separate multiple sequences with commas.',
-            },
-            {
-                displayName: 'Include Request Body',
-                name: 'includeRequestBody',
-                type: 'boolean',
-                default: false,
-                description: 'Whether to include the request body in the output',
-            },
-            {
-                displayName: 'Cache TTL (seconds)',
-                name: 'cacheTTL',
-                type: 'number',
-                default: 3600,
-                description: 'How long to keep cached content (in seconds). Default: 3600 (1 hour). Longer TTL = more cost but better for repeated use.',
-            },
-        ]);
-        return this;
-    }
-    build() {
-        return this.description;
-    }
-}
-exports.NodeDescriptionBuilder = NodeDescriptionBuilder;
-exports.COMMON_PROVIDERS = {
-    google: { name: 'Google Generative AI', value: 'google', description: 'Google Gemini models with multimodal support' },
-    openai: { name: 'OpenAI', value: 'openai' },
-    deepseek: { name: 'DeepSeek', value: 'deepseek', description: 'DeepSeek models with strong reasoning capabilities' },
-    groq: { name: 'Groq', value: 'groq', description: 'High-performance models via Groq LPU' },
-    openrouter: { name: 'OpenRouter', value: 'openrouter', description: 'Access multiple models through OpenRouter' },
-};
-exports.COMMON_CREDENTIALS = {
-    google: 'googleGenerativeAIApi',
-    openai: 'openAiApi',
-    deepseek: 'deepSeekApi',
-    groq: 'groqApi',
-    openrouter: 'openRouterApi',
-};
-exports.COMMON_OPERATIONS = {
-    generateText: { name: 'Generate Text', value: 'generateText', description: 'Generate text using simple prompt or chat messages', action: 'Generate text' },
-    generateObject: { name: 'Generate Object', value: 'generateObject', description: 'Generate a structured object based on a JSON schema', action: 'Generate object' },
-};
-exports.COMMON_INPUT_TYPES = {
-    prompt: { name: 'Simple Prompt', value: 'prompt', description: 'Use a single prompt' },
-    messages: { name: 'Messages', value: 'messages', description: 'Use a conversation with multiple messages' },
-};
-//# sourceMappingURL=descriptions.js.map