import type { JsonValue, MonitoringSourceItem } from '@geo/shared-types'
import type { Page as PlaywrightPage, Response as PlaywrightResponse } from 'playwright-core'

import type { MonitorAdapter } from './base'
import { normalizeText } from './common'

const YUANBAO_BOOTSTRAP_URL = 'https://yuanbao.tencent.com/'
const YUANBAO_PAGE_READY_TIMEOUT_MS = 20_000
const YUANBAO_QUERY_TIMEOUT_MS = 120_000
const YUANBAO_CAPTURE_LIMIT = 96
const YUANBAO_CAPTURE_BODY_LIMIT = 1_200_000
const YUANBAO_CAPTURE_FLUSH_TIMEOUT_MS = 20_000
// Match both formats so we tolerate either side of the migration without breaking:
//   - "[citation:N]" — emitted by the legacy yuanbao SSE protocol and what older
//     captures / fixtures still contain.
//   - "[N]" — emitted by the new model (DOM places <div data-idx-list="N,M,..."/>
//     placeholders inline; we now lower them to bare "[N]" markers, which is also
//     the format DeepSeek answers carry through to the SaaS side).
const YUANBAO_CITATION_MARKER_PATTERN = /\[(?:citation:\s*)?(\d+)\]/gi
const YUANBAO_LEGACY_CITATION_MARKER_PATTERN = /\[citation:\s*(\d+)\]/gi
const WINDOWS_1252_REVERSE_MAP = new Map<number, number>([
  [0x20ac, 0x80],
  [0x201a, 0x82],
  [0x0192, 0x83],
  [0x201e, 0x84],
  [0x2026, 0x85],
  [0x2020, 0x86],
  [0x2021, 0x87],
  [0x02c6, 0x88],
  [0x2030, 0x89],
  [0x0160, 0x8a],
  [0x2039, 0x8b],
  [0x0152, 0x8c],
  [0x017d, 0x8e],
  [0x2018, 0x91],
  [0x2019, 0x92],
  [0x201c, 0x93],
  [0x201d, 0x94],
  [0x2022, 0x95],
  [0x2013, 0x96],
  [0x2014, 0x97],
  [0x02dc, 0x98],
  [0x2122, 0x99],
  [0x0161, 0x9a],
  [0x203a, 0x9b],
  [0x0153, 0x9c],
  [0x017e, 0x9e],
  [0x0178, 0x9f],
])

type YuanbaoCaptureRecord = {
  url: string
  status: number
  contentType: string | null
  body: string
}

type YuanbaoDomLink = {
  url: string
  title: string | null
  text: string | null
  siteName: string | null
  sourceIndex: number | null
}

type YuanbaoPageQuerySuccessResult = {
  ok: true
  url: string
  title: string | null
  modelLabel: string | null
  deepThinkEnabled: boolean | null
  webSearchEnabled: boolean | null
  domAnswer: string | null
  domLinks: YuanbaoDomLink[]
  inlineCitationIndexes: number[]
}

type YuanbaoPageQueryFailureResult = {
  ok: false
  error: string
  detail: string | null
  url: string | null
  title: string | null
  modelLabel: string | null
  deepThinkEnabled: boolean | null
  webSearchEnabled: boolean | null
  domAnswer: string | null
  domLinks: YuanbaoDomLink[]
  inlineCitationIndexes: number[]
}

type YuanbaoPageQueryResult = YuanbaoPageQuerySuccessResult | YuanbaoPageQueryFailureResult

type YuanbaoSummary = {
  answer: string | null
  reasoning: string | null
  providerModel: string | null
  providerRequestID: string | null
  requestID: string | null
  conversationID: string | null
  citations: MonitoringSourceItem[]
  searchResults: MonitoringSourceItem[]
  candidateCount: number
  contentTypes: Set<string>
}

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === 'object' && value !== null && !Array.isArray(value)
}

function normalizeOptionalString(value: unknown): string | null {
  if (typeof value !== 'string') {
    return null
  }
  const trimmed = value.trim()
  return trimmed ? trimmed : null
}

function countHanCharacters(value: string): number {
  const matched = value.match(/[\u3400-\u9fff]/g)
  return matched?.length ?? 0
}

function countSuspiciousMojibakeCharacters(value: string): number {
  const matched = value.match(/[\u00a0-\u017f\u02c0-\u02ff\u2000-\u20ff]/g)
  return matched?.length ?? 0
}

function looksLikeMojibake(value: string): boolean {
  const normalized = value.trim()
  if (!normalized) {
    return false
  }

  if (
    normalized.includes('Ã') ||
    normalized.includes('â€') ||
    normalized.includes('ï¼') ||
    normalized.includes('ã€')
  ) {
    return true
  }

  const hanCount = countHanCharacters(normalized)
  const suspiciousCount = countSuspiciousMojibakeCharacters(normalized)
  if (hanCount > 0) {
    return suspiciousCount >= 8 && suspiciousCount > hanCount * 3
  }
  return suspiciousCount >= 4
}

function repairPotentialMojibake(value: string | null): string | null {
  const normalized = normalizeOptionalString(value)
  if (!normalized || !looksLikeMojibake(normalized)) {
    return value
  }

  try {
    const bytes = Uint8Array.from(
      Array.from(normalized, (char) => {
        const codePoint = char.codePointAt(0) ?? 0
        const mapped = WINDOWS_1252_REVERSE_MAP.get(codePoint)
        if (mapped !== undefined) {
          return mapped
        }
        if (codePoint <= 0xff) {
          return codePoint
        }
        throw new Error('non_windows_1252_codepoint')
      }),
    )
    const repaired = new TextDecoder('utf-8').decode(bytes)
    const originalHanCount = countHanCharacters(normalized)
    const repairedHanCount = countHanCharacters(repaired)
    const originalSuspiciousCount = countSuspiciousMojibakeCharacters(normalized)
    const repairedSuspiciousCount = countSuspiciousMojibakeCharacters(repaired)

    if (
      repairedHanCount > originalHanCount ||
      (repairedHanCount > 0 && repairedSuspiciousCount * 2 < originalSuspiciousCount)
    ) {
      return repaired
    }
  } catch {
    return value
  }

  return value
}

function decodeResponseBody(buffer: Buffer): string {
  const decoded = new TextDecoder('utf-8').decode(buffer)
  return repairPotentialMojibake(decoded) ?? decoded
}

function extractCitationMarkerIndexes(value: string | null): number[] {
  const normalized = normalizeOptionalString(value)
  if (!normalized) {
    return []
  }

  const indexes: number[] = []
  const seen = new Set<number>()
  for (const matched of normalized.matchAll(YUANBAO_CITATION_MARKER_PATTERN)) {
    const index = Number.parseInt(matched[1] ?? '', 10)
    if (!Number.isFinite(index) || index < 1 || seen.has(index)) {
      continue
    }
    seen.add(index)
    indexes.push(index)
  }
  return indexes
}

// Normalise legacy "[citation:N]" markers (still emitted by some SSE frames)
// to "[N]" so the SaaS front-end can render the same superscript chip as
// DeepSeek answers — without that, mixed sources show two unrelated formats.
function normalizeCitationMarkers(value: string | null): string | null {
  if (value == null) {
    return value
  }
  return value.replace(YUANBAO_LEGACY_CITATION_MARKER_PATTERN, '[$1]')
}

function looksLikeNonAnswerNoise(value: string): boolean {
  const trimmed = value.trim()
  if (!trimmed) {
    return true
  }

  const hanCount = countHanCharacters(trimmed)
  const suspiciousCount = countSuspiciousMojibakeCharacters(trimmed)
  if (hanCount === 0) {
    if (suspiciousCount >= 4) {
      return true
    }
    const codePointLength = [...trimmed].length
    return suspiciousCount >= 2 && suspiciousCount * 2 >= codePointLength
  }
  return suspiciousCount >= 8 && suspiciousCount > hanCount * 3
}

function answerQualityScore(value: string | null): number {
  const normalized = normalizeOptionalString(value)
  if (!normalized) {
    return Number.NEGATIVE_INFINITY
  }

  const hanCount = countHanCharacters(normalized)
  const suspiciousCount = countSuspiciousMojibakeCharacters(normalized)
  return (
    hanCount * 8 -
    suspiciousCount * 6 +
    Math.min(normalized.length, 400) +
    extractCitationMarkerIndexes(normalized).length * 12
  )
}

