@goonnguyen/human-mcp 2.8.1 → 2.8.3

package/dist/index.js

@@ -167915,271 +167915,72 @@ function estimateVideoSize(duration, aspectRatio) {
 // src/tools/hands/processors/image-editor.ts
 init_logger();
 init_image_loader();
-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.getImageGenerationModel();
-    const requestContent = await buildRequestContent(options, processedInputImage, editingPrompt);
-    const response = await model.generateContent(requestContent);
-    const result = response.response;
-    const candidates = result.candidates;
-    logger2.debug(`Gemini API response structure: ${JSON.stringify({
-      hasCandidates: !!candidates,
-      candidatesLength: candidates?.length,
-      firstCandidate: candidates?.[0] ? {
-        hasContent: !!candidates[0].content,
-        hasParts: !!candidates[0].content?.parts,
-        partsLength: candidates[0].content?.parts?.length
-      } : null
-    })}`);
-    if (!candidates || candidates.length === 0) {
-      logger2.error("No candidates in Gemini response. Full response:", JSON.stringify(result, null, 2));
-      throw new Error("No image candidates returned from Gemini API. This may indicate the API doesn't support image editing yet, or the request format is incorrect.");
-    }
-    const candidate = candidates[0];
-    if (!candidate || !candidate.content) {
-      logger2.error("Invalid candidate structure:", JSON.stringify(candidate, null, 2));
-      throw new Error("Invalid response format from Gemini API: missing candidate content");
-    }
-    if (!candidate.content.parts || candidate.content.parts.length === 0) {
-      logger2.error("No parts in candidate content:", JSON.stringify(candidate.content, null, 2));
-      throw new Error("Invalid response format from Gemini API: missing content parts. Note: Gemini image editing may not be available in the current API version.");
-    }
-    let imageData = null;
-    let mimeType = "image/jpeg";
-    logger2.debug(`Searching for image data in ${candidate.content.parts.length} parts`);
-    for (const part of candidate.content.parts) {
-      logger2.debug(`Part type: ${JSON.stringify(Object.keys(part))}`);
-      if ("inlineData" in part && part.inlineData) {
-        imageData = part.inlineData.data;
-        mimeType = part.inlineData.mimeType || "image/jpeg";
-        logger2.info(`Found image data: ${imageData.length} bytes, type: ${mimeType}`);
-        break;
-      }
-    }
-    if (!imageData) {
-      logger2.error("No image data found in response parts:", JSON.stringify(candidate.content.parts, null, 2));
-      throw new Error("No image data found in Gemini response. The API may have returned text instead of an edited image.");
-    }
-    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");
+
+// src/tools/hands/index.ts
+init_logger();
+init_errors();
+
+// src/utils/response-formatter.ts
+function formatMediaResponse(result, config, contextText) {
+  const isHttpTransport = config.transport.type === "http" || config.transport.type === "both" && config.transport.http?.enabled;
+  if (isHttpTransport && result.url) {
+    const response = [];
+    response.push({
+      type: "resource",
+      resource: {
+        uri: result.url,
+        mimeType: result.mimeType || "image/png",
+        text: contextText || `Generated media available at: ${result.url}`
       }
+    });
+    const details = [];
+    if (result.size) {
+      details.push(`Size: ${(result.size / 1024).toFixed(2)} KB`);
     }
-    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}`);
+    if (result.width && result.height) {
+      details.push(`Dimensions: ${result.width}x${result.height}`);
     }
-    throw new Error("Image editing failed due to an unexpected error");
-  }
-}
-async function processImageForEditing(inputImage) {
-  try {
-    const result = await loadImageForProcessing(inputImage, {
-      fetchTimeout: 30000,
-      maxWidth: 1024,
-      maxHeight: 1024,
-      quality: 85
+    response.push({
+      type: "text",
+      text: `✅ Media generated successfully!
+
+URL: ${result.url}${details.length > 0 ? `
+` + details.join(", ") : ""}`
     });
-    return {
-      data: result.data,
-      mimeType: result.mimeType
-    };
-  } catch (error) {
-    throw new Error(`Failed to process input image: ${error instanceof Error ? error.message : error}`);
+    return response;
   }
-}
-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}`;
+  if (result.base64) {
+    return [
+      {
+        type: "image",
+        data: result.base64,
+        mimeType: result.mimeType || "image/png"
+      },
+      {
+        type: "text",
+        text: contextText || (result.url ? `Image URL: ${result.url}` : "Image generated successfully")
       }
-      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}`;
+  if (result.url) {
+    return [
+      {
+        type: "text",
+        text: `${contextText || "Media generated successfully"}
+
+URL: ${result.url}`
+      }
+    ];
   }
-  return prompt;
-}
-async function buildRequestContent(options, processedInputImage, editingPrompt) {
-  const content = [
+  return [
     {
-      text: editingPrompt
-    },
-    {
-      inlineData: {
-        data: processedInputImage.data,
-        mimeType: processedInputImage.mimeType
-      }
+      type: "text",
+      text: contextText || "Media generated successfully"
     }
   ];
-  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
-init_logger();
-init_errors();
 async function registerHandsTool(server, config) {
   const geminiClient = new GeminiClient(config);
   server.registerTool("gemini_gen_image", {
@@ -168269,177 +168070,6 @@ 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);
@@ -168459,21 +168089,16 @@ async function handleImageGeneration(geminiClient, args, config) {
     filePrefix: "gemini-image"
   };
   const result = await generateImage(geminiClient, generationOptions, config);
+  let base64Data;
+  let mimeType;
   if (result.imageData.startsWith("data:")) {
     const matches = result.imageData.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 generated successfully using ${result.model}
+      mimeType = matches[1];
+      base64Data = matches[2];
+    }
+  }
+  const contextText = `✅ Image generated successfully using ${result.model}
 
 **Generation Details:**
 - Prompt: "${prompt}"
@@ -168487,35 +168112,16 @@ async function handleImageGeneration(geminiClient, args, config) {
 - File Path: ${result.filePath}
 - File Name: ${result.fileName}
 - File Size: ${result.fileSize} bytes` : ""}${result.fileUrl ? `
-- Public URL: ${result.fileUrl}` : ""}`
-          }
-        ],
-        isError: false
-      };
-    }
-  }
+- Public URL: ${result.fileUrl}` : ""}`;
+  const formattedResponse = formatMediaResponse({
+    url: result.fileUrl,
+    filePath: result.filePath,
+    base64: base64Data,
+    mimeType,
+    size: result.fileSize
+  }, config, contextText);
   return {
-    content: [
-      {
-        type: "text",
-        text: `✅ Image generated successfully!
-
-**Generation Details:**
-- Prompt: "${prompt}"
-- Model: ${result.model}
-- Format: ${result.format}
-- Size: ${result.size}
-- Generation Time: ${result.generationTime}ms${result.filePath ? `
-
-**File Information:**
-- File Path: ${result.filePath}
-- File Name: ${result.fileName}
-- File Size: ${result.fileSize} bytes` : ""}${result.fileUrl ? `
-- Public URL: ${result.fileUrl}` : ""}
-
-**Image Data:** ${result.imageData.substring(0, 100)}...`
-      }
-    ],
+    content: formattedResponse,
     isError: false
   };
 }
