@reconcrap/boss-recommend-mcp 2.0.6 → 2.0.8

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

@@ -1,4 +1,9 @@
 import { createRunLifecycleManager } from "../../core/run/index.js";
+import {
+  addTiming,
+  imageEvidenceFilePath,
+  measureTiming
+} from "../../core/run/timing.js";
 import { captureScrolledNodeScreenshots } from "../../core/capture/index.js";
 import { sleep } from "../../core/browser/index.js";
 import { GREET_CREDITS_EXHAUSTED_CODE } from "../../core/greet-quota/index.js";
@@ -21,7 +26,13 @@ import {
   resetInfiniteListForRefreshRound
 } from "../../core/infinite-list/index.js";
 import { createViewportRunGuard } from "../../core/self-heal/index.js";
-import { screenCandidate } from "../../core/screening/index.js";
+import {
+  callScreeningLlm,
+  compactScreeningLlmResult,
+  createFailedLlmScreeningResult,
+  llmResultToScreening,
+  screenCandidate
+} from "../../core/screening/index.js";
 import {
   closeRecommendDetail,
   createRecommendDetailNetworkRecorder,
@@ -165,10 +176,22 @@ function compactDetail(detailResult) {
     parsed_network_profile_count: detailResult.parsed_network_profiles?.filter((item) => item.ok).length || 0,
     cv_acquisition: detailResult.cv_acquisition || null,
     image_evidence: summarizeImageEvidence(detailResult.image_evidence),
+    llm_screening: compactScreeningLlmResult(detailResult.llm_result),
     close_result: detailResult.close_result
   };
 }
 
