@goonnguyen/human-mcp 2.6.0 → 2.7.0

package/dist/index.js

@@ -132386,10 +132386,10 @@ var require_view = __commonJS((exports, module) => {
   var debug = require_src3()("express:view");
   var path5 = __require("node:path");
   var fs5 = __require("node:fs");
-  var dirname3 = path5.dirname;
+  var dirname2 = path5.dirname;
   var basename = path5.basename;
   var extname2 = path5.extname;
-  var join3 = path5.join;
+  var join2 = path5.join;
   var resolve = path5.resolve;
   module.exports = View;
   function View(name, options) {
@@ -132425,7 +132425,7 @@ var require_view = __commonJS((exports, module) => {
     for (var i = 0;i < roots.length && !path6; i++) {
       var root = roots[i];
       var loc = resolve(root, name);
-      var dir = dirname3(loc);
+      var dir = dirname2(loc);
       var file = basename(loc);
       path6 = this.resolve(dir, file);
     }
@@ -132451,12 +132451,12 @@ var require_view = __commonJS((exports, module) => {
   };
   View.prototype.resolve = function resolve(dir, file) {
     var ext = this.ext;
-    var path6 = join3(dir, file);
+    var path6 = join2(dir, file);
     var stat = tryStat(path6);
     if (stat && stat.isFile()) {
       return path6;
     }
-    path6 = join3(dir, basename(file, ext), "index" + ext);
+    path6 = join2(dir, basename(file, ext), "index" + ext);
     stat = tryStat(path6);
     if (stat && stat.isFile()) {
       return path6;
@@ -136217,7 +136217,7 @@ var require_send = __commonJS((exports, module) => {
   var Stream = __require("stream");
   var util3 = __require("util");
   var extname2 = path5.extname;
-  var join3 = path5.join;
+  var join2 = path5.join;
   var normalize = path5.normalize;
   var resolve = path5.resolve;
   var sep = path5.sep;
@@ -136389,7 +136389,7 @@ var require_send = __commonJS((exports, module) => {
         return res;
       }
       parts = path6.split(sep);
-      path6 = normalize(join3(root, path6));
+      path6 = normalize(join2(root, path6));
     } else {
       if (UP_PATH_REGEXP.test(path6)) {
         debug('malicious path "%s"', path6);
@@ -136529,7 +136529,7 @@ var require_send = __commonJS((exports, module) => {
           return self2.onStatError(err);
         return self2.error(404);
       }
-      var p = join3(path6, self2._index[i]);
+      var p = join2(path6, self2._index[i]);
       debug('stat "%s"', p);
       fs5.stat(p, function(err2, stat) {
         if (err2)
@@ -167234,6 +167234,35 @@ var VideoGenerationInputSchema = exports_external.object({
   camera_movement: exports_external.enum(["static", "pan_left", "pan_right", "zoom_in", "zoom_out", "dolly_forward", "dolly_backward"]).optional(),
   seed: exports_external.number().int().min(0).optional()
 });
+var ImageEditingInputSchema = exports_external.object({
+  operation: exports_external.enum([
+    "inpaint",
+    "outpaint",
+    "style_transfer",
+    "object_manipulation",
+    "multi_image_compose"
+  ]).describe("Type of image editing operation to perform"),
+  input_image: exports_external.string().describe("Base64 encoded image or file path to the input image"),
+  prompt: exports_external.string().min(1, "Prompt cannot be empty").describe("Text description of the desired edit"),
+  mask_image: exports_external.string().optional().describe("Base64 encoded mask image for inpainting (white = edit area, black = keep)"),
+  mask_prompt: exports_external.string().optional().describe("Text description of the area to mask for editing"),
+  expand_direction: exports_external.enum(["all", "left", "right", "top", "bottom", "horizontal", "vertical"]).optional().describe("Direction to expand the image"),
+  expansion_ratio: exports_external.number().min(0.1).max(3).optional().default(1.5).describe("How much to expand the image (1.0 = no expansion)"),
+  style_image: exports_external.string().optional().describe("Base64 encoded reference image for style transfer"),
+  style_strength: exports_external.number().min(0.1).max(1).optional().default(0.7).describe("Strength of style application"),
+  target_object: exports_external.string().optional().describe("Description of the object to manipulate"),
+  manipulation_type: exports_external.enum(["move", "resize", "remove", "replace", "duplicate"]).optional().describe("Type of object manipulation"),
+  target_position: exports_external.string().optional().describe("New position for the object (e.g., 'center', 'top-left')"),
+  secondary_images: exports_external.array(exports_external.string()).optional().describe("Array of base64 encoded images for composition"),
+  composition_layout: exports_external.enum(["blend", "collage", "overlay", "side_by_side"]).optional().describe("How to combine multiple images"),
+  blend_mode: exports_external.enum(["normal", "multiply", "screen", "overlay", "soft_light"]).optional().describe("Blending mode for image composition"),
+  negative_prompt: exports_external.string().optional().describe("What to avoid in the edited image"),
+  strength: exports_external.number().min(0.1).max(1).optional().default(0.8).describe("Strength of the editing effect"),
+  guidance_scale: exports_external.number().min(1).max(20).optional().default(7.5).describe("How closely to follow the prompt"),
+  seed: exports_external.number().int().min(0).optional().describe("Random seed for reproducible results"),
+  output_format: exports_external.enum(["base64", "url"]).optional().default("base64").describe("Output format for the edited image"),
+  quality: exports_external.enum(["draft", "standard", "high"]).optional().default("standard").describe("Quality level of the editing")
+});
 
 // src/utils/file-storage.ts
 import { writeFileSync, mkdirSync } from "fs";
@@ -167610,6 +167639,264 @@ function estimateVideoSize(duration, aspectRatio) {
   return `${width}x${height}`;
 }
 
+// src/tools/hands/processors/image-editor.ts
+function processImageDataUri(dataUri) {
+  const matches = dataUri.match(/^data:([^;]+);base64,(.+)$/);
+  if (!matches || !matches[1] || !matches[2]) {
+    throw new Error("Invalid data URI format");
+  }
+  return {
+    mimeType: matches[1],
+    data: matches[2]
+  };
+}
+async function editImage(geminiClient, options, config) {
+  const startTime = Date.now();
+  try {
+    const processedInputImage = await processImageForEditing(options.inputImage);
+    const editingPrompt = buildEditingPrompt(options);
+    logger2.info(`Image editing operation: ${options.operation}`);
+    logger2.info(`Editing prompt: "${editingPrompt}"`);
+    const model = geminiClient.getModel("detailed");
+    const requestContent = await buildRequestContent(options, processedInputImage, editingPrompt);
+    const response = await model.generateContent(requestContent);
+    const result = response.response;
+    const candidates = result.candidates;
+    if (!candidates || candidates.length === 0) {
+      throw new Error("No image candidates returned from Gemini API");
+    }
+    const candidate = candidates[0];
+    if (!candidate || !candidate.content || !candidate.content.parts) {
+      throw new Error("Invalid response format from Gemini API");
+    }
+    let imageData = null;
+    let mimeType = "image/jpeg";
+    for (const part of candidate.content.parts) {
+      if ("inlineData" in part && part.inlineData) {
+        imageData = part.inlineData.data;
+        mimeType = part.inlineData.mimeType || "image/jpeg";
+        break;
+      }
+    }
+    if (!imageData) {
+      throw new Error("No image data found in Gemini response");
+    }
+    const processingTime = Date.now() - startTime;
+    let resultData;
+    let format;
+    let filePath;
+    let fileName;
+    let fileUrl;
+    let fileSize;
+    const shouldSaveFile = options.saveToFile !== false;
+    const shouldUploadToR2 = options.uploadToR2 === true;
+    if (shouldSaveFile && config) {
+      try {
+        const savedFile = await saveBase64ToFile(imageData, mimeType, config, {
+          prefix: options.filePrefix || `edited-${options.operation}`,
+          directory: options.saveDirectory,
+          uploadToR2: shouldUploadToR2
+        });
+        filePath = savedFile.filePath;
+        fileName = savedFile.fileName;
+        fileUrl = savedFile.url;
+        fileSize = savedFile.size;
+        logger2.info(`Edited image saved to file: ${filePath}`);
+        if (options.outputFormat === "url") {
+          resultData = fileUrl || filePath || `data:${mimeType};base64,${imageData}`;
+          format = fileUrl ? "url" : "file_path";
+        } else {
+          resultData = `data:${mimeType};base64,${imageData}`;
+          format = "base64_data_uri";
+        }
+      } catch (error) {
+        logger2.warn(`Failed to save edited image file: ${error}. Falling back to base64 only.`);
+        resultData = `data:${mimeType};base64,${imageData}`;
+        format = "base64_data_uri";
+      }
+    } else {
+      if (options.outputFormat === "base64") {
+        resultData = `data:${mimeType};base64,${imageData}`;
+        format = "base64_data_uri";
+      } else {
+        resultData = `data:${mimeType};base64,${imageData}`;
+        format = "base64_data_uri";
+        logger2.warn("URL output format requested but file saving disabled. Returning base64 data URI");
+      }
+    }
+    return {
+      editedImageData: resultData,
+      format,
+      operation: options.operation,
+      processingTime,
+      originalSize: estimateImageSize2(processedInputImage.data),
+      editedSize: estimateImageSize2(imageData),
+      filePath,
+      fileName,
+      fileUrl,
+      fileSize,
+      metadata: {
+        prompt: options.prompt,
+        operation: options.operation,
+        strength: options.strength,
+        guidanceScale: options.guidanceScale,
+        seed: options.seed
+      }
+    };
+  } catch (error) {
+    const processingTime = Date.now() - startTime;
+    logger2.error(`Image editing failed after ${processingTime}ms:`, error);
+    if (error instanceof Error) {
+      if (error.message.includes("API key")) {
+        throw new Error("Invalid or missing Google AI API key. Please check your GOOGLE_GEMINI_API_KEY environment variable.");
+      }
+      if (error.message.includes("quota") || error.message.includes("rate limit")) {
+        throw new Error("API quota exceeded or rate limit reached. Please try again later.");
+      }
+      if (error.message.includes("safety") || error.message.includes("policy")) {
+        throw new Error("Image editing blocked due to safety policies. Please modify your request and try again.");
+      }
+      throw new Error(`Image editing failed: ${error.message}`);
+    }
+    throw new Error("Image editing failed due to an unexpected error");
+  }
+}
+async function processImageForEditing(inputImage) {
+  try {
+    if (inputImage.startsWith("data:")) {
+      const result = processImageDataUri(inputImage);
+      return {
+        data: result.data,
+        mimeType: result.mimeType
+      };
+    }
+    if (inputImage.startsWith("/") || inputImage.startsWith("./")) {
+      throw new Error("File path input not yet implemented. Please use base64 data URI format.");
+    }
+    return {
+      data: inputImage,
+      mimeType: "image/jpeg"
+    };
+  } catch (error) {
+    throw new Error(`Failed to process input image: ${error instanceof Error ? error.message : error}`);
+  }
+}
+function buildEditingPrompt(options) {
+  let prompt = options.prompt;
+  switch (options.operation) {
+    case "inpaint":
+      prompt = `Edit the specified area of this image: ${prompt}`;
+      if (options.maskPrompt) {
+        prompt += `. Focus on the area described as: ${options.maskPrompt}`;
+      }
+      break;
+    case "outpaint":
+      prompt = `Expand this image ${options.expandDirection || "in all directions"}: ${prompt}`;
+      if (options.expansionRatio && options.expansionRatio !== 1.5) {
+        prompt += `. Expansion ratio: ${options.expansionRatio}x`;
+      }
+      break;
+    case "style_transfer":
+      prompt = `Apply the following style to this image: ${prompt}`;
+      if (options.styleStrength && options.styleStrength !== 0.7) {
+        prompt += `. Style strength: ${options.styleStrength}`;
+      }
+      break;
+    case "object_manipulation":
+      if (options.targetObject) {
+        prompt = `${options.manipulationType || "modify"} the ${options.targetObject} in this image: ${prompt}`;
+        if (options.targetPosition) {
+          prompt += `. Position: ${options.targetPosition}`;
+        }
+      }
+      break;
+    case "multi_image_compose":
+      prompt = `Compose multiple images together: ${prompt}`;
+      if (options.compositionLayout) {
+        prompt += `. Layout: ${options.compositionLayout}`;
+      }
+      if (options.blendMode) {
+        prompt += `. Blend mode: ${options.blendMode}`;
+      }
+      break;
+  }
+  if (options.quality === "high") {
+    prompt += ". High quality, detailed result.";
+  } else if (options.quality === "draft") {
+    prompt += ". Quick draft version.";
+  }
+  if (options.negativePrompt) {
+    prompt += ` Avoid: ${options.negativePrompt}`;
+  }
+  return prompt;
+}
+async function buildRequestContent(options, processedInputImage, editingPrompt) {
+  const content = [
+    {
+      text: editingPrompt
+    },
+    {
+      inlineData: {
+        data: processedInputImage.data,
+        mimeType: processedInputImage.mimeType
+      }
+    }
+  ];
+  if (options.operation === "inpaint" && options.maskImage) {
+    try {
+      const processedMask = await processImageForEditing(options.maskImage);
+      content.push({
+        inlineData: {
+          data: processedMask.data,
+          mimeType: processedMask.mimeType
+        }
+      });
+    } catch (error) {
+      logger2.warn(`Failed to process mask image: ${error}. Proceeding without mask.`);
+    }
+  }
+  if (options.operation === "style_transfer" && options.styleImage) {
+    try {
+      const processedStyle = await processImageForEditing(options.styleImage);
+      content.push({
+        inlineData: {
+          data: processedStyle.data,
+          mimeType: processedStyle.mimeType
+        }
+      });
+    } catch (error) {
+      logger2.warn(`Failed to process style image: ${error}. Proceeding without style reference.`);
+    }
+  }
+  if (options.operation === "multi_image_compose" && options.secondaryImages) {
+    for (const secondaryImage of options.secondaryImages) {
+      try {
+        const processedSecondary = await processImageForEditing(secondaryImage);
+        content.push({
+          inlineData: {
+            data: processedSecondary.data,
+            mimeType: processedSecondary.mimeType
+          }
+        });
+      } catch (error) {
+        logger2.warn(`Failed to process secondary image: ${error}. Skipping this image.`);
+      }
+    }
+  }
+  return content;
+}
+function estimateImageSize2(base64Data) {
+  const dataLength = base64Data.length;
+  const estimatedBytes = dataLength * 3 / 4;
+  if (estimatedBytes < 1e5) {
+    return "512x512";
+  } else if (estimatedBytes < 400000) {
+    return "1024x1024";
+  } else {
+    return "1024x1024+";
+  }
+}
+
 // src/tools/hands/index.ts
 async function registerHandsTool(server, config) {
   const geminiClient = new GeminiClient(config);
@@ -167700,6 +167987,177 @@ async function registerHandsTool(server, config) {
       };
     }
   });
+  server.registerTool("gemini_edit_image", {
+    title: "Gemini Image Editing Tool",
+    description: "Edit images using AI with various operations like inpainting, outpainting, style transfer, object manipulation, and composition",
+    inputSchema: {
+      operation: exports_external.enum([
+        "inpaint",
+        "outpaint",
+        "style_transfer",
+        "object_manipulation",
+        "multi_image_compose"
+      ]).describe("Type of image editing operation to perform"),
+      input_image: exports_external.string().describe("Base64 encoded image or file path to the input image"),
+      prompt: exports_external.string().min(1, "Prompt cannot be empty").describe("Text description of the desired edit"),
+      mask_image: exports_external.string().optional().describe("Base64 encoded mask image for inpainting (white = edit area, black = keep)"),
+      mask_prompt: exports_external.string().optional().describe("Text description of the area to mask for editing"),
+      expand_direction: exports_external.enum(["all", "left", "right", "top", "bottom", "horizontal", "vertical"]).optional().describe("Direction to expand the image"),
+      expansion_ratio: exports_external.number().min(0.1).max(3).optional().default(1.5).describe("How much to expand the image (1.0 = no expansion)"),
+      style_image: exports_external.string().optional().describe("Base64 encoded reference image for style transfer"),
+      style_strength: exports_external.number().min(0.1).max(1).optional().default(0.7).describe("Strength of style application"),
+      target_object: exports_external.string().optional().describe("Description of the object to manipulate"),
+      manipulation_type: exports_external.enum(["move", "resize", "remove", "replace", "duplicate"]).optional().describe("Type of object manipulation"),
+      target_position: exports_external.string().optional().describe("New position for the object (e.g., 'center', 'top-left')"),
+      secondary_images: exports_external.array(exports_external.string()).optional().describe("Array of base64 encoded images for composition"),
+      composition_layout: exports_external.enum(["blend", "collage", "overlay", "side_by_side"]).optional().describe("How to combine multiple images"),
+      blend_mode: exports_external.enum(["normal", "multiply", "screen", "overlay", "soft_light"]).optional().describe("Blending mode for image composition"),
+      negative_prompt: exports_external.string().optional().describe("What to avoid in the edited image"),
+      strength: exports_external.number().min(0.1).max(1).optional().default(0.8).describe("Strength of the editing effect"),
+      guidance_scale: exports_external.number().min(1).max(20).optional().default(7.5).describe("How closely to follow the prompt"),
+      seed: exports_external.number().int().min(0).optional().describe("Random seed for reproducible results"),
+      output_format: exports_external.enum(["base64", "url"]).optional().default("base64").describe("Output format for the edited image"),
+      quality: exports_external.enum(["draft", "standard", "high"]).optional().default("standard").describe("Quality level of the editing")
+    }
+  }, async (args) => {
+    try {
+      return await handleImageEditing(geminiClient, args, config);
+    } catch (error) {
+      const mcpError = handleError(error);
+      logger2.error(`Tool gemini_edit_image error:`, mcpError);
+      return {
+        content: [{
+          type: "text",
+          text: `Error: ${mcpError.message}`
+        }],
+        isError: true
+      };
+    }
+  });
+  server.registerTool("gemini_inpaint_image", {
+    title: "Gemini Image Inpainting Tool",
+    description: "Fill or modify specific areas of an image based on a text prompt and mask",
+    inputSchema: {
+      input_image: exports_external.string().describe("Base64 encoded image or file path to the input image"),
+      prompt: exports_external.string().min(1, "Prompt cannot be empty").describe("Text description of what to paint in the masked area"),
+      mask_image: exports_external.string().optional().describe("Base64 encoded mask image (white = edit area, black = keep)"),
+      mask_prompt: exports_external.string().optional().describe("Text description of the area to mask for editing"),
+      negative_prompt: exports_external.string().optional().describe("What to avoid in the edited area"),
+      strength: exports_external.number().min(0.1).max(1).optional().default(0.8).describe("Strength of the editing effect"),
+      guidance_scale: exports_external.number().min(1).max(20).optional().default(7.5).describe("How closely to follow the prompt"),
+      seed: exports_external.number().int().min(0).optional().describe("Random seed for reproducible results"),
+      output_format: exports_external.enum(["base64", "url"]).optional().default("base64").describe("Output format"),
+      quality: exports_external.enum(["draft", "standard", "high"]).optional().default("standard").describe("Quality level")
+    }
+  }, async (args) => {
+    try {
+      const inpaintArgs = { ...args, operation: "inpaint" };
+      return await handleImageEditing(geminiClient, inpaintArgs, config);
+    } catch (error) {
+      const mcpError = handleError(error);
+      logger2.error(`Tool gemini_inpaint_image error:`, mcpError);
+      return {
+        content: [{
+          type: "text",
+          text: `Error: ${mcpError.message}`
+        }],
+        isError: true
+      };
+    }
+  });
+  server.registerTool("gemini_outpaint_image", {
+    title: "Gemini Image Outpainting Tool",
+    description: "Expand an image beyond its original borders in specified directions",
+    inputSchema: {
+      input_image: exports_external.string().describe("Base64 encoded image or file path to the input image"),
+      prompt: exports_external.string().min(1, "Prompt cannot be empty").describe("Text description of what to add in the expanded areas"),
+      expand_direction: exports_external.enum(["all", "left", "right", "top", "bottom", "horizontal", "vertical"]).optional().default("all").describe("Direction to expand the image"),
+      expansion_ratio: exports_external.number().min(0.1).max(3).optional().default(1.5).describe("How much to expand the image (1.0 = no expansion)"),
+      negative_prompt: exports_external.string().optional().describe("What to avoid in the expanded areas"),
+      strength: exports_external.number().min(0.1).max(1).optional().default(0.8).describe("Strength of the editing effect"),
+      guidance_scale: exports_external.number().min(1).max(20).optional().default(7.5).describe("How closely to follow the prompt"),
+      seed: exports_external.number().int().min(0).optional().describe("Random seed for reproducible results"),
+      output_format: exports_external.enum(["base64", "url"]).optional().default("base64").describe("Output format"),
+      quality: exports_external.enum(["draft", "standard", "high"]).optional().default("standard").describe("Quality level")
+    }
+  }, async (args) => {
+    try {
+      const outpaintArgs = { ...args, operation: "outpaint" };
+      return await handleImageEditing(geminiClient, outpaintArgs, config);
+    } catch (error) {
+      const mcpError = handleError(error);
+      logger2.error(`Tool gemini_outpaint_image error:`, mcpError);
+      return {
+        content: [{
+          type: "text",
+          text: `Error: ${mcpError.message}`
+        }],
+        isError: true
+      };
+    }
+  });
+  server.registerTool("gemini_style_transfer_image", {
+    title: "Gemini Style Transfer Tool",
+    description: "Transfer the style from one image to another using AI",
+    inputSchema: {
+      input_image: exports_external.string().describe("Base64 encoded image or file path to the input image"),
+      prompt: exports_external.string().min(1, "Prompt cannot be empty").describe("Text description of the desired style"),
+      style_image: exports_external.string().optional().describe("Base64 encoded reference image for style transfer"),
+      style_strength: exports_external.number().min(0.1).max(1).optional().default(0.7).describe("Strength of style application"),
+      negative_prompt: exports_external.string().optional().describe("What style elements to avoid"),
+      guidance_scale: exports_external.number().min(1).max(20).optional().default(7.5).describe("How closely to follow the prompt"),
+      seed: exports_external.number().int().min(0).optional().describe("Random seed for reproducible results"),
+      output_format: exports_external.enum(["base64", "url"]).optional().default("base64").describe("Output format"),
+      quality: exports_external.enum(["draft", "standard", "high"]).optional().default("standard").describe("Quality level")
+    }
+  }, async (args) => {
+    try {
+      const styleArgs = { ...args, operation: "style_transfer" };
+      return await handleImageEditing(geminiClient, styleArgs, config);
+    } catch (error) {
+      const mcpError = handleError(error);
+      logger2.error(`Tool gemini_style_transfer_image error:`, mcpError);
+      return {
+        content: [{
+          type: "text",
+          text: `Error: ${mcpError.message}`
+        }],
+        isError: true
+      };
+    }
+  });
+  server.registerTool("gemini_compose_images", {
+    title: "Gemini Image Composition Tool",
+    description: "Combine multiple images into a single composition using AI",
+    inputSchema: {
+      input_image: exports_external.string().describe("Base64 encoded primary image"),
+      secondary_images: exports_external.array(exports_external.string()).describe("Array of base64 encoded secondary images to compose"),
+      prompt: exports_external.string().min(1, "Prompt cannot be empty").describe("Text description of how to compose the images"),
+      composition_layout: exports_external.enum(["blend", "collage", "overlay", "side_by_side"]).optional().default("blend").describe("How to combine the images"),
+      blend_mode: exports_external.enum(["normal", "multiply", "screen", "overlay", "soft_light"]).optional().default("normal").describe("Blending mode for image composition"),
+      negative_prompt: exports_external.string().optional().describe("What to avoid in the composition"),
+      strength: exports_external.number().min(0.1).max(1).optional().default(0.8).describe("Strength of the composition effect"),
+      guidance_scale: exports_external.number().min(1).max(20).optional().default(7.5).describe("How closely to follow the prompt"),
+      seed: exports_external.number().int().min(0).optional().describe("Random seed for reproducible results"),
+      output_format: exports_external.enum(["base64", "url"]).optional().default("base64").describe("Output format"),
+      quality: exports_external.enum(["draft", "standard", "high"]).optional().default("standard").describe("Quality level")
+    }
+  }, async (args) => {
+    try {
+      const composeArgs = { ...args, operation: "multi_image_compose" };
+      return await handleImageEditing(geminiClient, composeArgs, config);
+    } catch (error) {
+      const mcpError = handleError(error);
+      logger2.error(`Tool gemini_compose_images error:`, mcpError);
+      return {
+        content: [{
+          type: "text",
+          text: `Error: ${mcpError.message}`
+        }],
+        isError: true
+      };
+    }
+  });
 }
 async function handleImageGeneration(geminiClient, args, config) {
   const input = ImageGenerationInputSchema.parse(args);
@@ -167895,6 +168353,128 @@ async function handleImageToVideoGeneration(geminiClient, args, config) {
     isError: false
   };
 }
+async function handleImageEditing(geminiClient, args, config) {
+  const input = ImageEditingInputSchema.parse(args);
+  const {
+    operation,
+    input_image,
+    prompt,
+    mask_image,
+    mask_prompt,
+    expand_direction,
+    expansion_ratio,
+    style_image,
+    style_strength,
+    target_object,
+    manipulation_type,
+    target_position,
+    secondary_images,
+    composition_layout,
+    blend_mode,
+    negative_prompt,
+    strength,
+    guidance_scale,
+    seed,
+    output_format,
+    quality
+  } = input;
+  logger2.info(`Editing image with operation: "${operation}" and prompt: "${prompt}"`);
+  const editingOptions = {
+    operation,
+    inputImage: input_image,
+    prompt,
+    maskImage: mask_image,
+    maskPrompt: mask_prompt,
+    expandDirection: expand_direction,
+    expansionRatio: expansion_ratio || 1.5,
+    styleImage: style_image,
+    styleStrength: style_strength || 0.7,
+    targetObject: target_object,
+    manipulationType: manipulation_type,
+    targetPosition: target_position,
+    secondaryImages: secondary_images,
+    compositionLayout: composition_layout,
+    blendMode: blend_mode,
+    negativePrompt: negative_prompt,
+    strength: strength || 0.8,
+    guidanceScale: guidance_scale || 7.5,
+    seed,
+    outputFormat: output_format || "base64",
+    quality: quality || "standard",
+    fetchTimeout: config.server.fetchTimeout,
+    saveToFile: true,
+    uploadToR2: config.cloudflare?.accessKey ? true : false,
+    filePrefix: `edited-${operation}`
+  };
+  const result = await editImage(geminiClient, editingOptions, config);
+  if (result.editedImageData.startsWith("data:")) {
+    const matches = result.editedImageData.match(/data:([^;]+);base64,(.+)/);
+    if (matches && matches[1] && matches[2]) {
+      const mimeType = matches[1];
+      const base64Data = matches[2];
+      return {
+        content: [
+          {
+            type: "image",
+            data: base64Data,
+            mimeType
+          },
+          {
+            type: "text",
+            text: `✅ Image edited successfully using ${operation} operation
+
+**Editing Details:**
+- Operation: ${operation}
+- Prompt: "${prompt}"
+- Format: ${result.format}
+- Original Size: ${result.originalSize}
+- Edited Size: ${result.editedSize}
+- Processing Time: ${result.processingTime}ms
+- Quality: ${quality}
+- Timestamp: ${new Date().toISOString()}${result.filePath ? `
+
+**File Information:**
+- File Path: ${result.filePath}
+- File Name: ${result.fileName}
+- File Size: ${result.fileSize} bytes` : ""}${result.fileUrl ? `
+- Public URL: ${result.fileUrl}` : ""}${result.metadata ? `
+
+**Operation Metadata:**
+- Strength: ${result.metadata.strength}
+- Guidance Scale: ${result.metadata.guidanceScale}
+- Seed: ${result.metadata.seed || "random"}` : ""}`
+          }
+        ],
+        isError: false
+      };
+    }
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: `✅ Image edited successfully!
+
+**Editing Details:**
+- Operation: ${operation}
+- Prompt: "${prompt}"
+- Format: ${result.format}
+- Original Size: ${result.originalSize}
+- Edited Size: ${result.editedSize}
+- Processing Time: ${result.processingTime}ms${result.filePath ? `
+
+**File Information:**
+- File Path: ${result.filePath}
+- File Name: ${result.fileName}
+- File Size: ${result.fileSize} bytes` : ""}${result.fileUrl ? `
+- Public URL: ${result.fileUrl}` : ""}
+
+**Edited Image Data:** ${result.editedImageData.substring(0, 100)}...`
+      }
+    ],
+    isError: false
+  };
+}
 
 // src/tools/mouth/schemas.ts
 var VoiceNames = [
@@ -169356,320 +169936,6 @@ ${session.finalAnswer}
   return output;
 }
 
-// src/tools/brain/native/memory.ts
-import { readFile, writeFile, mkdir } from "fs/promises";
-import { existsSync } from "fs";
-import { join as join2, dirname as dirname2 } from "path";
-class MemoryManager {
-  memoryPath;
-  graph;
-  constructor(memoryPath) {
-    this.memoryPath = memoryPath || join2(process.cwd(), "data", "memory.json");
-    this.graph = {
-      entities: [],
-      relations: [],
-      metadata: {
-        version: "1.0.0",
-        createdAt: Date.now(),
-        updatedAt: Date.now(),
-        totalEntities: 0,
-        totalRelations: 0
-      }
-    };
-  }
-  async initialize() {
-    try {
-      const dir = dirname2(this.memoryPath);
-      if (!existsSync(dir)) {
-        await mkdir(dir, { recursive: true });
-      }
-      if (existsSync(this.memoryPath)) {
-        await this.loadMemory();
-      } else {
-        await this.saveMemory();
-      }
-    } catch (error) {
-      logger2.warn("Failed to initialize memory:", error);
-    }
-  }
-  async loadMemory() {
-    try {
-      const data = await readFile(this.memoryPath, "utf-8");
-      this.graph = JSON.parse(data);
-      if (!this.graph.metadata) {
-        this.graph.metadata = {
-          version: "1.0.0",
-          createdAt: Date.now(),
-          updatedAt: Date.now(),
-          totalEntities: this.graph.entities.length,
-          totalRelations: this.graph.relations.length
-        };
-      }
-    } catch (error) {
-      logger2.error("Failed to load memory:", error);
-      throw new Error("Memory file corrupted or unreadable");
-    }
-  }
-  async saveMemory() {
-    try {
-      this.graph.metadata.updatedAt = Date.now();
-      this.graph.metadata.totalEntities = this.graph.entities.length;
-      this.graph.metadata.totalRelations = this.graph.relations.length;
-      await writeFile(this.memoryPath, JSON.stringify(this.graph, null, 2));
-    } catch (error) {
-      logger2.error("Failed to save memory:", error);
-      throw new Error("Unable to persist memory");
-    }
-  }
-  async createEntity(name, entityType, observations = []) {
-    const existing = this.graph.entities.find((e) => e.name === name);
-    if (existing) {
-      throw new Error(`Entity '${name}' already exists`);
-    }
-    const entity = {
-      name,
-      entityType,
-      observations,
-      createdAt: Date.now(),
-      updatedAt: Date.now()
-    };
-    this.graph.entities.push(entity);
-    await this.saveMemory();
-    return entity;
-  }
-  async addObservation(entityName, observation) {
-    const entity = this.graph.entities.find((e) => e.name === entityName);
-    if (!entity) {
-      throw new Error(`Entity '${entityName}' not found`);
-    }
-    entity.observations.push(observation);
-    entity.updatedAt = Date.now();
-    await this.saveMemory();
-    return entity;
-  }
-  async createRelation(from, to, relationType) {
-    const fromEntity = this.graph.entities.find((e) => e.name === from);
-    const toEntity = this.graph.entities.find((e) => e.name === to);
-    if (!fromEntity) {
-      throw new Error(`Source entity '${from}' not found`);
-    }
-    if (!toEntity) {
-      throw new Error(`Target entity '${to}' not found`);
-    }
-    const existing = this.graph.relations.find((r) => r.from === from && r.to === to && r.relationType === relationType);
-    if (existing) {
-      throw new Error(`Relation '${from}' -> '${to}' (${relationType}) already exists`);
-    }
-    const relation = {
-      from,
-      to,
-      relationType,
-      createdAt: Date.now()
-    };
-    this.graph.relations.push(relation);
-    await this.saveMemory();
-    return relation;
-  }
-  async searchEntities(query, limit = 10) {
-    const lowerQuery = query.toLowerCase();
-    return this.graph.entities.filter((entity) => entity.name.toLowerCase().includes(lowerQuery) || entity.entityType.toLowerCase().includes(lowerQuery) || entity.observations.some((obs) => obs.toLowerCase().includes(lowerQuery))).slice(0, limit);
-  }
-  async getEntity(name) {
-    return this.graph.entities.find((e) => e.name === name) || null;
-  }
-  async getRelatedEntities(entityName) {
-    const incoming = this.graph.relations.filter((r) => r.to === entityName);
-    const outgoing = this.graph.relations.filter((r) => r.from === entityName);
-    return { incoming, outgoing };
-  }
-  getStats() {
-    const types2 = [...new Set(this.graph.entities.map((e) => e.entityType))];
-    return {
-      entities: this.graph.entities.length,
-      relations: this.graph.relations.length,
-      types: types2
-    };
-  }
-}
-var memoryManager;
-async function registerMemoryTools(server, config) {
-  logger2.info("Registering native memory tools...");
-  memoryManager = new MemoryManager;
-  await memoryManager.initialize();
-  server.registerTool("mcp__memory__store", {
-    title: "Store information in memory",
-    description: "Create entities, relations, and observations in the knowledge graph",
-    inputSchema: {
-      action: exports_external.enum(["create_entity", "add_observation", "create_relation"]).describe("The action to perform"),
-      entityName: exports_external.string().describe("Name of the entity"),
-      entityType: exports_external.string().optional().describe("Type of entity (e.g., person, concept, project)"),
-      observation: exports_external.string().optional().describe("Observation to add to entity"),
-      targetEntity: exports_external.string().optional().describe("Target entity for relation"),
-      relationType: exports_external.string().optional().describe("Type of relation (e.g., 'works_with', 'part_of', 'causes')")
-    }
-  }, async (args) => {
-    try {
-      const action = args.action;
-      const entityName = args.entityName;
-      let result;
-      switch (action) {
-        case "create_entity":
-          const entityType = args.entityType || "general";
-          result = await memoryManager.createEntity(entityName, entityType);
-          break;
-        case "add_observation":
-          const observation = args.observation;
-          if (!observation) {
-            throw new Error("Observation is required");
-          }
-          result = await memoryManager.addObservation(entityName, observation);
-          break;
-        case "create_relation":
-          const targetEntity = args.targetEntity;
-          const relationType = args.relationType;
-          if (!targetEntity || !relationType) {
-            throw new Error("targetEntity and relationType are required for relations");
-          }
-          result = await memoryManager.createRelation(entityName, targetEntity, relationType);
-          break;
-        default:
-          throw new Error(`Unknown action: ${action}`);
-      }
-      return {
-        content: [{
-          type: "text",
-          text: `✅ ${action.replace("_", " ").toUpperCase()} completed successfully
-
-${JSON.stringify(result, null, 2)}`
-        }],
-        isError: false
-      };
-    } catch (error) {
-      const mcpError = handleError(error);
-      logger2.error("Memory store tool error:", mcpError);
-      return {
-        content: [{
-          type: "text",
-          text: `❌ Error: ${mcpError.message}`
-        }],
-        isError: true
-      };
-    }
-  });
-  server.registerTool("mcp__memory__recall", {
-    title: "Recall information from memory",
-    description: "Search and retrieve entities, relations, and observations",
-    inputSchema: {
-      action: exports_external.enum(["search", "get_entity", "get_relations", "get_stats"]).describe("The recall action to perform"),
-      query: exports_external.string().optional().describe("Search query"),
-      entityName: exports_external.string().optional().describe("Name of specific entity to retrieve"),
-      limit: exports_external.number().int().default(10).optional().describe("Maximum number of results")
-    }
-  }, async (args) => {
-    try {
-      const action = args.action;
-      let result;
-      switch (action) {
-        case "search":
-          const query = args.query;
-          if (!query) {
-            throw new Error("Query is required for search");
-          }
-          const limit = args.limit || 10;
-          result = await memoryManager.searchEntities(query, limit);
-          break;
-        case "get_entity":
-          const entityName = args.entityName;
-          if (!entityName) {
-            throw new Error("entityName is required");
-          }
-          result = await memoryManager.getEntity(entityName);
-          break;
-        case "get_relations":
-          const entityNameForRelations = args.entityName;
-          if (!entityNameForRelations) {
-            throw new Error("entityName is required for relations");
-          }
-          result = await memoryManager.getRelatedEntities(entityNameForRelations);
-          break;
-        case "get_stats":
-          result = memoryManager.getStats();
-          break;
-        default:
-          throw new Error(`Unknown action: ${action}`);
-      }
-      return {
-        content: [{
-          type: "text",
-          text: formatMemoryResult(action, result)
-        }],
-        isError: false
-      };
-    } catch (error) {
-      const mcpError = handleError(error);
-      logger2.error("Memory recall tool error:", mcpError);
-      return {
-        content: [{
-          type: "text",
-          text: `❌ Error: ${mcpError.message}`
-        }],
-        isError: true
-      };
-    }
-  });
-  logger2.info("Native memory tools registered successfully");
-}
-function formatMemoryResult(action, result) {
-  switch (action) {
-    case "search":
-      if (!result || result.length === 0) {
-        return "\uD83D\uDD0D No entities found matching the search criteria.";
-      }
-      return `\uD83D\uDD0D **Search Results** (${result.length} found)
-
-` + result.map((entity) => `**${entity.name}** (${entity.entityType})
-` + `Observations: ${entity.observations.length}
-` + `${entity.observations.slice(0, 2).map((obs) => `• ${obs}`).join(`
-`)}` + (entity.observations.length > 2 ? `
-• ...` : "")).join(`
-
-`);
-    case "get_entity":
-      if (!result) {
-        return "\uD83D\uDEAB Entity not found.";
-      }
-      return `\uD83D\uDCCB **Entity: ${result.name}**
-
-` + `**Type:** ${result.entityType}
-` + `**Created:** ${new Date(result.createdAt).toLocaleString()}
-` + `**Updated:** ${new Date(result.updatedAt).toLocaleString()}
-
-` + `**Observations (${result.observations.length}):**
-` + result.observations.map((obs) => `• ${obs}`).join(`
-`);
-    case "get_relations":
-      const { incoming, outgoing } = result;
-      return `\uD83D\uDD17 **Relations for Entity**
-
-` + `**Incoming (${incoming.length}):**
-` + (incoming.length > 0 ? incoming.map((rel) => `• ${rel.from} --[${rel.relationType}]--> entity`).join(`
-`) : "• None") + `
-
-` + `**Outgoing (${outgoing.length}):**
-` + (outgoing.length > 0 ? outgoing.map((rel) => `• entity --[${rel.relationType}]--> ${rel.to}`).join(`
-`) : "• None");
-    case "get_stats":
-      return `\uD83D\uDCCA **Memory Statistics**
-
-` + `**Entities:** ${result.entities}
-` + `**Relations:** ${result.relations}
-` + `**Entity Types:** ${result.types.join(", ")}
-`;
-    default:
-      return JSON.stringify(result, null, 2);
-  }
-}
-
 // src/tools/brain/native/simple-reasoning.ts
 var REASONING_PATTERNS = {
   problem_solving: {
@@ -170443,7 +170709,6 @@ Generate specific, actionable recommendations for next steps.
 async function registerBrainTools(server, config) {
   logger2.info("Registering optimized Brain tools (native + enhanced hybrid)...");
   await registerSequentialThinkingTool(server, config);
-  await registerMemoryTools(server, config);
   await registerSimpleReasoningTools(server, config);
   await registerEnhancedReflectionTool(server, config);
   logger2.info("✅ Brain tools optimization complete:");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goonnguyen/human-mcp",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "description": "Human MCP: Bringing Human Capabilities to Coding Agents",
   "type": "module",
   "main": "dist/index.js",