@reconcrap/boss-recommend-mcp 1.3.31 → 1.3.32

package/package.json

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

package/src/test-boss-chat.js

@@ -18,7 +18,7 @@ import { __testables as indexTestables } from "./index.js";
 import { BossChatApp } from "../vendor/boss-chat-cli/src/app.js";
 import { __testables as vendorCliTestables } from "../vendor/boss-chat-cli/src/cli.js";
 import { BossChatPage } from "../vendor/boss-chat-cli/src/browser/chat-page.js";
-import { LlmClient, parseLlmJson } from "../vendor/boss-chat-cli/src/services/llm.js";
+import { LlmClient, parseLlmJson, __testables as llmTestables } from "../vendor/boss-chat-cli/src/services/llm.js";
 import { ReportStore } from "../vendor/boss-chat-cli/src/services/report-store.js";
 import {
   NETWORK_RESUME_IMAGE_MODE_GRACE_MS,
@@ -36,6 +36,7 @@ const TOOL_BOSS_CHAT_GET_RUN = "get_boss_chat_run";
 const TOOL_BOSS_CHAT_PAUSE_RUN = "pause_boss_chat_run";
 const TOOL_BOSS_CHAT_RESUME_RUN = "resume_boss_chat_run";
 const TOOL_BOSS_CHAT_CANCEL_RUN = "cancel_boss_chat_run";
+const { extractCompletionReasoningText, extractResponsesReasoningText } = llmTestables;
 
 function makeToolCall(id, name, args = {}) {
   return {
@@ -949,6 +950,50 @@ function testBossChatLlmParserShouldAcceptDecisionField() {
   assert.equal(parsed.passed, false);
 }
 
+function testBossChatLlmParserShouldPreserveReasoningFields() {
+  const parsed = parseLlmJson(
+    JSON.stringify({
+      passed: true,
+      reason: "候选人具备 2 段 AI Agent 项目经验",
+      summary: "符合筛选要求",
+      evidence: ["AI Agent", "MCP"],
+    }),
+    {
+      reasoningText: "先检查项目经历，再核对技能栈，结论为通过。",
+    },
+  );
+  assert.equal(parsed.passed, true);
+  assert.equal(parsed.reason, "候选人具备 2 段 AI Agent 项目经验");
+  assert.equal(parsed.summary, "符合筛选要求");
+  assert.equal(parsed.cot, "先检查项目经历，再核对技能栈，结论为通过。");
+  assert.deepEqual(parsed.evidence, ["AI Agent", "MCP"]);
+  assert.equal(parsed.rawReasoningText, "先检查项目经历，再核对技能栈，结论为通过。");
+}
+
+function testBossChatLlmExtractorsShouldReadProviderReasoningFields() {
+  const completionReasoning = extractCompletionReasoningText({
+    choices: [
+      {
+        message: {
+          content: [{ type: "text", text: "{\"passed\":true}" }],
+          reasoning_content: [{ text: "先核对教育背景，再核对项目经历。" }],
+        },
+      },
+    ],
+  });
+  assert.equal(completionReasoning.includes("教育背景"), true);
+
+  const responsesReasoning = extractResponsesReasoningText({
+    output: [
+      {
+        type: "reasoning",
+        summary: [{ text: "根据项目经历与技能关键词判断为通过。" }],
+      },
+    ],
+  });
+  assert.equal(responsesReasoning.includes("技能关键词"), true);
+}
+
 async function testBossChatLlmTextChunkFallbackShouldWork() {
   const originalChunkSize = process.env.BOSS_CHAT_TEXT_CHUNK_SIZE_CHARS;
   const originalChunkOverlap = process.env.BOSS_CHAT_TEXT_CHUNK_OVERLAP_CHARS;
@@ -2133,6 +2178,11 @@ async function testBossChatAppShouldPersistEvidenceArtifacts() {
       return {
         passed: false,
         rawOutputText: '{"passed":false}',
+        rawReasoningText: "先看项目经验，再看技能，结论不通过。",
+        cot: "先看项目经验，再看技能，结论不通过。",
+        reason: "项目经验与岗位要求不符",
+        summary: "不符合要求",
+        evidence: ["Python"],
         evaluationMode: "image-multi-chunk",
         imageCount: 3,
         chunkIndex: 1,
@@ -2197,9 +2247,14 @@ async function testBossChatAppShouldPersistEvidenceArtifacts() {
 
   assert.equal(result.passed, false);
   assert.equal(result.artifacts.finalPassed, false);
-  assert.equal(result.reason, "LLM判定不通过");
+  assert.equal(result.reason, "项目经验与岗位要求不符");
   assert.equal(result.artifacts.evaluationMode, "image-multi-chunk");
   assert.equal(result.artifacts.evaluationImageCount, 3);
+  assert.equal(result.artifacts.llmReason, "项目经验与岗位要求不符");
+  assert.equal(result.artifacts.llmSummary, "不符合要求");
+  assert.equal(result.artifacts.llmCot, "先看项目经验，再看技能，结论不通过。");
+  assert.deepEqual(result.artifacts.llmEvidence, ["Python"]);
+  assert.equal(result.artifacts.llmRawReasoning, "先看项目经验，再看技能，结论不通过。");
   assert.equal(result.artifacts.llmRawOutput, '{"passed":false}');
   assert.equal(Array.isArray(result.artifacts.modelImagePaths), true);
   assert.equal(result.artifacts.modelImagePaths.length, 3);
@@ -2241,6 +2296,10 @@ async function testBossChatReportStoreShouldWriteReadableMarkdownAndCsv() {
           textModelMs: 18234,
           initialNetworkWaitMs: 4200,
           evaluationMode: "text",
+          llmSummary: "教育与项目经历匹配",
+          llmCot: "先看教育背景，再看项目经历，结论通过。",
+          llmEvidence: ["AI Agent", "MCP"],
+          llmRawReasoning: "先看教育背景，再看项目经历，结论通过。",
           llmRawOutput: '{"passed":true}',
         },
       },
@@ -2260,6 +2319,10 @@ async function testBossChatReportStoreShouldWriteReadableMarkdownAndCsv() {
           lateNetworkRetryMs: 3000,
           evaluationMode: "image-multi-chunk",
           evaluationImageCount: 3,
+          llmSummary: "项目经历不足",
+          llmCot: "先看项目经历，再看实习时长，结论不通过。",
+          llmEvidence: ["数据分析"],
+          llmRawReasoning: "先看项目经历，再看实习时长，结论不通过。",
           llmRawOutput: '{"passed":false}',
         },
       },
@@ -2297,8 +2360,13 @@ async function testBossChatReportStoreShouldWriteReadableMarkdownAndCsv() {
   assert.match(csvContent, /resume_acquisition_mode/);
   assert.match(csvContent, /initial_network_wait_ms/);
   assert.match(csvContent, /late_network_retry_ms/);
+  assert.match(csvContent, /llm_summary/);
+  assert.match(csvContent, /llm_cot/);
+  assert.match(csvContent, /llm_raw_reasoning/);
+  assert.match(csvContent, /llm_raw_output/);
   assert.match(csvContent, /候选人B/);
   assert.match(csvContent, /image-multi-chunk/);
+  assert.match(csvContent, /先看项目经历，再看实习时长/);
 }
 
 async function main() {
@@ -2316,6 +2384,8 @@ async function main() {
   testBossChatLlmParserShouldAcceptMinimalDecisionJson();
   testBossChatLlmParserShouldAcceptPlainPassFailText();
   testBossChatLlmParserShouldAcceptDecisionField();
+  testBossChatLlmParserShouldPreserveReasoningFields();
+  testBossChatLlmExtractorsShouldReadProviderReasoningFields();
   await testBossChatLlmTextChunkFallbackShouldWork();
   await testBossChatLlmShouldApplyThinkingDefaultsAndOverrides();
   await testBossChatLlmShouldSendAllImageChunksInSingleRequest();

package/vendor/boss-chat-cli/src/app.js

@@ -18,6 +18,18 @@ function normalizeText(value) {
   return String(value || '').replace(/\s+/g, ' ').trim();
 }
 
+function toStringArray(value, maxItems = 8) {
+  if (!Array.isArray(value)) return [];
+  const normalized = [];
+  for (const item of value) {
+    const text = normalizeText(item);
+    if (!text) continue;
+    normalized.push(text);
+    if (normalized.length >= maxItems) break;
+  }
+  return normalized;
+}
+
 function shouldContinue(summary, targetCount) {
   if (!targetCount || !Number.isFinite(targetCount) || targetCount <= 0) {
     return true;
@@ -1064,7 +1076,9 @@ export class BossChatApp {
       const evaluation = acquisition.evaluation;
       const capture = acquisition.capture;
       modalOpened = Boolean(acquisition.modalOpened);
-      const finalReason = evaluation.passed ? 'LLM判定通过' : 'LLM判定不通过';
+      const finalReason =
+        normalizeText(evaluation.reason || evaluation.summary || evaluation.cot) ||
+        (evaluation.passed ? 'LLM判定通过' : 'LLM判定不通过');
       this.logger.log(
         `LLM评估完成：passed=${evaluation.passed} | source=${acquisition.acquisitionMode} | reason=${acquisition.acquisitionReason || 'n/a'} | mode=${evaluation.evaluationMode || 'unknown'} | imageCount=${Number(evaluation.imageCount || baseResult.artifacts.modelImagePaths?.length || 0)} | result=${normalizeText(evaluation.rawOutputText || '') || 'n/a'}`,
       );
@@ -1085,6 +1099,11 @@ export class BossChatApp {
       baseResult.artifacts.evaluationChunkTotal = Number.isFinite(Number(evaluation.chunkTotal))
         ? Number(evaluation.chunkTotal)
         : null;
+      baseResult.artifacts.llmReason = normalizeText(evaluation.reason || '');
+      baseResult.artifacts.llmSummary = normalizeText(evaluation.summary || '');
+      baseResult.artifacts.llmCot = normalizeText(evaluation.cot || '');
+      baseResult.artifacts.llmEvidence = toStringArray(evaluation.evidence);
+      baseResult.artifacts.llmRawReasoning = String(evaluation.rawReasoningText || '');
       baseResult.artifacts.llmRawOutput = String(evaluation.rawOutputText || '');
       baseResult.artifacts.resumeAcquisitionMode = String(acquisition.acquisitionMode || '');
       baseResult.artifacts.resumeAcquisitionReason = String(acquisition.acquisitionReason || '');

package/vendor/boss-chat-cli/src/services/llm.js

@@ -43,6 +43,22 @@ function getCompletionContent(data) {
   return '';
 }
 
+function flattenChatMessageContent(content) {
+  if (Array.isArray(content)) {
+    return content
+      .map((item) => {
+        if (typeof item === 'string') return item;
+        if (item && typeof item === 'object') {
+          return item.text || item.content || item.reasoning_content || '';
+        }
+        return '';
+      })
+      .filter(Boolean)
+      .join('\n');
+  }
+  return String(content || '');
+}
+
 function getResponsesContent(data) {
   if (typeof data?.output_text === 'string' && data.output_text.trim()) {
     return data.output_text;
@@ -163,6 +179,100 @@ function toStringArray(value, maxItems = 8) {
   return normalized;
 }
 
+function collectNestedText(value, out = [], depth = 0) {
+  if (depth > 6 || value === null || value === undefined) return out;
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    const normalized = normalizeText(String(value));
+    if (normalized) out.push(normalized);
+    return out;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectNestedText(item, out, depth + 1);
+    }
+    return out;
+  }
+  if (typeof value === 'object') {
+    const priorityKeys = ['text', 'reasoning_content', 'summary_text', 'summary', 'content', 'cot', 'reason'];
+    const seen = new Set();
+    for (const key of priorityKeys) {
+      if (Object.prototype.hasOwnProperty.call(value, key)) {
+        seen.add(key);
+        collectNestedText(value[key], out, depth + 1);
+      }
+    }
+    for (const [key, nested] of Object.entries(value)) {
+      if (seen.has(key)) continue;
+      collectNestedText(nested, out, depth + 1);
+    }
+  }
+  return out;
+}
+
+function dedupeTextFragments(fragments = []) {
+  const deduped = [];
+  const seen = new Set();
+  for (const item of fragments) {
+    const normalized = normalizeText(item);
+    if (!normalized) continue;
+    if (seen.has(normalized)) continue;
+    seen.add(normalized);
+    deduped.push(normalized);
+  }
+  return deduped;
+}
+
+function joinTextFragments(fragments = []) {
+  return dedupeTextFragments(fragments).join('\n');
+}
+
+function extractCompletionReasoningText(data) {
+  const choice = data?.choices?.[0] || {};
+  const fragments = [];
+  const content = choice?.message?.content;
+  if (Array.isArray(content)) {
+    for (const part of content) {
+      const partType = normalizeText(part?.type || '').toLowerCase();
+      if (partType.includes('reason') || partType.includes('summary')) {
+        collectNestedText(part, fragments);
+      }
+    }
+  }
+  const candidates = [
+    choice?.message?.reasoning_content,
+    choice?.message?.reasoning,
+    choice?.reasoning_content,
+    choice?.reasoning,
+  ];
+  for (const candidate of candidates) {
+    collectNestedText(candidate, fragments);
+  }
+  return joinTextFragments(fragments);
+}
+
+function extractResponsesReasoningText(data) {
+  const fragments = [];
+  collectNestedText(data?.reasoning, fragments);
+  collectNestedText(data?.reasoning_content, fragments);
+
+  const output = Array.isArray(data?.output) ? data.output : [];
+  for (const item of output) {
+    const itemType = normalizeText(item?.type || '').toLowerCase();
+    if (itemType.includes('reason') || itemType.includes('summary')) {
+      collectNestedText(item, fragments);
+    }
+    const content = Array.isArray(item?.content) ? item.content : [];
+    for (const chunk of content) {
+      const chunkType = normalizeText(chunk?.type || '').toLowerCase();
+      if (chunkType.includes('reason') || chunkType.includes('summary')) {
+        collectNestedText(chunk, fragments);
+      }
+    }
+  }
+
+  return joinTextFragments(fragments);
+}
+
 function extractEvidenceTokens(text, maxItems = MAX_EVIDENCE_TOKENS) {
   const normalized = normalizeText(text);
   if (!normalized) return [];
@@ -341,6 +451,14 @@ function buildTextPrompt({ screeningCriteria, candidate, resumeText, chunkIndex
   ].join('\n');
 }
 
+function pickFirstText(...values) {
+  for (const value of values) {
+    const normalized = normalizeText(value);
+    if (normalized) return normalized;
+  }
+  return '';
+}
+
 export function parseLlmJson(content, options = {}) {
   const text = String(content || '').trim();
   if (!text) {
@@ -355,6 +473,11 @@ export function parseLlmJson(content, options = {}) {
     return {
       passed: true,
       rawOutputText: text,
+      rawReasoningText: normalizeText(options.reasoningText || ''),
+      cot: normalizeText(options.reasoningText || ''),
+      reason: '',
+      summary: '',
+      evidence: [],
       chunkIndex,
       chunkTotal,
     };
@@ -364,6 +487,11 @@ export function parseLlmJson(content, options = {}) {
     return {
       passed: false,
       rawOutputText: text,
+      rawReasoningText: normalizeText(options.reasoningText || ''),
+      cot: normalizeText(options.reasoningText || ''),
+      reason: '',
+      summary: '',
+      evidence: [],
       chunkIndex,
       chunkTotal,
     };
@@ -391,9 +519,26 @@ export function parseLlmJson(content, options = {}) {
     throw new Error('LLM response missing boolean "passed"');
   }
 
+  const parsedReason = pickFirstText(parsed?.reason, parsed?.summary, parsed?.summary_text);
+  const parsedSummary = pickFirstText(parsed?.summary, parsed?.summary_text, parsed?.reason);
+  const parsedCot = pickFirstText(
+    options.reasoningText,
+    parsed?.cot,
+    parsed?.reasoning_content,
+    parsed?.reasoning,
+    parsedReason,
+    parsedSummary,
+  );
+  const parsedEvidence = toStringArray(parsed?.evidence);
+
   return {
     passed: parsedPassed,
     rawOutputText: text,
+    rawReasoningText: normalizeText(options.reasoningText || ''),
+    cot: parsedCot,
+    reason: parsedReason || parsedCot,
+    summary: parsedSummary || parsedReason || parsedCot,
+    evidence: parsedEvidence,
     chunkIndex,
     chunkTotal,
   };
@@ -525,6 +670,7 @@ export class LlmClient {
     }
 
     const outputContent = getResponsesContent(data);
+    const reasoningText = extractResponsesReasoningText(data);
     if (!outputContent) {
       const incompleteReason = String(data?.incomplete_details?.reason || '').trim();
       const outputTypes = Array.isArray(data?.output)
@@ -547,6 +693,7 @@ export class LlmClient {
     try {
       return parseLlmJson(outputContent, {
         evidenceCorpus,
+        reasoningText,
         chunkIndex,
         chunkTotal,
       });
@@ -610,6 +757,7 @@ export class LlmClient {
     }
 
     const outputContent = getCompletionContent(data);
+    const reasoningText = extractCompletionReasoningText(data);
     if (!String(outputContent || '').trim()) {
       const emptyError = new Error('Completions API empty textual content');
       emptyError.code = 'COMPLETIONS_EMPTY_CONTENT';
@@ -619,6 +767,7 @@ export class LlmClient {
     try {
       return parseLlmJson(outputContent, {
         evidenceCorpus,
+        reasoningText,
         chunkIndex,
         chunkTotal,
       });
@@ -759,6 +908,11 @@ export class LlmClient {
       rawOutputText:
         chunkResults.map((item) => normalizeText(item?.rawOutputText)).find(Boolean) ||
         `{"passed":false,"mode":"text-chunk-fallback","chunks":${chunks.length}}`,
+      rawReasoningText: chunkResults.map((item) => normalizeText(item?.rawReasoningText)).find(Boolean) || '',
+      cot: chunkResults.map((item) => normalizeText(item?.cot)).find(Boolean) || '',
+      reason: chunkResults.map((item) => normalizeText(item?.reason)).find(Boolean) || '',
+      summary: chunkResults.map((item) => normalizeText(item?.summary)).find(Boolean) || '',
+      evidence: [],
       chunkIndex: null,
       chunkTotal: chunks.length,
       evaluationMode: 'text',
@@ -791,6 +945,10 @@ export class LlmClient {
 }
 
 export const __testables = {
+  flattenChatMessageContent,
+  collectNestedText,
+  extractCompletionReasoningText,
+  extractResponsesReasoningText,
   extractEvidenceTokens,
   matchEvidenceAgainstResume,
   splitTextByChunks,

package/vendor/boss-chat-cli/src/services/report-store.js

@@ -31,7 +31,12 @@ const CSV_HEADER = [
   'text_model_ms',
   'timing_summary',
   'reason',
+  'llm_summary',
+  'llm_cot',
+  'llm_evidence',
+  'llm_raw_reasoning',
   'error_message',
+  'llm_raw_output',
   'llm_raw_output_preview',
 ];
 
@@ -100,6 +105,24 @@ function getTimingValue(result, key) {
   return normalizeMs(getArtifacts(result)[key]);
 }
 
+function getLlmSummary(result) {
+  return normalizeText(getArtifacts(result).llmSummary);
+}
+
+function getLlmCot(result) {
+  return normalizeText(getArtifacts(result).llmCot);
+}
+
+function getLlmEvidence(result) {
+  const evidence = getArtifacts(result).llmEvidence;
+  if (!Array.isArray(evidence)) return '';
+  return evidence.map((item) => normalizeText(item)).filter(Boolean).join(' | ');
+}
+
+function getLlmRawReasoning(result) {
+  return normalizeText(getArtifacts(result).llmRawReasoning);
+}
+
 function formatTimingSummary(result) {
   const parts = [];
   for (const [key, label] of TIMING_BUCKETS) {
@@ -113,10 +136,16 @@ function formatTimingSummary(result) {
 function formatResultNotes(result) {
   const parts = [];
   const reason = previewText(result?.reason, 120);
+  const summary = previewText(getLlmSummary(result), 120);
+  const cot = previewText(getLlmCot(result), 180);
   const errorMessage = previewText(result?.error, 120);
+  const llmRawReasoning = previewText(getLlmRawReasoning(result), 180);
   const llmRawOutput = previewText(getArtifacts(result).llmRawOutput, 180);
   if (reason) parts.push(`原因: ${reason}`);
+  if (summary) parts.push(`摘要: ${summary}`);
+  if (cot) parts.push(`CoT: ${cot}`);
   if (errorMessage) parts.push(`错误: ${errorMessage}`);
+  if (llmRawReasoning) parts.push(`Reasoning: ${llmRawReasoning}`);
   if (llmRawOutput) parts.push(`LLM: ${llmRawOutput}`);
   return parts.length > 0 ? parts.join(' | ') : '-';
 }
@@ -243,7 +272,12 @@ function buildCsvSummary(summary) {
       csvEscape(getTimingValue(result, 'textModelMs') ?? ''),
       csvEscape(formatTimingSummary(result)),
       csvEscape(result?.reason || ''),
+      csvEscape(getLlmSummary(result)),
+      csvEscape(getLlmCot(result)),
+      csvEscape(getLlmEvidence(result)),
+      csvEscape(getLlmRawReasoning(result)),
       csvEscape(result?.error || ''),
+      csvEscape(artifacts.llmRawOutput || ''),
       csvEscape(previewText(artifacts.llmRawOutput, 500)),
     ].join(','));
   });