@reconcrap/boss-recommend-mcp 2.0.9 → 2.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recommend-mcp",
-  "version": "2.0.9",
+  "version": "2.0.11",
   "description": "Unified MCP pipeline for recommend-page filtering and screening on Boss Zhipin",
   "keywords": [
     "boss",

package/src/core/capture/index.js

@@ -146,6 +146,14 @@ function filePathForSequence(basePath, index, extension) {
   return path.join(parsed.dir, `${parsed.name}-page-${page}${parsed.ext || `.${extension}`}`);
 }
 
+function filePathForLlmSequence(basePath, index) {
+  const resolved = resolveOutputPath(basePath);
+  if (!resolved) return null;
+  const parsed = path.parse(resolved);
+  const page = String(index + 1).padStart(2, "0");
+  return path.join(parsed.dir, `${parsed.name}-llm-${page}.jpg`);
+}
+
 function screenshotHash(buffer) {
   return crypto.createHash("sha256").update(buffer).digest("hex");
 }
@@ -207,6 +215,111 @@ async function optimizeScreenshotBuffer(buffer, {
   }
 }
 
+async function composeScreenshotsForLlm(screenshots = [], {
+  basePath,
+  pagesPerImage = 3,
+  resizeMaxWidth = 1100,
+  quality = 72
+} = {}) {
+  const fileScreenshots = screenshots.filter((item) => item?.file_path);
+  if (!basePath || fileScreenshots.length <= 1) {
+    return {
+      llm_file_paths: fileScreenshots.map((item) => item.file_path),
+      llm_screenshots: [],
+      llm_total_byte_length: 0,
+      llm_original_total_byte_length: 0,
+      llm_composition_error: null
+    };
+  }
+
+  const safePagesPerImage = Math.max(1, Math.min(5, Number(pagesPerImage) || 3));
+  const safeWidth = Math.max(700, Math.min(1400, Number(resizeMaxWidth) || 1100));
+  const safeQuality = Math.max(45, Math.min(90, Number(quality) || 72));
+  const llmScreenshots = [];
+
+  try {
+    for (let index = 0; index < fileScreenshots.length; index += safePagesPerImage) {
+      const group = fileScreenshots.slice(index, index + safePagesPerImage);
+      const prepared = [];
+      for (const item of group) {
+        const sourceBuffer = fs.readFileSync(item.file_path);
+        const { data, info } = await sharp(sourceBuffer, { failOn: "none" })
+          .resize({
+            width: safeWidth,
+            withoutEnlargement: true
+          })
+          .jpeg({
+            quality: safeQuality,
+            mozjpeg: true
+          })
+          .toBuffer({ resolveWithObject: true });
+        prepared.push({
+          input: data,
+          width: info.width,
+          height: info.height,
+          source_file_path: item.file_path
+        });
+      }
+
+      const width = Math.max(...prepared.map((item) => item.width), 1);
+      const height = prepared.reduce((sum, item) => sum + item.height, 0);
+      let top = 0;
+      const composites = prepared.map((item) => {
+        const layer = {
+          input: item.input,
+          left: 0,
+          top
+        };
+        top += item.height;
+        return layer;
+      });
+      const outputBuffer = await sharp({
+        create: {
+          width,
+          height,
+          channels: 3,
+          background: "#ffffff"
+        }
+      })
+        .composite(composites)
+        .jpeg({
+          quality: safeQuality,
+          mozjpeg: true
+        })
+        .toBuffer();
+      const outputPath = filePathForLlmSequence(basePath, llmScreenshots.length);
+      fs.writeFileSync(outputPath, outputBuffer);
+      llmScreenshots.push({
+        index: llmScreenshots.length,
+        file_path: outputPath,
+        byte_length: outputBuffer.length,
+        source_file_paths: prepared.map((item) => item.source_file_path),
+        source_page_count: prepared.length,
+        width,
+        height,
+        format: "jpeg",
+        mime_type: "image/jpeg"
+      });
+    }
+  } catch (error) {
+    return {
+      llm_file_paths: fileScreenshots.map((item) => item.file_path),
+      llm_screenshots: [],
+      llm_total_byte_length: 0,
+      llm_original_total_byte_length: fileScreenshots.reduce((sum, item) => sum + (Number(item.byte_length) || 0), 0),
+      llm_composition_error: error?.message || String(error)
+    };
+  }
+
+  return {
+    llm_file_paths: llmScreenshots.map((item) => item.file_path),
+    llm_screenshots: llmScreenshots,
+    llm_total_byte_length: llmScreenshots.reduce((sum, item) => sum + (Number(item.byte_length) || 0), 0),
+    llm_original_total_byte_length: fileScreenshots.reduce((sum, item) => sum + (Number(item.byte_length) || 0), 0),
+    llm_composition_error: null
+  };
+}
+
 export async function captureScrolledNodeScreenshots(client, nodeId, {
   filePath,
   format = "png",
@@ -222,6 +335,10 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
   skipDuplicateScreenshots = false,
   optimize = false,
   resizeMaxWidth = 0,
+  composeForLlm = false,
+  llmPagesPerImage = 3,
+  llmResizeMaxWidth = 1100,
+  llmQuality = 72,
   metadata = {}
 } = {}) {
   if (!nodeId) throw new Error("captureScrolledNodeScreenshots requires nodeId");
@@ -322,6 +439,21 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
     }
   }
 
