@reconcrap/boss-recommend-mcp 1.2.10 → 1.3.0

package/src/test-index-async.js

@@ -21,6 +21,17 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function createFollowUpChat(overrides = {}) {
+  return {
+    chat: {
+      criteria: "有 AI Agent 经验",
+      start_from: "unread",
+      target_count: 3,
+      ...overrides
+    }
+  };
+}
+
 function makeToolCall(id, name, args = {}) {
   return {
     jsonrpc: "2.0",
@@ -57,14 +68,25 @@ async function waitForRunState(runId, acceptedStates, timeoutMs = 6000) {
   throw new Error(`Timed out waiting run state (${Array.from(accepted).join(", ")}) for run_id=${runId}`);
 }
 
-async function startAcceptedRun(instruction, idSeed = 1) {
+async function waitForRunSnapshot(runId, predicate, timeoutMs = 6000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const payload = await callTool(TOOL_GET_RUN, { run_id: runId }, 1002);
+    if (predicate(payload?.run)) return payload.run;
+    await sleep(80);
+  }
+  throw new Error(`Timed out waiting run snapshot for run_id=${runId}`);
+}
+
+async function startAcceptedRun(instruction, idSeed = 1, extraArgs = {}) {
   const payload = await callTool(TOOL_START_RUN, {
     instruction,
     confirmation: {
       job_confirmed: true,
       job_value: "mock job",
       final_confirmed: true
-    }
+    },
+    ...extraArgs
   }, idSeed);
   assert.equal(payload.status, "ACCEPTED");
   assert.equal(typeof payload.run_id, "string");
@@ -73,6 +95,7 @@ async function startAcceptedRun(instruction, idSeed = 1) {
 
 function setupPipelineMock() {
   const checkpointStore = new Map();
+  const chatStateStore = new Map();
   setRunPipelineImplForTests(async (input, _deps, runtime) => {
     if (input.confirmation?.job_confirmed !== true) {
       return {
@@ -128,15 +151,172 @@ function setupPipelineMock() {
     }
 
     checkpointStore.delete(checkpointPath);
-    return {
+    const recommendResult = {
       status: "COMPLETED",
+      search_params: {
+        school_tag: ["985"]
+      },
+      screen_params: {
+        criteria: "mock criteria",
+        target_count: 12,
+        post_action: "favorite",
+        max_greet_count: null
+      },
       result: {
         processed_count: total,
         passed_count: Math.floor(total / 3),
         skipped_count: total - Math.floor(total / 3),
         greet_count: 0,
         output_csv: outputCsv,
-        completion_reason: "screen_completed"
+        completion_reason: "screen_completed",
+        selected_job: {
+          title: "mock job"
+        }
+      }
+    };
+
+    if (!input.followUp?.chat) {
+      return recommendResult;
+    }
+
+    runtime?.onStage?.({ stage: "chat_followup", message: "chat follow-up running" });
+    const chatCheckpointKey = `${checkpointPath}:chat`;
+    let chatState = "running";
+    if (input.resume?.resume === true && input.resume?.follow_up_phase === "chat_followup") {
+      const storedState = String(chatStateStore.get(chatCheckpointKey) || "running").trim().toLowerCase();
+      chatState = storedState === "paused" ? "running" : storedState;
+    }
+
+    runtime?.onFollowUp?.({
+      stage: "chat_followup",
+      last_message: "chat follow-up running",
+      recommend_payload: recommendResult,
+      recommend_result: recommendResult.result,
+      follow_up: {
+        chat: {
+          run_id: "mock-chat-run",
+          state: chatState,
+          input: {
+            ...input.followUp.chat
+          },
+          progress: {
+            inspected: 1,
+            passed: 0,
+            requested: 0,
+            skipped: 1,
+            errors: 0
+          }
+        }
+      }
+    });
+
+    for (let chatTick = 0; chatTick < 20; chatTick += 1) {
+      await sleep(25);
+      if (runtime?.isCancelRequested?.() === true) {
+        chatStateStore.set(chatCheckpointKey, "canceled");
+        runtime?.onFollowUp?.({
+          stage: "chat_followup",
+          last_message: "chat follow-up canceled",
+          recommend_payload: recommendResult,
+          recommend_result: recommendResult.result,
+          follow_up: {
+            chat: {
+              run_id: "mock-chat-run",
+              state: "canceled",
+              input: {
+                ...input.followUp.chat
+              }
+            }
+          }
+        });
+        return {
+          ...recommendResult,
+          status: "PAUSED",
+          partial_result: recommendResult.result,
+          follow_up: {
+            chat: {
+              run_id: "mock-chat-run",
+              state: "canceled",
+              input: {
+                ...input.followUp.chat
+              }
+            }
+          }
+        };
+      }
+      if (runtime?.isPauseRequested?.() === true) {
+        chatStateStore.set(chatCheckpointKey, "paused");
+        runtime?.onFollowUp?.({
+          stage: "chat_followup",
+          last_message: "chat follow-up paused",
+          recommend_payload: recommendResult,
+          recommend_result: recommendResult.result,
+          follow_up: {
+            chat: {
+              run_id: "mock-chat-run",
+              state: "paused",
+              input: {
+                ...input.followUp.chat
+              }
+            }
+          }
+        });
+        return {
+          ...recommendResult,
+          status: "PAUSED",
+          partial_result: recommendResult.result,
+          follow_up: {
+            chat: {
+              run_id: "mock-chat-run",
+              state: "paused",
+              input: {
+                ...input.followUp.chat
+              }
+            }
+          }
+        };
+      }
+    }
+
+    chatStateStore.delete(chatCheckpointKey);
+    runtime?.onFollowUp?.({
+      stage: "chat_followup",
+      last_message: "chat follow-up completed",
+      recommend_payload: recommendResult,
+      recommend_result: recommendResult.result,
+      follow_up: {
+        chat: {
+          run_id: "mock-chat-run",
+          state: "completed",
+          input: {
+            ...input.followUp.chat
+          },
+          progress: {
+            inspected: 3,
+            passed: 1,
+            requested: 1,
+            skipped: 2,
+            errors: 0
+          },
+          result: {
+            requested_count: 1
+          }
+        }
+      }
+    });
+    return {
+      ...recommendResult,
+      follow_up: {
+        chat: {
+          run_id: "mock-chat-run",
+          state: "completed",
+          input: {
+            ...input.followUp.chat
+          },
+          result: {
+            requested_count: 1
+          }
+        }
       }
     };
   });
@@ -236,6 +416,58 @@ async function testCancelRunningRunKeepsCsv() {
   assert.equal(Boolean(canceledRun.resume?.output_csv), true);
 }
 
+async function testPauseAndResumeDuringChatFollowUp() {
+  const runId = await startAcceptedRun("run with follow-up chat pause resume", 51, {
+    follow_up: createFollowUpChat()
+  });
+  const runningChatRun = await waitForRunSnapshot(
+    runId,
+    (run) => run?.stage === "chat_followup" && run?.state === "running" && run?.result?.follow_up?.chat?.state === "running"
+  );
+  assert.equal(runningChatRun.result?.result?.processed_count, 12);
+  assert.equal(runningChatRun.result?.follow_up?.chat?.run_id, "mock-chat-run");
+
+  const pausePayload = await callTool(TOOL_PAUSE_RUN, { run_id: runId }, 52);
+  assert.equal(pausePayload.status, "PAUSE_REQUESTED");
+
+  const pausedRun = await waitForRunSnapshot(
+    runId,
+    (run) => run?.state === "paused" && run?.stage === "chat_followup"
+  );
+  assert.equal(pausedRun.result?.follow_up?.chat?.state, "paused");
+  assert.equal(pausedRun.result?.result?.processed_count, 12);
+
+  const resumePayload = await callTool(TOOL_RESUME_RUN, { run_id: runId }, 53);
+  assert.equal(resumePayload.status, "RESUME_REQUESTED");
+
+  const completedRun = await waitForRunSnapshot(
+    runId,
+    (run) => run?.state === "completed" && run?.result?.follow_up?.chat?.state === "completed"
+  );
+  assert.equal(completedRun.result?.follow_up?.chat?.result?.requested_count, 1);
+  assert.equal(completedRun.result?.result?.processed_count, 12);
+}
+
+async function testCancelDuringChatFollowUp() {
+  const runId = await startAcceptedRun("run with follow-up chat cancel", 61, {
+    follow_up: createFollowUpChat()
+  });
+  await waitForRunSnapshot(
+    runId,
+    (run) => run?.stage === "chat_followup" && run?.state === "running" && run?.result?.follow_up?.chat?.state === "running"
+  );
+
+  const cancelPayload = await callTool(TOOL_CANCEL_RUN, { run_id: runId }, 62);
+  assert.equal(cancelPayload.status, "CANCEL_REQUESTED");
+
+  const canceledRun = await waitForRunSnapshot(
+    runId,
+    (run) => run?.state === "canceled" && run?.stage === "chat_followup"
+  );
+  assert.equal(canceledRun.result?.follow_up?.chat?.state, "canceled");
+  assert.equal(canceledRun.result?.result?.processed_count, 12);
+}
+
 async function main() {
   const previousHome = process.env.BOSS_RECOMMEND_HOME;
   const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-index-async-"));
@@ -248,6 +480,8 @@ async function main() {
     await testResumeAfterProcessRestartSimulation();
     await testCancelPausedRun();
     await testCancelRunningRunKeepsCsv();
+    await testPauseAndResumeDuringChatFollowUp();
+    await testCancelDuringChatFollowUp();
     console.log("index async tests passed");
   } finally {
     setRunPipelineImplForTests(null);