pollinations-mcp-server.js•15 kB
#!/usr/bin/env node
// Check Node.js version and provide polyfill for AbortController if needed
// This needs to be done before importing any modules that might use AbortController
const DEBUG = /^(1|true|yes)$/i.test(process.env.DEBUG || process.env.MCP_DEBUG || '');
const log = (...args) => { if (DEBUG) { try { console.error(...args); } catch {} } };
const nodeVersion = process.versions.node;
const majorVersion = parseInt(nodeVersion.split('.')[0], 10);
// Show version info (debug only)
log(`Running on Node.js version: ${nodeVersion}`);
// Add AbortController polyfill for Node.js versions < 16
if (majorVersion < 16) {
// Check if AbortController is already defined globally
if (typeof global.AbortController === 'undefined') {
log('Adding AbortController polyfill for Node.js < 16');
try {
// Try to dynamically import a polyfill
// First attempt to use node-abort-controller if it's installed
try {
const { AbortController: AbortControllerPolyfill } = await import('node-abort-controller');
global.AbortController = AbortControllerPolyfill;
} catch (importError) {
// Create a basic implementation if the import fails
log('Using basic AbortController polyfill');
class AbortSignal {
constructor() {
this.aborted = false;
this.onabort = null;
this._eventListeners = {};
}
addEventListener(type, listener) {
if (!this._eventListeners[type]) {
this._eventListeners[type] = [];
}
this._eventListeners[type].push(listener);
}
removeEventListener(type, listener) {
if (!this._eventListeners[type]) return;
this._eventListeners[type] = this._eventListeners[type].filter(l => l !== listener);
}
dispatchEvent(event) {
if (event.type === 'abort' && this.onabort) {
this.onabort(event);
}
if (this._eventListeners[event.type]) {
this._eventListeners[event.type].forEach(listener => listener(event));
}
}
}
global.AbortController = class AbortController {
constructor() {
this.signal = new AbortSignal();
}
abort() {
if (this.signal.aborted) return;
this.signal.aborted = true;
const event = { type: 'abort' };
this.signal.dispatchEvent(event);
}
};
}
} catch (error) {
if (DEBUG) {
log('Failed to add AbortController polyfill:', error);
log('This package requires Node.js >= 16. Please upgrade your Node.js version.');
}
process.exit(1);
}
}
}
// Now import the MCP SDK and other modules
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
CallToolRequestSchema,
ErrorCode,
ListToolsRequestSchema,
McpError,
} from '@modelcontextprotocol/sdk/types.js';
import {
generateImageUrl,
generateImage,
editImage,
generateImageFromReference,
respondAudio,
listImageModels,
listTextModels,
listAudioVoices,
respondText,
} from './src/index.js';
import { getAllToolSchemas } from './src/schemas.js';
import fs from 'fs';
import path from 'path';
import os from 'os';
import player from 'play-sound';
// Create audio player instance
const audioPlayer = player({});
// Read authentication configuration from environment variables
// These are optional - the server works without them (free tier)
// Support both namespaced and plain keys so MCP `env` can use simple keys
const authConfig = {
token: process.env.POLLINATIONS_TOKEN || process.env.TOKEN || process.env.token || null,
referrer: process.env.POLLINATIONS_REFERRER || process.env.REFERRER || process.env.referrer || null
};
// Only create authConfig object if we have at least one auth parameter
const finalAuthConfig = (authConfig.token || authConfig.referrer) ? authConfig : null;
if (finalAuthConfig) {
log('Auth configuration loaded:', {
hasToken: !!finalAuthConfig.token,
hasReferrer: !!finalAuthConfig.referrer
});
} else {
log('Running in free tier mode (no auth configuration)');
}
// Read optional defaults from environment. These provide the server's implicit
// defaults when tool calls omit specific arguments. Users configure these via
// MCP config `env`.
function parseBool(value, fallback) {
if (value === undefined || value === null || value === '') return fallback;
const v = String(value).toLowerCase();
if (["1","true","yes","y"].includes(v)) return true;
if (["0","false","no","n"].includes(v)) return false;
return fallback;
}
const defaultConfig = {
image: {
model: process.env.DEFAULT_IMAGE_MODEL || process.env.IMAGE_MODEL || 'flux',
width: Number(process.env.DEFAULT_IMAGE_WIDTH || process.env.IMAGE_WIDTH || 1024) || 1024,
height: Number(process.env.DEFAULT_IMAGE_HEIGHT || process.env.IMAGE_HEIGHT || 1024) || 1024,
enhance: parseBool(process.env.DEFAULT_IMAGE_ENHANCE ?? process.env.IMAGE_ENHANCE, true),
safe: parseBool(process.env.DEFAULT_IMAGE_SAFE ?? process.env.IMAGE_SAFE, false)
},
text: {
model: process.env.DEFAULT_TEXT_MODEL || process.env.TEXT_MODEL || 'openai',
temperature: process.env.DEFAULT_TEXT_TEMPERATURE || process.env.TEXT_TEMPERATURE,
top_p: process.env.DEFAULT_TEXT_TOP_P || process.env.TEXT_TOP_P,
system: process.env.DEFAULT_TEXT_SYSTEM || process.env.TEXT_SYSTEM
},
audio: {
voice: process.env.DEFAULT_AUDIO_VOICE || process.env.AUDIO_VOICE || 'alloy'
},
resources: {
output_dir: process.env.OUTPUT_DIR || process.env.DEFAULT_OUTPUT_DIR || './mcpollinations-output'
}
};
log('Default params:', {
image: defaultConfig.image,
text: {
model: defaultConfig.text.model,
temperature: defaultConfig.text.temperature,
top_p: defaultConfig.text.top_p,
hasSystem: !!defaultConfig.text.system
},
audio: defaultConfig.audio,
resources: defaultConfig.resources
});
// Create the server instance
const server = new Server(
{
name: '@pinkpixel/mcpollinations',
version: '1.3.1',
},
{
capabilities: {
tools: {}
}
}
);
// Set up error handling
server.onerror = (error) => log('[MCP Error]', error);
process.on('SIGINT', async () => {
await server.close();
process.exit(0);
});
// Set up tool handlers
// List available tools
server.setRequestHandler(ListToolsRequestSchema, async () => ({
tools: getAllToolSchemas()
}));
// Handle tool calls
server.setRequestHandler(CallToolRequestSchema, async (request) => {
const { name, arguments: args } = request.params;
if (name === 'generateImageUrl') {
try {
const { prompt, model = defaultConfig.image.model, seed, width = defaultConfig.image.width, height = defaultConfig.image.height, enhance = defaultConfig.image.enhance, safe = defaultConfig.image.safe } = args;
const result = await generateImageUrl(prompt, model, seed, width, height, enhance, safe, finalAuthConfig);
return {
content: [
{ type: 'text', text: JSON.stringify(result, null, 2) }
]
};
} catch (error) {
return {
content: [
{ type: 'text', text: `Error generating image URL: ${error.message}` }
],
isError: true
};
}
} else if (name === 'generateImage') {
try {
const { prompt, model = defaultConfig.image.model, seed, width = defaultConfig.image.width, height = defaultConfig.image.height, enhance = defaultConfig.image.enhance, safe = defaultConfig.image.safe, outputPath = defaultConfig.resources.output_dir, fileName = '', format = 'png' } = args;
const result = await generateImage(prompt, model, seed, width, height, enhance, safe, outputPath, fileName, format, finalAuthConfig);
// Prepare the response content
const content = [
{
type: 'image',
data: result.data,
mimeType: result.mimeType
}
];
// Prepare the response text
let responseText = `Generated image from prompt: "${prompt}"\n\nImage metadata: ${JSON.stringify(result.metadata, null, 2)}`;
// Add file path information if the image was saved to a file
if (result.filePath) {
responseText += `\n\nImage saved to: ${result.filePath}`;
}
// Add the text content
content.push({ type: 'text', text: responseText });
return { content };
} catch (error) {
return {
content: [
{ type: 'text', text: `Error generating image: ${error.message}` }
],
isError: true
};
}
} else if (name === 'respondAudio') {
try {
const { prompt, voice = defaultConfig.audio.voice, seed, voiceInstructions } = args;
const result = await respondAudio(prompt, voice, seed, voiceInstructions, finalAuthConfig);
// Save audio to a temporary file
const tempDir = os.tmpdir();
const tempFilePath = path.join(tempDir, `pollinations-audio-${Date.now()}.mp3`);
// Decode base64 and write to file
fs.writeFileSync(tempFilePath, Buffer.from(result.data, 'base64'));
// Play the audio file
audioPlayer.play(tempFilePath, (err) => {
if (err) log('Error playing audio:', err);
// Clean up the temporary file after playing
try {
fs.unlinkSync(tempFilePath);
} catch (cleanupErr) {
log('Error cleaning up temp file:', cleanupErr);
}
});
return {
content: [
{
type: 'text',
text: `Audio has been played.\n\nAudio metadata: ${JSON.stringify(result.metadata, null, 2)}`
}
]
};
} catch (error) {
return {
content: [
{ type: 'text', text: `Error generating audio: ${error.message}` }
],
isError: true
};
}
} else if (name === 'listImageModels') {
try {
const result = await listImageModels();
return {
content: [
{ type: 'text', text: JSON.stringify(result, null, 2) }
]
};
} catch (error) {
return {
content: [
{ type: 'text', text: `Error listing image models: ${error.message}` }
],
isError: true
};
}
} else if (name === 'listTextModels') {
try {
const result = await listTextModels();
return {
content: [
{ type: 'text', text: JSON.stringify(result, null, 2) }
]
};
} catch (error) {
return {
content: [
{ type: 'text', text: `Error listing text models: ${error.message}` }
],
isError: true
};
}
} else if (name === 'listAudioVoices') {
try {
const result = await listAudioVoices();
return {
content: [
{ type: 'text', text: JSON.stringify(result, null, 2) }
]
};
} catch (error) {
return {
content: [
{ type: 'text', text: `Error listing audio voices: ${error.message}` }
],
isError: true
};
}
} else if (name === 'respondText') {
try {
const { prompt, model = defaultConfig.text.model, seed, temperature = defaultConfig.text.temperature ? Number(defaultConfig.text.temperature) : undefined, top_p = defaultConfig.text.top_p ? Number(defaultConfig.text.top_p) : undefined, system = defaultConfig.text.system } = args;
const result = await respondText(prompt, model, seed, temperature, top_p, system, finalAuthConfig);
return {
content: [
{ type: 'text', text: result }
]
};
} catch (error) {
return {
content: [
{ type: 'text', text: `Error generating text response: ${error.message}` }
],
isError: true
};
}
} else if (name === 'editImage') {
try {
const { prompt, imageUrl, model = 'kontext', seed, width = defaultConfig.image.width, height = defaultConfig.image.height, enhance = defaultConfig.image.enhance, safe = defaultConfig.image.safe, outputPath = defaultConfig.resources.output_dir, fileName = '', format = 'png' } = args;
const result = await editImage(prompt, imageUrl, model, seed, width, height, enhance, safe, outputPath, fileName, format, finalAuthConfig);
// Prepare the response content
const content = [
{
type: 'image',
data: result.data,
mimeType: result.mimeType
}
];
// Prepare the response text
let responseText = `Edited image from prompt: "${prompt}"\nInput image: ${imageUrl}\n\nImage metadata: ${JSON.stringify(result.metadata, null, 2)}`;
// Add file path information if the image was saved to a file
if (result.filePath) {
responseText += `\n\nImage saved to: ${result.filePath}`;
}
content.push({
type: 'text',
text: responseText
});
return { content };
} catch (error) {
return {
content: [
{ type: 'text', text: `Error editing image: ${error.message}` }
],
isError: true
};
}
} else if (name === 'generateImageFromReference') {
try {
const { prompt, imageUrl, model = 'kontext', seed, width = defaultConfig.image.width, height = defaultConfig.image.height, enhance = defaultConfig.image.enhance, safe = defaultConfig.image.safe, outputPath = defaultConfig.resources.output_dir, fileName = '', format = 'png' } = args;
const result = await generateImageFromReference(prompt, imageUrl, model, seed, width, height, enhance, safe, outputPath, fileName, format, finalAuthConfig);
// Prepare the response content
const content = [
{
type: 'image',
data: result.data,
mimeType: result.mimeType
}
];
// Prepare the response text
let responseText = `Generated image from reference: "${prompt}"\nReference image: ${imageUrl}\n\nImage metadata: ${JSON.stringify(result.metadata, null, 2)}`;
// Add file path information if the image was saved to a file
if (result.filePath) {
responseText += `\n\nImage saved to: ${result.filePath}`;
}
content.push({
type: 'text',
text: responseText
});
return { content };
} catch (error) {
return {
content: [
{ type: 'text', text: `Error generating image from reference: ${error.message}` }
],
isError: true
};
}
} else {
throw new McpError(
ErrorCode.MethodNotFound,
`Unknown tool: ${name}`
);
}
});
// Run the server
async function run() {
const transport = new StdioServerTransport();
await server.connect(transport);
log('MCPollinations MCP server running on stdio');
}
run().catch(console.error);
