myagent-ai 1.47.19 → 1.47.21

package/core/output_parser.py

@@ -1,730 +0,0 @@
-"""
-Custom Fault-Tolerant XML Output Parser Module.
-
-Parses the XML ``<output>`` block generated by the LLM in response to the
-system prompt.  The LLM produces structured XML that drives the agent's
-execution loop — including tool calls, memory operations, user interaction
-hints, and loop-control flags.
-
-**This module does NOT use xml.etree.ElementTree.**  All parsing is done with
-pure Python + regex to achieve maximum fault tolerance.
-
-Expected XML schema produced by the LLM::
-
-    <output>
-        <mainsubject>当前对话的6字以内标题</mainsubject>
-        <usersays_correct>...</usersays_correct>
-        <reply>展示给用户的文本内容</reply>
-        <toolstocal>
-            <tool>
-                
-                <toolname>工具名</toolname>
-                <parms>参数JSON或描述</parms>
-                <timeout>预估超时时限(秒)</timeout>
-            </tool>
-        </toolstocal>
-        <remember>
-            <type>global|session</type>
-            <content>记忆内容</content>
-        </remember>
-        <recall>下一轮需要调取的记忆</recall>
-        <get_knowledge>下一轮需要搜索获得的知识</get_knowledge>
-    </output>
-
-Fault-tolerance features:
-
-* Text before ``<output>`` or after ``</output>`` is silently stripped.
-* Unclosed tags are auto-closed at the next sibling tag boundary.
-* Self-closing tags (``<tag/>``) resolve to empty strings.
-* Case-insensitive tag matching (``<OUTPUT>`` == ``<output>``).
-* Tag-name aliases (reserved for future use).
-* If extraction yields nothing meaningful, ``needs_correction`` is set to
-  ``True`` so the caller can ask the LLM to re-format.
-"""
-
-from __future__ import annotations
-
-import html
-import re
-from dataclasses import dataclass, field
-from typing import Any, Dict, List
-
-from core.logger import get_logger
-
-logger = get_logger("myagent.output_parser")
-
-# ---------------------------------------------------------------------------
-# Constants
-# ---------------------------------------------------------------------------
-
-_DEFAULT_TIMEOUT: int = 120
-
-# All top-level tags we recognise inside <output>.
-KNOWN_TOP_LEVEL_TAGS = [
-    "usersays_correct",
-    "task_plan",  # 任务计划（Markdown格式）
-    "toolstocal",
-    "remember",
-    "recall",
-    "knowledge",
-    "get_knowledge",
-
-    "reply",  # [v1.36] 用户可见文本（顶层标签，不再嵌套在 <response> 内）
-    # [v1.37] "response" 已移除 — 不再兼容 <response> 包裹，统一使用 <reply>
-    "mainsubject",  # [v1.15.8] 会话标题自动命名
-]
-
-# Inner tags inside each <tool>.
-TOOL_INNER_TAGS = [
-    "toolname",
-    "parms",
-    "timeout",
-]
-
-# Inner tags inside <remember>.
-REMEMBER_INNER_TAGS = ["type", "content"]
-
-# Tag aliases: canonical name -> list of aliases.
-_TAG_ALIASES: Dict[str, List[str]] = {
-    # [v1.36] askuser/ask_user aliases removed — tag no longer used
-}
-
-# Build reverse lookup: alias -> canonical.
-_ALIAS_TO_CANONICAL: Dict[str, str] = {}
-for _canonical, _aliases in _TAG_ALIASES.items():
-    for _alias in _aliases:
-        _ALIAS_TO_CANONICAL[_alias.lower()] = _canonical
-
-
-# ---------------------------------------------------------------------------
-# Data classes
-# ---------------------------------------------------------------------------
-
-
-@dataclass
-class ParsedOutput:
-    """Structured representation of the LLM's ``<output>`` block.
-
-    Attributes:
-        usersays_correct: Corrected / canonicalised version of the user's
-            voice input.
-        task_plan: Updated or new task plan (may contain Markdown).
-        tools_to_call: Ordered list of tool descriptors to execute.
-        remember: Content that should be persisted to the agent's memory.
-        remember_type: "global" (cross-session) or "session" (current session only).
-        recall: Memory keys / descriptions to retrieve for the next loop
-            iteration.
-        knowledge: Knowledge content the LLM wants to persist.
-        get_knowledge: Knowledge search keywords for the next loop iteration.
-        reply: User-visible text content extracted from <reply> tag (sole display content).
-        raw_text: The verbatim raw text returned by the LLM.
-        parse_success: Whether parsing extracted at least one meaningful field.
-        needs_correction: When ``True``, the caller should send the raw text
-            back to the LLM for re-formatting.
-    """
-
-    usersays_correct: str = ""
-    task_plan: str = ""  # 任务计划（Markdown格式）
-    tools_to_call: List[Dict[str, Any]] = field(default_factory=list)
-    remember: str = ""
-    remember_type: str = ""
-    recall: str = ""
-    knowledge: str = ""
-    get_knowledge: str = ""
-
-    reply: str = ""  # [v1.37] 用户可见文本（<reply> 标签，唯一回复来源）
-    mainsubject: str = ""  # [v1.15.8] 会话标题自动命名（6字以内）
-    raw_text: str = ""
-    parse_success: bool = False
-    needs_correction: bool = False
-    output_block_complete: bool = False  # </output> 闭合标签是否存在
-
-
-# ---------------------------------------------------------------------------
-# Low-level extraction helpers
-# ---------------------------------------------------------------------------
-
-
-def _safe_strip(value: str | None) -> str:
-    if value is None:
-        return ""
-    return value.strip()
-
-
-def _parse_bool(value: str | None, default: bool) -> bool:
-    if value is None:
-        return default
-    stripped = value.strip().lower()
-    if stripped in ("true", "1", "yes"):
-        return True
-    if stripped in ("false", "0", "no"):
-        return False
-    return default
-
-
-def _parse_int(value: str | None, default: int) -> int:
-    if value is None:
-        return default
-    try:
-        return int(value.strip())
-    except (ValueError, TypeError):
-        return default
-
-
-def _canonical_tag(tag_name: str) -> str:
-    """Return the canonical tag name for *tag_name* (alias-aware, lowercased)."""
-    lower = tag_name.strip().lower()
-    return _ALIAS_TO_CANONICAL.get(lower, lower)
-
-
-def _extract_tag_content(text: str, tag_name: str, stop_tags: List[str] | None = None, *, conservative: bool = False) -> str:
-    """Extract the text content of ``<tag_name>…</tag_name>`` from *text*.
-
-    Fault-tolerant strategies tried in order:
-
-    1. **Properly closed**: ``<tag>content</tag>``
-    2. **Unclosed at next sibling opening tag**: ``<tag>content<next_tag>…``
-    3. **Unclosed at ``</output>``**: ``<tag>content</output>``
-    4. **Self-closing**: ``<tag/>``
-    5. **Opening tag at end of string**: ``<tag>content$``
-
-    Parameters:
-        text: The text to search within (typically the body of ``<output>``).
-        tag_name: The tag name to extract (case-insensitive).
-        stop_tags: Sibling tag names that signal the end of this tag's
-            content (used for unclosed-tag detection).  Defaults to
-            ``KNOWN_TOP_LEVEL_TAGS``.
-    """
-    if not text or not tag_name:
-        return ""
-
-    if stop_tags is None:
-        stop_tags = KNOWN_TOP_LEVEL_TAGS
-
-    tag_esc = re.escape(tag_name)
-
-    # Strategy 1: Properly closed <tag>content</tag>
-    m = re.search(
-        rf"<{tag_esc}[^>]*>(.*?)</{tag_esc}\s*>",
-        text,
-        re.DOTALL | re.IGNORECASE,
-    )
-    if m:
-        return html.unescape(m.group(1))
-
-    # Conservative mode: only extract properly closed tags, skip all fallbacks
-    if conservative:
-        return ""
-
-    # Strategy 2: Unclosed — content runs until the next opening/closing
-    # sibling tag or </output>.
-    sibling_names = [t for t in stop_tags if t.lower() != tag_name.lower()]
-    if sibling_names:
-        sibling_pat = "|".join(re.escape(t) for t in sibling_names)
-        # CRITICAL: Wrap sibling_pat in (?:...) so that | doesn't split the
-        # leading < or </ from the alternation.  Without this, e.g.
-        # "<a|b|c" is parsed as "<a" OR "b" OR "c" — NOT "<a" OR "<b" OR "<c".
-        boundary = rf"(?:</output\s*>|<(?:{sibling_pat})\b|</(?:{sibling_pat})\s*>)"
-    else:
-        boundary = r"</output\s*>"
-
-    m = re.search(
-        rf"<{tag_esc}[^>]*>(.*?)({boundary})",
-        text,
-        re.DOTALL | re.IGNORECASE,
-    )
-    if m:
-        return html.unescape(m.group(1))
-
-    # Strategy 3: Self-closing <tag/> or <tag />
-    m = re.search(rf"<{tag_esc}[^>]*/\s*>", text, re.IGNORECASE)
-    if m:
-        return ""
-
-    # Strategy 4: Opening tag at end of text with no closing
-    m = re.search(
-        rf"<{tag_esc}[^>]*>(.*?)$",
-        text,
-        re.DOTALL | re.IGNORECASE,
-    )
-    if m:
-        content = m.group(1).strip()
-        # Only return if there's actual content (not just whitespace)
-        if content:
-            return html.unescape(content)
-
-    return ""
-
-
-def _extract_all_tag_blocks(
-    text: str,
-    tag_name: str,
-    parent_close_tag: str | None = None,
-    *,
-    conservative: bool = False,
-) -> List[str]:
-    """Extract all ``<tag_name>…`` blocks from *text*.
-
-    Used for extracting multiple ``<tool>`` blocks from ``<toolstocal>``
-    content.  Handles both properly closed and unclosed blocks.
-
-    Returns a list of content strings, one per block.
-    """
-    if not text:
-        return []
-
-    tag_esc = re.escape(tag_name)
-    blocks: List[str] = []
-
-    # Strategy 1: Find all properly closed <tag>content</tag> blocks
-    properly_closed = re.findall(
-        rf"<{tag_esc}[^>]*>(.*?)</{tag_esc}\s*>",
-        text,
-        re.DOTALL | re.IGNORECASE,
-    )
-    if properly_closed:
-        return [html.unescape(b) for b in properly_closed]
-
-    # Conservative mode: only extract properly closed blocks
-    if conservative:
-        return []
-
-    # Strategy 2: Split by <tag> openings — each segment is a block
-    positions = [
-        m.end() for m in re.finditer(rf"<{tag_esc}[^>]*>", text, re.IGNORECASE)
-    ]
-
-    for i, content_start in enumerate(positions):
-        if i + 1 < len(positions):
-            # Block ends at next <tag> opening
-            content_end = positions[i + 1]
-        elif parent_close_tag:
-            # Last block — ends at parent close tag
-            close_m = re.search(
-                re.escape(parent_close_tag),
-                text[content_start:],
-                re.IGNORECASE,
-            )
-            content_end = content_start + close_m.start() if close_m else len(text)
-        else:
-            content_end = len(text)
-
-        blocks.append(html.unescape(text[content_start:content_end]))
-
-    return blocks
-
-
-def _extract_output_body(raw_text: str) -> str | None:
-    """Extract the content between ``<output>`` and ``</output>``.
-
-    If ``</output>`` is missing (unclosed), returns everything after the
-    opening ``<output>`` tag.
-
-    Returns ``None`` if no ``<output>`` opening tag is found at all.
-    """
-    open_match = re.search(r"<output[^>]*>", raw_text, re.IGNORECASE)
-    if open_match is None:
-        return None
-
-    content_start = open_match.end()
-
-    close_match = re.search(
-        r"</output\s*>",
-        raw_text[content_start:],
-        re.IGNORECASE,
-    )
-    if close_match:
-        return raw_text[content_start : content_start + close_match.start()]
-
-    # Unclosed <output> — take everything after it
-    return raw_text[content_start:]
-
-
-def _strip_outer_noise(text: str) -> str:
-    """Remove text that is outside any recognised XML tags.
-
-    This handles the case where the LLM outputs plain text before or
-    after the ``<output>`` block, e.g.::
-
-        "我来使用 Python 脚本下载... <output>...</output>"
-
-    The function returns the ``<output>…</output>`` body, or the original
-    text if no output block is found.
-    """
-    if not text:
-        return text
-
-    body = _extract_output_body(text)
-    if body is not None:
-        return body
-
-    # No <output> tag at all — check if there are any recognised tags
-    has_tags = False
-    for tag in KNOWN_TOP_LEVEL_TAGS:
-        if re.search(rf"<{re.escape(tag)}[\s>]", text, re.IGNORECASE):
-            has_tags = True
-            break
-
-    if has_tags:
-        # Tags exist but no <output> wrapper — return as-is
-        return text
-
-    # No tags at all — return original (caller will set needs_correction)
-    return text
-
-
-def is_output_block_complete(raw_text: str) -> bool:
-    """Check if *raw_text* contains a properly closed ``<output>...</output>`` block.
-
-    Returns:
-        True if both ``<output>`` and ``</output>`` tags are present.
-        False if neither tag, or only the opening tag, is found.
-    """
-    if not raw_text:
-        return False
-    open_m = re.search(r"<output[^>]*>", raw_text, re.IGNORECASE)
-    if open_m is None:
-        return False
-    close_m = re.search(r"</output\s*>", raw_text[open_m.end():], re.IGNORECASE)
-    return close_m is not None
-
-
-# ---------------------------------------------------------------------------
-# Core custom parser — NO xml.etree.ElementTree
-# ---------------------------------------------------------------------------
-
-
-def _custom_parse(raw_text: str) -> ParsedOutput:
-    """Fully custom, regex-based XML parser with maximum fault tolerance.
-
-    This function does NOT use ``xml.etree.ElementTree`` at all.  Every
-    extraction is done via regex patterns that handle malformed XML
-    gracefully.
-
-    Returns a :class:`ParsedOutput` with ``parse_success=True`` if at least
-    one meaningful field was extracted, or ``needs_correction=True`` if
-    nothing could be parsed.
-    """
-    parsed = ParsedOutput(raw_text=raw_text)
-
-    if not raw_text or not raw_text.strip():
-        parsed.needs_correction = True
-        return parsed
-
-    # ── Step 0: 检查 <output> 块，处理缺少开始/闭合标签的情况 ──
-    _has_open = bool(re.search(r"<output[^>]*>", raw_text, re.IGNORECASE))
-    _has_close = bool(re.search(r"</output\s*>", raw_text, re.IGNORECASE))
-
-    if not _has_open and not _has_close:
-        # 完全没有 <output> 标签 — 检查是否包含已知子标签
-        _has_known_tags = any(
-            re.search(rf"<{re.escape(t)}[\s>]", raw_text, re.IGNORECASE)
-            for t in KNOWN_TOP_LEVEL_TAGS
-        )
-        if _has_known_tags:
-            # 有子标签但缺少 <output> 包装 — 自动补全后正常解析
-            logger.info(
-                "LLM 输出缺少 <output> 标签但包含已知子标签，"
-                "自动补全 <output> 包装后解析"
-            )
-            raw_text = "<output>\n" + raw_text.strip() + "\n</output>"
-            parsed.output_block_complete = True
-        else:
-            parsed.output_block_complete = False
-    elif _has_open and not _has_close:
-        parsed.output_block_complete = False
-    elif not _has_open and _has_close:
-        # 有闭合标签但没开始标签 — 补全开始标签
-        logger.info("LLM 输出缺少 <output> 开始标签但有 </output>，自动补全")
-        raw_text = "<output>\n" + raw_text.strip()
-        parsed.output_block_complete = True
-    else:
-        parsed.output_block_complete = True
-
-    conservative = not parsed.output_block_complete
-
-    if conservative:
-        logger.warning(
-            "XML <output> 块不完整（缺少 </output> 闭合标签），"
-            "启用保守解析模式（仅提取完整闭合的标签）\n"
-            "====== LLM 完整输出开始 ======\n"
-            f"{raw_text}\n"
-            "====== LLM 完整输出结束 ======"
-        )
-
-    # ── Step 1: Strip non-XML noise (text before/after <output>) ──
-    body = _strip_outer_noise(raw_text)
-
-    # ── Step 2: Extract each known top-level tag ──
-
-    # usersays_correct
-    raw_val = _extract_tag_content(body, "usersays_correct", conservative=conservative)
-    parsed.usersays_correct = _safe_strip(raw_val)
-
-    # task_plan [v1.34.5] 任务计划（Markdown格式）
-    raw_val = _extract_tag_content(body, "task_plan", conservative=conservative)
-    parsed.task_plan = _safe_strip(raw_val)
-
-    # [v1.37] 不再提取 <response> — 统一使用 <reply>，<response> 标签直接剥离不保留
-    # reply — 用户可见文本（唯一回复来源）
-    # [v1.38] 保守模式下 <reply> 仍尝试宽松提取 — LLM 输出截断时 <reply> 常不完整但包含重要内容
-    raw_val = _extract_tag_content(body, "reply", conservative=conservative)
-    if not raw_val.strip() and conservative:
-        # 保守模式未提取到闭合的 <reply>，尝试宽松模式（允许未闭合标签）
-        raw_val = _extract_tag_content(body, "reply", conservative=False)
-        if raw_val.strip():
-            logger.info("保守模式下 <reply> 未闭合但通过宽松提取恢复内容")
-    parsed.reply = _safe_strip(raw_val)
-
-    # recall
-    raw_val = _extract_tag_content(body, "recall", conservative=conservative)
-    parsed.recall = _safe_strip(raw_val)
-
-    # knowledge
-    raw_val = _extract_tag_content(body, "knowledge", conservative=conservative)
-    parsed.knowledge = _safe_strip(raw_val)
-
-    # get_knowledge
-    raw_val = _extract_tag_content(body, "get_knowledge", conservative=conservative)
-    parsed.get_knowledge = _safe_strip(raw_val)
-
-
-
-    # mainsubject [v1.15.8] 会话标题自动命名
-    raw_val = _extract_tag_content(body, "mainsubject", conservative=conservative)
-    parsed.mainsubject = _safe_strip(raw_val)
-
-    # ── Step 3: Parse <remember> (may contain <type> and <content>) ──
-    remember_raw = _extract_tag_content(body, "remember", conservative=conservative)
-    if remember_raw.strip():
-        # Try structured format: <type>global</type><content>...</content>
-        type_val = _extract_tag_content(remember_raw, "type", REMEMBER_INNER_TAGS, conservative=conservative)
-        content_val = _extract_tag_content(remember_raw, "content", REMEMBER_INNER_TAGS, conservative=conservative)
-
-        if content_val.strip():
-            mem_type = _safe_strip(type_val) or "session"
-            if mem_type not in ("global", "session"):
-                mem_type = "session"
-            parsed.remember = _safe_strip(content_val)
-            parsed.remember_type = mem_type
-        else:
-            # Legacy plain-text format
-            parsed.remember = _safe_strip(remember_raw)
-            parsed.remember_type = "session"
-
-    # ── Step 4: Parse <toolstocal> → list of tool dicts ──
-    toolstocal_raw = _extract_tag_content(body, "toolstocal", conservative=conservative)
-    if toolstocal_raw.strip():
-        parsed.tools_to_call = _parse_toolstocal(toolstocal_raw, conservative=conservative)
-
-    # ── Step 4.5: 兜底机制 — 宽松提取工具调用，确保执行不会因解析错误而中断 ──
-    # 策略优先级:
-    #   1. _parse_toolstocal 已成功提取 → 不做任何事
-    #   2. 直接在整个输出中搜索 <tool>...</tool> 块（跳过 toolstocal 包装）
-    #   3. 搜索散落的 <toolname>...</toolname> + <parms>...</parms> 配对
-    if not parsed.tools_to_call:
-        # 兜底 Level 1: 在整个原始文本中直接搜索 <tool> 块
-        _raw_tool_blocks = _extract_all_tag_blocks(
-            raw_text, "tool", parent_close_tag=None, conservative=False,
-        )
-        for block in _raw_tool_blocks:
-            tn = _safe_strip(_extract_tag_content(block, "toolname", TOOL_INNER_TAGS))
-            if tn:
-                parsed.tools_to_call.append({
-                    "toolname": tn,
-                    "parms": _safe_strip(_extract_tag_content(block, "parms", TOOL_INNER_TAGS)),
-                    "timeout": _parse_int(_extract_tag_content(block, "timeout", TOOL_INNER_TAGS), _DEFAULT_TIMEOUT),
-                })
-                logger.info(f"[兜底L1] 从非<toolstocal>区域提取到工具调用: {tn}")
-
-    if not parsed.tools_to_call:
-        # 兜底 Level 2: 搜索散落的 <toolname>...</toolname>，然后在同一段中找最近的 <parms>
-        _toolname_positions = []
-        for m in re.finditer(r"<toolname[^>]*>(.*?)</toolname\s*>", raw_text, re.DOTALL | re.IGNORECASE):
-            tn = html.unescape(m.group(1)).strip()
-            if tn:
-                _toolname_positions.append((m.start(), m.end(), tn))
-
-        if _toolname_positions:
-            logger.info(f"[兜底L2] 找到 {len(_toolname_positions)} 个散落的 <toolname> 标签")
-            for _i, (_start, _end, _tn) in enumerate(_toolname_positions):
-                # 在 toolname 之后的 500 字符内搜索最近的 <parms>
-                _search_region = raw_text[_end:_end + 500]
-                _parms_match = re.search(
-                    r"<parms[^>]*>(.*?)</parms\s*>",
-                    _search_region, re.DOTALL | re.IGNORECASE,
-                )
-                _parms = html.unescape(_parms_match.group(1)).strip() if _parms_match else ""
-
-                # 也尝试在 toolname 之前的 200 字符内搜索（parms 可能在 toolname 前面）
-                if not _parms:
-                    _pre_region = raw_text[max(0, _start - 200):_start]
-                    _parms_match = re.search(
-                        r"<parms[^>]*>(.*?)</parms\s*>",
-                        _pre_region, re.DOTALL | re.IGNORECASE,
-                    )
-                    _parms = html.unescape(_parms_match.group(1)).strip() if _parms_match else ""
-
-                parsed.tools_to_call.append({
-                    "toolname": _tn,
-                    "parms": _parms,
-                    "timeout": _DEFAULT_TIMEOUT,
-                })
-                logger.info(f"[兜底L2] 散落提取工具: {_tn}, parms={'有' if _parms else '无'}")
-
-    # ── Step 5: Determine parse success ──
-    has_content = bool(
-        parsed.reply
-        or parsed.usersays_correct
-        or parsed.tools_to_call
-        or parsed.remember
-        or parsed.recall
-        or parsed.knowledge
-        or parsed.get_knowledge
-    )
-
-    if has_content:
-        parsed.parse_success = True
-    else:
-        # Nothing was extracted — check if there's any raw text that could
-        # be a response (the LLM might have skipped XML entirely)
-        cleaned = raw_text.strip()
-        # Remove any residual XML tags
-        cleaned_no_tags = re.sub(r"<[^>]+>", "", cleaned).strip()
-        if cleaned_no_tags:
-            # The LLM output something but not in XML format
-            # Treat the entire output as a response
-            parsed.reply = cleaned_no_tags
-            parsed.parse_success = True
-            logger.info(
-                f"XML解析未提取到结构化字段，将原始文本（去除标签后）作为reply: "
-                f"{cleaned_no_tags[:100]}..."
-            )
-        else:
-            # Complete parse failure
-            parsed.needs_correction = True
-            logger.warning(
-                f"XML解析完全失败，需要LLM修正。原始输出前200字符: {raw_text[:200]}"
-            )
-
-    return parsed
-
-
-def _parse_toolstocal(toolstocal_content: str, *, conservative: bool = False) -> List[Dict[str, Any]]:
-    """Parse ``<toolstocal>`` body into a list of tool descriptors."""
-    tools: List[Dict[str, Any]] = []
-
-    tool_blocks = _extract_all_tag_blocks(
-        toolstocal_content, "tool", parent_close_tag="</toolstocal>",
-        conservative=conservative,
-    )
-
-    for block in tool_blocks:
-        tool: Dict[str, Any] = {
-            "toolname": _safe_strip(
-                _extract_tag_content(block, "toolname", TOOL_INNER_TAGS, conservative=conservative)
-            ),
-            "parms": _safe_strip(
-                _extract_tag_content(block, "parms", TOOL_INNER_TAGS, conservative=conservative)
-            ),
-            "timeout": _parse_int(
-                _extract_tag_content(block, "timeout", TOOL_INNER_TAGS, conservative=conservative),
-                _DEFAULT_TIMEOUT,
-            ),
-        }
-        # Only add if toolname is present
-        if tool["toolname"]:
-            tools.append(tool)
-
-    return tools
-
-
-# ---------------------------------------------------------------------------
-# Public API
-# ---------------------------------------------------------------------------
-
-
-def parse_output(raw_text: str) -> ParsedOutput:
-    """Parse the LLM's raw response into a :class:`ParsedOutput`.
-
-    This function uses a **fully custom regex-based parser** (no
-    ``xml.etree.ElementTree``) for maximum fault tolerance.
-
-    If the custom parser cannot extract any meaningful content, it falls
-    back to treating the raw text as a plain response.  Only if even that
-    fails does it set ``needs_correction=True``, signalling the caller to
-    ask the LLM to re-format its output.
-
-    Parameters:
-        raw_text: The complete text returned by the LLM.
-
-    Returns:
-        A :class:`ParsedOutput` instance.
-    """
-    if not raw_text:
-        return ParsedOutput(raw_text=raw_text, needs_correction=True)
-
-    return _custom_parse(raw_text)
-
-
-def extract_surrounding_text(full_text: str) -> tuple[str, str]:
-    """Split *full_text* around the ``<output>…</output>`` block.
-
-    Returns:
-        A ``(text_before_xml, text_after_xml)`` tuple.  Both parts are
-        stripped.  If no ``<output>`` block is found the original text
-        becomes *text_before_xml* and *text_after_xml* is ``""``.
-    """
-    open_match = re.search(r"<output[^>]*>", full_text, re.IGNORECASE)
-    if open_match is None:
-        return full_text.strip(), ""
-
-    text_before = full_text[: open_match.start()].strip()
-
-    rest = full_text[open_match.end() :]
-    close_match = re.search(r"</output\s*>", rest, re.IGNORECASE)
-    if close_match is None:
-        text_after = rest.strip()
-    else:
-        text_after = rest[close_match.end() :].strip()
-
-    return text_before, text_after
-
-
-# ---------------------------------------------------------------------------
-# Validation
-# ---------------------------------------------------------------------------
-
-
-def validate_output(parsed: ParsedOutput) -> list[str]:
-    """Validate a :class:`ParsedOutput` and return a list of warnings.
-
-    An empty list means no issues were detected.  Warnings are non-fatal
-    hints that the calling code may log or present to the user.
-    """
-    warnings: list[str] = []
-
-    # --- Tool-level checks ---
-    for idx, tool in enumerate(parsed.tools_to_call):
-        prefix = f"tool[{idx}]"
-
-        if not tool.get("toolname"):
-            warnings.append(f"{prefix}: missing 'toolname'")
-
-        timeout = tool.get("timeout", _DEFAULT_TIMEOUT)
-        if isinstance(timeout, int) and timeout <= 0:
-            warnings.append(
-                f"{prefix}: timeout={timeout} is not positive; "
-                f"defaulting to {_DEFAULT_TIMEOUT}s"
-            )
-
-        if tool.get("toolname") and not tool.get("parms"):
-            warnings.append(
-                f"{prefix} ('{tool['toolname']}'): 'parms' is empty — "
-                "verify the tool requires no parameters"
-            )
-
-    # --- Semantic checks ---
-    # [v1.36] askuser/finish/finish_reason 已废弃，移除相关校验
-
-    return warnings