+function normalizeScreeningMode(value) {
+  const normalized = String(value || "llm").trim().toLowerCase();
+  return ["deterministic", "local", "local_scorer"].includes(normalized)
+    ? "deterministic"
+    : "llm";
+}
+
+function createMissingLlmConfigResult() {
+  return createFailedLlmScreeningResult(new Error("LLM screening config is required for production recommend runs"));
+}
+
 function compactActionDiscovery(discovery) {
   if (!discovery) return null;
   return {
@@ -354,13 +377,21 @@ export async function runRecommendWorkflow({
   executePostAction = true,
   actionTimeoutMs = 8000,
   actionIntervalMs = 500,
-  actionAfterClickDelayMs = 900
+  actionAfterClickDelayMs = 900,
+  screeningMode = "llm",
+  llmConfig = null,
+  llmTimeoutMs = 120000,
+  llmImageLimit = 8,
+  llmImageDetail = "high",
+  imageOutputDir = ""
 } = {}, runControl) {
   if (!client) throw new Error("runRecommendWorkflow requires a guarded CDP client");
   const normalizedFilter = normalizeFilter(filter);
   const normalizedPostAction = normalizeRecommendPostAction(postAction) || "none";
   const requestedPageScope = normalizeRecommendPageScope(pageScope) || "recommend";
   const normalizedFallbackPageScope = normalizeRecommendPageScope(fallbackPageScope) || "recommend";
+  const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
+  const useLlmScreening = normalizedScreeningMode !== "deterministic";
   const postActionEnabled = normalizedPostAction !== "none";
   const limit = Math.max(1, Number(maxCandidates) || 1);
   const detailCountLimit = detailLimit == null ? limit : Math.max(0, Number(detailLimit) || 0);
@@ -484,6 +515,8 @@ export async function runRecommendWorkflow({
     passed: 0,
     greet_count: 0,
     post_action_clicked: 0,
+    screening_mode: normalizedScreeningMode,
+    llm_screened: 0,
     unique_seen: compactInfiniteListState(listState).seen_count,
     scroll_count: 0,
     refresh_rounds: 0,
@@ -493,12 +526,14 @@ export async function runRecommendWorkflow({
   });
 
   while (results.length < limit) {
+    const candidateStarted = Date.now();
+    const timings = {};
     await runControl.waitIfPaused();
     runControl.throwIfCanceled();
     runControl.setPhase("recommend:candidate");
     rootState = await ensureRecommendViewport(rootState, "candidate_loop");
 
-    const nextCandidateResult = await getNextInfiniteListCandidate({
+    const nextCandidateResult = await measureTiming(timings, "card_read_ms", () => getNextInfiniteListCandidate({
       client,
       state: listState,
       maxScrolls: listMaxScrolls,
@@ -525,7 +560,7 @@ export async function runRecommendWorkflow({
           visible_index: visibleIndex
         }
       })
-    });
+    }));
     if (!nextCandidateResult.ok) {
       listEndReason = nextCandidateResult.reason || "list_exhausted";
       if (
@@ -562,6 +597,7 @@ export async function runRecommendWorkflow({
           screened: results.length,
           detail_opened: results.filter((item) => item.detail).length,
           passed: results.filter((item) => item.screening.passed).length,
+          llm_screened: results.filter((item) => item.detail?.llm_screening || item.llm_screening).length,
           unique_seen: compactInfiniteListState(listState).seen_count,
           scroll_count: compactInfiniteListState(listState).scroll_count,
           refresh_rounds: refreshRounds,
@@ -616,11 +652,13 @@ export async function runRecommendWorkflow({
         targetUrl,
         maxAttempts: 2
       });
+      addTiming(timings, "candidate_click_ms", openedDetail.timings?.candidate_click_ms);
+      addTiming(timings, "detail_open_ms", openedDetail.timings?.detail_open_ms);
       cardNodeId = openedDetail.card_node_id || cardNodeId;
       cardCandidate = openedDetail.card_candidate || cardCandidate;
       screeningCandidate = cardCandidate;
       const waitPlan = getCvNetworkWaitPlan(cvAcquisitionState);
-      const networkWait = await waitForCvNetworkEvents(
+      const networkWait = await measureTiming(timings, "network_cv_wait_ms", () => waitForCvNetworkEvents(
         waitForRecommendDetailNetworkEvents,
         networkRecorder,
         {
@@ -629,7 +667,10 @@ export async function runRecommendWorkflow({
           requireLoaded: true,
           intervalMs: 120
         }
-      );
+      ));
+      if (networkWait?.elapsed_ms != null) {
+        timings.network_cv_wait_ms = Math.round(Number(networkWait.elapsed_ms) || 0);
+      }
       detailResult = await extractRecommendDetailCandidate(client, {
         cardCandidate,
         cardNodeId,
@@ -652,7 +693,13 @@ export async function runRecommendWorkflow({
           || openedDetail.detail_state?.resumeIframe?.node_id
           || null;
         if (captureNodeId) {
-          imageEvidence = await captureScrolledNodeScreenshots(client, captureNodeId, {
+          imageEvidence = await measureTiming(timings, "screenshot_capture_ms", () => captureScrolledNodeScreenshots(client, captureNodeId, {
+            filePath: imageEvidenceFilePath({
+              imageOutputDir,
+              domain: "recommend",
+              runId: runControl?.runId,
+              index
+            }),
             padding: 4,
             maxScreenshots: maxImagePages,
             wheelDeltaY: imageWheelDeltaY,
@@ -664,7 +711,7 @@ export async function runRecommendWorkflow({
               run_candidate_index: index,
               candidate_key: candidateKey
             }
-          });
+          }));
           source = "image";
           recordCvImageFallback(cvAcquisitionState, {
             parsedNetworkProfileCount,
@@ -696,10 +743,37 @@ export async function runRecommendWorkflow({
     await runControl.waitIfPaused();
     runControl.throwIfCanceled();
     runControl.setPhase("recommend:screening");
-    const screening = screenCandidate(screeningCandidate, { criteria });
+    let llmResult = null;
+    if (useLlmScreening) {
+      if (!llmConfig) {
+        llmResult = createMissingLlmConfigResult();
+      } else {
+        try {
+          const llmTimingKey = detailResult?.image_evidence?.file_paths?.length
+            ? "vision_model_ms"
+            : "text_model_ms";
+          llmResult = await measureTiming(timings, llmTimingKey, () => callScreeningLlm({
+            candidate: screeningCandidate,
+            criteria,
+            config: llmConfig,
+            timeoutMs: llmTimeoutMs,
+            imageEvidence: detailResult?.image_evidence || null,
+            maxImages: llmImageLimit,
+            imageDetail: llmImageDetail
+          }));
+        } catch (error) {
+          llmResult = createFailedLlmScreeningResult(error);
+        }
+      }
+      if (detailResult) detailResult.llm_result = llmResult;
+    }
+    const screening = useLlmScreening
+      ? llmResultToScreening(llmResult, screeningCandidate)
+      : screenCandidate(screeningCandidate, { criteria });
     let actionDiscovery = null;
     let postActionResult = null;
     if (postActionEnabled && detailResult) {
+      const postActionStarted = Date.now();
       await runControl.waitIfPaused();
       runControl.throwIfCanceled();
       runControl.setPhase("recommend:post-action");
@@ -721,19 +795,23 @@ export async function runRecommendWorkflow({
       if (postActionResult.counted_as_greet && postActionResult.action_clicked) {
         greetCount += 1;
       }
+      addTiming(timings, "post_action_ms", Date.now() - postActionStarted);
     }
     if (detailResult && closeDetail) {
-      detailResult.close_result = await closeRecommendDetail(client);
+      detailResult.close_result = await measureTiming(timings, "close_detail_ms", () => closeRecommendDetail(client));
     }
+    timings.total_ms = Date.now() - candidateStarted;
     const compactResult = {
       index,
       candidate_key: candidateKey,
       card_node_id: cardNodeId,
       candidate: compactCandidate(screeningCandidate),
       detail: compactDetail(detailResult),
+      llm_screening: detailResult ? null : compactScreeningLlmResult(llmResult),
       screening: compactScreening(screening),
       action_discovery: compactActionDiscovery(actionDiscovery),
-      post_action: postActionResult
+      post_action: postActionResult,
+      timings
     };
     results.push(compactResult);
     markInfiniteListCandidateProcessed(listState, candidateKey, {
@@ -750,6 +828,7 @@ export async function runRecommendWorkflow({
       screened: results.length,
       detail_opened: results.filter((item) => item.detail).length,
       passed: results.filter((item) => item.screening.passed).length,
+      llm_screened: results.filter((item) => item.detail?.llm_screening || item.llm_screening).length,
       greet_count: greetCount,
       post_action_clicked: results.filter((item) => item.post_action?.action_clicked).length,
       unique_seen: compactInfiniteListState(listState).seen_count,
@@ -763,7 +842,9 @@ export async function runRecommendWorkflow({
       last_candidate_key: candidateKey,
       last_score: screening.score
     });
+    const checkpointStarted = Date.now();
     runControl.checkpoint({
+      results,
       last_candidate: {
         id: screeningCandidate.id || null,
         key: candidateKey,
@@ -773,9 +854,11 @@ export async function runRecommendWorkflow({
           passed: screening.passed,
           score: screening.score
         },
+        llm_screening: compactScreeningLlmResult(llmResult),
         post_action: postActionResult
       }
     });
+    addTiming(compactResult.timings, "checkpoint_save_ms", Date.now() - checkpointStarted);
 
     if (postActionResult?.stop_run) {
       listEndReason = postActionResult.reason || "post_action_stop";
@@ -783,7 +866,10 @@ export async function runRecommendWorkflow({
     }
 
     if (delayMs > 0) {
+      const sleepStarted = Date.now();
       await runControl.sleep(delayMs);
+      addTiming(compactResult.timings, "sleep_ms", Date.now() - sleepStarted);
+      compactResult.timings.total_ms = Date.now() - candidateStarted;
     }
   }
 
@@ -806,6 +892,7 @@ export async function runRecommendWorkflow({
     processed: results.length,
     screened: results.length,
     detail_opened: results.filter((item) => item.detail).length,
+    llm_screened: results.filter((item) => item.detail?.llm_screening || item.llm_screening).length,
     passed: results.filter((item) => item.screening.passed).length,
     greet_count: greetCount,
     post_action_clicked: results.filter((item) => item.post_action?.action_clicked).length,
@@ -851,6 +938,12 @@ export function createRecommendRunService({
     actionTimeoutMs = 8000,
     actionIntervalMs = 500,
     actionAfterClickDelayMs = 900,
+    screeningMode = "llm",
+    llmConfig = null,
+    llmTimeoutMs = 120000,
+    llmImageLimit = 8,
+    llmImageDetail = "high",
+    imageOutputDir = "",
     name = "recommend-domain-run"
   } = {}) {
     if (!client) throw new Error("startRecommendRun requires a guarded CDP client");
@@ -858,6 +951,7 @@ export function createRecommendRunService({
     const normalizedPostAction = normalizeRecommendPostAction(postAction) || "none";
     const requestedPageScope = normalizeRecommendPageScope(pageScope) || "recommend";
     const normalizedFallbackPageScope = normalizeRecommendPageScope(fallbackPageScope) || "recommend";
+    const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
     const candidateLimit = Math.max(1, Number(maxCandidates) || 1);
     const normalizedDetailLimit = detailLimit == null ? candidateLimit : Math.max(0, Number(detailLimit) || 0);
     return manager.startRun({
@@ -888,7 +982,13 @@ export function createRecommendRunService({
         post_action: normalizedPostAction,
         max_greet_count: Number.isInteger(maxGreetCount) ? maxGreetCount : null,
         execute_post_action: Boolean(executePostAction),
-        action_timeout_ms: actionTimeoutMs
+        action_timeout_ms: actionTimeoutMs,
+        screening_mode: normalizedScreeningMode,
+        llm_configured: Boolean(llmConfig),
+        llm_timeout_ms: llmTimeoutMs,
+        llm_image_limit: llmImageLimit,
+        llm_image_detail: llmImageDetail,
+        image_output_dir: imageOutputDir || ""
       },
       progress: {
         card_count: 0,
@@ -896,6 +996,7 @@ export function createRecommendRunService({
         processed: 0,
         screened: 0,
         detail_opened: 0,
+        llm_screened: 0,
         passed: 0,
         greet_count: 0,
         post_action_clicked: 0
@@ -931,7 +1032,13 @@ export function createRecommendRunService({
         executePostAction,
         actionTimeoutMs,
         actionIntervalMs,
-        actionAfterClickDelayMs
+        actionAfterClickDelayMs,
+        screeningMode: normalizedScreeningMode,
+        llmConfig,
+        llmTimeoutMs,
+        llmImageLimit,
+        llmImageDetail,
+        imageOutputDir
       }, runControl)
     });
   }

package/src/domains/recruit/cards.js

@@ -4,9 +4,16 @@ import {
   querySelectorAll,
   sleep
 } from "../../core/browser/index.js";
+import { mergeBossCandidateCardFields } from "../../core/boss-cards/index.js";
 import { normalizeCandidateFromHtml } from "../../core/screening/index.js";
 import { RECRUIT_CARD_SELECTOR } from "./constants.js";
 
+function mergeRecruitCardFields(candidate, outerHTML = "") {
+  return mergeBossCandidateCardFields(candidate, outerHTML, {
+    metadataKey: "search_card_fields"
+  });
+}
+
 export async function findRecruitCardNodeIds(client, frameNodeId, {
   selector = RECRUIT_CARD_SELECTOR
 } = {}) {
@@ -37,7 +44,7 @@ export async function readRecruitCardCandidate(client, cardNodeId, {
     getAttributesMap(client, cardNodeId),
     getOuterHTML(client, cardNodeId)
   ]);
-  return normalizeCandidateFromHtml({
+  const candidate = normalizeCandidateFromHtml({
     domain: "recruit",
     source,
     html: outerHTML,
@@ -48,6 +55,7 @@ export async function readRecruitCardCandidate(client, cardNodeId, {
       ...metadata
     }
   });
+  return mergeRecruitCardFields(candidate, outerHTML);
 }
 
 export async function readFirstRecruitCardCandidate(client, frameNodeId, options = {}) {

package/src/domains/recruit/detail.js

@@ -213,17 +213,22 @@ export async function waitForRecruitDetailContent(client, {
 export async function openRecruitCardDetail(client, cardNodeId, {
   timeoutMs = 12000
 } = {}) {
+  const openedStarted = Date.now();
   const attempts = [];
+  const clickStarted = Date.now();
   const cardBox = await clickNodeCenter(client, cardNodeId, {
     scrollIntoView: true
   });
+  let candidateClickMs = Date.now() - clickStarted;
   attempts.push({
     mode: "card-center",
     center: cardBox.center
   });
+  const detailStarted = Date.now();
   let detailState = await waitForRecruitDetail(client, { timeoutMs });
 
   if (!detailState?.popup && !detailState?.resumeIframe) {
+    const fallbackClickStarted = Date.now();
     const leftTitlePoint = {
       x: cardBox.rect.x + Math.min(140, Math.max(40, cardBox.rect.width * 0.2)),
       y: cardBox.rect.y + Math.min(42, Math.max(24, cardBox.rect.height * 0.28))
@@ -232,6 +237,7 @@ export async function openRecruitCardDetail(client, cardNodeId, {
       clickCount: 2,
       delayMs: 120
     });
+    candidateClickMs += Date.now() - fallbackClickStarted;
     attempts.push({
       mode: "card-left-title-double-click",
       center: leftTitlePoint
@@ -248,7 +254,12 @@ export async function openRecruitCardDetail(client, cardNodeId, {
   return {
     card_box: cardBox,
     open_attempts: attempts,
-    detail_state: detailState
+    detail_state: detailState,
+    timings: {
+      candidate_click_ms: candidateClickMs,
+      detail_open_ms: Date.now() - detailStarted,
+      open_total_ms: Date.now() - openedStarted
+    }
   };
 }