nonebot-plugin-hermes 0.2.1__tar.gz → 0.2.2__tar.gz

{nonebot_plugin_hermes-0.2.1 → nonebot_plugin_hermes-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nonebot-plugin-hermes
-Version: 0.2.1
+Version: 0.2.2
 Summary: NoneBot plugin for Hermes Agent — multi-platform AI chatbot via Hermes API Server
 License: MIT
 Project-URL: Homepage, https://github.com/gsskk/nonebot-plugin-hermes
@@ -304,7 +304,6 @@ mcp_servers:
 | `HERMES_MCP_HOST` | `127.0.0.1` | MCP server 绑定地址。改成公开地址前请阅读上文「群活跃态 + 反向通道」节的安全注意 |
 | `HERMES_MCP_PORT` | `8643` | MCP server 绑定端口 |
 | `HERMES_MCP_RECENT_LIMIT_MAX` | `50` | `get_recent_messages` 工具单次最大返回条数 |
-| `HERMES_STRUCTURED_PATH` | `prompt` | reactive 结构化输出路径: `prompt`（JSON5 解析） / `tools`（OpenAI tool_choice） |
 
 ## 限制
 

{nonebot_plugin_hermes-0.2.1 → nonebot_plugin_hermes-0.2.2}/README.md

@@ -285,7 +285,6 @@ mcp_servers:
 | `HERMES_MCP_HOST` | `127.0.0.1` | MCP server 绑定地址。改成公开地址前请阅读上文「群活跃态 + 反向通道」节的安全注意 |
 | `HERMES_MCP_PORT` | `8643` | MCP server 绑定端口 |
 | `HERMES_MCP_RECENT_LIMIT_MAX` | `50` | `get_recent_messages` 工具单次最大返回条数 |
-| `HERMES_STRUCTURED_PATH` | `prompt` | reactive 结构化输出路径: `prompt`（JSON5 解析） / `tools`（OpenAI tool_choice） |
 
 ## 限制
 

{nonebot_plugin_hermes-0.2.1 → nonebot_plugin_hermes-0.2.2}/nonebot_plugin_hermes/__init__.py

@@ -13,7 +13,7 @@ require("nonebot_plugin_apscheduler")
 
 from .config import Config, plugin_config
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 
 __plugin_meta__ = PluginMetadata(
     name="Hermes Agent",

{nonebot_plugin_hermes-0.2.1 → nonebot_plugin_hermes-0.2.2}/nonebot_plugin_hermes/config.py

@@ -4,7 +4,7 @@
 所有配置项通过 NoneBot 的 .env 文件读取，前缀为 HERMES_。
 """
 
-from typing import Literal, Set
+from typing import Set
 
 from nonebot import get_plugin_config
 from pydantic import BaseModel, Field
@@ -106,11 +106,5 @@ class Config(BaseModel):
     """get_recent_messages 工具单次返回上限。最小 1——0/负值会让工具静默返空,
     Pydantic 在启动期校验防 misconfig。"""
 
-    # --- M1: 结构化输出路径(由 P0-spike 决定) ---
-    hermes_structured_path: Literal["tools", "prompt"] = "prompt"
-    """tools = 路径 A(tools+tool_choice);prompt = 路径 B(JSON5)。
-    Task 3 spike (2026-05-09) 结论:Hermes 不透传 tools/tool_choice 给底层 LLM,
-    必须用 prompt 强约束 + JSON5 容错解析。"""
-
 
 plugin_config = get_plugin_config(Config)

{nonebot_plugin_hermes-0.2.1 → nonebot_plugin_hermes-0.2.2}/nonebot_plugin_hermes/core/hermes_client.py

@@ -7,6 +7,7 @@ M1-mem 路径 B(P0-spike 决策):tools/tool_choice 被 Hermes 吞掉,改用 syst
 
 from __future__ import annotations
 
+import json
 import re
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Literal, Optional, Tuple, Union
@@ -23,6 +24,16 @@ UserContent = Union[str, List[Dict[str, Any]]]
 _MD_IMAGE_PATTERN = re.compile(r"!\[([^\]]*)\]\(([^)]+)\)")
 _MEDIA_TAG_PATTERN = re.compile(r"MEDIA:(\S+)")
 
+# Hermes apiserver 把 provider 端错误包成 502, body 形如:
+#   {"error": {"message": "Error code: 400 - {'error': {'message': '...'}}"}}
+# 把外层 502 当真因显示会误导, 因此抠出内层 status 与 reason。
+_INNER_STATUS_RE = re.compile(r"Error code:\s*(\d+)")
+_VISION_UNSUPPORTED_RE = re.compile(
+    r"unknown variant\s+[`'\"]image_url|image_url.*not.*support|does not support.*image|"
+    r"input_image.*not.*support|multimodal.*not.*support",
+    re.IGNORECASE,
+)
+
 # 提取首个 {...} 块。
 # 当前正则只支持嵌套一层(`\{[^{}]*\}` 出现在外层 `\{...\}` 中)。
 # M1 submit_decision schema 全平,够用。如未来 schema 加 nested object,
@@ -36,10 +47,101 @@ _DECISION_HINT = (
     "  reply_text (string, optional, required when should_reply=true)\n"
     "  topic_hint (string, optional)\n"
     "  should_exit_active (boolean, optional)\n"
-    "Output ONLY the JSON object, no preamble, no postscript, no markdown fences."
+    "Output ONLY the JSON object, no preamble, no postscript, no markdown fences.\n"
+    "All string values MUST be single-line; escape line breaks inside strings as \\n (no raw newlines)."
 )
 
 
+def _escape_raw_newlines_in_strings(s: str) -> str:
+    """把 JSON 字符串字面量内部的裸 \\n/\\r/\\t 转义掉,让 json5 能解析。
+
+    LLM 经常在 reply_text 里嵌真换行(段落分隔),JSON5 字符串不允许;首发 json5
+    抛 `Unexpected "\\n"` 后我们走这一遍状态机重试一次。状态:跟踪 " / ' 进出
+    string、`\\X` 整对透传(不参与 quote 计数),quoted 区里把裸控制字符替换。
+    """
+    out: List[str] = []
+    in_string = False
+    quote = ""
+    i = 0
+    n = len(s)
+    while i < n:
+        c = s[i]
+        if not in_string:
+            if c == '"' or c == "'":
+                in_string = True
+                quote = c
+            out.append(c)
+            i += 1
+            continue
+        # 在 string 内
+        if c == "\\" and i + 1 < n:
+            # 转义序列整对透传(含 \" / \' / \\ / \n 等),不参与 quote 计数
+            out.append(s[i : i + 2])
+            i += 2
+            continue
+        if c == quote:
+            in_string = False
+            quote = ""
+            out.append(c)
+            i += 1
+            continue
+        if c == "\n":
+            out.append("\\n")
+        elif c == "\r":
+            out.append("\\r")
+        elif c == "\t":
+            out.append("\\t")
+        else:
+            out.append(c)
+        i += 1
+    return "".join(out)
+
+
+def _summarize_error_body(body: str) -> Tuple[str, Optional[int]]:
+    """从 Hermes 错误响应体里抠出可读 reason 与内层 status。
+
+    Hermes apiserver 习惯把 provider 端错误外包成 502, body 是 JSON, `error.message`
+    形如 `"Error code: 400 - {...}"`。直接把 200 字符 body 倒进日志噪音大、
+    用户看到只剩外层 502 完全不知道发生了什么, 所以这里先剥一层。
+
+    返回 (reason_snippet, inner_status_or_None);body 不可解析时退化到 body 截断。
+    """
+    if not body:
+        return "(empty body)", None
+    raw = body.strip()
+    try:
+        parsed = json.loads(raw)
+    except (json.JSONDecodeError, ValueError):
+        return raw[:200], None
+    err = parsed.get("error") if isinstance(parsed, dict) else None
+    if isinstance(err, dict):
+        msg = str(err.get("message") or err).strip()
+    elif isinstance(err, str):
+        msg = err.strip()
+    else:
+        msg = raw[:200]
+    inner_status: Optional[int] = None
+    m = _INNER_STATUS_RE.search(msg)
+    if m:
+        try:
+            inner_status = int(m.group(1))
+        except ValueError:
+            inner_status = None
+    return msg[:300], inner_status
+
+
+def _user_facing_error(reason: str) -> str:
+    """把 _summarize_error_body 的 reason 翻译成给群里发的简短提示。
+
+    命中已知模式(目前: 图片输入被非 vision 模型拒)就给精准提示;否则带 reason 片段
+    让用户能直接看到真因, 不再只露一个误导性的 502。
+    """
+    if _VISION_UNSUPPORTED_RE.search(reason):
+        return "⚠️ 当前主模型不支持图片识别,请改用文字提问或换用 vision 模型"
+    snippet = reason.strip().splitlines()[0][:140] if reason.strip() else "未知错误"
+    return f"⚠️ AI 服务异常: {snippet}"
+
+
 def extract_response_media(text: str) -> Tuple[str, List[str]]:
     """从 Hermes 回复中提取 markdown 图片 / MEDIA: 标签 URL,返回 (清洗后文本, URL 列表)。"""
     media_urls: List[str] = []
@@ -55,16 +157,24 @@ def extract_response_media(text: str) -> Tuple[str, List[str]]:
 
 
 def _try_parse_first_json_block(text: str) -> Optional[Dict[str, Any]]:
-    """从模型回复中提取首个 {...} 块并 JSON5 解析。失败返回 None,调用方记 parse_failed。"""
+    """从模型回复中提取首个 {...} 块并 JSON5 解析。失败返回 None,调用方记 parse_failed。
+
+    两段式回退:json5 首发失败 → 走 _escape_raw_newlines_in_strings 把字符串内
+    的裸控制字符转义后重试。两次都失败才返回 None。
+    """
     if not text:
         return None
     m = _FIRST_JSON_BLOCK.search(text)
     if not m:
         return None
+    candidate = m.group(0)
     try:
-        parsed = json5.loads(m.group(0))
+        parsed = json5.loads(candidate)
     except Exception:
-        return None
+        try:
+            parsed = json5.loads(_escape_raw_newlines_in_strings(candidate))
+        except Exception:
+            return None
     if not isinstance(parsed, dict):
         return None
     return parsed
@@ -212,10 +322,11 @@ class HermesClient:
             async with httpx.AsyncClient(timeout=self.timeout) as client:
                 resp = await client.post(url, json=payload, headers=headers)
                 if resp.status_code != 200:
-                    body = resp.text[:200]
-                    logger.error(f"[HERMES] API 返回 {resp.status_code}: {body}")
+                    reason, inner_status = _summarize_error_body(resp.text)
+                    inner_tag = f" inner={inner_status}" if inner_status else ""
+                    logger.error(f"[HERMES] upstream HTTP {resp.status_code}{inner_tag}: {reason}")
                     return ChatResult(
-                        raw_text=f"⚠️ AI 服务返回错误 ({resp.status_code})",
+                        raw_text=_user_facing_error(reason),
                         parse_failed=True,
                         is_transport_error=True,
                     )

nonebot_plugin_hermes-0.2.2/nonebot_plugin_hermes/core/inflight.py

@@ -0,0 +1,71 @@
+"""In-flight 调用追踪 + coalesce 重燃支持。
+
+修同一 (adapter, group_id|user_id) 上事件 task 并发调 chat() 的 bug:
+in-flight 时新消息只更新 pending 单元,等当前一发完成后再合并跑一次。
+
+线程安全:**否**。预设单线程 asyncio 事件循环,与 ActiveSessionManager 一致。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Literal, Optional, Tuple
+
+from .message_buffer import BufferedMessage
+
+
+# Refire 链最大深度。超过则丢 pending、warn,等下一个新触发。
+# 一次 burst 最多产出 1(主回) + MAX_REFIRE_DEPTH(链尾)= 4 发回复。
+MAX_REFIRE_DEPTH = 3
+
+
+@dataclass
+class InflightSlot:
+    started_at: int
+    pending: Optional[BufferedMessage] = None
+
+
+class InflightRegistry:
+    """per-target 非阻塞 busy 标记 + pending 单元。
+
+    Key 约定:
+      - 群: ("adapter", "group:" + group_id)
+      - 私聊: ("adapter", "private:" + user_id)
+
+    不持有任何 asyncio.Task 引用 —— 重燃由 caller 用 create_task 自己接手,
+    registry 只负责「现在有没有人在跑」+「跑完后是否要再跑一次」两个状态。
+    """
+
+    def __init__(self) -> None:
+        self._slots: Dict[Tuple[str, str], InflightSlot] = {}
+
+    def try_enter(
+        self,
+        key: Tuple[str, str],
+        current_msg: BufferedMessage,
+        now_ms: int,
+    ) -> Literal["entered", "pending_set"]:
+        """无 slot → 占位 started_at=now_ms,返回 'entered'。
+        有 slot → 把 current_msg 写进 pending(覆盖旧 pending),返回 'pending_set'。
+        """
+        slot = self._slots.get(key)
+        if slot is None:
+            self._slots[key] = InflightSlot(started_at=now_ms)
+            return "entered"
+        slot.pending = current_msg
+        return "pending_set"
+
+    def take_pending(self, key: Tuple[str, str]) -> Optional[BufferedMessage]:
+        """Destructive read。无 slot 或 pending 为 None 都返回 None。"""
+        slot = self._slots.get(key)
+        if slot is None:
+            return None
+        msg = slot.pending
+        slot.pending = None
+        return msg
+
+    def exit(self, key: Tuple[str, str]) -> None:
+        """释放 slot。pending 仍在的话由调用方自行先 take_pending。
+        slot 不存在则 no-op。
+        """
+        self._slots.pop(key, None)

{nonebot_plugin_hermes-0.2.1 → nonebot_plugin_hermes-0.2.2}/nonebot_plugin_hermes/handlers/commands.py

@@ -168,7 +168,6 @@ async def handle_status(bot: Bot, event: Event, matcher: Matcher):
         "🔍 Hermes Plugin M1-mem 状态",
         f"MCP: {mcp_line}",
         f"active_session: {active_line}",
-        f"structured_path: {plugin_config.hermes_structured_path}",
         f"hermes_api: {plugin_config.hermes_api_url}",
         "",
         f"📊 ActiveSessions: {active_count} 个活跃",

{nonebot_plugin_hermes-0.2.1 → nonebot_plugin_hermes-0.2.2}/nonebot_plugin_hermes/handlers/message.py

@@ -7,6 +7,7 @@ priority=98 main:触发判断 → reactive 决策 → 出向
 
 from __future__ import annotations
 
+import asyncio
 import time
 from typing import List, Optional
 
@@ -264,7 +265,7 @@ async def handle_message(bot: Bot, event: Event, matcher: Matcher):
     )
 
 
-async def _handle_passive_path(
+async def _run_passive_turn(
     *,
     bot: Bot,
     target,
@@ -276,6 +277,7 @@ async def _handle_passive_path(
     is_private: bool,
     now_ms: int,
 ):
+    """跑一发 passive turn,返回 ChatResult 或 None(被 submit_decision 静默兜底等情况)。"""
     session_key = session_manager.get_session_key(
         adapter_name=adapter_name,
         is_private=is_private,
@@ -323,12 +325,12 @@ async def _handle_passive_path(
     if extracted is not None:
         if extracted == "":
             logger.info(f"[HERMES passive] LLM 返回 should_reply=false 结构,静默(group={group_id})")
-            return
+            return result
         logger.warning(f"[HERMES passive] 检测到 submit_decision 形 JSON 残留,抠 reply_text 后发送(group={group_id})")
         reply_text = extracted
 
     if not reply_text and not result.media_urls:
-        return
+        return result
     await send_text_with_media(
         bot=bot,
         target=target,
@@ -336,9 +338,10 @@ async def _handle_passive_path(
         media_urls=result.media_urls,
         at_user_id=None if is_private else user_id,
     )
+    return result
 
 
-async def _handle_reactive_path(
+async def _run_reactive_turn(
     *,
     bot: Bot,
     target,
@@ -350,13 +353,18 @@ async def _handle_reactive_path(
     is_explicit_trigger: bool,
     now_ms: int,
 ):
+    """跑一发 reactive turn,返回 hermes_client.chat() 的 ChatResult,或 None 表示提前 return。
+
+    外壳 _handle_reactive_path 负责 inflight + 图片门控,这里只管:
+    拉 recent → 组 prompt → 调 chat → 解析 decision → 发出向 → 回写 buffer。
+    """
     assert _mcp.message_buffer is not None and _mcp.active_sessions is not None
 
     # 用 get_if_active 而非 get():get() 是 debug-only 裸访问,可能返回已过期 session;
     # get_if_active 与 is_active(handle_message 入口处用过)同口径。
     session = _mcp.active_sessions.get_if_active(adapter_name, group_id, now_ms)
     if session is None:
-        return  # 防御:窗口刚刚过期 / 被外部 end()
+        return None  # 防御:窗口刚刚过期 / 被外部 end()
 
     recent = _mcp.message_buffer.get_recent(
         adapter=adapter_name,
@@ -418,7 +426,7 @@ async def _handle_reactive_path(
                 media_urls=result.media_urls,
                 at_user_id=user_id,
             )
-        return
+        return result
 
     decision_summary = (
         f"should_reply={result.structured.get('should_reply')} "
@@ -435,11 +443,11 @@ async def _handle_reactive_path(
 
     if not decision.get("should_reply"):
         logger.debug(f"[HERMES reactive] should_reply=false (group={group_id})")
-        return
+        return result
 
     reply_text = str(decision.get("reply_text") or "").strip()
     if not reply_text:
-        return
+        return result
 
     # 群里明确说话给某人 → at;主动插话 → 不 at
     at_user = user_id if is_explicit_trigger else None
@@ -469,3 +477,250 @@ async def _handle_reactive_path(
         # 注:若 should_exit_active=True,session 已在上方 end(),touch 是安全 no-op
         # (ActiveSessionManager.touch 文档:session 缺失则 no-op)。
         _mcp.active_sessions.touch(adapter_name, group_id, now_ms=now_ms)
+
+    return result
+
+
+async def _handle_passive_path(
+    *,
+    bot: Bot,
+    target,
+    adapter_name: str,
+    user_id: str,
+    group_id: Optional[str],
+    text: str,
+    image_urls: List[str],
+    is_private: bool,
+    now_ms: int,
+):
+    """Passive 外壳:inflight 占位 → _run_passive_turn → 合并重燃。
+
+    与 reactive 同形,key 含 private/group 前缀区分。
+    """
+    assert _mcp.inflight is not None
+
+    scope_id = user_id if is_private else (group_id or "")
+    scope_prefix = "private" if is_private else "group"
+    key = (adapter_name, f"{scope_prefix}:{scope_id}")
+
+    current_buffered = BufferedMessage(
+        ts=now_ms,
+        adapter=adapter_name,
+        group_id=group_id,
+        user_id=user_id,
+        nickname=user_id,
+        content=text,
+        image_urls=list(image_urls),
+        reply_to_ts=None,
+        is_bot=False,
+    )
+
+    if _mcp.inflight.try_enter(key, current_buffered, now_ms) == "pending_set":
+        return
+
+    should_refire = False
+    try:
+        result = await _run_passive_turn(
+            bot=bot,
+            target=target,
+            adapter_name=adapter_name,
+            user_id=user_id,
+            group_id=group_id,
+            text=text,
+            image_urls=image_urls,
+            is_private=is_private,
+            now_ms=now_ms,
+        )
+        should_refire = not (result is not None and result.is_transport_error)
+    except Exception:
+        logger.exception(f"[HERMES] passive turn raised; dropping pending for {key}")
+        should_refire = False
+        raise
+    finally:
+        if not should_refire:
+            _mcp.inflight.exit(key)
+        else:
+            pending = _mcp.inflight.take_pending(key)
+            if pending is None or pending.ts <= current_buffered.ts:
+                _mcp.inflight.exit(key)
+            else:
+                asyncio.create_task(
+                    _refire(
+                        key=key,
+                        trigger_msg=pending,
+                        depth=1,
+                        mode="passive",
+                        bot=bot,
+                        target=target,
+                        adapter_name=adapter_name,
+                        group_id=group_id,
+                    )
+                )
+
+
+async def _handle_reactive_path(
+    *,
+    bot: Bot,
+    target,
+    adapter_name: str,
+    user_id: str,
+    group_id: str,
+    text: str,
+    image_urls: List[str],
+    is_explicit_trigger: bool,
+    now_ms: int,
+):
+    """Reactive 外壳:inflight 占位 → 调 _run_reactive_turn → finally 合并重燃。
+
+    coalesce 语义:in-flight 期间到来的新触发不并发跑,只覆盖 pending 单元;
+    本发完成后 take_pending,如有则用 create_task 起一个 _refire 接力,
+    本 task 立即 return,不阻塞 NoneBot 事件循环。
+    """
+    assert _mcp.inflight is not None and _mcp.active_sessions is not None
+
+    # 图片门控:active window + 非显式触发 + 纯图无文本 → 跳过 chat()
+    # 理由:LLM 自己的 should_reply 决策对图片要先看完才能定,而看图本身慢。
+    # 这种「旁观纯图」最大概率是 should_reply=false,跳过它就是省一次多模态调用。
+    # 消息已被 priority=1 perception 写入 MessageBuffer,等下次文本触发能看到。
+    in_active = _mcp.active_sessions.is_active(adapter_name, group_id, now_ms)
+    if in_active and not is_explicit_trigger and image_urls and not text.strip():
+        logger.debug(
+            f"[HERMES reactive] skip image-only passive in-window msg "
+            f"(group={group_id} user={user_id}); buffered for next text trigger"
+        )
+        return
+
+    key = (adapter_name, f"group:{group_id}")
+    current_buffered = BufferedMessage(
+        ts=now_ms,
+        adapter=adapter_name,
+        group_id=group_id,
+        user_id=user_id,
+        nickname=user_id,
+        content=text,
+        image_urls=list(image_urls),
+        reply_to_ts=None,
+        is_bot=False,
+    )
+
+    if _mcp.inflight.try_enter(key, current_buffered, now_ms) == "pending_set":
+        return
+
+    should_refire = False
+    try:
+        result = await _run_reactive_turn(
+            bot=bot,
+            target=target,
+            adapter_name=adapter_name,
+            user_id=user_id,
+            group_id=group_id,
+            text=text,
+            image_urls=image_urls,
+            is_explicit_trigger=is_explicit_trigger,
+            now_ms=now_ms,
+        )
+        should_refire = not (result is not None and result.is_transport_error)
+    except Exception:
+        logger.exception(f"[HERMES] reactive turn raised; dropping pending for {key}")
+        should_refire = False
+        raise
+    finally:
+        if not should_refire:
+            _mcp.inflight.exit(key)
+        else:
+            pending = _mcp.inflight.take_pending(key)
+            if pending is None or pending.ts <= current_buffered.ts:
+                _mcp.inflight.exit(key)
+            else:
+                asyncio.create_task(
+                    _refire(
+                        key=key,
+                        trigger_msg=pending,
+                        depth=1,
+                        mode="reactive",
+                        bot=bot,
+                        target=target,
+                        adapter_name=adapter_name,
+                        group_id=group_id,
+                    )
+                )
+
+
+async def _refire(
+    *,
+    key,
+    trigger_msg: BufferedMessage,
+    depth: int,
+    mode: str,
+    bot: Bot,
+    target,
+    adapter_name: str,
+    group_id,
+):
+    """链式重燃。fire-and-forget,深度上限 MAX_REFIRE_DEPTH。"""
+    from ..core.inflight import MAX_REFIRE_DEPTH
+
+    assert _mcp.inflight is not None
+
+    if depth > MAX_REFIRE_DEPTH:
+        logger.warning(f"[HERMES] refire depth exceeded ({depth}); dropping pending {key}")
+        _mcp.inflight.exit(key)
+        return
+
+    # now_ms 用 wall-clock 而不是 trigger_msg.ts:_run_*_turn 内部用它做
+    # get_if_active 的 TTL 校验、active_sessions.touch 的滑动续期、以及 bot
+    # 自己回复的 BufferedMessage.ts。如果用 trigger 时间会导致 touch 后窗口
+    # 比预期早 N 秒过期、bot 回复时间戳倒退。trigger_msg.ts 只在 finally 的
+    # pending.ts 比对里用,那是消息到达时序而非「当前是几点」。
+    refire_now_ms = _now_ms()
+    should_refire = False
+    try:
+        if mode == "reactive":
+            assert group_id is not None
+            result = await _run_reactive_turn(
+                bot=bot,
+                target=target,
+                adapter_name=adapter_name,
+                user_id=trigger_msg.user_id,
+                group_id=group_id,
+                text=trigger_msg.content,
+                image_urls=list(trigger_msg.image_urls),
+                is_explicit_trigger=False,  # 重燃总是 passive 旁观;显式触发已是初发那一发
+                now_ms=refire_now_ms,
+            )
+        else:
+            result = await _run_passive_turn(
+                bot=bot,
+                target=target,
+                adapter_name=adapter_name,
+                user_id=trigger_msg.user_id,
+                group_id=trigger_msg.group_id,
+                text=trigger_msg.content,
+                image_urls=list(trigger_msg.image_urls),
+                is_private=trigger_msg.group_id is None,
+                now_ms=refire_now_ms,
+            )
+        should_refire = not (result is not None and result.is_transport_error)
+    except Exception:
+        logger.exception(f"[HERMES] refire raised at depth {depth}; dropping pending for {key}")
+        should_refire = False
+    finally:
+        if not should_refire:
+            _mcp.inflight.exit(key)
+            return
+        pending = _mcp.inflight.take_pending(key)
+        if pending and pending.ts > trigger_msg.ts:
+            asyncio.create_task(
+                _refire(
+                    key=key,
+                    trigger_msg=pending,
+                    depth=depth + 1,
+                    mode=mode,
+                    bot=bot,
+                    target=target,
+                    adapter_name=adapter_name,
+                    group_id=group_id,
+                )
+            )
+        else:
+            _mcp.inflight.exit(key)

{nonebot_plugin_hermes-0.2.1 → nonebot_plugin_hermes-0.2.2}/nonebot_plugin_hermes/mcp/__init__.py

@@ -13,6 +13,7 @@ from nonebot import get_driver, logger
 from ..config import plugin_config
 from ..core.active_session import ActiveSessionManager
 from ..core.bot_registry import BotRegistry
+from ..core.inflight import InflightRegistry
 from ..core.message_buffer import MessageBuffer
 from .server import build_mcp_app
 
@@ -66,14 +67,15 @@ if not any(isinstance(f, _ToolValidationLogRedirect) for f in _FASTMCP_TOOL_LOGG
 message_buffer: MessageBuffer | None = None
 active_sessions: ActiveSessionManager | None = None
 bot_registry: BotRegistry | None = None
+inflight: InflightRegistry | None = None
 
 _server_task: Optional[asyncio.Task] = None
 _uvicorn_server: Optional[uvicorn.Server] = None
 
 
 def init_runtime_state() -> None:
-    """由 plugin __init__.py 在 import 时调用,装配三个全局对象。"""
-    global message_buffer, active_sessions, bot_registry
+    """由 plugin __init__.py 在 import 时调用,装配全局对象。"""
+    global message_buffer, active_sessions, bot_registry, inflight
     if message_buffer is None:
         message_buffer = MessageBuffer(
             per_group_cap=plugin_config.hermes_buffer_per_group_cap,
@@ -85,6 +87,8 @@ def init_runtime_state() -> None:
         )
     if bot_registry is None:
         bot_registry = BotRegistry()
+    if inflight is None:
+        inflight = InflightRegistry()
 
 
 def _on_server_task_done(task: asyncio.Task) -> None: