n8n-nodes-pollinations-ai 1.0.0 → 1.1.0

package/dist/nodes/Pollinations/Pollinations.node.js

@@ -10,7 +10,7 @@ class Pollinations {
             group: ['transform'],
             version: 1,
             subtitle: '={{$parameter["operation"]}}',
-            description: 'Generate images using Pollinations AI',
+            description: 'Generate images and text using Pollinations AI',
             defaults: {
                 name: 'Pollinations',
             },
@@ -36,10 +36,17 @@ class Pollinations {
                             description: 'Generate an image from a text prompt',
                             action: 'Generate an image from a text prompt',
                         },
+                        {
+                            name: 'Generate Text',
+                            value: 'generateText',
+                            description: 'Generate text from a prompt using AI',
+                            action: 'Generate text from a prompt',
+                        },
                     ],
                     default: 'generateImage',
                 },
-                // Prompt (Basic)
+                // ==================== GENERATE IMAGE ====================
+                // Prompt (Image)
                 {
                     displayName: 'Prompt',
                     name: 'prompt',
@@ -56,7 +63,7 @@ class Pollinations {
                         rows: 4,
                     },
                 },
-                // Model (Basic)
+                // Model (Image) - Dynamic loading
                 {
                     displayName: 'Model',
                     name: 'model',
@@ -67,46 +74,12 @@ class Pollinations {
                             operation: ['generateImage'],
                         },
                     },
-                    options: [
-                        {
-                            name: 'Flux (Default)',
-                            value: 'flux',
-                            description: 'High quality image generation model',
-                        },
-                        {
-                            name: 'Turbo',
-                            value: 'turbo',
-                            description: 'Faster generation with good quality',
-                        },
-                        {
-                            name: 'GPT Image',
-                            value: 'gptimage',
-                            description: 'OpenAI DALL-E style generation',
-                        },
-                        {
-                            name: 'Kontext',
-                            value: 'kontext',
-                            description: 'Context-aware image generation (strict content filter)',
-                        },
-                        {
-                            name: 'Seedream',
-                            value: 'seedream',
-                            description: 'Dream-like artistic images',
-                        },
-                        {
-                            name: 'Nanobanana',
-                            value: 'nanobanana',
-                            description: 'Lightweight fast model',
-                        },
-                        {
-                            name: 'Nanobanana Pro',
-                            value: 'nanobanana-pro',
-                            description: 'Enhanced nanobanana model',
-                        },
-                    ],
+                    typeOptions: {
+                        loadOptionsMethod: 'getImageModels',
+                    },
                     description: 'The model to use for image generation',
                 },
-                // Advanced Options
+                // Advanced Options (Image)
                 {
                     displayName: 'Options',
                     name: 'options',
@@ -171,8 +144,217 @@ class Pollinations {
                         },
                     ],
                 },
+                // ==================== GENERATE TEXT ====================
+                // Prompt (Text)
+                {
+                    displayName: 'Prompt',
+                    name: 'textPrompt',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['generateText'],
+                        },
+                    },
+                    description: 'The text prompt or question for the AI model',
+                    typeOptions: {
+                        rows: 4,
+                    },
+                },
+                // Model (Text) - Dynamic loading
+                {
+                    displayName: 'Model',
+                    name: 'textModel',
+                    type: 'options',
+                    default: 'openai',
+                    displayOptions: {
+                        show: {
+                            operation: ['generateText'],
+                        },
+                    },
+                    typeOptions: {
+                        loadOptionsMethod: 'getTextModels',
+                    },
+                    description: 'The AI model to use for text generation',
+                },
+                // System Prompt (Text)
+                {
+                    displayName: 'System Prompt',
+                    name: 'systemPrompt',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            operation: ['generateText'],
+                        },
+                    },
+                    description: 'Instructions that define the AI behavior and context',
+                    placeholder: 'You are a helpful assistant that responds concisely...',
+                    typeOptions: {
+                        rows: 3,
+                    },
+                },
+                // Temperature (Text)
+                {
+                    displayName: 'Temperature',
+                    name: 'temperature',
+                    type: 'number',
+                    default: 0.7,
+                    displayOptions: {
+                        show: {
+                            operation: ['generateText'],
+                        },
+                    },
+                    description: 'Controls creativity: 0.0 = strict/deterministic, 2.0 = very creative',
+                    typeOptions: {
+                        minValue: 0,
+                        maxValue: 2,
+                        numberPrecision: 1,
+                    },
+                },
+                // Advanced Options (Text)
+                {
+                    displayName: 'Options',
+                    name: 'textOptions',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            operation: ['generateText'],
+                        },
+                    },
+                    options: [
+                        {
+                            displayName: 'JSON Response',
+                            name: 'jsonMode',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to force the response in JSON format. Not supported by all models.',
+                        },
+                        {
+                            displayName: 'Seed',
+                            name: 'seed',
+                            type: 'number',
+                            default: -1,
+                            description: 'Seed for reproducible results. Use -1 for random.',
+                        },
+                    ],
+                },
             ],
         };
+        this.methods = {
+            loadOptions: {
+                async getImageModels() {
+                    try {
+                        const credentials = await this.getCredentials('pollinationsApi');
+                        const apiKey = credentials.apiKey;
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: 'https://gen.pollinations.ai/image/models',
+                            headers: {
+                                Authorization: `Bearer ${apiKey}`,
+                            },
+                        });
+                        if (Array.isArray(response)) {
+                            // Filter only image models (exclude video models)
+                            const imageModels = response.filter((model) => model.output_modalities?.includes('image') &&
+                                !model.output_modalities?.includes('video'));
+                            return imageModels.map((model) => {
+                                let displayName = model.description || model.name;
+                                // Add pricing info if available
+                                if (model.pricing?.completionImageTokens) {
+                                    const imagesPerPollen = Math.floor(1 / model.pricing.completionImageTokens);
+                                    displayName += ` (~${imagesPerPollen.toLocaleString()} img/$)`;
+                                }
+                                return {
+                                    name: displayName,
+                                    value: model.name,
+                                };
+                            });
+                        }
+                        // Fallback if API fails
+                        return [
+                            { name: 'Flux Schnell', value: 'flux' },
+                            { name: 'SDXL Turbo', value: 'turbo' },
+                            { name: 'GPT Image 1 Mini', value: 'gptimage' },
+                            { name: 'FLUX.1 Kontext', value: 'kontext' },
+                            { name: 'Seedream 4.0', value: 'seedream' },
+                            { name: 'NanoBanana', value: 'nanobanana' },
+                            { name: 'NanoBanana Pro', value: 'nanobanana-pro' },
+                        ];
+                    }
+                    catch {
+                        // Fallback if API fails
+                        return [
+                            { name: 'Flux Schnell', value: 'flux' },
+                            { name: 'SDXL Turbo', value: 'turbo' },
+                            { name: 'GPT Image 1 Mini', value: 'gptimage' },
+                            { name: 'FLUX.1 Kontext', value: 'kontext' },
+                            { name: 'Seedream 4.0', value: 'seedream' },
+                        ];
+                    }
+                },
+                async getTextModels() {
+                    try {
+                        const credentials = await this.getCredentials('pollinationsApi');
+                        const apiKey = credentials.apiKey;
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: 'https://gen.pollinations.ai/text/models',
+                            headers: {
+                                Authorization: `Bearer ${apiKey}`,
+                            },
+                        });
+                        if (Array.isArray(response)) {
+                            // Filter only text models (exclude image/video models)
+                            const textModels = response.filter((model) => model.output_modalities?.includes('text') &&
+                                !model.output_modalities?.includes('image') &&
+                                !model.output_modalities?.includes('video'));
+                            return textModels.map((model) => {
+                                let displayName = model.description || model.name;
+                                // Add pricing info if available (responses per pollen)
+                                if (model.pricing?.completionTextTokens) {
+                                    const responsesPerPollen = Math.floor(1 / model.pricing.completionTextTokens);
+                                    displayName += ` (~${responsesPerPollen.toLocaleString()} resp/$)`;
+                                }
+                                return {
+                                    name: displayName,
+                                    value: model.name,
+                                };
+                            });
+                        }
+                        // Fallback if API fails
+                        return [
+                            { name: 'OpenAI GPT-4o Mini', value: 'openai' },
+                            { name: 'OpenAI GPT-4o Mini (Fast)', value: 'openai-fast' },
+                            { name: 'OpenAI GPT-4o (Large)', value: 'openai-large' },
+                            { name: 'Claude Sonnet 3.5', value: 'claude' },
+                            { name: 'Claude (Fast)', value: 'claude-fast' },
+                            { name: 'Claude (Large)', value: 'claude-large' },
+                            { name: 'Gemini', value: 'gemini' },
+                            { name: 'Gemini (Fast)', value: 'gemini-fast' },
+                            { name: 'Gemini (Large)', value: 'gemini-large' },
+                            { name: 'DeepSeek V3', value: 'deepseek' },
+                            { name: 'Mistral', value: 'mistral' },
+                            { name: 'Grok', value: 'grok' },
+                        ];
+                    }
+                    catch {
+                        // Fallback if API fails
+                        return [
+                            { name: 'OpenAI GPT-4o Mini', value: 'openai' },
+                            { name: 'OpenAI GPT-4o Mini (Fast)', value: 'openai-fast' },
+                            { name: 'OpenAI GPT-4o (Large)', value: 'openai-large' },
+                            { name: 'Claude Sonnet 3.5', value: 'claude' },
+                            { name: 'Mistral', value: 'mistral' },
+                            { name: 'DeepSeek V3', value: 'deepseek' },
+                        ];
+                    }
+                },
+            },
+        };
     }
     async execute() {
         const items = this.getInputData();
@@ -183,6 +365,9 @@ class Pollinations {
                 const prompt = this.getNodeParameter('prompt', i);
                 const model = this.getNodeParameter('model', i);
                 const options = this.getNodeParameter('options', i, {});
+                // Get credentials
+                const credentials = await this.getCredentials('pollinationsApi');
+                const apiKey = credentials.apiKey;
                 // Build query parameters
                 const queryParams = {
                     model,
@@ -206,16 +391,19 @@ class Pollinations {
                     queryParams.safe = 'true';
                 }
                 // Build the URL
-                const baseUrl = 'https://image.pollinations.ai/prompt';
+                const baseUrl = 'https://gen.pollinations.ai/image';
                 const encodedPrompt = encodeURIComponent(prompt);
                 const queryString = new URLSearchParams(queryParams).toString();
                 const fullUrl = `${baseUrl}/${encodedPrompt}?${queryString}`;
                 // Record start time
                 const startTime = Date.now();
-                // Make the request
+                // Make the request with authentication
                 const response = await this.helpers.httpRequest({
                     method: 'GET',
                     url: fullUrl,
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                    },
                     encoding: 'arraybuffer',
                     returnFullResponse: true,
                 });
@@ -251,6 +439,83 @@ class Pollinations {
                     },
                 });
             }
