@reconcrap/boss-recommend-mcp 2.1.11 → 2.1.13

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

@@ -38,11 +38,11 @@ import {
   imageEvidenceFilePath,
   measureTiming
 } from "../../core/run/timing.js";
-import {
-  callScreeningLlm,
-  normalizeText,
-  screenCandidate
-} from "../../core/screening/index.js";
+import {
+  callScreeningLlm,
+  normalizeText,
+  screenCandidate
+} from "../../core/screening/index.js";
 import {
   CHAT_BOTTOM_MARKER_SELECTORS,
   CHAT_CARD_SELECTORS,
@@ -104,11 +104,11 @@ function compactScreening(screening) {
 
 function compactLlmResult(llmResult) {
   if (!llmResult) return null;
-  return {
-    ok: Boolean(llmResult.ok),
-    provider: llmResult.provider || null,
-    passed: llmResult.passed,
-    cot: llmResult.cot || llmResult.decision_cot || "",
+  return {
+    ok: Boolean(llmResult.ok),
+    provider: llmResult.provider || null,
+    passed: llmResult.passed,
+    cot: llmResult.cot || llmResult.decision_cot || "",
     reasoning_content: llmResult.reasoning_content || "",
     raw_model_output: llmResult.raw_model_output || "",
     evidence_count: llmResult.evidence?.length || 0,
@@ -743,12 +743,12 @@ export async function runChatWorkflow({
     safeClickPointEnabled: effectiveHumanBehavior.clickMovement,
     actionCooldownEnabled: effectiveHumanBehavior.actionCooldown
   });
-  const humanRestController = createHumanRestController({
-    enabled: effectiveHumanRestEnabled,
-    shortRestEnabled: effectiveHumanBehavior.shortRest,
-    batchRestEnabled: effectiveHumanBehavior.batchRest,
-    restLevel: effectiveHumanBehavior.restLevel
-  });
+  const humanRestController = createHumanRestController({
+    enabled: effectiveHumanRestEnabled,
+    shortRestEnabled: effectiveHumanBehavior.shortRest,
+    batchRestEnabled: effectiveHumanBehavior.batchRest,
+    restLevel: effectiveHumanBehavior.restLevel
+  });
   const normalizedDetailSource = normalizeDetailSource(detailSource);
   const normalizedScreeningMode = normalizeScreeningMode(screeningMode);
   const useLlmScreening = normalizedScreeningMode !== "deterministic";
@@ -792,12 +792,12 @@ export async function runChatWorkflow({
   let requestedCount = 0;
   let requestSatisfiedCount = 0;
   let requestSkippedCount = 0;
-  let contextSetup = {};
-  let contextRecoveryAttempts = 0;
-  const candidateRecoveryCounts = new Map();
-  let lastHumanEvent = null;
-
-  function recordHumanEvent(event = null) {
+  let contextSetup = {};
+  let contextRecoveryAttempts = 0;
+  const candidateRecoveryCounts = new Map();
+  let lastHumanEvent = null;
+
+  function recordHumanEvent(event = null) {
     if (!event) return lastHumanEvent;
     lastHumanEvent = {
       at: new Date().toISOString(),
@@ -861,13 +861,13 @@ export async function runChatWorkflow({
     ...setup.contextSetup,
     initial_top_level_state: initialTopLevelState
   };
-  runControl.checkpoint({
-    chat_context: contextSetup
-  });
-
-  async function recoverAndReapplyChatContext(reason, error = null, {
-    forceRefresh = false
-  } = {}) {
+  runControl.checkpoint({
+    chat_context: contextSetup
+  });
+
+  async function recoverAndReapplyChatContext(reason, error = null, {
+    forceRefresh = false
+  } = {}) {
     runControl.setPhase("chat:recover_shell");
     contextRecoveryAttempts += 1;
     const shellRecovery = await recoverChatShell(client, {
@@ -967,12 +967,12 @@ export async function runChatWorkflow({
       context_recoveries: contextRecoveryAttempts,
       list_end_reason: listEndReason,
       viewport_checks: viewportGuard.getStats().checks,
-      viewport_recoveries: viewportGuard.getStats().recoveries,
-      human_behavior_enabled: effectiveHumanBehavior.enabled,
-      human_behavior_profile: effectiveHumanBehavior.profile,
-      human_rest_level: effectiveHumanBehavior.restLevel,
-      human_rest_enabled: effectiveHumanRestEnabled,
-      human_rest_count: humanRestController.getState().rest_count,
+      viewport_recoveries: viewportGuard.getStats().recoveries,
+      human_behavior_enabled: effectiveHumanBehavior.enabled,
+      human_behavior_profile: effectiveHumanBehavior.profile,
+      human_rest_level: effectiveHumanBehavior.restLevel,
+      human_rest_enabled: effectiveHumanRestEnabled,
+      human_rest_count: humanRestController.getState().rest_count,
       human_rest_ms: humanRestController.getState().total_rest_ms,
       last_human_event: lastHumanEvent
     });
@@ -997,10 +997,10 @@ export async function runChatWorkflow({
       last_human_event: lastHumanEvent,
       list_end_reason: listEndReason,
       target_pass_count: passTarget,
-      process_until_list_end: Boolean(processUntilListEnd),
-      processed_limit: processedLimit,
-      detail_source: normalizedDetailSource,
-      processed: 0,
+      process_until_list_end: Boolean(processUntilListEnd),
+      processed_limit: processedLimit,
+      detail_source: normalizedDetailSource,
+      processed: 0,
       screened: 0,
       detail_opened: 0,
       llm_screened: 0,
@@ -1501,11 +1501,11 @@ export async function runChatWorkflow({
                   llmResult = createMissingLlmConfigResult();
                 } else {
                   try {
-                    llmResult = await measureTiming(timings, "vision_model_ms", () => callScreeningLlm({
-                      candidate: detailResult.candidate,
-                      criteria,
-                      config: llmConfig,
-                      timeoutMs: llmTimeoutMs,
+                    llmResult = await measureTiming(timings, "vision_model_ms", () => callScreeningLlm({
+                      candidate: detailResult.candidate,
+                      criteria,
+                      config: llmConfig,
+                      timeoutMs: llmTimeoutMs,
                       imageEvidence,
                       maxImages: llmImageLimit,
                       imageDetail: llmImageDetail
@@ -1574,10 +1574,10 @@ export async function runChatWorkflow({
                   const llmTimingKey = imageEvidence?.file_paths?.length
                     ? "vision_model_ms"
                     : "text_model_ms";
-                  llmResult = await measureTiming(timings, llmTimingKey, () => callScreeningLlm({
-                    candidate: detailResult.candidate,
-                    criteria,
-                    config: llmConfig,
+                  llmResult = await measureTiming(timings, llmTimingKey, () => callScreeningLlm({
+                    candidate: detailResult.candidate,
+                    criteria,
+                    config: llmConfig,
                     timeoutMs: llmTimeoutMs,
                     imageEvidence,
                     maxImages: llmImageLimit,
@@ -1773,12 +1773,12 @@ export async function runChatWorkflow({
       context_recoveries: contextRecoveryAttempts,
       list_end_reason: listEndReason || null,
       viewport_checks: viewportGuard.getStats().checks,
-      viewport_recoveries: viewportGuard.getStats().recoveries,
-      human_behavior_enabled: effectiveHumanBehavior.enabled,
-      human_behavior_profile: effectiveHumanBehavior.profile,
-      human_rest_level: effectiveHumanBehavior.restLevel,
-      human_rest_enabled: effectiveHumanRestEnabled,
-      human_rest_count: humanRestController.getState().rest_count,
+      viewport_recoveries: viewportGuard.getStats().recoveries,
+      human_behavior_enabled: effectiveHumanBehavior.enabled,
+      human_behavior_profile: effectiveHumanBehavior.profile,
+      human_rest_level: effectiveHumanBehavior.restLevel,
+      human_rest_enabled: effectiveHumanRestEnabled,
+      human_rest_count: humanRestController.getState().rest_count,
       human_rest_ms: humanRestController.getState().total_rest_ms,
       last_human_event: lastHumanEvent,
       last_candidate_id: screeningCandidate.id || null,
@@ -1818,11 +1818,11 @@ export async function runChatWorkflow({
         compactResult.human_rest = restResult;
         addTiming(compactResult.timings, "human_rest_ms", restElapsed);
         compactResult.timings.total_ms = Date.now() - candidateStarted;
-        runControl.updateProgress({
-          human_rest_enabled: effectiveHumanRestEnabled,
-          human_rest_level: effectiveHumanBehavior.restLevel,
-          human_rest_count: humanRestController.getState().rest_count,
-          human_rest_ms: humanRestController.getState().total_rest_ms,
+        runControl.updateProgress({
+          human_rest_enabled: effectiveHumanRestEnabled,
+          human_rest_level: effectiveHumanBehavior.restLevel,
+          human_rest_count: humanRestController.getState().rest_count,
+          human_rest_ms: humanRestController.getState().total_rest_ms,
           human_rest_last: restResult,
           context_recoveries: contextRecoveryAttempts,
           last_human_event: lastHumanEvent
@@ -1855,10 +1855,10 @@ export async function runChatWorkflow({
     last_human_event: lastHumanEvent,
     list_end_reason: listEndReason || null,
     target_pass_count: passTarget,
-    process_until_list_end: Boolean(processUntilListEnd),
-    processed_limit: processedLimit,
-    detail_source: normalizedDetailSource,
-    processed: finalCounters.processed,
+    process_until_list_end: Boolean(processUntilListEnd),
+    processed_limit: processedLimit,
+    detail_source: normalizedDetailSource,
+    processed: finalCounters.processed,
     screened: finalCounters.screened,
     detail_opened: finalCounters.detail_opened,
     llm_screened: finalCounters.llm_screened,
@@ -1880,10 +1880,10 @@ export function createChatRunService({
 } = {}) {
   const manager = lifecycle || createRunLifecycleManager({ idPrefix, onSnapshot });
 
-  function startChatRun({
-    runId = "",
-    client,
-    targetUrl = CHAT_TARGET_URL,
+  function startChatRun({
+    runId = "",
+    client,
+    targetUrl = CHAT_TARGET_URL,
     job = "",
     startFrom = "all",
     criteria = "",
@@ -1929,10 +1929,10 @@ export function createChatRunService({
       legacyEnabled: humanRestEnabled === true || llmConfig?.humanRestEnabled === true
     });
     const effectiveHumanRestEnabled = effectiveHumanBehavior.restEnabled;
-    return manager.startRun({
-      runId,
-      name,
-      context: {
+    return manager.startRun({
+      runId,
+      name,
+      context: {
         domain: "chat",
         target_url: targetUrl,
         criteria_present: Boolean(criteria),
@@ -1962,13 +1962,13 @@ export function createChatRunService({
         list_settle_ms: listSettleMs,
         list_fallback_point: listFallbackPoint,
         online_resume_button_timeout_ms: onlineResumeButtonTimeoutMs,
-        image_output_dir: imageOutputDir || "",
-        human_behavior_enabled: effectiveHumanBehavior.enabled,
-        human_behavior_profile: effectiveHumanBehavior.profile,
-        human_behavior: effectiveHumanBehavior,
-        human_rest_level: effectiveHumanBehavior.restLevel,
-        human_rest_enabled: effectiveHumanRestEnabled
-      },
+        image_output_dir: imageOutputDir || "",
+        human_behavior_enabled: effectiveHumanBehavior.enabled,
+        human_behavior_profile: effectiveHumanBehavior.profile,
+        human_behavior: effectiveHumanBehavior,
+        human_rest_level: effectiveHumanBehavior.restLevel,
+        human_rest_enabled: effectiveHumanRestEnabled
+      },
       progress: {
         card_count: 0,
         target_count: targetPassCount || (processUntilListEnd ? "all" : processedLimit),
@@ -1983,11 +1983,11 @@ export function createChatRunService({
         requested: 0,
         request_satisfied: 0,
         request_skipped: 0,
-        context_recoveries: 0,
-        human_behavior_enabled: effectiveHumanBehavior.enabled,
-        human_behavior_profile: effectiveHumanBehavior.profile,
-        human_rest_level: effectiveHumanBehavior.restLevel,
-        human_rest_enabled: effectiveHumanRestEnabled,
+        context_recoveries: 0,
+        human_behavior_enabled: effectiveHumanBehavior.enabled,
+        human_behavior_profile: effectiveHumanBehavior.profile,
+        human_rest_level: effectiveHumanBehavior.restLevel,
+        human_rest_enabled: effectiveHumanRestEnabled,
         human_rest_count: 0,
         human_rest_ms: 0,
         last_human_event: null

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

@@ -38,13 +38,13 @@ import {
   resolveInfiniteListFallbackPoint
 } from "../../core/infinite-list/index.js";
 import { createViewportRunGuard } from "../../core/self-heal/index.js";
-import {
-  callScreeningLlm,
-  compactScreeningLlmResult,
-  createFailedLlmScreeningResult,
-  llmResultToScreening,
-  screenCandidate
-} from "../../core/screening/index.js";
+import {
+  callScreeningLlm,
+  compactScreeningLlmResult,
+  createFailedLlmScreeningResult,
+  llmResultToScreening,
+  screenCandidate
+} from "../../core/screening/index.js";
 import {
   closeRecommendBlockingPanels,
   closeRecommendAvatarPreview,
@@ -906,8 +906,8 @@ export async function runRecommendWorkflow({
       recovery_reason: reason
     });
     return refreshResult;
-  }
-
+  }
+
   runControl.setPhase("recommend:cleanup");
   await closeRecommendDetail(client, { attemptsLimit: 2 });
   await closeRecommendAvatarPreview(client, { attemptsLimit: 2 });
@@ -1334,11 +1334,11 @@ export async function runRecommendWorkflow({
           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,
+          llmResult = await measureTiming(timings, llmTimingKey, () => callScreeningLlm({
+            candidate: screeningCandidate,
+            criteria,
+            config: llmConfig,
+            timeoutMs: llmTimeoutMs,
             imageEvidence: detailResult?.image_evidence || null,
             maxImages: llmImageLimit,
             imageDetail: llmImageDetail
@@ -1532,7 +1532,7 @@ export async function runRecommendWorkflow({
     human_rest: humanRestController.getState(),
     last_human_event: lastHumanEvent,
     list_end_reason: listEndReason || null,
-    refresh_rounds: refreshRounds,
+    refresh_rounds: refreshRounds,
     refresh_attempts: refreshAttempts,
     context_recoveries: contextRecoveryAttempts,
     ...countRecommendResultStatuses(results, { greetCount }),

package/src/index.js

@@ -123,8 +123,50 @@ const TOOL_GET_RECRUIT_PIPELINE_RUN = "get_recruit_pipeline_run";
 const TOOL_CANCEL_RECRUIT_PIPELINE_RUN = "cancel_recruit_pipeline_run";
 const TOOL_PAUSE_RECRUIT_PIPELINE_RUN = "pause_recruit_pipeline_run";
 const TOOL_RESUME_RECRUIT_PIPELINE_RUN = "resume_recruit_pipeline_run";
-
-const SERVER_NAME = "boss-recommend-mcp";
+
+const SERVER_NAME = "boss-recommend-mcp";
+const MCP_TOOLSET_ENV = "BOSS_RECOMMEND_MCP_TOOLSET";
+const MCP_TOOLSET_ALL = "all";
+const MCP_TOOLSET_RECOMMEND = "recommend";
+const MCP_TOOLSET_CHAT = "chat";
+const MCP_TOOLSET_RECRUIT = "recruit";
+const VALID_MCP_TOOLSETS = new Set([
+  MCP_TOOLSET_ALL,
+  MCP_TOOLSET_RECOMMEND,
+  MCP_TOOLSET_CHAT,
+  MCP_TOOLSET_RECRUIT
+]);
+const RECOMMEND_TOOL_NAMES = new Set([
+  TOOL_LIST_RECOMMEND_JOBS,
+  TOOL_RUN_RECOMMEND,
+  TOOL_START_RUN,
+  TOOL_PREPARE_RUN,
+  TOOL_SCHEDULE_RUN,
+  TOOL_GET_SCHEDULED_RUN,
+  TOOL_GET_RUN,
+  TOOL_LIST_RUNS,
+  TOOL_CANCEL_RUN,
+  TOOL_PAUSE_RUN,
+  TOOL_RESUME_RUN
+]);
+const BOSS_CHAT_TOOL_NAMES = new Set([
+  TOOL_BOSS_CHAT_HEALTH_CHECK,
+  TOOL_BOSS_CHAT_LIST_JOBS,
+  TOOL_BOSS_CHAT_PREPARE_RUN,
+  TOOL_BOSS_CHAT_START_RUN,
+  TOOL_BOSS_CHAT_GET_RUN,
+  TOOL_BOSS_CHAT_PAUSE_RUN,
+  TOOL_BOSS_CHAT_RESUME_RUN,
+  TOOL_BOSS_CHAT_CANCEL_RUN
+]);
+const RECRUIT_TOOL_NAMES = new Set([
+  TOOL_RUN_RECRUIT_PIPELINE,
+  TOOL_START_RECRUIT_PIPELINE_RUN,
+  TOOL_GET_RECRUIT_PIPELINE_RUN,
+  TOOL_CANCEL_RECRUIT_PIPELINE_RUN,
+  TOOL_PAUSE_RECRUIT_PIPELINE_RUN,
+  TOOL_RESUME_RECRUIT_PIPELINE_RUN
+]);
 const FRAMING_UNKNOWN = "unknown";
 const FRAMING_HEADER = "header";
 const FRAMING_LINE = "line";
@@ -454,6 +496,26 @@ function readRawRunState(runId) {
   }
 }
 
+function compactProgressForList(progress = {}) {
+  const compact = {};
+  for (const key of [
+    "processed",
+    "screened",
+    "passed",
+    "skipped",
+    "target_count",
+    "card_count",
+    "detail_opened",
+    "greet_count",
+    "post_action_clicked"
+  ]) {
+    if (Number.isFinite(progress?.[key])) {
+      compact[key] = progress[key];
+    }
+  }
+  return compact;
+}
+
 function getRunSortTime(run = {}, fallbackMs = 0) {
   for (const key of ["updated_at", "heartbeat_at", "completed_at", "started_at", "updatedAt", "completedAt", "startedAt"]) {
     const ms = Date.parse(run?.[key] || "");
@@ -477,7 +539,7 @@ function compactRunForList(run = {}) {
     heartbeat_at: run.heartbeat_at || null,
     completed_at: run.completed_at || run.completedAt || null,
     pid: Number.isInteger(run.pid) && run.pid > 0 ? run.pid : null,
-    progress: run.progress || {},
+    progress: compactProgressForList(run.progress),
     last_message: normalizeText(run.last_message || error?.message || ""),
     control: {
       pause_requested: run.control?.pause_requested === true,
@@ -494,11 +556,10 @@ function compactRunForList(run = {}) {
       report_json: normalizeText(result.report_json || result.result?.report_json || ""),
       checkpoint_path: normalizeText(result.checkpoint_path || result.result?.checkpoint_path || "")
     } : null,
-    resume: {
-      checkpoint_path: normalizeText(run.resume?.checkpoint_path || ""),
-      output_csv: normalizeText(run.resume?.output_csv || ""),
-      worker_stdout_path: normalizeText(run.resume?.worker_stdout_path || ""),
-      worker_stderr_path: normalizeText(run.resume?.worker_stderr_path || "")
+    artifacts: {
+      output_csv: normalizeText(result?.output_csv || result?.result?.output_csv || ""),
+      report_json: normalizeText(result?.report_json || result?.result?.report_json || ""),
+      checkpoint_path: normalizeText(result?.checkpoint_path || result?.result?.checkpoint_path || "")
     }
   };
 }
@@ -1294,8 +1355,154 @@ function createScheduleRunInputSchema() {
   };
 }
 
-function createToolsSchema() {
-  return [
+function createCompactRunInputSchema() {
+  const targetCountSchema = {
+    anyOf: [
+      { type: "integer", minimum: 0 },
+      { type: "string" }
+    ],
+    description: "目标通过人数；扫到底/不限可传 all"
+  };
+  return {
+    type: "object",
+    properties: {
+      instruction: {
+        type: "string",
+        description: "用户原始筛选标准/任务说明；正式启动时逐字复用"
+      },
+      confirmation: {
+        type: "object",
+        properties: {
+          final_confirmed: {
+            type: "boolean",
+            description: "用户完成总确认后传 true"
+          }
+        },
+        additionalProperties: true
+      },
+      overrides: {
+        type: "object",
+        properties: {
+          page_scope: { type: "string", enum: ["recommend", "latest", "featured"] },
+          school_tag: {
+            anyOf: [
+              { type: "string" },
+              { type: "array", items: { type: "string" } }
+            ]
+          },
+          degree: {
+            anyOf: [
+              { type: "string" },
+              { type: "array", items: { type: "string" } }
+            ]
+          },
+          gender: { type: "string" },
+          recent_not_view: { type: "string" },
+          criteria: { type: "string" },
+          target_count: targetCountSchema,
+          post_action: { type: "string", enum: ["greet", "none"] },
+          max_greet_count: targetCountSchema,
+          job: { type: "string" }
+        },
+        additionalProperties: true
+      },
+      human_behavior: {
+        type: "object",
+        properties: {
+          restLevel: { type: "string", enum: ["low", "medium", "high"] },
+          rest_level: { type: "string", enum: ["low", "medium", "high"] }
+        },
+        additionalProperties: true
+      },
+      host: { type: "string" },
+      port: { type: "integer", minimum: 1 },
+      slow_live: { type: "boolean" },
+      delay_ms: { type: "integer", minimum: 0 },
+      detail_limit: { type: "integer", minimum: 0 },
+      execute_post_action: { type: "boolean" },
+      no_filter: { type: "boolean" },
+      dry_run: { type: "boolean" }
+    },
+    required: ["instruction"],
+    additionalProperties: true
+  };
+}
+
+function createCompactScheduleRunInputSchema() {
+  const base = createCompactRunInputSchema();
+  return {
+    ...base,
+    properties: {
+      ...base.properties,
+      schedule_id: {
+        type: "string",
+        description: "可选，自定义定时任务 id；默认自动生成"
+      },
+      schedule_run_at: {
+        type: "string",
+        description: "ISO 时间字符串"
+      },
+      schedule_delay_minutes: {
+        type: "number",
+        minimum: 0
+      },
+      schedule_delay_seconds: {
+        type: "number",
+        minimum: 0
+      }
+    }
+  };
+}
+
+function normalizeMcpToolset(value) {
+  const raw = String(value || "").trim().toLowerCase().replace(/[\s_]+/g, "-");
+  if (!raw) return MCP_TOOLSET_ALL;
+  if (raw === "boss-recommend" || raw === "recommend-page" || raw === "recommended") return MCP_TOOLSET_RECOMMEND;
+  if (raw === "boss-chat" || raw === "chat-only" || raw === "chat-page") return MCP_TOOLSET_CHAT;
+  if (raw === "boss-recruit" || raw === "search" || raw === "search-page" || raw === "recruit-page") return MCP_TOOLSET_RECRUIT;
+  return VALID_MCP_TOOLSETS.has(raw) ? raw : MCP_TOOLSET_ALL;
+}
+
+function getConfiguredMcpToolset(argv = process.argv, env = process.env) {
+  const args = Array.isArray(argv) ? argv.slice(2) : [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = String(args[index] || "");
+    if (arg === "--toolset" || arg === "--tools") {
+      return normalizeMcpToolset(args[index + 1]);
+    }
+    if (arg.startsWith("--toolset=")) {
+      return normalizeMcpToolset(arg.slice("--toolset=".length));
+    }
+    if (arg.startsWith("--tools=")) {
+      return normalizeMcpToolset(arg.slice("--tools=".length));
+    }
+  }
+  return normalizeMcpToolset(env?.[MCP_TOOLSET_ENV]);
+}
+
+function toolNamesForMcpToolset(toolset) {
+  const normalized = normalizeMcpToolset(toolset);
+  if (normalized === MCP_TOOLSET_RECOMMEND) return RECOMMEND_TOOL_NAMES;
+  if (normalized === MCP_TOOLSET_CHAT) return BOSS_CHAT_TOOL_NAMES;
+  if (normalized === MCP_TOOLSET_RECRUIT) return RECRUIT_TOOL_NAMES;
+  return null;
+}
+
+function filterToolsForMcpToolset(tools, toolset = getConfiguredMcpToolset()) {
+  const names = toolNamesForMcpToolset(toolset);
+  if (!names) return tools;
+  return tools.filter((tool) => names.has(tool.name));
+}
+
+function createToolsSchema(toolset = getConfiguredMcpToolset()) {
+  const normalizedToolset = normalizeMcpToolset(toolset);
+  const runInputSchema = normalizedToolset === MCP_TOOLSET_RECOMMEND
+    ? createCompactRunInputSchema()
+    : createRunInputSchema();
+  const scheduleRunInputSchema = normalizedToolset === MCP_TOOLSET_RECOMMEND
+    ? createCompactScheduleRunInputSchema()
+    : createScheduleRunInputSchema();
+  const tools = [
     {
       name: TOOL_BOSS_CHAT_HEALTH_CHECK,
       description: "Boss 聊天页/chat-only 健康检查。chat-only、未读、全部聊天、求简历等任务必须先走 boss-chat 工具，不要调用 list_recommend_jobs 或 start_recommend_pipeline_run。",
@@ -1402,22 +1609,22 @@ function createToolsSchema() {
     {
       name: TOOL_RUN_RECOMMEND,
       description: "立即通过原生 MCP 启动 Boss 推荐页筛选。它是 start_recommend_pipeline_run 的短别名；用户已经确认并要现在启动时，优先调用本工具，不需要先调用 prepare_recommend_pipeline_run。必须作为 MCP tool call 调用，禁止通过 terminal/shell/run_command/PowerShell/CLI/manual JSON-RPC 代替，也不要用 schedule_recommend_pipeline_run 冒充立即启动。",
-      inputSchema: createRunInputSchema()
+      inputSchema: runInputSchema
     },
     {
       name: TOOL_START_RUN,
       description: "立即通过原生 MCP 异步启动 Boss 推荐页流水线（含同步门禁预检）。用户已经确认并要现在启动时，优先调用本工具或 run_recommend，不需要先调用 prepare_recommend_pipeline_run。必须作为 MCP tool call 调用，禁止通过 terminal/shell/run_command/PowerShell/CLI/manual JSON-RPC 代替，也不要用 schedule_recommend_pipeline_run 冒充立即启动。",
-      inputSchema: createRunInputSchema()
+      inputSchema: runInputSchema
     },
     {
       name: TOOL_PREPARE_RUN,
       description: "只校验 Boss 推荐页流水线参数是否完整；不会启动筛选任务。主要用于显式预检或稍后/cron/定时启动前校验。若用户要现在运行，READY/cron_ready=true 后必须继续调用本 MCP server 的 run_recommend 或 start_recommend_pipeline_run；prepare 能返回结果就证明原生 MCP 可用，禁止改用 terminal/shell/run_command/PowerShell/CLI/manual JSON-RPC，也禁止再次调用 prepare 试图启动。",
-      inputSchema: createRunInputSchema()
+      inputSchema: runInputSchema
     },
     {
       name: TOOL_SCHEDULE_RUN,
       description: "只用于用户明确要求稍后/cron/定时启动的 package-owned Boss 推荐页定时任务。若用户要现在运行，必须调用 run_recommend 或 start_recommend_pipeline_run，不要用短延迟 schedule 冒充立即启动。schedule 会先校验 READY/cron_ready，再保存完整 payload，并由 detached scheduler 到点直接启动，不依赖 AI harness 自己拼 shell cron。",
-      inputSchema: createScheduleRunInputSchema()
+      inputSchema: scheduleRunInputSchema
     },
     {
       name: TOOL_GET_SCHEDULED_RUN,
@@ -1558,6 +1765,7 @@ function createToolsSchema() {
       inputSchema: createRecruitRunIdInputSchema()
     }
   ];
+  return filterToolsForMcpToolset(tools, toolset);
 }
 
 function createToolResultResponse(id, payload, isError = false) {
@@ -2859,10 +3067,19 @@ async function handleRequest(message, workspaceRoot) {
     };
   }
 
-  if (method === "tools/call") {
-    const toolName = params?.name;
-    const args = params?.arguments || {};
-
+  if (method === "tools/call") {
+    const toolName = params?.name;
+    const args = params?.arguments || {};
+    const toolset = getConfiguredMcpToolset();
+    const visibleToolNames = new Set(createToolsSchema(toolset).map((tool) => tool.name));
+    if (!visibleToolNames.has(toolName)) {
+      return createJsonRpcError(
+        id,
+        -32602,
+        `Tool ${toolName || ""} is not available in the ${toolset} boss-recommend-mcp toolset. Use the MCP server/toolset that exposes this domain instead of terminal or CLI fallback.`
+      );
+    }
+
     if ([TOOL_RUN_RECOMMEND, TOOL_START_RUN].includes(toolName)) {
       const inputError = validateRunArgs(args);
       if (inputError) {
@@ -3105,6 +3322,9 @@ export function startServer() {
 }
 
 export const __testables = {
+  createToolsSchema,
+  getConfiguredMcpToolset,
+  normalizeMcpToolset,
   handleRequest,
   runDetachedWorkerForTests(options = {}) {
     return runDetachedWorker(options);