@inline-chat/hermes-agent-adapter 1.0.0-alpha.3 → 1.0.1

package/plugin/inline/adapter.py

@@ -76,6 +76,16 @@ _CHAT_ACCESS_LOOKUP_TIMEOUT_SECONDS = 2.0
 _INBOUND_ACCESS_LOOKUP_TIMEOUT_SECONDS = 30.0
 _INBOUND_RETRY_INITIAL_SECONDS = 1.0
 _MAX_INBOUND_DELIVERIES = 16
+# Telegram's drop_pending_on_cold_boot, for Inline: updates the server recorded
+# before this gateway process started are acknowledged without waking the agent.
+# A lost or fresh SDK cursor otherwise replays chat history as new messages.
+_PROCESS_STARTED_AT = time.time()
+_COLD_BOOT_CLOCK_SKEW_SECONDS = 60
+_COLD_BOOT_DROP_LOG_INTERVAL_SECONDS = 60.0
+_COLD_BOOT_GATED_KINDS = frozenset({
+    "message.new", "message.edit", "message.delete", "message.history.clear",
+    "reaction.add", "reaction.delete", "chat.participant.add", "chat.participant.delete",
+})
 # Provider discovery may invoke host CLIs. Keep repeated panel opens and
 # unrelated mutations off that slow path while always injecting the live
 # current/default model into the document below.
@@ -196,11 +206,42 @@ def _truthy(value: Any, default: bool = False) -> bool:
     return str(value).strip().lower() in {"1", "true", "yes", "on"}
 
 
+_UNAVAILABLE_HERMES_SEAMS: set[str] = set()
+
+
+def _hermes_seam_unavailable(seam: str, effect: str, exc: Optional[BaseException] = None) -> None:
+    """Warn once per process that an undocumented Hermes internal is missing or changed.
+
+    Hermes documents no public API for these seams yet; the Inline repo tracks them in
+    plugins/hermes-agent/docs/hermes-upstream-seams.md.
+    Callers degrade the one feature that needs the seam; message delivery never depends on one.
+    """
+    if seam in _UNAVAILABLE_HERMES_SEAMS:
+        return
+    _UNAVAILABLE_HERMES_SEAMS.add(seam)
+    reason = f"{type(exc).__name__}: {exc}" if exc is not None else "missing"
+    logger.warning("[inline] Hermes internal %s is unavailable (%s); %s", seam, reason, effect)
+
+
+def _display_registration_fields() -> Dict[str, Any]:
+    """Inline's display defaults through the public PlatformEntry fields, when the host has them."""
+    try:
+        from gateway.platform_registry import PlatformEntry
+
+        fields = getattr(PlatformEntry, "__dataclass_fields__", {})
+        if {"display_tier", "display_overrides"}.issubset(fields):
+            # The overrides cover every key a tier sets, so the tier only names the closest base.
+            return {"display_tier": "low", "display_overrides": dict(_INLINE_DISPLAY_DEFAULTS)}
+    except Exception:
+        logger.debug("[inline] Hermes display registration fields are unavailable", exc_info=True)
+    return {}
+
+
 def _install_inline_display_defaults() -> None:
-    """Register Slack-like display defaults for Inline when Hermes exposes them.
+    """Seed Inline's display defaults on hosts that predate PlatformEntry.display_overrides.
 