+  const llmComposition = composeForLlm
+    ? await composeScreenshotsForLlm(screenshots, {
+        basePath: filePath,
+        pagesPerImage: llmPagesPerImage,
+        resizeMaxWidth: llmResizeMaxWidth,
+        quality: llmQuality
+      })
+    : {
+        llm_file_paths: screenshots.map((item) => item.file_path).filter(Boolean),
+        llm_screenshots: [],
+        llm_total_byte_length: 0,
+        llm_original_total_byte_length: 0,
+        llm_composition_error: null
+      };
+
   return {
     schema_version: 1,
     source: "image-scroll-sequence",
@@ -335,12 +467,22 @@ export async function captureScrolledNodeScreenshots(client, nodeId, {
     dropped_duplicate_count: droppedDuplicateCount,
     total_byte_length: screenshots.reduce((sum, item) => sum + (Number(item.byte_length) || 0), 0),
     original_total_byte_length: screenshots.reduce((sum, item) => sum + (Number(item.original_byte_length) || 0), 0),
+    llm_file_paths: llmComposition.llm_file_paths,
+    llm_screenshot_count: llmComposition.llm_file_paths.length,
+    llm_total_byte_length: llmComposition.llm_total_byte_length,
+    llm_original_total_byte_length: llmComposition.llm_original_total_byte_length,
+    llm_composition_error: llmComposition.llm_composition_error,
+    llm_screenshots: llmComposition.llm_screenshots,
     optimization: {
       enabled: Boolean(optimize),
       resize_max_width: Math.max(0, Number(resizeMaxWidth) || 0),
       capture_viewport: Boolean(captureViewport),
       format,
-      quality: quality ?? null
+      quality: quality ?? null,
+      llm_compose_enabled: Boolean(composeForLlm),
+      llm_pages_per_image: Math.max(1, Math.min(5, Number(llmPagesPerImage) || 3)),
+      llm_resize_max_width: Math.max(0, Number(llmResizeMaxWidth) || 0),
+      llm_quality: llmQuality ?? null
     },
     file_paths: screenshots.map((item) => item.file_path).filter(Boolean),
     screenshots,

package/src/core/cv-acquisition/index.js

@@ -132,8 +132,13 @@ export function summarizeImageEvidence(imageEvidence = null) {
     dropped_duplicate_count: imageEvidence.dropped_duplicate_count || 0,
     total_byte_length: imageEvidence.total_byte_length || 0,
     original_total_byte_length: imageEvidence.original_total_byte_length || 0,
+    llm_screenshot_count: imageEvidence.llm_screenshot_count || 0,
+    llm_total_byte_length: imageEvidence.llm_total_byte_length || 0,
+    llm_original_total_byte_length: imageEvidence.llm_original_total_byte_length || 0,
+    llm_composition_error: imageEvidence.llm_composition_error || null,
     optimization: imageEvidence.optimization || null,
     file_paths: imageEvidence.file_paths || [],
+    llm_file_paths: imageEvidence.llm_file_paths || [],
     first_clip: imageEvidence.screenshots?.[0]?.clip || imageEvidence.clip || null
   };
 }

package/src/core/screening/index.js

@@ -392,11 +392,18 @@ function normalizeImagePaths({ imageEvidence = null, imagePaths = [] } = {}) {
   if (Array.isArray(imagePaths)) {
     paths.push(...imagePaths);
   }
-  if (Array.isArray(imageEvidence?.file_paths)) {
-    paths.push(...imageEvidence.file_paths);
-  }
-  if (Array.isArray(imageEvidence?.screenshots)) {
-    paths.push(...imageEvidence.screenshots.map((item) => item.file_path));
+  const evidenceLlmPaths = Array.isArray(imageEvidence?.llm_file_paths)
+    ? imageEvidence.llm_file_paths
+    : [];
+  if (evidenceLlmPaths.length) {
+    paths.push(...evidenceLlmPaths);
+  } else {
+    if (Array.isArray(imageEvidence?.file_paths)) {
+      paths.push(...imageEvidence.file_paths);
+    }
+    if (Array.isArray(imageEvidence?.screenshots)) {
+      paths.push(...imageEvidence.screenshots.map((item) => item.file_path));
+    }
   }
   return unique(paths.map((filePath) => String(filePath || "").trim()).filter(Boolean));
 }
@@ -1292,6 +1299,7 @@ export function compactScreeningLlmResult(llmResult) {
     usage: llmResult.usage || null,
     finish_reason: llmResult.finish_reason || null,
     image_input_count: llmResult.image_input_count || 0,
+    attempt_count: llmResult.attempt_count || 0,
     error: llmResult.error || null,
     screened_at: llmResult.screened_at || null
   };
@@ -1324,6 +1332,7 @@ export function createFailedLlmScreeningResult(error) {
     raw_model_output: "",
     image_input_count: Number(error?.image_input_count) || 0,
     image_inputs: Array.isArray(error?.image_inputs) ? error.image_inputs : [],
+    attempt_count: Number(error?.llm_attempt_count) || 0,
     error: error?.message || String(error || "unknown"),
     screened_at: nowIso()
   };
@@ -1352,7 +1361,7 @@ export function buildScreeningLlmMessages({
     `请根据以下标准判断候选人是否通过筛选。\n\n筛选标准:\n${safeCriteria}\n\n`
     + `候选人信息:\n${safeText || "候选人的完整简历信息在后续截图中，请按截图顺序阅读。"}\n\n`
     + (images.length
-      ? `候选人简历截图共 ${images.length} 张，按从上到下的滚动顺序排列。请完整阅读所有截图后再判断。\n\n`
+      ? `候选人简历截图共 ${images.length} 张，按从上到下的滚动顺序排列。若截图是拼接长图，请按图内从上到下顺序完整阅读；不要跳过任何一段简历内容。\n\n`
       : "")
     + "要求：\n"
     + "1) 只能依据候选人信息或截图中真实出现的内容判断。\n"
@@ -1383,6 +1392,24 @@ export function buildScreeningLlmMessages({
   ];
 }
 
+function normalizeLlmMaxRetries(value) {
+  if (value == null || value === "") return 1;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) return 1;
+  return Math.min(3, Math.floor(parsed));
+}
+
+function isRetryableLlmRequestError(error) {
+  const status = Number(error?.status);
+  if ([408, 409, 425, 429].includes(status) || status >= 500) return true;
+  return /(?:aborted|abort|timeout|timed out|fetch failed|socket|network|ECONNRESET|ETIMEDOUT|EAI_AGAIN)/i
+    .test(String(error?.message || error || ""));
+}
+
+function sleepMs(ms) {
+  return new Promise((resolve) => setTimeout(resolve, Math.max(0, Number(ms) || 0)));
+}
+
 export async function callScreeningLlm({
   candidate,
   criteria,
@@ -1422,12 +1449,16 @@ export async function callScreeningLlm({
   applyChatCompletionThinking(payload, {
     baseUrl,
     model,
-    thinkingLevel: config.llmThinkingLevel || config.thinkingLevel || config.reasoningEffort || "off"
+    thinkingLevel: config.llmThinkingLevel || config.thinkingLevel || config.reasoningEffort || "low"
   });
 
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
+  const maxRetries = normalizeLlmMaxRetries(config.llmMaxRetries ?? config.maxRetries);
+  const maxAttempts = maxRetries + 1;
+  let lastError = null;
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
     const headers = {
       "Content-Type": "application/json",
       Authorization: `Bearer ${apiKey}`
@@ -1443,7 +1474,9 @@ export async function callScreeningLlm({
     });
     const responseText = await response.text();
     if (!response.ok) {
-      throw new Error(`LLM request failed: ${response.status} ${responseText.slice(0, 400)}`);
+      const error = new Error(`LLM request failed: ${response.status} ${responseText.slice(0, 400)}`);
+      error.status = response.status;
+      throw error;
     }
     const json = tryParseJson(responseText);
     if (!json) {
@@ -1485,13 +1518,25 @@ export async function callScreeningLlm({
       raw_content_length: content.length,
       image_input_count: imageInputs.length,
       image_inputs: summarizeLlmImageInputs(imageInputs),
+      attempt_count: attempt,
       screened_at: nowIso()
     };
   } catch (error) {
-    error.image_input_count = imageInputs.length;
-    error.image_inputs = summarizeLlmImageInputs(imageInputs);
-    throw error;
+      lastError = error;
+      if (attempt >= maxAttempts || !isRetryableLlmRequestError(error)) {
+        error.image_input_count = imageInputs.length;
+        error.image_inputs = summarizeLlmImageInputs(imageInputs);
+        error.llm_attempt_count = attempt;
+        throw error;
+      }
+      await sleepMs(Math.min(2500, 500 * attempt));
   } finally {
     clearTimeout(timer);
   }
+  }
+  lastError = lastError || new Error("LLM request failed without response");
+  lastError.image_input_count = imageInputs.length;
+  lastError.image_inputs = summarizeLlmImageInputs(imageInputs);
+  lastError.llm_attempt_count = maxAttempts;
+  throw lastError;
 }

package/src/domains/chat/run-service.js

@@ -98,6 +98,7 @@ function compactLlmResult(llmResult) {
     usage: llmResult.usage || null,
     finish_reason: llmResult.finish_reason || null,
     image_input_count: llmResult.image_input_count || 0,
+    attempt_count: llmResult.attempt_count || 0,
     error: llmResult.error || null
   };
 }
@@ -826,11 +827,15 @@ export async function runChatWorkflow({
                 maxScreenshots: maxImagePages,
                 wheelDeltaY: imageWheelDeltaY,
                 settleMs: 350,
-                duplicateStopCount: 1,
-                skipDuplicateScreenshots: true,
-                metadata: {
-                  domain: "chat",
-                  capture_mode: "scroll_sequence",
+            duplicateStopCount: 1,
+            skipDuplicateScreenshots: true,
+            composeForLlm: true,
+            llmPagesPerImage: 3,
+            llmResizeMaxWidth: 1100,
+            llmQuality: 72,
+            metadata: {
+              domain: "chat",
+              capture_mode: "scroll_sequence",
                   acquisition_reason: normalizedDetailSource === "image"
                     ? "forced_image"
                     : "network_miss_image_fallback",

package/src/domains/recommend/refresh.js

@@ -110,95 +110,117 @@ export async function refreshRecommendListAtEnd(client, {
     );
     attempts.push(buttonResult);
     if (buttonResult.ok) {
-      currentRootState = await getRecommendRoots(client);
-      const pageScopeResult = await selectRecommendPageScope(
-        client,
-        currentRootState.iframe.documentNodeId,
-        {
-          pageScope,
-          fallbackScope: fallbackPageScope,
-          settleMs: buttonSettleMs > 10000 ? 3000 : 1200,
-          timeoutMs: Math.max(10000, Math.min(cardTimeoutMs, 60000))
+      try {
+        currentRootState = await getRecommendRoots(client);
+        const pageScopeResult = await selectRecommendPageScope(
+          client,
+          currentRootState.iframe.documentNodeId,
+          {
+            pageScope,
+            fallbackScope: fallbackPageScope,
+            settleMs: buttonSettleMs > 10000 ? 3000 : 1200,
+            timeoutMs: Math.max(10000, Math.min(cardTimeoutMs, 60000))
+          }
+        );
+        if (!pageScopeResult.selected) {
+          throw new Error(`Recommend page scope was not selected after end refresh: ${pageScopeResult.reason || pageScope}`);
         }
-      );
-      if (!pageScopeResult.selected) {
-        throw new Error(`Recommend page scope was not selected after end refresh: ${pageScopeResult.reason || pageScope}`);
+        currentRootState = await getRecommendRoots(client);
+        const filterResult = await selectAndConfirmFirstSafeFilter(
+          client,
+          currentRootState.iframe.documentNodeId,
+          buildRecommendFilterSelectionOptions(filter, { forceRecentNotView })
+        );
+        const cardNodeIds = await waitForRecommendCardNodeIds(client, currentRootState.iframe.documentNodeId, {
+          timeoutMs: cardTimeoutMs,
+          intervalMs: 500
+        });
+        return {
+          ok: cardNodeIds.length > 0,
+          method: "end_refresh_button",
+          attempts,
+          page_scope: pageScopeResult,
+          filter: filterResult,
+          card_count: cardNodeIds.length,
+          root_state: currentRootState,
+          forced_recent_not_view: forceRecentNotView
+        };
+      } catch (error) {
+        attempts.push({
+          ok: false,
+          method: "end_refresh_button_after_click",
+          reason: "end_refresh_reapply_failed",
+          error: error?.message || String(error)
+        });
       }
-      currentRootState = await getRecommendRoots(client);
-      const filterResult = await selectAndConfirmFirstSafeFilter(
-        client,
-        currentRootState.iframe.documentNodeId,
-        buildRecommendFilterSelectionOptions(filter, { forceRecentNotView })
-      );
-      const cardNodeIds = await waitForRecommendCardNodeIds(client, currentRootState.iframe.documentNodeId, {
-        timeoutMs: cardTimeoutMs,
-        intervalMs: 500
-      });
-      return {
-        ok: cardNodeIds.length > 0,
-        method: "end_refresh_button",
-        attempts,
-        page_scope: pageScopeResult,
-        filter: filterResult,
-        card_count: cardNodeIds.length,
-        root_state: currentRootState,
-        forced_recent_not_view: forceRecentNotView
-      };
     }
   }
 
-  await client.Page.reload({ ignoreCache: true });
-  if (reloadSettleMs > 0) await sleep(reloadSettleMs);
-  currentRootState = await waitForRecommendRoots(client, {
-    timeoutMs: Math.max(30000, reloadSettleMs * 4),
-    intervalMs: 500
-  });
-  if (!currentRootState?.iframe?.documentNodeId) {
-    throw new Error("Recommend iframe was not ready after refresh reload");
-  }
-  let jobSelection = null;
-  if (jobLabel) {
-    jobSelection = await selectRecommendJob(client, currentRootState.iframe.documentNodeId, {
-      jobLabel,
-      settleMs: reloadSettleMs > 10000 ? 12000 : 6000
+  try {
+    await client.Page.reload({ ignoreCache: true });
+    if (reloadSettleMs > 0) await sleep(reloadSettleMs);
+    currentRootState = await waitForRecommendRoots(client, {
+      timeoutMs: Math.max(30000, reloadSettleMs * 4),
+      intervalMs: 500
     });
-    if (!jobSelection.selected) {
-      throw new Error(`Requested recommend job was not selected after refresh reload: ${jobSelection.reason}`);
+    if (!currentRootState?.iframe?.documentNodeId) {
+      throw new Error("Recommend iframe was not ready after refresh reload");
     }
-    currentRootState = await getRecommendRoots(client);
-  }
-  const pageScopeResult = await selectRecommendPageScope(
-    client,
-    currentRootState.iframe.documentNodeId,
-    {
-      pageScope,
-      fallbackScope: fallbackPageScope,
-      settleMs: reloadSettleMs > 10000 ? 3000 : 1200,
-      timeoutMs: Math.max(10000, Math.min(cardTimeoutMs, 60000))
+    let jobSelection = null;
+    if (jobLabel) {
+      jobSelection = await selectRecommendJob(client, currentRootState.iframe.documentNodeId, {
+        jobLabel,
+        settleMs: reloadSettleMs > 10000 ? 12000 : 6000
+      });
+      if (!jobSelection.selected) {
+        throw new Error(`Requested recommend job was not selected after refresh reload: ${jobSelection.reason}`);
+      }
+      currentRootState = await getRecommendRoots(client);
     }
-  );
-  if (!pageScopeResult.selected) {
-    throw new Error(`Recommend page scope was not selected after refresh reload: ${pageScopeResult.reason || pageScope}`);
+    const pageScopeResult = await selectRecommendPageScope(
+      client,
+      currentRootState.iframe.documentNodeId,
+      {
+        pageScope,
+        fallbackScope: fallbackPageScope,
+        settleMs: reloadSettleMs > 10000 ? 3000 : 1200,
+        timeoutMs: Math.max(10000, Math.min(cardTimeoutMs, 60000))
+      }
+    );
+    if (!pageScopeResult.selected) {
+      throw new Error(`Recommend page scope was not selected after refresh reload: ${pageScopeResult.reason || pageScope}`);
+    }
+    currentRootState = await getRecommendRoots(client);
+    const filterResult = await selectAndConfirmFirstSafeFilter(
+      client,
+      currentRootState.iframe.documentNodeId,
+      buildRecommendFilterSelectionOptions(filter, { forceRecentNotView })
+    );
+    const cardNodeIds = await waitForRecommendCardNodeIds(client, currentRootState.iframe.documentNodeId, {
+      timeoutMs: cardTimeoutMs,
+      intervalMs: 500
+    });
+    return {
+      ok: cardNodeIds.length > 0,
+      method: "page_reload",
+      attempts,
+      job_selection: jobSelection,
+      page_scope: pageScopeResult,
+      filter: filterResult,
+      card_count: cardNodeIds.length,
+      root_state: currentRootState,
+      forced_recent_not_view: forceRecentNotView
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      method: "page_reload",
+      reason: "page_reload_failed",
+      error: error?.message || String(error),
+      attempts,
+      card_count: 0,
+      root_state: currentRootState,
+      forced_recent_not_view: forceRecentNotView
+    };
   }
-  currentRootState = await getRecommendRoots(client);
-  const filterResult = await selectAndConfirmFirstSafeFilter(
-    client,
-    currentRootState.iframe.documentNodeId,
-    buildRecommendFilterSelectionOptions(filter, { forceRecentNotView })
-  );
-  const cardNodeIds = await waitForRecommendCardNodeIds(client, currentRootState.iframe.documentNodeId, {
-    timeoutMs: cardTimeoutMs,
-    intervalMs: 500
-  });
-  return {
-    ok: cardNodeIds.length > 0,
-    method: "page_reload",
-    attempts,
-    job_selection: jobSelection,
-    page_scope: pageScopeResult,
-    filter: filterResult,
-    card_count: cardNodeIds.length,
-    root_state: currentRootState,
-    forced_recent_not_view: forceRecentNotView
-  };
 }

package/src/domains/recommend/run-service.js

@@ -715,6 +715,10 @@ export async function runRecommendWorkflow({
             settleMs: 350,
             duplicateStopCount: 1,
             skipDuplicateScreenshots: true,
+            composeForLlm: true,
+            llmPagesPerImage: 3,
+            llmResizeMaxWidth: 1100,
+            llmQuality: 72,
             metadata: {
               domain: "recommend",
               capture_mode: "scroll_sequence",

package/src/domains/recruit/run-service.js

@@ -440,6 +440,10 @@ export async function runRecruitWorkflow({
             settleMs: 350,
             duplicateStopCount: 1,
             skipDuplicateScreenshots: true,
+            composeForLlm: true,
+            llmPagesPerImage: 3,
+            llmResizeMaxWidth: 1100,
+            llmQuality: 72,
             metadata: {
               domain: "recruit",
               capture_mode: "scroll_sequence",