@@ -168540,34 +168146,32 @@ async function handleVideoGeneration(geminiClient, args, config) {
     filePrefix: "gemini-video"
   };
   const result = await generateVideo(geminiClient, generationOptions, config);
+  const contextText = `✅ Video generated successfully!
+
+**Generation Details:**
+- Prompt: "${prompt}"
+- Model: ${result.model}
+- Format: ${result.format}
+- Duration: ${result.duration}
+- Aspect Ratio: ${result.aspectRatio}
+- FPS: ${result.fps}
+- Generation Time: ${result.generationTime}ms
+- Operation ID: ${result.operationId}
+- 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}` : ""}`;
+  const formattedResponse = formatMediaResponse({
+    url: result.fileUrl,
+    filePath: result.filePath,
+    mimeType: `video/${result.format}`,
+    size: result.fileSize
+  }, config, contextText);
   return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          video: result.filePath ? `File saved to: ${result.filePath}` : result.videoData.substring(0, 100) + "...",
-          format: result.format,
-          model: result.model,
-          prompt,
-          operation_id: result.operationId,
-          file_info: result.filePath ? {
-            file_path: result.filePath,
-            file_name: result.fileName,
-            file_size: result.fileSize,
-            public_url: result.fileUrl
-          } : null,
-          metadata: {
-            timestamp: new Date().toISOString(),
-            generation_time: result.generationTime,
-            duration: result.duration,
-            aspect_ratio: result.aspectRatio,
-            fps: result.fps,
-            size: result.size
-          }
-        }, null, 2)
-      }
-    ],
+    content: formattedResponse,
     isError: false
   };
 }
@@ -168603,157 +168207,32 @@ async function handleImageToVideoGeneration(geminiClient, args, config) {
     filePrefix: "gemini-image-to-video"
   };
   const result = await generateImageToVideo(geminiClient, prompt, image_input, generationOptions, config);
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          video: result.filePath ? `File saved to: ${result.filePath}` : result.videoData.substring(0, 100) + "...",
-          format: result.format,
-          model: result.model,
-          prompt,
-          image_input,
-          operation_id: result.operationId,
-          file_info: result.filePath ? {
-            file_path: result.filePath,
-            file_name: result.fileName,
-            file_size: result.fileSize,
-            public_url: result.fileUrl
-          } : null,
-          metadata: {
-            timestamp: new Date().toISOString(),
-            generation_time: result.generationTime,
-            duration: result.duration,
-            aspect_ratio: result.aspectRatio,
-            fps: result.fps,
-            size: result.size
-          }
-        }, null, 2)
-      }
-    ],
-    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
+  const contextText = `✅ Video generated from image successfully!
 
-**Editing Details:**
-- Operation: ${operation}
+**Generation Details:**
 - Prompt: "${prompt}"
+- Model: ${result.model}
 - Format: ${result.format}
-- Original Size: ${result.originalSize}
-- Edited Size: ${result.editedSize}
-- Processing Time: ${result.processingTime}ms
-- Quality: ${quality}
+- Duration: ${result.duration}
+- Aspect Ratio: ${result.aspectRatio}
+- FPS: ${result.fps}
+- Generation Time: ${result.generationTime}ms
+- Operation ID: ${result.operationId}
 - 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
-      };
-    }
-  }
+- Public URL: ${result.fileUrl}` : ""}`;
+  const formattedResponse = formatMediaResponse({
+    url: result.fileUrl,
+    filePath: result.filePath,
+    mimeType: `video/${result.format}`,
+    size: result.fileSize
+  }, config, contextText);
   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)}...`
-      }
-    ],
+    content: formattedResponse,
     isError: false
   };
 }

package/package.json

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