-    Hermes core owns display resolution. External plugins do not yet have a
-    first-class display-default hook, so we seed the same private table core
+    Newer hosts take the same defaults from ``ctx.register_platform`` (see
+    ``_display_registration_fields``); only older ones need the private table core
     platforms use. User config still wins over these defaults.
     """
     try:
@@ -208,6 +249,10 @@ def _install_inline_display_defaults() -> None:
 
         defaults = getattr(_display_config, "_PLATFORM_DEFAULTS", None)
         if not isinstance(defaults, dict):
+            _hermes_seam_unavailable(
+                "gateway.display_config._PLATFORM_DEFAULTS",
+                "Inline uses Hermes' generic display defaults (tool progress may be shown)",
+            )
             return
         inline_defaults = dict(_INLINE_DISPLAY_DEFAULTS)
         current = defaults.get("inline")
@@ -215,8 +260,12 @@ def _install_inline_display_defaults() -> None:
             defaults["inline"] = {**inline_defaults, **current}
         else:
             defaults["inline"] = inline_defaults
-    except Exception:
-        logger.debug("[inline] failed to install display defaults", exc_info=True)
+    except Exception as exc:
+        _hermes_seam_unavailable(
+            "gateway.display_config._PLATFORM_DEFAULTS",
+            "Inline uses Hermes' generic display defaults (tool progress may be shown)",
+            exc,
+        )
 
 
 def _reply_thread_mode(value: Any, default: str = "auto") -> str:
@@ -560,7 +609,12 @@ def _normalize_inline_plugin_command_text(text: str) -> str:
         from hermes_cli.plugins import get_plugin_commands
         if command not in (get_plugin_commands() or {}):
             return text
-    except Exception:
+    except Exception as exc:
+        _hermes_seam_unavailable(
+            "hermes_cli.plugins.get_plugin_commands",
+            "hyphenated plugin commands must be typed with hyphens in Inline",
+            exc,
+        )
         return text
     # Inline menus require underscores, while Hermes registers plugin commands
     # with hyphens. Normalize before gateway access checks as well as dispatch.
@@ -575,16 +629,30 @@ def _normalize_inline_command_description(raw: str) -> str:
     return description
 
 
-def _inline_menu_commands(max_commands: int = _INLINE_COMMAND_LIMIT) -> tuple[List[Dict[str, Any]], int]:
-    from hermes_cli.commands_platforms import telegram_menu_commands
+def _hermes_menu_commands(max_commands: int) -> tuple[list, int]:
+    """Hermes' gateway command menu; empty when the host no longer exposes it."""
+    try:
+        from hermes_cli.commands_platforms import telegram_menu_commands
+
+        menu_commands, hidden_count = telegram_menu_commands(max_commands=max_commands)
+        return list(menu_commands or []), int(hidden_count or 0)
+    except Exception as exc:
+        _hermes_seam_unavailable(
+            "hermes_cli.commands_platforms.telegram_menu_commands",
+            "the Inline command menu lists only Inline's own commands",
+            exc,
+        )
+        return [], 0
+
 
+def _inline_menu_commands(max_commands: int = _INLINE_COMMAND_LIMIT) -> tuple[List[Dict[str, Any]], int]:
     command_specs = _inline_command_specs()
     local_commands = [
         (spec.name, spec.description)
         for spec in command_specs[:max(0, max_commands)]
     ]
     remaining = max(0, max_commands - len(local_commands))
-    menu_commands, hidden_count = telegram_menu_commands(max_commands=remaining)
+    menu_commands, hidden_count = _hermes_menu_commands(remaining)
     commands: List[Dict[str, Any]] = []
     seen: set[str] = set()
     skipped = 0
@@ -610,11 +678,18 @@ def _inline_menu_commands(max_commands: int = _INLINE_COMMAND_LIMIT) -> tuple[Li
 
 def _inline_skill_catalog() -> List[Dict[str, Any]]:
     """Return installed, enabled Hermes skills in the Bot API catalog shape."""
-    from tools.skills_tool import _find_all_skills, _sort_skills
-
+    try:
+        # Public since Hermes 0.22.5 (plugins/index.md § Read the skill catalog).
+        from tools.skills_tool import find_all_skills as find_all, sort_skills as sort
+    except ImportError:
+        # Legacy hosts (< 0.22.5) only had the private names. Drop with that host floor.
+        import tools.skills_tool as legacy_skills_tool
+
+        find_all = getattr(legacy_skills_tool, "_find_all_skills")
+        sort = getattr(legacy_skills_tool, "_sort_skills")
     published: List[Dict[str, Any]] = []
     seen: set[str] = set()
-    for skill in _sort_skills(_find_all_skills(skip_disabled=False)):
+    for skill in sort(find_all(skip_disabled=False)):
         if len(published) >= 250:
             break
         key = str(skill.get("name") or "").strip()
@@ -915,6 +990,14 @@ class InlineAdapter(BasePlatformAdapter):
             else inline_env("INLINE_OBSERVE_UNMENTIONED_MESSAGES"),
             True,
         )