+            if (operation === 'generateText') {
+                const prompt = this.getNodeParameter('textPrompt', i);
+                const model = this.getNodeParameter('textModel', i);
+                const systemPrompt = this.getNodeParameter('systemPrompt', i, '');
+                const temperature = this.getNodeParameter('temperature', i);
+                const textOptions = this.getNodeParameter('textOptions', i, {});
+                const jsonMode = textOptions.jsonMode || false;
+                // Get credentials
+                const credentials = await this.getCredentials('pollinationsApi');
+                const apiKey = credentials.apiKey;
+                // Build query parameters
+                const queryParams = {
+                    model,
+                    temperature: temperature.toString(),
+                };
+                if (systemPrompt) {
+                    queryParams.system = systemPrompt;
+                }
+                if (textOptions.seed !== undefined && textOptions.seed !== -1) {
+                    queryParams.seed = textOptions.seed.toString();
+                }
+                if (jsonMode) {
+                    queryParams.json = 'true';
+                }
+                // Build the URL
+                const baseUrl = 'https://gen.pollinations.ai/text';
+                const encodedPrompt = encodeURIComponent(prompt);
+                const queryString = new URLSearchParams(queryParams).toString();
+                const fullUrl = `${baseUrl}/${encodedPrompt}?${queryString}`;
+                // Record start time
+                const startTime = Date.now();
+                // Make the request with authentication
+                const response = await this.helpers.httpRequest({
+                    method: 'GET',
+                    url: fullUrl,
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                    },
+                    returnFullResponse: true,
+                });
+                // Calculate duration
+                const duration = Date.now() - startTime;
+                // Parse response text
+                const text = response.body;
+                let parsedJson = null;
+                // If JSON mode, try to parse the response
+                if (jsonMode) {
+                    try {
+                        parsedJson = JSON.parse(text);
+                    }
+                    catch {
+                        // Keep as string if parsing fails
+                    }
+                }
+                // Build metadata for debugging
+                const metadata = {
+                    text: parsedJson || text,
+                    request: {
+                        url: fullUrl,
+                        prompt,
+                        model,
+                        system: systemPrompt || null,
+                        temperature,
+                        seed: textOptions.seed !== -1 ? textOptions.seed : null,
+                        jsonMode: jsonMode,
+                    },
+                    response: {
+                        statusCode: response.statusCode,
+                        contentType: response.headers?.['content-type'] || 'text/plain',
+                        duration: `${duration}ms`,
+                    },
+                    timestamp: new Date().toISOString(),
+                };
+                returnData.push({
+                    json: metadata,
+                });
+            }
         }
         return [returnData];
     }

