@reconcrap/boss-recommend-mcp 2.0.15 → 2.0.17

package/config/screening-config.example.json

@@ -4,7 +4,10 @@
   "model": "gpt-4.1-mini",
   "llmThinkingLevel": "low",
   "llmTimeoutMs": 60000,
+  "llmMaxTokens": 512,
   "llmMaxRetries": 3,
+  "llmImageLimit": 8,
+  "llmImageDetail": "low",
   "debugPort": 9222,
   "outputDir": "",
   "humanRestEnabled": false,

package/package.json

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

package/src/chat-runtime-config.js

@@ -10,6 +10,7 @@ const SCREEN_CONFIG_TEMPLATE_DEFAULTS = Object.freeze({
   apiKey: "replace-with-your-api-key",
   model: "gpt-4.1-mini"
 });
+const LLM_THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "auto", "current"]);
 
 export const TARGET_COUNT_CANONICAL_ALL = "all";
 export const TARGET_COUNT_ACCEPTED_EXAMPLES = [TARGET_COUNT_CANONICAL_ALL, -1, 20, "全部候选人"];
@@ -223,6 +224,12 @@ function parsePositiveInteger(raw, fallback = null) {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 
+function parseConfigNumber(raw, fallback = null) {
+  if (raw === undefined || raw === null || raw === "") return fallback;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
 function parseConfigBoolean(raw, fallback = false) {
   if (typeof raw === "boolean") return raw;
   const normalized = normalizeText(raw).toLowerCase();
@@ -231,6 +238,11 @@ function parseConfigBoolean(raw, fallback = false) {
   return fallback;
 }
 
+function normalizeLlmThinkingLevel(raw, fallback = "low") {
+  const normalized = normalizeText(raw).toLowerCase();
+  return LLM_THINKING_LEVELS.has(normalized) ? normalized : fallback;
+}
+
 function resolveConfigPathValue(raw, configDir) {
   const normalized = normalizeText(raw);
   if (!normalized) return "";
@@ -387,8 +399,18 @@ export function resolveBossScreeningConfig(workspaceRoot) {
       baseUrl: normalizeText(parsed.baseUrl).replace(/\/+$/, ""),
       apiKey: normalizeText(parsed.apiKey),
       model: normalizeText(parsed.model),
+      openaiOrganization: normalizeText(parsed.openaiOrganization || parsed.organization),
+      openaiProject: normalizeText(parsed.openaiProject || parsed.project),
       debugPort: parsePositiveInteger(parsed.debugPort, 9222),
-      llmThinkingLevel: normalizeText(parsed.llmThinkingLevel || parsed.thinkingLevel || parsed.reasoningEffort),
+      llmThinkingLevel: normalizeLlmThinkingLevel(parsed.llmThinkingLevel || parsed.thinkingLevel || parsed.reasoningEffort, "low"),
+      llmTimeoutMs: parsePositiveInteger(parsed.llmTimeoutMs || parsed.timeoutMs, null),
+      llmMaxRetries: parsePositiveInteger(parsed.llmMaxRetries || parsed.maxRetries, null),
+      llmMaxTokens: parsePositiveInteger(parsed.llmMaxTokens || parsed.maxTokens, null),
+      llmMaxCompletionTokens: parsePositiveInteger(parsed.llmMaxCompletionTokens || parsed.maxCompletionTokens, null),
+      llmImageLimit: parsePositiveInteger(parsed.llmImageLimit || parsed.imageLimit, null),
+      llmImageDetail: normalizeText(parsed.llmImageDetail || parsed.imageDetail),
+      temperature: parseConfigNumber(parsed.temperature, null),
+      topP: parseConfigNumber(parsed.topP || parsed.top_p, null),
       outputDir: resolveConfigPathValue(parsed.outputDir, configDir),
       humanRestEnabled: parseConfigBoolean(parsed.humanRestEnabled, false)
     },

package/src/cli.js

@@ -55,6 +55,10 @@ const externalMcpTargetsEnv = "BOSS_RECOMMEND_MCP_CONFIG_TARGETS";
 const externalSkillDirsEnv = "BOSS_RECOMMEND_EXTERNAL_SKILL_DIRS";
 const installConfigDefaults = Object.freeze({
   llmThinkingLevel: "low",
+  llmMaxTokens: 512,
+  llmMaxRetries: 3,
+  llmImageLimit: 8,
+  llmImageDetail: "low",
   humanRestEnabled: false
 });
 const bossChatRuntimeChildDirs = ["logs", "runs", "profiles", "reports", "artifacts", "state"];

package/src/core/screening/index.js

@@ -77,6 +77,31 @@ function applyChatCompletionThinking(payload, { baseUrl = "", model = "", thinki
   return payload;
 }
 
+function parsePositiveNumber(value, fallback = null) {
+  if (value === undefined || value === null || value === "") return fallback;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function parseFiniteNumber(value, fallback = null) {
+  if (value === undefined || value === null || value === "") return fallback;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function resolveLlmOutputTokenBudget(config = {}, thinkingLevel = "") {
+  const explicit = parsePositiveNumber(
+    config.llmMaxCompletionTokens
+    ?? config.maxCompletionTokens
+    ?? config.llmMaxTokens
+    ?? config.maxTokens,
+    null
+  );
+  if (explicit) return Math.max(1, Math.floor(explicit));
+  const normalizedThinking = normalizeLlmThinkingLevel(thinkingLevel || "low") || "low";
+  return normalizedThinking === "off" || normalizedThinking === "minimal" ? 64 : 512;
+}
+
 export function normalizeText(input) {
   return String(input || "").replace(/\s+/g, " ").trim();
 }
@@ -1436,20 +1461,31 @@ export async function callScreeningLlm({
     throw new Error("Candidate text and image evidence are empty");
   }
 
+  const thinkingLevel = config.llmThinkingLevel || config.thinkingLevel || config.reasoningEffort || "low";
+  const outputTokenBudget = resolveLlmOutputTokenBudget(config, thinkingLevel);
   const payload = {
     model,
-    temperature: 0.1,
-    max_tokens: Math.max(1, Number(config.maxTokens || config.llmMaxTokens) || 64),
+    temperature: parseFiniteNumber(config.temperature, 0.1),
+    max_tokens: outputTokenBudget,
     messages: buildScreeningLlmMessages({
       candidate,
       criteria,
       imageInputs
     })
   };
+  const topP = parseFiniteNumber(config.topP ?? config.top_p, null);
+  if (topP !== null) payload.top_p = topP;
+  const maxCompletionTokens = parsePositiveNumber(
+    config.llmMaxCompletionTokens ?? config.maxCompletionTokens,
+    null
+  );
+  if (maxCompletionTokens !== null) {
+    payload.max_completion_tokens = Math.max(1, Math.floor(maxCompletionTokens));
+  }
   applyChatCompletionThinking(payload, {
     baseUrl,
     model,
-    thinkingLevel: config.llmThinkingLevel || config.thinkingLevel || config.reasoningEffort || "low"
+    thinkingLevel
   });
 
   const maxRetries = normalizeLlmMaxRetries(config.llmMaxRetries ?? config.maxRetries);
@@ -1504,7 +1540,12 @@ export async function callScreeningLlm({
       ok: true,
       provider: {
         baseUrl: baseUrl.replace(/\/\/[^/]+/, "//[redacted-host]"),
-        model
+        model,
+        thinking_level: normalizeLlmThinkingLevel(thinkingLevel) || "low",
+        thinking: payload.thinking || null,
+        reasoning_effort: payload.reasoning_effort || null,
+        max_tokens: payload.max_tokens,
+        max_completion_tokens: payload.max_completion_tokens || null
       },
       passed,
       reason: "",

package/src/domains/chat/detail.js

@@ -39,13 +39,65 @@ import {
 import {
   assertChatShellNotResumeTopLevel,
   getChatTopLevelState,
+  isForbiddenChatResumeTopLevelUrl,
   makeForbiddenChatResumeNavigationError
 } from "./page-guard.js";
 
+export const CHAT_UNSAFE_ONLINE_RESUME_LINK_CODE = "CHAT_UNSAFE_ONLINE_RESUME_LINK";
+
 export function matchesChatProfileNetwork(url) {
   return CHAT_PROFILE_NETWORK_PATTERNS.some((pattern) => pattern.test(String(url || "")));
 }
 
+function looksLikeForbiddenChatResumePath(value = "") {
+  const normalized = String(value || "");
+  return isForbiddenChatResumeTopLevelUrl(normalized)
+    || /(?:^|["'\s=])(?:https?:\/\/[^"'\s>]*zhipin\.com)?\/web\/frame\/c-resume(?:[/?#"' >]|$)/i
+      .test(normalized);
+}
+
+function extractFirstHtmlAttribute(html = "", names = []) {
+  const source = String(html || "");
+  for (const name of names) {
+    const escaped = String(name).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`${escaped}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'>]+))`, "i");
+    const match = source.match(regex);
+    if (match) return match[1] ?? match[2] ?? match[3] ?? "";
+  }
+  return "";
+}
+
+export function isUnsafeChatOnlineResumeTarget(target = {}, buttonHTML = "") {
+  const attributes = target?.attributes || {};
+  const href = attributes.href
+    || attributes["data-href"]
+    || attributes["data-url"]
+    || attributes.url
+    || extractFirstHtmlAttribute(buttonHTML, ["href", "data-href", "data-url", "url"]);
+  return looksLikeForbiddenChatResumePath(href)
+    || looksLikeForbiddenChatResumePath(buttonHTML);
+}
+
+export function makeUnsafeChatOnlineResumeLinkError(target = {}, buttonHTML = "") {
+  const href = target?.attributes?.href
+    || target?.attributes?.["data-href"]
+    || target?.attributes?.["data-url"]
+    || extractFirstHtmlAttribute(buttonHTML, ["href", "data-href", "data-url", "url"])
+    || null;
+  const error = new Error("CHAT_UNSAFE_ONLINE_RESUME_LINK: refusing to click an online resume link that can navigate the chat tab to /web/frame/c-resume/");
+  error.code = CHAT_UNSAFE_ONLINE_RESUME_LINK_CODE;
+  error.href = href;
+  error.button_selector = target?.selector || null;
+  error.button_text = htmlToText(buttonHTML).slice(0, 120);
+  error.button_html_length = String(buttonHTML || "").length;
+  return error;
+}
+
+export function isUnsafeChatOnlineResumeLinkError(error) {
+  return error?.code === CHAT_UNSAFE_ONLINE_RESUME_LINK_CODE
+    || /CHAT_UNSAFE_ONLINE_RESUME_LINK/i.test(String(error?.message || error || ""));
+}
+
 export function createChatProfileNetworkRecorder(client) {
   const events = [];
   client.Network.responseReceived((event) => {
@@ -673,6 +725,22 @@ export async function openChatOnlineResume(client, {
       buttonHTML = await getOuterHTML(client, buttonState.target.node_id);
     } catch {}
 
+    if (isUnsafeChatOnlineResumeTarget(buttonState.target, buttonHTML)) {
+      const error = makeUnsafeChatOnlineResumeLinkError(buttonState.target, buttonHTML);
+      attempts.push({
+        attempt: index + 1,
+        ok: false,
+        error: error.code,
+        blocked_pre_click: true,
+        button_selector: buttonState.target.selector,
+        button_text: error.button_text,
+        button_href: error.href,
+        button_html_length: buttonHTML.length
+      });
+      error.attempts = attempts;
+      throw error;
+    }
+
     try {
       if (buttonState.target.center) {
         await clickPoint(client, buttonState.target.center.x, buttonState.target.center.y);

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

@@ -49,6 +49,7 @@ import {
   closeChatResumeModal,
   createChatProfileNetworkRecorder,
   extractChatProfileCandidate,
+  isUnsafeChatOnlineResumeLinkError,
   openChatOnlineResume,
   readChatConversationReadyState,
   requestChatResumeForPassedCandidate,
@@ -205,6 +206,8 @@ function createSkippedDetailResult(cardCandidate, reason, error = null) {
 
 const CHAT_FULL_CV_DOM_MIN_TEXT_LENGTH = 500;
 const CHAT_FULL_CV_DOM_MIN_SECTION_TEXT_LENGTH = 180;
+const CHAT_FULL_CV_NETWORK_MIN_TEXT_LENGTH = 650;
+const CHAT_FULL_CV_NETWORK_MIN_RICH_ITEM_COUNT = 3;
 const CHAT_FULL_CV_SECTION_PATTERNS = Object.freeze([
   /教育(?:经历|背景|经验)?/i,
   /工作(?:经历|经验)?/i,
@@ -250,17 +253,32 @@ function isFullCvNetworkProfile(profileResult = {}) {
   const sourceKeys = profileResult.profile?.source_keys || {};
   const textLength = networkProfileTextLength(profileResult);
   const sectionCount = resumeSectionMatchCount(profileResult.profile?.text || "");
+  const richItemCount = [
+    "education_count",
+    "work_count",
+    "project_count",
+    "expectation_count",
+    "certification_count"
+  ].reduce((sum, key) => sum + (Number(sourceKeys[key]) || 0), 0);
+  const hasResumeSections = sectionCount >= 3 || (sectionCount >= 2 && richItemCount >= 2);
+  const hasEnoughNetworkText = textLength >= CHAT_FULL_CV_NETWORK_MIN_TEXT_LENGTH;
 
-  if (sourceKeys.geek_detail_info || sourceKeys.geek_detail) return true;
+  if (sourceKeys.geek_detail_info || sourceKeys.geek_detail) {
+    return hasEnoughNetworkText && (
+      hasResumeSections
+      || richItemCount >= CHAT_FULL_CV_NETWORK_MIN_RICH_ITEM_COUNT
+    );
+  }
   if (sourceKeys.network_html_text) {
-    return textLength >= CHAT_FULL_CV_DOM_MIN_TEXT_LENGTH
-      || sectionCount >= 2;
+    return textLength >= CHAT_FULL_CV_NETWORK_MIN_TEXT_LENGTH
+      && sectionCount >= 2;
   }
   if (sourceKeys.chat_history_resume) {
     const educationCount = Number(sourceKeys.education_count) || 0;
     const workCount = Number(sourceKeys.work_count) || 0;
-    return (educationCount + workCount) > 0
-      && (textLength >= CHAT_FULL_CV_DOM_MIN_SECTION_TEXT_LENGTH || sectionCount >= 2);
+    return (educationCount + workCount) >= 2
+      && textLength >= CHAT_FULL_CV_NETWORK_MIN_TEXT_LENGTH
+      && sectionCount >= 2;
   }
   return false;
 }
@@ -826,28 +844,8 @@ export async function runChatWorkflow({
         }
 
         if (!detailResult) {
-          detailStep = "open_online_resume";
-          networkRecorder.clear();
-          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 measureTiming(timings, "network_cv_wait_ms", () => waitForCvNetworkEvents(
-                waitForChatProfileNetworkEvents,
-                networkRecorder,
-                {
-                  waitPlan,
-                  minCount: 1,
-                  requireLoaded: true,
-                  intervalMs: 200
-                }
-              ))
-            : null;
-          if (networkWait?.elapsed_ms != null) {
-            timings.network_cv_wait_ms = Math.round(Number(networkWait.elapsed_ms) || 0);
-          }
+          let networkWait = null;
           let contentWait = {
             ok: false,
             skipped: false,
@@ -855,39 +853,44 @@ export async function runChatWorkflow({
             elapsed_ms: 0,
             text_length: 0
           };
-          let resumeState = openedResume.resume_state;
+          let resumeState = null;
           let resumeHtml = null;
-          let resumeNetworkEvents = networkRecorder.events.slice();
+          let resumeNetworkEvents = [];
           let parsedNetworkProfileCount = 0;
 
           if (
             ["network", "cascade"].includes(normalizedDetailSource)
-            && networkWait?.count > 0
+            && selectionNetworkEvents.length > 0
           ) {
-            detailStep = "extract_network_profile";
+            detailStep = "extract_selection_network_profile";
             detailResult = await extractChatProfileCandidate(client, {
               cardCandidate,
               cardNodeId: effectiveCardNodeId,
-              resumeState,
-              resumeHtml,
-              networkEvents: selectedDetailNetworkEvents(
-                normalizedDetailSource,
-                selectionNetworkEvents,
-                resumeNetworkEvents
-              ),
+              resumeState: null,
+              resumeHtml: null,
+              networkEvents: selectionNetworkEvents,
               targetUrl,
               closeResume: false,
-              networkParseRetryMs: waitPlan.mode_before === "image" ? 500 : 2200,
-              networkParseIntervalMs: 250
+              networkParseRetryMs: waitPlan.mode_before === "image" ? 250 : 900,
+              networkParseIntervalMs: 150
             });
             addTiming(timings, "late_network_retry_ms", detailResult.network_parse_retry_elapsed_ms);
             parsedNetworkProfileCount = countParsedNetworkProfiles(detailResult);
-            const networkEvidence = summarizeChatFullCvEvidence({ detailResult, contentWait });
-            if (networkEvidence.network_full_cv_count > 0) {
+            const selectionNetworkEvidence = summarizeChatFullCvEvidence({ detailResult, contentWait });
+            if (selectionNetworkEvidence.network_full_cv_count > 0) {
+              networkWait = {
+                ok: true,
+                skipped: true,
+                reason: "selection_network_full_cv_before_online_resume_click",
+                elapsed_ms: detailResult.network_parse_retry_elapsed_ms,
+                count: selectionNetworkEvents.length,
+                total_event_count: selectionNetworkEvents.length,
+                wait_plan: waitPlan
+              };
               contentWait = {
                 ok: true,
                 skipped: true,
-                reason: "network_full_cv_parsed_before_dom_wait",
+                reason: "selection_network_full_cv_before_online_resume_click",
                 elapsed_ms: 0,
                 text_length: 0
               };
@@ -897,32 +900,94 @@ export async function runChatWorkflow({
           }
 
           if (!detailResult) {
-            detailStep = "wait_resume_content";
-            contentWait = await measureTiming(timings, "dom_fallback_ms", () => waitForChatResumeContent(client, {
-              timeoutMs: resumeDomTimeoutMs,
-              intervalMs: 300
+            detailStep = "open_online_resume";
+            networkRecorder.clear();
+            const openedResume = await measureTiming(timings, "detail_open_ms", () => openChatOnlineResume(client, {
+              timeoutMs: readyTimeoutMs
             }));
-            resumeState = contentWait.resume_state || openedResume.resume_state;
-            resumeHtml = contentWait.resume_html || null;
+            resumeState = openedResume.resume_state;
+            detailStep = "wait_network";
+            networkWait = ["network", "cascade"].includes(normalizedDetailSource)
+              ? await measureTiming(timings, "network_cv_wait_ms", () => waitForCvNetworkEvents(
+                  waitForChatProfileNetworkEvents,
+                  networkRecorder,
+                  {
+                    waitPlan,
+                    minCount: 1,
+                    requireLoaded: true,
+                    intervalMs: 200
+                  }
+                ))
+              : null;
+            if (networkWait?.elapsed_ms != null) {
+              timings.network_cv_wait_ms = Math.round(Number(networkWait.elapsed_ms) || 0);
+            }
             resumeNetworkEvents = networkRecorder.events.slice();
-            detailStep = "extract_resume_content";
-            detailResult = await extractChatProfileCandidate(client, {
-              cardCandidate,
-              cardNodeId: effectiveCardNodeId,
-              resumeState,
-              resumeHtml,
-              networkEvents: selectedDetailNetworkEvents(
-                normalizedDetailSource,
-                selectionNetworkEvents,
-                resumeNetworkEvents
-              ),
-              targetUrl,
-              closeResume: false,
-              networkParseRetryMs: waitPlan.mode_before === "image" ? 500 : 2200,
-              networkParseIntervalMs: 250
-            });
-            addTiming(timings, "late_network_retry_ms", detailResult.network_parse_retry_elapsed_ms);
-            parsedNetworkProfileCount = countParsedNetworkProfiles(detailResult);
+
+            if (
+              ["network", "cascade"].includes(normalizedDetailSource)
+              && networkWait?.count > 0
+            ) {
+              detailStep = "extract_network_profile";
+              detailResult = await extractChatProfileCandidate(client, {
+                cardCandidate,
+                cardNodeId: effectiveCardNodeId,
+                resumeState,
+                resumeHtml,
+                networkEvents: selectedDetailNetworkEvents(
+                  normalizedDetailSource,
+                  selectionNetworkEvents,
+                  resumeNetworkEvents
+                ),
+                targetUrl,
+                closeResume: false,
+                networkParseRetryMs: waitPlan.mode_before === "image" ? 500 : 2200,
+                networkParseIntervalMs: 250
+              });
+              addTiming(timings, "late_network_retry_ms", detailResult.network_parse_retry_elapsed_ms);
+              parsedNetworkProfileCount = countParsedNetworkProfiles(detailResult);
+              const networkEvidence = summarizeChatFullCvEvidence({ detailResult, contentWait });
+              if (networkEvidence.network_full_cv_count > 0) {
+                contentWait = {
+                  ok: true,
+                  skipped: true,
+                  reason: "network_full_cv_parsed_before_dom_wait",
+                  elapsed_ms: 0,
+                  text_length: 0
+                };
+              } else {
+                detailResult = null;
+              }
+            }
+
+            if (!detailResult) {
+              detailStep = "wait_resume_content";
+              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();
+              detailStep = "extract_resume_content";
+              detailResult = await extractChatProfileCandidate(client, {
+                cardCandidate,
+                cardNodeId: effectiveCardNodeId,
+                resumeState,
+                resumeHtml,
+                networkEvents: selectedDetailNetworkEvents(
+                  normalizedDetailSource,
+                  selectionNetworkEvents,
+                  resumeNetworkEvents
+                ),
+                targetUrl,
+                closeResume: false,
+                networkParseRetryMs: waitPlan.mode_before === "image" ? 500 : 2200,
+                networkParseIntervalMs: 250
+              });
+              addTiming(timings, "late_network_retry_ms", detailResult.network_parse_retry_elapsed_ms);
+              parsedNetworkProfileCount = countParsedNetworkProfiles(detailResult);
+            }
           }
 
           let source = normalizedDetailSource === "dom" ? "dom" : "network";
@@ -1113,6 +1178,13 @@ export async function runChatWorkflow({
           const recovery = await recoverAndReapplyChatContext(detailUnavailableReason, error);
           detailResult = createSkippedDetailResult(cardCandidate, detailUnavailableReason, error);
           detailResult.cv_acquisition.recovery = recovery;
+        } else if (isUnsafeChatOnlineResumeLinkError(error)) {
+          detailUnavailableReason = "unsafe_online_resume_navigation_link";
+          detailResult = createSkippedDetailResult(cardCandidate, detailUnavailableReason, error);
+          detailResult.cv_acquisition.blocked_pre_click = true;
+          detailResult.cv_acquisition.button_href = error.href || null;
+          detailResult.cv_acquisition.button_selector = error.button_selector || null;
+          detailResult.cv_acquisition.attempts = error.attempts || null;
         } else {
           if (!isRecoverableCdpNodeError(error)) throw error;
           detailUnavailableReason = `recoverable_cdp_node_stale:${detailStep}`;