@reconcrap/boss-recommend-mcp 2.1.19 → 2.1.20

package/package.json

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

package/src/recommend-mcp.js

@@ -54,6 +54,7 @@ import { DEFAULT_MAX_IMAGE_PAGES } from "./core/cv-acquisition/index.js";
 const DEFAULT_RECOMMEND_HOST = "127.0.0.1";
 const DEFAULT_RECOMMEND_PORT = 9222;
 const DEFAULT_RECOMMEND_POLL_AFTER_SEC = 10;
+const STATUS_METHOD_LOG_TAIL_LIMIT = 25;
 const TARGET_COUNT_SEMANTICS = "target_count means candidates that pass screening; scan continues until that many candidates pass or the list ends";
 const RUN_MODE_ASYNC = "async";
 const REST_LEVEL_OPTIONS = ["low", "medium", "high"];
@@ -302,15 +303,23 @@ function resolveRecommendDetailLimit(args = {}, normalized = {}) {
   return requested;
 }
 
-function methodSummary(methodLog = []) {
+function methodSummary(methodLog = []) {
   const summary = {};
   for (const entry of methodLog || []) {
     summary[entry.method] = (summary[entry.method] || 0) + 1;
   }
-  return summary;
-}
-
-function clonePlain(value, fallback = null) {
+  return summary;
+}
+
+function compactMethodLogForStatus(methodLog = []) {
+  if (!Array.isArray(methodLog)) return [];
+  return methodLog.slice(-STATUS_METHOD_LOG_TAIL_LIMIT).map((entry) => ({
+    method: normalizeText(entry?.method || entry || ""),
+    at: normalizeText(entry?.at || "")
+  }));
+}
+
+function clonePlain(value, fallback = null) {
   try {
     return value === undefined ? fallback : JSON.parse(JSON.stringify(value));
   } catch {
@@ -477,7 +486,7 @@ function secondsBetween(startedAt, endedAt) {
   return Math.max(1, Math.round((endMs - startMs) / 1000));
 }
 
-function normalizeLegacyProgress(progress = {}, summary = null) {
+function normalizeLegacyProgress(progress = {}, summary = null) {
   const processed = Number.isInteger(progress.processed)
     ? progress.processed
     : Number.isInteger(summary?.processed)
@@ -502,12 +511,146 @@ function normalizeLegacyProgress(progress = {}, summary = null) {
     skipped: Number.isInteger(progress.skipped) ? progress.skipped : Math.max(processed - passed, 0),
     greet_count: Number.isInteger(progress.greet_count) ? progress.greet_count : 0,
     post_action_clicked: Number.isInteger(progress.post_action_clicked) ? progress.post_action_clicked : 0
-  };
-}
-
-function completionReason(status) {
-  if (status === RUN_STATUS_COMPLETED) return "completed";
-  if (status === RUN_STATUS_CANCELED) return "canceled_by_user";
+  };
+}
+
+const STATUS_COUNT_KEYS = [
+  "processed",
+  "screened",
+  "detail_opened",
+  "passed",
+  "skipped",
+  "llm_screened",
+  "greet_count",
+  "post_action_clicked",
+  "image_capture_failed",
+  "detail_open_failed",
+  "transient_recovered",
+  "colleague_contact_checked",
+  "recent_colleague_contact_skipped",
+  "colleague_contact_panel_missing",
+  "context_recoveries",
+  "human_rest_count",
+  "human_rest_ms",
+  "card_count",
+  "refresh_rounds"
+];
+
+function compactPositiveInteger(value, fallback = null) {
+  return Number.isInteger(value) && value >= 0 ? value : fallback;
+}
+
+function compactSmallRecord(value, fallback = null) {
+  const record = plainRecord(value);
+  if (!Object.keys(record).length) return fallback;
+  return clonePlain(record, fallback);
+}
+
+function compactRecommendSummaryForStatus(summary) {
+  if (!summary || typeof summary !== "object" || Array.isArray(summary)) return null;
+  const compact = {
+    domain: normalizeText(summary.domain || "recommend") || "recommend"
+  };
+  for (const key of STATUS_COUNT_KEYS) {
+    if (Number.isInteger(summary[key])) compact[key] = summary[key];
+  }
+  if (summary.target_url) compact.target_url = normalizeText(summary.target_url);
+  if (summary.list_end_reason) compact.list_end_reason = normalizeText(summary.list_end_reason);
+  if (Array.isArray(summary.results)) {
+    compact.results_count = summary.results.length;
+  } else if (Number.isInteger(summary.results_count)) {
+    compact.results_count = summary.results_count;
+  }
+  if (Array.isArray(summary.refresh_attempts)) {
+    compact.refresh_attempt_count = summary.refresh_attempts.length;
+  }
+  if (Array.isArray(summary.context_recoveries)) {
+    compact.context_recovery_count = summary.context_recoveries.length;
+  } else if (Number.isInteger(summary.context_recoveries)) {
+    compact.context_recoveries = summary.context_recoveries;
+  }
+  if (summary.job_selection) compact.job_selection = compactSmallRecord(summary.job_selection);
+  if (summary.page_scope) compact.page_scope = compactSmallRecord(summary.page_scope);
+  if (summary.filter) compact.filter = compactSmallRecord(summary.filter);
+  if (summary.candidate_list) {
+    const candidateList = plainRecord(summary.candidate_list);
+    compact.candidate_list = {
+      total_count: compactPositiveInteger(candidateList.total_count ?? candidateList.card_count, null),
+      visible_count: compactPositiveInteger(candidateList.visible_count, null),
+      list_end_reason: normalizeText(candidateList.list_end_reason || "")
+    };
+  }
+  if (summary.viewport_health?.stats) {
+    compact.viewport_health = {
+      stats: clonePlain(summary.viewport_health.stats, {})
+    };
+  }
+  if (summary.human_behavior) {
+    compact.human_behavior = {
+      enabled: summary.human_behavior.enabled === true,
+      profile: normalizeText(summary.human_behavior.profile || ""),
+      restLevel: normalizeText(summary.human_behavior.restLevel || summary.human_behavior.rest_level || "")
+    };
+  }
+  if (summary.human_rest) {
+    const humanRest = plainRecord(summary.human_rest);
+    compact.human_rest = {
+      enabled: humanRest.enabled === true,
+      restLevel: normalizeText(humanRest.restLevel || humanRest.rest_level || ""),
+      rest_count: compactPositiveInteger(humanRest.rest_count ?? humanRest.count, null),
+      total_pause_ms: compactPositiveInteger(humanRest.total_pause_ms ?? humanRest.pause_ms, null)
+    };
+  }
+  return compact;
+}
+
+function compactRecommendCheckpointForStatus(checkpoint) {
+  if (!checkpoint || typeof checkpoint !== "object" || Array.isArray(checkpoint)) return {};
+  const compact = {};
+  if (checkpoint.updatedAt || checkpoint.updated_at) {
+    compact.updatedAt = normalizeText(checkpoint.updatedAt || checkpoint.updated_at);
+  }
+  if (Array.isArray(checkpoint.results)) {
+    compact.results_count = checkpoint.results.length;
+  } else if (Number.isInteger(checkpoint.results_count)) {
+    compact.results_count = checkpoint.results_count;
+  }
+  for (const key of STATUS_COUNT_KEYS) {
+    if (Number.isInteger(checkpoint[key])) compact[key] = checkpoint[key];
+  }
+  return compact;
+}
+
+function compactRecommendResultForStatus(result) {
+  if (!result || typeof result !== "object" || Array.isArray(result)) return result || null;
+  const compact = {
+    ...result
+  };
+  if (Array.isArray(result.results)) {
+    compact.results_count = result.results.length;
+    compact.results_available = result.results.length > 0;
+  } else if (Number.isInteger(result.results_count)) {
+    compact.results_count = result.results_count;
+    compact.results_available = result.results_available === true || result.results_count > 0;
+  }
+  delete compact.results;
+  return compact;
+}
+
+export function compactRecommendRunForStatus(run) {
+  if (!run || typeof run !== "object" || Array.isArray(run)) return run || null;
+  const compact = {
+    ...run
+  };
+  if (compact.result) compact.result = compactRecommendResultForStatus(compact.result);
+  if (compact.summary) compact.summary = compactRecommendSummaryForStatus(compact.summary);
+  if (compact.checkpoint) compact.checkpoint = compactRecommendCheckpointForStatus(compact.checkpoint);
+  return compact;
+}
+
+function completionReason(status) {
+  if (status === RUN_STATUS_COMPLETED) return "completed";
+  if (status === RUN_STATUS_CANCELED) return "canceled_by_user";
   if (status === RUN_STATUS_FAILED) return "failed";
   if (status === RUN_STATUS_PAUSED) return "paused";
   return null;
@@ -685,13 +828,14 @@ function buildLegacyRecommendResult(snapshot) {
       effective_scope: meta.normalized?.pageScope || meta.parsed?.page_scope || "recommend"
     },
     search_params: clonePlain(meta.parsed?.searchParams || {}, {}),
-    screen_params: clonePlain(meta.parsed?.screenParams || {}, {}),
-    target_count_semantics: TARGET_COUNT_SEMANTICS,
-    error: snapshot.error || null,
-    recovery: buildConstrainedAgentRecovery(snapshot, meta, artifacts),
-    results: resultRows
-  };
-}
+    screen_params: clonePlain(meta.parsed?.screenParams || {}, {}),
+    target_count_semantics: TARGET_COUNT_SEMANTICS,
+    error: snapshot.error || null,
+    recovery: buildConstrainedAgentRecovery(snapshot, meta, artifacts),
+    results_count: resultRows.length,
+    results_available: resultRows.length > 0
+  };
+}
 
 function normalizeRunSnapshot(snapshot) {
   if (!snapshot) return null;
@@ -714,10 +858,12 @@ function normalizeRunSnapshot(snapshot) {
     follow_up: clonePlain(metaArgs.follow_up ?? snapshotContext.follow_up ?? null, null),
     target_count_semantics: TARGET_COUNT_SEMANTICS
   };
-  return {
-    ...snapshot,
-    progress,
-    run_id: snapshot.runId,
+  return {
+    ...snapshot,
+    checkpoint: compactRecommendCheckpointForStatus(snapshot.checkpoint),
+    summary: compactRecommendSummaryForStatus(summary),
+    progress,
+    run_id: snapshot.runId,
     mode: RUN_MODE_ASYNC,
     state: snapshot.status,
     stage: snapshot.phase,
@@ -874,7 +1020,7 @@ function persistRecommendRunSnapshot(snapshot, {
   normalized.control = mergePersistedControlRequest(normalized, existing);
   normalized = coerceCanceledTerminalSnapshot(normalized, existing);
   if (persistActiveCheckpoint) {
-    persistRecommendCheckpointSnapshot(normalized);
+    persistRecommendCheckpointSnapshot(snapshot);
   }
   const payload = {
     run_id: normalized.run_id,
@@ -970,17 +1116,19 @@ function persistRecommendLifecycleSnapshot(snapshot, event = {}) {
   });
 }
 
-function attachMethodEvidence(payload, runId) {
-  const meta = getRecommendRunMeta(runId);
-  assertNoForbiddenCdpCalls(meta.methodLog || []);
-  return {
-    ...payload,
-    runtime_evaluate_used: false,
-    method_summary: methodSummary(meta.methodLog || []),
-    method_log: meta.methodLog || [],
-    chrome: meta.chrome || null
-  };
-}
+function attachMethodEvidence(payload, runId) {
+  const meta = getRecommendRunMeta(runId);
+  const methodLog = meta.methodLog || [];
+  assertNoForbiddenCdpCalls(methodLog);
+  return {
+    ...payload,
+    runtime_evaluate_used: false,
+    method_summary: methodSummary(methodLog),
+    method_log: compactMethodLogForStatus(methodLog),
+    method_log_total: Array.isArray(methodLog) ? methodLog.length : 0,
+    chrome: meta.chrome || null
+  };
+}
 
 function compactRecommendJobListOption(option, index) {
   const label = normalizeText(option?.label);
@@ -1945,19 +2093,19 @@ export function getRecommendPipelineRunTool({ args = {} } = {}) {
     };
   }
   try {
-    const run = recommendRunService.getRecommendRun(runId);
-    const normalizedRun = persistRecommendRunSnapshot(run);
-    return attachMethodEvidence({
-      status: "RUN_STATUS",
-      run: normalizedRun
-    }, runId);
-  } catch {
-    const persisted = readRecommendRunState(runId);
-    if (persisted) {
-      const reconciled = reconcilePersistedRecommendRunIfNeeded(persisted);
-      return {
-        status: "RUN_STATUS",
-        run: reconciled,
+    const run = recommendRunService.getRecommendRun(runId);
+    const normalizedRun = persistRecommendRunSnapshot(run);
+    return attachMethodEvidence({
+      status: "RUN_STATUS",
+      run: compactRecommendRunForStatus(normalizedRun)
+    }, runId);
+  } catch {
+    const persisted = readRecommendRunState(runId);
+    if (persisted) {
+      const reconciled = compactRecommendRunForStatus(reconcilePersistedRecommendRunIfNeeded(persisted));
+      return {
+        status: "RUN_STATUS",
+        run: reconciled,
         persistence: {
           source: "disk",
           active_control_available: false,
@@ -1985,36 +2133,36 @@ export function pauseRecommendPipelineRunTool({ args = {} } = {}) {
   try {
     const before = recommendRunService.getRecommendRun(runId);
     if (TERMINAL_STATUSES.has(before.status)) {
-      const normalizedBefore = persistRecommendRunSnapshot(before);
-      return attachMethodEvidence({
-        status: "PAUSE_IGNORED",
-        run: normalizedBefore,
-        message: "目标任务已结束，无需暂停。"
-      }, runId);
+      const normalizedBefore = persistRecommendRunSnapshot(before);
+      return attachMethodEvidence({
+        status: "PAUSE_IGNORED",
+        run: compactRecommendRunForStatus(normalizedBefore),
+        message: "目标任务已结束，无需暂停。"
+      }, runId);
     }
     if (before.status === RUN_STATUS_PAUSED) {
-      const normalizedBefore = persistRecommendRunSnapshot(before);
-      return attachMethodEvidence({
-        status: "PAUSE_IGNORED",
-        run: normalizedBefore,
-        message: "目标任务已经处于 paused 状态。"
-      }, runId);
+      const normalizedBefore = persistRecommendRunSnapshot(before);
+      return attachMethodEvidence({
+        status: "PAUSE_IGNORED",
+        run: compactRecommendRunForStatus(normalizedBefore),
+        message: "目标任务已经处于 paused 状态。"
+      }, runId);
     }
     const run = recommendRunService.pauseRecommendRun(runId);
-    const normalizedRun = persistRecommendRunSnapshot(run);
-    return attachMethodEvidence({
-      status: "PAUSE_REQUESTED",
-      run: normalizedRun,
-      message: "暂停请求已接收，将在当前候选人处理完成后进入 paused。"
-    }, runId);
+    const normalizedRun = persistRecommendRunSnapshot(run);
+    return attachMethodEvidence({
+      status: "PAUSE_REQUESTED",
+      run: compactRecommendRunForStatus(normalizedRun),
+      message: "暂停请求已接收，将在当前候选人处理完成后进入 paused。"
+    }, runId);
   } catch {
     const persisted = readRecommendRunState(runId);
     if (persisted && TERMINAL_STATUSES.has(persisted.state)) {
-      return {
-        status: "PAUSE_IGNORED",
-        run: persisted,
-        message: "目标任务已结束，无需暂停。",
-        runtime_evaluate_used: false,
+      return {
+        status: "PAUSE_IGNORED",
+        run: compactRecommendRunForStatus(persisted),
+        message: "目标任务已结束，无需暂停。",
+        runtime_evaluate_used: false,
         method_summary: {},
         method_log: [],
         chrome: null
@@ -2029,28 +2177,28 @@ export function resumeRecommendPipelineRunTool({ args = {} } = {}) {
   try {
     const before = recommendRunService.getRecommendRun(runId);
     if (TERMINAL_STATUSES.has(before.status)) {
-      const normalizedBefore = persistRecommendRunSnapshot(before);
-      return attachMethodEvidence({
-        status: "FAILED",
+      const normalizedBefore = persistRecommendRunSnapshot(before);
+      return attachMethodEvidence({
+        status: "FAILED",
         error: {
           code: "RUN_ALREADY_TERMINATED",
           message: "目标任务已结束，无法继续。",
           retryable: false
         },
-        run: normalizedBefore
-      }, runId);
+        run: compactRecommendRunForStatus(normalizedBefore)
+      }, runId);
     }
     if (before.status !== RUN_STATUS_PAUSED) {
-      const normalizedBefore = persistRecommendRunSnapshot(before);
-      return attachMethodEvidence({
-        status: "FAILED",
+      const normalizedBefore = persistRecommendRunSnapshot(before);
+      return attachMethodEvidence({
+        status: "FAILED",
         error: {
           code: "RUN_NOT_PAUSED",
           message: "仅 paused 状态的 run 才能继续。",
           retryable: true
         },
-        run: normalizedBefore
-      }, runId);
+        run: compactRecommendRunForStatus(normalizedBefore)
+      }, runId);
     }
     const run = recommendRunService.resumeRecommendRun(runId);
     const meta = getRecommendRunMeta(runId);
@@ -2058,12 +2206,12 @@ export function resumeRecommendPipelineRunTool({ args = {} } = {}) {
       meta.resumeCount = (meta.resumeCount || 0) + 1;
       meta.lastResumedAt = new Date().toISOString();
     }
-    const normalizedRun = persistRecommendRunSnapshot(run);
-    return attachMethodEvidence({
-      status: "RESUME_REQUESTED",
-      run: normalizedRun,
-      poll_after_sec: DEFAULT_RECOMMEND_POLL_AFTER_SEC,
-      message: "已恢复 Recommend run，请使用 get_recommend_pipeline_run 按需轮询。"
+    const normalizedRun = persistRecommendRunSnapshot(run);
+    return attachMethodEvidence({
+      status: "RESUME_REQUESTED",
+      run: compactRecommendRunForStatus(normalizedRun),
+      poll_after_sec: DEFAULT_RECOMMEND_POLL_AFTER_SEC,
+      message: "已恢复 Recommend run，请使用 get_recommend_pipeline_run 按需轮询。"
     }, runId);
   } catch {
     const persisted = readRecommendRunState(runId);
@@ -2077,9 +2225,9 @@ export function resumeRecommendPipelineRunTool({ args = {} } = {}) {
             : "该 run 只有磁盘快照，没有当前进程内的活动 CDP 会话，无法安全继续。",
           retryable: !TERMINAL_STATUSES.has(persisted.state)
         },
-        run: persisted,
-        persistence: {
-          source: "disk",
+        run: compactRecommendRunForStatus(persisted),
+        persistence: {
+          source: "disk",
           active_control_available: false
         },
         runtime_evaluate_used: false,
@@ -2097,28 +2245,28 @@ export function cancelRecommendPipelineRunTool({ args = {} } = {}) {
   try {
     const before = recommendRunService.getRecommendRun(runId);
     if (TERMINAL_STATUSES.has(before.status)) {
-      const normalizedBefore = persistRecommendRunSnapshot(before);
-      return attachMethodEvidence({
-        status: "CANCEL_IGNORED",
-        run: normalizedBefore,
-        message: "目标任务已结束，无需取消。"
-      }, runId);
+      const normalizedBefore = persistRecommendRunSnapshot(before);
+      return attachMethodEvidence({
+        status: "CANCEL_IGNORED",
+        run: compactRecommendRunForStatus(normalizedBefore),
+        message: "目标任务已结束，无需取消。"
+      }, runId);
     }
     const run = recommendRunService.cancelRecommendRun(runId);
-    const normalizedRun = persistRecommendRunSnapshot(run);
-    return attachMethodEvidence({
-      status: "CANCEL_REQUESTED",
-      run: normalizedRun,
-      message: "已收到取消请求，将在当前候选人处理完成后安全停止。"
-    }, runId);
+    const normalizedRun = persistRecommendRunSnapshot(run);
+    return attachMethodEvidence({
+      status: "CANCEL_REQUESTED",
+      run: compactRecommendRunForStatus(normalizedRun),
+      message: "已收到取消请求，将在当前候选人处理完成后安全停止。"
+    }, runId);
   } catch {
     const persisted = readRecommendRunState(runId);
     if (persisted && TERMINAL_STATUSES.has(persisted.state)) {
       return {
         status: "CANCEL_IGNORED",
-        run: persisted,
+        run: compactRecommendRunForStatus(persisted),
         message: "目标任务已结束，无需取消。",
-        runtime_evaluate_used: false,
+        runtime_evaluate_used: false,
         method_summary: {},
         method_log: [],
         chrome: null
@@ -2136,7 +2284,7 @@ export function cancelRecommendPipelineRunTool({ args = {} } = {}) {
     if (patched) {
       return {
         status: "CANCEL_REQUESTED",
-        run: patched,
+        run: compactRecommendRunForStatus(patched),
         message: cancelMessage,
         persistence: {
           source: "disk",

package/src/recommend-scheduler.js

@@ -5,6 +5,7 @@ import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { getStateHome } from "./run-state.js";
 import {
+  compactRecommendRunForStatus,
   getRecommendPipelineRunTool,
   prepareRecommendPipelineRunTool,
   startRecommendPipelineRunTool
@@ -142,6 +143,19 @@ function writeSchedule(scheduleId, patch) {
   });
 }
 
+function compactScheduleForStatus(schedule) {
+  if (!schedule || typeof schedule !== "object" || Array.isArray(schedule)) return schedule || null;
+  const compact = clonePlain(schedule, schedule);
+  if (compact.run) compact.run = compactRecommendRunForStatus(compact.run);
+  if (compact.launch_payload?.run) {
+    compact.launch_payload = {
+      ...compact.launch_payload,
+      run: compactRecommendRunForStatus(compact.launch_payload.run)
+    };
+  }
+  return compact;
+}
+
 function isProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
@@ -355,7 +369,7 @@ export function getRecommendScheduledRunTool({ args = {} } = {}) {
   return {
     status: "OK",
     schedule_id: scheduleId,
-    schedule: next
+    schedule: compactScheduleForStatus(next)
   };
 }