package/dist/nodes/Pollinations/PollinationsChatModel.node.d.ts

@@ -0,0 +1,10 @@
+import type { ILoadOptionsFunctions, INodePropertyOptions, INodeType, INodeTypeDescription, ISupplyDataFunctions, SupplyData } from 'n8n-workflow';
+export declare class PollinationsChatModel implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getChatModels(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+    supplyData(this: ISupplyDataFunctions): Promise<SupplyData>;
+}

package/dist/nodes/Pollinations/PollinationsChatModel.node.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollinationsChatModel = void 0;
+const openai_1 = require("@langchain/openai");
+class PollinationsChatModel {
+    constructor() {
+        this.description = {
+            displayName: 'Pollinations Chat Model',
+            name: 'pollinationsChatModel',
+            icon: 'file:pollinations.svg',
+            group: ['transform'],
+            version: 1,
+            description: 'Use Pollinations AI chat models with AI Agents and LLM Chains',
+            defaults: {
+                name: 'Pollinations Chat Model',
+            },
+            codex: {
+                categories: ['AI'],
+                subcategories: {
+                    AI: ['Language Models', 'Chat Models'],
+                },
+                resources: {
+                    primaryDocumentation: [
+                        {
+                            url: 'https://enter.pollinations.ai/api/docs',
+                        },
+                    ],
+                },
+            },
+            // Sub-node: no main inputs, output is ai_languageModel
+            inputs: [],
+            outputs: ['ai_languageModel'],
+            outputNames: ['Model'],
+            credentials: [
+                {
+                    name: 'pollinationsApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                // Model - dynamic loading
+                {
+                    displayName: 'Model',
+                    name: 'model',
+                    type: 'options',
+                    default: 'openai',
+                    typeOptions: {
+                        loadOptionsMethod: 'getChatModels',
+                    },
+                    description: 'The model to use for chat completions',
+                },
+                // Temperature
+                {
+                    displayName: 'Temperature',
+                    name: 'temperature',
+                    type: 'number',
+                    default: 1,
+                    typeOptions: {
+                        minValue: 0,
+                        maxValue: 2,
+                        numberPrecision: 1,
+                    },
+                    description: 'Controls randomness: 0 = deterministic, 2 = very creative',
+                },
+                // Options collection
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Max Tokens',
+                            name: 'maxTokens',
+                            type: 'number',
+                            default: 0,
+                            description: 'Maximum tokens in response. 0 uses model default.',
+                            typeOptions: {
+                                minValue: 0,
+                            },
+                        },
+                        {
+                            displayName: 'Top P',
+                            name: 'topP',
+                            type: 'number',
+                            default: 1,
+                            typeOptions: {
+                                minValue: 0,
+                                maxValue: 1,
+                                numberPrecision: 2,
+                            },
+                            description: 'Nucleus sampling: consider tokens with top_p probability mass',
+                        },
+                        {
+                            displayName: 'Frequency Penalty',
+                            name: 'frequencyPenalty',
+                            type: 'number',
+                            default: 0,
+                            typeOptions: {
+                                minValue: -2,
+                                maxValue: 2,
+                                numberPrecision: 1,
+                            },
+                            description: 'Reduce repetition of token sequences. Higher values decrease repetition.',
+                        },
+                        {
+                            displayName: 'Presence Penalty',
+                            name: 'presencePenalty',
+                            type: 'number',
+                            default: 0,
+                            typeOptions: {
+                                minValue: -2,
+                                maxValue: 2,
+                                numberPrecision: 1,
+                            },
+                            description: 'Increase likelihood of new topics. Higher values encourage novelty.',
+                        },
+                        {
+                            displayName: 'Timeout',
+                            name: 'timeout',
+                            type: 'number',
+                            default: 60000,
+                            typeOptions: {
+                                minValue: 1000,
+                            },
+                            description: 'Request timeout in milliseconds',
+                        },
+                    ],
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getChatModels() {
+                    try {
+                        const credentials = await this.getCredentials('pollinationsApi');
+                        const apiKey = credentials.apiKey;
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: 'https://gen.pollinations.ai/text/models',
+                            headers: {
+                                Authorization: `Bearer ${apiKey}`,
+                            },
+                        });
+                        if (Array.isArray(response)) {
+                            // Filter only text models (exclude image/video models)
+                            const textModels = response.filter((model) => model.output_modalities?.includes('text') &&
+                                !model.output_modalities?.includes('image') &&
+                                !model.output_modalities?.includes('video'));
+                            return textModels.map((model) => {
+                                let displayName = model.description || model.name;
+                                // Add pricing info if available (responses per pollen)
+                                if (model.pricing?.completionTextTokens) {
+                                    const responsesPerPollen = Math.floor(1 / model.pricing.completionTextTokens);
+                                    displayName += ` (~${responsesPerPollen.toLocaleString()} resp/$)`;
+                                }
+                                return {
+                                    name: displayName,
+                                    value: model.name,
+                                };
+                            });
+                        }
+                        // Fallback if API fails
+                        return [
+                            { name: 'OpenAI GPT-4o Mini', value: 'openai' },
+                            { name: 'OpenAI GPT-4o Mini (Fast)', value: 'openai-fast' },
+                            { name: 'OpenAI GPT-4o (Large)', value: 'openai-large' },
+                            { name: 'Claude Sonnet 3.5', value: 'claude' },
+                            { name: 'Claude (Fast)', value: 'claude-fast' },
+                            { name: 'Claude (Large)', value: 'claude-large' },
+                            { name: 'Gemini', value: 'gemini' },
+                            { name: 'Gemini (Fast)', value: 'gemini-fast' },
+                            { name: 'Gemini (Large)', value: 'gemini-large' },
+                            { name: 'DeepSeek V3', value: 'deepseek' },
+                            { name: 'Mistral', value: 'mistral' },
+                            { name: 'Grok', value: 'grok' },
+                        ];
+                    }
+                    catch {
+                        // Fallback if API fails
+                        return [
+                            { name: 'OpenAI GPT-4o Mini', value: 'openai' },
+                            { name: 'OpenAI GPT-4o Mini (Fast)', value: 'openai-fast' },
+                            { name: 'OpenAI GPT-4o (Large)', value: 'openai-large' },
+                            { name: 'Claude Sonnet 3.5', value: 'claude' },
+                            { name: 'Mistral', value: 'mistral' },
+                            { name: 'DeepSeek V3', value: 'deepseek' },
+                        ];
+                    }
+                },
+            },
+        };
+    }
+    async supplyData() {
+        const credentials = await this.getCredentials('pollinationsApi');
+        const apiKey = credentials.apiKey;
+        const model = this.getNodeParameter('model', 0);
+        const temperature = this.getNodeParameter('temperature', 0);
+        const options = this.getNodeParameter('options', 0, {});
+        const chatModel = new openai_1.ChatOpenAI({
+            model,
+            temperature,
+            maxTokens: options.maxTokens || undefined,
+            topP: options.topP,
+            frequencyPenalty: options.frequencyPenalty,
+            presencePenalty: options.presencePenalty,
+            timeout: options.timeout,
+            configuration: {
+                baseURL: 'https://gen.pollinations.ai/v1',
+            },
+            apiKey,
+        });
+        return {
+            response: chatModel,
+        };
+    }
+}
+exports.PollinationsChatModel = PollinationsChatModel;