+        self._drop_pending_on_cold_boot = _truthy(
+            extra.get("drop_pending_on_cold_boot")
+            if "drop_pending_on_cold_boot" in extra
+            else inline_env("INLINE_DROP_PENDING_ON_COLD_BOOT"),
+            True,
+        )
+        self._cold_boot_dropped = 0
+        self._cold_boot_drop_logged_at = 0.0
         self._reply_thread_mode = _reply_thread_mode(
             extra.get("reply_threads") if "reply_threads" in extra else inline_env("INLINE_REPLY_THREADS"),
             "auto",
@@ -1015,7 +1098,7 @@ class InlineAdapter(BasePlatformAdapter):
         self._reply_thread_cache: "OrderedDict[str, str]" = OrderedDict()
         self._reply_thread_parent_reply_ids: "OrderedDict[str, set[str]]" = OrderedDict()
         # Whether each request came from a bot, so answers to bots reply to them and reach them.
-        self._request_sender_is_bot: "OrderedDict[str, bool]" = OrderedDict()
+        self._request_quotes_sender: "OrderedDict[str, bool]" = OrderedDict()
         # Commands this bot advertises in Inline's command menu, as last synced.
         self._advertised_commands: set[str] = set()
         self._reply_thread_parent_typing_targets: "OrderedDict[str, str]" = OrderedDict()
@@ -1142,12 +1225,14 @@ class InlineAdapter(BasePlatformAdapter):
         """Hermes' own slash-command access for this platform; None on hosts without it."""
         try:
             from gateway.slash_access import policy_from_extra
-        except Exception:
-            return None
-        try:
+
             return policy_from_extra(dict(self.config.extra or {}), "dm" if chat_type == "dm" else "group")
-        except Exception:
-            logger.debug("[inline] slash access policy unavailable", exc_info=True)
+        except Exception as exc:
+            _hermes_seam_unavailable(
+                "gateway.slash_access.policy_from_extra",
+                "only a DM's owner can change reply threads; group settings are locked",
+                exc,
+            )
             return None
 
     def _may_change_reply_threads(self, actor_id: str, chat_type: str) -> bool:
@@ -1155,7 +1240,9 @@ class InlineAdapter(BasePlatformAdapter):
         who may run /threads. Without admin lists Hermes allows everyone, and so does this."""
         policy = self._slash_access_policy(chat_type)
         if policy is None:
-            return True
+            # Every supported host has the policy, so its absence means the seam broke:
+            # keep a DM's owner in control, but never open a group's setting to everyone.
+            return chat_type == "dm"
         return policy.can_run(actor_id, "threads")
 
     def note_turn_thread(self, chat_id: str, message_id: str, thread_id: str) -> None:
@@ -1179,7 +1266,8 @@ class InlineAdapter(BasePlatformAdapter):
         self, *, chat_id: str, chat_type: str, parent_chat_id: str, actor_id: str, actor_is_bot: bool, mode: str,
     ) -> Dict[str, Any]:
         """Change reply threads because the person talking to the agent asked, with the access
-        /threads needs. Inside a reply thread it changes the parent chat, as /threads does."""
+        /threads needs. Inside a reply thread it changes the parent chat, as /threads does,
+        and chat_type is the parent's."""
         if actor_is_bot or not actor_id:
             raise PermissionError("only a person can change reply threads")
         target_chat_id = parent_chat_id or chat_id
@@ -1190,6 +1278,9 @@ class InlineAdapter(BasePlatformAdapter):
         self._set_reply_threads_for_chat(target_chat_id, None if mode in {"default", "reset"} else _reply_thread_mode(mode))
         return {"chat_id": self._chat_key(target_chat_id), "mode": self._reply_thread_mode_for_chat(target_chat_id)}
 
+    def chat_type_from_info(self, info: Dict[str, Any]) -> str:
+        return self._bot_settings_chat_type(info)
+
     @staticmethod
     def _bot_settings_chat_type(info: Dict[str, Any]) -> str:
         peer = info.get("peer")
@@ -1202,14 +1293,9 @@ class InlineAdapter(BasePlatformAdapter):
         return "group"
 
     def _bot_settings_runner(self) -> Any:
-        runner = getattr(self, "gateway_runner", None)
-        if runner is not None:
-            return runner
-        try:
-            from gateway.run import _gateway_runner_ref
-            return _gateway_runner_ref()
-        except Exception:
-            return None
+        # BasePlatformAdapter.gateway_runner is the runner's documented back-reference;
+        # every supported host sets it before the adapter connects.
+        return getattr(self, "gateway_runner", None)
 
     async def _bot_settings_context(
         self,
@@ -1285,10 +1371,11 @@ class InlineAdapter(BasePlatformAdapter):
             return context
 
         try:
-            from gateway.run import _load_gateway_config
+            from hermes_cli.config import load_config_readonly
             from hermes_cli.model_switch_providers import list_picker_providers
 
-            cfg = _load_gateway_config() or {}
+            # Read-only: the returned dict is Hermes' shared config cache.
+            cfg = load_config_readonly() or {}
             model_cfg = cfg.get("model") if isinstance(cfg, dict) else {}
             if not isinstance(model_cfg, dict):
                 model_cfg = {"default": str(model_cfg or "")}
@@ -1390,8 +1477,16 @@ class InlineAdapter(BasePlatformAdapter):
                     {"value": value, "label": value.capitalize()} for value in dict.fromkeys(reasoning_values)
                 ],
             })
