@reconcrap/boss-recommend-mcp 1.3.15 → 1.3.17

package/vendor/boss-recommend-screen-cli/scripts/capture-full-resume-canvas.cjs

@@ -23,6 +23,8 @@ const SHOULD_BRING_TO_FRONT = shouldBringChromeToFront();
 
 const EARLY_FAIL_NO_RESUME_IFRAME_MIN_WAIT_MS = 5000;
 const EARLY_FAIL_NO_RESUME_IFRAME_STABLE_POLLS = 4;
+const RESUME_VIEWPORT_STABILITY_POLL_MS = 80;
+const RESUME_VIEWPORT_STABLE_POLLS = 2;
 
 function clampInteger(value, low, high) {
   return Math.max(low, Math.min(high, value));
@@ -105,14 +107,71 @@ function isStableNoResumeIframeProbe(probe) {
   return activeScopeCount === 0 && totalResumeIframes === 0 && visibleResumeIframes === 0;
 }
 
-function shouldAbortResumeProbeEarly({ probe, stableNoResumeIframePolls, elapsedMs, waitResumeMs }) {
+function shouldAbortResumeProbeEarly({ probe, stableNoResumeIframePolls, elapsedMs, waitResumeMs }) {
   if (!isStableNoResumeIframeProbe(probe)) {
     return false;
   }
   const minWaitMs = Math.min(waitResumeMs, EARLY_FAIL_NO_RESUME_IFRAME_MIN_WAIT_MS);
   return stableNoResumeIframePolls >= EARLY_FAIL_NO_RESUME_IFRAME_STABLE_POLLS
-    && elapsedMs >= minWaitMs;
-}
+    && elapsedMs >= minWaitMs;
+}
+
+function parseBooleanOption(value, fallback = false) {
+  if (value === undefined || value === null || value === "") return fallback;
+  if (typeof value === "boolean") return value;
+  const normalized = String(value).trim().toLowerCase();
+  if (["1", "true", "yes", "y", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "n", "off"].includes(normalized)) return false;
+  return fallback;
+}
+
+function numbersClose(left, right, tolerance = 1) {
+  return Math.abs(Number(left || 0) - Number(right || 0)) <= tolerance;
+}
+
+function isStableResumeViewport(previous, current, targetScroll) {
+  if (!previous?.ok || !current?.ok) return false;
+  const target = Number(targetScroll || 0);
+  const scrollTop = Number(current.scrollTop || 0);
+  const maxScroll = Number(current.maxScroll || 0);
+  const targetReached = numbersClose(scrollTop, target, 2)
+    || (target >= maxScroll && numbersClose(scrollTop, maxScroll, 2));
+  if (!targetReached) return false;
+  const prevClip = previous.clip || {};
+  const currentClip = current.clip || {};
+  return numbersClose(previous.scrollTop, current.scrollTop, 1)
+    && numbersClose(previous.scrollHeight, current.scrollHeight, 1)
+    && numbersClose(previous.clientHeight, current.clientHeight, 1)
+    && numbersClose(prevClip.x, currentClip.x, 1)
+    && numbersClose(prevClip.y, currentClip.y, 1)
+    && numbersClose(prevClip.width, currentClip.width, 1)
+    && numbersClose(prevClip.height, currentClip.height, 1);
+}
+
+async function waitForStableResumeViewport(evaluate, targetScroll, maxWaitMs) {
+  const maxWait = Math.max(160, Number(maxWaitMs || 0));
+  const start = Date.now();
+  let previous = null;
+  let latest = null;
+  let stablePolls = 0;
+  while (Date.now() - start < maxWait) {
+    await sleep(RESUME_VIEWPORT_STABILITY_POLL_MS);
+    const current = await evaluate(buildResumeProbeExpr({ init: false, targetScroll: null }));
+    if (current?.ok) {
+      latest = current;
+      if (isStableResumeViewport(previous, current, targetScroll)) {
+        stablePolls += 1;
+        if (stablePolls >= RESUME_VIEWPORT_STABLE_POLLS) {
+          return current;
+        }
+      } else {
+        stablePolls = 0;
+      }
+      previous = current;
+    }
+  }
+  return latest;
+}
 
 async function stitchWithSharp(metadataFile, stitchedImage) {
   const sharp = loadSharp();
@@ -490,10 +549,14 @@ function buildResumeProbeExpr({ init, targetScroll }) {
 
 async function captureFullResumeCanvas(options = {}) {
   const host = options.host || process.env.CDP_HOST || "127.0.0.1";
-  const port = Number(options.port || process.env.CDP_PORT || 9222);
-  const waitResumeMs = Number(options.waitResumeMs || process.env.WAIT_RESUME_MS || 30000);
-  const scrollSettleMs = Number(options.scrollSettleMs || process.env.SCROLL_SETTLE_MS || 500);
-  const outPrefix = options.outPrefix || process.env.OUT_PREFIX || path.resolve(process.cwd(), "recommend_resume_full");
+  const port = Number(options.port || process.env.CDP_PORT || 9222);
+  const waitResumeMs = Number(options.waitResumeMs || process.env.WAIT_RESUME_MS || 30000);
+  const scrollSettleMs = Number(options.scrollSettleMs || process.env.SCROLL_SETTLE_MS || 500);
+  const stitchFullImage = parseBooleanOption(
+    options.stitchFullImage,
+    parseBooleanOption(process.env.BOSS_RECOMMEND_STITCH_FULL_IMAGE, true)
+  );
+  const outPrefix = options.outPrefix || process.env.OUT_PREFIX || path.resolve(process.cwd(), "recommend_resume_full");
   const targetPattern = options.targetPattern || process.env.TARGET_PATTERN || "/web/chat/recommend";
   const stitchScript = path.resolve(__dirname, "stitch_resume_chunks.py");
   const chunkDir = `${outPrefix}_chunks`;
@@ -633,12 +696,11 @@ async function captureFullResumeCanvas(options = {}) {
     const chunks = [];
     const seenScroll = [];
 
-    for (let index = 0; index < uniquePositions.length; index += 1) {
-      const targetScroll = uniquePositions[index];
-      await evaluate(buildResumeProbeExpr({ init: false, targetScroll }));
-      await sleep(scrollSettleMs);
-      const current = await evaluate(buildResumeProbeExpr({ init: false, targetScroll: null }));
-      if (!current?.ok) continue;
+    for (let index = 0; index < uniquePositions.length; index += 1) {
+      const targetScroll = uniquePositions[index];
+      await evaluate(buildResumeProbeExpr({ init: false, targetScroll }));
+      const current = await waitForStableResumeViewport(evaluate, targetScroll, scrollSettleMs);
+      if (!current?.ok) continue;
 
       const actualScroll = Number(current.scrollTop || 0);
       if (seenScroll.some((value) => Math.abs(value - actualScroll) < 1)) {
@@ -688,31 +750,36 @@ async function captureFullResumeCanvas(options = {}) {
     };
     fs.writeFileSync(metadataFile, JSON.stringify(metadata, null, 2), "utf8");
 
-    let stitchEngine = "sharp";
-    try {
-      await stitchWithSharp(metadataFile, stitchedImage);
-    } catch (sharpError) {
-      const fallback = stitchWithAvailablePython(stitchScript, metadataFile, stitchedImage);
-      if (!fallback.ok) {
-        const fallbackSummary = fallback.attempts
-          .map((item) => {
-            const message = item.stderr || item.stdout || item.error || "unknown error";
-            return `${item.command}(status=${item.status ?? "null"}): ${message}`;
-          })
-          .join(" | ");
-        throw new Error(
-          `Stitch failed (sharp + python fallback). sharp=${sharpError?.message || sharpError}; fallback=${fallbackSummary}`
-        );
-      }
-      stitchEngine = fallback.command || "python";
-    }
-
-    return {
-      stitchedImage,
-      metadataFile,
-      chunkDir,
-      chunkCount: chunks.length,
-      stitch_engine: stitchEngine,
+    let stitchEngine = "skipped";
+    if (stitchFullImage) {
+      stitchEngine = "sharp";
+      try {
+        await stitchWithSharp(metadataFile, stitchedImage);
+      } catch (sharpError) {
+        const fallback = stitchWithAvailablePython(stitchScript, metadataFile, stitchedImage);
+        if (!fallback.ok) {
+          const fallbackSummary = fallback.attempts
+            .map((item) => {
+              const message = item.stderr || item.stdout || item.error || "unknown error";
+              return `${item.command}(status=${item.status ?? "null"}): ${message}`;
+            })
+            .join(" | ");
+          throw new Error(
+            `Stitch failed (sharp + python fallback). sharp=${sharpError?.message || sharpError}; fallback=${fallbackSummary}`
+          );
+        }
+        stitchEngine = fallback.command || "python";
+      }
+    }
+
+    return {
+      stitchedImage: stitchFullImage ? stitchedImage : "",
+      metadataFile,
+      chunkDir,
+      chunkCount: chunks.length,
+      chunkFiles: chunks.map((chunk) => chunk.file),
+      modelImagePaths: chunks.map((chunk) => chunk.file),
+      stitch_engine: stitchEngine,
       target: {
         title: target.title,
         url: target.url
@@ -729,9 +796,10 @@ module.exports = {
   captureFullResumeCanvas,
   __testables: {
     EARLY_FAIL_NO_RESUME_IFRAME_MIN_WAIT_MS,
-    EARLY_FAIL_NO_RESUME_IFRAME_STABLE_POLLS,
-    isStableNoResumeIframeProbe,
-    shouldAbortResumeProbeEarly,
+    EARLY_FAIL_NO_RESUME_IFRAME_STABLE_POLLS,
+    isStableNoResumeIframeProbe,
+    isStableResumeViewport,
+    shouldAbortResumeProbeEarly,
     stitchWithAvailablePython,
     stitchWithSharp
   }

package/vendor/boss-recommend-screen-cli/test-recoverable-resume-failures.cjs

@@ -238,6 +238,31 @@ function testShouldAbortResumeProbeEarly() {
   assert.equal(shouldAbort, true);
 }
 
+function testResumeViewportStabilityRequiresSettledScrollAndClip() {
+  const previous = {
+    ok: true,
+    scrollTop: 200,
+    scrollHeight: 1000,
+    clientHeight: 400,
+    maxScroll: 600,
+    clip: { x: 10, y: 20, width: 300, height: 400 }
+  };
+  const current = {
+    ok: true,
+    scrollTop: 200.5,
+    scrollHeight: 1000,
+    clientHeight: 400,
+    maxScroll: 600,
+    clip: { x: 10, y: 20, width: 300, height: 400 }
+  };
+  assert.equal(captureTestables.isStableResumeViewport(previous, current, 200), true);
+  assert.equal(captureTestables.isStableResumeViewport(previous, { ...current, scrollTop: 180 }, 200), false);
+  assert.equal(
+    captureTestables.isStableResumeViewport(previous, { ...current, clip: { ...current.clip, height: 360 } }, 200),
+    false
+  );
+}
+
 async function testSingleResumeCaptureFailureIsSkipped() {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-skip-"));
   const badCandidate = { key: "bad", geek_id: "bad", name: "bad candidate" };
@@ -467,7 +492,7 @@ async function testRecommendShouldPreferNetworkResumeWhenAvailable() {
   assert.equal(result.result.resume_source, "network");
 }
 
-async function testNetworkMissShouldFallbackToDomBeforeImageCapture() {
+async function testNetworkMissShouldFallbackToImageThenDom() {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-network-dom-fallback-"));
   const candidate = { key: "dom-1", geek_id: "dom-1", name: "dom candidate" };
   const cli = new FakeRecommendScreenCli(createArgs(tempDir), {
@@ -485,13 +510,15 @@ async function testNetworkMissShouldFallbackToDomBeforeImageCapture() {
   });
 
   cli.waitForNetworkResumeCandidateInfo = async () => null;
+  let captureAttempted = false;
   cli.callTextModel = async (resumeText) => ({
     passed: true,
     reason: resumeText.includes("华中科技大学") ? "dom fallback used" : "unexpected",
     summary: "dom fallback used"
   });
   cli.captureResumeImage = async () => {
-    throw new Error("capture should not be called when dom fallback resume exists");
+    captureAttempted = true;
+    throw new Error("capture failed, should fallback to dom");
   };
 
   const result = await cli.run();
@@ -501,6 +528,7 @@ async function testNetworkMissShouldFallbackToDomBeforeImageCapture() {
   assert.equal(cli.passedCandidates.length, 1);
   assert.equal(cli.passedCandidates[0].school, "华中科技大学");
   assert.equal(cli.passedCandidates[0].resumeSource, "dom_fallback");
+  assert.equal(captureAttempted, true);
 }
 
 async function testNetworkMissShouldFallbackToImageCapture() {
@@ -522,6 +550,64 @@ async function testNetworkMissShouldFallbackToImageCapture() {
   assert.equal(result.result.resume_source, "image_fallback");
 }
 
+async function testImageModeShouldUseShortNetworkGraceWindow() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-image-mode-grace-"));
+  const first = { key: "img-mode-1", geek_id: "img-mode-1", name: "image mode one" };
+  const second = { key: "img-mode-2", geek_id: "img-mode-2", name: "image mode two" };
+  const cli = new FakeRecommendScreenCli(createArgs(tempDir), {
+    candidates: [first, second],
+    captureOutcomes: new Map([
+      [first.key, { stitchedImage: path.join(tempDir, "img-mode-1.png") }],
+      [second.key, { stitchedImage: path.join(tempDir, "img-mode-2.png") }]
+    ]),
+    screeningByKey: new Map([
+      [first.key, { passed: false, reason: "image one", summary: "image one" }],
+      [second.key, { passed: false, reason: "image two", summary: "image two" }]
+    ])
+  });
+  const waits = [];
+  cli.waitForNetworkResumeCandidateInfo = async (_candidate, timeoutMs) => {
+    waits.push(timeoutMs);
+    return null;
+  };
+
+  const result = await cli.run();
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(cli.resumeAcquisitionMode, "image");
+  assert.deepEqual(waits.slice(-1), [__testables.NETWORK_RESUME_IMAGE_MODE_GRACE_MS]);
+}
+
+async function testImageFailureShouldLateRetryNetworkBeforeDomFallback() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-image-fail-late-network-"));
+  const candidate = { key: "late-network-1", geek_id: "late-network-1", name: "late network candidate" };
+  const cli = new FakeRecommendScreenCli(createArgs(tempDir), {
+    candidates: [candidate]
+  });
+  let domUsed = false;
+  cli.waitForNetworkResumeCandidateInfo = async (_candidate, timeoutMs) => (
+    timeoutMs === __testables.NETWORK_RESUME_LATE_RETRY_MS
+      ? { resumeText: "late network resume text" }
+      : null
+  );
+  cli.captureResumeImage = async () => {
+    throw createResumeCaptureError("image capture failed before late network");
+  };
+  cli.extractResumeTextFromDom = async () => {
+    domUsed = true;
+    return null;
+  };
+  cli.callTextModel = async () => ({
+    passed: true,
+    reason: "late network used",
+    summary: "late network used"
+  });
+
+  const result = await cli.run();
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(result.result.resume_source, "network");
+  assert.equal(domUsed, false);
+}
+
 async function testLatestShouldPreferNetworkResumeWhenAvailable() {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-latest-network-main-"));
   const args = createArgs(tempDir);
@@ -600,7 +686,7 @@ function testLatestPayloadShouldRemainAvailableWhenCandidateKeyMissing() {
     key: "",
     geek_id: ""
   });
-  assert.equal(extracted?.resumeText, "recent resume payload");
+  assert.equal(extracted?.candidateInfo?.resumeText, "recent resume payload");
 }
 
 async function testVisionModelFailureShouldSkipCandidateAndContinue() {
@@ -638,25 +724,44 @@ async function testVisionModelFailureShouldSkipCandidateAndContinue() {
   assert.equal(result.result.skipped_count, 1);
 }
 
-async function testFeaturedNetworkMissShouldSkipWithoutImageCapture() {
+async function testFeaturedNetworkMissShouldFallbackToDomAfterImageFailure() {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-screen-featured-network-only-"));
   const args = createArgs(tempDir);
   args.pageScope = "featured";
   const candidate = { key: "featured-no-network", geek_id: "featured-no-network", name: "featured no network" };
   const cli = new FakeRecommendScreenCli(args, {
-    candidates: [candidate]
+    candidates: [candidate],
+    domResumeByKey: new Map([
+      ["featured-no-network", {
+        name: "featured no network",
+        school: "华中科技大学",
+        major: "软件工程",
+        company: "测试公司",
+        position: "后端工程师",
+        resumeText: "featured network miss 后应在截图失败后走 DOM 兜底。"
+      }]
+    ])
   });
   cli.waitForNetworkResumeCandidateInfo = async () => null;
+  let captureAttempted = false;
+  cli.callTextModel = async () => ({
+    passed: true,
+    reason: "dom fallback used",
+    summary: "dom fallback used"
+  });
   cli.captureResumeImage = async () => {
-    throw new Error("capture should not be called for featured scope");
+    captureAttempted = true;
+    throw new Error("capture failed for featured scope");
   };
 
   const result = await cli.run();
   assert.equal(result.status, "COMPLETED");
   assert.equal(result.result.processed_count, 1);
-  assert.equal(result.result.passed_count, 0);
-  assert.equal(result.result.skipped_count, 1);
-  assert.equal(result.result.resume_source, "network");
+  assert.equal(result.result.passed_count, 1);
+  assert.equal(result.result.skipped_count, 0);
+  assert.equal(result.result.resume_source, "dom_fallback");
+  assert.equal(captureAttempted, true);
+  assert.equal(cli.passedCandidates[0].resumeSource, "dom_fallback");
 }
 
 async function testFeaturedFavoriteShouldNotUseDomFallback() {
@@ -1326,6 +1431,75 @@ async function testCallTextModelShouldFallbackToChunkModeOnContextLimit() {
   }
 }
 
+async function testTextModelShouldDefaultThinkingOffForVolcengine() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-thinking-off-"));
+  const cli = new RecommendScreenCli(createArgs(tempDir));
+  cli.args.baseUrl = "https://ark.cn-beijing.volces.com/api/v3";
+  cli.args.model = "doubao-seed-2-0-mini-260215";
+  const originalFetch = global.fetch;
+  let capturedPayload = null;
+  global.fetch = async (_url, options = {}) => {
+    capturedPayload = JSON.parse(String(options.body || "{}"));
+    return {
+      ok: true,
+      status: 200,
+      async json() {
+        return {
+          choices: [
+            {
+              message: {
+                content: "{\"passed\": false, \"reason\": \"not matched\", \"summary\": \"not matched\", \"evidence\": [\"resume\"]}"
+              }
+            }
+          ]
+        };
+      }
+    };
+  };
+  try {
+    await cli.callTextModel("resume");
+    assert.deepEqual(capturedPayload?.thinking, { type: "disabled" });
+    assert.equal(capturedPayload?.reasoning_effort, "minimal");
+  } finally {
+    global.fetch = originalFetch;
+  }
+}
+
+async function testTextModelShouldSupportLowThinkingForVolcengine() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-thinking-low-"));
+  const cli = new RecommendScreenCli(createArgs(tempDir));
+  cli.args.baseUrl = "https://ark.cn-beijing.volces.com/api/v3";
+  cli.args.model = "doubao-seed-2-0-mini-260215";
+  cli.args.thinkingLevel = "low";
+  const originalFetch = global.fetch;
+  let capturedPayload = null;
+  global.fetch = async (_url, options = {}) => {
+    capturedPayload = JSON.parse(String(options.body || "{}"));
+    return {
+      ok: true,
+      status: 200,
+      async json() {
+        return {
+          choices: [
+            {
+              message: {
+                content: "{\"passed\": false, \"reason\": \"not matched\", \"summary\": \"not matched\", \"evidence\": [\"resume\"]}"
+              }
+            }
+          ]
+        };
+      }
+    };
+  };
+  try {
+    await cli.callTextModel("resume");
+    assert.deepEqual(capturedPayload?.thinking, { type: "enabled" });
+    assert.equal(capturedPayload?.reasoning_effort, "low");
+  } finally {
+    global.fetch = originalFetch;
+  }
+}
+
 async function testPrepareVisionImageSegmentsShouldSplitLongImage() {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-vision-segments-"));
   const cli = new RecommendScreenCli(createArgs(tempDir));
@@ -1451,8 +1625,55 @@ async function testVisionEvidenceGateShouldDemoteImageFallbackWithoutEvidence()
   assert.equal(result.evidenceMatchedCount, 0);
 }
 
+async function testVisionModelShouldSendAllOrderedChunks() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-recommend-vision-all-chunks-"));
+  const chunkPaths = [];
+  for (let index = 0; index < 3; index += 1) {
+    const chunkPath = path.join(tempDir, `chunk-${index + 1}.png`);
+    await sharp({
+      create: { width: 16, height: 16, channels: 3, background: { r: 255 - index, g: 250, b: 245 } }
+    }).png().toFile(chunkPath);
+    chunkPaths.push(chunkPath);
+  }
+  const cli = new RecommendScreenCli(createArgs(tempDir));
+  const originalFetch = global.fetch;
+  let capturedPayload = null;
+  global.fetch = async (_url, options = {}) => {
+    capturedPayload = JSON.parse(String(options.body || "{}"));
+    return {
+      ok: true,
+      status: 200,
+      async json() {
+        return {
+          choices: [
+            {
+              message: {
+                content: "{\"passed\": false, \"reason\": \"checked all chunks\", \"summary\": \"checked\", \"evidence\": [\"chunk evidence\", \"more evidence\"]}"
+              }
+            }
+          ]
+        };
+      }
+    };
+  };
+  try {
+    const result = await cli.requestVisionModel(chunkPaths);
+    assert.equal(result.passed, false);
+    const userContent = capturedPayload?.messages?.[1]?.content || [];
+    assert.equal(userContent.filter((item) => item?.type === "image_url").length, 3);
+    const text = userContent.map((item) => item?.text || "").join("\n");
+    assert.equal(text.includes("简历分段 1/3"), true);
+    assert.equal(text.includes("简历分段 2/3"), true);
+    assert.equal(text.includes("简历分段 3/3"), true);
+    assert.equal(text.includes("不能只根据前几段下结论"), true);
+  } finally {
+    global.fetch = originalFetch;
+  }
+}
+
 async function main() {
   testShouldAbortResumeProbeEarly();
+  testResumeViewportStabilityRequiresSettledScrollAndClip();
   await testSingleResumeCaptureFailureIsSkipped();
   await testConsecutiveResumeCaptureFailuresStillAbort();
   await testPageExhaustedBeforeTargetShouldRaiseRecoverableError();
@@ -1461,14 +1682,16 @@ async function main() {
   await testTargetCountShouldNotTreatProcessedCountAsReached();
   await testFeaturedShouldUseNetworkResumeOnly();
   await testRecommendShouldPreferNetworkResumeWhenAvailable();
-  await testNetworkMissShouldFallbackToDomBeforeImageCapture();
+  await testNetworkMissShouldFallbackToImageThenDom();
   await testNetworkMissShouldFallbackToImageCapture();
+  await testImageModeShouldUseShortNetworkGraceWindow();
+  await testImageFailureShouldLateRetryNetworkBeforeDomFallback();
   await testLatestShouldPreferNetworkResumeWhenAvailable();
   await testLatestNetworkMissShouldFallbackToImageCapture();
   testLatestPayloadShouldNotLeakAcrossCandidates();
   testLatestPayloadShouldRemainAvailableWhenCandidateKeyMissing();
   await testVisionModelFailureShouldSkipCandidateAndContinue();
-  await testFeaturedNetworkMissShouldSkipWithoutImageCapture();
+  await testFeaturedNetworkMissShouldFallbackToDomAfterImageFailure();
   await testFeaturedFavoriteShouldNotUseDomFallback();
   await testFeaturedFavoriteShouldSkipClickWhenAlreadyInterested();
   await testFeaturedFavoriteShouldRecognizeAlreadyFavoritedByDelThenAdd();
@@ -1493,8 +1716,11 @@ async function main() {
   testParseArgsShouldSupportInputSummaryJson();
   await testCallTextModelShouldNotTruncateLongResume();
   await testCallTextModelShouldFallbackToChunkModeOnContextLimit();
+  await testTextModelShouldDefaultThinkingOffForVolcengine();
+  await testTextModelShouldSupportLowThinkingForVolcengine();
   await testPrepareVisionImageSegmentsShouldSplitLongImage();
   await testVisionEvidenceGateShouldDemoteImageFallbackWithoutEvidence();
+  await testVisionModelShouldSendAllOrderedChunks();
   testRecoverablePostActionErrorShouldTreatGreetContinueAndNoButtonAsRecoverable();
   await testRecoverableGreetContinueButtonShouldNotAbortWhenDetailCloseFails();
   await testRecoverableGreetButtonNotFoundShouldNotAbortWhenDetailCloseFails();