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

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.
@@ -610,11 +620,14 @@ 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
+    import tools.skills_tool as skills_tool
 
+    # Hermes 0.22.5 made these public; older supported hosts keep the private names.
+    find_all = getattr(skills_tool, "find_all_skills", None) or getattr(skills_tool, "_find_all_skills")
+    sort = getattr(skills_tool, "sort_skills", None) or getattr(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 +928,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 +1036,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()
@@ -1176,18 +1197,23 @@ class InlineAdapter(BasePlatformAdapter):
         return {**(metadata or {}), "thread_id": thread_id} if thread_id else metadata
 
     def set_reply_threads_from_tool(
-        self, *, chat_id: str, chat_type: str, in_reply_thread: bool, actor_id: str, actor_is_bot: bool, mode: str,
+        self, *, chat_id: str, chat_type: str, parent_chat_id: str, actor_id: str, actor_is_bot: bool, mode: str,
     ) -> Dict[str, Any]:
-        """Change this chat's reply threads because the person talking to the agent asked,
-        with the access /threads needs."""
+        """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,
+        and chat_type is the parent's."""
         if actor_is_bot or not actor_id:
             raise PermissionError("only a person can change reply threads")
-        if in_reply_thread:
-            raise PermissionError("change reply threads from the parent chat, not inside a thread")
+        target_chat_id = parent_chat_id or chat_id
+        if parent_chat_id and self._actor_authorization(chat_type, actor_id, parent_chat_id) is not True:
+            raise PermissionError("parent chat access could not be confirmed")
         if not self._may_change_reply_threads(actor_id, chat_type):
             raise PermissionError("changing reply threads needs access to the threads command")
-        self._set_reply_threads_for_chat(chat_id, None if mode in {"default", "reset"} else _reply_thread_mode(mode))
-        return {"chat_id": self._chat_key(chat_id), "mode": self._reply_thread_mode_for_chat(chat_id)}
+        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:
@@ -1952,6 +1978,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
 
@@ -2392,6 +2424,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)
@@ -2436,6 +2470,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)
@@ -2683,13 +2740,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)
@@ -2769,33 +2830,14 @@ 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
             _inline_tools.remember_turn_message(
                 session_chat_id=session_chat_id, thread_id=str(thread_id or ""), message_id=msg_id,
                 chat_id=chat_id, sender_id=from_id, sender_is_bot=sender_profile.get("bot") is True,
-                chat_type=chat_type, in_reply_thread=bool(parent_chat_id) and parent_chat_id != chat_id,
+                chat_type=chat_type,
+                parent_chat_id=parent_chat_id if parent_chat_id and parent_chat_id != chat_id else "",
             )
         except Exception:
             logger.debug("[inline] failed to record the turn's message for tools", exc_info=True)
@@ -2810,7 +2852,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,
@@ -2833,7 +2879,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),
         ))
@@ -3817,33 +3862,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()
@@ -3937,8 +3955,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 ""
@@ -3949,8 +3969,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
@@ -3962,16 +3982,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)
@@ -5555,6 +5575,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)
@@ -5570,12 +5596,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)
@@ -5603,8 +5632,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)
 
 

package/plugin/inline/cli.py

@@ -27,7 +27,10 @@ _CLI_INSTALL_URL = "https://inline.chat/cli/install.sh"
 _MAX_TOKEN_BYTES = 16 * 1024
 _MAX_PROBE_RESPONSE_BYTES = 64 * 1024
 _MACHINE_SETUP_PROTOCOL_VERSION = 1
-_PROBE_USER_AGENT = "inline-hermes-agent-adapter/1.0.0-alpha.2"
+# Hermes' own tolerance: macOS readings of one process's start time drift about a second
+# after boot-clock adjustments, and 200 is 2 s on every platform's scale.
+_START_TIME_DRIFT_TOLERANCE = 200
+_PROBE_USER_AGENT = "inline-hermes-agent-adapter/1.0.0"
 _ENV_REFERENCE_RE = re.compile(r"^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$")
 
 
@@ -581,7 +584,11 @@ def _gateway_status() -> dict:
             return {"supported": False, "ready": False, "reason": "runtime_writer_identity_unavailable"}
         # Runtime status can retain platform entries from the prior process.
         # Only the current process's own connected projection is readiness proof.
-        writer_matches = isinstance(inline, dict) and inline.get("writer_pid") == pid and inline.get("writer_start_time") == start_time
+        writer_start_time = inline.get("writer_start_time") if isinstance(inline, dict) else None
+        writer_matches = (
+            isinstance(inline, dict) and inline.get("writer_pid") == pid and type(writer_start_time) is int
+            and abs(writer_start_time - start_time) <= _START_TIME_DRIFT_TOLERANCE
+        )
         ready = generation is not None and writer_matches and state == "running" and platform_state == "connected"
         return {
             "supported": True,

package/plugin/inline/plugin.yaml

@@ -3,7 +3,7 @@ label: Inline
 kind: platform
 provides_tools:
   - inline
-version: 1.0.0-alpha.2
+version: 1.0.0
 requires_hermes: ">=0.21.3"
 description: >
   Inline platform adapter for Hermes Agent. The adapter runs as a native