@bsbofmusic/cdper-doubao 1.1.4 → 1.1.6

package/dist/doubao.js

@@ -0,0 +1,829 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * cdper-doubao — 豆包 CDP 查询逻辑
+ * Platform-specific DOM logic only. All shared helpers live in @bsbofmusic/cdper-core/plugin_helpers.
+ */
+const { log } = require('@bsbofmusic/cdper-core/logger');
+const { connectWithWarmReuse, disconnect } = require('@bsbofmusic/cdper-core/cdp');
+const { resolveCdpWs } = require('@bsbofmusic/cdper-core/cdp-ws');
+const { waitForDoubaoReply, captureDoubaoReplySnapshot, detectChallenge } = require('@bsbofmusic/cdper-core/smart_wait');
+const { updateSession } = require('@bsbofmusic/cdper-core/session');
+const { createPluginContext, buildPluginSuccess } = require('@bsbofmusic/cdper-core/plugin_contract');
+const { runState } = require('@bsbofmusic/cdper-core/state_machine');
+const { getRuntimeStatus } = require('@bsbofmusic/cdper-core/runtime_status');
+const { WRAPPER_STATUSES, buildWrapperResult } = require('@bsbofmusic/cdper-core/wrapper_result');
+const { randomInt, humanPause, withLocalTimeout, throwIfAborted, ensureMinimumPageDwell, humanWarmup, computeSendTimeoutMs, insertTextViaCdp, buildWaitPlan, createProgressRecorder, resolveConversationPolicy, buildConversationAnchor, prefersShortAnswer, handlePluginQueryError, verifySubmission, } = require('@bsbofmusic/cdper-core/plugin_helpers');
+const PLATFORM = 'doubao';
+const STATE_TIMEOUTS = { open: 150000, ensure_session: 30000, ensure_mode: 45000, send: 45000, extract: 10000 };
+const WAIT_PROFILES = {
+    short: { minWait: 8000, maxWait: 90000, maxExtends: 2, pollInterval: 2500 },
+    normal: { minWait: 12000, maxWait: 300000, maxExtends: 6, pollInterval: 2500 },
+    long: { minWait: 20000, maxWait: 20 * 60 * 1000, maxExtends: 8, pollInterval: 2500 },
+    very_long: { minWait: 30000, maxWait: 45 * 60 * 1000, maxExtends: 10, pollInterval: 2500 },
+};
+function emptyDoubaoSnapshot() {
+    return { text: '', normalized: '', length: 0, candidateCount: 0 };
+}
+function buildDoubaoModeState(expertModeConfirmed) {
+    return {
+        modePath: expertModeConfirmed ? 'composer_expert' : 'composer_quick',
+        modeConfirmed: Boolean(expertModeConfirmed),
+        modeConfidence: expertModeConfirmed ? 'high' : 'low',
+    };
+}
+// ─── Conversation anchor ──────────────────────────────────────────────────────
+function isDoubaoUrl(url) {
+    return /doubao\.com/.test(String(url || ''));
+}
+function getDoubaoConversationId(url) {
+    const match = String(url || '').match(/https:\/\/(?:www\.)?doubao\.com\/chat\/([^/?#]+)/);
+    if (!match || match[1] === 'url-action')
+        return null;
+    return match[1];
+}
+function hasStrongAnchor(session) {
+    const conversation = session?.conversation || {};
+    if (conversation.platform !== PLATFORM || !conversation.anchorUrl)
+        return false;
+    return conversation.anchorConfidence === 'strong' || !!getDoubaoConversationId(conversation.anchorUrl);
+}
+function getStoredConversationId(session) {
+    const conversation = session?.conversation || {};
+    return conversation.conversationId || getDoubaoConversationId(conversation.anchorUrl);
+}
+function assertFollowupAnchorActive(page, session) {
+    const expectedId = getStoredConversationId(session);
+    const actualId = getDoubaoConversationId(page.url());
+    if (!expectedId || actualId !== expectedId) {
+        throw new Error('Doubao followup anchor was not active after navigation; refusing to send into an unanchored chat');
+    }
+}
+// ─── Page readiness ───────────────────────────────────────────────────────────
+async function findDoubaoInput(page) {
+    const handles = await page.$$('textarea, [contenteditable="true"], [role="textbox"]');
+    for (const handle of handles) {
+        try {
+            const box = await handle.boundingBox();
+            if (!box || box.width < 80 || box.height < 20)
+                continue;
+            const meta = await page.evaluate((el) => ({
+                tag: el.tagName, placeholder: el.getAttribute('placeholder') || '',
+                contenteditable: el.getAttribute('contenteditable') || '', role: el.getAttribute('role') || '',
+                disabled: !!el.disabled, ariaHidden: el.getAttribute('aria-hidden') || '',
+            }), handle);
+            if (meta.disabled || meta.ariaHidden === 'true')
+                continue;
+            return { handle, meta };
+        }
+        catch (_) { }
+    }
+    return null;
+}
+async function hasDoubaoInput(page, timeoutMs = 12000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const found = await findDoubaoInput(page);
+        if (found)
+            return found;
+        await humanPause(250, 500);
+    }
+    return null;
+}
+async function waitForDoubaoPredicate(page, predicate, options = {}) {
+    const { timeoutMs = 12000, intervalMs = 250, stableCount = 1, sessionId, challengeCheck = true } = options;
+    const deadline = Date.now() + timeoutMs;
+    let hits = 0;
+    while (Date.now() < deadline) {
+        if (challengeCheck)
+            await assertNoChallenge(page, sessionId);
+        const matched = await predicate();
+        if (matched) {
+            hits += 1;
+            if (hits >= stableCount)
+                return true;
+        }
+        else
+            hits = 0;
+        await humanPause(intervalMs, intervalMs + 60);
+    }
+    return false;
+}
+async function getDoubaoUiState(page) {
+    return page.evaluate(() => {
+        const bodyText = document.body?.innerText || '';
+        const viewportHeight = window.innerHeight || 0;
+        const buttons = Array.from(document.querySelectorAll('button'));
+        const visibleButton = (button) => {
+            const text = (button.innerText || '').trim();
+            const rect = button.getBoundingClientRect();
+            return { text, visible: rect.width >= 28 && rect.height >= 20 && rect.y <= viewportHeight && rect.bottom >= 0 };
+        };
+        const quickButton = buttons.find((button) => {
+            const meta = visibleButton(button);
+            return ['快速', 'Quick'].includes(meta.text) && meta.visible;
+        });
+        const expertButton = buttons.find((button) => /^(?:专家|Expert)($|\n)/.test(visibleButton(button).text) && visibleButton(button).visible);
+        const superModeButton = buttons.find((button) => /^(?:超能模式|Super|Deep)($|\n)/i.test(visibleButton(button).text) && visibleButton(button).visible);
+        const menu = document.querySelector('[role="menu"]');
+        const menuItems = menu
+            ? Array.from(menu.querySelectorAll('[role="menuitem"]')).map((node) => ({
+                text: (node.innerText || '').trim(),
+                visible: (() => {
+                    const rect = node.getBoundingClientRect();
+                    return rect.width >= 28 && rect.height >= 20;
+                })(),
+            }))
+            : [];
+        const hasInput = Array.from(document.querySelectorAll('textarea, [contenteditable="true"], [role="textbox"]')).some((element) => {
+            const rect = element.getBoundingClientRect();
+            if (rect.width < 80 || rect.height < 20)
+                return false;
+            const ariaHidden = element.getAttribute('aria-hidden') || '';
+            return ariaHidden !== 'true' && !element.disabled;
+        });
+        const loading = !!document.querySelector('[class*="loading"], [class*="spinner"], [class*="skeleton"]');
+        const unavailable = bodyText.includes('该页面暂时不可用');
+        return { url: location.href, title: document.title || '', hasInput, hasQuickButton: !!quickButton, hasExpertButton: !!expertButton, hasSuperModeButton: !!superModeButton, menuVisible: !!menu, menuItems, loading, unavailable };
+    });
+}
+async function waitForDoubaoReady(page, options = {}) {
+    const { timeoutMs = 24000, sessionId } = options;
+    return waitForDoubaoPredicate(page, async () => {
+        const state = await getDoubaoUiState(page);
+        if (state.unavailable) {
+            await recoverDoubaoUnavailablePage(page);
+            return false;
+        }
+        return state.hasInput;
+    }, { timeoutMs, intervalMs: 300, stableCount: 2, sessionId });
+}
+async function waitForDoubaoModeSettled(page, options = {}) {
+    const { timeoutMs = 7000, sessionId } = options;
+    return waitForDoubaoPredicate(page, async () => {
+        const state = await getDoubaoUiState(page);
+        return state.hasExpertButton && state.hasInput && !state.menuVisible;
+    }, { timeoutMs, intervalMs: 220, stableCount: 2, sessionId });
+}
+async function assertNoChallenge(page, sessionId) {
+    const detected = await detectChallenge(page);
+    if (detected.detected) {
+        log('WARN', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: sessionId, step: 'gate', action: 'challenge_detect', status: 'blocked', message: '命中风控/验证页: ' + detected.hint });
+        throw new Error('命中风控/验证页，需要人工接管: ' + detected.hint);
+    }
+}
+// ─── Navigation helpers ───────────────────────────────────────────────────────
+async function adoptExistingDoubaoPage(browser, fallbackPage) {
+    try {
+        const pages = await browser.pages();
+        for (const candidate of pages) {
+            try {
+                const url = candidate.url();
+                if (isDoubaoUrl(url) && candidate !== fallbackPage) {
+                    await candidate.bringToFront();
+                    try {
+                        await fallbackPage.close();
+                    }
+                    catch (_) { }
+                    candidate.__cdperManagedPage = false;
+                    return candidate;
+                }
+            }
+            catch (_) { }
+        }
+    }
+    catch (_) { }
+    return fallbackPage;
+}
+async function clickHandleAtCenter(page, handle, label) {
+    try {
+        const box = await handle.boundingBox();
+        if (box && box.width > 0 && box.height > 0) {
+            await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2, { delay: 80 });
+            return true;
+        }
+    }
+    catch (error) {
+        log('WARN', '[doubao]', label + '坐标点击失败: ' + error.message);
+    }
+    return false;
+}
+async function clickHandleWithoutCoordinates(handle, label) {
+    try {
+        await withLocalTimeout(handle.evaluate((element) => element.click()), label + ' DOM click');
+        return true;
+    }
+    catch (error) {
+        log('WARN', '[doubao]', label + 'DOM click 失败，尝试键盘激活: ' + error.message);
+    }
+    try {
+        await withLocalTimeout((async () => {
+            await handle.focus();
+            await humanPause(80, 140);
+            await handle.press('Enter');
+        })(), label + ' keyboard activate');
+        return true;
+    }
+    catch (error) {
+        log('WARN', '[doubao]', label + '键盘激活失败，尝试句柄点击: ' + error.message);
+    }
+    try {
+        await withLocalTimeout(handle.click({ delay: 80 }), label + ' handle click');
+        return true;
+    }
+    catch (error) {
+        log('WARN', '[doubao]', label + '句柄点击失败: ' + error.message);
+    }
+    return false;
+}
+async function clickButtonByExactText(page, text, label) {
+    try {
+        const clicked = await page.evaluate((targetText) => {
+            const button = Array.from(document.querySelectorAll('button')).find((node) => {
+                const nodeText = (node.innerText || '').trim();
+                const rect = node.getBoundingClientRect();
+                return nodeText === targetText && rect.width > 0 && rect.height > 0;
+            });
+            if (!button)
+                return false;
+            button.click();
+            return true;
+        }, text);
+        if (clicked)
+            return true;
+    }
+    catch (error) {
+        log('WARN', '[doubao]', label + '页面级点击失败: ' + error.message);
+    }
+    return false;
+}
+async function clickMenuItemByPrefix(page, prefix, label) {
+    try {
+        const items = await page.$$('[role="menuitem"]');
+        for (const item of items) {
+            const meta = await item.evaluate((node) => {
+                const text = (node.innerText || '').trim();
+                const rect = node.getBoundingClientRect();
+                return { text, visible: rect.width > 0 && rect.height > 0 };
+            }).catch(() => null);
+            if (!meta || !meta.visible || !meta.text.startsWith(prefix))
+                continue;
+            if (await clickHandleAtCenter(page, item, label + '坐标'))
+                return true;
+            if (await clickHandleWithoutCoordinates(item, label))
+                return true;
+        }
+    }
+    catch (error) {
+        log('WARN', '[doubao]', label + '坐标点击链路失败: ' + error.message);
+    }
+    try {
+        const clicked = await page.evaluate((targetPrefix) => {
+            const menu = document.querySelector('[role="menu"]');
+            if (!menu)
+                return false;
+            const item = Array.from(menu.querySelectorAll('[role="menuitem"]')).find((node) => {
+                const text = (node.innerText || '').trim();
+                const rect = node.getBoundingClientRect();
+                return text.startsWith(targetPrefix) && rect.width > 0 && rect.height > 0;
+            });
+            if (!item)
+                return false;
+            item.click();
+            return true;
+        }, prefix);
+        if (clicked)
+            return true;
+    }
+    catch (error) {
+        log('WARN', '[doubao]', label + '页面级点击失败: ' + error.message);
+    }
+    return false;
+}
+async function recoverDoubaoUnavailablePage(page) {
+    try {
+        const refreshState = await page.evaluate(() => {
+            const bodyText = document.body?.innerText || '';
+            if (!bodyText.includes('该页面暂时不可用'))
+                return { found: false, reload: false };
+            const hasRefreshButton = Array.from(document.querySelectorAll('button')).some((button) => {
+                const text = (button.innerText || '').trim();
+                const rect = button.getBoundingClientRect();
+                return text.includes('刷新页面') && rect.width > 0 && rect.height > 0;
+            });
+            return { found: true, reload: !hasRefreshButton };
+        });
+        if (!refreshState.found)
+            return false;
+        if (refreshState.reload) {
+            await page.reload({ timeout: 60000, waitUntil: 'domcontentloaded' });
+        }
+        else {
+            const buttons = await page.$$('button');
+            let clicked = false;
+            for (const button of buttons) {
+                const text = await button.evaluate((element) => (element.innerText || '').trim()).catch(() => '');
+                if (!text.includes('刷新页面'))
+                    continue;
+                clicked = await clickHandleWithoutCoordinates(button, '刷新页面按钮');
+                if (clicked)
+                    break;
+            }
+            if (!clicked)
+                await page.reload({ timeout: 60000, waitUntil: 'domcontentloaded' });
+        }
+        await humanPause(2500, 5000);
+        return true;
+    }
+    catch (_) {
+        return false;
+    }
+}
+async function openDoubaoHome(page, sessionId) {
+    let lastError = null;
+    if (isDoubaoUrl(page.url())) {
+        await humanWarmup(page);
+        await recoverDoubaoUnavailablePage(page);
+        if (await waitForDoubaoReady(page, { timeoutMs: 5000, sessionId }))
+            return true;
+    }
+    for (const url of ['https://www.doubao.com/', 'https://www.doubao.com/chat/']) {
+        try {
+            await page.goto(url, { timeout: 60000, waitUntil: 'domcontentloaded' });
+            await humanWarmup(page);
+            await recoverDoubaoUnavailablePage(page);
+            if (await waitForDoubaoReady(page, { timeoutMs: 24000, sessionId }))
+                return true;
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    if (lastError)
+        throw lastError;
+    throw new Error('Doubao 页面未准备好：输入框未出现');
+}
+async function hasDoubaoConversationContent(page) {
+    const snapshot = await captureDoubaoReplySnapshot(page).catch(() => null);
+    return Number(snapshot?.length || 0) > 0;
+}
+async function ensureFreshDoubaoHome(page, sessionId) {
+    await openDoubaoHome(page, sessionId);
+    const hasExistingContent = await hasDoubaoConversationContent(page);
+    const isConversationUrl = !!getDoubaoConversationId(page.url());
+    if (hasExistingContent || isConversationUrl) {
+        await clickNewChat(page, { strict: true, sessionId });
+        await humanPause(900, 1800);
+    }
+    await assertNoChallenge(page, sessionId);
+    if (!(await waitForDoubaoReady(page, { timeoutMs: 12000, sessionId }))) {
+        throw new Error('Doubao fresh conversation input was not ready');
+    }
+    if (await hasDoubaoConversationContent(page)) {
+        throw new Error('Doubao fresh conversation could not be confirmed clean');
+    }
+    return true;
+}
+// ─── Input helpers ────────────────────────────────────────────────────────────
+async function typeIntoDoubaoInput(page, inputHandle, text) {
+    await inputHandle.focus();
+    await humanPause(160, 420);
+    const value = String(text || '');
+    // Doubao composer is React-controlled; use CDP insertText for both short and
+    // multiline prompts to avoid stale keyboard/IME edge cases.
+    await insertTextViaCdp(page, value);
+}
+async function clickDoubaoSend(page) {
+    const candidates = await page.$$('button,[role="button"]');
+    for (const handle of candidates) {
+        const meta = await handle.evaluate((element) => {
+            const text = (element.innerText || '').trim();
+            const aria = element.getAttribute('aria-label') || '';
+            const disabled = element.disabled || element.getAttribute('aria-disabled') === 'true';
+            const rect = element.getBoundingClientRect();
+            return { text, aria, disabled, visible: rect.width > 0 && rect.height > 0 };
+        }).catch(() => null);
+        if (!meta || meta.disabled || !meta.visible)
+            continue;
+        const looksLikeSend = [meta.text, meta.aria].some((value) => /发送|提交|send/i.test(value));
+        if (looksLikeSend)
+            return clickHandleWithoutCoordinates(handle, '发送按钮');
+    }
+    return false;
+}
+async function clearDoubaoInput(page, inputHandle) {
+    await inputHandle.focus();
+    await humanPause(100, 220);
+    const modifier = process.platform === 'darwin' ? 'Meta' : 'Control';
+    try {
+        await page.keyboard.down(modifier);
+        await page.keyboard.press('A');
+        await page.keyboard.up(modifier);
+    }
+    catch (_) { }
+    await humanPause(60, 160);
+    try {
+        await page.keyboard.press('Backspace');
+    }
+    catch (_) { }
+    await humanPause(80, 180);
+}
+async function clickNewChat(page, options = {}) {
+    const { strict = false, sessionId } = options;
+    try {
+        const handles = await page.$$('button,[role="button"],div,span,a');
+        let target = null;
+        for (const handle of handles) {
+            const meta = await handle.evaluate((el) => {
+                const text = (el.innerText || '').trim();
+                const rect = el.getBoundingClientRect();
+                return { text, x: rect.x, y: rect.y, w: rect.width, h: rect.height };
+            }).catch(() => null);
+            if (!meta || !['新对话', '新聊天', 'New chat'].includes(meta.text))
+                continue;
+            if (meta.w <= 0 || meta.h <= 0)
+                continue;
+            target = handle;
+            break;
+        }
+        if (target) {
+            await clickHandleWithoutCoordinates(target, '新对话按钮');
+            log('DEBUG', '[doubao]', '已点击新对话');
+            return true;
+        }
+        if (strict) {
+            log('WARN', '[doubao]', '未找到新对话按钮，严格 fresh 模式下重新打开首页');
+            await page.goto('https://www.doubao.com/', { timeout: 60000, waitUntil: 'domcontentloaded' });
+            await humanPause(900, 1800);
+            return waitForDoubaoReady(page, { timeoutMs: 12000, sessionId });
+        }
+        const input = await hasDoubaoInput(page, 4000);
+        if (input) {
+            log('WARN', '[doubao]', '未找到新对话按钮，但输入框可用，保留当前页面继续');
+            return false;
+        }
+        log('WARN', '[doubao]', '未找到新对话按钮，重新打开首页');
+        await openDoubaoHome(page, sessionId);
+        return false;
+    }
+    catch (e) {
+        log('WARN', '[doubao]', '新建对话失败: ' + e.message);
+        return false;
+    }
+}
+async function switchToExpert(page, sessionId) {
+    const isExpertButton = async () => {
+        const state = await getDoubaoUiState(page);
+        return state.hasExpertButton;
+    };
+    if (await isExpertButton()) {
+        log('INFO', '[doubao]', '专家按钮已存在，模式已就绪');
+        return true;
+    }
+    const findQuickButtons = async () => {
+        const btns = await page.$$('button');
+        let trigger = null;
+        let fallback = null;
+        for (const btn of btns) {
+            const meta = await btn.evaluate((el) => ({
+                text: (el.innerText || '').trim(), ariaHasPopup: el.getAttribute('aria-haspopup') || '',
+                dataSlot: el.getAttribute('data-slot') || '', dataState: el.getAttribute('data-state') || '',
+            })).catch(() => null);
+            if (!meta || meta.text !== '快速')
+                continue;
+            if (meta.ariaHasPopup === 'menu' || meta.dataSlot === 'dropdown-menu-trigger') {
+                trigger = btn;
+                break;
+            }
+            if (!fallback)
+                fallback = btn;
+        }
+        return { trigger, fallback };
+    };
+    const waitForExpertMenu = () => waitForDoubaoPredicate(page, async () => {
+        const state = await getDoubaoUiState(page);
+        return state.menuVisible && state.menuItems.some((item) => /^专家($|\n)/.test(item.text));
+    }, { timeoutMs: 5000, intervalMs: 180, stableCount: 1, challengeCheck: false });
+    const openQuickMenu = async (attempt) => {
+        const { trigger, fallback } = await findQuickButtons();
+        const candidates = [
+            { handle: trigger, label: '快速菜单触发器(第' + attempt + '次)' },
+            { handle: fallback, label: '快速按钮候选(第' + attempt + '次)' },
+        ].filter((item) => item.handle);
+        const activate = async (handle, key) => {
+            try {
+                await handle.focus();
+                await humanPause(80, 140);
+                await handle.press(key);
+                return waitForExpertMenu().catch(() => false);
+            }
+            catch (_) {
+                return false;
+            }
+        };
+        for (const candidate of candidates) {
+            if (await clickHandleAtCenter(page, candidate.handle, candidate.label + '坐标')) {
+                if (await waitForExpertMenu().catch(() => false))
+                    return true;
+            }
+            const clicked = await clickHandleWithoutCoordinates(candidate.handle, candidate.label);
+            if (clicked && await waitForExpertMenu().catch(() => false))
+                return true;
+            if (await activate(candidate.handle, 'ArrowDown'))
+                return true;
+            if (await activate(candidate.handle, 'Enter'))
+                return true;
+        }
+        return (await clickButtonByExactText(page, '快速', '快速按钮(第' + attempt + '次)')) && await waitForExpertMenu().catch(() => false);
+    };
+    const clickExpertInMenu = async () => {
+        if (await clickMenuItemByPrefix(page, '专家', '专家菜单项'))
+            return true;
+        const menu = await page.$('[role="menu"]');
+        if (!menu)
+            return false;
+        const items = await menu.$$('[role="menuitem"]');
+        for (const item of items) {
+            const text = await item.evaluate((el) => (el.innerText || '').trim()).catch(() => '');
+            if (!/^专家($|\n)/.test(text))
+                continue;
+            if (await clickHandleWithoutCoordinates(item, '专家菜单项'))
+                return true;
+        }
+        return false;
+    };
+    for (let attempt = 1; attempt <= 2; attempt += 1) {
+        const { trigger, fallback } = await findQuickButtons();
+        if (!trigger && !fallback) {
+            log('WARN', '[doubao]', '未找到快速按钮');
+            return false;
+        }
+        if (!(await openQuickMenu(attempt))) {
+            log('WARN', '[doubao]', '点击快速后菜单未出现，第' + attempt + '次重试');
+            continue;
+        }
+        if (!(await clickExpertInMenu())) {
+            const state = await getDoubaoUiState(page).catch(() => ({ menuItems: [] }));
+            log('WARN', '[doubao]', '未在菜单中找到专家项: ' + JSON.stringify((state.menuItems || []).map((item) => item.text)));
+            continue;
+        }
+        const settled = await waitForDoubaoModeSettled(page, { timeoutMs: 7000, sessionId }).catch(() => false);
+        if (settled) {
+            log('INFO', '[doubao]', '专家模式切换成功');
+            return true;
+        }
+        const inputStable = await waitForDoubaoReady(page, { timeoutMs: 5000, sessionId }).catch(() => false);
+        if (inputStable && await isExpertButton()) {
+            log('INFO', '[doubao]', '专家模式切换成功，输入区稳定');
+            return true;
+        }
+    }
+    log('WARN', '[doubao]', '专家模式切换未能确认成功');
+    return false;
+}
+// ─── Main query ───────────────────────────────────────────────────────────────
+async function queryDoubao(queryText, opts = {}) {
+    const { mode = 'expert', sessionId, _retried = false } = opts;
+    const abortSignal = opts.abortSignal || null;
+    const fallbackMeta = opts._fallbackMeta || null;
+    throwIfAborted(abortSignal, 'Doubao query');
+    const hasExplicitSession = Boolean(sessionId);
+    const queryPreview = String(queryText || '').slice(0, 50);
+    log('INFO', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: sessionId || '', step: 'query', action: 'start', status: 'ok', message: '查询: "' + queryPreview + '..." [mode=' + mode + ']' });
+    const { session, flow } = createPluginContext('doubao', PLATFORM, sessionId);
+    const conversationPlan = resolveConversationPolicy(opts, session, hasExplicitSession, hasStrongAnchor);
+    if (conversationPlan.effective === 'followup' && !hasStrongAnchor(session)) {
+        throw new Error('Doubao followup requires an existing conversation anchor for this sessionId');
+    }
+    const waitPlan = buildWaitPlan(opts, WAIT_PROFILES);
+    const progressRecorder = createProgressRecorder('doubao', opts);
+    let activeSession = session;
+    let initialReplySnapshot = null;
+    let inputReadyAfterOpen = false;
+    let promptSubmitted = false;
+    let expertModeConfirmed = false;
+    let page, browser;
+    try {
+        throwIfAborted(abortSignal, 'Doubao query');
+        await runState(flow, 'open', async () => {
+            throwIfAborted(abortSignal, 'Doubao open');
+            const wantsFreshPage = conversationPlan.effective === 'fresh';
+            const connected = await connectWithWarmReuse({
+                wsUrl: resolveCdpWs(),
+                preferHost: 'doubao.com',
+                prewarmUrl: 'https://www.doubao.com/',
+                titleHint: '豆包',
+                mode: 'advanced',
+                profile: 'Default',
+                forceNewPage: wantsFreshPage,
+                waitMs: randomInt(800, 1600),
+                driver: opts.driver,
+            });
+            page = connected.page;
+            browser = connected.browser;
+            // Fresh queries should start from a fresh tab instead of adopting a stale
+            // conversation that happens to share the same host.
+            if (!connected.reusedExistingPage && !wantsFreshPage)
+                page = await adoptExistingDoubaoPage(browser, page);
+            if (conversationPlan.effective === 'followup') {
+                inputReadyAfterOpen = await openDoubaoHome(page, session.sessionId);
+                const anchorUrl = session.conversation?.anchorUrl;
+                if (anchorUrl && page.url() !== anchorUrl) {
+                    await page.goto(anchorUrl, { timeout: 60000, waitUntil: 'domcontentloaded' });
+                    await humanPause(900, 1800);
+                    await assertNoChallenge(page, session.sessionId);
+                    assertFollowupAnchorActive(page, session);
+                    inputReadyAfterOpen = await waitForDoubaoReady(page, { timeoutMs: 24000, sessionId: session.sessionId });
+                    if (!inputReadyAfterOpen)
+                        throw new Error('Doubao followup anchor opened but input was not ready');
+                }
+                assertFollowupAnchorActive(page, session);
+            }
+            else if (conversationPlan.effective === 'fresh') {
+                // Fresh queries: open a clean doubao home and confirm no prior content.
+                // We intentionally avoid the url-action entrypoint because doubao
+                // cannot reliably open/fetch external URLs through it — the page says
+                // "无法打开外链".  Instead we open the composer, switch to expert mode
+                // (in ensure_mode), then type the full prompt including any URLs, which
+                // lets doubao's built-in link preview handle them natively.
+                inputReadyAfterOpen = await ensureFreshDoubaoHome(page, session.sessionId);
+                initialReplySnapshot = emptyDoubaoSnapshot();
+            }
+            else {
+                inputReadyAfterOpen = await openDoubaoHome(page, session.sessionId);
+            }
+            page.__cdperManagedPage = false;
+            await ensureMinimumPageDwell(Date.now(), 'doubao');
+        }, { timeoutMs: STATE_TIMEOUTS.open, retries: 1, retryable: (error) => /页面未准备好|输入框未出现|STATE_TIMEOUT/.test(String(error.message || '') + ' ' + String(error.code || '')) });
+        log('INFO', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: session.sessionId, step: 'flow', action: 'stage_complete', stage: 'open', status: 'ok' });
+        throwIfAborted(abortSignal, 'Doubao query');
+        await runState(flow, 'ensure_session', async () => {
+            if (inputReadyAfterOpen && await hasDoubaoInput(page, 1800))
+                return;
+            const existingInput = await hasDoubaoInput(page, 12000);
+            if (!existingInput) {
+                if (conversationPlan.effective === 'followup') {
+                    throw new Error('Doubao followup anchor opened but input was not ready; refusing to start a fresh chat');
+                }
+                await clickNewChat(page, { sessionId: session.sessionId });
+            }
+            if (!(await waitForDoubaoReady(page, { timeoutMs: 12000, sessionId: session.sessionId }))) {
+                throw new Error('Doubao 输入框未就绪');
+            }
+        }, { timeoutMs: STATE_TIMEOUTS.ensure_session });
+        log('INFO', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: session.sessionId, step: 'flow', action: 'stage_complete', stage: 'ensure_session', status: 'ok' });
+        throwIfAborted(abortSignal, 'Doubao query');
+        expertModeConfirmed = await runState(flow, 'ensure_mode', async () => {
+            // Fresh/followup queries always use the composer path; verify and switch
+            // to expert mode via the 快速→专家 menu before sending.
+            const confirmed = await switchToExpert(page, session.sessionId);
+            await assertNoChallenge(page, session.sessionId);
+            if (confirmed)
+                await waitForDoubaoModeSettled(page, { timeoutMs: 6000, sessionId: session.sessionId }).catch(() => false);
+            return confirmed;
+        }, { timeoutMs: STATE_TIMEOUTS.ensure_mode });
+        log('INFO', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: session.sessionId, step: 'flow', action: 'stage_complete', stage: 'ensure_mode', status: 'ok', ...buildDoubaoModeState(expertModeConfirmed), expertModeConfirmed });
+        // Block sending when expert mode could not be confirmed; composer path
+        // should not silently degrade into the quick model.
+        if (!expertModeConfirmed) {
+            log('WARN', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: session.sessionId, step: 'mode', action: 'expert_confirm', status: 'blocked', message: '未确认进入专家模式，停止发送以避免错误模式输出' });
+            throw new Error('Doubao 专家模式未确认，需要人工接管');
+        }
+        throwIfAborted(abortSignal, 'Doubao query');
+        await runState(flow, 'send', async () => {
+            const input = await hasDoubaoInput(page, 18000);
+            if (!input)
+                throw new Error('Doubao 输入框未就绪');
+            await assertNoChallenge(page, session.sessionId);
+            initialReplySnapshot = await captureDoubaoReplySnapshot(page).catch(() => null);
+            await clearDoubaoInput(page, input.handle);
+            await typeIntoDoubaoInput(page, input.handle, queryText);
+            await assertNoChallenge(page, session.sessionId);
+            await humanPause(900, 1800);
+            const clicked = await clickDoubaoSend(page);
+            if (!clicked)
+                await page.keyboard.press('Enter');
+            await assertNoChallenge(page, session.sessionId);
+            await humanPause(350, 900);
+            promptSubmitted = true;
+            // P1-3: Verify submission was accepted
+            const submitVerify = await verifySubmission(page, {
+                timeoutMs: 15000,
+                pollIntervalMs: 500,
+                baselineSnapshot: initialReplySnapshot,
+                captureUserTurn: async (page, baseline) => {
+                    const baselineCount = Number(baseline?.candidateCount || 0);
+                    return page.evaluate((bc) => {
+                        // Broad selector set matching smart_wait's selectBestDoubaoReplyText
+                        const replyContainers = document.querySelectorAll('[class*="flow-markdown-body"], [class*="container-P2rR72"],' +
+                            '[class*="mdbox-theme"], [class*="response"], [class*="answer"], .prose');
+                        return replyContainers.length > bc;
+                    }, baselineCount);
+                },
+                captureInputCleared: async (page) => {
+                    return page.evaluate(() => {
+                        const textarea = document.querySelector('textarea') || document.querySelector('[contenteditable="true"]');
+                        if (!textarea)
+                            return false;
+                        const val = textarea.value || textarea.innerText || '';
+                        return val.trim().length <= 5;
+                    });
+                },
+                captureGenerating: async (page) => {
+                    return page.evaluate(() => {
+                        const isVisible = (el) => {
+                            if (!el)
+                                return false;
+                            const rect = el.getBoundingClientRect();
+                            const style = window.getComputedStyle(el);
+                            return rect.width > 0 && rect.height > 0 && style.visibility !== 'hidden' && style.display !== 'none' && el.getAttribute('aria-hidden') !== 'true';
+                        };
+                        const stopBtn = Array.from(document.querySelectorAll('button,[role="button"]')).find((button) => {
+                            if (!isVisible(button) || button.disabled || button.getAttribute('aria-disabled') === 'true')
+                                return false;
+                            const text = button.innerText || '';
+                            const aria = button.getAttribute('aria-label') || '';
+                            return /停止生成|停止回答|Stop generating|stop-button/i.test(`${text} ${aria}`) || !!button.querySelector('svg[icon="stop"]');
+                        });
+                        const loading = Array.from(document.querySelectorAll('[class*="loading"], [class*="skeleton"], [class*="spinner"]')).find((element) => isVisible(element) && /loading|spinner|生成中|思考中|回答中/i.test(String(element.className || '') + ' ' + (element.innerText || '')));
+                        return !!stopBtn || !!loading;
+                    });
+                },
+            });
+            if (!submitVerify.accepted) {
+                flow.enter('send', { submitVerified: false, submitElapsed: submitVerify.elapsed });
+                const error = new Error('Doubao 消息未成功提交 (send_not_accepted)');
+                error.code = 'SEND_NOT_ACCEPTED';
+                throw error;
+            }
+            flow.enter('send', { submitVerified: true, submitSignal: submitVerify.signal, submitElapsed: submitVerify.elapsed });
+            log('INFO', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: session.sessionId, step: 'query', action: 'submit', status: 'ok', message: '问题已发送' });
+        }, { timeoutMs: computeSendTimeoutMs(queryText, STATE_TIMEOUTS.send) });
+        const result = await runState(flow, 'wait', () => waitForDoubaoReply(page, {
+            query: queryText, abortSignal, minWait: waitPlan.minWait, maxWait: waitPlan.maxWait, pollInterval: waitPlan.pollInterval,
+            stableThreshold: 4, enableCircuitBreaker: true, enableExtend: true, maxExtends: waitPlan.maxExtends,
+            acceptShortContent: prefersShortAnswer(queryText), minShortContentLength: 1,
+            onProgress: progressRecorder.onProgress, challengeCheckIntervalMs: 6000, initialReplySnapshot,
+        }), { timeoutMs: waitPlan.stateTimeoutMs });
+        if (!result?.content)
+            throw new Error('未获取到有效回复');
+        const wrapperStatus = result.wrapperStatus || result.exitReason;
+        if ([WRAPPER_STATUSES.CAPTCHA_REQUIRED, WRAPPER_STATUSES.CIRCUIT_BREAKER, 'challenge', 'circuit_breaker'].includes(wrapperStatus)) {
+            throw new Error('查询被阻断，需要人工接管: ' + wrapperStatus + (result.detectedChallenge ? ' (' + result.detectedChallenge + ')' : ''));
+        }
+        const completenessScore = result.completeness?.score || 0;
+        const contentMarkedIncomplete = result.completeness?.isComplete === false;
+        if (wrapperStatus === WRAPPER_STATUSES.PARTIAL_TIMEOUT && result.content) {
+            return buildWrapperResult({
+                status: WRAPPER_STATUSES.PARTIAL_TIMEOUT,
+                content: result.content,
+                exitReason: result.exitReason,
+                diagnostics: { pillars: result.pillars, completeness: result.completeness },
+                platform: 'doubao',
+            });
+        }
+        activeSession = await runState(flow, 'extract', async () => {
+            const conversation = buildConversationAnchor(PLATFORM, page.url(), getDoubaoConversationId, conversationPlan.effective);
+            return updateSession(session.sessionId, { turns: session.turns + 1, conversation });
+        }, { timeoutMs: STATE_TIMEOUTS.extract });
+        const modeState = buildDoubaoModeState(expertModeConfirmed);
+        const contentIsComplete = result.completeness?.isComplete === true;
+        const finalStatus = ['complete', 'complete_short'].includes(result.exitReason) && contentIsComplete ? 'ok' : 'degraded';
+        log('INFO', '[doubao]', { component: 'doubao', plugin: 'cdper-doubao', session_id: session.sessionId, step: 'query', action: 'complete', status: finalStatus, message: '回复完成：' + result.content.length + ' 字，完整度 ' + (result.completeness?.score || 0) + '分，exitReason=' + (result.exitReason || 'unknown') });
+        return buildPluginSuccess({
+            pluginName: 'doubao',
+            session: activeSession,
+            flow,
+            runtimeStatus: await getRuntimeStatus('doubao'),
+            doneMeta: { status: finalStatus, turn: activeSession.turns, ...modeState, expertModeConfirmed, conversationPolicy: conversationPlan.effective },
+            payload: {
+                content: result.content,
+                score: completenessScore,
+                completeness: result.completeness || null,
+                status: finalStatus,
+                fallback: fallbackMeta,
+                exitReason: result.exitReason || 'unknown',
+                ...modeState,
+                expertModeConfirmed,
+                detectedChallenge: result.detectedChallenge || null,
+                conversationPolicy: conversationPlan.requested,
+                effectiveConversationPolicy: conversationPlan.effective,
+                conversation: activeSession.conversation || null,
+                waitPlan: { expectedDuration: waitPlan.expectedDuration, minWait: waitPlan.minWait, maxWait: waitPlan.maxWait, maxExtends: waitPlan.maxExtends, pollInterval: waitPlan.pollInterval, elapsed: result.elapsed, extendCount: result.extendCount },
+                progress: progressRecorder.events,
+            },
+        });
+    }
+    catch (error) {
+        return handlePluginQueryError(error, {
+            flow, pluginName: 'doubao', retried: _retried,
+            retryFn: () => queryDoubao(queryText, { ...opts, _retried: true }),
+            failedMeta: { error: error.message, conversationPolicy: conversationPlan.effective, promptSubmitted },
+        });
+    }
+    finally {
+        if (page || browser)
+            await disconnect(page, browser);
+    }
+}
+module.exports = { queryDoubao };