@reconcrap/boss-recommend-mcp 2.0.5 → 2.0.7

package/src/domains/recommend/detail.js

@@ -8,6 +8,7 @@ import {
   querySelectorAll,
   sleep
 } from "../../core/browser/index.js";
+import { candidateKeyFromProfile } from "../../core/infinite-list/index.js";
 import {
   buildScreeningCandidateFromDetail,
   htmlToText
@@ -22,6 +23,10 @@ import {
   getRecommendRoots,
   queryFirstAcrossRoots
 } from "./roots.js";
+import {
+  findRecommendCardNodeIds,
+  readRecommendCardCandidate
+} from "./cards.js";
 
 export function matchesRecommendDetailNetwork(url) {
   return DETAIL_NETWORK_PATTERNS.some((pattern) => pattern.test(String(url || "")));
@@ -146,14 +151,36 @@ export async function readRecommendDetailHtml(client, detailState) {
   let popupHTML = "";
   let resumeHTML = "";
   let resumeIframeDocumentNodeId = null;
+  const errors = [];
 
   if (detailState?.popup?.node_id) {
-    popupHTML = await getOuterHTML(client, detailState.popup.node_id);
+    try {
+      popupHTML = await getOuterHTML(client, detailState.popup.node_id);
+    } catch (error) {
+      errors.push({
+        source: "popup",
+        node_id: detailState.popup.node_id,
+        stale_node: isStaleRecommendNodeError(error),
+        error: error?.message || String(error)
+      });
+    }
   }
 
   if (detailState?.resumeIframe?.node_id) {
-    resumeIframeDocumentNodeId = await getFrameDocumentNodeId(client, detailState.resumeIframe.node_id);
-    resumeHTML = await getOuterHTML(client, resumeIframeDocumentNodeId);
+    try {
+      resumeIframeDocumentNodeId = await getFrameDocumentNodeId(client, detailState.resumeIframe.node_id);
+      resumeHTML = await getOuterHTML(client, resumeIframeDocumentNodeId);
+    } catch (error) {
+      errors.push({
+        source: "resume_iframe",
+        node_id: detailState.resumeIframe.node_id,
+        document_node_id: resumeIframeDocumentNodeId,
+        stale_node: isStaleRecommendNodeError(error),
+        error: error?.message || String(error)
+      });
+      resumeIframeDocumentNodeId = null;
+      resumeHTML = "";
+    }
   }
 
   return {
@@ -161,7 +188,90 @@ export async function readRecommendDetailHtml(client, detailState) {
     resumeHTML,
     resumeIframeDocumentNodeId,
     popupText: htmlToText(popupHTML),
-    resumeText: htmlToText(resumeHTML)
+    resumeText: htmlToText(resumeHTML),
+    errors
+  };
+}
+
+export function isStaleRecommendNodeError(error) {
+  const message = String(error?.message || error || "");
+  return /Could not find node with given id|No node with given id|Node is detached|Cannot find node/i.test(message);
+}
+
+export async function findRecommendCardNodeForCandidateKey(client, {
+  candidateKey = "",
+  rootState = null,
+  targetUrl = "",
+  source = "recommend-run-card-retry",
+  timeoutMs = 5000,
+  intervalMs = 250
+} = {}) {
+  if (!candidateKey) {
+    return {
+      ok: false,
+      reason: "candidate_key_required"
+    };
+  }
+
+  const started = Date.now();
+  let lastError = null;
+  let lastCardCount = 0;
+  while (Date.now() - started <= timeoutMs) {
+    const currentRootState = rootState?.iframe?.documentNodeId
+      ? rootState
+      : await getRecommendRoots(client);
+    const frameNodeId = currentRootState?.iframe?.documentNodeId;
+    if (!frameNodeId) {
+      return {
+        ok: false,
+        reason: "recommend_frame_not_found"
+      };
+    }
+
+    const nodeIds = await findRecommendCardNodeIds(client, frameNodeId);
+    lastCardCount = nodeIds.length;
+    for (let visibleIndex = 0; visibleIndex < nodeIds.length; visibleIndex += 1) {
+      const nodeId = nodeIds[visibleIndex];
+      try {
+        const candidate = await readRecommendCardCandidate(client, nodeId, {
+          targetUrl,
+          source,
+          metadata: {
+            visible_index: visibleIndex,
+            retry_reason: "stale_detail_node"
+          }
+        });
+        const key = candidateKeyFromProfile(candidate, {
+          nodeId,
+          visibleIndex,
+          attributes: candidate?.attributes || candidate?.metadata?.attributes || {}
+        });
+        if (key === candidateKey) {
+          return {
+            ok: true,
+            node_id: nodeId,
+            visible_index: visibleIndex,
+            candidate,
+            key,
+            root_state: currentRootState,
+            card_count: nodeIds.length
+          };
+        }
+      } catch (error) {
+        lastError = error;
+      }
+    }
+
+    if (intervalMs > 0) await sleep(intervalMs);
+    rootState = null;
+  }
+
+  return {
+    ok: false,
+    reason: "candidate_key_not_mounted",
+    candidate_key: candidateKey,
+    last_card_count: lastCardCount,
+    error: lastError?.message || null
   };
 }
 
@@ -181,6 +291,77 @@ export async function openRecommendCardDetail(client, cardNodeId, {
   };
 }
 
+export async function openRecommendCardDetailWithFreshRetry(client, {
+  cardNodeId,
+  candidateKey = "",
+  cardCandidate = null,
+  rootState = null,
+  targetUrl = "",
+  timeoutMs = 12000,
+  scrollIntoView = true,
+  retryTimeoutMs = 5000,
+  retryIntervalMs = 250,
+  maxAttempts = 2
+} = {}) {
+  let currentNodeId = cardNodeId;
+  let currentCandidate = cardCandidate;
+  let currentRootState = rootState;
+  const attempts = [];
+  const limit = Math.max(1, Number(maxAttempts) || 1);
+
+  for (let attemptIndex = 0; attemptIndex < limit; attemptIndex += 1) {
+    try {
+      const opened = await openRecommendCardDetail(client, currentNodeId, {
+        timeoutMs,
+        scrollIntoView
+      });
+      return {
+        ...opened,
+        card_node_id: currentNodeId,
+        card_candidate: currentCandidate,
+        retry_attempts: attempts
+      };
+    } catch (error) {
+      const stale = isStaleRecommendNodeError(error);
+      attempts.push({
+        attempt: attemptIndex + 1,
+        node_id: currentNodeId,
+        stale_node: stale,
+        error: error?.message || String(error)
+      });
+      if (!stale || attemptIndex >= limit - 1 || !candidateKey) {
+        error.recommend_detail_open_attempts = attempts;
+        throw error;
+      }
+
+      const resolved = await findRecommendCardNodeForCandidateKey(client, {
+        candidateKey,
+        rootState: currentRootState,
+        targetUrl,
+        timeoutMs: retryTimeoutMs,
+        intervalMs: retryIntervalMs
+      });
+      attempts[attempts.length - 1].refresh_lookup = {
+        ok: Boolean(resolved.ok),
+        node_id: resolved.node_id || null,
+        visible_index: resolved.visible_index ?? null,
+        card_count: resolved.card_count || resolved.last_card_count || 0,
+        reason: resolved.reason || null,
+        error: resolved.error || null
+      };
+      if (!resolved.ok || !resolved.node_id) {
+        error.recommend_detail_open_attempts = attempts;
+        throw error;
+      }
+      currentNodeId = resolved.node_id;
+      currentCandidate = resolved.candidate || currentCandidate;
+      currentRootState = resolved.root_state || null;
+    }
+  }
+
+  throw new Error("Recommend detail retry exhausted");
+}
+
 export async function closeRecommendDetail(client, {
   attemptsLimit = 3
 } = {}) {
@@ -317,7 +498,8 @@ export async function extractRecommendDetailCandidate(client, {
       detail_popup_root: detailState?.popup?.root || null,
       resume_iframe_selector: detailState?.resumeIframe?.selector || null,
       resume_iframe_root: detailState?.resumeIframe?.root || null,
-      resume_iframe_document_node_id: detailHtml.resumeIframeDocumentNodeId
+      resume_iframe_document_node_id: detailHtml.resumeIframeDocumentNodeId,
+      detail_html_errors: detailHtml.errors || []
     }
   });
 
@@ -334,7 +516,8 @@ export async function extractRecommendDetailCandidate(client, {
       popup_text: detailHtml.popupText,
       resume_text: detailHtml.resumeText,
       popup_html_length: detailHtml.popupHTML.length,
-      resume_html_length: detailHtml.resumeHTML.length
+      resume_html_length: detailHtml.resumeHTML.length,
+      html_errors: detailHtml.errors || []
     },
     close_result: closeResult
   };

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

@@ -21,12 +21,18 @@ 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,
   extractRecommendDetailCandidate,
-  openRecommendCardDetail,
+  openRecommendCardDetailWithFreshRetry,
   waitForRecommendDetailNetworkEvents
 } from "./detail.js";
 import {
@@ -165,10 +171,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 +372,20 @@ export async function runRecommendWorkflow({
   executePostAction = true,
   actionTimeoutMs = 8000,
   actionIntervalMs = 500,
-  actionAfterClickDelayMs = 900
+  actionAfterClickDelayMs = 900,
+  screeningMode = "llm",
+  llmConfig = null,
+  llmTimeoutMs = 120000,
+  llmImageLimit = 8,
+  llmImageDetail = "high"
 } = {}, 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 +509,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,
@@ -562,6 +589,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,
@@ -596,9 +624,9 @@ export async function runRecommendWorkflow({
     }
 
     const index = results.length;
-    const cardNodeId = nextCandidateResult.item.node_id;
+    let cardNodeId = nextCandidateResult.item.node_id;
     const candidateKey = nextCandidateResult.item.key;
-    const cardCandidate = nextCandidateResult.item.candidate;
+    let cardCandidate = nextCandidateResult.item.candidate;
 
     let screeningCandidate = cardCandidate;
     let detailResult = null;
@@ -608,7 +636,17 @@ export async function runRecommendWorkflow({
       runControl.setPhase("recommend:detail");
       rootState = await ensureRecommendViewport(rootState, "detail");
       networkRecorder.clear();
-      const openedDetail = await openRecommendCardDetail(client, cardNodeId);
+      const openedDetail = await openRecommendCardDetailWithFreshRetry(client, {
+        cardNodeId,
+        candidateKey,
+        cardCandidate,
+        rootState,
+        targetUrl,
+        maxAttempts: 2
+      });
+      cardNodeId = openedDetail.card_node_id || cardNodeId;
+      cardCandidate = openedDetail.card_candidate || cardCandidate;
+      screeningCandidate = cardCandidate;
       const waitPlan = getCvNetworkWaitPlan(cvAcquisitionState);
       const networkWait = await waitForCvNetworkEvents(
         waitForRecommendDetailNetworkEvents,
@@ -686,7 +724,30 @@ 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 {
+          llmResult = await 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) {
@@ -721,6 +782,7 @@ export async function runRecommendWorkflow({
       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
@@ -740,6 +802,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,
@@ -754,6 +817,7 @@ export async function runRecommendWorkflow({
       last_score: screening.score
     });
     runControl.checkpoint({
+      results,
       last_candidate: {
         id: screeningCandidate.id || null,
         key: candidateKey,
@@ -763,6 +827,7 @@ export async function runRecommendWorkflow({
           passed: screening.passed,
           score: screening.score
         },
+        llm_screening: compactScreeningLlmResult(llmResult),
         post_action: postActionResult
       }
     });
@@ -796,6 +861,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,
@@ -841,6 +907,11 @@ export function createRecommendRunService({
     actionTimeoutMs = 8000,
     actionIntervalMs = 500,
     actionAfterClickDelayMs = 900,
+    screeningMode = "llm",
+    llmConfig = null,
+    llmTimeoutMs = 120000,
+    llmImageLimit = 8,
+    llmImageDetail = "high",
     name = "recommend-domain-run"
   } = {}) {
     if (!client) throw new Error("startRecommendRun requires a guarded CDP client");
@@ -848,6 +919,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({
@@ -878,7 +950,12 @@ 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
       },
       progress: {
         card_count: 0,
@@ -886,6 +963,7 @@ export function createRecommendRunService({
         processed: 0,
         screened: 0,
         detail_opened: 0,
+        llm_screened: 0,
         passed: 0,
         greet_count: 0,
         post_action_clicked: 0
@@ -921,7 +999,12 @@ export function createRecommendRunService({
         executePostAction,
         actionTimeoutMs,
         actionIntervalMs,
-        actionAfterClickDelayMs
+        actionAfterClickDelayMs,
+        screeningMode: normalizedScreeningMode,
+        llmConfig,
+        llmTimeoutMs,
+        llmImageLimit,
+        llmImageDetail
       }, runControl)
     });
   }