@reconcrap/boss-recommend-mcp 2.0.6 → 2.0.8

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

@@ -24,6 +24,11 @@ import {
 } from "../../core/infinite-list/index.js";
 import { createViewportRunGuard } from "../../core/self-heal/index.js";
 import { createRunLifecycleManager } from "../../core/run/index.js";
+import {
+  addTiming,
+  imageEvidenceFilePath,
+  measureTiming
+} from "../../core/run/timing.js";
 import {
   callScreeningLlm,
   normalizeText,
@@ -167,6 +172,17 @@ function createFailedLlmResult(error) {
   };
 }
 
+function normalizeScreeningMode(value) {
+  const normalized = String(value || "llm").trim().toLowerCase();
+  return ["deterministic", "local", "local_scorer"].includes(normalized)
+    ? "deterministic"
+    : "llm";
+}
+
+function createMissingLlmConfigResult() {
+  return createFailedLlmResult(new Error("LLM screening config is required for production chat runs"));
+}
+
 function createSkippedDetailResult(cardCandidate, reason, error = null) {
   return {
     candidate: cardCandidate,
@@ -334,7 +350,7 @@ export async function runChatWorkflow({
   maxCandidates = 5,
   targetPassCount = null,
   processUntilListEnd = false,
-  detailLimit = 0,
+  detailLimit = null,
   detailSource = "cascade",
   closeResume = true,
   requestResumeForPassed = false,
@@ -353,20 +369,24 @@ export async function runChatWorkflow({
   llmTimeoutMs = 120000,
   llmImageLimit = 8,
   llmImageDetail = "high",
+  screeningMode = "llm",
   listMaxScrolls = 20,
   listStableSignatureLimit = 2,
   listWheelDeltaY = 850,
   listSettleMs = 1200,
-  listFallbackPoint = null
+  listFallbackPoint = null,
+  imageOutputDir = ""
 } = {}, runControl) {
   if (!client) throw new Error("runChatWorkflow requires a guarded CDP client");
   const normalizedDetailSource = normalizeDetailSource(detailSource);
+  const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
+  const useLlmScreening = normalizedScreeningMode !== "deterministic";
   const processedLimit = Math.max(1, Number(maxCandidates) || 1);
   const passTarget = Number.isFinite(Number(targetPassCount)) && Number(targetPassCount) > 0
     ? Number(targetPassCount)
     : null;
   const normalizedStartFrom = normalizeText(startFrom).toLowerCase() === "unread" ? "unread" : "all";
-  const detailCountLimit = Math.max(0, Number(detailLimit) || 0);
+  const detailCountLimit = detailLimit == null ? processedLimit : Math.max(0, Number(detailLimit) || 0);
   const networkRecorder = detailCountLimit > 0
     ? createChatProfileNetworkRecorder(client)
     : null;
@@ -556,6 +576,7 @@ export async function runChatWorkflow({
     requested: 0,
     request_satisfied: 0,
     request_skipped: 0,
+    screening_mode: normalizedScreeningMode,
     unique_seen: compactInfiniteListState(listState).seen_count,
     scroll_count: 0,
     viewport_checks: viewportGuard.getStats().checks,
@@ -569,6 +590,8 @@ export async function runChatWorkflow({
       || results.filter((item) => item.screening?.passed).length < passTarget
     )
   ) {
+    const candidateStarted = Date.now();
+    const timings = {};
     await runControl.waitIfPaused();
     runControl.throwIfCanceled();
     runControl.setPhase("chat:candidate");
@@ -581,7 +604,7 @@ export async function runChatWorkflow({
       continue;
     }
 
-    const nextCandidateResult = await getNextInfiniteListCandidate({
+    const nextCandidateResult = await measureTiming(timings, "card_read_ms", () => getNextInfiniteListCandidate({
       client,
       state: listState,
       maxScrolls: listMaxScrolls,
@@ -608,7 +631,7 @@ export async function runChatWorkflow({
           visible_index: visibleIndex
         }
       })
-    });
+    }));
     if (!nextCandidateResult.ok) {
       const endTopLevelState = await getChatTopLevelState(client);
       if (!endTopLevelState.is_chat_shell) {
@@ -650,11 +673,11 @@ export async function runChatWorkflow({
 
         detailStep = "select_candidate";
         networkRecorder.clear();
-        const selected = await selectFreshChatCandidate(client, {
+        const selected = await measureTiming(timings, "candidate_click_ms", () => selectFreshChatCandidate(client, {
           cardNodeId,
           candidate: cardCandidate,
           timeoutMs: onlineResumeButtonTimeoutMs
-        });
+        }));
         if (selected.ready?.forbidden_top_level_navigation) {
           throw makeForbiddenChatResumeNavigationError(selected.ready.top_level_state);
         }
@@ -681,13 +704,13 @@ export async function runChatWorkflow({
         if (!detailResult) {
           detailStep = "open_online_resume";
           networkRecorder.clear();
-          const openedResume = await openChatOnlineResume(client, {
+          const openedResume = await measureTiming(timings, "detail_open_ms", () => openChatOnlineResume(client, {
             timeoutMs: readyTimeoutMs
-          });
+          }));
           const waitPlan = getCvNetworkWaitPlan(cvAcquisitionState);
           detailStep = "wait_network";
           const networkWait = ["network", "cascade"].includes(normalizedDetailSource)
-            ? await waitForCvNetworkEvents(
+            ? await measureTiming(timings, "network_cv_wait_ms", () => waitForCvNetworkEvents(
                 waitForChatProfileNetworkEvents,
                 networkRecorder,
                 {
@@ -696,8 +719,11 @@ export async function runChatWorkflow({
                   requireLoaded: true,
                   intervalMs: 200
                 }
-              )
+              ))
             : null;
+          if (networkWait?.elapsed_ms != null) {
+            timings.network_cv_wait_ms = Math.round(Number(networkWait.elapsed_ms) || 0);
+          }
           let contentWait = {
             ok: false,
             skipped: false,
@@ -744,10 +770,10 @@ export async function runChatWorkflow({
 
           if (!detailResult) {
             detailStep = "wait_resume_content";
-            contentWait = await waitForChatResumeContent(client, {
+            contentWait = await measureTiming(timings, "dom_fallback_ms", () => waitForChatResumeContent(client, {
               timeoutMs: resumeDomTimeoutMs,
               intervalMs: 300
-            });
+            }));
             resumeState = contentWait.resume_state || openedResume.resume_state;
             resumeHtml = contentWait.resume_html || null;
             resumeNetworkEvents = networkRecorder.events.slice();
@@ -777,7 +803,13 @@ export async function runChatWorkflow({
           if (shouldCaptureImage) {
             if (captureNodeId) {
               detailStep = "capture_image_fallback";
-              imageEvidence = await captureScrolledNodeScreenshots(client, captureNodeId, {
+              imageEvidence = await measureTiming(timings, "screenshot_capture_ms", () => captureScrolledNodeScreenshots(client, captureNodeId, {
+                filePath: imageEvidenceFilePath({
+                  imageOutputDir,
+                  domain: "chat",
+                  runId: runControl?.runId,
+                  index
+                }),
                 padding: 8,
                 maxScreenshots: maxImagePages,
                 wheelDeltaY: imageWheelDeltaY,
@@ -791,7 +823,7 @@ export async function runChatWorkflow({
                   run_candidate_index: index,
                   candidate_key: candidateKey
                 }
-              });
+              }));
               source = "image";
               recordCvImageFallback(cvAcquisitionState, {
                 parsedNetworkProfileCount,
@@ -799,21 +831,23 @@ export async function runChatWorkflow({
                 imageEvidence
               });
               if (callLlmOnImage) {
-                if (!llmConfig) throw new Error("callLlmOnImage requires llmConfig");
                 detailStep = "llm_image_screening";
-                try {
-                  llmResult = await callScreeningLlm({
-                    candidate: detailResult.candidate,
-                    criteria,
-                    config: llmConfig,
-                    timeoutMs: llmTimeoutMs,
-                    imageEvidence,
-                    maxImages: llmImageLimit,
-                    imageDetail: llmImageDetail
-                  });
-                } catch (error) {
-                  if (!isRecoverableLlmScreeningError(error)) throw error;
-                  llmResult = createFailedLlmResult(error);
+                if (!llmConfig) {
+                  llmResult = createMissingLlmConfigResult();
+                } else {
+                  try {
+                    llmResult = await measureTiming(timings, "vision_model_ms", () => callScreeningLlm({
+                      candidate: detailResult.candidate,
+                      criteria,
+                      config: llmConfig,
+                      timeoutMs: llmTimeoutMs,
+                      imageEvidence,
+                      maxImages: llmImageLimit,
+                      imageDetail: llmImageDetail
+                    }));
+                  } catch (error) {
+                    llmResult = createFailedLlmResult(error);
+                  }
                 }
               }
             } else {
@@ -838,28 +872,34 @@ export async function runChatWorkflow({
             });
           }
 
-          if (llmConfig && !llmResult) {
+          if (useLlmScreening && !llmResult) {
             detailStep = "llm_screening";
-            try {
-              llmResult = await callScreeningLlm({
-                candidate: detailResult.candidate,
-                criteria,
-                config: llmConfig,
-                timeoutMs: llmTimeoutMs,
-                imageEvidence,
-                maxImages: llmImageLimit,
-                imageDetail: llmImageDetail
-              });
-            } catch (error) {
-              if (!isRecoverableLlmScreeningError(error)) throw error;
-              llmResult = createFailedLlmResult(error);
+            if (!llmConfig) {
+              llmResult = createMissingLlmConfigResult();
+            } else {
+              try {
+                const llmTimingKey = imageEvidence?.file_paths?.length
+                  ? "vision_model_ms"
+                  : "text_model_ms";
+                llmResult = await measureTiming(timings, llmTimingKey, () => callScreeningLlm({
+                  candidate: detailResult.candidate,
+                  criteria,
+                  config: llmConfig,
+                  timeoutMs: llmTimeoutMs,
+                  imageEvidence,
+                  maxImages: llmImageLimit,
+                  imageDetail: llmImageDetail
+                }));
+              } catch (error) {
+                llmResult = createFailedLlmResult(error);
+              }
             }
           }
 
           let closeResult = null;
           if (closeResume) {
             detailStep = "close_resume_modal";
-            closeResult = await closeChatResumeModal(client);
+            closeResult = await measureTiming(timings, "close_detail_ms", () => closeChatResumeModal(client));
           }
           detailResult.close_result = closeResult;
           detailResult.image_evidence = imageEvidence;
@@ -901,6 +941,26 @@ export async function runChatWorkflow({
     await runControl.waitIfPaused();
     runControl.throwIfCanceled();
     runControl.setPhase("chat:screening");
+    let cardOnlyLlmResult = null;
+    if (useLlmScreening && !detailUnavailableReason && !detailResult?.llm_result) {
+      if (!llmConfig) {
+        cardOnlyLlmResult = createMissingLlmConfigResult();
+      } else {
+        try {
+          cardOnlyLlmResult = await measureTiming(timings, "text_model_ms", () => callScreeningLlm({
+            candidate: screeningCandidate,
+            criteria,
+            config: llmConfig,
+            timeoutMs: llmTimeoutMs,
+            maxImages: llmImageLimit,
+            imageDetail: llmImageDetail
+          }));
+        } catch (error) {
+          cardOnlyLlmResult = createFailedLlmResult(error);
+        }
+      }
+    }
+    const effectiveLlmResult = detailResult?.llm_result || cardOnlyLlmResult;
     const screening = detailUnavailableReason
       ? {
           status: "skip",
@@ -909,15 +969,15 @@ export async function runChatWorkflow({
           reasons: [detailUnavailableReason],
           candidate: screeningCandidate
         }
-      : detailResult?.llm_result
-        ? llmToScreening(detailResult.llm_result, screeningCandidate)
+      : useLlmScreening
+        ? llmToScreening(effectiveLlmResult, screeningCandidate)
         : screenCandidate(screeningCandidate, { criteria });
     let postAction = null;
     if (requestResumeForPassed && screening.passed) {
-      postAction = await requestChatResumeForPassedCandidate(client, {
+      postAction = await measureTiming(timings, "post_action_ms", () => requestChatResumeForPassedCandidate(client, {
         greetingText,
         dryRun: dryRunRequestCv
-      });
+      }));
       if (postAction?.requested) requestSatisfiedCount += 1;
       if (postAction?.skipped) requestSkippedCount += 1;
       if (postAction?.requested && !postAction?.skipped) requestedCount += 1;
@@ -925,15 +985,18 @@ export async function runChatWorkflow({
         throw new Error(`REQUEST_CV_NOT_VERIFIED:${postAction?.reason || "unknown"}`);
       }
     }
+    timings.total_ms = Date.now() - candidateStarted;
     const compactResult = {
       index,
       candidate_key: candidateKey,
       card_node_id: effectiveCardNodeId,
       candidate: compactCandidate(screeningCandidate),
       detail: compactDetail(detailResult),
+      llm_screening: detailResult ? null : compactLlmResult(cardOnlyLlmResult),
       screening: compactScreening(screening),
       post_action: postAction,
-      pre_action_state: preActionState
+      pre_action_state: preActionState,
+      timings
     };
     results.push(compactResult);
     markInfiniteListCandidateProcessed(listState, candidateKey, {
@@ -951,7 +1014,7 @@ export async function runChatWorkflow({
       processed: results.length,
       screened: results.length,
       detail_opened: results.filter(resultOpenedDetail).length,
-      llm_screened: results.filter((item) => item.detail?.llm_screening).length,
+      llm_screened: results.filter((item) => item.detail?.llm_screening || item.llm_screening).length,
       passed: results.filter((item) => item.screening.passed).length,
       requested: requestedCount,
       request_satisfied: requestSatisfiedCount,
@@ -965,7 +1028,9 @@ export async function runChatWorkflow({
       last_candidate_key: candidateKey,
       last_score: screening.score
     });
+    const checkpointStarted = Date.now();
     runControl.checkpoint({
+      results,
       last_candidate: {
         id: screeningCandidate.id || null,
         key: candidateKey,
@@ -974,12 +1039,17 @@ export async function runChatWorkflow({
           status: screening.status,
           passed: screening.passed,
           score: screening.score
-        }
+        },
+        llm_screening: compactLlmResult(effectiveLlmResult)
       }
     });
+    addTiming(compactResult.timings, "checkpoint_save_ms", Date.now() - checkpointStarted);
 
     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;
     }
   }
 
@@ -1002,7 +1072,7 @@ export async function runChatWorkflow({
     processed: results.length,
     screened: results.length,
     detail_opened: results.filter(resultOpenedDetail).length,
-    llm_screened: results.filter((item) => item.detail?.llm_screening).length,
+    llm_screened: results.filter((item) => item.detail?.llm_screening || item.llm_screening).length,
     passed: results.filter((item) => item.screening.passed).length,
     requested: requestedCount,
     request_satisfied: requestSatisfiedCount,
@@ -1027,7 +1097,7 @@ export function createChatRunService({
     maxCandidates = 5,
     targetPassCount = null,
     processUntilListEnd = false,
-    detailLimit = 0,
+    detailLimit = null,
     detailSource = "cascade",
     closeResume = true,
     requestResumeForPassed = false,
@@ -1046,15 +1116,20 @@ export function createChatRunService({
     llmTimeoutMs = 120000,
     llmImageLimit = 8,
     llmImageDetail = "high",
+    screeningMode = "llm",
     listMaxScrolls = 20,
     listStableSignatureLimit = 2,
     listWheelDeltaY = 850,
     listSettleMs = 1200,
     listFallbackPoint = null,
+    imageOutputDir = "",
     name = "chat-domain-run"
   } = {}) {
     if (!client) throw new Error("startChatRun requires a guarded CDP client");
     const normalizedDetailSource = normalizeDetailSource(detailSource);
+    const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
+    const processedLimit = Math.max(1, Number(maxCandidates) || 1);
+    const normalizedDetailLimit = detailLimit == null ? processedLimit : Math.max(0, Number(detailLimit) || 0);
     return manager.startRun({
       name,
       context: {
@@ -1066,11 +1141,16 @@ export function createChatRunService({
         max_candidates: maxCandidates,
         target_pass_count: targetPassCount,
         process_until_list_end: Boolean(processUntilListEnd),
-        detail_limit: detailLimit,
+        detail_limit: normalizedDetailLimit,
         detail_source: normalizedDetailSource,
         close_resume: closeResume,
         cv_acquisition_mode: cvAcquisitionMode,
         call_llm_on_image: Boolean(callLlmOnImage),
+        screening_mode: normalizedScreeningMode,
+        llm_configured: Boolean(llmConfig),
+        llm_timeout_ms: llmTimeoutMs,
+        llm_image_limit: llmImageLimit,
+        llm_image_detail: llmImageDetail,
         max_image_pages: maxImagePages,
         image_wheel_delta_y: imageWheelDeltaY,
         list_max_scrolls: listMaxScrolls,
@@ -1078,13 +1158,14 @@ export function createChatRunService({
         list_wheel_delta_y: listWheelDeltaY,
         list_settle_ms: listSettleMs,
         list_fallback_point: listFallbackPoint,
-        online_resume_button_timeout_ms: onlineResumeButtonTimeoutMs
+        online_resume_button_timeout_ms: onlineResumeButtonTimeoutMs,
+        image_output_dir: imageOutputDir || ""
       },
       progress: {
         card_count: 0,
-        target_count: targetPassCount || (processUntilListEnd ? "all" : Math.max(1, Number(maxCandidates) || 1)),
+        target_count: targetPassCount || (processUntilListEnd ? "all" : processedLimit),
         target_pass_count: targetPassCount,
-        processed_limit: Math.max(1, Number(maxCandidates) || 1),
+        processed_limit: processedLimit,
         processed: 0,
         screened: 0,
         detail_opened: 0,
@@ -1104,7 +1185,7 @@ export function createChatRunService({
         maxCandidates,
         targetPassCount,
         processUntilListEnd,
-        detailLimit,
+        detailLimit: normalizedDetailLimit,
         detailSource: normalizedDetailSource,
         closeResume,
         requestResumeForPassed,
@@ -1123,11 +1204,13 @@ export function createChatRunService({
         llmTimeoutMs,
         llmImageLimit,
         llmImageDetail,
+        screeningMode: normalizedScreeningMode,
         listMaxScrolls,
         listStableSignatureLimit,
         listWheelDeltaY,
         listSettleMs,
-        listFallbackPoint
+        listFallbackPoint,
+        imageOutputDir
       }, runControl)
     });
   }

package/src/domains/recommend/cards.js

@@ -6,6 +6,10 @@ import {
   querySelectorAll,
   sleep
 } from "../../core/browser/index.js";
+import {
+  mergeBossCandidateCardFields,
+  parseBossCandidateCardFieldsFromHtml
+} from "../../core/boss-cards/index.js";
 import {
   htmlToText,
   normalizeCandidateFromHtml,
@@ -24,6 +28,16 @@ function normalizeRefreshButtonLabel(outerHTML = "") {
   return normalizeText(htmlToText(outerHTML)).replace(/\s+/g, "");
 }
 
+export function parseRecommendCardFieldsFromHtml(html = "") {
+  return parseBossCandidateCardFieldsFromHtml(html);
+}
+
+function enrichRecommendCardCandidate(candidate, outerHTML = "") {
+  return mergeBossCandidateCardFields(candidate, outerHTML, {
+    metadataKey: "recommend_card_fields"
+  });
+}
+
 function isRefreshButtonLabel(label = "") {
   const normalized = String(label || "").trim();
   if (!normalized || normalized.length > 80) return false;
@@ -91,7 +105,7 @@ export async function readRecommendCardCandidate(client, cardNodeId, {
     getAttributesMap(client, cardNodeId),
     getOuterHTML(client, cardNodeId)
   ]);
-  return normalizeCandidateFromHtml({
+  const candidate = normalizeCandidateFromHtml({
     domain: "recommend",
     source,
     html: outerHTML,
@@ -102,6 +116,7 @@ export async function readRecommendCardCandidate(client, cardNodeId, {
       ...metadata
     }
   });
+  return enrichRecommendCardCandidate(candidate, outerHTML);
 }
 
 export async function readFirstRecommendCardCandidate(client, frameNodeId, options = {}) {

package/src/domains/recommend/detail.js

@@ -279,15 +279,25 @@ export async function openRecommendCardDetail(client, cardNodeId, {
   timeoutMs = 12000,
   scrollIntoView = true
 } = {}) {
+  const started = Date.now();
+  const clickStarted = Date.now();
   const cardBox = await clickNodeCenter(client, cardNodeId, { scrollIntoView });
+  const candidateClickMs = Date.now() - clickStarted;
+  const detailStarted = Date.now();
   const detailState = await waitForRecommendDetail(client, { timeoutMs });
+  const detailOpenMs = Date.now() - detailStarted;
   if (!detailState?.popup && !detailState?.resumeIframe) {
     throw new Error("Candidate detail did not open or no known detail selectors mounted");
   }
 
   return {
     card_box: cardBox,
-    detail_state: detailState
+    detail_state: detailState,
+    timings: {
+      candidate_click_ms: candidateClickMs,
+      detail_open_ms: detailOpenMs,
+      open_total_ms: Date.now() - started
+    }
   };
 }