const STREAMING_FRAGMENT_MAX_LENGTH = 6
const STREAMING_FRAGMENT_RUN_THRESHOLD = 10
const STREAMING_FALLBACK_MIN_CONTENT_CHARS = 120
const STREAMING_MARKDOWN_STRUCTURE_PATTERN =
  /^(?:#{1,6}\s|[*\-+•]\s|\d+[.、]\s?|>\s?|\|\s?|```|---|===|\*\*)/

function isLikelyStreamingFragmentLine(line: string): boolean {
  const trimmed = line.trim()
  if (!trimmed) {
    return false
  }
  if ([...trimmed].length > STREAMING_FRAGMENT_MAX_LENGTH) {
    return false
  }
  if (STREAMING_MARKDOWN_STRUCTURE_PATTERN.test(trimmed)) {
    return false
  }
  if (/^[\-=_*]{2,}$/.test(trimmed)) {
    return false
  }
  return true
}

function collapseTokenFragmentRuns(value: string): string {
  if (!value.includes('\n')) {
    return value
  }

  const rawLines = value.split('\n')
  type Segment = { type: 'content' | 'fragments'; lines: string[] }
  const segments: Segment[] = []
  let fragmentBuffer: string[] = []

  const pushContent = (line: string) => {
    const last = segments[segments.length - 1]
    if (last && last.type === 'content') {
      last.lines.push(line)
    } else {
      segments.push({ type: 'content', lines: [line] })
    }
  }

  const flushFragments = () => {
    if (!fragmentBuffer.length) {
      return
    }
    if (fragmentBuffer.length >= STREAMING_FRAGMENT_RUN_THRESHOLD) {
      segments.push({ type: 'fragments', lines: fragmentBuffer })
    } else {
      for (const buffered of fragmentBuffer) {
        pushContent(buffered)
      }
    }
    fragmentBuffer = []
  }

  for (const line of rawLines) {
    if (isLikelyStreamingFragmentLine(line)) {
      fragmentBuffer.push(line)
    } else {
      flushFragments()
      pushContent(line)
    }
  }
  flushFragments()

  const contentCharCount = segments
    .filter((segment) => segment.type === 'content')
    .reduce(
      (total, segment) => total + segment.lines.reduce((acc, line) => acc + line.trim().length, 0),
      0,
    )
  const keepFragmentsAsFallback = contentCharCount < STREAMING_FALLBACK_MIN_CONTENT_CHARS

  const output: string[] = []
  for (const segment of segments) {
    if (segment.type === 'content') {
      output.push(...segment.lines)
    } else if (keepFragmentsAsFallback) {
      output.push(segment.lines.map((line) => line.trim()).join(''))
    }
  }

  return output.join('\n')
}

function sanitizeAnswerCandidate(value: string | null): string | null {
  const normalized = normalizeOptionalString(value)
  if (!normalized) {
    return null
  }

  const repaired = repairPotentialMojibake(normalized) ?? normalized
  const collapsed = collapseTokenFragmentRuns(repaired)
  const lines = collapsed.split(/\r?\n/)
  if (lines.length <= 1) {
    return collapsed
  }

  const keptLines = lines.filter((line) => !line.trim() || !looksLikeNonAnswerNoise(line.trim()))
  if (!keptLines.some((line) => line.trim())) {
    return collapsed
  }

  return (
    keptLines
      .join('\n')
      .replace(/\n{3,}/g, '\n\n')
      .trim() || collapsed
  )
}

function selectBestAnswerText(
  parsedAnswer: string | null,
  domAnswer: string | null,
): string | null {
  const parsed = sanitizeAnswerCandidate(parsedAnswer)
  const dom = sanitizeAnswerCandidate(domAnswer)
  if (!parsed) {
    return dom
  }
  if (!dom) {
    return parsed
  }
  return parsed
}

function resolveCitationsFromMarkers(
  answerText: string | null,
  pools: MonitoringSourceItem[][],
): MonitoringSourceItem[] {
  const indexes = extractCitationMarkerIndexes(answerText)
  if (!indexes.length) {
    return []
  }

  const maxIndex = Math.max(...indexes)
  const candidates = pools.filter((pool) => pool.length > 0)
  const resolvedPool = candidates.find((pool) => pool.length >= maxIndex) ?? candidates[0] ?? []
  return indexes
    .map((index) => resolvedPool[index - 1] ?? null)
    .filter((item): item is MonitoringSourceItem => item !== null)
}

function sharedBoundaryLength(left: string, right: string): number {
  const maxLength = Math.min(left.length, right.length)
  for (let length = maxLength; length >= 8; length -= 1) {
    if (left.slice(left.length - length) === right.slice(0, length)) {
      return length
    }
  }
  return 0
}

function sharedPrefixLength(left: string, right: string): number {
  const maxLength = Math.min(left.length, right.length)
  let length = 0
  while (length < maxLength && left[length] === right[length]) {
    length += 1
  }
  return length
}

function mergeText(current: string | null, nextFragment: string | null): string | null {
  if (!nextFragment) {
    return current
  }
  if (!current) {
    return nextFragment
  }
  if (current === nextFragment || current.includes(nextFragment)) {
    return current
  }
  if (nextFragment.startsWith(current)) {
    return nextFragment
  }

  const forwardOverlap = sharedBoundaryLength(current, nextFragment)
  if (forwardOverlap > 0) {
    return `${current}${nextFragment.slice(forwardOverlap)}`
  }

  const reverseOverlap = sharedBoundaryLength(nextFragment, current)
  if (reverseOverlap > 0) {
    return `${nextFragment}${current.slice(reverseOverlap)}`
  }

  const commonPrefixLength = sharedPrefixLength(current, nextFragment)
  const duplicatePrefixThreshold = Math.max(
    16,
    Math.min(80, Math.floor(Math.min(current.length, nextFragment.length) * 0.45)),
  )
  if (commonPrefixLength >= duplicatePrefixThreshold) {
    return answerQualityScore(nextFragment) > answerQualityScore(current) ? nextFragment : current
  }

  return `${current}${nextFragment}`
}

function getDirectString(record: Record<string, unknown>, keys: string[]): string | null {
  for (const key of keys) {
    const value = normalizeOptionalString(record[key])
    if (value) {
      return value
    }
  }
  return null
}

function getDirectTextFragment(record: Record<string, unknown>, keys: string[]): string | null {
  for (const key of keys) {
    const value = record[key]
    if (typeof value === 'string' && value.length > 0) {
      return value
    }
  }
  return null
}

function normalizeSourceUrl(value: string | null): string | null {
  const input = normalizeText(value)
  if (!input) {
    return null
  }

  try {
    const url = new URL(input)
    for (const key of [
      'url',
      'u',
      'target',
      'target_url',
      'targetUrl',
      'redirect',
      'redirect_url',
      'redirectUrl',
      'jump_url',
      'jumpUrl',
      'link',
    ]) {
      const nested = normalizeText(url.searchParams.get(key))
      if (!nested || nested === input || !/^https?:\/\//i.test(nested)) {
        continue
      }
      const unwrapped = normalizeSourceUrl(nested)
      if (unwrapped) {
        return unwrapped
      }
    }
    url.hash = ''
    return url.toString()
  } catch {
    return input
  }
}

function isYuanbaoInternalUrl(value: string): boolean {
  try {
    const host = new URL(value).hostname.toLowerCase()
    return host === 'yuanbao.tencent.com' || host.endsWith('.yuanbao.tencent.com')
  } catch {
    return false
  }
}

function buildSourceItem(input: unknown): MonitoringSourceItem | null {
  if (typeof input === 'string') {
    const url = normalizeSourceUrl(input)
    return url ? { url, normalized_url: url } : null
  }

  if (!isRecord(input)) {
    return null
  }

  const url = normalizeSourceUrl(
    getDirectString(input, [
      'url',
      'link',
      'href',
      'uri',
      'source_url',
      'sourceUrl',
      'page_url',
      'pageUrl',
      'jump_url',
      'jumpUrl',
      'target_url',
      'targetUrl',
      'target',
      'doc_url',
      'docUrl',
      'document_url',
      'documentUrl',
      'article_url',
      'articleUrl',
      'web_url',
      'webUrl',
      'webpage_url',
      'webpageUrl',
      'url_pc',
      'urlPc',
      'pc_url',
      'pcUrl',
      'mobile_url',
      'mobileUrl',
      'link_url',
      'linkUrl',
      'ori_url',
      'oriUrl',
      'original_url',
      'originalUrl',
    ]),
  )
  if (!url || isYuanbaoInternalUrl(url)) {
    return null
  }

  let host: string | null = null
  try {
    host = new URL(url).hostname || null
  } catch {
    host = null
  }

  return {
    url,
    title: repairPotentialMojibake(
      getDirectString(input, ['title', 'name', 'page_title', 'display_title', 'text']),
    ),
    site_name: repairPotentialMojibake(
      getDirectString(input, [
        'site_name',
        'siteName',
        'source',
        'platform_name',
        'site',
        'domain',
      ]),
    ),
    site_key: getDirectString(input, ['site_key', 'siteKey', 'domain_key']),
    normalized_url: url,
    host,
    resolution_status: repairPotentialMojibake(
      getDirectString(input, ['resolution_status', 'resolutionStatus']),
    ),
    resolution_confidence: repairPotentialMojibake(
      getDirectString(input, ['resolution_confidence', 'resolutionConfidence']),
    ),
  }
}

function dedupeSourceItems(items: MonitoringSourceItem[]): MonitoringSourceItem[] {
  const keyed = new Map<string, MonitoringSourceItem>()
  for (const item of items) {
    const key = normalizeSourceUrl(item.normalized_url ?? item.url)
    if (!key) {
      continue
    }

    const existing = keyed.get(key)
    if (!existing) {
      keyed.set(key, {
        ...item,
        normalized_url: key,
      })
      continue
    }

    keyed.set(key, {
      ...existing,
      title: existing.title ?? item.title ?? null,
      site_name: existing.site_name ?? item.site_name ?? null,
      site_key: existing.site_key ?? item.site_key ?? null,
      host: existing.host ?? item.host ?? null,
      resolution_status: existing.resolution_status ?? item.resolution_status ?? null,
      resolution_confidence: existing.resolution_confidence ?? item.resolution_confidence ?? null,
    })
  }

  return Array.from(keyed.values())
}

function appendUniqueSourceItems(
  primaryItems: MonitoringSourceItem[],
  extraItems: MonitoringSourceItem[],
): MonitoringSourceItem[] {
  const output = [...primaryItems]
  const seen = new Set<string>()
  for (const item of primaryItems) {
    const key = normalizeSourceUrl(item.normalized_url ?? item.url)
    if (key) {
      seen.add(key)
    }
  }

  for (const item of extraItems) {
    const key = normalizeSourceUrl(item.normalized_url ?? item.url)
    if (!key || seen.has(key)) {
      continue
    }
    seen.add(key)
    output.push({
      ...item,
      normalized_url: key,
    })
  }

  return output
}

function buildOrderedDomSourceItems(links: YuanbaoDomLink[]): MonitoringSourceItem[] {
  const indexedItems = new Map<number, MonitoringSourceItem>()
  const fallbackItems: MonitoringSourceItem[] = []

  for (const link of links) {
    const sourceItem = buildSourceItem(link)
    if (!sourceItem) {
      continue
    }

    const sourceIndex = link.sourceIndex
    if (sourceIndex !== null && Number.isFinite(sourceIndex) && sourceIndex > 0) {
      if (!indexedItems.has(sourceIndex)) {
        indexedItems.set(sourceIndex, sourceItem)
      }
      continue
    }

    fallbackItems.push(sourceItem)
  }

  if (!indexedItems.size) {
    return dedupeSourceItems(fallbackItems)
  }

  const maxIndex = Math.max(...indexedItems.keys())
  const hasContiguousIndexes = Array.from({ length: maxIndex }, (_, index) => index + 1).every(
    (index) => indexedItems.has(index),
  )

  if (!hasContiguousIndexes) {
    return dedupeSourceItems([
      ...Array.from(indexedItems.entries())
        .sort(([left], [right]) => left - right)
        .map(([, item]) => item),
      ...fallbackItems,
    ])
  }

  return Array.from({ length: maxIndex }, (_, index) => indexedItems.get(index + 1)).filter(
    (item): item is MonitoringSourceItem => item !== undefined,
  )
}

function findUnresolvedCitationIndexes(
  answerText: string | null,
  citations: MonitoringSourceItem[],
): number[] {
  const unresolved: number[] = []
  const seen = new Set<number>()
  for (const index of extractCitationMarkerIndexes(answerText)) {
    if (seen.has(index)) {
      continue
    }
    seen.add(index)
    if (!citations[index - 1]) {
      unresolved.push(index)
    }
  }
  return unresolved
}

function toJsonSources(items: MonitoringSourceItem[]): JsonValue[] {
  return items.map((item) => ({
    url: item.url,
    title: item.title ?? null,
    site_name: item.site_name ?? null,
    site_key: item.site_key ?? null,
    normalized_url: item.normalized_url ?? null,
    host: item.host ?? null,
    registrable_domain: item.registrable_domain ?? null,
    subdomain: item.subdomain ?? null,
    suffix: item.suffix ?? null,
    article_id: item.article_id ?? null,
    publish_record_id: item.publish_record_id ?? null,
    resolution_status: item.resolution_status ?? null,
    resolution_confidence: item.resolution_confidence ?? null,
  }))
}

function buildAdapterError(
  code: string,
  message: string,
  extras: Record<string, JsonValue> = {},
): Record<string, JsonValue> {
  return {
    code,
    message,
    ...extras,
  }
}

function looksLikeRuntimeDiagnosticQuestion(value: string): boolean {
  return (
    /^The resource https?:\/\/localhost:[^\s]+ was preloaded using link preload/i.test(value) ||
    /^failed to solve:/i.test(value) ||
    /did not complete successfully:\s*exit code:\s*\d+/i.test(value)
  )
}

function extractQuestionText(payload: Record<string, unknown>): string {
  const candidates = [
    payload.question_text,
    payload.questionText,
    payload.query,
    payload.question,
    payload.prompt,
    payload.content,
  ]

  let rejectedDiagnostic = false
  for (const candidate of candidates) {
    const text = normalizeOptionalString(candidate)
    if (!text) {
      continue
    }
    if (looksLikeRuntimeDiagnosticQuestion(text)) {
      rejectedDiagnostic = true
      continue
    }
    return text
  }

  if (rejectedDiagnostic) {
    throw new Error('yuanbao_question_text_runtime_diagnostic')
  }
  throw new Error('yuanbao_question_text_missing')
}

async function sleep(ms: number, signal?: AbortSignal): Promise<void> {
  await new Promise<void>((resolve, reject) => {
    if (signal?.aborted) {
      reject(new Error('adapter_aborted'))
      return
    }

    const timer = setTimeout(() => {
      signal?.removeEventListener('abort', onAbort)
      resolve()
    }, ms)

    const onAbort = () => {
      clearTimeout(timer)
      reject(new Error('adapter_aborted'))
    }

    signal?.addEventListener('abort', onAbort, { once: true })
  })
}

async function ensurePageOnYuanbaoChat(page: PlaywrightPage, signal: AbortSignal): Promise<void> {
  if (signal.aborted) {
    throw new Error('adapter_aborted')
  }

  const currentURL = safePageURL(page)
  if (!currentURL.startsWith('https://yuanbao.tencent.com/')) {
    await page.goto(YUANBAO_BOOTSTRAP_URL, {
      waitUntil: 'domcontentloaded',
      timeout: YUANBAO_PAGE_READY_TIMEOUT_MS,
    })
  }

  await page
    .waitForLoadState('domcontentloaded', {
      timeout: YUANBAO_PAGE_READY_TIMEOUT_MS,
    })
    .catch(() => undefined)
  await page.waitForLoadState('networkidle', { timeout: 3_000 }).catch(() => undefined)

  if (signal.aborted) {
    throw new Error('adapter_aborted')
  }
}

function safePageURL(page: PlaywrightPage): string {
  try {
    return page.url()
  } catch {
    return ''
  }
}

function isCurrentYuanbaoChatSSE(
  url: string,
  method: string,
  contentType: string | null,
  requestBody: string | null,
  questionText: string,
): boolean {
  if (method.toUpperCase() !== 'POST' || !contentType || !/text\/event-stream/i.test(contentType)) {
    return false
  }

  try {
    const parsedURL = new URL(url)
    if (
      parsedURL.hostname !== 'yuanbao.tencent.com' ||
      !/^\/api\/chat\/[^/]+\/?$/.test(parsedURL.pathname)
    ) {
      return false
    }
  } catch {
    return false
  }

  if (!requestBody) {
    return false
  }

  try {
    const payload = JSON.parse(requestBody) as unknown
    if (!isRecord(payload)) {
      return false
    }
    const expected = normalizeText(questionText)
    const candidates = [payload.prompt, payload.displayPrompt]
      .map((value) => normalizeText(value))
      .filter((value): value is string => value !== null)
    return Boolean(expected && candidates.some((candidate) => candidate === expected))
  } catch {
    return false
  }
}

function attachYuanbaoResponseCapture(
  page: PlaywrightPage,
  questionText: string,
): {
  captures: YuanbaoCaptureRecord[]
  flush: (timeoutMs: number) => Promise<void>
  pendingCount: () => number
  dispose: () => void
} {
  const captures: YuanbaoCaptureRecord[] = []
  const pending = new Set<Promise<void>>()

  const pushCapture = (record: YuanbaoCaptureRecord) => {
    captures.push({
      ...record,
      body:
        record.body.length > YUANBAO_CAPTURE_BODY_LIMIT
          ? record.body.slice(0, YUANBAO_CAPTURE_BODY_LIMIT)
          : record.body,
    })
    if (captures.length > YUANBAO_CAPTURE_LIMIT) {
      captures.splice(0, captures.length - YUANBAO_CAPTURE_LIMIT)
    }
  }

  const responseHandler = (response: PlaywrightResponse) => {
    const url = normalizeOptionalString(response.url())
    if (!url) {
      return
    }

    const headers = response.headers()
    const contentType = normalizeOptionalString(headers['content-type']) ?? null
    const request = response.request()
    if (
      !isCurrentYuanbaoChatSSE(url, request.method(), contentType, request.postData(), questionText)
    ) {
      return
    }

    const task = response
      .body()
      .then((body) => {
        const normalizedBody = normalizeOptionalString(decodeResponseBody(body)) ?? ''
        pushCapture({
          url,
          status: response.status(),
          contentType,
          body: normalizedBody,
        })
      })
      .catch(() => undefined)
    pending.add(task)
    void task.finally(() => {
      pending.delete(task)
    })
  }

  page.on('response', responseHandler)

  return {
    captures,
    async flush(timeoutMs: number) {
      const deadline = Date.now() + timeoutMs
      while (pending.size > 0 && Date.now() < deadline) {
        const snapshot = Array.from(pending)
        const remaining = Math.max(0, deadline - Date.now())
        await Promise.race([
          Promise.allSettled(snapshot),
          new Promise<void>((resolve) => {
            setTimeout(resolve, remaining)
          }),
        ])
      }
    },
    pendingCount() {
      return pending.size
    },
    dispose() {
      page.off('response', responseHandler)
    },
  }
}

function extractJSONCandidates(body: string): unknown[] {
  const values: unknown[] = []
  const seen = new Set<string>()

  const pushParsed = (raw: string) => {
    const normalized = raw.trim()
    if (!normalized || seen.has(normalized)) {
      return
    }
    try {
      values.push(JSON.parse(normalized))
      seen.add(normalized)
    } catch {
      // Ignore malformed frames and continue with the remaining candidates.
    }
  }

  pushParsed(body)

  for (const rawLine of body.split(/\r?\n/)) {
    const line = rawLine.trim()
    if (!line) {
      continue
    }
    if (line.startsWith('data:')) {
      const value = line.slice(5).trim()
      if (value && value !== '[DONE]') {
        pushParsed(value)
      }
      continue
    }
    if (line.startsWith('{') || line.startsWith('[')) {
      pushParsed(line)
    }
  }

  return values
}

function collectSourceBucket(input: unknown, bucket: MonitoringSourceItem[]): void {
  if (input == null) {
    return
  }

  if (Array.isArray(input)) {
    for (const item of input) {
      collectSourceBucket(item, bucket)
    }
    return
  }

  const sourceItem = buildSourceItem(input)
  if (sourceItem) {
    bucket.push(sourceItem)
  }

  if (!isRecord(input)) {
    return
  }

  for (const value of Object.values(input)) {
    if (Array.isArray(value) || isRecord(value)) {
      collectSourceBucket(value, bucket)
    }
  }
}

function resolveYuanbaoSourceFieldBucket(key: string): 'citation' | 'search' | null {
  if (
    /^(?:citations?|citationInfo|citationList|ref_docs|refDocs|references?|referenceList|referenceDocs)$/i.test(
      key,
    )
  ) {
    return 'citation'
  }
  if (
    /^(?:docs?|docList|doc_list|sources?|sourceList|searchResults?|search_results|webResults?|web_results|webPages?|web_pages|pages?|pageList|thinkDeepSections)$/i.test(
      key,
    )
  ) {
    return 'search'
  }
  return null
}

function walkYuanbaoPayload(
  value: unknown,
  summary: YuanbaoSummary,
  depth = 0,
  allowAnswer = false,
): void {
  if (depth > 12 || value == null) {
    return
  }

  if (Array.isArray(value)) {
    for (const item of value) {
      walkYuanbaoPayload(item, summary, depth + 1, false)
    }
    return
  }

  if (!isRecord(value)) {
    return
  }

  summary.providerModel =
    summary.providerModel ??
    getDirectString(value, ['chatModelId', 'chat_model_id', 'model', 'modelName', 'model_name'])
  summary.providerRequestID =
    summary.providerRequestID ??
    getDirectString(value, ['traceID', 'traceId', 'request_id', 'requestId', 'msgId', 'msg_id'])
  summary.requestID =
    summary.requestID ??
    getDirectString(value, ['request_id', 'requestId', 'traceID', 'traceId', 'msgId', 'msg_id'])
  summary.conversationID =
    summary.conversationID ??
    getDirectString(value, ['conversationId', 'conversation_id', 'chatId', 'chat_id'])

  const type = getDirectString(value, ['type'])
  if (type) {
    summary.contentTypes.add(type)
    switch (type) {
      case 'text':
        if (allowAnswer) {
          summary.answer = mergeText(
            summary.answer,
            getDirectTextFragment(value, ['msg', 'text', 'content']),
          )
        }
        break
      case 'think':
        summary.reasoning = mergeText(
          summary.reasoning,
          getDirectString(value, ['content', 'msg', 'text']),
        )
        break
      case 'searchGuid':
        // The new hunyuan_t1 deep-search SSE places EVERY citable reference in
        // `docs[]` (each entry carries a 1-based `index` that aligns with the
        // answer's `[N]` markers), and the legacy `citations` field is now
        // always `null`. Promote `docs` into both buckets — the citations
        // bucket preserves array order so `citations[index - 1]` matches the
        // marker, while the search-results bucket keeps the existing
        // `dom_reference_links` semantics for downstream consumers.
        collectSourceBucket(value.docs, summary.citations)
        collectSourceBucket(value.docs, summary.searchResults)
        collectSourceBucket(value.citations, summary.citations)
        break
      case 'toolCall':
        collectSourceBucket(value.docs, summary.searchResults)
        collectSourceBucket(value.ref_docs, summary.citations)
        break
      case 'thinkDeep':
        summary.reasoning = mergeText(
          summary.reasoning,
          getDirectString(value, ['content', 'msg', 'text']),
        )
        collectSourceBucket(value.thinkDeepSections, summary.citations)
        break
      case 'deepSearch':
        walkYuanbaoPayload(value.contents, summary, depth + 1, false)
        break
      case 'step':
        collectSourceBucket(value.thinkDeepSections, summary.citations)
        break
      default:
        break
    }
  }

  for (const [key, nested] of Object.entries(value)) {
    const bucket = resolveYuanbaoSourceFieldBucket(key)
    if (!bucket) {
      continue
    }
    collectSourceBucket(nested, bucket === 'citation' ? summary.citations : summary.searchResults)
  }

  if (Array.isArray(value.content)) {
    walkYuanbaoPayload(value.content, summary, depth + 1, false)
  }
  if (Array.isArray(value.contents)) {
    walkYuanbaoPayload(value.contents, summary, depth + 1, false)
  }
  if (Array.isArray(value.speechesV2)) {
    walkYuanbaoPayload(value.speechesV2, summary, depth + 1, false)
  }
  if (Array.isArray(value.convs)) {
    walkYuanbaoPayload(value.convs, summary, depth + 1, false)
  }
  if (Array.isArray(value.docs)) {
    walkYuanbaoPayload(value.docs, summary, depth + 1, false)
  }
  if (Array.isArray(value.citations)) {
    walkYuanbaoPayload(value.citations, summary, depth + 1, false)
  }
  if (Array.isArray(value.ref_docs)) {
    walkYuanbaoPayload(value.ref_docs, summary, depth + 1, false)
  }
  if (Array.isArray(value.thinkDeepSections)) {
    walkYuanbaoPayload(value.thinkDeepSections, summary, depth + 1, false)
  }
  if (Array.isArray(value.list)) {
    walkYuanbaoPayload(value.list, summary, depth + 1, false)
  }

  for (const nested of Object.values(value)) {
    if (Array.isArray(nested) || isRecord(nested)) {
      walkYuanbaoPayload(nested, summary, depth + 1, false)
    }
  }
}

function parseYuanbaoCaptures(captures: YuanbaoCaptureRecord[]): YuanbaoSummary {
  const summary: YuanbaoSummary = {
    answer: null,
    reasoning: null,
    providerModel: null,
    providerRequestID: null,
    requestID: null,
    conversationID: null,
    citations: [],
    searchResults: [],
    candidateCount: 0,
    contentTypes: new Set<string>(),
  }

  for (const capture of captures) {
    if (!capture.body) {
      continue
    }

    const candidates = extractJSONCandidates(capture.body)
    summary.candidateCount += candidates.length
    for (const candidate of candidates) {
      walkYuanbaoPayload(candidate, summary, 0, true)
    }
  }

  summary.citations = dedupeSourceItems(summary.citations)
  summary.searchResults = dedupeSourceItems(summary.searchResults)
  return summary
}

function extractConversationID(url: string | null): string | null {
  const input = normalizeText(url)
  if (!input) {
    return null
  }

  try {
    const parsed = new URL(input)
    const matched = parsed.pathname.match(/\/chat\/([^/?#]+)/i)
    return matched?.[1]?.trim() || null
  } catch {
    return null
  }
}

function resolveProviderModel(pageResult: YuanbaoPageQueryResult, summary: YuanbaoSummary): string {
  if (summary.providerModel) {
    return summary.providerModel
  }
  if (pageResult.modelLabel) {
    return pageResult.modelLabel
  }

  const title = normalizeText(pageResult.title)
  const matched = title?.match(/体验\s*([^-]+?)(?:全新版|高效AI助手|AI助手)/)
  const fromTitle = normalizeText(matched?.[1] ?? null)
  if (fromTitle) {
    return fromTitle
  }

  return pageResult.deepThinkEnabled ? 'yuanbao-web-deep-think' : 'yuanbao-web'
}

const yuanbaoQueryInPage = async (parameters: {
  questionText: string
  timeoutMs: number
  readyTimeoutMs: number
  enableDeepThink: boolean
  enableWebSearch: boolean
}): Promise<YuanbaoPageQueryResult> => {
  const { questionText, timeoutMs, readyTimeoutMs, enableDeepThink, enableWebSearch } = parameters

  const wait = (timeMs: number) =>
    new Promise<void>((resolve) => {
      window.setTimeout(resolve, timeMs)
    })

  const normalize = (value: unknown): string | null => {
    if (typeof value !== 'string') {
      return null
    }
    const trimmed = value.trim().replace(/\s+/g, ' ')
    return trimmed ? trimmed : null
  }

  const isVisible = (element: Element | null | undefined): element is HTMLElement => {
    if (!(element instanceof HTMLElement)) {
      return false
    }
    const style = window.getComputedStyle(element)
    if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') {
      return false
    }
    const rect = element.getBoundingClientRect()
    return rect.width > 0 && rect.height > 0
  }

  const isDisabled = (element: HTMLElement | null): boolean => {
    if (!element) {
      return false
    }

    if ('disabled' in element && typeof (element as HTMLButtonElement).disabled === 'boolean') {
      return Boolean((element as HTMLButtonElement).disabled)
    }

    const ariaDisabled = element.getAttribute('aria-disabled')
    return ariaDisabled === 'true'
  }

  const parseColor = (
    value: string | null,
  ): { r: number; g: number; b: number; a: number } | null => {
    if (!value) {
      return null
    }

    const matched = value.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([0-9.]+))?\)/i)
    if (!matched) {
      return null
    }

    return {
      r: Number(matched[1]),
      g: Number(matched[2]),
      b: Number(matched[3]),
      a: matched[4] ? Number(matched[4]) : 1,
    }
  }

  const isGreenish = (value: string | null): boolean => {
    const color = parseColor(value)
    if (!color) {
      return false
    }
    return color.g >= color.r + 12 && color.g >= color.b + 12
  }

  const toggleState = (element: HTMLElement | null): boolean | null => {
    if (!element) {
      return null
    }

    const attrs = [
      element.getAttribute('aria-pressed'),
      element.getAttribute('aria-checked'),
      element.getAttribute('data-state'),
      element.getAttribute('data-selected'),
      element.getAttribute('data-active'),
    ]
      .map((value) => normalize(value)?.toLowerCase() ?? null)
      .filter((value): value is string => value !== null)

    if (attrs.some((value) => ['true', 'checked', 'selected', 'active', 'on'].includes(value))) {
      return true
    }
    if (attrs.some((value) => ['false', 'unchecked', 'off'].includes(value))) {
      return false
    }

    const className = normalize(element.className)?.toLowerCase() ?? ''
    if (/(^|[\s_-])(active|selected|checked|current|on)([\s_-]|$)/.test(className)) {
      return true
    }
    if (/(^|[\s_-])(inactive|unselected|unchecked|off)([\s_-]|$)/.test(className)) {
      return false
    }

    const style = window.getComputedStyle(element)
    if (
      isGreenish(style.color) ||
      isGreenish(style.borderColor) ||
      isGreenish(style.backgroundColor)
    ) {
      return true
    }

    const parent = element.closest("button, label, [role='button']") as HTMLElement | null
    if (parent && parent !== element) {
      const parentStyle = window.getComputedStyle(parent)
      if (
        isGreenish(parentStyle.color) ||
        isGreenish(parentStyle.borderColor) ||
        isGreenish(parentStyle.backgroundColor)
      ) {
        return true
      }
    }

    return null
  }

  const textOf = (element: Element | null | undefined): string | null => {
    if (!(element instanceof HTMLElement)) {
      return null
    }
    return normalize(element.innerText) ?? normalize(element.textContent)
  }

  const hintText = (element: Element | null | undefined): string => {
    if (!(element instanceof HTMLElement)) {
      return ''
    }
    return [
      element.getAttribute('aria-label'),
      element.getAttribute('placeholder'),
      element.getAttribute('title'),
      element.getAttribute('type'),
      element.getAttribute('name'),
      element.getAttribute('id'),
      typeof element.className === 'string' ? element.className : '',
      textOf(element),
    ]
      .map((value) => normalize(value)?.toLowerCase() ?? '')
      .filter(Boolean)
      .join(' ')
      .slice(0, 600)
  }

  const contextText = (element: HTMLElement | null): string => {
    if (!element) {
      return ''
    }

    const scopes = [
      element,
      element.parentElement,
      element.parentElement?.parentElement,
      element.closest("form, main, article, section, [role='dialog']"),
    ]

    return scopes
      .map((scope) => textOf(scope)?.toLowerCase() ?? '')
      .filter(Boolean)
      .join(' ')
      .slice(0, 900)
  }

  const looksLikeSearchSurface = (element: HTMLElement | null): boolean => {
    if (!element) {
      return false
    }
    const searchHint = [
      element.getAttribute('aria-label'),
      element.getAttribute('placeholder'),
      element.getAttribute('title'),
      element.getAttribute('type'),
      element.getAttribute('name'),
      element.getAttribute('id'),
      typeof element.className === 'string' ? element.className : '',
    ]
      .map((value) => normalize(value)?.toLowerCase() ?? '')
      .filter(Boolean)
      .join(' ')
    const context = contextText(element)
    return (
      /(搜索|search)/i.test(searchHint) ||
      /(搜索 元宝|全部应用|全部收藏|灵感图库|前往下载中心|下载中心)/i.test(context)
    )
  }

  const looksLikeComposerSurface = (
    element: HTMLElement | null,
    shell: HTMLElement | null,
  ): boolean => {
    if (!element) {
      return false
    }
    const hint = `${hintText(element)} ${hintText(shell)} ${contextText(shell ?? element)}`
    return /(ql-editor|chat-input|text-area|dialogue|composer|editor|提问|问题|输入|深度思考|联网搜索|工具|内容由ai生成，仅供参考)/i.test(
      hint,
    )
  }

  const summarizeFailureDetail = (raw: string | null): string | null => {
    const normalized = normalize(raw)
    if (!normalized) {
      return null
    }

    const cleaned = normalized
      .replace(
        /The resource http:\/\/localhost:[^\s]+ was preloaded using link preload but not used within a few seconds from the window's load event\.?/gi,
        '',
      )
      .replace(/\s+/g, ' ')
      .trim()
    if (!cleaned) {
      return null
    }
    if (cleaned.length <= 280) {
      return cleaned
    }
    return `${cleaned.slice(0, 280)}...`
  }

  const findComposer = (): HTMLElement | null => {
    const selectors = [
      "[contenteditable='true'][role='textbox']",
      "[contenteditable='true'][aria-multiline='true']",
      "[contenteditable='true']",
      'textarea',
      "input[type='text']",
    ]

    const candidates: Array<{ element: HTMLElement; score: number }> = []

    for (const selector of selectors) {
      const matched = Array.from(document.querySelectorAll(selector))
      for (const node of matched) {
        if (!(node instanceof HTMLElement) || !isVisible(node)) {
          continue
        }
        if ((node as HTMLInputElement).readOnly || (node as HTMLInputElement).disabled) {
          continue
        }

        const shell = findComposerShell(node)
        const rect = node.getBoundingClientRect()
        const isPlainInput = node instanceof HTMLInputElement
        const composerLike = looksLikeComposerSurface(node, shell)
        const searchLike = looksLikeSearchSurface(node) || looksLikeSearchSurface(shell)

        if (searchLike && !composerLike) {
          continue
        }
        if (isPlainInput && !composerLike && rect.top < window.innerHeight * 0.75) {
          continue
        }

        let score = rect.top * 3 + Math.min(rect.width, 1200) + rect.height
        if (node.isContentEditable) {
          score += 2_200
        } else if (node instanceof HTMLTextAreaElement) {
          score += 1_400
        } else if (isPlainInput) {
          score -= 1_000
        }
        if (composerLike) {
          score += 1_800
        }
        if (searchLike) {
          score -= 1_800
        }
        if (rect.top < window.innerHeight * 0.45) {
          score -= 1_200
        }
        if (rect.width >= window.innerWidth * 0.45) {
          score += 400
        }
        if (score <= 0) {
          continue
        }

        candidates.push({
          element: node,
          score,
        })
      }
    }

    candidates.sort((left, right) => right.score - left.score)
    return candidates[0]?.element ?? null
  }

  const findComposerShell = (composer: HTMLElement | null): HTMLElement | null => {
    if (!composer) {
      return null
    }

    let current: HTMLElement | null = composer
    let best: HTMLElement | null = composer
    let bestArea = composer.getBoundingClientRect().width * composer.getBoundingClientRect().height

    for (let depth = 0; current && depth < 5; depth += 1) {
      if (isVisible(current)) {
        const rect = current.getBoundingClientRect()
        const area = rect.width * rect.height
        if (area >= bestArea) {
          best = current
          bestArea = area
        }
      }
      current = current.parentElement
    }

    return best
  }

  const findInteractiveByText = (
    pattern: RegExp,
    shell: HTMLElement | null,
  ): HTMLElement | null => {
    const scopes: ParentNode[] = []
    if (shell) {
      scopes.push(shell)
      if (shell.parentElement) {
        scopes.push(shell.parentElement)
      }
      if (shell.parentElement?.parentElement) {
        scopes.push(shell.parentElement.parentElement)
      }
    }
    scopes.push(document)

    const seen = new Set<HTMLElement>()
    const candidates: Array<{ element: HTMLElement; score: number }> = []

    // The new yuanbao toolbar renders the deep-think toggle as a plain <div>
    // with the business attribute `dt-button-id="deep_think"` (and parallel
    // `dt-button-id` / `data-button-id` markers on other toolbar buttons),
    // not a <button>/[role=button]. Include those selectors so we still
    // match the toggle by visible text. Business attributes are far more
    // stable than CSS-module-hashed class names.
    for (const scope of scopes) {
      const nodes = Array.from(
        scope.querySelectorAll(
          "button, [role='button'], [role='menuitem'], [role='option'], li.t-dropdown__item, label, [tabindex], [dt-button-id], [data-button-id]",
        ),
      )
      for (const node of nodes) {
        if (!(node instanceof HTMLElement) || seen.has(node) || !isVisible(node)) {
          continue
        }
        seen.add(node)

        const text = normalize(node.innerText) ?? normalize(node.textContent)
        if (!text || !pattern.test(text)) {
          continue
        }

        const rect = node.getBoundingClientRect()
        const score = rect.top + rect.left + rect.width
        candidates.push({ element: node, score })
      }
    }

    candidates.sort((left, right) => right.score - left.score)
    return candidates[0]?.element ?? null
  }

  const deepThinkPattern = /深度(?:思考|搜索)|deep\s*(?:think|search)/i
  const webSearchPattern = /联网搜索|网页搜索|web\s*search|online\s*search/i
  const toolsPattern = /工具|tools?/i

  const clickInteractive = async (element: HTMLElement, delayMs = 180) => {
    element.scrollIntoView({ block: 'center', inline: 'center' })
    element.click()
    await wait(delayMs)
  }

  const hasActiveComposerMode = (pattern: RegExp, shell: HTMLElement | null): boolean => {
    const scopes: ParentNode[] = shell ? [shell, document] : [document]
    const seen = new Set<Element>()
    for (const scope of scopes) {
      const atoms = Array.from(scope.querySelectorAll('.application-blot-ai-atom'))
      for (const atom of atoms) {
        if (seen.has(atom) || !isVisible(atom)) {
          continue
        }
        seen.add(atom)
        const text = normalize(atom.textContent)
        if (text && pattern.test(text)) {
          return true
        }
      }
    }
    return false
  }

  const readToggleStateByPattern = (pattern: RegExp, shell: HTMLElement | null): boolean | null => {
    if (hasActiveComposerMode(pattern, shell)) {
      return true
    }
    const target = findInteractiveByText(pattern, shell)
    return target ? toggleState(target) : null
  }

  const ensureToggleEnabledByPattern = async (
    pattern: RegExp,
    shell: HTMLElement | null,
  ): Promise<boolean | null> => {
    const target = findInteractiveByText(pattern, shell)
    if (!target) {
      return null
    }

    let state = toggleState(target)
    let clicked = false
    if (state !== true) {
      await clickInteractive(target)
      clicked = true
      state = toggleState(target)
    }

    return state ?? (clicked ? true : null)
  }

  const ensureWebSearchEnabled = async (shell: HTMLElement | null): Promise<boolean | null> => {
    if (hasActiveComposerMode(webSearchPattern, shell)) {
      return true
    }

    const toolsButton = findInteractiveByText(toolsPattern, shell)
    if (!toolsButton) {
      return null
    }

    await clickInteractive(toolsButton, 220)
    const menuItem = findInteractiveByText(webSearchPattern, null)
    if (!menuItem) {
      return false
    }

    await clickInteractive(menuItem, 300)
    return hasActiveComposerMode(webSearchPattern, shell)
  }

  const setComposerText = (composer: HTMLElement, text: string) => {
    composer.focus()

    if (composer instanceof HTMLTextAreaElement || composer instanceof HTMLInputElement) {
      const prototype = Object.getPrototypeOf(composer) as {
        value?: PropertyDescriptor
      }
      const setter = Object.getOwnPropertyDescriptor(prototype, 'value')?.set
      if (setter) {
        setter.call(composer, text)
      } else {
        composer.value = text
      }
      composer.dispatchEvent(new Event('input', { bubbles: true }))
      composer.dispatchEvent(new Event('change', { bubbles: true }))
      return
    }

    if (composer.isContentEditable) {
      const selection = window.getSelection()
      const range = document.createRange()
      range.selectNodeContents(composer)
      selection?.removeAllRanges()
      selection?.addRange(range)

      const inserted =
        typeof document.execCommand === 'function'
          ? document.execCommand('insertText', false, text)
          : false
      if (!inserted) {
        composer.textContent = text
      }

      composer.dispatchEvent(
        new InputEvent('input', {
          bubbles: true,
          cancelable: true,
          data: text,
          inputType: 'insertText',
        }),
      )
      composer.dispatchEvent(new Event('change', { bubbles: true }))
    }
  }

  const findSendButton = (
    shell: HTMLElement | null,
    composer: HTMLElement | null,
  ): HTMLElement | null => {
    const scopes: ParentNode[] = []
    if (shell) {
      scopes.push(shell)
      if (shell.parentElement) {
        scopes.push(shell.parentElement)
      }
      if (shell.parentElement?.parentElement) {
        scopes.push(shell.parentElement.parentElement)
      }
    }
    scopes.push(document)

    const composerRect = composer?.getBoundingClientRect() ?? null
    const blacklist = /^(深度思考|联网搜索|工具|登录|安装电脑版|下载电脑版)$/
    const candidates: Array<{ element: HTMLElement; score: number }> = []
    const seen = new Set<HTMLElement>()

    for (const scope of scopes) {
      const nodes = Array.from(scope.querySelectorAll("button, [role='button']"))
      for (const node of nodes) {
        if (!(node instanceof HTMLElement) || seen.has(node) || !isVisible(node)) {
          continue
        }
        seen.add(node)

        const text = normalize(node.innerText) ?? normalize(node.textContent) ?? ''
        const hint = `${hintText(node)} ${contextText(node.parentElement)}`
        if (blacklist.test(text)) {
          continue
        }
        if (/(登录|下载电脑版|安装电脑版|前往下载中心|全部应用|全部收藏|搜索)/i.test(hint)) {
          continue
        }
        if (isDisabled(node)) {
          continue
        }

        const rect = node.getBoundingClientRect()
        if (rect.width < 20 || rect.height < 20) {
          continue
        }
        if (composerRect) {
          if (rect.top < composerRect.top - 120 || rect.top > composerRect.bottom + 140) {
            continue
          }
          if (rect.left < composerRect.left - 80 || rect.left > composerRect.right + 240) {
            continue
          }
        }

        let score = rect.left * 2 + rect.top + rect.width + rect.height
        if (composerRect) {
          const dx = Math.abs(rect.left - composerRect.right)
          const dy = Math.abs(rect.top - composerRect.top)
          score += Math.max(0, 1_800 - dx * 3 - dy * 3)
          if (rect.left >= composerRect.right - 24) {
            score += 400
          }
        }
        if (/(发送|submit|send|paper-plane|arrow|up)/i.test(hint)) {
          score += 1_200
        }
        if (!text && rect.width <= 64 && rect.height <= 64) {
          score += 280
        }
        candidates.push({ element: node, score })
      }
    }

    candidates.sort((left, right) => right.score - left.score)
    return candidates[0]?.element ?? null
  }

  const dispatchEnter = (composer: HTMLElement) => {
    const eventInit: KeyboardEventInit = {
      bubbles: true,
      cancelable: true,
      key: 'Enter',
      code: 'Enter',
    }
    composer.dispatchEvent(new KeyboardEvent('keydown', eventInit))
    composer.dispatchEvent(new KeyboardEvent('keypress', eventInit))
    composer.dispatchEvent(new KeyboardEvent('keyup', eventInit))
  }

  const collectLinks = (scope: HTMLElement | null): YuanbaoDomLink[] => {
    if (!scope) {
      return []
    }

    const links: YuanbaoDomLink[] = []
    const seen = new Set<string>()
    const urlAttributeNames = [
      'href',
      'data-href',
      'data-url',
      'data-link',
      'data-source-url',
      'data-target-url',
      'data-jump-url',
      'data-doc-url',
      'data-article-url',
      'data-real-url',
      'dt-ext6',
    ]
    const extractUrls = (value: string | null): string[] => {
      const normalized = normalize(value)
      if (!normalized) {
        return []
      }

      const urls = new Set<string>()
      const pushCandidate = (candidate: string) => {
        const cleaned = candidate.replace(/&amp;/g, '&')
        try {
          const decoded = decodeURIComponent(cleaned)
          if (/^https?:\/\//i.test(decoded)) {
            urls.add(decoded)
          }
        } catch {
          if (/^https?:\/\//i.test(cleaned)) {
            urls.add(cleaned)
          }
        }
      }

      if (/^https?:\/\//i.test(normalized)) {
        pushCandidate(normalized)
      }
      for (const matched of normalized.matchAll(/https?:\/\/[^\s"'<>\\]+/gi)) {
        if (matched[0]) {
          pushCandidate(matched[0])
        }
      }
      return Array.from(urls)
    }

    for (const node of [scope, ...Array.from(scope.querySelectorAll('*'))]) {
      if (!(node instanceof HTMLElement) || !isVisible(node)) {
        continue
      }

      const sourceScope = (node.closest(
        '.agent-dialogue-references__item, .hyc-common-markdown__ref_card',
      ) ?? node) as HTMLElement
      const urls = new Set<string>()
      if (node instanceof HTMLAnchorElement) {
        for (const url of extractUrls(node.href)) {
          urls.add(url)
        }
      }
      for (const attributeName of urlAttributeNames) {
        for (const url of extractUrls(node.getAttribute(attributeName))) {
          urls.add(url)
        }
      }

      for (const url of urls) {
        const title =
          normalize(
            sourceScope.querySelector('.hyc-common-markdown__ref_card-title')?.textContent ?? null,
          ) ??
          normalize(node.getAttribute('title')) ??
          normalize(node.getAttribute('aria-label'))
        const siteName =
          normalize(sourceScope.getAttribute('dt-ext3')) ??
          normalize(
            sourceScope.querySelector('.hyc-common-markdown__ref_card-foot__source_txt')
              ?.textContent ?? null,
          )
        const sourceIndex =
          Number.parseInt(
            sourceScope.getAttribute('data-idx') ??
              sourceScope.querySelector('[data-idx]')?.getAttribute('data-idx') ??
              node.getAttribute('data-idx') ??
              '',
            10,
          ) || null
        const seenKey = sourceIndex !== null ? `idx:${sourceIndex}` : `url:${url}`
        if (seen.has(seenKey)) {
          continue
        }
        seen.add(seenKey)
        links.push({
          url,
          title,
          text:
            normalize(node.innerText) ??
            normalize(node.textContent) ??
            normalize(node.getAttribute('aria-label')),
          siteName,
          sourceIndex,
        })
      }
    }
    return links
  }

  const collectInlineCitationIndexes = (scope: HTMLElement | null): number[] => {
    if (!scope) {
      return []
    }

    const indexes: number[] = []
    const seen = new Set<string>()
    const triggers = Array.from(scope.querySelectorAll('[data-idx-list]'))
    for (const trigger of triggers) {
      if (
        !(trigger instanceof HTMLElement) ||
        !isVisible(trigger) ||
        trigger.closest(
          '#chatReferenceList, .agent-dialogue-references, .hyc-common-markdown__ref_card',
        )
      ) {
        continue
      }
      const raw = normalize(trigger.getAttribute('data-idx-list'))
      if (!raw) {
        continue
      }
      for (const part of raw.split(/[,，\s]+/)) {
        const index = Number.parseInt(part, 10)
        if (!Number.isFinite(index) || index < 1) {
          continue
        }
        const key = `${trigger.getBoundingClientRect().top}:${index}:${indexes.length}`
        if (seen.has(key)) {
          continue
        }
        seen.add(key)
        indexes.push(index)
      }
    }
    return indexes
  }

  const textWithInlineCitationMarkers = (scope: HTMLElement | null): string | null => {
    if (!scope) {
      return null
    }

    const clone = scope.cloneNode(true) as HTMLElement
    for (const node of Array.from(
      clone.querySelectorAll(
        "#chatReferenceList, [class*='agent-dialogue-references'], [class*='deepsearch-cot__think'], [class*='toolbar'], [class*='question-toolbar'], [class*='suggestion']",
      ),
    )) {
      node.remove()
    }
    for (const node of Array.from(clone.querySelectorAll('[data-idx-list]'))) {
      if (!(node instanceof HTMLElement)) {
        continue
      }
      const raw = normalize(node.getAttribute('data-idx-list'))
      if (!raw) {
        continue
      }
      const markers = raw
        .split(/[,，\s]+/)
        .map((part) => Number.parseInt(part, 10))
        .filter((index) => Number.isFinite(index) && index > 0)
        .map((index) => `[${index}]`)
        .join('')
      if (!markers) {
        continue
      }
      node.replaceWith(document.createTextNode(markers))
    }
    return normalize(clone.innerText) ?? normalize(clone.textContent)
  }

  const hasVisibleReferenceCards = (): boolean => {
    return Array.from(
      document.querySelectorAll(
        '#chatReferenceList .hyc-common-markdown__ref_card[data-url], #chatReferenceList [dt-ext6]',
      ),
    ).some((node) => node instanceof HTMLElement && isVisible(node))
  }

  const scrollLatestConversationToBottom = async (): Promise<void> => {
    const preferred = document.querySelector('.agent-chat__list__content-wrapper')
    if (preferred instanceof HTMLElement && preferred.scrollHeight > preferred.clientHeight) {
      preferred.scrollTop = preferred.scrollHeight
      await wait(120)
      return
    }

    const scrollers = Array.from(document.querySelectorAll('*'))
      .filter(
        (node): node is HTMLElement =>
          node instanceof HTMLElement &&
          isVisible(node) &&
          node.scrollHeight > node.clientHeight + 80 &&
          node.getBoundingClientRect().width > 240 &&
          /agent-chat|chat|dialogue|conversation|content-wrapper/i.test(
            `${node.id} ${typeof node.className === 'string' ? node.className : ''}`,
          ),
      )
      .sort(
        (left, right) =>
          right.scrollHeight - right.clientHeight - (left.scrollHeight - left.clientHeight),
      )

    const target = scrollers[0] ?? null
    if (target) {
      target.scrollTop = target.scrollHeight
      await wait(120)
    }
  }

  const clickLatestThoughtReferenceTrigger = async (composerTop: number | null): Promise<void> => {
    const candidates: Array<{ element: HTMLElement; score: number }> = []
    for (const node of Array.from(document.querySelectorAll('*'))) {
      if (!(node instanceof HTMLElement) || !isVisible(node)) {
        continue
      }
      const text = normalize(node.textContent)
      if (!text || !/^找到了\s*\d+\s*篇相关资料/.test(text)) {
        continue
      }
      const style = window.getComputedStyle(node)
      const clickable =
        style.cursor === 'pointer' ||
        node.tabIndex >= 0 ||
        typeof (node as { onclick?: unknown }).onclick === 'function'
      const className = typeof node.className === 'string' ? node.className : ''
      if (!clickable && !/docs__number__words|search/i.test(className)) {
        continue
      }
      const rect = node.getBoundingClientRect()
      if (composerTop !== null && rect.top >= composerTop - 12) {
        continue
      }
      candidates.push({
        element: node,
        score: rect.top + rect.left - Math.abs((composerTop ?? window.innerHeight) - rect.bottom),
      })
    }
    candidates.sort((left, right) => right.score - left.score)
    const target = candidates[0]?.element ?? null
    if (target) {
      await clickInteractive(target, 250)
    }
  }

  const clickLatestCitationPanelTrigger = async (composerTop: number | null): Promise<void> => {
    if (hasVisibleReferenceCards()) {
      return
    }

    const candidates: Array<{ element: HTMLElement; score: number }> = []
    const nodes = Array.from(
      document.querySelectorAll(
        "#search-guide-tool, [data-toolbar-type='citation'], [class*='SearchGuid'], [class*='searchGuid']",
      ),
    )
    for (const node of nodes) {
      if (!(node instanceof HTMLElement) || !isVisible(node)) {
        continue
      }
      const text = normalize(node.textContent) ?? ''
      const hint = `${text} ${hintText(node)}`
      if (!/(源|引用|citation|source|search)/i.test(hint)) {
        continue
      }
      const rect = node.getBoundingClientRect()
      const isCitationTrigger =
        node.id === 'search-guide-tool' || node.getAttribute('data-toolbar-type') === 'citation'
      if (composerTop !== null && rect.top >= composerTop - 12 && !isCitationTrigger) {
        continue
      }
      candidates.push({
        element: node,
        score: rect.top * 2 + rect.left + rect.width,
      })
    }
    candidates.sort((left, right) => right.score - left.score)
    const target = candidates[0]?.element ?? null
    if (target) {
      await clickInteractive(target, 350)
    }
  }

  const waitForReferenceCards = async (timeoutMs: number): Promise<void> => {
    const deadline = Date.now() + timeoutMs
    while (Date.now() <= deadline) {
      if (hasVisibleReferenceCards()) {
        return
      }
      await wait(150)
    }
  }

  const revealLatestReferenceSources = async (composerTop: number | null): Promise<void> => {
    await scrollLatestConversationToBottom()
    await clickLatestThoughtReferenceTrigger(null)
    await scrollLatestConversationToBottom()
    await clickLatestCitationPanelTrigger(composerTop)
    await waitForReferenceCards(2_000)
  }

  const snapshotConversation = (
    composerTop: number | null,
  ): {
    text: string | null
    links: YuanbaoDomLink[]
    inlineCitationIndexes: number[]
    signature: string
  } => {
    const candidates: Array<{ element: HTMLElement; score: number }> = []
    const sourceScopes: HTMLElement[] = []
    const elements = Array.from(document.querySelectorAll('article, section, div, main'))

    for (const node of elements) {
      if (!(node instanceof HTMLElement) || !isVisible(node)) {
        continue
      }

      if (
        node.id === 'chatReferenceList' ||
        node.classList.contains('agent-dialogue-references') ||
        node.closest('#chatReferenceList')
      ) {
        sourceScopes.push(node)
        continue
      }

      const rect = node.getBoundingClientRect()
      if (composerTop !== null && rect.top >= composerTop - 12) {
        continue
      }
      if (rect.left < window.innerWidth * 0.12 || rect.width < 180) {
        continue
      }

      const text = normalize(node.innerText)
      const links = collectLinks(node)
      if ((!text || text.length < 24) && links.length === 0) {
        continue
      }
      if (
        text &&
        (/^(Hi[,，\s].*|内容由AI生成，仅供参考|请登录后输入内容)$/.test(text) ||
          /(前往下载中心|全部应用|全部收藏|搜索 元宝|安装电脑版|下载电脑版)/.test(text))
      ) {
        continue
      }
      if (looksLikeSearchSurface(node)) {
        continue
      }

      const score =
        rect.height * 2 +
        Math.min(text?.length ?? 0, 800) +
        links.length * 80 -
        Math.max(0, Math.abs((composerTop ?? window.innerHeight) - rect.bottom))
      candidates.push({ element: node, score })
    }

    candidates.sort((left, right) => right.score - left.score)
    const best = candidates[0]?.element ?? null
    const text = best ? textWithInlineCitationMarkers(best) : null
    const linkMap = new Map<string, YuanbaoDomLink>()
    for (const scope of sourceScopes) {
      for (const link of collectLinks(scope)) {
        const normalizedURL = normalize(link.url)
        const linkKey =
          link.sourceIndex !== null
            ? `idx:${link.sourceIndex}`
            : normalizedURL
              ? `url:${normalizedURL}`
              : null
        if (!linkKey || linkMap.has(linkKey)) {
          continue
        }
        linkMap.set(linkKey, link)
      }
    }
    for (const candidate of candidates.slice(0, 16)) {
      for (const link of collectLinks(candidate.element)) {
        const normalizedURL = normalize(link.url)
        const linkKey =
          link.sourceIndex !== null
            ? `idx:${link.sourceIndex}`
            : normalizedURL
              ? `url:${normalizedURL}`
              : null
        if (!linkKey || linkMap.has(linkKey)) {
          continue
        }
        linkMap.set(linkKey, link)
      }
    }
    const links = Array.from(linkMap.values())
    const inlineCitationIndexes = best ? collectInlineCitationIndexes(best) : []
    const signature = `${text ?? ''}|${links.map((item) => item.url).join('|')}`.slice(-1_500)

    return { text, links, inlineCitationIndexes, signature }
  }

  const resolveModelLabel = (): string | null => {
    const title = normalize(document.title)
    const matched = title?.match(/体验\s*([^-]+?)(?:全新版|高效AI助手|AI助手)/)
    return normalize(matched?.[1] ?? null)
  }

  const bodyText = () => normalize(document.body?.innerText ?? '')

  const hasLoginGate = (): boolean => {
    if (
      document.querySelector(
        ".hyc-login__dialog, [class*='login__dialog'], [class*='login-dialog']",
      )
    ) {
      return true
    }
    return /请登录后输入内容|请先登录|立即登录|未登录|扫码登录|微信扫码登录/.test(bodyText() ?? '')
  }

  const hasBusyIndicator = (): boolean => {
    const text = bodyText() ?? ''
    return /停止生成|思考中|搜索中|回答中|生成中/.test(text)
  }

  let lastKnownDeepThinkEnabled: boolean | null = null
  let lastKnownWebSearchEnabled: boolean | null = null

  const fail = (
    error: string,
    detail: string | null,
    composerTop: number | null,
  ): YuanbaoPageQueryFailureResult => {
    const snapshot = snapshotConversation(composerTop)
    const currentComposerShell = findComposerShell(findComposer())
    return {
      ok: false,
      error,
      detail:
        summarizeFailureDetail(detail) ??
        summarizeFailureDetail(snapshot.text) ??
        summarizeFailureDetail(bodyText()),
      url: window.location.href || null,
      title: normalize(document.title),
      modelLabel: resolveModelLabel(),
      deepThinkEnabled:
        readToggleStateByPattern(deepThinkPattern, currentComposerShell) ??
        lastKnownDeepThinkEnabled,
      webSearchEnabled:
        readToggleStateByPattern(webSearchPattern, currentComposerShell) ??
        lastKnownWebSearchEnabled,
      domAnswer: snapshot.text,
      domLinks: snapshot.links,
      inlineCitationIndexes: snapshot.inlineCitationIndexes,
    }
  }

  const readyDeadline = Date.now() + readyTimeoutMs
  let composer = findComposer()
  while (!composer && Date.now() <= readyDeadline) {
    await wait(250)
    composer = findComposer()
  }

  if (hasLoginGate()) {
    return fail('yuanbao_login_required', bodyText(), composer?.getBoundingClientRect().top ?? null)
  }

  if (!composer) {
    return fail('yuanbao_composer_missing', bodyText(), null)
  }

  let composerShell = findComposerShell(composer)
  const composerTop = composer.getBoundingClientRect().top

  if (enableDeepThink) {
    lastKnownDeepThinkEnabled = await ensureToggleEnabledByPattern(deepThinkPattern, composerShell)
  }

  if (enableWebSearch) {
    lastKnownWebSearchEnabled = await ensureWebSearchEnabled(composerShell)
    if (lastKnownWebSearchEnabled !== true) {
      return fail('yuanbao_web_search_enable_failed', bodyText(), composerTop)
    }
  }

  setComposerText(composer, questionText)
  await wait(220)

  composer = findComposer() ?? composer
  composerShell = findComposerShell(composer) ?? composerShell
  const sendButton = findSendButton(composerShell, composer)
  if (sendButton) {
    sendButton.click()
  } else {
    dispatchEnter(composer)
  }

  await wait(600)

  const initialSnapshot = snapshotConversation(composerTop)
  let lastSignature = initialSnapshot.signature
  let stableCount = 0
  let sawChange = false
  const deadline = Date.now() + timeoutMs

  while (Date.now() <= deadline) {
    const snapshot = snapshotConversation(composerTop)
    if (snapshot.signature && snapshot.signature !== initialSnapshot.signature) {
      sawChange = true
      if (snapshot.signature === lastSignature) {
        stableCount += 1
      } else {
        lastSignature = snapshot.signature
        stableCount = 0
      }
    }

    if (hasLoginGate()) {
      return fail('yuanbao_login_expired', bodyText(), composerTop)
    }

    if (sawChange && !hasBusyIndicator() && stableCount >= 2) {
      await revealLatestReferenceSources(composerTop)
      const finalSnapshot = snapshotConversation(composerTop)
      const currentDeepThinkEnabled =
        readToggleStateByPattern(deepThinkPattern, composerShell) ?? lastKnownDeepThinkEnabled
      const currentWebSearchEnabled =
        readToggleStateByPattern(webSearchPattern, composerShell) ?? lastKnownWebSearchEnabled
      return {
        ok: true,
        url: window.location.href,
        title: normalize(document.title),
        modelLabel: resolveModelLabel(),
        deepThinkEnabled: currentDeepThinkEnabled,
        webSearchEnabled: currentWebSearchEnabled,
        domAnswer: finalSnapshot.text ?? snapshot.text,
        domLinks: finalSnapshot.links.length ? finalSnapshot.links : snapshot.links,
        inlineCitationIndexes: finalSnapshot.inlineCitationIndexes.length
          ? finalSnapshot.inlineCitationIndexes
          : snapshot.inlineCitationIndexes,
      }
    }

    await wait(1_000)
  }

  return fail('yuanbao_query_timeout', bodyText(), composerTop)
}

export const yuanbaoAdapter: MonitorAdapter = {
  provider: 'yuanbao',
  executionMode: 'playwright',
  async query(context, payload) {
    if (!context.playwright?.page) {
      return {
        status: 'failed',
        summary: '元宝监测缺少 Playwright 页面上下文。',
        error: buildAdapterError('yuanbao_playwright_required', 'yuanbao_playwright_required'),
      }
    }

    const questionText = extractQuestionText(payload)
    const page = context.playwright.page

    context.reportProgress('yuanbao.page_ready')
    await ensurePageOnYuanbaoChat(page, context.signal)

    const capture = attachYuanbaoResponseCapture(page, questionText)
    let pageResult: YuanbaoPageQueryResult

    try {
      context.reportProgress('yuanbao.query')
      pageResult = await page.evaluate(yuanbaoQueryInPage, {
        questionText,
        timeoutMs: YUANBAO_QUERY_TIMEOUT_MS,
        readyTimeoutMs: YUANBAO_PAGE_READY_TIMEOUT_MS,
        enableDeepThink: true,
        enableWebSearch: true,
      })
      await sleep(600, context.signal).catch(() => undefined)
      await capture.flush(YUANBAO_CAPTURE_FLUSH_TIMEOUT_MS)
    } finally {
      capture.dispose()
    }

    const parsed = parseYuanbaoCaptures(capture.captures)
    const pendingCaptureCount = capture.pendingCount()
    const domCitations = buildOrderedDomSourceItems(pageResult.domLinks)
    const searchResults = parsed.searchResults.length
      ? dedupeSourceItems(parsed.searchResults)
      : dedupeSourceItems(domCitations)
    const apiAnswer = sanitizeAnswerCandidate(parsed.answer)
    const domAnswer = sanitizeAnswerCandidate(pageResult.domAnswer)
    const answerWithMarkers = selectBestAnswerText(apiAnswer, domAnswer)
    const responseSource = apiAnswer ? 'api_sse' : domAnswer ? 'page_rpa' : null
    const citationMarkerIndexes = extractCitationMarkerIndexes(
      answerWithMarkers ?? pageResult.domAnswer,
    )
    const maxCitationMarkerIndex = citationMarkerIndexes.length
      ? Math.max(...citationMarkerIndexes)
      : 0
    const markerCitations = dedupeSourceItems(
      resolveCitationsFromMarkers(answerWithMarkers ?? pageResult.domAnswer, [
        parsed.citations,
        parsed.searchResults,
        domCitations,
        dedupeSourceItems([...parsed.citations, ...parsed.searchResults, ...domCitations]),
      ]),
    )
    const answer = normalizeCitationMarkers(answerWithMarkers)
    const citations =
      parsed.citations.length >= maxCitationMarkerIndex
        ? appendUniqueSourceItems(parsed.citations, [...markerCitations, ...domCitations])
        : domCitations.length >= maxCitationMarkerIndex
          ? appendUniqueSourceItems(domCitations, [...parsed.citations, ...markerCitations])
          : appendUniqueSourceItems(
              dedupeSourceItems([...parsed.citations, ...markerCitations]),
              domCitations,
            )
    const inlineCitationCandidates = dedupeSourceItems(
      citationMarkerIndexes
        .map((index) => citations[index - 1] ?? null)
        .filter((item): item is MonitoringSourceItem => item !== null),
    )
    const reasoning = repairPotentialMojibake(normalizeText(parsed.reasoning))
    const providerModel = resolveProviderModel(pageResult, parsed)
    const conversationID = parsed.conversationID ?? extractConversationID(pageResult.url)
    const requestID = parsed.requestID ?? conversationID
    const unresolvedCitationIndexes = findUnresolvedCitationIndexes(answer, citations)

    if (pageResult.ok === false) {
      const failedPageResult = pageResult
      const detail = normalizeText(failedPageResult.detail) ?? 'unknown'
      if (
        failedPageResult.error === 'yuanbao_login_required' ||
        failedPageResult.error === 'yuanbao_login_expired'
      ) {
        return {
          status: 'failed',
          summary: '元宝账号未登录或登录态已失效，请先在 desktop client 中重新授权。',
          error: buildAdapterError(failedPageResult.error, detail, {
            page_url: failedPageResult.url ?? safePageURL(page),
          }),
        }
      }

      if (
        failedPageResult.error !== 'yuanbao_query_timeout' ||
        (!answer && !searchResults.length && !citations.length)
      ) {
        return {
          status: 'failed',
          summary: `元宝请求失败：${detail}`,
          error: buildAdapterError(failedPageResult.error, detail, {
            page_url: failedPageResult.url ?? safePageURL(page),
          }),
        }
      }
    }

    if (!answer && !searchResults.length && !citations.length) {
      return {
        status: 'unknown',
        summary: '元宝返回为空，已回写 unknown 等待后续对账。',
        error: buildAdapterError('yuanbao_empty_response', 'yuanbao returned no answer or sources'),
      }
    }

    if (answer && unresolvedCitationIndexes.length > 0) {
      return {
        status: 'unknown',
        summary: '元宝回答含引用标记但未拿到完整引用来源，已回写 unknown 等待后续补采。',
        error: buildAdapterError(
          'yuanbao_incomplete_citations',
          'yuanbao answer contains citation markers but source extraction is incomplete',
          {
            citation_marker_count: citationMarkerIndexes.length,
            max_citation_marker_index: maxCitationMarkerIndex,
            unresolved_citation_indexes: unresolvedCitationIndexes,
            citation_count: citations.length,
            search_result_count: searchResults.length,
            dom_citation_count: domCitations.length,
            parsed_citation_count: parsed.citations.length,
            parsed_search_result_count: parsed.searchResults.length,
          },
        ),
      }
    }

    context.reportProgress('yuanbao.parse_result')
    return {
      status: 'succeeded',
      summary: '元宝监控任务执行成功。',
      payload: {
        platform: 'yuanbao',
        provider_model: providerModel,
        provider_request_id: parsed.providerRequestID,
        request_id: requestID,
        conversation_id: conversationID,
        answer,
        response_source: responseSource,
        reasoning,
        citation_count: citations.length,
        search_result_count: searchResults.length,
        citations: toJsonSources(citations),
        search_results: toJsonSources(searchResults),
        raw_response_json: {
          platform: 'yuanbao',
          page_url: pageResult.url,
          page_title: pageResult.title,
          model_label: pageResult.modelLabel,
          deep_think_enabled: pageResult.deepThinkEnabled,
          web_search_enabled: pageResult.webSearchEnabled,
          response_source: responseSource,
          candidate_count: parsed.candidateCount,
          capture_count: capture.captures.length,
          capture_pending_after_flush: pendingCaptureCount,
          content_types: Array.from(parsed.contentTypes.values()),
          citation_marker_count: citationMarkerIndexes.length,
          citation_marker_indexes: citationMarkerIndexes,
          unresolved_citation_indexes: unresolvedCitationIndexes,
          dom_inline_citation_indexes: pageResult.inlineCitationIndexes,
          inline_citation_candidates: toJsonSources(inlineCitationCandidates),
          dom_reference_links: toJsonSources(domCitations),
        },
      },
    }
  },
}

export const __yuanbaoTestUtils = {
  appendUniqueSourceItems,
  buildOrderedDomSourceItems,
  buildSourceItem,
  dedupeSourceItems,
  extractCitationMarkerIndexes,
  extractQuestionText,
  findUnresolvedCitationIndexes,
  isCurrentYuanbaoChatSSE,
  mergeText,
  normalizeCitationMarkers,
  normalizeSourceUrl,
  parseYuanbaoCaptures,
  resolveCitationsFromMarkers,
  selectBestAnswerText,
}