`feat: Add image-to-image generation tools and transparent background support`

CHANGELOG.md

@@ -5,6 +5,32 @@ All notable changes to the MCPollinations will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.2.0] - `2025-07-25`
+
+### Added
+- **Transparent Background Support**: Added `transparent` parameter for generating images with transparent backgrounds
+  - Works with `gptimage` model only
+  - Perfect for logos, icons, and graphics that need transparent backgrounds
+  - Added to both `generateImageUrl` and `generateImage` tools
+  - Configurable in MCP configuration with default settings
+- **Image-to-Image Generation**: Two new powerful tools for working with existing images
+  - `editImage` tool: Edit or modify existing images based on text prompts (e.g., "remove the cat and add a dog", "change background to mountains")
+  - `generateImageFromReference` tool: Generate new images using existing images as reference (e.g., "make this into a cartoon", "create a painting version")
+  - Both tools support `gptimage` and `kontext` models
+  - Full parameter support including transparent backgrounds, custom dimensions, and file saving
+- **Enhanced Configuration**: Updated configuration generator and example files
+  - Added transparent parameter configuration prompts
+  - Updated tool lists to include new image-to-image tools
+  - Enhanced model guidance and descriptions
+
+### Changed
+- Updated tool schemas to include new transparent parameter
+- Enhanced image generation capabilities with more flexible model options
+- Improved tool descriptions for better AI assistant understanding
+
+### Fixed
+- Ensured all new tools follow consistent parameter patterns and error handling
+
 ## [1.1.3] - `2025-07-25`
 
 ### Added

README.md

@@ -192,13 +192,18 @@ If it shows a version lower than 16.0.0, consider upgrading for best compatibili
 
 The MCP server provides the following tools:
 
+### **Image Generation Tools**
 1. `generateImageUrl` - Generates an image URL from a text prompt
 2. `generateImage` - Generates an image, returns it as base64-encoded data, and saves it to a file by default (PNG format)
-3. `respondAudio` - Generates an audio response to a text prompt (customizable voice parameter)
-4. `respondText` - Responds with text to a prompt using text models (customizable model parameter)
+3. `editImage` - **NEW!** Edit or modify existing images based on text prompts
+4. `generateImageFromReference` - **NEW!** Generate new images using existing images as reference
 5. `listImageModels` - Lists available models for image generation
-6. `listTextModels` - Lists available models for text generation
-7. `listAudioVoices` - Lists all available voices for audio generation
+
+### **Text & Audio Tools**
+6. `respondText` - Responds with text to a prompt using text models (customizable parameters)
+7. `respondAudio` - Generates an audio response to a text prompt (customizable voice parameter)
+8. `listTextModels` - Lists available models for text generation
+9. `listAudioVoices` - Lists all available voices for audio generation
 
 ## Text Generation Details
 
