@goonnguyen/human-mcp 2.4.0 → 2.5.0

package/dist/index.js

@@ -160065,41 +160065,98 @@ function getCloudflareR2() {
 // src/tools/eyes/processors/image.ts
 async function processImage(model, source, options) {
   const startTime = Date.now();
-  try {
-    logger2.debug(`Processing image: ${source.substring(0, 50)}...`);
-    const { imageData, mimeType } = await loadImage(source, options.fetchTimeout);
-    const prompt = createPrompt(options);
-    const response = await model.generateContent([
-      { text: prompt },
-      {
-        inlineData: {
-          mimeType,
-          data: imageData
+  const maxRetries = 3;
+  let lastError = null;
+  for (let attempt = 1;attempt <= maxRetries; attempt++) {
+    try {
+      logger2.debug(`Processing image (attempt ${attempt}/${maxRetries}): ${source.substring(0, 50)}...`);
+      const { imageData, mimeType } = await loadImage(source, options.fetchTimeout);
+      const prompt = createPrompt(options);
+      logger2.debug(`Generated prompt for analysis: ${prompt.substring(0, 100)}...`);
+      logger2.debug(`Image data size: ${imageData.length} characters, MIME type: ${mimeType}`);
+      const response = await model.generateContent([
+        { text: prompt },
+        {
+          inlineData: {
+            mimeType,
+            data: imageData
+          }
         }
+      ]);
+      const result = await response.response;
+      const analysisText = result.text();
+      logger2.debug(`Gemini response received. Text length: ${analysisText ? analysisText.length : 0}`);
+      if (!analysisText || analysisText.trim().length === 0) {
+        const errorMsg = `Gemini returned empty response on attempt ${attempt}/${maxRetries}`;
+        logger2.warn(errorMsg);
+        if (attempt === maxRetries) {
+          logger2.info("Using fallback analysis due to empty Gemini response");
+          const fallbackAnalysis = "Image was processed but detailed analysis is unavailable. This may be due to API limitations or content restrictions.";
+          return {
+            description: "Image analysis completed with limited results",
+            analysis: fallbackAnalysis,
+            elements: [],
+            insights: ["Gemini API returned empty response", "Consider retrying the analysis"],
+            recommendations: ["Check image format and content", "Verify API key and quotas"],
+            metadata: {
+              processing_time_ms: Date.now() - startTime,
+              model_used: model.model,
+              attempts_made: maxRetries,
+              status: "partial_success"
+            }
+          };
+        }
+        const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
+        logger2.debug(`Retrying in ${delay}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        continue;
       }
-    ]);
-    const result = await response.response;
-    const analysisText = result.text();
-    if (!analysisText) {
-      throw new ProcessingError("No analysis result from Gemini");
-    }
-    const parsed = parseAnalysisResponse(analysisText);
-    const processingTime = Date.now() - startTime;
-    return {
-      description: parsed.description || "Image analysis completed",
-      analysis: parsed.analysis || analysisText,
-      elements: parsed.elements || [],
-      insights: parsed.insights || [],
-      recommendations: parsed.recommendations || [],
-      metadata: {
-        processing_time_ms: processingTime,
-        model_used: model.model
+      const parsed = parseAnalysisResponse(analysisText);
+      const processingTime = Date.now() - startTime;
+      logger2.info(`Image analysis successful on attempt ${attempt}. Processing time: ${processingTime}ms`);
+      return {
+        description: parsed.description || "Image analysis completed",
+        analysis: parsed.analysis || analysisText,
+        elements: parsed.elements || [],
+        insights: parsed.insights || [],
+        recommendations: parsed.recommendations || [],
+        metadata: {
+          processing_time_ms: processingTime,
+          model_used: model.model,
+          attempts_made: attempt,
+          status: "success"
+        }
+      };
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error("Unknown error");
+      logger2.warn(`Image processing attempt ${attempt} failed:`, lastError.message);
+      if (attempt < maxRetries && isRetryableError(lastError)) {
+        const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
+        logger2.debug(`Retrying in ${delay}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        continue;
+      } else if (attempt === maxRetries) {
+        break;
       }
-    };
-  } catch (error) {
-    logger2.error("Image processing error:", error);
-    throw new ProcessingError(`Failed to process image: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
   }
+  logger2.error("Image processing failed after all retries:", lastError);
+  throw new ProcessingError(`Failed to process image after ${maxRetries} attempts: ${lastError?.message || "Unknown error"}`);
+}
+function isRetryableError(error) {
+  const retryableMessages = [
+    "timeout",
+    "network",
+    "rate limit",
+    "temporary",
+    "429",
+    "500",
+    "502",
+    "503",
+    "504"
+  ];
+  const errorMessage = error.message.toLowerCase();
+  return retryableMessages.some((msg) => errorMessage.includes(msg));
 }
 async function loadImage(source, fetchTimeout) {
   if (source.match(/^\[Image #\d+\]$/)) {
@@ -164048,11 +164105,35 @@ async function registerVisionTools(server, geminiClient, config) {
       return await handleAnalyze(geminiClient, args, config);
     } catch (error) {
       const mcpError = handleError(error);
-      logger2.error(`Tool eyes_analyze error:`, mcpError);
+      logger2.error(`Tool eyes_analyze error:`, {
+        message: mcpError.message,
+        code: mcpError.code,
+        args,
+        timestamp: new Date().toISOString(),
+        stackTrace: error instanceof Error ? error.stack : "No stack trace available"
+      });
+      let userMessage = mcpError.message;
+      if (mcpError.message.includes("No analysis result from Gemini")) {
+        userMessage = `The image analysis service returned an empty response. This can happen due to:
+` + `• API rate limits or quota exceeded
+` + `• Image content restrictions
+` + `• Temporary service issues
+` + `• Network connectivity problems
+
+` + "Please try again in a few moments, or check if your image meets the requirements.";
+      } else if (mcpError.message.includes("Failed to process image after")) {
+        userMessage = `Image processing failed after multiple attempts. This could be due to:
+` + `• Network connectivity issues
+` + `• API service unavailability
+` + `• Image format or size issues
+` + `• Rate limiting
+
+` + "Please check your internet connection and try again.";
+      }
       return {
         content: [{
           type: "text",
-          text: `Error: ${mcpError.message}`
+          text: `Error: ${userMessage}`
         }],
         isError: true
       };
@@ -164216,10 +164297,13 @@ async function registerDocumentTools(server, geminiClient, config) {
 async function handleAnalyze(geminiClient, args, config) {
   const input = EyesInputSchema.parse(args);
   const { source, type, detail_level } = input;
-  logger2.info(`Analyzing ${type} with detail level: ${detail_level}`);
+  const customPrompt = "prompt" in input ? input.prompt : undefined;
+  logger2.info(`Analyzing ${type} with detail level: ${detail_level}, source: ${source.substring(0, 50)}...`);
   const model = geminiClient.getModel(detail_level || "detailed");
   const options = {
-    ...input,
+    analysis_type: "general",
+    detail_level: detail_level || "detailed",
+    specific_focus: customPrompt,
     fetchTimeout: config.server.fetchTimeout
   };
   let result;
@@ -164236,6 +164320,7 @@ async function handleAnalyze(geminiClient, args, config) {
     default:
       throw new Error(`Unsupported media type: ${type}`);
   }
+  logger2.info(`Analysis completed for ${type}. Processing time: ${result.metadata.processing_time_ms}ms`);
   return {
     content: [
       {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goonnguyen/human-mcp",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "Human MCP: Bringing Human Capabilities to Coding Agents",
   "type": "module",
   "main": "dist/index.js",
@@ -9,13 +9,13 @@
     "human-mcp": "bin/human-mcp.js"
   },
   "scripts": {
-    "dev": "bun run --watch src/index.ts",
-    "build": "bun build src/index.ts --target=node --outdir=dist",
-    "start": "bun run dist/index.js",
-    "test": "bun test tests/unit/ && bun test tests/integration/sse-transport.test.ts && bun test tests/integration/server.test.ts && bun test tests/integration/http-transport-files.test.ts",
-    "test:parallel": "bun test",
-    "typecheck": "tsc --noEmit",
-    "inspector": "mcp-inspector stdio -- bun run src/index.ts"
+    "dev": "bun run --watch src/index.ts 2>&1 | tee -a ./logs.txt",
+    "build": "bun build src/index.ts --target=node --outdir=dist 2>&1 | tee -a ./logs.txt",
+    "start": "bun run dist/index.js 2>&1 | tee -a ./logs.txt",
+    "test": "bun test tests/unit/ && bun test tests/integration/sse-transport.test.ts && bun test tests/integration/server.test.ts && bun test tests/integration/http-transport-files.test.ts 2>&1 | tee -a ./logs.txt",
+    "test:parallel": "bun test 2>&1 | tee -a ./logs.txt",
+    "typecheck": "tsc --noEmit 2>&1 | tee -a ./logs.txt",
+    "inspector": "mcp-inspector stdio -- bun run src/index.ts 2>&1 | tee -a ./logs.txt"
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.888.0",