smart-image-scraper-mcp 2.9.2 → 2.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smart-image-scraper-mcp",
-  "version": "2.9.2",
+  "version": "2.10.0",
   "description": "全网智能图片抓取 MCP 服务器 - 支持 Bing/Google 图片搜索、验证和下载",
   "main": "src/index.js",
   "type": "module",

package/src/index.js

@@ -200,6 +200,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     // 格式化输出
     const formattedResult = orchestrator.formatResult(result);
 
+    // 如果任务失败，标记为错误
+    if (!result.success) {
+      return {
+        content: [{ type: 'text', text: formattedResult }],
+        isError: true,
+      };
+    }
+
     return {
       content: [{ type: 'text', text: formattedResult }],
     };

package/src/services/orchestrator.js

@@ -347,31 +347,43 @@ export class Orchestrator {
     metrics.recordRequest();
     const requestId = `req_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`;
     
-    // 根据关键词数量动态计算超时时间（每个关键词 10 秒，最少 30 秒，最多 120 秒）
+    // 根据关键词数量动态计算超时时间（每个关键词 8 秒，最少 20 秒，最多 90 秒）
     const keywords = this.parseKeywords(params.query);
     const keywordCount = keywords.length;
-    const GLOBAL_TIMEOUT = Math.min(Math.max(keywordCount * 10000, 30000), 120000);
+    const GLOBAL_TIMEOUT = Math.min(Math.max(keywordCount * 8000, 20000), 90000);
+    
+    logger.info(`[Orchestrator] Starting request: ${requestId}, keywords: ${keywordCount}, timeout: ${GLOBAL_TIMEOUT/1000}s`);
+    
+    // 创建超时控制器
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        const errorMsg = `REQUEST_TIMEOUT: 请求超时(${GLOBAL_TIMEOUT/1000}秒)，关键词过多请减少数量或稍后重试`;
+        logger.error(`[Orchestrator] ${errorMsg}`);
+        reject(new Error(errorMsg));
+      }, GLOBAL_TIMEOUT);
+    });
     
     try {
-      logger.info(`[Orchestrator] Starting request: ${requestId}, keywords: ${keywordCount}, timeout: ${GLOBAL_TIMEOUT/1000}s`);
-      
       // 添加全局超时熔断机制
       const result = await Promise.race([
         this._executeInternal(params),
-        new Promise((_, reject) => 
-          setTimeout(() => reject(new Error(`REQUEST_TIMEOUT: 请求超时(${GLOBAL_TIMEOUT/1000}秒)，关键词过多请减少数量`)), GLOBAL_TIMEOUT)
-        )
+        timeoutPromise
       ]);
       
+      clearTimeout(timeoutId);
       result.requestId = requestId;
       logger.info(`[Orchestrator] Completed request: ${requestId}`);
       return result;
     } catch (error) {
+      clearTimeout(timeoutId);
       logger.error(`[Orchestrator] Failed request: ${requestId} - ${error.message}`);
+      // 确保返回标准错误格式
       return {
         success: false,
         error: error.message,
         requestId,
+        duration: 0,
       };
     }
   }
@@ -391,7 +403,7 @@ export class Orchestrator {
     const options = { size, safeSearch, aspect, targetSize, fit, position };
     
     const startTime = Date.now();
-    const keywords = this.parseKeywords(query);
+    let keywords = this.parseKeywords(query);
 
     if (keywords.length === 0) {
       return {
@@ -400,6 +412,13 @@ export class Orchestrator {
       };
     }
 
+    // 限制最大关键词数量为 10 个，避免阻塞
+    const MAX_KEYWORDS = 10;
+    if (keywords.length > MAX_KEYWORDS) {
+      logger.warn(`Too many keywords (${keywords.length}), limiting to ${MAX_KEYWORDS}`);
+      keywords = keywords.slice(0, MAX_KEYWORDS);
+    }
+
     logger.info(`Starting task: mode=${mode}, keywords=${keywords.join(', ')}, count=${count}, source=${source}`);
 
     // 根据模式选择处理函数
@@ -407,12 +426,23 @@ export class Orchestrator {
       ? this.processKeywordLink.bind(this)
       : this.processKeywordDownload.bind(this);
 
-    // 并发处理关键词
-    const results = await Promise.all(
-      keywords.map(keyword => 
-        this.keywordLimit(() => processFunc(keyword, count, source, options))
-      )
-    );
+    // 串行处理关键词，避免阻塞事件循环
+    const results = [];
+    for (const keyword of keywords) {
+      try {
+        const result = await processFunc(keyword, count, source, options);
+        results.push(result);
+        // 让出事件循环，确保 MCP 通信不被阻塞
+        await new Promise(resolve => setImmediate(resolve));
+      } catch (error) {
+        results.push({
+          keyword,
+          success: false,
+          error: error.message,
+          duration: 0,
+        });
+      }
+    }
 
     // 汇总结果
     const successResults = results.filter(r => r.success);