@@ -244,6 +249,51 @@ In your MCP configuration, you can set defaults:
 }
 ```
 
+## Image-to-Image Generation (NEW!)
+
+MCPollinations now supports powerful image-to-image generation with two specialized tools:
+
+### **editImage Tool**
+Perfect for modifying existing images:
+- **Remove objects**: "remove the cat from this image"
+- **Add elements**: "add a dog to this scene"
+- **Change backgrounds**: "replace the background with mountains"
+- **Style modifications**: "make the lighting more dramatic"
+
+### **generateImageFromReference Tool**
+Perfect for creating variations and new styles:
+- **Style transfer**: "make this photo look like a painting"
+- **Format changes**: "convert this to a cartoon style"
+- **Creative variations**: "create a futuristic version of this"
+- **Artistic interpretations**: "make this look like a sketch"
+
+### **Supported Models**
+- **`gptimage`**: Versatile model for both editing and reference generation
+- **`kontext`**: Specialized model optimized for image-to-image tasks
+
+### **Example Usage**
+```javascript
+// Edit an existing image
+const editResult = await editImage(
+  "change the background to a sunset beach",
+  "https://example.com/photo.jpg",
+  "gptimage"
+);
+
+// Generate from reference
+const referenceResult = await generateImageFromReference(
+  "make this into a watercolor painting",
+  "https://example.com/photo.jpg",
+  "kontext"
+);
+```
+
+### **Transparent Backgrounds (NEW!)**
+Generate images with transparent backgrounds using the `gptimage` model:
+- Perfect for logos, icons, and graphics
+- Set `transparent: true` in your requests
+- Only works with the `gptimage` model
+
 ## Image Generation Details
 
 ### Default Behavior
@@ -272,6 +322,7 @@ const options = {
   seed: 12345,  // Specific seed for reproducibility (defaults to random)
   enhance: true,  // Enhance the prompt using an LLM before generating (defaults to true)
   safe: false,  // Content filtering (defaults to false)
+  transparent: false,  // Generate with transparent background (gptimage model only)
 
   // File saving options
   saveToFile: true,  // Set to false to skip saving to disk

example-mcp.json

@@ -18,7 +18,8 @@
         "width": 1024,
         "height": 1024,
         "safe": false,
-        "enhance": true
+        "enhance": true,
+        "transparent": false
       },
       "text": {
         "model": "openai",
@@ -34,6 +35,8 @@
     "alwaysAllow": [
       "generateImageUrl",
       "generateImage",
+      "editImage",
+      "generateImageFromReference",
       "listImageModels",
       "respondAudio",
       "listAudioVoices",

generate-mcp-config.js

@@ -29,7 +29,8 @@ const defaultConfig = {
         "width": 1024,
         "height": 1024,
         "safe": false,
-        "enhance": true
+        "enhance": true,
+        "transparent": false
       },
       "text": {
         "model": "openai",
@@ -45,6 +46,8 @@ const defaultConfig = {
     "alwaysAllow": [
       "generateImageUrl",
       "generateImage",
+      "editImage",
+      "generateImageFromReference",
       "listImageModels",
       "respondAudio",
       "listAudioVoices",
@@ -149,6 +152,9 @@ async function generateMcpConfig() {
 
       const imageEnhance = await promptYesNo('Enable prompt enhancement using LLM before image generation?', true);
       config[configKey].default_params.image.enhance = imageEnhance;
+
+      const imageTransparent = await promptYesNo('Enable transparent background by default? (gptimage model only, default: false)', false);
+      config[configKey].default_params.image.transparent = imageTransparent;
     }
 
     // Text parameters
@@ -191,6 +197,8 @@ async function generateMcpConfig() {
       const allTools = [
         'generateImageUrl',
         'generateImage',
+        'editImage',
+        'generateImageFromReference',
         'listImageModels',
         'respondAudio',
         'listAudioVoices',

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pinkpixel/mcpollinations",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "description": "Model Context Protocol (MCP) server for the Pollinations APIs with image saving functionality.",
   "type": "module",
   "bin": {

pollinations-mcp-server.js

@@ -86,6 +86,8 @@ import {
 import {
   generateImageUrl,
   generateImage,
+  editImage,
+  generateImageFromReference,
   respondAudio,
   listImageModels,
   listTextModels,
@@ -125,7 +127,7 @@ if (finalAuthConfig) {
 const server = new Server(
   {
     name: '@pinkpixel/mcpollinations',
-    version: '1.1.3',
+    version: '1.2.0',
   },
   {
     capabilities: {
@@ -153,8 +155,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
   if (name === 'generateImageUrl') {
     try {
-      const { prompt, model = 'flux', seed, width = 1024, height = 1024, enhance = true, safe = false } = args;
-      const result = await generateImageUrl(prompt, model, seed, width, height, enhance, safe, finalAuthConfig);
+      const { prompt, model = 'flux', seed, width = 1024, height = 1024, enhance = true, safe = false, transparent = false } = args;
+      const result = await generateImageUrl(prompt, model, seed, width, height, enhance, safe, transparent, finalAuthConfig);
       return {
         content: [
           { type: 'text', text: JSON.stringify(result, null, 2) }
@@ -170,8 +172,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
   } else if (name === 'generateImage') {
     try {
-      const { prompt, model = 'flux', seed, width = 1024, height = 1024, enhance = true, safe = false, outputPath = './mcpollinations-output', fileName = '', format = 'png' } = args;
-      const result = await generateImage(prompt, model, seed, width, height, enhance, safe, outputPath, fileName, format, finalAuthConfig);
+      const { prompt, model = 'flux', seed, width = 1024, height = 1024, enhance = true, safe = false, transparent = false, outputPath = './mcpollinations-output', fileName = '', format = 'png' } = args;
+      const result = await generateImage(prompt, model, seed, width, height, enhance, safe, transparent, outputPath, fileName, format, finalAuthConfig);
 
       // Prepare the response content
       const content = [
@@ -308,6 +310,79 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       };
     }
 
+  } else if (name === 'editImage') {
+    try {
+      const { prompt, imageUrl, model = 'gptimage', seed, width = 1024, height = 1024, enhance = true, safe = false, transparent = false, outputPath = './mcpollinations-output', fileName = '', format = 'png' } = args;
+      const result = await editImage(prompt, imageUrl, model, seed, width, height, enhance, safe, transparent, 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 = 'gptimage', seed, width = 1024, height = 1024, enhance = true, safe = false, transparent = false, outputPath = './mcpollinations-output', fileName = '', format = 'png' } = args;
+      const result = await generateImageFromReference(prompt, imageUrl, model, seed, width, height, enhance, safe, transparent, 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(

src/index.js

@@ -5,7 +5,7 @@
  */
 
 // Import services
-import { generateImageUrl, generateImage, listImageModels } from './services/imageService.js';
+import { generateImageUrl, generateImage, editImage, generateImageFromReference, listImageModels } from './services/imageService.js';
 import { respondAudio, listAudioVoices } from './services/audioService.js';
 import { respondText, listTextModels } from './services/textService.js';
 
@@ -15,6 +15,8 @@ export {
   // Image services
   generateImageUrl,
   generateImage,
+  editImage,
+  generateImageFromReference,
   listImageModels,
 
   // Audio services

src/schemas.js

@@ -2,7 +2,7 @@
  * Central export for all schema definitions
  */
 
-import { generateImageUrlSchema, generateImageSchema, listImageModelsSchema } from './services/imageSchema.js';
+import { generateImageUrlSchema, generateImageSchema, editImageSchema, generateImageFromReferenceSchema, listImageModelsSchema } from './services/imageSchema.js';
 import { respondAudioSchema, listAudioVoicesSchema } from './services/audioSchema.js';
 import { respondTextSchema, listTextModelsSchema } from './services/textSchema.js';
 
@@ -12,6 +12,8 @@ export {
   // Image schemas
   generateImageUrlSchema,
   generateImageSchema,
+  editImageSchema,
+  generateImageFromReferenceSchema,
   listImageModelsSchema,
 
   // Audio schemas
@@ -31,6 +33,8 @@ export function getAllToolSchemas() {
   return [
     generateImageUrlSchema,
     generateImageSchema,
+    editImageSchema,
+    generateImageFromReferenceSchema,
     listImageModelsSchema,
     respondAudioSchema,
     listAudioVoicesSchema,

src/services/imageSchema.js

@@ -38,6 +38,10 @@ export const generateImageUrlSchema = {
       safe: {
         type: 'boolean',
         description: 'Whether to apply content filtering (default: false)'
+      },
+      transparent: {
+        type: 'boolean',
+        description: 'Generate image with transparent background (gptimage model only, default: false)'
       }
     },
     required: ['prompt']
@@ -81,6 +85,10 @@ export const generateImageSchema = {
         type: 'boolean',
         description: 'Whether to apply content filtering (default: false)'
       },
+      transparent: {
+        type: 'boolean',
+        description: 'Generate image with transparent background (gptimage model only, default: false)'
+      },
       outputPath: {
         type: 'string',
         description: 'Directory path where to save the image (default: "./mcpollinations-output")'
@@ -109,3 +117,127 @@ export const listImageModelsSchema = {
     properties: {}
   }
 };
+
+/**
+ * Schema for the editImage tool
+ */
+export const editImageSchema = {
+  name: 'editImage',
+  description: 'Edit or modify an existing image based on a text prompt. User-configured settings in MCP config will be used as defaults unless specifically overridden.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      prompt: {
+        type: 'string',
+        description: 'The text description of how to edit the image (e.g., "remove the cat and add a dog", "change background to mountains")'
+      },
+      imageUrl: {
+        type: 'string',
+        description: 'URL of the input image to edit'
+      },
+      model: {
+        type: 'string',
+        description: 'Model name to use for editing (default: user config or "gptimage"). Available: "gptimage", "kontext"'
+      },
+      seed: {
+        type: 'number',
+        description: 'Seed for reproducible results (default: random)'
+      },
+      width: {
+        type: 'number',
+        description: 'Width of the generated image (default: 1024)'
+      },
+      height: {
+        type: 'number',
+        description: 'Height of the generated image (default: 1024)'
+      },
+      enhance: {
+        type: 'boolean',
+        description: 'Whether to enhance the prompt using an LLM before generating (default: true)'
+      },
+      safe: {
+        type: 'boolean',
+        description: 'Whether to apply content filtering (default: false)'
+      },
+      transparent: {
+        type: 'boolean',
+        description: 'Generate image with transparent background (gptimage model only, default: false)'
+      },
+      outputPath: {
+        type: 'string',
+        description: 'Directory path where to save the image (default: user config or "./mcpollinations-output")'
+      },
+      fileName: {
+        type: 'string',
+        description: 'Name of the file to save (without extension, default: generated from prompt)'
+      },
+      format: {
+        type: 'string',
+        description: 'Image format to save as (png, jpeg, jpg, webp - default: png)'
+      }
+    },
+    required: ['prompt', 'imageUrl']
+  }
+};
+
+/**
+ * Schema for the generateImageFromReference tool
+ */
+export const generateImageFromReferenceSchema = {
+  name: 'generateImageFromReference',
+  description: 'Generate a new image using an existing image as reference. User-configured settings in MCP config will be used as defaults unless specifically overridden.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      prompt: {
+        type: 'string',
+        description: 'The text description of what to generate based on the reference image (e.g., "create a cartoon version", "make it look like a painting")'
+      },
+      imageUrl: {
+        type: 'string',
+        description: 'URL of the reference image to base the generation on'
+      },
+      model: {
+        type: 'string',
+        description: 'Model name to use for generation (default: user config or "gptimage"). Available: "gptimage", "kontext"'
+      },
+      seed: {
+        type: 'number',
+        description: 'Seed for reproducible results (default: random)'
+      },
+      width: {
+        type: 'number',
+        description: 'Width of the generated image (default: 1024)'
+      },
+      height: {
+        type: 'number',
+        description: 'Height of the generated image (default: 1024)'
+      },
+      enhance: {
+        type: 'boolean',
+        description: 'Whether to enhance the prompt using an LLM before generating (default: true)'
+      },
+      safe: {
+        type: 'boolean',
+        description: 'Whether to apply content filtering (default: false)'
+      },
+      transparent: {
+        type: 'boolean',
+        description: 'Generate image with transparent background (gptimage model only, default: false)'
+      },
+      outputPath: {
+        type: 'string',
+        description: 'Directory path where to save the image (default: user config or "./mcpollinations-output")'
+      },
+      fileName: {
+        type: 'string',
+        description: 'Name of the file to save (without extension, default: generated from prompt)'
+      },
+      format: {
+        type: 'string',
+        description: 'Image format to save as (png, jpeg, jpg, webp - default: png)'
+      }
+    },
+    required: ['prompt', 'imageUrl']
+  }
+};

src/services/imageService.js

@@ -14,11 +14,12 @@
  * @param {number} [height=1024] - Height of the generated image
  * @param {boolean} [enhance=true] - Whether to enhance the prompt using an LLM before generating
  * @param {boolean} [safe=false] - Whether to apply content filtering
+ * @param {boolean} [transparent=false] - Generate image with transparent background (gptimage model only)
  * @param {Object} [authConfig] - Optional authentication configuration {token, referrer}
  * @returns {Object} - Object containing the image URL and metadata
  * @note Always includes nologo=true and private=true parameters
  */
-export async function generateImageUrl(prompt, model = 'flux', seed = Math.floor(Math.random() * 1000000), width = 1024, height = 1024, enhance = true, safe = false, authConfig = null) {
+export async function generateImageUrl(prompt, model = 'flux', seed = Math.floor(Math.random() * 1000000), width = 1024, height = 1024, enhance = true, safe = false, transparent = false, authConfig = null) {
   if (!prompt || typeof prompt !== 'string') {
     throw new Error('Prompt is required and must be a string');
   }
@@ -43,6 +44,7 @@ export async function generateImageUrl(prompt, model = 'flux', seed = Math.floor
   queryParams.append('nologo', 'true'); // Always set nologo to true
   queryParams.append('private', 'true'); // Always set private to true)
   queryParams.append('safe', safe.toString()); // Use the customizable safe parameter
+  if (transparent) queryParams.append('transparent', 'true'); // Add transparent parameter if true
 
   // Construct the URL
   const encodedPrompt = encodeURIComponent(prompt);
@@ -64,7 +66,8 @@ export async function generateImageUrl(prompt, model = 'flux', seed = Math.floor
     enhance,
     private: true,
     nologo: true,
-    safe
+    safe,
+    transparent
   };
 }
 
@@ -79,6 +82,7 @@ export async function generateImageUrl(prompt, model = 'flux', seed = Math.floor
  * @param {number} [height=1024] - Height of the generated image
  * @param {boolean} [enhance=true] - Whether to enhance the prompt using an LLM before generating
  * @param {boolean} [safe=false] - Whether to apply content filtering
+ * @param {boolean} [transparent=false] - Generate image with transparent background (gptimage model only)
  * @param {string} [outputPath='./mcpollinations-output'] - Directory path where to save the image
  * @param {string} [fileName] - Name of the file to save (without extension)
  * @param {string} [format='png'] - Image format to save as (png, jpeg, jpg, webp)
@@ -86,13 +90,13 @@ export async function generateImageUrl(prompt, model = 'flux', seed = Math.floor
  * @returns {Promise<Object>} - Object containing the base64 image data, mime type, metadata, and file path if saved
  * @note Always includes nologo=true and private=true parameters
  */
-export async function generateImage(prompt, model = 'flux', seed = Math.floor(Math.random() * 1000000), width = 1024, height = 1024, enhance = true, safe = false, outputPath = './mcpollinations-output', fileName = '', format = 'png', authConfig = null) {
+export async function generateImage(prompt, model = 'flux', seed = Math.floor(Math.random() * 1000000), width = 1024, height = 1024, enhance = true, safe = false, transparent = false, outputPath = './mcpollinations-output', fileName = '', format = 'png', authConfig = null) {
   if (!prompt || typeof prompt !== 'string') {
     throw new Error('Prompt is required and must be a string');
   }
 
   // First, generate the image URL
-  const urlResult = await generateImageUrl(prompt, model, seed, width, height, enhance, safe, authConfig);
+  const urlResult = await generateImageUrl(prompt, model, seed, width, height, enhance, safe, transparent, authConfig);
 
   try {
     // Prepare fetch options with optional auth headers
@@ -136,7 +140,8 @@ export async function generateImage(prompt, model = 'flux', seed = Math.floor(Ma
         enhance: urlResult.enhance,
         private: urlResult.private,
         nologo: urlResult.nologo,
-        safe: urlResult.safe
+        safe: urlResult.safe,
+        transparent: urlResult.transparent
       }
     };
 
@@ -193,6 +198,310 @@ export async function generateImage(prompt, model = 'flux', seed = Math.floor(Ma
   }
 }
 
+/**
+ * Edits or modifies an existing image based on a text prompt
+ *
+ * @param {string} prompt - The text description of how to edit the image
+ * @param {string} imageUrl - URL of the input image to edit
+ * @param {string} [model='gptimage'] - Model name to use for editing (gptimage or kontext)
+ * @param {number} [seed] - Seed for reproducible results (defaults to random if not specified)
+ * @param {number} [width=1024] - Width of the generated image
+ * @param {number} [height=1024] - Height of the generated image
+ * @param {boolean} [enhance=true] - Whether to enhance the prompt using an LLM before generating
+ * @param {boolean} [safe=false] - Whether to apply content filtering
+ * @param {boolean} [transparent=false] - Generate image with transparent background (gptimage model only)
+ * @param {string} [outputPath='./mcpollinations-output'] - Directory path where to save the image
+ * @param {string} [fileName] - Name of the file to save (without extension)
+ * @param {string} [format='png'] - Image format to save as (png, jpeg, jpg, webp)
+ * @param {Object} [authConfig] - Optional authentication configuration {token, referrer}
+ * @returns {Promise<Object>} - Object containing the base64 image data, mime type, metadata, and file path if saved
+ * @note Always includes nologo=true and private=true parameters
+ */
+export async function editImage(prompt, imageUrl, model = 'gptimage', seed = Math.floor(Math.random() * 1000000), width = 1024, height = 1024, enhance = true, safe = false, transparent = false, outputPath = './mcpollinations-output', fileName = '', format = 'png', authConfig = null) {
+  if (!prompt || typeof prompt !== 'string') {
+    throw new Error('Prompt is required and must be a string');
+  }
+
+  if (!imageUrl || typeof imageUrl !== 'string') {
+    throw new Error('Image URL is required and must be a string');
+  }
+
+  // Build the query parameters
+  const queryParams = new URLSearchParams();
+  queryParams.append('model', model);
+  queryParams.append('image', imageUrl); // Add the input image URL
+  if (seed !== undefined) queryParams.append('seed', seed);
+  if (width !== 1024) queryParams.append('width', width);
+  if (height !== 1024) queryParams.append('height', height);
+
+  // Add enhance parameter if true
+  if (enhance) queryParams.append('enhance', 'true');
+
+  // Add parameters
+  queryParams.append('nologo', 'true'); // Always set nologo to true
+  queryParams.append('private', 'true'); // Always set private to true)
+  queryParams.append('safe', safe.toString()); // Use the customizable safe parameter
+  if (transparent) queryParams.append('transparent', 'true'); // Add transparent parameter if true
+
+  // Construct the URL
+  const encodedPrompt = encodeURIComponent(prompt);
+  const baseUrl = 'https://image.pollinations.ai';
+  let url = `${baseUrl}/prompt/${encodedPrompt}`;
+
+  // Add query parameters
+  const queryString = queryParams.toString();
+  url += `?${queryString}`;
+
+  try {
+    // Prepare fetch options with optional auth headers
+    const fetchOptions = {};
+    if (authConfig) {
+      fetchOptions.headers = {};
+      if (authConfig.token) {
+        fetchOptions.headers['Authorization'] = `Bearer ${authConfig.token}`;
+      }
+      if (authConfig.referrer) {
+        fetchOptions.headers['Referer'] = authConfig.referrer;
+      }
+    }
+
+    // Fetch the image from the URL
+    const response = await fetch(url, fetchOptions);
+
+    if (!response.ok) {
+      throw new Error(`Failed to edit image: ${response.statusText}`);
+    }
+
+    // Get the image data as an ArrayBuffer
+    const imageBuffer = await response.arrayBuffer();
+
+    // Convert the ArrayBuffer to a base64 string
+    const base64Data = Buffer.from(imageBuffer).toString('base64');
+
+    // Determine the mime type from the response headers or default to image/jpeg
+    const contentType = response.headers.get('content-type') || 'image/jpeg';
+
+    // Prepare the result object
+    const result = {
+      data: base64Data,
+      mimeType: contentType,
+      metadata: {
+        prompt,
+        inputImageUrl: imageUrl,
+        width,
+        height,
+        model,
+        seed,
+        enhance,
+        private: true,
+        nologo: true,
+        safe,
+        transparent
+      }
+    };
+
+    // Always save the image to a file
+    // Import required modules
+    const fs = await import('fs');
+    const path = await import('path');
+
+    // Create the output directory if it doesn't exist
+    if (!fs.existsSync(outputPath)) {
+      fs.mkdirSync(outputPath, { recursive: true });
+    }
+
+    // Generate a filename if not provided
+    let finalFileName = fileName;
+    if (!finalFileName) {
+      // Create a filename from the prompt (first 20 characters) and timestamp
+      const sanitizedPrompt = prompt.replace(/[^a-zA-Z0-9]/g, '_').substring(0, 20);
+      const timestamp = Date.now();
+      const randomSuffix = Math.floor(Math.random() * 1000);
+      finalFileName = `edited_${sanitizedPrompt}_${timestamp}_${randomSuffix}`;
+    }
+
+    // Ensure the filename has the correct extension
+    const extension = format.toLowerCase();
+    if (!finalFileName.endsWith(`.${extension}`)) {
+      finalFileName += `.${extension}`;
+    }
+
+    // Check if file already exists and add a number suffix if needed
+    let finalFilePath = path.join(outputPath, finalFileName);
+    let counter = 1;
+    while (fs.existsSync(finalFilePath)) {
+      const nameWithoutExt = finalFileName.replace(`.${extension}`, '');
+      const numberedFileName = `${nameWithoutExt}_${counter}.${extension}`;
+      finalFilePath = path.join(outputPath, numberedFileName);
+      counter++;
+    }
+
+    // Write the image data to the file
+    fs.writeFileSync(finalFilePath, Buffer.from(base64Data, 'base64'));
+
+    // Add the file path to the result
+    result.filePath = finalFilePath;
+
+    return result;
+
+  } catch (error) {
+    console.error('Error editing image:', error);
+    throw error;
+  }
+}
+
+/**
+ * Generates a new image using an existing image as reference
+ *
+ * @param {string} prompt - The text description of what to generate based on the reference image
+ * @param {string} imageUrl - URL of the reference image
+ * @param {string} [model='gptimage'] - Model name to use for generation (gptimage or kontext)
+ * @param {number} [seed] - Seed for reproducible results (defaults to random if not specified)
+ * @param {number} [width=1024] - Width of the generated image
+ * @param {number} [height=1024] - Height of the generated image
+ * @param {boolean} [enhance=true] - Whether to enhance the prompt using an LLM before generating
+ * @param {boolean} [safe=false] - Whether to apply content filtering
+ * @param {boolean} [transparent=false] - Generate image with transparent background (gptimage model only)
+ * @param {string} [outputPath='./mcpollinations-output'] - Directory path where to save the image
+ * @param {string} [fileName] - Name of the file to save (without extension)
+ * @param {string} [format='png'] - Image format to save as (png, jpeg, jpg, webp)
+ * @param {Object} [authConfig] - Optional authentication configuration {token, referrer}
+ * @returns {Promise<Object>} - Object containing the base64 image data, mime type, metadata, and file path if saved
+ * @note Always includes nologo=true and private=true parameters
+ */
+export async function generateImageFromReference(prompt, imageUrl, model = 'gptimage', seed = Math.floor(Math.random() * 1000000), width = 1024, height = 1024, enhance = true, safe = false, transparent = false, outputPath = './mcpollinations-output', fileName = '', format = 'png', authConfig = null) {
+  if (!prompt || typeof prompt !== 'string') {
+    throw new Error('Prompt is required and must be a string');
+  }
+
+  if (!imageUrl || typeof imageUrl !== 'string') {
+    throw new Error('Reference image URL is required and must be a string');
+  }
+
+  // Build the query parameters
+  const queryParams = new URLSearchParams();
+  queryParams.append('model', model);
+  queryParams.append('image', imageUrl); // Add the reference image URL
+  if (seed !== undefined) queryParams.append('seed', seed);
+  if (width !== 1024) queryParams.append('width', width);
+  if (height !== 1024) queryParams.append('height', height);
+
+  // Add enhance parameter if true
+  if (enhance) queryParams.append('enhance', 'true');
+
+  // Add parameters
+  queryParams.append('nologo', 'true'); // Always set nologo to true
+  queryParams.append('private', 'true'); // Always set private to true)
+  queryParams.append('safe', safe.toString()); // Use the customizable safe parameter
+  if (transparent) queryParams.append('transparent', 'true'); // Add transparent parameter if true
+
+  // Construct the URL
+  const encodedPrompt = encodeURIComponent(prompt);
+  const baseUrl = 'https://image.pollinations.ai';
+  let url = `${baseUrl}/prompt/${encodedPrompt}`;
+
+  // Add query parameters
+  const queryString = queryParams.toString();
+  url += `?${queryString}`;
+
+  try {
+    // Prepare fetch options with optional auth headers
+    const fetchOptions = {};
+    if (authConfig) {
+      fetchOptions.headers = {};
+      if (authConfig.token) {
+        fetchOptions.headers['Authorization'] = `Bearer ${authConfig.token}`;
+      }
+      if (authConfig.referrer) {
+        fetchOptions.headers['Referer'] = authConfig.referrer;
+      }
+    }
+
+    // Fetch the image from the URL
+    const response = await fetch(url, fetchOptions);
+
+    if (!response.ok) {
+      throw new Error(`Failed to generate image from reference: ${response.statusText}`);
+    }
+
+    // Get the image data as an ArrayBuffer
+    const imageBuffer = await response.arrayBuffer();
+
+    // Convert the ArrayBuffer to a base64 string
+    const base64Data = Buffer.from(imageBuffer).toString('base64');
+
+    // Determine the mime type from the response headers or default to image/jpeg
+    const contentType = response.headers.get('content-type') || 'image/jpeg';
+
+    // Prepare the result object
+    const result = {
+      data: base64Data,
+      mimeType: contentType,
+      metadata: {
+        prompt,
+        referenceImageUrl: imageUrl,
+        width,
+        height,
+        model,
+        seed,
+        enhance,
+        private: true,
+        nologo: true,
+        safe,
+        transparent
+      }
+    };
+
+    // Always save the image to a file
+    // Import required modules
+    const fs = await import('fs');
+    const path = await import('path');
+
+    // Create the output directory if it doesn't exist
+    if (!fs.existsSync(outputPath)) {
+      fs.mkdirSync(outputPath, { recursive: true });
+    }
+
+    // Generate a filename if not provided
+    let finalFileName = fileName;
+    if (!finalFileName) {
+      // Create a filename from the prompt (first 20 characters) and timestamp
+      const sanitizedPrompt = prompt.replace(/[^a-zA-Z0-9]/g, '_').substring(0, 20);
+      const timestamp = Date.now();
+      const randomSuffix = Math.floor(Math.random() * 1000);
+      finalFileName = `reference_${sanitizedPrompt}_${timestamp}_${randomSuffix}`;
+    }
+
+    // Ensure the filename has the correct extension
+    const extension = format.toLowerCase();
+    if (!finalFileName.endsWith(`.${extension}`)) {
+      finalFileName += `.${extension}`;
+    }
+
+    // Check if file already exists and add a number suffix if needed
+    let finalFilePath = path.join(outputPath, finalFileName);
+    let counter = 1;
+    while (fs.existsSync(finalFilePath)) {
+      const nameWithoutExt = finalFileName.replace(`.${extension}`, '');
+      const numberedFileName = `${nameWithoutExt}_${counter}.${extension}`;
+      finalFilePath = path.join(outputPath, numberedFileName);
+      counter++;
+    }
+
+    // Write the image data to the file
+    fs.writeFileSync(finalFilePath, Buffer.from(base64Data, 'base64'));
+
+    // Add the file path to the result
+    result.filePath = finalFilePath;
+
+    return result;
+
+  } catch (error) {
+    console.error('Error generating image from reference:', error);
+    throw error;
+  }
+}
+
 /**
  * List available image generation models from Pollinations API
  *