@reconcrap/boss-recommend-mcp 2.1.2 → 2.1.4

package/src/parser.js

@@ -546,7 +546,7 @@ function buildCriteria({ instruction, rawInstruction, overrideCriteria }) {
   };
 }
 
-function resolvePostAction({ instruction, confirmation, overrides }) {
+function resolvePostAction({ instruction, confirmation, overrides, finalConfirmed = false }) {
   const confirmed = confirmation?.post_action_confirmed === true;
   const confirmationValue = normalizePostAction(confirmation?.post_action_value);
   const overrideValue = normalizePostAction(overrides?.post_action);
@@ -557,40 +557,34 @@ function resolvePostAction({ instruction, confirmation, overrides }) {
         ? "greet"
         : /什么也不做|不做任何操作|不操作|仅筛选|只筛选/.test(instruction)
           ? "none"
-        : null;
+          : null;
   const proposed = overrideValue || confirmationValue || instructionValue || null;
 
-  if (confirmed && confirmationValue) {
-    return {
-      post_action: confirmationValue,
-      proposed_post_action: confirmationValue,
-      needs_post_action_confirmation: false
-    };
-  }
-
   return {
-    post_action: confirmed ? confirmationValue || proposed : null,
+    post_action: (confirmed || finalConfirmed) && proposed ? proposed : null,
     proposed_post_action: proposed,
-    needs_post_action_confirmation: true
+    needs_post_action_confirmation: !proposed
   };
 }
 
-function resolveTargetCount({ instruction, confirmation, overrides }) {
+function resolveTargetCount({ instruction, confirmation, overrides, finalConfirmed = false }) {
   const confirmed = confirmation?.target_count_confirmed === true;
   const overrideValue = parsePositiveIntegerValue(overrides?.target_count);
   const confirmationValue = parsePositiveIntegerValue(confirmation?.target_count_value);
   const instructionValue = extractTargetCount(instruction);
   const proposed = overrideValue || confirmationValue || instructionValue || null;
-  const resolved = overrideValue || (confirmed ? confirmationValue : null);
+  const resolved = (confirmed || finalConfirmed)
+    ? (overrideValue || confirmationValue || instructionValue || null)
+    : null;
 
   return {
     target_count: resolved,
     proposed_target_count: proposed,
-    needs_target_count_confirmation: !confirmed
+    needs_target_count_confirmation: false
   };
 }
 
-function resolveMaxGreetCount({ instruction, confirmation, overrides, postActionResolution }) {
+function resolveMaxGreetCount({ instruction, confirmation, overrides, postActionResolution, finalConfirmed = false }) {
   const actionHint = postActionResolution.post_action || postActionResolution.proposed_post_action;
   if (actionHint !== "greet") {
     return {
@@ -612,9 +606,12 @@ function resolveMaxGreetCount({ instruction, confirmation, overrides, postAction
     || null
   );
   const proposed = confirmationValue || overrideValue || instructionValue || null;
-  const resolved = confirmed ? (confirmationValue || overrideValue || null) : null;
+  const resolved = (confirmed || finalConfirmed)
+    ? (confirmationValue || overrideValue || instructionValue || null)
+    : null;
   const suspiciousAutoFill = Boolean(
     !confirmed
+    && !finalConfirmed
     && Number.isInteger(proposed)
     && proposed > 0
     && !Number.isInteger(instructionValue)
@@ -622,32 +619,31 @@ function resolveMaxGreetCount({ instruction, confirmation, overrides, postAction
     && targetCountHint > 0
     && proposed === targetCountHint
   );
-  const needsConfirmation = (
-    !(Number.isInteger(resolved) && resolved > 0)
-  );
+  const hasProposedValue = Number.isInteger(proposed) && proposed > 0;
+  const needsConfirmation = !hasProposedValue;
 
   return {
-    max_greet_count: needsConfirmation ? null : resolved,
+    max_greet_count: (confirmed || finalConfirmed) && hasProposedValue ? resolved : null,
     proposed_max_greet_count: proposed,
     needs_max_greet_count_confirmation: needsConfirmation,
     suspicious_auto_fill: suspiciousAutoFill
   };
 }
 
-function resolvePageScope({ instruction, confirmation, overrides }) {
+function resolvePageScope({ instruction, confirmation, overrides, finalConfirmed = false }) {
   const confirmed = confirmation?.page_confirmed === true;
   const confirmationValue = normalizePageScope(confirmation?.page_value);
   const overrideValue = normalizePageScope(overrides?.page_scope);
   const instructionValue = extractPageScope(instruction);
   const proposed = overrideValue || confirmationValue || instructionValue || "recommend";
   return {
-    page_scope: confirmed && confirmationValue ? confirmationValue : null,
+    page_scope: (confirmed && confirmationValue) || finalConfirmed ? proposed : null,
     proposed_page_scope: proposed,
-    needs_page_confirmation: !(confirmed && Boolean(confirmationValue))
+    needs_page_confirmation: !proposed
   };
 }
 
-function collectSuspiciousFields({ invalidOverrideSchoolTags, maxGreetCountResolution }) {
+function collectSuspiciousFields({ invalidOverrideSchoolTags }) {
   const suspicious = [];
   if (Array.isArray(invalidOverrideSchoolTags) && invalidOverrideSchoolTags.length > 0) {
     suspicious.push({
@@ -656,19 +652,13 @@ function collectSuspiciousFields({ invalidOverrideSchoolTags, maxGreetCountResol
       reason: `已忽略无效学校标签：${invalidOverrideSchoolTags.join(" / ")}；仅保留可识别选项。`
     });
   }
-  if (maxGreetCountResolution?.suspicious_auto_fill) {
-    suspicious.push({
-      field: "max_greet_count",
-      value: maxGreetCountResolution.proposed_max_greet_count,
-      reason: "检测到 max_greet_count 与 target_count 相同且原始指令未明确该值，可能是自动填充，需用户再次确认。"
-    });
-  }
   return suspicious;
 }
 
 export function parseRecommendInstruction({ instruction, confirmation, overrides }) {
   const rawInstruction = String(instruction || "");
   const text = normalizeText(rawInstruction);
+  const finalConfirmed = confirmation?.final_confirmed === true;
   const detectedSchoolTags = extractSchoolTags(text);
   const detectedDegrees = extractDegrees(text);
   const schoolTagAudit = auditSchoolTagSelections(overrides?.school_tag);
@@ -692,7 +682,7 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
     || extractJobSelectionHint(rawInstruction)
     || ""
   );
-  const pageScopeResolution = resolvePageScope({ instruction: text, confirmation, overrides });
+  const pageScopeResolution = resolvePageScope({ instruction: text, confirmation, overrides, finalConfirmed });
 
   const inferredSchoolTag = detectedSchoolTags.length > 0
     ? sortSchoolTagSelections(detectedSchoolTags)
@@ -717,15 +707,16 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
     post_action: null,
     max_greet_count: null
   };
-  const targetCountResolution = resolveTargetCount({ instruction: text, confirmation, overrides });
+  const targetCountResolution = resolveTargetCount({ instruction: text, confirmation, overrides, finalConfirmed });
   screenParams.target_count = targetCountResolution.target_count;
-  const postActionResolution = resolvePostAction({ instruction: text, confirmation, overrides });
+  const postActionResolution = resolvePostAction({ instruction: text, confirmation, overrides, finalConfirmed });
   screenParams.post_action = postActionResolution.post_action;
   const maxGreetCountResolution = resolveMaxGreetCount({
     instruction: text,
     confirmation,
     overrides,
-    postActionResolution
+    postActionResolution,
+    finalConfirmed
   });
   screenParams.max_greet_count = maxGreetCountResolution.max_greet_count;
 
@@ -735,37 +726,23 @@ export function parseRecommendInstruction({ instruction, confirmation, overrides
   }
 
   const suspicious_fields = collectSuspiciousFields({
-    invalidOverrideSchoolTags: schoolTagAudit.invalid,
-    maxGreetCountResolution
+    invalidOverrideSchoolTags: schoolTagAudit.invalid
   });
-  const hasConfirmedSchoolTagValue = Array.isArray(confirmationSchoolTag) && confirmationSchoolTag.length > 0;
-  const hasConfirmedDegreeValue = Array.isArray(confirmationDegrees) && confirmationDegrees.length > 0;
-  const hasConfirmedGenderValue = Boolean(confirmationGender);
-  const hasConfirmedRecentNotViewValue = Boolean(confirmationRecentNotView);
-  const needs_school_tag_confirmation = (
-    confirmation?.school_tag_confirmed !== true
-    || !hasConfirmedSchoolTagValue
-  );
-  const needs_degree_confirmation = (
-    confirmation?.degree_confirmed !== true
-    || !hasConfirmedDegreeValue
-  );
-  const needs_gender_confirmation = (
-    confirmation?.gender_confirmed !== true
-    || !hasConfirmedGenderValue
-  );
-  const needs_recent_not_view_confirmation = (
-    confirmation?.recent_not_view_confirmed !== true
-    || !hasConfirmedRecentNotViewValue
-  );
+  const hasResolvedSchoolTagValue = Array.isArray(searchParams.school_tag) && searchParams.school_tag.length > 0;
+  const hasResolvedDegreeValue = Array.isArray(searchParams.degree) && searchParams.degree.length > 0;
+  const hasResolvedGenderValue = Boolean(searchParams.gender);
+  const hasResolvedRecentNotViewValue = Boolean(searchParams.recent_not_view);
+  const needs_school_tag_confirmation = !hasResolvedSchoolTagValue;
+  const needs_degree_confirmation = !hasResolvedDegreeValue;
+  const needs_gender_confirmation = !hasResolvedGenderValue;
+  const needs_recent_not_view_confirmation = !hasResolvedRecentNotViewValue;
   const needs_filters_confirmation = (
-    confirmation?.filters_confirmed !== true
-    || needs_school_tag_confirmation
+    needs_school_tag_confirmation
     || needs_degree_confirmation
     || needs_gender_confirmation
     || needs_recent_not_view_confirmation
   );
-  const needs_criteria_confirmation = confirmation?.criteria_confirmed !== true;
+  const needs_criteria_confirmation = !screenParams.criteria;
   const needs_target_count_confirmation = targetCountResolution.needs_target_count_confirmation;
   const needs_post_action_confirmation = postActionResolution.needs_post_action_confirmation;
   const needs_max_greet_count_confirmation = maxGreetCountResolution.needs_max_greet_count_confirmation;

package/src/recommend-mcp.js

@@ -52,10 +52,12 @@ import {
 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 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 DEFAULT_RECOMMEND_PORT = 9222;
+const DEFAULT_RECOMMEND_POLL_AFTER_SEC = 10;
+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"];
+const REST_LEVEL_SET = new Set(REST_LEVEL_OPTIONS);
 
 const TERMINAL_STATUSES = new Set([
   RUN_STATUS_COMPLETED,
@@ -1019,17 +1021,68 @@ async function connectRecommendChromeSession({
   };
 }
 
-function parseRecommendPipelineRequest(args = {}) {
-  return parseRecommendInstruction({
-    instruction: args.instruction,
+function parseRecommendPipelineRequest(args = {}) {
+  return parseRecommendInstruction({
+    instruction: args.instruction,
     confirmation: args.confirmation,
     overrides: args.overrides
-  });
-}
-
-function buildRequiredConfirmations(parsed, args = {}) {
-  const required = [];
-  if (parsed.needs_page_confirmation) required.push("page_scope");
+  });
+}
+
+function readOwn(source, keys = []) {
+  if (!source || typeof source !== "object" || Array.isArray(source)) return undefined;
+  for (const key of keys) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) return source[key];
+  }
+  return undefined;
+}
+
+function getExplicitRestLevel(args = {}) {
+  const behavior = readOwn(args, ["human_behavior", "humanBehavior"]);
+  const raw = readOwn(behavior, ["restLevel", "rest_level"]);
+  const normalized = normalizeText(raw).toLowerCase();
+  return {
+    raw: raw ?? null,
+    restLevel: REST_LEVEL_SET.has(normalized) ? normalized : null,
+    valid: REST_LEVEL_SET.has(normalized),
+    missing: raw === undefined || raw === null || normalizeText(raw) === ""
+  };
+}
+
+function buildReviewScreenParams(parsed) {
+  return {
+    ...(parsed.screenParams || {}),
+    criteria: parsed.screenParams?.criteria || null,
+    criteria_normalized: parsed.criteria_normalized || null,
+    target_count: parsed.screenParams?.target_count ?? parsed.proposed_target_count ?? null,
+    post_action: parsed.screenParams?.post_action || parsed.proposed_post_action || null,
+    max_greet_count: parsed.screenParams?.max_greet_count ?? parsed.proposed_max_greet_count ?? null
+  };
+}
+
+function buildReviewPageScope(parsed) {
+  return parsed.page_scope || parsed.proposed_page_scope || "recommend";
+}
+
+function buildReviewJob(args = {}) {
+  return normalizeText(args.confirmation?.job_value || args.overrides?.job || "") || null;
+}
+
+function buildScheduleReview(args = {}) {
+  const scheduleRunAt = normalizeText(args.schedule_run_at || args.scheduleRunAt || args.run_at || args.runAt);
+  const scheduleDelayMinutes = args.schedule_delay_minutes ?? args.scheduleDelayMinutes;
+  const scheduleDelaySeconds = args.schedule_delay_seconds ?? args.scheduleDelaySeconds;
+  if (!scheduleRunAt && scheduleDelayMinutes === undefined && scheduleDelaySeconds === undefined) return null;
+  return {
+    schedule_run_at: scheduleRunAt || null,
+    schedule_delay_minutes: scheduleDelayMinutes ?? null,
+    schedule_delay_seconds: scheduleDelaySeconds ?? null
+  };
+}
+
+function buildRequiredConfirmations(parsed, args = {}) {
+  const required = [];
+  if (parsed.needs_page_confirmation) required.push("page_scope");
   if (parsed.needs_filters_confirmation) required.push("filters");
   if (parsed.needs_school_tag_confirmation) required.push("school_tag");
   if (parsed.needs_degree_confirmation) required.push("degree");
@@ -1037,45 +1090,77 @@ function buildRequiredConfirmations(parsed, args = {}) {
   if (parsed.needs_recent_not_view_confirmation) required.push("recent_not_view");
   if (parsed.needs_criteria_confirmation) required.push("criteria");
   if (parsed.needs_target_count_confirmation) required.push("target_count");
-  if (parsed.needs_post_action_confirmation) required.push("post_action");
-  if (parsed.needs_max_greet_count_confirmation) required.push("max_greet_count");
-  if ((parsed.suspicious_fields || []).length) required.push("suspicious_fields");
-
-  const confirmation = args.confirmation || {};
-  const jobValue = normalizeText(confirmation.job_value || args.overrides?.job || "");
-  if (confirmation.job_confirmed !== true || !jobValue) required.push("job");
-  if (confirmation.final_confirmed !== true) required.push("final_review");
-  return Array.from(new Set(required));
-}
+  if (parsed.needs_post_action_confirmation) required.push("post_action");
+  if (parsed.needs_max_greet_count_confirmation) required.push("max_greet_count");
+  if ((parsed.suspicious_fields || []).length) required.push("suspicious_fields");
+
+  const confirmation = args.confirmation || {};
+  const jobValue = normalizeText(confirmation.job_value || args.overrides?.job || "");
+  if (!jobValue) required.push("job");
+  const restLevel = getExplicitRestLevel(args);
+  if (!restLevel.valid) required.push("rest_level");
+  const blocksFinalReview = required.some((field) => field !== "rest_level");
+  if (confirmation.final_confirmed !== true && !blocksFinalReview) required.push("final_review");
+  return Array.from(new Set(required));
+}
 
-function buildJobPendingQuestion(args = {}) {
-  const value = normalizeText(args.confirmation?.job_value || args.overrides?.job || "");
+function buildJobPendingQuestion(args = {}) {
+  const value = normalizeText(args.confirmation?.job_value || args.overrides?.job || "");
   return {
     field: "job",
     question: "请确认推荐页岗位。CDP-only rewrite 会先切换到该岗位，再按所选页面范围执行筛选。",
     value: value || null
-  };
-}
-
-function buildFinalReviewQuestion(parsed) {
-  return {
-    field: "final_review",
-    question: "请最终确认本次推荐页筛选参数无误，并明确 final_confirmed=true 后再启动。",
-    value: {
-      page_scope: parsed.page_scope,
-      search_params: parsed.searchParams,
-      screen_params: parsed.screenParams
-    }
-  };
-}
-
-function buildNeedInputResponse(parsed) {
-  return {
-    status: "NEED_INPUT",
-    missing_fields: parsed.missing_fields,
-    required_confirmations: buildRequiredConfirmations(parsed),
-    search_params: parsed.searchParams,
-    screen_params: parsed.screenParams,
+  };
+}
+
+function buildRestLevelPendingQuestion(args = {}) {
+  const restLevel = getExplicitRestLevel(args);
+  return {
+    field: "rest_level",
+    question: restLevel.missing
+      ? "请确认本次运行休息强度 rest_level。"
+      : "rest_level 只能是 low / medium / high，请重新确认本次运行休息强度。",
+    value: restLevel.restLevel || restLevel.raw || null,
+    options: REST_LEVEL_OPTIONS.map((value) => ({
+      label: value,
+      value
+    }))
+  };
+}
+
+function buildSuspiciousFieldsQuestion(parsed) {
+  return {
+    field: "suspicious_fields",
+    question: "检测到需要修正或明确确认的异常字段，请先修正后再启动。",
+    value: parsed.suspicious_fields || []
+  };
+}
+
+function buildFinalReviewQuestion(parsed, args = {}) {
+  const restLevel = getExplicitRestLevel(args);
+  return {
+    field: "final_review",
+    question: "请最终确认本次推荐页筛选参数无误；确认后设置 final_confirmed=true 即可启动或创建定时任务。",
+    value: {
+      page_scope: buildReviewPageScope(parsed),
+      job: buildReviewJob(args),
+      search_params: parsed.searchParams,
+      screen_params: buildReviewScreenParams(parsed),
+      human_behavior: {
+        restLevel: restLevel.restLevel || null
+      },
+      schedule: buildScheduleReview(args)
+    }
+  };
+}
+
+function buildNeedInputResponse(parsed, args = {}) {
+  return {
+    status: "NEED_INPUT",
+    missing_fields: parsed.missing_fields,
+    required_confirmations: buildRequiredConfirmations(parsed, args),
+    search_params: parsed.searchParams,
+    screen_params: parsed.screenParams,
     pending_questions: parsed.pending_questions,
     review: parsed.review,
     error: {
@@ -1086,30 +1171,36 @@ function buildNeedInputResponse(parsed) {
   };
 }
 
-function buildNeedConfirmationResponse(parsed, args, requiredConfirmations) {
-  const pending = [...(parsed.pending_questions || [])];
-  if (requiredConfirmations.includes("job") && !pending.some((item) => item.field === "job")) {
-    pending.push(buildJobPendingQuestion(args));
-  }
-  if (requiredConfirmations.includes("final_review") && !pending.some((item) => item.field === "final_review")) {
-    pending.push(buildFinalReviewQuestion(parsed));
-  }
-  return {
-    status: "NEED_CONFIRMATION",
-    required_confirmations: requiredConfirmations,
-    page_scope: parsed.page_scope,
-    search_params: parsed.searchParams,
-    screen_params: parsed.screenParams,
-    pending_questions: pending,
-    review: {
-      ...(parsed.review || {}),
+function buildNeedConfirmationResponse(parsed, args, requiredConfirmations) {
+  const pending = [...(parsed.pending_questions || [])];
+  if (requiredConfirmations.includes("suspicious_fields") && !pending.some((item) => item.field === "suspicious_fields")) {
+    pending.push(buildSuspiciousFieldsQuestion(parsed));
+  }
+  if (requiredConfirmations.includes("job") && !pending.some((item) => item.field === "job")) {
+    pending.push(buildJobPendingQuestion(args));
+  }
+  if (requiredConfirmations.includes("rest_level") && !pending.some((item) => item.field === "rest_level")) {
+    pending.push(buildRestLevelPendingQuestion(args));
+  }
+  if (requiredConfirmations.includes("final_review") && !pending.some((item) => item.field === "final_review")) {
+    pending.push(buildFinalReviewQuestion(parsed, args));
+  }
+  return {
+    status: "NEED_CONFIRMATION",
+    required_confirmations: requiredConfirmations,
+    page_scope: buildReviewPageScope(parsed),
+    search_params: parsed.searchParams,
+    screen_params: buildReviewScreenParams(parsed),
+    pending_questions: pending,
+    review: {
+      ...(parsed.review || {}),
       required_confirmations: requiredConfirmations
     }
   };
 }
-
-function evaluateRecommendPipelineGate(parsed, args = {}) {
-  if (parsed.missing_fields?.length) return buildNeedInputResponse(parsed);
+
+function evaluateRecommendPipelineGate(parsed, args = {}) {
+  if (parsed.missing_fields?.length) return buildNeedInputResponse(parsed, args);
   const requiredConfirmations = buildRequiredConfirmations(parsed, args);
   if (requiredConfirmations.length) {
     return buildNeedConfirmationResponse(parsed, args, requiredConfirmations);