@goonnguyen/human-mcp 2.8.0 → 2.8.2

package/dist/index.js

@@ -167922,29 +167922,48 @@ async function editImage(geminiClient, options, config) {
     const editingPrompt = buildEditingPrompt(options);
     logger2.info(`Image editing operation: ${options.operation}`);
     logger2.info(`Editing prompt: "${editingPrompt}"`);
-    const model = geminiClient.getModel("detailed");
+    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) {
-      throw new Error("No image candidates returned from Gemini API");
+      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 || !candidate.content.parts) {
-      throw new Error("Invalid response format from Gemini API");
+    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) {
-      throw new Error("No image data found in Gemini response");
+      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;
@@ -168161,6 +168180,68 @@ function estimateImageSize2(base64Data) {
 // 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`);
+    }
+    if (result.width && result.height) {
+      details.push(`Dimensions: ${result.width}x${result.height}`);
+    }
+    response.push({
+      type: "text",
+      text: `✅ Media generated successfully!
+
+URL: ${result.url}${details.length > 0 ? `
+` + details.join(", ") : ""}`
+    });
+    return response;
+  }
+  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")
+      }
+    ];
+  }
+  if (result.url) {
+    return [
+      {
+        type: "text",
+        text: `${contextText || "Media generated successfully"}
+
+URL: ${result.url}`
+      }
+    ];
+  }
+  return [
+    {
+      type: "text",
+      text: contextText || "Media generated successfully"
+    }
+  ];
+}
+
+// src/tools/hands/index.ts
 async function registerHandsTool(server, config) {
   const geminiClient = new GeminiClient(config);
   server.registerTool("gemini_gen_image", {
@@ -168440,21 +168521,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}"
@@ -168468,35 +168544,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
   };
 }
@@ -168521,34 +168578,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
   };
 }
@@ -168584,35 +168639,32 @@ async function handleImageToVideoGeneration(geminiClient, args, config) {
     filePrefix: "gemini-image-to-video"
   };
   const result = await generateImageToVideo(geminiClient, prompt, image_input, generationOptions, config);
+  const contextText = `✅ Video generated from image 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,
-          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)
-      }
-    ],
+    content: formattedResponse,
     isError: false
   };
 }
@@ -168670,21 +168722,16 @@ async function handleImageEditing(geminiClient, args, config) {
     filePrefix: `edited-${operation}`
   };
   const result = await editImage(geminiClient, editingOptions, config);
+  let base64Data;
+  let mimeType;
   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
+      mimeType = matches[1];
+      base64Data = matches[2];
+    }
+  }
+  const contextText = `✅ Image edited successfully using ${operation} operation
 
 **Editing Details:**
 - Operation: ${operation}
@@ -168705,36 +168752,16 @@ async function handleImageEditing(geminiClient, args, config) {
 **Operation Metadata:**
 - Strength: ${result.metadata.strength}
 - Guidance Scale: ${result.metadata.guidanceScale}
-- Seed: ${result.metadata.seed || "random"}` : ""}`
-          }
-        ],
-        isError: false
-      };
-    }
-  }
+- Seed: ${result.metadata.seed || "random"}` : ""}`;
+  const formattedResponse = formatMediaResponse({
+    url: result.fileUrl,
+    filePath: result.filePath,
+    base64: base64Data,
+    mimeType,
+    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.0",
+  "version": "2.8.2",
   "description": "Human MCP: Bringing Human Capabilities to Coding Agents",
   "type": "module",
   "main": "dist/index.js",