+        except asyncio.TimeoutError:
+            logger.warning("[inline] agent settings model catalog timed out")
         except Exception as exc:
-            logger.debug("[inline] Hermes runtime settings unavailable: %s", exc)
+            # Model and reasoning rows lean on GatewayRunner internals and the model picker
+            # catalog; without them the settings sheet still offers reply-thread controls.
+            _hermes_seam_unavailable(
+                "GatewayRunner session model/reasoning settings",
+                "Inline agent settings hide the model and reasoning rows",
+                exc,
+            )
         return context
 
     @staticmethod
@@ -1607,7 +1702,11 @@ class InlineAdapter(BasePlatformAdapter):
                 f"/model {shlex.quote(model)} --provider {shlex.quote(provider)} "
                 f"{'--global' if item_id == 'model-default' else '--session'}"
             )
-            result = await runner._handle_model_command(MessageEvent(
+            handle_model_command = getattr(runner, "_handle_model_command", None)
+            if not callable(handle_model_command):
+                _hermes_seam_unavailable("GatewayRunner._handle_model_command", "Inline settings cannot switch models")
+                raise ValueError("model switching unavailable")
+            result = await handle_model_command(MessageEvent(
                 text=command,
                 message_type=MessageType.TEXT,
                 source=source,
@@ -1620,7 +1719,13 @@ class InlineAdapter(BasePlatformAdapter):
             selected = str(value_body.get("stringValue") or "")
             if selected not in {option.get("value") for option in context.get("reasoning_options") or []}:
                 raise ValueError("reasoning unavailable")
-            runner._apply_reasoning_selection(context["session_key"], "inline", selected)
+            apply_reasoning_selection = getattr(runner, "_apply_reasoning_selection", None)
+            if not callable(apply_reasoning_selection):
+                _hermes_seam_unavailable(
+                    "GatewayRunner._apply_reasoning_selection", "Inline settings cannot change reasoning effort",
+                )
+                raise ValueError("reasoning unavailable")
+            apply_reasoning_selection(context["session_key"], "inline", selected)
             return
         raise ValueError("setting unavailable")
 
@@ -1953,6 +2058,12 @@ class InlineAdapter(BasePlatformAdapter):
         self._inbound_task = asyncio.get_event_loop().create_task(self._inbound_loop())
         self._mark_connected()
         logger.info("[inline] connected via sidecar on %s:%d", self._sidecar_bind, self._sidecar_port)
+        if not is_reconnect:
+            logger.info(
+                "[inline] Cold boot: %s Inline updates recorded before this gateway started "
+                "(drop_pending_on_cold_boot: %s)",
+                "dropping" if self._drop_pending_on_cold_boot else "preserving",
+                "true" if self._drop_pending_on_cold_boot else "false")
         self._schedule_bot_command_sync()
         return True
 
@@ -2393,6 +2504,8 @@ class InlineAdapter(BasePlatformAdapter):
         # owns a coherent client-state cache.
         self._invalidate_chat_info(event.get("chatId"))
         kind = event.get("kind")
+        if kind in _COLD_BOOT_GATED_KINDS and self._recorded_before_cold_boot(event):
+            return
         if kind == "bot.chatSettings.request":
             if event.get("_inlineDeliveryId"):
                 await self._handle_bot_settings_request(event)
@@ -2437,6 +2550,29 @@ class InlineAdapter(BasePlatformAdapter):
             return
         await self._dispatch_message(event)
 
+    def _recorded_before_cold_boot(self, event: Dict[str, Any]) -> bool:
+        """Whether this update predates the gateway process and must not wake the agent.
+
+        The update date is when the server recorded the change, so a live edit or reaction
+        on an old message still passes. Updates without a date pass rather than risk
+        dropping live work."""
+        if not self._drop_pending_on_cold_boot:
+            return False
+        date = _to_int(event.get("date"))
+        if date is None and event.get("kind") == "message.new":
+            date = _to_int((event.get("message") or {}).get("date"))
+        if date is None or date <= 0 or date >= _PROCESS_STARTED_AT - _COLD_BOOT_CLOCK_SKEW_SECONDS:
+            return False
+        self._cold_boot_dropped += 1
+        now = time.time()
+        if now - self._cold_boot_drop_logged_at >= _COLD_BOOT_DROP_LOG_INTERVAL_SECONDS:
+            self._cold_boot_drop_logged_at = now
+            logger.info(
+                "[inline] dropped %d update(s) recorded before this gateway started; latest %s in chat %s, %ds before startup",
+                self._cold_boot_dropped, event.get("kind"), event.get("chatId") or "?",
+                int(_PROCESS_STARTED_AT - date))
+        return True
+
     def _is_duplicate(self, key: str) -> bool:
         now = time.time()
         old = self._seen_messages.get(key)
@@ -2684,13 +2820,17 @@ class InlineAdapter(BasePlatformAdapter):
             if not mentioned and not reply_wakes_thread and (addressed_to_others or not ambient):
                 self._remember_observed_context(chat_id, msg, text)
                 return
-        self._remember_request_sender(chat_id, msg_id, sender_profile.get("bot") is True)
+        sender_is_bot = sender_profile.get("bot") is True
+        self._remember_request_sender(chat_id, msg_id, sender_is_bot and (explicitly_mentions_me or command_addressed_to_me))
         if edit:
             text = f"message:edited:{text}" if text else "message:edited"
         if (
             not edit
             and not agent_action
             and not thread_id
+            # A bot's message is answered in place even in a chat set to On: it wakes on
+            # replies in the chat it asked from, and a thread would never reach it.
+            and sender_profile.get("bot") is not True
             and self._should_create_reply_thread_for_message(chat_id=chat_id, parent_chat_id=parent_chat_id)
         ):
             created_thread_id = await self._create_reply_thread(chat_id, msg_id, text, reply_to_id)
@@ -2770,26 +2910,6 @@ class InlineAdapter(BasePlatformAdapter):
             reply_context_messages=context_backfill["reply_context_messages"],
             recent_messages=context_backfill["recent_messages"],
         )
-        metadata = self._inline_event_metadata(
-            chat_id=chat_id,
-            msg_id=msg_id,
-            from_id=from_id,
-            thread_id=thread_id,
-            parent_chat_id=parent_chat_id,
-            parent_message_id=parent_message_id,
-            entity_text=entity_text,
-        )
-        if agent_action:
-            metadata["inline"]["action"] = {
-                "event_kind": "message.action.invoke",
-                "actor_user_id": str(agent_action.get("actorUserId") or ""),
-                "chat_id": str(agent_action.get("chatId") or ""),
-                "target_message_id": str(agent_action.get("messageId") or ""),
-                "interaction_id": str(agent_action.get("interactionId") or ""),
-                "action_id": str(agent_action.get("actionId") or ""),
-                "callback_data_base64": str(agent_action.get("dataBase64") or ""),
-            }
-
         session_chat_id = _session_chat_id(chat_id, chat_type, thread_id, parent_chat_id)
         try:
             from . import tools as _inline_tools
@@ -2812,7 +2932,11 @@ class InlineAdapter(BasePlatformAdapter):
             parent_chat_id=parent_chat_id,
             message_id=msg_id,
         )
+        # A bot's answer coming back needs no reply: the agent may stay silent instead of Hermes
+        # posting its "needed a reply" warning. Hosts before reply_expected ignore this.
+        answer_from_bot = sender_is_bot and not explicitly_mentions_me and not command_addressed_to_me
         await self.handle_message(MessageEvent(
+            **({"reply_expected": False} if answer_from_bot and "reply_expected" in getattr(MessageEvent, "__dataclass_fields__", {}) else {}),
             text=text,
             message_type=message_type,
             source=source,
@@ -2835,7 +2959,6 @@ class InlineAdapter(BasePlatformAdapter):
             auto_skill=auto_skill,
             channel_prompt=channel_prompt,
             channel_context=channel_context,
-            metadata=metadata,
             timestamp=self._timestamp(event.get("date") or msg.get("date")),
             allow_gateway_control=not bool(agent_action),
         ))
@@ -3819,33 +3942,6 @@ class InlineAdapter(BasePlatformAdapter):
                 prefix += " from an unknown sender"
         return f"{prefix}: {text}"
 
-    def _inline_event_metadata(
-        self,
-        *,
-        chat_id: str,
-        msg_id: str,
-        from_id: str,
-        thread_id: Optional[str],
-        parent_chat_id: Optional[str],
-        parent_message_id: Optional[str],
-        entity_text: Optional[str],
-    ) -> Dict[str, Any]:
-        inline: Dict[str, Any] = {
-            "chat_id": self._chat_key(chat_id),
-            "message_id": str(msg_id),
-        }
-        if from_id:
-            inline["sender_user_id"] = self._chat_key(from_id)
-        if thread_id:
-            inline["thread_id"] = self._chat_key(thread_id)
-        if parent_chat_id:
-            inline["parent_chat_id"] = self._chat_key(parent_chat_id)
-        if parent_message_id:
-            inline["parent_message_id"] = str(parent_message_id)
-        if entity_text:
-            inline["message_entities"] = entity_text
-        return {"inline": inline}
-
     @staticmethod
     def _reply_thread_title(text: str) -> str:
         title = strip_markdown(str(text or "")).strip()
@@ -3939,8 +4035,10 @@ class InlineAdapter(BasePlatformAdapter):
     async def _reply_to_for_target(
         self, reply_to: Optional[str], target: Dict[str, str], *, request_chat_id: str = "", anchored: bool = False,
     ) -> Optional[str]:
-        """Answers quote the message only when it came from a bot: a bot wakes on replies to its
-        own messages, so that is how an answer reaches it. People get plain answers."""
+        """Answers quote the message only when a bot asked by addressing this one: a bot wakes on
+        replies to its own messages, so that is how the answer reaches it. A bot's reply to this
+        bot is that answer coming back and gets a plain response, otherwise two bots would quote
+        each other forever; another round takes a new mention. People get plain answers."""
         if not reply_to:
             return None
         target_chat_id = target.get("chatId") or ""
@@ -3951,8 +4049,8 @@ class InlineAdapter(BasePlatformAdapter):
         if anchored:
             return str(reply_to)
         key = f"{self._chat_key(target_chat_id)}:{reply_to}"
-        sender_is_bot = self._request_sender_is_bot.get(key)
-        if sender_is_bot is None and target_chat_id and self._chat_key(request_chat_id) == self._chat_key(target_chat_id):
+        quotes_sender = self._request_quotes_sender.get(key)
+        if quotes_sender is None and target_chat_id and self._chat_key(request_chat_id) == self._chat_key(target_chat_id):
             info = await self._get_chat_info(target_chat_id)
             if not info:
                 return None
@@ -3964,16 +4062,16 @@ class InlineAdapter(BasePlatformAdapter):
             # Message ids are per chat, so only look it up where the request was sent; an answer
             # moved into a thread would otherwise read the thread's message with the same id.
             fetched = await self._fetch_message(target_chat_id, str(reply_to))
-            sender_is_bot = _inline_sender_profile({}, fetched).get("bot") is True if fetched else False
-            self._remember_request_sender(target_chat_id, str(reply_to), sender_is_bot)
-        return str(reply_to) if sender_is_bot else None
+            quotes_sender = bool(fetched) and _inline_sender_profile({}, fetched).get("bot") is True and self._message_entity_mentions_me(fetched)
+            self._remember_request_sender(target_chat_id, str(reply_to), quotes_sender)
+        return str(reply_to) if quotes_sender else None
 
-    def _remember_request_sender(self, chat_id: str, msg_id: str, sender_is_bot: bool) -> None:
+    def _remember_request_sender(self, chat_id: str, msg_id: str, quotes_sender: bool) -> None:
         key = f"{self._chat_key(chat_id)}:{msg_id}"
-        self._request_sender_is_bot[key] = sender_is_bot
-        self._request_sender_is_bot.move_to_end(key)
-        while len(self._request_sender_is_bot) > _CHAT_INFO_CACHE_MAX_SIZE:
-            self._request_sender_is_bot.popitem(last=False)
+        self._request_quotes_sender[key] = quotes_sender
+        self._request_quotes_sender.move_to_end(key)
+        while len(self._request_quotes_sender) > _CHAT_INFO_CACHE_MAX_SIZE:
+            self._request_quotes_sender.popitem(last=False)
 
     async def _get_chat_info(self, chat_id: str, *, required: bool = False) -> Dict[str, Any]:
         target = _target_from_chat_id(chat_id)
@@ -4374,6 +4472,11 @@ class InlineAdapter(BasePlatformAdapter):
             return True
         try:
             from tools import slash_confirm as slash_confirm_mod
+        except Exception as exc:
+            _hermes_seam_unavailable("tools.slash_confirm.resolve", "Inline slash-confirm buttons cannot answer", exc)
+            await self._finish_action(event, "Unavailable", "This Hermes version cannot record that choice.")
+            return True
+        try:
             result = await slash_confirm_mod.resolve(session_key, confirm_id, choice)
             self._slash_sessions.pop(confirm_id, None)
             text = str(result or ("Cancelled." if choice == "cancel" else "Recorded."))
@@ -4633,7 +4736,10 @@ class InlineAdapter(BasePlatformAdapter):
             from hermes_cli.models_catalog_static import PROVIDER_GROUPS
             label, _desc, members = PROVIDER_GROUPS.get(group_id, (group_id, "", []))
             member_slugs = [str(member) for member in members]
-        except Exception:
+        except Exception as exc:
+            _hermes_seam_unavailable(
+                "hermes_cli.models_catalog_static.PROVIDER_GROUPS", "the model picker cannot open provider groups", exc,
+            )
             member_slugs = []
         by_slug = {
             str(provider.get("slug") or "").strip().lower(): provider
@@ -4732,8 +4838,17 @@ class InlineAdapter(BasePlatformAdapter):
     async def _expensive_model_warning(self, model_id: str, provider_slug: str) -> Optional[Any]:
         try:
             from hermes_cli.model_cost_guard import expensive_model_warning
+        except Exception as exc:
+            _hermes_seam_unavailable(
+                "hermes_cli.model_cost_guard.expensive_model_warning",
+                "the model picker switches without the expensive-model confirmation",
+                exc,
+            )
+            return None
+        try:
             return await asyncio.to_thread(expensive_model_warning, model_id, provider=provider_slug)
         except Exception:
+            logger.warning("[inline] expensive model check failed", exc_info=True)
             return None
 
     async def _edit_action_message(self, event: Dict[str, Any], text: str, actions: Optional[Dict[str, Any]] = None) -> SendResult:
@@ -5378,7 +5493,8 @@ class InlineAdapter(BasePlatformAdapter):
         try:
             from hermes_cli.providers import get_label
             return str(get_label(slug))
-        except Exception:
+        except Exception as exc:
+            _hermes_seam_unavailable("hermes_cli.providers.get_label", "the model picker shows provider slugs", exc)
             return str(slug or "")
 
     def _build_provider_actions(self, picker_id: str, providers: list, *, include_back: bool = False) -> Dict[str, Any]:
@@ -5391,7 +5507,10 @@ class InlineAdapter(BasePlatformAdapter):
         try:
             from hermes_cli.models_catalog_static import group_providers
             grouped = group_providers(list(by_slug.keys()))
-        except Exception:
+        except Exception as exc:
+            _hermes_seam_unavailable(
+                "hermes_cli.models_catalog_static.group_providers", "the model picker lists providers ungrouped", exc,
+            )
             grouped = [{"kind": "single", "slug": slug} for slug in by_slug.keys()]
         for row in grouped:
             if row.get("kind") == "group":
@@ -5557,6 +5676,12 @@ class InlineAdapter(BasePlatformAdapter):
         if len(mapping) > limit:
             mapping.popitem(last=False)
 
+    def _send_retry_is_final(self, result: SendResult) -> bool:
+        # The request reached Inline but its result was lost. A retry or plain-text
+        # fallback would post the message twice; Hermes treats timeouts the same way.
+        raw = getattr(result, "raw_response", None)
+        return isinstance(raw, dict) and raw.get("outcomeUnknown") is True
+
     async def _send_sidecar(self, path: str, body: Dict[str, Any]) -> SendResult:
         try:
             data = await self._sidecar_call(path, body)
@@ -5572,12 +5697,15 @@ class InlineAdapter(BasePlatformAdapter):
         except InlineSidecarError as exc:
             if exc.error_kind == "unknown":
                 self._report_error("sidecar.send", exc)
+            raw = exc.raw if isinstance(exc.raw, dict) else {}
+            retry_after = _to_int(raw.get("retryAfterSeconds"))
             return _send_result(
                 success=False,
                 error=str(exc),
                 raw_response=exc.raw,
                 retryable=exc.retryable,
                 error_kind=exc.error_kind,
+                retry_after=float(retry_after) if retry_after and retry_after > 0 else None,
             )
         except Exception as exc:
             self._report_error("sidecar.send", exc)
@@ -5605,8 +5733,9 @@ class InlineAdapter(BasePlatformAdapter):
 
 def _send_result(**kwargs: Any) -> SendResult:
     fields = getattr(SendResult, "__dataclass_fields__", {})
-    if "error_kind" in kwargs and "error_kind" not in fields:
-        kwargs.pop("error_kind")
+    for optional in ("error_kind", "retry_after"):
+        if optional in kwargs and optional not in fields:
+            kwargs.pop(optional)
     return SendResult(**kwargs)
 
 
@@ -5756,7 +5885,9 @@ def _inline_catalog_part_summary(part: Dict[str, Any]) -> str:
 def _inline_version_text(last_sync: Optional[Dict[str, Any]] = None) -> str:
     version = _installed_inline_plugin_version()
     try:
-        from hermes_cli import __version__ as hermes_version
+        from importlib.metadata import version as _distribution_version
+
+        hermes_version = _distribution_version("hermes-agent")
     except Exception:
         hermes_version = None
 
@@ -5826,7 +5957,9 @@ def register(ctx) -> None:
     from . import cli as _cli
     from . import tools as _tools
 
-    _install_inline_display_defaults()
+    display_fields = _display_registration_fields()
+    if not display_fields:
+        _install_inline_display_defaults()
     ctx.register_platform(
         name="inline",
         label="Inline",
@@ -5849,6 +5982,7 @@ def register(ctx) -> None:
         allow_update_command=True,
         platform_hint=_tools.INLINE_PLATFORM_GUIDANCE,
         **_target_registration_hooks(),
+        **display_fields,
     )
     register_command = getattr(ctx, "register_command", None)
     if callable(register_command):